Initial commit for Hugging Face Space

.gitignore

@@ -0,0 +1,21 @@
+# 忽略Python的缓存文件
+__pycache__/
+*.pyc
+*.pyo
+
+# 忽略日志文件和目录
+logs/
+*.log
+
+# 忽略输出目录
+output/
+
+# 忽略数据目录（如果数据文件很大或不需要在线上运行）
+data/
+
+# 忽略本地开发环境文件
+.venv/
+venv/
+env/
+*.env
+.vscode/ 

Dockerfile

@@ -0,0 +1,29 @@
+# 使用官方Python 3.9 slim版本作为基础镜像
+FROM python:3.9-slim
+
+# 创建一个非root用户，并切换到该用户，增强安全性
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+# 设置容器内的工作目录
+WORKDIR /app
+
+# 将依赖文件复制到工作目录
+# 使用 --chown=user 确保文件所有者为我们创建的非root用户
+COPY --chown=user ./requirements.txt requirements.txt
+
+# 安装项目依赖
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# 将src目录下的所有代码复制到工作目录的src子目录中
+COPY --chown=user ./src /app/src
+
+# 暴露端口，让Hugging Face平台可以访问我们的应用
+EXPOSE 7860
+
+# 容器启动时运行的命令
+# 运行src目录下的app.py文件中的app实例
+# --host 0.0.0.0 使其可以从外部访问
+# --port 7860 使用Hugging Face指定的端口
+CMD ["uvicorn", "src.app:app", "--host", "0.0.0.0", "--port", "7860"] 

README.md

@@ -0,0 +1,202 @@
+# AI大模型辩论系统
+
+## 项目简介
+
+本项目是一个可以让两个AI大模型（ZhipuAI/GLM-4.5和deepseek-ai/DeepSeek-V3.1）根据给定话题进行实时辩论的系统。用户将能够实时观看两个模型之间的对话内容，并可以控制辩论的进行。
+
+## 功能特点
+
+- 支持两个AI大模型之间的实时辩论
+- 可自定义辩论话题和轮数
+- 实时显示辩论内容
+- 支持暂停、恢复和停止辩论
+- 保存完整的辩论记录
+- 提供多种显示模式（简单控制台、控制台实时显示、文件保存、复合显示）
+- 可查看历史辩论记录
+- 支持流式输出，实时显示模型生成内容
+- 提供图形用户界面(GUI)，便于使用和分享
+
+## 系统要求
+
+- Python 3.7+
+- requests库
+- tkinter库（用于GUI界面）
+
+## 安装说明
+
+1. 克隆或下载本项目
+2. 安装依赖包：
+   ```
+   pip install -r requirements.txt
+   ```
+
+## 使用方法
+
+### 命令行版本
+
+在项目根目录下运行主程序：
+
+```
+python src/1_辩论系统.py
+```
+
+### 命令行参数
+
+```
+python src/1_辩论系统.py [--api-key API_KEY] [--display-type DISPLAY_TYPE]
+```
+
+参数说明：
+- `--api-key`: API密钥（默认：ms-b4690538-3224-493a-8f5b-4073d527f788）
+- `--display-type`: 显示类型，可选值：simple, console, file, composite（默认：composite）
+
+### GUI版本
+
+在项目根目录下运行GUI测试程序：
+
+```
+python src/5_GUI测试.py
+```
+
+GUI界面功能：
+- 选择模型（GLM-4.5或DeepSeek-V3.1）
+- 输入提示文本
+- 实时流式显示模型输出
+- 开始/停止生成按钮
+- 清空输出和保存输出功能
+
+### 操作流程
+
+1. 启动系统后，会显示主菜单：
+   - 1. 开始新辩论
+   - 2. 查看历史辩论记录
+   - 3. 系统设置
+   - 4. 退出系统
+
+2. 选择"开始新辩论"后，按提示输入：
+   - 辩论话题
+   - 辩论轮数（默认5轮）
+   - 首发模型（默认GLM-4.5）
+
+3. 确认参数后，辩论将自动开始，您可以实时观看两个模型的辩论内容。
+
+4. 在辩论过程中，您可以输入以下命令控制辩论：
+   - `stop`: 停止辩论
+   - `pause`: 暂停辩论
+   - `resume`: 恢复辩论
+
+5. 辩论结束后，系统会自动保存辩论记录。
+
+## 项目结构
+
+```
+20250907_大模型辩论/
+├── src/                    # 源代码目录
+│   ├── 1_辩论系统.py       # 主程序文件
+│   ├── 2_模型接口.py       # 模型API接口封装
+│   ├── 3_辩论控制器.py     # 辩论流程控制
+│   ├── 4_显示界面.py       # 实时显示界面
+│   └── 5_GUI测试.py       # GUI测试程序
+├── data/                   # 数据目录
+│   └── 辩论话题.txt       # 存储辩论话题
+├── output/                 # 输出目录
+│   ├── 辩论记录/           # 每次辩论的完整记录
+│   └── 辩论统计/           # 辩论统计数据
+├── logs/                   # 日志目录
+│   └── 系统运行日志.log    # 系统运行日志
+├── docs/                   # 文档目录
+│   ├── 项目规划.md         # 项目规划文档
+│   ├── 修改记录.md         # 项目修改记录
+│   └── 更新计划.md         # 更新计划文档
+├── models/                 # 模型目录（预留）
+├── sql/                    # SQL脚本目录（预留）
+├── requirements.txt        # 依赖包列表
+└── README.md              # 本文档
+```
+
+## 模块说明
+
+### 1_辩论系统.py
+
+主程序模块，整合所有模块，提供用户交互界面。包含：
+- 系统主菜单
+- 辩论参数设置
+- 历史记录查看
+- 系统设置
+
+### 2_模型接口.py
+
+模型接口模块，封装两个大模型的API调用。包含：
+- ModelInterface基类
+- GLM45Interface类（GLM-4.5模型接口）
+- DeepSeekV31Interface类（DeepSeek-V3.1模型接口）
+- ModelManager类（模型管理器）
+
+### 3_辩论控制器.py
+
+辩论控制器模块，管理辩论流程和控制发言顺序。包含：
+- DebateMessage类（辩论消息）
+- DebateSession类（辩论会话）
+- DebateController类（辩论控制器）
+
+### 4_显示界面.py
+
+显示界面模块，用于实时显示辩论内容。包含：
+- ConsoleDisplay类（控制台显示界面）
+- SimpleDisplay类（简单显示界面）
+- FileDisplay类（文件显示界面）
+- CompositeDisplay类（复合显示界面）
+- DisplayManager类（显示管理器）
+
+### 5_GUI测试.py
+
+GUI测试模块，提供图形用户界面。包含：
+- StreamOutputGUI类（流式输出GUI界面）
+- 支持模型选择和流式输出显示
+- 提供完整的用户交互功能
+
+## API信息
+
+- API基础地址：https://api-inference.modelscope.cn/v1/
+- 支持的模型：
+  - ZhipuAI/GLM-4.5
+  - deepseek-ai/DeepSeek-V3.1
+
+## 注意事项
+
+1. 确保网络连接正常，能够访问API服务器。
+2. 辩论过程中请耐心等待，模型响��可能需要一定时间。
+3. 辩论记录会自动保存在`output/辩论记录/`目录下。
+4. 系统日志会记录在`logs/`目录下，便于排查问题。
+
+## 常见问题
+
+### Q: 如何更换API密钥？
+A: 可以通过命令行参数`--api-key`指定，或者在代码中修改默认值。
+
+### Q: 如何更改显示模式？
+A: 可以通过命令行参数`--display-type`指定，或者在系统设置中更改。
+
+### Q: 辩论过程中出现错误怎么办？
+A: 系统会自动记录错误信息到日志文件，可以查看`logs/`目录下的日志文件排查问题。
+
+### Q: 如何查看历史辩论记录？
+A: 在主菜单选择"查看历史辩论记录"，然后选择要查看的记录即可。
+
+## 开发计划
+
+1. 增加更多模型支持
+2. 优化辩论逻辑和提示词
+3. 添加辩论评分功能
+4. 开发图形用户界面
+5. 支持更多输出格式（如HTML、PDF等）
+
+## 许可证
+
+本项目仅供学习和研究使用。
+
+## 联系方式
+
+如有问题或建议，请通过以下方式联系：
+- 邮箱：[您的邮箱]
+- GitHub：[您的GitHub地址] 

docs/修改记录.md

@@ -0,0 +1,53 @@
+# 项目修改记录
+
+## 第1次修改
+- 创建项目目录结构
+- 实现模型接口模块 (2_模型接口.py)
+  - 封装ZhipuAI/GLM-4.5和moonshotai/Kimi-K2-Instruct-0905模型API
+  - 实现ModelManager类统一管理模型接口
+  - 添加错误处理和日志记录
+- 实现辩论控制器模块 (3_辩论控制器.py)
+  - 设计DebateMessage类管理辩论消息
+  - 实现DebateSession类管理辩论会话
+  - 创建DebateController类控制辩论流程
+  - 支持多线程异步处理辩论
+- 实现显示界面模块 (4_显示界面.py)
+  - 实现SimpleDisplay类简单显示
+  - 实现ConsoleDisplay类控制台实时显示
+  - 实现FileDisplay类文件保存显示
+  - 实现CompositeDisplay类复合显示
+  - 创建DisplayManager类统一管理显示界面
+- 实现主程序模块 (1_辩论系统.py)
+  - 整合所有模块
+  - 提供用户交互界面
+  - 实现辩论参数设置
+  - 实现历史记录查看
+  - 实现系统设置
+- 创建项目规划文档 (docs/项目规划.md)
+- 创建requirements.txt文件
+- 创建README.md文档
+- 创建修改记录文档 (docs/修改记录.md)
+
+## 第2次修改
+- 创建更新计划文档 (docs/更新计划.md)
+  - 制定流式输出和GUI界面的实现方案
+  - 规划实施步骤和时间安排
+  - 分析技术风险并制定应对措施
+
+## 第3次修改
+- 修改模型接口模块 (2_模型接口.py)
+  - 添加流式输出支持，实现send_stream_request方法
+  - 为GLM45Interface和DeepSeekV31Interface类添加chat_stream方法
+  - 添加回调函数机制支持逐字输出
+  - 更新测试代码以验证流式输出功能
+  - 修复模型名称引用错误（kimi_k2改为deepseek_v31）
+
+## 第4次修改
+- 修改requirements.txt文件
+  - 添加tkinter依赖（用于GUI界面开发）
+- 创建GUI测试程序 (src/5_GUI测试.py)
+  - 实现基于tkinter的图形用户界面
+  - 支持模型选择（GLM-4.5和DeepSeek-V3.1）
+  - 支持流式输出显示
+  - 提供开始/停止/清空/保存功能
+  - 添加状态栏和错误处理 

docs/更新计划.md

@@ -0,0 +1,104 @@
+# AI大模型辩论系统更新计划
+
+## 目标
+
+1. 实现大模型回复的流式输出，提升用户体验
+2. 开发图形用户界面(GUI)，使系统更易于使用和分享
+
+## 当前系统分析
+
+### 现有架构
+- **模型接口模块**：使用requests库发送HTTP请求，一次性获取完整响应
+- **辩论控制器模块**：管理辩论流程和模型交互
+- **显示界面模块**：提供多种显示方式（简单控制台、控制台实时显示、文件保存、复合显示）
+- **主程序模块**：整合所有模块，提供命令行界面
+
+### 存在的问题
+1. 当前模型接口使用非流式请求，需要等待模型完全生成回复后才能显示
+2. 只有命令行界面，不利于分享和用户体验
+
+## 实现方案
+
+### 1. 流式输出实现
+
+#### 1.1 修改模型接口模块 (2_模型接口.py)
+- 添加支持流式输出的chat_stream方法
+- 使用requests的stream=True参数
+- 实现SSE（Server-Sent Events）解析
+- 提供逐字输出的回调函数
+
+#### 1.2 修改辩论控制器模块 (3_辩论控制器.py)
+- 添加支持流式输出的辩论方法
+- 修改_debate_loop方法以支持流式输出
+- 更新DebateController类以处理流式回调
+
+#### 1.3 修改显示界面模块 (4_显示界面.py)
+- 更新显示界面以支持流式内容显示
+- 添加流式显示的视觉效果（如打字机效果）
+
+### 2. GUI界面实现
+
+#### 2.1 技术选型
+- 使用Python的tkinter库创建桌面GUI应用
+- 或使用Flask/FastAPI创建Web应用
+
+#### 2.2 功能设计
+- 主界面：包含辩论话题输入、模型选择、轮数设置等
+- 实时显示区域：显示辩论内容，支持流式输出效果
+- 控制按钮：开始、暂停、停止、保存等
+- 历史记录查看界面
+- 设置界面：API密钥、显示设置等
+
+#### 2.3 实现步骤
+1. 创建GUI主窗口和布局
+2. 实现辩论参数设置界面
+3. 实现辩论内容显示区域
+4. 实现控制按钮功能
+5. 实现历史记录查看功能
+6. 实现设置功能
+
+## 实施计划
+
+### 第一阶段：流式输出实现（预计2天）
+1. 修改模型接口模块，添加流式输出支持
+2. 修改辩论控制器模块，支持流式输出
+3. 更新显示界面模块，支持流式显示
+4. 测试流式输出功能
+
+### 第二阶段：GUI界面开发（预计3天）
+1. 设计GUI界面布局和功能
+2. 实现主界面和参数设置
+3. 实现辩论内容显示区域
+4. 实现控制功能
+5. 实现历史记录和设置功能
+6. 测试GUI界面
+
+### 第三阶段：集成测试和优化（预计1天）
+1. 集成流式输出和GUI界面
+2. 进行完整功能测试
+3. 优化用户体验
+4. 编写使用文档
+
+## 预期效果
+
+1. **流式输出**：用户可以实时看到模型生成的内容，提升交互体验
+2. **GUI界面**：提供直观易用的图形界面，便于分享和使用
+3. **兼容性**：保持原有命令行界面功能，同时提供GUI选项
+4. **稳定性**：确保系统稳定运行，错误处理完善
+
+## 风险评估和应对
+
+### 技术风险
+- **流式输出兼容性**：某些模型可能不支持流式输出
+  - 应对：提供降级方案，不支持流式时使用现有方式
+  
+- **GUI跨平台兼容性**：不同操作系统可能显示效果不同
+  - 应对：使用标准组件，进行多平台测试
+
+### 时间风险
+- **开发时间超期**：功能实现可能比预期复杂
+  - 应对：分阶段实现，优先核心功能
+
+## 结论
+
+通过实现流式输出和GUI界面，可以显著提升AI大模型辩论系统的用户体验和可用性。流式输出让用户能够实时看到模型生成的内容，增强交互感；GUI界面使系统更易于使用和分享。该更新计划分阶段实施，风险可控，预期效果良好。 

docs/项目规划.md

@@ -0,0 +1,141 @@
+# AI大模型辩论系统项目规划
+
+## 项目概述
+
+本项目旨在创建一个可以让两个AI大模型（ZhipuAI/GLM-4.5和moonshotai/Kimi-K2-Instruct-0905）根据给定话题进行实时辩论的系统。用户将能够实时观看两个模型之间的对话内容，并可以控制辩论的进行。
+
+## 系统架构
+
+### 1. 核心组件
+
+- **辩论控制器**：管理辩论流程，控制发言顺序，处理用户输入
+- **模型接口**：与两个大模型API进行交互的封装
+- **实时显示界面**：展示辩论内容的用户界面
+- **日志记录系统**：记录辩论过程和结果
+
+### 2. 数据流
+
+1. 用户输入辩论话题和初始参数
+2. 辩论控制器初始化辩论
+3. 模型A生成初始论点
+4. 模型B针对模型A的论点进行反驳
+5. 模型A针对模型B的反驳进行回应
+6. 循环进行，直到达到设定的轮数或用户手动停止
+7. 实时显示每轮辩论内容
+8. 记录完整辩论过程
+
+## 技术实现方案
+
+### 1. 目录结构
+
+```
+20250907_大模型辩论/
+├── src/                    # 源代码目录
+│   ├── 1_辩论系统.py       # 主程序文件
+│   ├── 2_模型接口.py       # 模型API接口封装
+│   ├── 3_辩论控制器.py     # 辩论流程控制
+│   └── 4_显示界面.py       # 实时显示界面
+├── data/                   # 数据目录
+│   └── 辩论话题.txt       # 存储辩论话题
+├── output/                 # 输出目录
+│   ├── 辩论记录/           # 每次辩论的完整记录
+│   └── 辩论统计/           # 辩论统计数据
+├── logs/                   # 日志目录
+│   └── 系统运行日志.log    # 系统运行日志
+├── docs/                   # 文档目录
+│   └── 项目规划.md         # 本文档
+├── models/                 # 模型目录（预留）
+├── sql/                    # SQL脚本目录（预留）
+├── requirements.txt        # 依赖包列表
+└── README.md              # 项目说明文档
+```
+
+### 2. 核心功能模块
+
+#### 2.1 模型接口模块 (2_模型接口.py)
+
+- 封装两个大模型的API调用
+- 处理API请求和响应
+- 错误处理和重试机制
+- 支持自定义模型参数
+
+#### 2.2 辩论控制器模块 (3_辩论控制器.py)
+
+- 管理辩论流程和状态
+- 控制发言顺序和轮次
+- 处理辩论规则和逻辑
+- 提供辩论开始、暂停、继续、结束等控制功能
+
+#### 2.3 显示界面模块 (4_显示界面.py)
+
+- 实时显示辩论内容
+- 区分不同模型的发言
+- 提供用户控制界面
+- 支持滚动查看历史内容
+
+#### 2.4 主程序模块 (1_辩论系统.py)
+
+- 整合所有模块
+- 处理用户输入
+- 协调各模块工作
+- 提供命令行界面
+
+### 3. 辩论流程设计
+
+1. **初始化阶段**
+   - 用户输入辩论话题
+   - 设置辩论轮数（默认为5轮）
+   - 设置每个模型的发言角色（正方/反方）
+   - 选择首发模型
+
+2. **辩论阶段**
+   - 首发模型根据话题生成初始论点
+   - 对方模型针对论点进行反驳
+   - 首发模型再针对反驳进行回应
+   - 交替进行，直到达到设定轮数
+
+3. **结束阶段**
+   - 显示辩论总结
+   - 保存辩论记录
+   - 生成辩论统计信息
+
+### 4. 技术细节
+
+#### 4.1 API调用
+
+- 使用requests库进行HTTP请求
+- API基础地址：https://api-inference.modelscope.cn/v1/
+- API Key：ms-b4690538-3224-493a-8f5b-4073d527f788
+- 模型标识：
+  - ZhipuAI/GLM-4.5
+  - moonshotai/Kimi-K2-Instruct-0905
+
+#### 4.2 实时显示
+
+- 使用多线程实现异步处理
+- 主线程处理用户交互
+- 子线程处理API调用和辩论逻辑
+- 使用队列传递辩论内容
+
+#### 4.3 日志记录
+
+- 记录系统运行状态
+- 记录API调用详情
+- 记录每轮辩论内容
+- 记录错误和异常信息
+
+## 实施计划
+
+1. **第一阶段**：创建项目结构，实现模型接口模块
+2. **第二阶段**：实现辩论控制器模块
+3. **第三阶段**：实现显示界面模块
+4. **第四阶段**：整合所有模块，完善主程序
+5. **第五阶段**：测试和优化
+
+## 预期效果
+
+- 用户可以输入任意话题，观看两个AI模型的辩论
+- 实时显示辩论内容，无需等待全部完成
+- 可以控制辩论的进行（暂停、继续、结束）
+- 完整记录辩论过程，便于后续分析
+- 系统稳定运行，错误处理完善 

requirements.txt

@@ -0,0 +1,4 @@
+fastapi
+uvicorn[standard]
+requests
+jinja2 

src/app.py

@@ -0,0 +1,473 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+AI大模型辩论系统Web版本
+基于FastAPI的Web应用，提供图形用户界面的辩论系统
+"""
+
+import os
+import sys
+import json
+import logging
+from datetime import datetime
+from typing import Optional
+import importlib.util
+import asyncio
+
+# 在代码开头强制设置终端编码为UTF-8
+os.system('chcp 6001 > nul')
+
+# 获取当前脚本文件所在目录的绝对路径
+current_script_dir = os.path.dirname(os.path.abspath(__file__))
+
+# 项目根目录 (即 '20250907_大模型辩论' 目录, 是 'src' 的上一级)
+project_root = os.path.dirname(current_script_dir)
+
+# 定义数据输入、输出和日志目录
+DATA_DIR = os.path.join(project_root, 'data')
+OUTPUT_DIR = os.path.join(project_root, 'output')
+LOGS_DIR = os.path.join(project_root, 'logs')
+
+# 确保目录存在
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+os.makedirs(LOGS_DIR, exist_ok=True)
+
+# 配置日志
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler(os.path.join(LOGS_DIR, '辩论系统Web日志.log'), encoding='utf-8'),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# 捕获警告并记录到日志
+logging.captureWarnings(True)
+
+# 导入FastAPI相关模块
+try:
+    from fastapi import FastAPI, Request, WebSocket, WebSocketDisconnect
+    from fastapi.responses import HTMLResponse
+    from fastapi.staticfiles import StaticFiles
+    from fastapi.templating import Jinja2Templates
+    import uvicorn
+    logger.info("FastAPI模块导入成功")
+except ImportError as e:
+    logger.error(f"导入FastAPI模块失败: {str(e)}")
+    print("请安装FastAPI: pip install fastapi uvicorn")
+    sys.exit(1)
+
+# 导入自定义模块
+try:
+    # 动态导入模型接口模块
+    model_interface_path = os.path.join(current_script_dir, "model_interface.py")
+    model_interface_spec = importlib.util.spec_from_file_location("model_interface", model_interface_path)
+    model_interface = importlib.util.module_from_spec(model_interface_spec)
+    model_interface_spec.loader.exec_module(model_interface)
+    
+    # 动态导入辩论控制器模块
+    debate_controller_path = os.path.join(current_script_dir, "debate_controller.py")
+    debate_controller_spec = importlib.util.spec_from_file_location("debate_controller", debate_controller_path)
+    debate_controller = importlib.util.module_from_spec(debate_controller_spec)
+    debate_controller_spec.loader.exec_module(debate_controller)
+    
+    # 从模块中获取需要的类
+    ModelManager = model_interface.ModelManager
+    DebateMessage = debate_controller.DebateMessage
+    DebateSession = debate_controller.DebateSession
+    
+except Exception as e:
+    logger.error(f"导入模块失败: {str(e)}")
+    sys.exit(1)
+
+# 创建FastAPI应用
+app = FastAPI(title="AI大模型辩论系统", description="基于FastAPI的AI大模型辩论系统Web版本")
+
+# 设置静态文件目录
+static_dir = os.path.join(project_root, "static")
+os.makedirs(static_dir, exist_ok=True)
+app.mount("/static", StaticFiles(directory=static_dir), name="static")
+
+# 设置模板目录
+templates_dir = os.path.join(project_root, "templates")
+os.makedirs(templates_dir, exist_ok=True)
+templates = Jinja2Templates(directory=templates_dir)
+
+# 全局变量
+api_key = "ms-b4690538-3224-493a-8f5b-4073d527f788"
+model_manager = ModelManager(api_key)
+active_debate_session = None
+active_websocket = None
+
+@app.get("/", response_class=HTMLResponse)
+async def read_root(request: Request):
+    """主页路由，返回Web界面"""
+    return templates.TemplateResponse("index.html", {
+        "request": request,
+        "title": "AI大模型辩论系统"
+    })
+
+@app.get("/api/status")
+async def get_status():
+    """获取系统状态"""
+    return {
+        "status": "running",
+        "timestamp": datetime.now().isoformat(),
+        "models": ["glm45", "deepseek_v31"]
+    }
+
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    """WebSocket端点，用于实时通信"""
+    global active_websocket
+    await websocket.accept()
+    active_websocket = websocket
+    
+    try:
+        while True:
+            data = await websocket.receive_text()
+            # 处理接收到的消息
+            await handle_websocket_message(websocket, data)
+    except WebSocketDisconnect:
+        logger.info("WebSocket连接已断开")
+        active_websocket = None
+    except Exception as e:
+        logger.error(f"WebSocket处理错误: {str(e)}")
+        active_websocket = None
+
+async def handle_websocket_message(websocket: WebSocket, message: str):
+    """处理WebSocket消息"""
+    try:
+        data = json.loads(message)
+        action = data.get("action")
+        
+        if action == "start_debate":
+            await start_debate(websocket, data)
+        elif action == "stop_debate":
+            await stop_debate(websocket)
+        elif action == "pause_debate":
+            await pause_debate(websocket)
+        elif action == "resume_debate":
+            await resume_debate(websocket)
+        else:
+            await websocket.send_text(json.dumps({
+                "type": "error",
+                "message": f"未知操作: {action}"
+            }))
+    except json.JSONDecodeError:
+        await websocket.send_text(json.dumps({
+            "type": "error",
+            "message": "无效的JSON格式"
+        }))
+    except Exception as e:
+        logger.error(f"处理WebSocket消息时出错: {str(e)}")
+        await websocket.send_text(json.dumps({
+            "type": "error",
+            "message": f"处理消息时出错: {str(e)}"
+        }))
+
+async def start_debate(websocket: WebSocket, data: dict):
+    """开始辩论"""
+    global active_debate_session
+    loop = asyncio.get_event_loop()
+    
+    try:
+        topic = data.get("topic", "人工智能是否会取代人类的工作")
+        rounds = int(data.get("rounds", 5))
+        first_model = data.get("first_model", "glm45")
+        initial_prompt = data.get("initial_prompt", "").strip() # 新增：获取自定义初始提示
+        
+        await websocket.send_text(json.dumps({ "type": "debate_started", "message": "辩论已开始", "topic": topic, "rounds": rounds, "first_model": first_model }))
+        
+        active_debate_session = DebateSession(topic, rounds, first_model)
+        
+        # 新增：如果存在自定义初始提示，则添加到会话历史中
+        if initial_prompt:
+            active_debate_session.add_message(DebateMessage("user", initial_prompt, "system"))
+
+        model_a_name = first_model
+        model_b_name = 'deepseek_v31' if model_a_name == 'glm45' else 'glm45'
+        model_a = model_manager.get_model(model_a_name)
+        model_b = model_manager.get_model(model_b_name)
+        
+        active_debate_session.start_time = datetime.now()
+        
+        speakers = [(model_a_name, model_a), (model_b_name, model_b)]
+        
+        # Main debate loop
+        for i in range(rounds * 2):
+            if not active_debate_session.is_active:
+                break
+
+            round_num = (i // 2) + 1
+            if i % 2 == 0:
+                active_debate_session.current_round = round_num
+                await websocket.send_text(json.dumps({ "type": "round_info", "message": f"--- 第{round_num}轮 ---" }))
+
+            speaker_name, speaker_model = speakers[i % 2]
+            role = "正方" if speaker_name == first_model else "反方"
+            
+            await websocket.send_text(json.dumps({ "type": "model_speaking", "model": speaker_name, "role": role }))
+
+            prompt = active_debate_session.generate_prompt(speaker_name, first_model)
+            
+            response_content = ""
+            def stream_callback(content):
+                nonlocal response_content
+                response_content += content
+                asyncio.run_coroutine_threadsafe(
+                    websocket.send_text(json.dumps({"type": "stream_content", "content": content})), loop
+                )
+
+            await loop.run_in_executor(None, speaker_model.chat_stream, active_debate_session.get_messages_for_model(speaker_name) + [{"role": "user", "content": prompt}], stream_callback)
+            await websocket.send_text(json.dumps({"type": "stream_end", "model": speaker_name}))
+
+            active_debate_session.add_message(DebateMessage("user", prompt, "system"))
+            active_debate_session.add_message(DebateMessage("assistant", response_content, speaker_name))
+            save_debate_record() # Incremental save
+
+        if active_debate_session.is_active:
+            active_debate_session.end_time = datetime.now()
+            active_debate_session.is_active = False
+            await websocket.send_text(json.dumps({ "type": "debate_ended", "message": "=== 辩论结束 ===" }))
+            save_debate_record()
+            logger.info("辩论结束")
+        
+    except Exception as e:
+        logger.error(f"辩论过程中出错: {str(e)}")
+        await websocket.send_text(json.dumps({ "type": "error", "message": f"辩论过程中出错: {str(e)}" }))
+
+async def stop_debate(websocket: WebSocket):
+    """停止辩论"""
+    global active_debate_session
+    if active_debate_session:
+        active_debate_session.is_active = False
+        active_debate_session.end_time = datetime.now()
+        await websocket.send_text(json.dumps({
+            "type": "debate_stopped",
+            "message": "辩论已停止"
+        }))
+        save_debate_record()
+        active_debate_session = None
+
+async def pause_debate(websocket: WebSocket):
+    """暂停辩论"""
+    await websocket.send_text(json.dumps({
+        "type": "debate_paused",
+        "message": "辩论已暂停"
+    }))
+
+async def resume_debate(websocket: WebSocket):
+    """继续辩论"""
+    await websocket.send_text(json.dumps({
+        "type": "debate_resumed",
+        "message": "辩论已继续"
+    }))
+
+def save_debate_record():
+    """保存辩论记录"""
+    global active_debate_session
+    if active_debate_session:
+        try:
+            output_dir = os.path.join(OUTPUT_DIR, "辩论记录")
+            os.makedirs(output_dir, exist_ok=True)
+            file_path = os.path.join(output_dir, f"{active_debate_session.debate_id}.json")
+            active_debate_session.save_to_file(file_path)
+            logger.info(f"辩论记录已保存: {file_path}")
+        except Exception as e:
+            logger.error(f"保存辩论记录时出错: {str(e)}")
+
+def create_templates():
+    """创建HTML模板文件"""
+    index_html = """
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AI大模型辩论系统</title>
+    <style>
+        body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif; margin: 0; background-color: #f0f2f5; color: #333; height: 100vh; display: flex; flex-direction: column; }
+        .container { background-color: white; padding: 20px; border-radius: 8px; box-shadow: 0 4px 12px rgba(0,0,0,0.1); width: 95%; max-width: 1400px; margin: 20px auto; flex-grow: 1; display: flex; flex-direction: column; }
+        .main-layout { display: flex; gap: 20px; flex-grow: 1; min-height: 0; }
+        .sidebar { flex: 0 0 320px; display: flex; flex-direction: column; gap: 15px; }
+        .chat-area { flex: 1; display: flex; flex-direction: column; min-width: 0; }
+        .header { text-align: center; margin-bottom: 20px; flex-shrink: 0; }
+        .header h1 { color: #1a73e8; }
+        .controls, .control-group { margin-bottom: 20px; }
+        .controls { display: flex; gap: 10px; flex-wrap: wrap; align-items: flex-end; }
+        .control-group { flex: 1; min-width: 200px; }
+        label { display: block; margin-bottom: 5px; font-weight: 600; color: #555; }
+        input, select, button, textarea { width: 100%; padding: 10px; border: 1px solid #ddd; border-radius: 6px; box-sizing: border-box; font-size: 16px; }
+        textarea { resize: vertical; }
+        button { background-color: #1a73e8; color: white; border: none; cursor: pointer; transition: background-color 0.3s; }
+        button:hover { background-color: #1558b8; }
+        button:disabled { background-color: #ccc; cursor: not-allowed; }
+        .output-container { background-color: #f8f9fa; border: 1px solid #ddd; border-radius: 8px; padding: 20px; height: 500px; overflow-y: auto; display: flex; flex-direction: column; gap: 15px; }
+        .status { padding: 10px; border-radius: 6px; margin-bottom: 15px; border: 1px solid; }
+        .status.connected { background-color: #e6f4ea; color: #155724; border-color: #c3e6cb; }
+        .status.disconnected { background-color: #f8d7da; color: #721c24; border-color: #f5c6cb; }
+        
+        /* 聊天气泡样式 */
+        .message { display: flex; align-items: flex-start; gap: 10px; max-width: 80%; }
+        .message .avatar { width: 40px; height: 40px; border-radius: 50%; color: white; display: flex; align-items: center; justify-content: center; font-weight: bold; flex-shrink: 0; font-size: 18px; }
+        .message .content { background-color: #ffffff; padding: 10px 15px; border-radius: 18px; box-shadow: 0 1px 2px rgba(0,0,0,0.1); }
+        .message .sender { font-weight: bold; margin-bottom: 5px; color: #333; }
+        .message.glm45 { align-self: flex-start; }
+        .message.glm45 .avatar { background-color: #34a853; } /* Google Green */
+        .message.glm45 .content { border-top-left-radius: 4px; }
+        .message.deepseek_v31 { align-self: flex-end; flex-direction: row-reverse; }
+        .message.deepseek_v31 .avatar { background-color: #4285f4; } /* Google Blue */
+        .message.deepseek_v31 .content { background-color: #e7f3ff; border-top-right-radius: 4px; }
+        .message .text { white-space: pre-wrap; word-wrap: break-word; }
+        .message .text p { margin: 0 0 10px; }
+        .message .text h1, .message .text h2, .message .text h3 { margin: 15px 0 10px; border-bottom: 1px solid #eee; padding-bottom: 5px; }
+        .message .text ul, .message .text ol { padding-left: 20px; }
+        .message .text code { background-color: #eee; padding: 2px 4px; border-radius: 4px; font-family: "SFMono-Regular", Consolas, "Liberation Mono", Menlo, Courier, monospace; }
+        .message .text pre { background-color: #2d2d2d; color: #f8f8f2; padding: 15px; border-radius: 6px; overflow-x: auto; }
+        .message .text pre code { background-color: transparent; padding: 0; }
+        .round-separator { text-align: center; color: #888; font-size: 0.9em; margin: 20px 0; font-weight: 600; }
+
+        /* 响应式设计 - 针对手机等小屏幕设备 */
+        @media (max-width: 768px) {
+            body { padding: 0; }
+            .container { width: 100%; margin: 0; border-radius: 0; padding: 10px; height: 100%; }
+            .main-layout { flex-direction: column; }
+            .sidebar { flex: 0 0 auto; }
+            .header h1 { font-size: 1.5em; }
+            .controls { flex-direction: column; }
+            .control-group { min-width: unset; }
+        }
+    </style>
+    <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/dompurify/dist/purify.min.js"></script>
+</head>
+<body>
+    <div class="container">
+        <div class="header"><h1>AI大模型辩论系统</h1><p>观看两个AI大模型实时辩论</p></div>
+        
+        <div class="main-layout">
+            <div class="sidebar">
+                <div class="control-group"><label for="topic">辩论话题:</label><input type="text" id="topic" value="人工智能是否会取代人类的工作"></div>
+                <div class="control-group">
+                    <label for="initialPrompt">自定义初始提示 (可选):</label>
+                    <textarea id="initialPrompt" rows="6" placeholder="例如：请作为正方，用强势的语气开启辩论..."></textarea>
+                </div>
+                <div class="control-group"><label for="rounds">轮数:</label><input type="number" id="rounds" min="1" max="10" value="5"></div>
+                <div class="control-group"><label for="firstModel">首发模型:</label><select id="firstModel"><option value="glm45">ZhipuAI/GLM-4.5</option><option value="deepseek_v31">deepseek-ai/DeepSeek-V3.1</option></select></div>
+                <div class="controls">
+                    <button id="startBtn" disabled>开始辩论</button>
+                    <button id="stopBtn" disabled>停止辩论</button>
+                </div>
+            </div>
+            <div class="chat-area">
+                <label for="output">辩论实况:</label>
+                <div id="output" class="output-container"></div>
+            </div>
+        </div>
+    </div>
+    <script>
+        let websocket = null, isConnected = false, currentMessageElement = null, currentMessageContent = '';
+        const startBtn = document.getElementById('startBtn'), stopBtn = document.getElementById('stopBtn');
+        const outputDiv = document.getElementById('output');
+        
+        function handleWebSocketMessage(data) {
+            let shouldScroll = Math.abs(outputDiv.scrollHeight - outputDiv.clientHeight - outputDiv.scrollTop) < 10;
+            
+            switch (data.type) {
+                case 'debate_started':
+                    outputDiv.innerHTML = '';
+                    const topicDiv = document.createElement('div');
+                    topicDiv.className = 'round-separator';
+                    topicDiv.innerHTML = `<strong>话题:</strong> ${data.topic}`;
+                    outputDiv.appendChild(topicDiv);
+                    break;
+                case 'round_info':
+                    const separator = document.createElement('div');
+                    separator.className = 'round-separator';
+                    separator.textContent = data.message.trim();
+                    outputDiv.appendChild(separator);
+                    break;
+                case 'model_speaking':
+                    currentMessageContent = ''; // 重置当前消息内容
+                    const messageDiv = document.createElement('div');
+                    messageDiv.className = `message ${data.model}`;
+                    messageDiv.innerHTML = `
+                        <div class="avatar">${data.model.substring(0, 1).toUpperCase()}</div>
+                        <div class="content">
+                            <div class="sender">${data.model} (${data.role})</div>
+                            <div class="text"><i>正在思考...</i></div>
+                        </div>`;
+                    outputDiv.appendChild(messageDiv);
+                    currentMessageElement = messageDiv.querySelector('.text');
+                    break;
+                case 'stream_content':
+                    if (currentMessageElement) {
+                        currentMessageContent += data.content;
+                        currentMessageElement.innerHTML = DOMPurify.sanitize(marked.parse(currentMessageContent));
+                    }
+                    break;
+                case 'stream_end':
+                    currentMessageElement = null;
+                    break;
+                case 'debate_ended':
+                case 'debate_stopped':
+                    const endMsg = document.createElement('div');
+                    endMsg.className = 'round-separator';
+                    endMsg.textContent = data.message;
+                    outputDiv.appendChild(endMsg);
+                    startBtn.disabled = false; stopBtn.disabled = true;
+                    break;
+                case 'error':
+                    outputDiv.innerHTML += `<div class="round-separator" style="color: red;">错误: ${data.message}</div>`;
+                    break;
+            }
+            if(shouldScroll) {
+                outputDiv.scrollTop = outputDiv.scrollHeight;
+            }
+        }
+        
+        function connect() {
+            const wsUrl = `ws://${window.location.host}/ws`;
+            websocket = new WebSocket(wsUrl);
+            websocket.onopen = () => { isConnected = true; startBtn.disabled = false; };
+            websocket.onmessage = (event) => handleWebSocketMessage(JSON.parse(event.data));
+            websocket.onclose = () => { isConnected = false; startBtn.disabled = true; stopBtn.disabled = true; };
+            websocket.onerror = (error) => { console.error('WebSocket Error:', error); };
+        }
+
+        window.addEventListener('load', connect);
+
+        startBtn.addEventListener('click', () => {
+            if (!websocket) return;
+            const message = { 
+                action: "start_debate", 
+                topic: document.getElementById('topic').value, 
+                rounds: parseInt(document.getElementById('rounds').value), 
+                first_model: document.getElementById('firstModel').value,
+                initial_prompt: document.getElementById('initialPrompt').value
+            };
+            websocket.send(JSON.stringify(message));
+            startBtn.disabled = true; stopBtn.disabled = false;
+        });
+        stopBtn.addEventListener('click', () => {
+            if (!websocket) return;
+            websocket.send(JSON.stringify({ action: "stop_debate" }));
+        });
+    </script>
+</body>
+</html>"""
+    with open(os.path.join(templates_dir, "index.html"), "w", encoding="utf-8") as f:
+        f.write(index_html)
+    logger.info("Web应用模板文件已创建")
+
+if __name__ == "__main__":
+    os.makedirs(static_dir, exist_ok=True)
+    os.makedirs(templates_dir, exist_ok=True)
+    create_templates()
+    logger.info("启动Web服务器...")
+    # 智能端口切换：优先使用环境变量PORT，否则默认为8000
+    port = int(os.environ.get("PORT", 8000))
+    uvicorn.run(app, host="0.0.0.0", port=port) 

src/debate_controller.py

@@ -0,0 +1,454 @@
+# -*- coding: utf-8 -*-
+"""
+辩论控制器模块
+管理辩论流程和控制发言顺序
+"""
+
+import os
+import sys
+import json
+import time
+import logging
+import threading
+from typing import Dict, List, Any, Optional, Callable
+from datetime import datetime
+from queue import Queue
+
+# 在代码开头强制设置终端编码为UTF-8
+os.system('chcp 65001 > nul')
+
+# 获取当前脚本文件所在目录的绝对路径
+current_script_dir = os.path.dirname(os.path.abspath(__file__))
+
+# 项目根目录 (即 '20250907_大模型辩论' 目录, 是 'src' 的上一级)
+project_root = os.path.dirname(current_script_dir)
+
+# 定义数据输入、输出和日志目录
+DATA_DIR = os.path.join(project_root, 'data')
+OUTPUT_DIR = os.path.join(project_root, 'output')
+LOGS_DIR = os.path.join(project_root, 'logs')
+
+# 确保目录存在
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+os.makedirs(LOGS_DIR, exist_ok=True)
+
+# 配置日志
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler(os.path.join(LOGS_DIR, '辩论控制器日志.log'), encoding='utf-8'),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# 捕获警告并记录到日志
+logging.captureWarnings(True)
+
+class DebateMessage:
+    """辩论消息类"""
+    
+    def __init__(self, role: str, content: str, model_name: str, timestamp: datetime = None):
+        """
+        初始化辩论消息
+        
+        Args:
+            role: 消息角色 ('user' 或 'assistant')
+            content: 消息内容
+            model_name: 模型名称
+            timestamp: 时间戳
+        """
+        self.role = role
+        self.content = content
+        self.model_name = model_name
+        self.timestamp = timestamp or datetime.now()
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """转换为字典"""
+        return {
+            'role': self.role,
+            'content': self.content,
+            'model_name': self.model_name,
+            'timestamp': self.timestamp.isoformat()
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'DebateMessage':
+        """从字典创建实例"""
+        return cls(
+            role=data['role'],
+            content=data['content'],
+            model_name=data['model_name'],
+            timestamp=datetime.fromisoformat(data['timestamp'])
+        )
+
+class DebateSession:
+    """辩论会话类"""
+    
+    def __init__(self, topic: str, max_rounds: int = 5, first_model: str = 'glm45'):
+        """
+        初始化辩论会话
+        
+        Args:
+            topic: 辩论话题
+            max_rounds: 最大轮数
+            first_model: 首发模型 ('glm45' 或 'kimi_k2')
+        """
+        self.topic = topic
+        self.max_rounds = max_rounds
+        self.first_model = first_model
+        self.messages: List[DebateMessage] = []
+        self.current_round = 0
+        self.is_active = True
+        self.is_paused = False
+        self.start_time = None
+        self.end_time = None
+        self.debate_id = f"debate_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+        
+        logger.info(f"辩论会话初始化完成，话题: {topic}, 最大轮数: {max_rounds}, 首发模型: {first_model}")
+    
+    def add_message(self, message: DebateMessage):
+        """添加消息到辩论记录"""
+        self.messages.append(message)
+        logger.info(f"添加消息到辩论记录，模型: {message.model_name}, 内容长度: {len(message.content)}")
+    
+    def get_messages_for_model(self, model_name: str) -> List[Dict[str, str]]:
+        """
+        获取指定模型的消息历史
+        
+        Args:
+            model_name: 模型名称
+            
+        Returns:
+            消息历史列表
+        """
+        # 转换为API需要的格式
+        result = []
+        for msg in self.messages:
+            result.append({
+                'role': msg.role,
+                'content': msg.content
+            })
+        return result
+    
+    def get_debate_summary(self) -> Dict[str, Any]:
+        """获取辩论摘要"""
+        return {
+            'debate_id': self.debate_id,
+            'topic': self.topic,
+            'max_rounds': self.max_rounds,
+            'current_round': self.current_round,
+            'total_messages': len(self.messages),
+            'is_active': self.is_active,
+            'is_paused': self.is_paused,
+            'start_time': self.start_time.isoformat() if self.start_time else None,
+            'end_time': self.end_time.isoformat() if self.end_time else None,
+            'duration': (self.end_time - self.start_time).total_seconds() if self.start_time and self.end_time else None
+        }
+    
+    def save_to_file(self, file_path: str):
+        """保存辩论记录到文件"""
+        data = {
+            'debate_info': self.get_debate_summary(),
+            'messages': [msg.to_dict() for msg in self.messages]
+        }
+        
+        with open(file_path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+        
+        logger.info(f"辩论记录已保存到: {file_path}")
+    
+    @classmethod
+    def load_from_file(cls, file_path: str) -> 'DebateSession':
+        """从文件加载辩论记录"""
+        with open(file_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        debate_info = data['debate_info']
+        session = cls(
+            topic=debate_info['topic'],
+            max_rounds=debate_info['max_rounds'],
+            first_model='glm45'  # 默认值，实际值应该从消息中推断
+        )
+        
+        session.debate_id = debate_info['debate_id']
+        session.current_round = debate_info['current_round']
+        session.is_active = debate_info['is_active']
+        session.is_paused = debate_info['is_paused']
+        session.start_time = datetime.fromisoformat(debate_info['start_time']) if debate_info['start_time'] else None
+        session.end_time = datetime.fromisoformat(debate_info['end_time']) if debate_info['end_time'] else None
+        
+        session.messages = [DebateMessage.from_dict(msg_data) for msg_data in data['messages']]
+        
+        logger.info(f"从文件加载辩论记录: {file_path}")
+        return session
+
+    def generate_prompt(self, speaker_name: str, first_model_name: str) -> str:
+        """
+        根据辩论历史和当前发言者生成提示
+        
+        Args:
+            speaker_name: 当前发言者名称
+            first_model_name: 首发模型名称
+            
+        Returns:
+            生成的提示字符串
+        """
+        is_positive_side = (speaker_name == first_model_name)
+        role = "正方" if is_positive_side else "反方"
+        
+        if not self.messages:
+            # 辩论开始，第一个发言者
+            return f"你将作为{role}，就以下话题进行辩论：{self.topic}。请提出你的主要论点，陈述你的核心立场和关键论据。"
+        else:
+            last_message = self.messages[-1]
+            opponent_statement = last_message.content
+            
+            if len(self.messages) == 1:
+                # 第二个发言者，对开场陈述进行反驳
+                return f"你将作为{role}，就以下话题进行辩论：{self.topic}。你的对手（{role}）的开场陈述是：\n\n“{opponent_statement}”\n\n请直接反驳对方的观点，并提出你自己的论点。"
+            else:
+                # 后续发言，进行反驳和回应
+                return f"现在轮到你（{role}）发言。你的对手刚刚的发言是：\n\n“{opponent_statement}”\n\n请针对他的观点进行反驳，并进一步阐述和强化你自己的立场。"
+
+class DebateController:
+    """辩论控制器类"""
+    
+    def __init__(self, model_manager, output_callback: Optional[Callable] = None):
+        """
+        初始化辩论控制器
+        
+        Args:
+            model_manager: 模型管理器实例
+            output_callback: 输出回调函数，用于实时显示辩论内容
+        """
+        self.model_manager = model_manager
+        self.output_callback = output_callback
+        self.current_session: Optional[DebateSession] = None
+        self.debate_thread: Optional[threading.Thread] = None
+        self.stop_event = threading.Event()
+        self.pause_event = threading.Event()
+        
+        logger.info("辩论控制器初始化完成")
+    
+    def create_debate(self, topic: str, max_rounds: int = 5, first_model: str = 'glm45') -> DebateSession:
+        """
+        创建新的辩论会话
+        
+        Args:
+            topic: 辩论话题
+            max_rounds: 最大轮数
+            first_model: 首发模型
+            
+        Returns:
+            辩论会话实例
+        """
+        self.current_session = DebateSession(topic, max_rounds, first_model)
+        logger.info(f"创建新辩论会话，话题: {topic}")
+        return self.current_session
+    
+    def start_debate(self):
+        """开始辩论"""
+        if not self.current_session:
+            logger.error("没有活动的辩论会话")
+            return
+        
+        if self.current_session.is_active:
+            logger.warning("辩论已经在进行中")
+            return
+        
+        self.current_session.is_active = True
+        self.current_session.is_paused = False
+        self.current_session.start_time = datetime.now()
+        self.stop_event.clear()
+        self.pause_event.clear()
+        
+        # 启动辩论线程
+        self.debate_thread = threading.Thread(target=self._debate_loop)
+        self.debate_thread.daemon = True
+        self.debate_thread.start()
+        
+        logger.info("辩论开始")
+    
+    def pause_debate(self):
+        """暂停辩论"""
+        if not self.current_session or not self.current_session.is_active:
+            logger.warning("没有活动的辩论会话")
+            return
+        
+        self.current_session.is_paused = True
+        self.pause_event.set()
+        logger.info("辩论已暂停")
+    
+    def resume_debate(self):
+        """恢复辩论"""
+        if not self.current_session or not self.current_session.is_active:
+            logger.warning("没有活动的辩论会话")
+            return
+        
+        self.current_session.is_paused = False
+        self.pause_event.clear()
+        logger.info("辩论已恢复")
+    
+    def stop_debate(self):
+        """停止辩论"""
+        if not self.current_session or not self.current_session.is_active:
+            logger.warning("没有活动的辩论会话")
+            return
+        
+        self.stop_event.set()
+        self.current_session.is_active = False
+        self.current_session.is_paused = False
+        self.current_session.end_time = datetime.now()
+        
+        if self.debate_thread and self.debate_thread.is_alive():
+            self.debate_thread.join(timeout=5)
+        
+        # 保存辩论记录
+        self._save_debate_record()
+        
+        logger.info("辩论已停止")
+    
+    def _debate_loop(self):
+        """辩论主循环"""
+        session = self.current_session
+        if not session:
+            return
+        
+        # 确定模型顺序
+        model_a = session.first_model
+        model_b = 'deepseek_v31' if model_a == 'glm45' else 'glm45'
+        
+        # 获取模型接口
+        model_a_interface = self.model_manager.get_model(model_a)
+        model_b_interface = self.model_manager.get_model(model_b)
+        
+        # 构建初始提示
+        initial_prompt_a = f"你将作为正方，就以下话题进行辩论：{session.topic}。请提出你的主要论点。"
+        initial_prompt_b = f"你将作为反方，就以下话题进行辩论：{session.topic}。请针对对方的论点进行反驳。"
+        
+        # 第一轮：模型A提出论点
+        if not self._should_continue_debate(session):
+            return
+        
+        self._output_message(f"=== 辩论开始 ===\n话题: {session.topic}\n")
+        self._output_message(f"--- 第1轮 ---\n")
+        
+        # 模型A发言
+        self._output_message(f"{model_a} (正方): ")
+        response_a = model_a_interface.chat([{"role": "user", "content": initial_prompt_a}])
+        self._output_message(f"{response_a}\n\n")
+        
+        # 记录消息
+        session.add_message(DebateMessage("user", initial_prompt_a, "system"))
+        session.add_message(DebateMessage("assistant", response_a, model_a))
+        
+        session.current_round = 1
+        
+        # 后续轮次
+        while self._should_continue_debate(session):
+            # 检查暂停状态
+            if self.pause_event.is_set():
+                self._output_message("辩论已暂停，等待恢复...\n")
+                self.pause_event.wait()
+                self._output_message("辩论已恢复\n")
+            
+            session.current_round += 1
+            self._output_message(f"--- 第{session.current_round}轮 ---\n")
+            
+            # 模型B反驳
+            self._output_message(f"{model_b} (反方): ")
+            prompt_b = f"{initial_prompt_b}\n\n对方的论点: {response_a}\n\n请进行反驳。"
+            response_b = model_b_interface.chat(session.get_messages_for_model(model_b) + [{"role": "user", "content": prompt_b}])
+            self._output_message(f"{response_b}\n\n")
+            
+            # 记录消息
+            session.add_message(DebateMessage("user", prompt_b, "system"))
+            session.add_message(DebateMessage("assistant", response_b, model_b))
+            
+            # 检查是否应该继续
+            if not self._should_continue_debate(session):
+                break
+            
+            # 模型A回应
+            self._output_message(f"{model_a} (正方): ")
+            prompt_a = f"请针对对方的反驳进行回应：{response_b}"
+            response_a = model_a_interface.chat(session.get_messages_for_model(model_a) + [{"role": "user", "content": prompt_a}])
+            self._output_message(f"{response_a}\n\n")
+            
+            # 记录消息
+            session.add_message(DebateMessage("user", prompt_a, "system"))
+            session.add_message(DebateMessage("assistant", response_a, model_a))
+        
+        # 辩论结束
+        session.is_active = False
+        session.end_time = datetime.now()
+        self._output_message("=== 辩论结束 ===\n")
+        
+        # 保存辩论记录
+        self._save_debate_record()
+    
+    def _should_continue_debate(self, session: DebateSession) -> bool:
+        """检查是否应该继续辩论"""
+        if self.stop_event.is_set():
+            return False
+        
+        if session.current_round >= session.max_rounds:
+            return False
+        
+        return True
+    
+    def _output_message(self, message: str):
+        """输出消息"""
+        if self.output_callback:
+            self.output_callback(message)
+        else:
+            print(message, end='', flush=True)
+    
+    def _save_debate_record(self):
+        """保存辩论记录"""
+        if not self.current_session:
+            return
+        
+        # 创建输出文件路径
+        output_dir = os.path.join(OUTPUT_DIR, "辩论记录")
+        os.makedirs(output_dir, exist_ok=True)
+        
+        file_path = os.path.join(output_dir, f"{self.current_session.debate_id}.json")
+        self.current_session.save_to_file(file_path)
+        
+        logger.info(f"辩论记录已保存: {file_path}")
+
+# 测试代码
+if __name__ == "__main__":
+    # 简单测试
+    import sys
+    import os
+    import importlib.util
+    
+    # 动态导入模块
+    module_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "2_模型接口.py")
+    spec = importlib.util.spec_from_file_location("model_interface", module_path)
+    model_interface = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(model_interface)
+    
+    # 创建模型管理器
+    api_key = "ms-b4690538-3224-493a-8f5b-4073d527f788"
+    model_manager = model_interface.ModelManager(api_key)
+    
+    # 创建辩论控制器
+    def print_callback(message):
+        print(message, end='', flush=True)
+    
+    controller = DebateController(model_manager, print_callback)
+    
+    # 创建辩论会话
+    session = controller.create_debate("人工智能是否会取代人类的工作", max_rounds=3, first_model='glm45')
+    
+    # 开始辩论
+    controller.start_debate()
+    
+    # 等待辩论结束
+    if controller.debate_thread:
+        controller.debate_thread.join() 

src/model_interface.py

@@ -0,0 +1,376 @@
+# -*- coding: utf-8 -*-
+"""
+模型接口模块
+用于与两个大模型API进行交互的封装
+"""
+
+import os
+import sys
+import requests
+import json
+import time
+import logging
+from typing import Dict, Any, Optional, Callable
+from urllib3.exceptions import InsecureRequestWarning
+
+# 在代码开头强制设置终端编码为UTF-8
+os.system('chcp 65001 > nul')
+
+# 获取当前脚本文件所在目录的绝对路径
+current_script_dir = os.path.dirname(os.path.abspath(__file__))
+
+# 项目根目录 (即 '20250907_大模型辩论' 目录, 是 'src' 的上一级)
+project_root = os.path.dirname(current_script_dir)
+
+# 定义数据输入、输出和日志目录
+DATA_DIR = os.path.join(project_root, 'data')
+OUTPUT_DIR = os.path.join(project_root, 'output')
+LOGS_DIR = os.path.join(project_root, 'logs')
+
+# 确保目录存在
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+os.makedirs(LOGS_DIR, exist_ok=True)
+
+# 配置日志
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler(os.path.join(LOGS_DIR, '模型接口日志.log'), encoding='utf-8'),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# 捕获警告并记录到日志
+logging.captureWarnings(True)
+
+class ModelInterface:
+    """模型接口基类"""
+    
+    def __init__(self, api_key: str, base_url: str):
+        """
+        初始化模型接口
+        
+        Args:
+            api_key: API密钥
+            base_url: API基础URL
+        """
+        self.api_key = api_key
+        self.base_url = base_url
+        self.headers = {
+            'Authorization': f'Bearer {api_key}',
+            'Content-Type': 'application/json'
+        }
+        logger.info(f"模型接口初始化完成，基础URL: {base_url}")
+    
+    def send_request(self, model: str, messages: list, **kwargs) -> Dict[str, Any]:
+        """
+        发送请求到模型API
+        
+        Args:
+            model: 模型名称
+            messages: 消息列表
+            **kwargs: 其他参数
+            
+        Returns:
+            API响应结果
+        """
+        payload = {
+            'model': model,
+            'messages': messages,
+            **kwargs
+        }
+        
+        try:
+            logger.info(f"向模型 {model} 发送请求")
+            response = requests.post(
+                f"{self.base_url}/chat/completions",
+                headers=self.headers,
+                json=payload,
+                timeout=60
+            )
+            response.raise_for_status()
+            result = response.json()
+            logger.info(f"模型 {model} 响应成功")
+            return result
+        except requests.exceptions.RequestException as e:
+            logger.error(f"请求模型 {model} 失败: {str(e)}")
+            raise
+        except json.JSONDecodeError as e:
+            logger.error(f"解析模型 {model} 响应失败: {str(e)}")
+            raise
+    
+    def send_stream_request(self, model: str, messages: list, callback: Callable[[str], None], **kwargs) -> str:
+        """
+        发送流式请求到模型API
+        
+        Args:
+            model: 模型名称
+            messages: 消息列表
+            callback: 回调函数，用于处理流式输出的每个字符
+            **kwargs: 其他参数
+            
+        Returns:
+            完整的响应文本
+        """
+        payload = {
+            'model': model,
+            'messages': messages,
+            'stream': True,
+            **kwargs
+        }
+        
+        full_response = ""
+        try:
+            logger.info(f"向模型 {model} 发送流式请求")
+            response = requests.post(
+                f"{self.base_url}/chat/completions",
+                headers=self.headers,
+                json=payload,
+                timeout=60,
+                stream=True
+            )
+            response.raise_for_status()
+            
+            # 处理流式响应
+            for line in response.iter_lines():
+                if line:
+                    decoded_line = line.decode('utf-8')
+                    if decoded_line.startswith("data: "):
+                        data = decoded_line[6:]  # 去掉 "data: " 前缀
+                        if data != "[DONE]":
+                            try:
+                                json_data = json.loads(data)
+                                content = json_data["choices"][0]["delta"].get("content", "")
+                                if content:
+                                    full_response += content
+                                    # 调用回调函数处理每个字符
+                                    callback(content)
+                            except json.JSONDecodeError:
+                                pass  # 忽略无法解析的行
+                                
+            logger.info(f"模型 {model} 流式响应完成")
+            return full_response
+        except requests.exceptions.RequestException as e:
+            logger.error(f"流式请求模型 {model} 失败: {str(e)}")
+            raise
+        except Exception as e:
+            logger.error(f"处理流式响应时出错: {str(e)}")
+            raise
+    
+    def get_response_text(self, response: Dict[str, Any]) -> str:
+        """
+        从API响应中提取回复文本
+        
+        Args:
+            response: API响应
+            
+        Returns:
+            回复文本
+        """
+        try:
+            return response['choices'][0]['message']['content']
+        except (KeyError, IndexError) as e:
+            logger.error(f"提取回复文本失败: {str(e)}")
+            raise
+
+class GLM45Interface(ModelInterface):
+    """GLM-4.5模型接口"""
+    
+    def __init__(self, api_key: str):
+        """
+        初始化GLM-4.5模型接口
+        
+        Args:
+            api_key: API密钥
+        """
+        super().__init__(api_key, "https://api-inference.modelscope.cn/v1")
+        self.model_name = "ZhipuAI/GLM-4.5"
+        logger.info(f"GLM-4.5模型接口初始化完成")
+    
+    def chat(self, messages: list, temperature: float = 0.7, max_tokens: int = 1000) -> str:
+        """
+        与GLM-4.5模型对话
+        
+        Args:
+            messages: 消息列表
+            temperature: 温度参数，控制随机性
+            max_tokens: 最大令牌数
+            
+        Returns:
+            模型回复文本
+        """
+        try:
+            response = self.send_request(
+                model=self.model_name,
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens
+            )
+            return self.get_response_text(response)
+        except Exception as e:
+            logger.error(f"GLM-4.5对话失败: {str(e)}")
+            return f"GLM-4.5对话失败: {str(e)}"
+    
+    def chat_stream(self, messages: list, callback: Callable[[str], None], temperature: float = 0.7, max_tokens: int = 1000) -> str:
+        """
+        与GLM-4.5模型流式对话
+        
+        Args:
+            messages: 消息列表
+            callback: 回调函数，用于处理流式输出的每个字符
+            temperature: 温度参数，控制随机性
+            max_tokens: 最大令牌数
+            
+        Returns:
+            完整的模型回复文本
+        """
+        try:
+            return self.send_stream_request(
+                model=self.model_name,
+                messages=messages,
+                callback=callback,
+                temperature=temperature
+                # 移除max_tokens参数，避免截断
+                # max_tokens=max_tokens
+            )
+        except Exception as e:
+            logger.error(f"GLM-4.5流式对话失败: {str(e)}")
+            error_msg = f"GLM-4.5流式对话失败: {str(e)}"
+            # 通过回调函数发送错误信息
+            callback(f"\n{error_msg}\n")
+            return error_msg
+
+class DeepSeekV31Interface(ModelInterface):
+    """DeepSeek-V3.1模型接口"""
+    
+    def __init__(self, api_key: str):
+        """
+        初始化DeepSeek-V3.1模型接口
+        
+        Args:
+            api_key: API密钥
+        """
+        super().__init__(api_key, "https://api-inference.modelscope.cn/v1")
+        self.model_name = "deepseek-ai/DeepSeek-V3.1"
+        logger.info(f"DeepSeek-V3.1模型接口初始化完成")
+    
+    def chat(self, messages: list, temperature: float = 0.7, max_tokens: int = 1000) -> str:
+        """
+        与DeepSeek-V3.1模型对话
+        
+        Args:
+            messages: 消息列表
+            temperature: 温度参数，控制随机性
+            max_tokens: 最大令牌数
+            
+        Returns:
+            模型回复文本
+        """
+        try:
+            response = self.send_request(
+                model=self.model_name,
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens
+            )
+            return self.get_response_text(response)
+        except Exception as e:
+            logger.error(f"DeepSeek-V3.1对话失败: {str(e)}")
+            return f"DeepSeek-V3.1对话失败: {str(e)}"
+    
+    def chat_stream(self, messages: list, callback: Callable[[str], None], temperature: float = 0.7, max_tokens: int = 1000) -> str:
+        """
+        与DeepSeek-V3.1模型流式对话
+        
+        Args:
+            messages: 消息列表
+            callback: 回调函数，用于处理流式输出的每个字符
+            temperature: 温度参数，控制随机性
+            max_tokens: 最大令牌数
+            
+        Returns:
+            完整的模型回复文本
+        """
+        try:
+            return self.send_stream_request(
+                model=self.model_name,
+                messages=messages,
+                callback=callback,
+                temperature=temperature
+                # 暂时移除max_tokens参数，排查兼容性问题
+                # max_tokens=max_tokens 
+            )
+        except Exception as e:
+            logger.error(f"DeepSeek-V3.1流式对话失败: {str(e)}")
+            error_msg = f"DeepSeek-V3.1流式对话失败: {str(e)}"
+            # 通过回调函数发送错误信息
+            callback(f"\n{error_msg}\n")
+            return error_msg
+
+class ModelManager:
+    """模型管理器，统一管理两个模型接口"""
+    
+    def __init__(self, api_key: str):
+        """
+        初始化模型管理器
+        
+        Args:
+            api_key: API密钥
+        """
+        self.api_key = api_key
+        self.glm45 = GLM45Interface(api_key)
+        self.deepseek_v31 = DeepSeekV31Interface(api_key)
+        logger.info("模型管理器初始化完成")
+    
+    def get_model(self, model_name: str) -> ModelInterface:
+        """
+        获取指定模型接口
+        
+        Args:
+            model_name: 模型名称 ('glm45' 或 'deepseek_v31')
+            
+        Returns:
+            模型接口实例
+        """
+        if model_name.lower() == 'glm45':
+            return self.glm45
+        elif model_name.lower() == 'deepseek_v31':
+            return self.deepseek_v31
+        else:
+            logger.error(f"不支持的模型名称: {model_name}")
+            raise ValueError(f"不支持的模型名称: {model_name}")
+
+# 测试代码
+if __name__ == "__main__":
+    # 测试模型接口
+    api_key = "ms-b4690538-3224-493a-8f5b-4073d527f788"
+    manager = ModelManager(api_key)
+    
+    # 测试GLM-4.5
+    glm45 = manager.get_model('glm45')
+    messages = [{"role": "user", "content": "你好，请简单介绍一下自己"}]
+    
+    print("=== 测试GLM-4.5普通对话 ===")
+    response = glm45.chat(messages)
+    print(f"GLM-4.5回复: {response}")
+    
+    print("\n=== 测试GLM-4.5流式对话 ===")
+    def stream_callback(content):
+        print(content, end='', flush=True)
+    
+    response = glm45.chat_stream(messages, stream_callback)
+    print(f"\n完整回复: {response}")
+    
+    # 测试DeepSeek-V3.1
+    deepseek_v31 = manager.get_model('deepseek_v31')
+    messages = [{"role": "user", "content": "你好，请简单介绍一下自己"}]
+    
+    print("\n=== 测试DeepSeek-V3.1普通对话 ===")
+    response = deepseek_v31.chat(messages)
+    print(f"DeepSeek-V3.1回复: {response}")
+    
+    print("\n=== 测试DeepSeek-V3.1流式对话 ===")
+    response = deepseek_v31.chat_stream(messages, stream_callback)
+    print(f"\n完整回复: {response}") 

src/旧文件/1_辩论系统.py

@@ -0,0 +1,414 @@
+# -*- coding: utf-8 -*-
+"""
+AI大模型辩论系统主程序
+整合所有模块，提供用户交互界面
+"""
+
+import os
+import sys
+import time
+import logging
+import argparse
+from datetime import datetime
+
+# 在代码开头强制设置终端编码为UTF-8
+os.system('chcp 65001 > nul')
+
+# 获取当前脚本文件所在目录的绝对路径
+current_script_dir = os.path.dirname(os.path.abspath(__file__))
+
+# 项目根目录 (即 '20250907_大模型辩论' 目录, 是 'src' 的上一级)
+project_root = os.path.dirname(current_script_dir)
+
+# 定义数据输入、输出和日志目录
+DATA_DIR = os.path.join(project_root, 'data')
+OUTPUT_DIR = os.path.join(project_root, 'output')
+LOGS_DIR = os.path.join(project_root, 'logs')
+
+# 确保目录存在
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+os.makedirs(LOGS_DIR, exist_ok=True)
+
+# 配置日志
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler(os.path.join(LOGS_DIR, '系统运行日志.log'), encoding='utf-8'),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# 捕获警告并记录到日志
+logging.captureWarnings(True)
+
+# 导入自定义模块
+try:
+    import importlib.util
+    import os
+    
+    # 动态导入模型接口模块
+    model_interface_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "2_模型接口.py")
+    model_interface_spec = importlib.util.spec_from_file_location("model_interface", model_interface_path)
+    model_interface = importlib.util.module_from_spec(model_interface_spec)
+    model_interface_spec.loader.exec_module(model_interface)
+    
+    # 动态导入辩论控制器模块
+    debate_controller_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "3_辩论控制器.py")
+    debate_controller_spec = importlib.util.spec_from_file_location("debate_controller", debate_controller_path)
+    debate_controller = importlib.util.module_from_spec(debate_controller_spec)
+    debate_controller_spec.loader.exec_module(debate_controller)
+    
+    # 动态导入显示界面模块
+    display_interface_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "4_显示界面.py")
+    display_interface_spec = importlib.util.spec_from_file_location("display_interface", display_interface_path)
+    display_interface = importlib.util.module_from_spec(display_interface_spec)
+    display_interface_spec.loader.exec_module(display_interface)
+    
+    # 从模块中获取需要的类
+    ModelManager = model_interface.ModelManager
+    DebateController = debate_controller.DebateController
+    DisplayManager = display_interface.DisplayManager
+    
+except ImportError as e:
+    logger.error(f"导入模块失败: {str(e)}")
+    print("请确保所有模块文件都在同一目录下")
+    sys.exit(1)
+
+class DebateSystem:
+    """AI大模型辩论系统"""
+    
+    def __init__(self, api_key: str, display_type: str = "composite"):
+        """
+        初始化辩论系统
+        
+        Args:
+            api_key: API密钥
+            display_type: 显示类型 ('simple', 'console', 'file', 'composite')
+        """
+        self.api_key = api_key
+        self.display_type = display_type
+        
+        # 初始化模型管理器
+        self.model_manager = ModelManager(api_key)
+        
+        # 初始化显示管理器
+        self.display_manager = DisplayManager(display_type)
+        
+        # 初始化辩论控制器
+        self.debate_controller = DebateController(
+            self.model_manager,
+            output_callback=self.display_manager.add_message
+        )
+        
+        logger.info("AI大模型辩论系统初始化完成")
+    
+    def start(self):
+        """启动辩论系统"""
+        logger.info("启动AI大模型辩论系统")
+        
+        # 启动显示界面
+        self.display_manager.start()
+        
+        # 显示欢迎信息
+        self.display_manager.add_message("=" * 50 + "\n")
+        self.display_manager.add_message("欢迎使用AI大模型辩论系统\n")
+        self.display_manager.add_message("=" * 50 + "\n\n")
+        
+        # 主循环
+        while True:
+            try:
+                # 显示菜单
+                self.display_manager.add_message("请选择操作:\n")
+                self.display_manager.add_message("1. 开始新辩论\n")
+                self.display_manager.add_message("2. 查看历史辩论记录\n")
+                self.display_manager.add_message("3. 系统设置\n")
+                self.display_manager.add_message("4. 退出系统\n")
+                self.display_manager.add_message("请输入选项 (1-4): ")
+                
+                # 获取用户输入
+                choice = input().strip()
+                
+                if choice == "1":
+                    self.start_new_debate()
+                elif choice == "2":
+                    self.view_history()
+                elif choice == "3":
+                    self.system_settings()
+                elif choice == "4":
+                    self.display_manager.add_message("感谢使用AI大模型辩论系统，再见！\n")
+                    break
+                else:
+                    self.display_manager.add_message("无效选项，请重新输入\n\n")
+                    
+            except KeyboardInterrupt:
+                self.display_manager.add_message("\n\n检测到中断信号，正在退出系统...\n")
+                break
+            except Exception as e:
+                logger.error(f"系统运行出错: {str(e)}")
+                self.display_manager.add_message(f"系统运行出错: {str(e)}\n\n")
+        
+        # 停止显示界面
+        self.display_manager.stop()
+        logger.info("AI大模型辩论系统已关闭")
+    
+    def start_new_debate(self):
+        """开始新辩论"""
+        self.display_manager.add_message("\n--- 开始新辩论 ---\n")
+        
+        # 获取辩论话题
+        self.display_manager.add_message("请输入辩论话题: ")
+        topic = input().strip()
+        
+        if not topic:
+            self.display_manager.add_message("话题不能为空\n\n")
+            return
+        
+        # 获取辩论轮数
+        self.display_manager.add_message("请输入辩论轮数 (默认5轮): ")
+        max_rounds_input = input().strip()
+        
+        try:
+            max_rounds = int(max_rounds_input) if max_rounds_input else 5
+            if max_rounds < 1 or max_rounds > 10:
+                self.display_manager.add_message("轮数必须在1-10之间，使用默认值5\n")
+                max_rounds = 5
+        except ValueError:
+            self.display_manager.add_message("无效输入，使用默认值5轮\n")
+            max_rounds = 5
+        
+        # 获取首发模型
+        self.display_manager.add_message("请选择首发模型 (1. GLM-4.5, 2. DeepSeek-V3.1, 默认1): ")
+        first_model_input = input().strip()
+        
+        if first_model_input == "2":
+            first_model = "deepseek_v31"
+        else:
+            first_model = "glm45"
+        
+        # 显示参数设置
+        self.display_manager.add_message(f"\n辩论参数设置:\n")
+        self.display_manager.add_message(f"话题: {topic}\n")
+        self.display_manager.add_message(f"轮数: {max_rounds}\n")
+        self.display_manager.add_message(f"首发模型: {first_model}\n")
+        
+        # 确认开始
+        self.display_manager.add_message("\n确认开始辩论? (y/n): ")
+        confirm = input().strip().lower()
+        
+        if confirm != "y":
+            self.display_manager.add_message("已取消辩论\n\n")
+            return
+        
+        # 创建辩论会话
+        debate_session = self.debate_controller.create_debate(topic, max_rounds, first_model)
+        
+        # 开始辩论
+        self.display_manager.add_message("\n辩论即将开始...\n\n")
+        time.sleep(1)
+        
+        self.debate_controller.start_debate()
+        
+        # 等待辩论结束
+        try:
+            while self.debate_controller.current_session and self.debate_controller.current_session.is_active:
+                time.sleep(1)
+                
+                # 检查用户输入
+                if sys.stdin in select.select([sys.stdin], [], [], 0)[0]:
+                    user_input = sys.stdin.readline().strip()
+                    if user_input.lower() == "stop":
+                        self.debate_controller.stop_debate()
+                        self.display_manager.add_message("\n用户手动停止辩论\n")
+                    elif user_input.lower() == "pause":
+                        self.debate_controller.pause_debate()
+                        self.display_manager.add_message("\n辩论已暂停\n")
+                    elif user_input.lower() == "resume":
+                        self.debate_controller.resume_debate()
+                        self.display_manager.add_message("\n辩论已恢复\n")
+                    
+        except KeyboardInterrupt:
+            self.display_manager.add_message("\n\n检测到中断信号，正在停止辩论...\n")
+            self.debate_controller.stop_debate()
+        
+        self.display_manager.add_message("\n辩论已结束\n\n")
+    
+    def view_history(self):
+        """查看历史辩论记录"""
+        self.display_manager.add_message("\n--- 历史辩论记录 ---\n")
+        
+        # 获取辩论记录目录
+        debate_records_dir = os.path.join(OUTPUT_DIR, "辩论记录")
+        
+        if not os.path.exists(debate_records_dir):
+            self.display_manager.add_message("暂无辩论记录\n\n")
+            return
+        
+        # 获取所有辩论记录文件
+        record_files = [f for f in os.listdir(debate_records_dir) if f.endswith('.json')]
+        
+        if not record_files:
+            self.display_manager.add_message("暂无辩论记录\n\n")
+            return
+        
+        # 显示辩论记录列表
+        self.display_manager.add_message("可用的辩论记录:\n")
+        for i, filename in enumerate(record_files, 1):
+            self.display_manager.add_message(f"{i}. {filename}\n")
+        
+        # 选择查看记录
+        self.display_manager.add_message("\n请选择要查看的记录 (输入序号，0返回): ")
+        choice = input().strip()
+        
+        try:
+            choice_num = int(choice)
+            if choice_num == 0:
+                self.display_manager.add_message("\n")
+                return
+            
+            if 1 <= choice_num <= len(record_files):
+                selected_file = record_files[choice_num - 1]
+                self.display_debate_record(os.path.join(debate_records_dir, selected_file))
+            else:
+                self.display_manager.add_message("无效选择\n\n")
+        except ValueError:
+            self.display_manager.add_message("无效输入\n\n")
+    
+    def display_debate_record(self, file_path: str):
+        """显示辩论记录"""
+        try:
+            import json
+            
+            with open(file_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            
+            debate_info = data['debate_info']
+            messages = data['messages']
+            
+            self.display_manager.add_message(f"\n--- 辩论记录详情 ---\n")
+            self.display_manager.add_message(f"辩论ID: {debate_info['debate_id']}\n")
+            self.display_manager.add_message(f"话题: {debate_info['topic']}\n")
+            self.display_manager.add_message(f"最大轮数: {debate_info['max_rounds']}\n")
+            self.display_manager.add_message(f"实际轮数: {debate_info['current_round']}\n")
+            self.display_manager.add_message(f"总消息数: {debate_info['total_messages']}\n")
+            
+            if debate_info['start_time']:
+                start_time = datetime.fromisoformat(debate_info['start_time'])
+                self.display_manager.add_message(f"开始时间: {start_time.strftime('%Y-%m-%d %H:%M:%S')}\n")
+            
+            if debate_info['end_time']:
+                end_time = datetime.fromisoformat(debate_info['end_time'])
+                self.display_manager.add_message(f"结束时间: {end_time.strftime('%Y-%m-%d %H:%M:%S')}\n")
+            
+            if debate_info['duration']:
+                duration = int(debate_info['duration'])
+                minutes, seconds = divmod(duration, 60)
+                self.display_manager.add_message(f"持续时间: {minutes}分{seconds}秒\n")
+            
+            self.display_manager.add_message("\n--- 辩论内容 ---\n")
+            
+            for msg in messages:
+                timestamp = datetime.fromisoformat(msg['timestamp'])
+                self.display_manager.add_message(f"[{timestamp.strftime('%H:%M:%S')}] {msg['model_name']}: {msg['content']}\n\n")
+            
+        except Exception as e:
+            logger.error(f"显示辩论记录时出错: {str(e)}")
+            self.display_manager.add_message(f"显示辩论记录时出错: {str(e)}\n\n")
+    
+    def system_settings(self):
+        """系统设置"""
+        self.display_manager.add_message("\n--- 系统设置 ---\n")
+        
+        while True:
+            self.display_manager.add_message("请选择设置项:\n")
+            self.display_manager.add_message("1. 更改显示类型\n")
+            self.display_manager.add_message("2. 查看系统信息\n")
+            self.display_manager.add_message("3. 返回主菜单\n")
+            self.display_manager.add_message("请输入选项 (1-3): ")
+            
+            choice = input().strip()
+            
+            if choice == "1":
+                self.change_display_type()
+            elif choice == "2":
+                self.show_system_info()
+            elif choice == "3":
+                self.display_manager.add_message("\n")
+                break
+            else:
+                self.display_manager.add_message("无效选项，请重新输入\n\n")
+    
+    def change_display_type(self):
+        """更改显示类型"""
+        self.display_manager.add_message("\n当前显示类型: " + self.display_type + "\n")
+        self.display_manager.add_message("可选显示类型:\n")
+        self.display_manager.add_message("1. simple - 简单控制台输出\n")
+        self.display_manager.add_message("2. console - 控制台实时显示\n")
+        self.display_manager.add_message("3. file - 仅保存到文件\n")
+        self.display_manager.add_message("4. composite - 复合显示 (默认)\n")
+        self.display_manager.add_message("请输入选项 (1-4): ")
+        
+        choice = input().strip()
+        
+        display_types = {
+            "1": "simple",
+            "2": "console",
+            "3": "file",
+            "4": "composite"
+        }
+        
+        if choice in display_types:
+            # 停止当前显示
+            self.display_manager.stop()
+            
+            # 更改显示类型
+            self.display_type = display_types[choice]
+            
+            # 重新初始化显示管理器
+            self.display_manager = DisplayManager(self.display_type)
+            
+            # 更新辩论控制器的回调
+            self.debate_controller.output_callback = self.display_manager.add_message
+            
+            # 启动新显示
+            self.display_manager.start()
+            
+            self.display_manager.add_message(f"\n显示类型已更改为: {self.display_type}\n\n")
+        else:
+            self.display_manager.add_message("无效选项\n\n")
+    
+    def show_system_info(self):
+        """显示系统信息"""
+        self.display_manager.add_message("\n--- 系统信息 ---\n")
+        self.display_manager.add_message(f"API基础URL: https://api-inference.modelscope.cn/v1/\n")
+        self.display_manager.add_message(f"支持的模型:\n")
+        self.display_manager.add_message(f"  - ZhipuAI/GLM-4.5\n")
+        self.display_manager.add_message(f"  - deepseek-ai/DeepSeek-V3.1\n")
+        self.display_manager.add_message(f"当前显示类型: {self.display_type}\n")
+        self.display_manager.add_message(f"项目根目录: {project_root}\n")
+        self.display_manager.add_message(f"数据目录: {DATA_DIR}\n")
+        self.display_manager.add_message(f"输出目录: {OUTPUT_DIR}\n")
+        self.display_manager.add_message(f"日志目录: {LOGS_DIR}\n\n")
+
+def main():
+    """主函数"""
+    # 解析命令行参数
+    parser = argparse.ArgumentParser(description='AI大模型辩论系统')
+    parser.add_argument('--api-key', type=str, default='ms-b4690538-3224-493a-8f5b-4073d527f788',
+                        help='API密钥')
+    parser.add_argument('--display-type', type=str, default='composite',
+                        choices=['simple', 'console', 'file', 'composite'],
+                        help='显示类型')
+    
+    args = parser.parse_args()
+    
+    # 创建并启动辩论系统
+    debate_system = DebateSystem(args.api_key, args.display_type)
+    debate_system.start()
+
+if __name__ == "__main__":
+    # 导入select模块（用于检测用户输入）
+    import select
+    
+    main() 

src/旧文件/4_显示界面.py

@@ -0,0 +1,347 @@
+# -*- coding: utf-8 -*-
+"""
+显示界面模块
+用于实时显示辩论内容
+"""
+
+import os
+import sys
+import time
+import threading
+import logging
+from typing import Optional, Dict, Any
+from datetime import datetime
+import queue
+
+# 在代码开头强制设置终端编码为UTF-8
+os.system('chcp 65001 > nul')
+
+# 获取当前脚本文件所在目录的绝对路径
+current_script_dir = os.path.dirname(os.path.abspath(__file__))
+
+# 项目根目录 (即 '20250907_大模型辩论' 目录, 是 'src' 的上一级)
+project_root = os.path.dirname(current_script_dir)
+
+# 定义数据输入、输出和日志目录
+DATA_DIR = os.path.join(project_root, 'data')
+OUTPUT_DIR = os.path.join(project_root, 'output')
+LOGS_DIR = os.path.join(project_root, 'logs')
+
+# 确保目录存在
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+os.makedirs(LOGS_DIR, exist_ok=True)
+
+# 配置日志
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler(os.path.join(LOGS_DIR, '显示界面日志.log'), encoding='utf-8'),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# 捕获警告并记录到日志
+logging.captureWarnings(True)
+
+class ConsoleDisplay:
+    """控制台显示界面"""
+    
+    def __init__(self):
+        """初始化控制台显示界面"""
+        self.message_queue = queue.Queue()
+        self.display_thread = None
+        self.stop_event = threading.Event()
+        self.is_running = False
+        
+        logger.info("控制台显示界面初始化完成")
+    
+    def start(self):
+        """启动显示界面"""
+        if self.is_running:
+            logger.warning("显示界面已经在运行中")
+            return
+        
+        self.is_running = True
+        self.stop_event.clear()
+        
+        # 启动显示线程
+        self.display_thread = threading.Thread(target=self._display_loop)
+        self.display_thread.daemon = True
+        self.display_thread.start()
+        
+        logger.info("显示界面已启动")
+    
+    def stop(self):
+        """停止显示界面"""
+        if not self.is_running:
+            logger.warning("显示界面未在运行")
+            return
+        
+        self.is_running = False
+        self.stop_event.set()
+        
+        if self.display_thread and self.display_thread.is_alive():
+            self.display_thread.join(timeout=1)
+        
+        logger.info("显示界面已停止")
+    
+    def add_message(self, message: str):
+        """添加消息到显示队列"""
+        if not self.is_running:
+            logger.warning("显示界面未在运行，无法添加消息")
+            return
+        
+        self.message_queue.put(message)
+    
+    def clear_screen(self):
+        """清空屏幕"""
+        os.system('cls' if os.name == 'nt' else 'clear')
+    
+    def _display_loop(self):
+        """显示主循环"""
+        buffer = ""
+        
+        while not self.stop_event.is_set():
+            try:
+                # 从队列获取消息，设置超时以便检查停止事件
+                message = self.message_queue.get(timeout=0.1)
+                
+                # 将消息添加到缓冲区
+                buffer += message
+                
+                # 清空屏幕并显示缓冲区内容
+                self.clear_screen()
+                print(buffer, end='', flush=True)
+                
+                # 标记消息已处理
+                self.message_queue.task_done()
+                
+            except queue.Empty:
+                # 队列为空，继续循环
+                continue
+            except Exception as e:
+                logger.error(f"显示消息时出错: {str(e)}")
+                continue
+
+class SimpleDisplay:
+    """简单显示界面，直接输出到控制台"""
+    
+    def __init__(self):
+        """初始化简单显示界面"""
+        logger.info("简单显示界面初始化完成")
+    
+    def start(self):
+        """启动显示界面"""
+        logger.info("简单显示界面已启动")
+    
+    def stop(self):
+        """停止显示界面"""
+        logger.info("简单显示界面已停止")
+    
+    def add_message(self, message: str):
+        """添加消息到显示"""
+        print(message, end='', flush=True)
+
+class FileDisplay:
+    """文件显示界面，将辩论内容保存到文件"""
+    
+    def __init__(self, output_dir: str = None):
+        """
+        初始化文件显示界面
+        
+        Args:
+            output_dir: 输出目录
+        """
+        self.output_dir = output_dir or os.path.join(OUTPUT_DIR, "辩论记录")
+        os.makedirs(self.output_dir, exist_ok=True)
+        
+        self.current_file = None
+        self.file_handle = None
+        
+        logger.info("文件显示界面初始化完成")
+    
+    def start(self, debate_id: str = None):
+        """
+        启动文件显示���面
+        
+        Args:
+            debate_id: 辩论ID，用于生成文件名
+        """
+        if self.file_handle:
+            logger.warning("文件显示界面已经在运行中")
+            return
+        
+        # 生成文件名
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        if debate_id:
+            filename = f"{debate_id}_实时记录.txt"
+        else:
+            filename = f"辩论记录_{timestamp}.txt"
+        
+        self.current_file = os.path.join(self.output_dir, filename)
+        
+        # 打开文件
+        self.file_handle = open(self.current_file, 'w', encoding='utf-8')
+        
+        logger.info(f"文件显示界面已启动，输出文件: {self.current_file}")
+    
+    def stop(self):
+        """停止文件显示界面"""
+        if not self.file_handle:
+            logger.warning("文件显示界面未在运行")
+            return
+        
+        # 关闭文件
+        self.file_handle.close()
+        self.file_handle = None
+        
+        logger.info(f"文件显示界面已停止，输出文件: {self.current_file}")
+        self.current_file = None
+    
+    def add_message(self, message: str):
+        """添加消息到文件"""
+        if not self.file_handle:
+            logger.warning("文件显示界面未在运行，无法添加消息")
+            return
+        
+        try:
+            self.file_handle.write(message)
+            self.file_handle.flush()
+        except Exception as e:
+            logger.error(f"写入文件时出错: {str(e)}")
+
+class CompositeDisplay:
+    """复合显示界面，可以同时使用多种显示方式"""
+    
+    def __init__(self, displays: list = None):
+        """
+        初始化复合显示界面
+        
+        Args:
+            displays: 显示界面列表
+        """
+        self.displays = displays or []
+        
+        logger.info("复合显示界面初始化完成")
+    
+    def add_display(self, display):
+        """添加显示界面"""
+        self.displays.append(display)
+        logger.info("已添加显示界面")
+    
+    def start(self, **kwargs):
+        """启动所有显示界面"""
+        for display in self.displays:
+            try:
+                if hasattr(display, 'start'):
+                    if isinstance(display, FileDisplay):
+                        display.start(**kwargs)
+                    else:
+                        display.start()
+            except Exception as e:
+                logger.error(f"启动显示界面时出错: {str(e)}")
+        
+        logger.info("所有显示界面已启动")
+    
+    def stop(self):
+        """停止所有显示界面"""
+        for display in self.displays:
+            try:
+                if hasattr(display, 'stop'):
+                    display.stop()
+            except Exception as e:
+                logger.error(f"停止显示界面时出错: {str(e)}")
+        
+        logger.info("所有显示界面已停止")
+    
+    def add_message(self, message: str):
+        """添加消息到所有显示界面"""
+        for display in self.displays:
+            try:
+                if hasattr(display, 'add_message'):
+                    display.add_message(message)
+            except Exception as e:
+                logger.error(f"添加消息到显示界面时出错: {str(e)}")
+
+class DisplayManager:
+    """显示管理器，统一管理所有显示界面"""
+    
+    def __init__(self, display_type: str = "simple"):
+        """
+        初始化显示管理器
+        
+        Args:
+            display_type: 显示类型 ('simple', 'console', 'file', 'composite')
+        """
+        self.display_type = display_type
+        self.display = None
+        
+        # 根据类型创建显示界面
+        if display_type == "simple":
+            self.display = SimpleDisplay()
+        elif display_type == "console":
+            self.display = ConsoleDisplay()
+        elif display_type == "file":
+            self.display = FileDisplay()
+        elif display_type == "composite":
+            # 复合显示，包含简单显示和文件显示
+            simple_display = SimpleDisplay()
+            file_display = FileDisplay()
+            self.display = CompositeDisplay([simple_display, file_display])
+        else:
+            logger.warning(f"不支持的显示类型: {display_type}，使用简单显示")
+            self.display = SimpleDisplay()
+        
+        logger.info(f"显示管理器初始化完成，显示类型: {display_type}")
+    
+    def start(self, **kwargs):
+        """启动显示界面"""
+        if self.display:
+            self.display.start(**kwargs)
+    
+    def stop(self):
+        """停止显示界面"""
+        if self.display:
+            self.display.stop()
+    
+    def add_message(self, message: str):
+        """添加消息到显示界面"""
+        if self.display:
+            self.display.add_message(message)
+
+# 测试代码
+if __name__ == "__main__":
+    # 测试简单��示
+    print("=== 测试简单显示 ===")
+    simple_display = DisplayManager("simple")
+    simple_display.start()
+    
+    for i in range(5):
+        simple_display.add_message(f"简单显示消息 {i}\n")
+        time.sleep(0.5)
+    
+    simple_display.stop()
+    
+    # 测试文件显示
+    print("\n=== 测试文件显示 ===")
+    file_display = DisplayManager("file")
+    file_display.start(debate_id="test_debate")
+    
+    for i in range(5):
+        file_display.add_message(f"文件显示消息 {i}\n")
+        time.sleep(0.5)
+    
+    file_display.stop()
+    
+    # 测试复合显示
+    print("\n=== 测试复合显示 ===")
+    composite_display = DisplayManager("composite")
+    composite_display.start(debate_id="test_composite")
+    
+    for i in range(5):
+        composite_display.add_message(f"复合显示消息 {i}\n")
+        time.sleep(0.5)
+    
+    composite_display.stop() 

src/旧文件/5_GUI测试.py

@@ -0,0 +1,289 @@
+# -*- coding: utf-8 -*-
+"""
+GUI测试程序
+用于验证流式输出功能
+"""
+
+import os
+import sys
+import threading
+import logging
+from tkinter import *
+from tkinter import ttk, scrolledtext, messagebox
+from tkinter.filedialog import asksaveasfilename
+import importlib.util
+
+# 在代码开头强制设置终端编码为UTF-8
+os.system('chcp 65001 > nul')
+
+# 获取当前脚本文件所在目录的绝对路径
+current_script_dir = os.path.dirname(os.path.abspath(__file__))
+
+# 项目根目录 (即 '20250907_大模型辩论' 目录, 是 'src' 的上一级)
+project_root = os.path.dirname(current_script_dir)
+
+# 定义数据输入、输出和日志目录
+DATA_DIR = os.path.join(project_root, 'data')
+OUTPUT_DIR = os.path.join(project_root, 'output')
+LOGS_DIR = os.path.join(project_root, 'logs')
+
+# 确保目录存在
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+os.makedirs(LOGS_DIR, exist_ok=True)
+
+# 配置日志
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler(os.path.join(LOGS_DIR, 'GUI测试日志.log'), encoding='utf-8'),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# 捕获警告并记录到日志
+logging.captureWarnings(True)
+
+# 导入自定义模块
+try:
+    # 动态导入模型接口模块
+    model_interface_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "2_模型接口.py")
+    model_interface_spec = importlib.util.spec_from_file_location("model_interface", model_interface_path)
+    model_interface = importlib.util.module_from_spec(model_interface_spec)
+    model_interface_spec.loader.exec_module(model_interface)
+    
+    # 从模块中获取需要的类
+    ModelManager = model_interface.ModelManager
+    
+except ImportError as e:
+    logger.error(f"导入模块失败: {str(e)}")
+    print("请确保所有模块文件都在同一目录下")
+    sys.exit(1)
+
+class StreamOutputGUI:
+    """流式输出GUI界面"""
+    
+    def __init__(self, root):
+        self.root = root
+        self.root.title("AI大模型流式输出测试")
+        self.root.geometry("800x600")
+        
+        # API密钥
+        self.api_key = "ms-b4690538-3224-493a-8f5b-4073d527f788"
+        
+        # 初始化模型管理器
+        self.model_manager = ModelManager(self.api_key)
+        
+        # 当前使用的模型
+        self.current_model = "glm45"
+        
+        # 是否正在生成
+        self.is_generating = False
+        
+        # 创建界面
+        self.create_widgets()
+        
+        logger.info("GUI界面初始化完成")
+    
+    def create_widgets(self):
+        """创建界面组件"""
+        # 主框架
+        main_frame = ttk.Frame(self.root, padding="10")
+        main_frame.grid(row=0, column=0, sticky=(W, E, N, S))
+        
+        # 配置网格权重
+        self.root.columnconfigure(0, weight=1)
+        self.root.rowconfigure(0, weight=1)
+        main_frame.columnconfigure(1, weight=1)
+        main_frame.rowconfigure(2, weight=1)
+        
+        # 模型选择
+        ttk.Label(main_frame, text="选择模型:").grid(row=0, column=0, sticky=W, padx=(0, 10))
+        self.model_var = StringVar(value="glm45")
+        model_combo = ttk.Combobox(main_frame, textvariable=self.model_var, 
+                                  values=["glm45", "deepseek_v31"], state="readonly", width=15)
+        model_combo.grid(row=0, column=1, sticky=W, padx=(0, 10))
+        model_combo.bind("<<ComboboxSelected>>", self.on_model_change)
+        
+        # 输入框
+        ttk.Label(main_frame, text="输入提示:").grid(row=1, column=0, sticky=W, padx=(0, 10), pady=(10, 0))
+        self.input_text = scrolledtext.ScrolledText(main_frame, height=3, width=60)
+        self.input_text.grid(row=1, column=1, columnspan=2, sticky=(W, E), pady=(10, 0))
+        self.input_text.insert("1.0", "请用100字介绍一下人工智能的发展历程")
+        
+        # 控制按钮框架
+        button_frame = ttk.Frame(main_frame)
+        button_frame.grid(row=2, column=0, columnspan=3, sticky=(W, E), pady=(10, 0))
+        
+        # 开始按钮
+        self.start_button = ttk.Button(button_frame, text="开始生成", command=self.start_generation)
+        self.start_button.pack(side=LEFT, padx=(0, 10))
+        
+        # 停止按钮
+        self.stop_button = ttk.Button(button_frame, text="停止生成", command=self.stop_generation, state=DISABLED)
+        self.stop_button.pack(side=LEFT, padx=(0, 10))
+        
+        # 清空按钮
+        ttk.Button(button_frame, text="清空输出", command=self.clear_output).pack(side=LEFT, padx=(0, 10))
+        
+        # 保存按钮
+        ttk.Button(button_frame, text="保存输出", command=self.save_output).pack(side=LEFT, padx=(0, 10))
+        
+        # 输出框
+        ttk.Label(main_frame, text="输出结果:").grid(row=3, column=0, sticky=W, padx=(0, 10), pady=(10, 0))
+        self.output_text = scrolledtext.ScrolledText(main_frame, height=20, width=80)
+        self.output_text.grid(row=4, column=0, columnspan=3, sticky=(W, E, N, S), pady=(5, 0))
+        
+        # 状态栏
+        self.status_var = StringVar(value="就绪")
+        status_bar = ttk.Label(main_frame, textvariable=self.status_var, relief=SUNKEN, anchor=W)
+        status_bar.grid(row=5, column=0, columnspan=3, sticky=(W, E), pady=(10, 0))
+    
+    def on_model_change(self, event=None):
+        """模型选择改变事件"""
+        self.current_model = self.model_var.get()
+        logger.info(f"切换模型为: {self.current_model}")
+        self.status_var.set(f"已选择模型: {self.current_model}")
+    
+    def start_generation(self):
+        """开始生成"""
+        if self.is_generating:
+            return
+        
+        # 获取输入文本
+        prompt = self.input_text.get("1.0", END).strip()
+        if not prompt:
+            messagebox.showwarning("警告", "请输入提示文本")
+            return
+        
+        # 更新界面状态
+        self.is_generating = True
+        self.start_button.config(state=DISABLED)
+        self.stop_button.config(state=NORMAL)
+        self.status_var.set("正在生成...")
+        
+        # 清空输出框
+        self.output_text.delete("1.0", END)
+        
+        # 在新线程中执行生成任务
+        thread = threading.Thread(target=self.generate_content, args=(prompt,))
+        thread.daemon = True
+        thread.start()
+        
+        logger.info(f"开始生成内容，模型: {self.current_model}，提示: {prompt}")
+    
+    def stop_generation(self):
+        """停止生成"""
+        self.is_generating = False
+        self.start_button.config(state=NORMAL)
+        self.stop_button.config(state=DISABLED)
+        self.status_var.set("已停止生成")
+        logger.info("停止生成")
+    
+    def generate_content(self, prompt):
+        """生成内容"""
+        try:
+            # 获取模型接口
+            model = self.model_manager.get_model(self.current_model)
+            
+            # 构造消息
+            messages = [{"role": "user", "content": prompt}]
+            
+            # 定义流式输出回调函数
+            def stream_callback(content):
+                if self.is_generating:
+                    # 在主线程中更新界面
+                    self.root.after(0, self.append_output, content)
+                else:
+                    # 如果已停止生成，则中断
+                    return False
+            
+            # 调用流式输出方法
+            full_response = model.chat_stream(messages, stream_callback)
+            
+            # 生成完成后更新界面
+            self.root.after(0, self.generation_completed)
+            
+            logger.info(f"生成完成，响应长度: {len(full_response)} 字符")
+            
+        except Exception as e:
+            logger.error(f"生成内容时出错: {str(e)}")
+            self.root.after(0, self.generation_error, str(e))
+    
+    def append_output(self, content):
+        """追加输出内容"""
+        if self.is_generating:
+            self.output_text.insert(END, content)
+            self.output_text.see(END)  # 滚动到末尾
+    
+    def generation_completed(self):
+        """生成完成"""
+        self.is_generating = False
+        self.start_button.config(state=NORMAL)
+        self.stop_button.config(state=DISABLED)
+        self.status_var.set("生成完成")
+        logger.info("生成完成")
+    
+    def generation_error(self, error_msg):
+        """生成出错"""
+        self.is_generating = False
+        self.start_button.config(state=NORMAL)
+        self.stop_button.config(state=DISABLED)
+        self.status_var.set("生成出错")
+        self.output_text.insert(END, f"\n[错误] {error_msg}\n")
+        logger.error(f"生成出错: {error_msg}")
+        messagebox.showerror("错误", f"生成内容时出错:\n{error_msg}")
+    
+    def clear_output(self):
+        """清空输出"""
+        self.output_text.delete("1.0", END)
+        self.status_var.set("输出已清空")
+        logger.info("清空输出")
+    
+    def save_output(self):
+        """保存输出"""
+        content = self.output_text.get("1.0", END)
+        if not content.strip():
+            messagebox.showinfo("提示", "没有内容可保存")
+            return
+        
+        try:
+            filename = asksaveasfilename(
+                defaultextension=".txt",
+                filetypes=[("文本文件", "*.txt"), ("所有文件", "*.*")],
+                title="保存输出内容"
+            )
+            if filename:
+                with open(filename, "w", encoding="utf-8") as f:
+                    f.write(content)
+                self.status_var.set(f"内容已保存到: {filename}")
+                logger.info(f"内容已保存到: {filename}")
+        except Exception as e:
+            logger.error(f"保存文件时出错: {str(e)}")
+            messagebox.showerror("错误", f"保存文件时出错:\n{str(e)}")
+
+def main():
+    """主函数"""
+    # 创建根窗口
+    root = Tk()
+    
+    # 创建GUI应用
+    app = StreamOutputGUI(root)
+    
+    # 设置窗口关闭事件
+    def on_closing():
+        if app.is_generating:
+            if messagebox.askokcancel("确认", "正在生成内容，确定要退出吗？"):
+                app.stop_generation()
+                root.destroy()
+        else:
+            root.destroy()
+    
+    root.protocol("WM_DELETE_WINDOW", on_closing)
+    
+    # 运行主循环
+    root.mainloop()
+
+if __name__ == "__main__":
+    main() 

src/旧文件/6_辩论系统GUI.py

@@ -0,0 +1,732 @@
+# -*- coding: utf-8 -*-
+"""
+AI大模型辩论系统GUI版本
+提供图形用户界面的辩论系统
+"""
+
+import os
+import sys
+import threading
+import time
+import json
+import logging
+from datetime import datetime
+from tkinter import *
+from tkinter import ttk, scrolledtext, messagebox, filedialog
+import importlib.util
+
+# 在代码开头强制设置终端编码为UTF-8
+os.system('chcp 65001 > nul')
+
+# 获取当前脚本文件所在目录的绝对路径
+current_script_dir = os.path.dirname(os.path.abspath(__file__))
+
+# 项目根目录 (即 '20250907_大模型辩论' 目录, 是 'src' 的上一级)
+project_root = os.path.dirname(current_script_dir)
+
+# 定义数据输入、输出和日志目录
+DATA_DIR = os.path.join(project_root, 'data')
+OUTPUT_DIR = os.path.join(project_root, 'output')
+LOGS_DIR = os.path.join(project_root, 'logs')
+
+# 确保目录存在
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+os.makedirs(LOGS_DIR, exist_ok=True)
+
+# 配置日志
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler(os.path.join(LOGS_DIR, '辩论系统GUI日志.log'), encoding='utf-8'),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# 捕获警告并记录到日志
+logging.captureWarnings(True)
+
+# 导入自定义模块
+try:
+    # 动态导入模型接口模块
+    model_interface_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "2_模型接口.py")
+    model_interface_spec = importlib.util.spec_from_file_location("model_interface", model_interface_path)
+    model_interface = importlib.util.module_from_spec(model_interface_spec)
+    model_interface_spec.loader.exec_module(model_interface)
+    
+    # 动态导入辩论控制器模块
+    debate_controller_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "3_辩论控制器.py")
+    debate_controller_spec = importlib.util.spec_from_file_location("debate_controller", debate_controller_path)
+    debate_controller = importlib.util.module_from_spec(debate_controller_spec)
+    debate_controller_spec.loader.exec_module(debate_controller)
+    
+    # 从模块中获取需要的类
+    ModelManager = model_interface.ModelManager
+    DebateMessage = debate_controller.DebateMessage
+    DebateSession = debate_controller.DebateSession
+    
+except ImportError as e:
+    logger.error(f"导入模块失败: {str(e)}")
+    messagebox.showerror("错误", f"导入模块失败: {str(e)}\n请确保所有模块文件都在同一目录下")
+    sys.exit(1)
+
+class DebateSystemGUI:
+    """AI大模型辩论系统GUI版本"""
+    
+    def __init__(self, root):
+        self.root = root
+        self.root.title("AI大模型辩论系统")
+        self.root.geometry("1000x700")
+        self.root.minsize(800, 600)
+        
+        # API密钥
+        self.api_key = "ms-b4690538-3224-493a-8f5b-4073d527f788"
+        
+        # 初始化模型管理器
+        self.model_manager = ModelManager(self.api_key)
+        
+        # 辩论会话
+        self.debate_session = None
+        
+        # 是否正在辩论
+        self.is_debating = False
+        
+        # 暂停标志
+        self.is_paused = False
+        
+        # 创建界面
+        self.create_widgets()
+        
+        logger.info("AI大模型辩论系统GUI初始化完成")
+    
+    def create_widgets(self):
+        """创建界面组件"""
+        # 创建菜单栏
+        self.create_menu()
+        
+        # 主框架
+        main_frame = ttk.Frame(self.root, padding="10")
+        main_frame.pack(fill=BOTH, expand=True)
+        
+        # 配置网格权重
+        main_frame.columnconfigure(1, weight=1)
+        main_frame.rowconfigure(0, weight=0)
+        main_frame.rowconfigure(1, weight=1)
+        
+        # 参数设置框架
+        settings_frame = ttk.LabelFrame(main_frame, text="辩论参数设置", padding="10")
+        settings_frame.grid(row=0, column=0, columnspan=2, sticky=(W, E), pady=(0, 10))
+        settings_frame.columnconfigure(1, weight=1)
+        settings_frame.columnconfigure(3, weight=1)
+        
+        # 辩论话题
+        ttk.Label(settings_frame, text="辩论话题:").grid(row=0, column=0, sticky=W, padx=(0, 5))
+        self.topic_var = StringVar(value="人工智能是否会取代人类的工作")
+        self.topic_entry = ttk.Entry(settings_frame, textvariable=self.topic_var, width=50)
+        self.topic_entry.grid(row=0, column=1, columnspan=3, sticky=(W, E), padx=(0, 10))
+        
+        # 辩论轮数
+        ttk.Label(settings_frame, text="辩论轮数:").grid(row=1, column=0, sticky=W, padx=(0, 5), pady=(5, 0))
+        self.rounds_var = StringVar(value="5")
+        self.rounds_entry = ttk.Entry(settings_frame, textvariable=self.rounds_var, width=10)
+        self.rounds_entry.grid(row=1, column=1, sticky=W, padx=(0, 10), pady=(5, 0))
+        
+        # 首发模型
+        ttk.Label(settings_frame, text="首发模型:").grid(row=1, column=2, sticky=W, padx=(0, 5), pady=(5, 0))
+        self.first_model_var = StringVar(value="glm45")
+        first_model_combo = ttk.Combobox(settings_frame, textvariable=self.first_model_var, 
+                                        values=["glm45", "deepseek_v31"], state="readonly", width=15)
+        first_model_combo.grid(row=1, column=3, sticky=W, pady=(5, 0))
+        
+        # 控制按钮框架
+        control_frame = ttk.Frame(settings_frame)
+        control_frame.grid(row=2, column=0, columnspan=4, sticky=(W, E), pady=(10, 0))
+        
+        # 开始辩论按钮
+        self.start_button = ttk.Button(control_frame, text="开始辩论", command=self.start_debate)
+        self.start_button.pack(side=LEFT, padx=(0, 10))
+        
+        # 暂停/继续按钮
+        self.pause_button = ttk.Button(control_frame, text="暂停辩论", command=self.toggle_pause, state=DISABLED)
+        self.pause_button.pack(side=LEFT, padx=(0, 10))
+        
+        # 停止辩论按钮
+        self.stop_button = ttk.Button(control_frame, text="停止辩论", command=self.stop_debate, state=DISABLED)
+        self.stop_button.pack(side=LEFT, padx=(0, 10))
+        
+        # 清空输出按钮
+        ttk.Button(control_frame, text="清空输出", command=self.clear_output).pack(side=LEFT, padx=(0, 10))
+        
+        # 辩论内容显示框架
+        debate_frame = ttk.LabelFrame(main_frame, text="辩论内容", padding="10")
+        debate_frame.grid(row=1, column=0, columnspan=2, sticky=(W, E, N, S), pady=(0, 10))
+        debate_frame.columnconfigure(0, weight=1)
+        debate_frame.rowconfigure(0, weight=1)
+        
+        # 辩论内容显示区域
+        self.debate_text = scrolledtext.ScrolledText(debate_frame, wrap=WORD, state=DISABLED)
+        self.debate_text.grid(row=0, column=0, sticky=(W, E, N, S))
+        
+        # 状态栏
+        self.status_var = StringVar(value="就绪")
+        status_bar = ttk.Label(main_frame, textvariable=self.status_var, relief=SUNKEN, anchor=W)
+        status_bar.grid(row=2, column=0, columnspan=2, sticky=(W, E))
+    
+    def create_menu(self):
+        """创建菜单栏"""
+        menubar = Menu(self.root)
+        self.root.config(menu=menubar)
+        
+        # 文件菜单
+        file_menu = Menu(menubar, tearoff=0)
+        menubar.add_cascade(label="文件", menu=file_menu)
+        file_menu.add_command(label="保存辩论记录", command=self.save_debate_record)
+        file_menu.add_command(label="查看历史记录", command=self.view_history)
+        file_menu.add_separator()
+        file_menu.add_command(label="退出", command=self.on_closing)
+        
+        # 设置菜单
+        settings_menu = Menu(menubar, tearoff=0)
+        menubar.add_cascade(label="设置", menu=settings_menu)
+        settings_menu.add_command(label="API密钥设置", command=self.set_api_key)
+        
+        # 帮助菜单
+        help_menu = Menu(menubar, tearoff=0)
+        menubar.add_cascade(label="帮助", menu=help_menu)
+        help_menu.add_command(label="关于", command=self.show_about)
+    
+    def start_debate(self):
+        """开始辩论"""
+        if self.is_debating:
+            return
+        
+        # 获取参数
+        topic = self.topic_var.get().strip()
+        if not topic:
+            messagebox.showwarning("警告", "请输入辩论话题")
+            return
+        
+        try:
+            rounds = int(self.rounds_var.get())
+            if rounds < 1 or rounds > 10:
+                messagebox.showwarning("警告", "辩论轮数必须在1-10之间")
+                return
+        except ValueError:
+            messagebox.showwarning("警告", "请输入有效的辩论轮数")
+            return
+        
+        first_model = self.first_model_var.get()
+        
+        # 更新界面状态
+        self.is_debating = True
+        self.is_paused = False
+        self.start_button.config(state=DISABLED)
+        self.pause_button.config(state=NORMAL, text="暂停辩论")
+        self.stop_button.config(state=NORMAL)
+        self.topic_entry.config(state=DISABLED)
+        self.rounds_entry.config(state=DISABLED)
+        self.first_model_var.set(first_model)
+        
+        # 清空输出
+        self.clear_output()
+        
+        # 显示辩论开始信息
+        self.append_output("=" * 50 + "\n")
+        self.append_output("AI大模型辩论系统\n")
+        self.append_output("=" * 50 + "\n\n")
+        self.append_output(f"辩论话题: {topic}\n")
+        self.append_output(f"辩论轮数: {rounds}\n")
+        self.append_output(f"首发模型: {first_model}\n")
+        self.append_output("\n辩论即将开始...\n\n")
+        
+        # 更新状态栏
+        self.status_var.set("正在辩论中...")
+        
+        # 在新线程中执行辩论任务
+        thread = threading.Thread(target=self.run_debate, args=(topic, rounds, first_model))
+        thread.daemon = True
+        thread.start()
+        
+        logger.info(f"开始辩论，���题: {topic}，轮数: {rounds}，首发模型: {first_model}")
+    
+    def run_debate(self, topic, rounds, first_model):
+        """运行辩论"""
+        try:
+            # 创建辩论会话
+            self.debate_session = DebateSession(topic, rounds, first_model)
+            
+            # 确定模型顺序
+            model_a_name = first_model
+            model_b_name = 'deepseek_v31' if model_a_name == 'glm45' else 'glm45'
+            
+            # 获取模型接口
+            model_a = self.model_manager.get_model(model_a_name)
+            model_b = self.model_manager.get_model(model_b_name)
+            
+            # 构建初始提示
+            initial_prompt_a = f"你将作为正方，就以下话题进行辩论：{topic}。请提出你的主要论点。"
+            initial_prompt_b = f"你将作为反方，就以下话题进行辩论：{topic}。请针对对方的论点进行反驳。"
+            
+            # 更新状态
+            self.debate_session.current_round = 1
+            self.debate_session.start_time = datetime.now()
+            
+            # 显示开始信息
+            self.root.after(0, self.append_output, f"=== 辩论开始 ===\n话题: {topic}\n")
+            self.root.after(0, self.append_output, f"--- 第1轮 ---\n")
+            
+            # 第一轮：模型A提出论点
+            if not self.is_debating:
+                return
+            
+            # 等待暂停
+            while self.is_paused and self.is_debating:
+                time.sleep(0.1)
+            
+            if not self.is_debating:
+                return
+            
+            # 模型A发言
+            self.root.after(0, self.append_output, f"{model_a_name} (正方): ")
+            response_a = self.get_model_response(model_a, [{"role": "user", "content": initial_prompt_a}])
+            self.root.after(0, self.append_output, f"{response_a}\n\n")
+            
+            # 记录消息
+            self.debate_session.add_message(DebateMessage("user", initial_prompt_a, "system"))
+            self.debate_session.add_message(DebateMessage("assistant", response_a, model_a_name))
+            
+            # 后续轮次
+            for round_num in range(2, rounds + 1):
+                # 检查是否继续
+                if not self.is_debating:
+                    break
+                
+                # 等待暂停
+                while self.is_paused and self.is_debating:
+                    time.sleep(0.1)
+                
+                if not self.is_debating:
+                    break
+                
+                self.debate_session.current_round = round_num
+                self.root.after(0, self.append_output, f"--- 第{round_num}轮 ---\n")
+                
+                # 模型B反驳
+                self.root.after(0, self.append_output, f"{model_b_name} (反方): ")
+                prompt_b = f"{initial_prompt_b}\n\n对方的论点: {response_a}\n\n请进行反驳。"
+                response_b = self.get_model_response(model_b, 
+                                                    self.debate_session.get_messages_for_model(model_b_name) + 
+                                                    [{"role": "user", "content": prompt_b}])
+                self.root.after(0, self.append_output, f"{response_b}\n\n")
+                
+                # 记录消息
+                self.debate_session.add_message(DebateMessage("user", prompt_b, "system"))
+                self.debate_session.add_message(DebateMessage("assistant", response_b, model_b_name))
+                
+                # 检查是否继续
+                if not self.is_debating:
+                    break
+                
+                # 等待暂停
+                while self.is_paused and self.is_debating:
+                    time.sleep(0.1)
+                
+                if not self.is_debating:
+                    break
+                
+                # 模型A回应
+                self.root.after(0, self.append_output, f"{model_a_name} (正方): ")
+                prompt_a = f"请针对对方的反驳进行回应：{response_b}"
+                response_a = self.get_model_response(model_a, 
+                                                    self.debate_session.get_messages_for_model(model_a_name) + 
+                                                    [{"role": "user", "content": prompt_a}])
+                self.root.after(0, self.append_output, f"{response_a}\n\n")
+                
+                # 记录消息
+                self.debate_session.add_message(DebateMessage("user", prompt_a, "system"))
+                self.debate_session.add_message(DebateMessage("assistant", response_a, model_a_name))
+            
+            # 辩论结束
+            if self.is_debating:
+                self.debate_session.end_time = datetime.now()
+                self.debate_session.is_active = False
+                self.root.after(0, self.append_output, "=== 辩论结束 ===\n")
+                self.root.after(0, self.debate_completed)
+                
+                # 保存辩论记录
+                self.save_debate_record_to_file()
+                
+                logger.info("辩论结束")
+        
+        except Exception as e:
+            logger.error(f"辩论过程中出错: {str(e)}")
+            self.root.after(0, self.debate_error, str(e))
+    
+    def get_model_response(self, model, messages):
+        """获取模型响应"""
+        try:
+            # 使用列表来存储流式输出的内容（避免作用域问题）
+            full_response = []
+            
+            def stream_callback(content):
+                if self.is_debating and not self.is_paused:
+                    self.root.after(0, self.append_output, content)
+                    full_response.append(content)
+                # 注意：这里不需要return False，因为模型接口会处理流式输出的中断
+            
+            # 调用流式输出方法
+            model.chat_stream(messages, stream_callback)
+            return "".join(full_response)
+        except Exception as e:
+            logger.error(f"获取模型响应时出错: {str(e)}")
+            return f"[错误] {str(e)}"
+    
+    def toggle_pause(self):
+        """切换暂停状态"""
+        if not self.is_debating:
+            return
+        
+        self.is_paused = not self.is_paused
+        if self.is_paused:
+            self.pause_button.config(text="继续辩论")
+            self.status_var.set("辩论已暂停")
+            logger.info("辩论已暂停")
+        else:
+            self.pause_button.config(text="暂停辩论")
+            self.status_var.set("正在辩论中...")
+            logger.info("辩论已继续")
+    
+    def stop_debate(self):
+        """停止辩论"""
+        self.is_debating = False
+        self.is_paused = False
+        self.start_button.config(state=NORMAL)
+        self.pause_button.config(state=DISABLED, text="暂停辩论")
+        self.stop_button.config(state=DISABLED)
+        self.topic_entry.config(state=NORMAL)
+        self.rounds_entry.config(state=NORMAL)
+        self.status_var.set("辩论已停止")
+        self.append_output("\n用户手动停止辩论\n")
+        logger.info("辩论已停止")
+    
+    def debate_completed(self):
+        """辩论完成"""
+        self.is_debating = False
+        self.is_paused = False
+        self.start_button.config(state=NORMAL)
+        self.pause_button.config(state=DISABLED, text="暂停辩论")
+        self.stop_button.config(state=DISABLED)
+        self.topic_entry.config(state=NORMAL)
+        self.rounds_entry.config(state=NORMAL)
+        self.status_var.set("辩论已完成")
+        logger.info("辩论已完成")
+    
+    def debate_error(self, error_msg):
+        """辩论出错"""
+        self.is_debating = False
+        self.is_paused = False
+        self.start_button.config(state=NORMAL)
+        self.pause_button.config(state=DISABLED, text="暂停辩论")
+        self.stop_button.config(state=DISABLED)
+        self.topic_entry.config(state=NORMAL)
+        self.rounds_entry.config(state=NORMAL)
+        self.status_var.set("辩论出错")
+        self.append_output(f"\n[错误] {error_msg}\n")
+        logger.error(f"辩论出错: {error_msg}")
+        messagebox.showerror("错误", f"辩论过程中出错:\n{error_msg}")
+    
+    def append_output(self, content):
+        """追加输出内容"""
+        self.debate_text.config(state=NORMAL)
+        self.debate_text.insert(END, content)
+        self.debate_text.see(END)  # 滚动到末尾
+        self.debate_text.config(state=DISABLED)
+    
+    def clear_output(self):
+        """清空输出"""
+        self.debate_text.config(state=NORMAL)
+        self.debate_text.delete("1.0", END)
+        self.debate_text.config(state=DISABLED)
+        logger.info("清空输出")
+    
+    def save_debate_record_to_file(self):
+        """保存辩论记录到文件"""
+        if not self.debate_session:
+            return
+        
+        try:
+            # 创建输出文件路径
+            output_dir = os.path.join(OUTPUT_DIR, "辩论记录")
+            os.makedirs(output_dir, exist_ok=True)
+            
+            file_path = os.path.join(output_dir, f"{self.debate_session.debate_id}.json")
+            
+            # 保存辩论记录
+            self.debate_session.save_to_file(file_path)
+            
+            logger.info(f"辩论记录已保存: {file_path}")
+        except Exception as e:
+            logger.error(f"保存辩论记录时出错: {str(e)}")
+    
+    def save_debate_record(self):
+        """保存当前辩论记录"""
+        if not self.debate_session:
+            messagebox.showinfo("提示", "当前没有辩论记录可保存")
+            return
+        
+        try:
+            # 选择保存位置
+            filename = filedialog.asksaveasfilename(
+                defaultextension=".json",
+                filetypes=[("JSON文件", "*.json"), ("所有文件", "*.*")],
+                title="��存辩论记录"
+            )
+            
+            if filename:
+                # 保存辩论记录
+                self.debate_session.save_to_file(filename)
+                self.status_var.set(f"辩论记录已保存到: {filename}")
+                logger.info(f"辩论记录已保存到: {filename}")
+                messagebox.showinfo("成功", f"辩论记录已保存到:\n{filename}")
+        except Exception as e:
+            logger.error(f"保存辩论记录时出错: {str(e)}")
+            messagebox.showerror("错误", f"保存辩论记录时出错:\n{str(e)}")
+    
+    def view_history(self):
+        """查看历史记录"""
+        try:
+            # 获取辩论记录目录
+            debate_records_dir = os.path.join(OUTPUT_DIR, "辩论记录")
+            
+            if not os.path.exists(debate_records_dir):
+                messagebox.showinfo("提示", "暂无辩论记录")
+                return
+            
+            # 获取所有辩论记录文件
+            record_files = [f for f in os.listdir(debate_records_dir) if f.endswith('.json')]
+            
+            if not record_files:
+                messagebox.showinfo("提示", "暂无辩论记录")
+                return
+            
+            # 创建历史记录窗口
+            history_window = Toplevel(self.root)
+            history_window.title("历史辩论记录")
+            history_window.geometry("600x400")
+            history_window.minsize(400, 300)
+            
+            # 创建列表框
+            list_frame = ttk.Frame(history_window, padding="10")
+            list_frame.pack(fill=BOTH, expand=True)
+            
+            list_frame.columnconfigure(0, weight=1)
+            list_frame.rowconfigure(0, weight=1)
+            
+            # 创建列表框和滚动条
+            listbox = Listbox(list_frame)
+            scrollbar = ttk.Scrollbar(list_frame, orient=VERTICAL, command=listbox.yview)
+            listbox.configure(yscrollcommand=scrollbar.set)
+            
+            listbox.grid(row=0, column=0, sticky=(W, E, N, S))
+            scrollbar.grid(row=0, column=1, sticky=(N, S))
+            
+            # 添加记录到列表框
+            for filename in record_files:
+                listbox.insert(END, filename)
+            
+            # 创建按钮框架
+            button_frame = ttk.Frame(history_window, padding="10")
+            button_frame.pack(fill=X)
+            
+            # 查看按钮
+            def view_selected():
+                selection = listbox.curselection()
+                if selection:
+                    filename = listbox.get(selection[0])
+                    file_path = os.path.join(debate_records_dir, filename)
+                    self.display_debate_record(file_path)
+                    history_window.destroy()
+                else:
+                    messagebox.showwarning("警告", "请选择一个记录文件")
+            
+            ttk.Button(button_frame, text="查看", command=view_selected).pack(side=LEFT, padx=(0, 10))
+            
+            # 删除按钮
+            def delete_selected():
+                selection = listbox.curselection()
+                if selection:
+                    filename = listbox.get(selection[0])
+                    if messagebox.askyesno("确认", f"确定要删除记录文件 {filename} 吗？"):
+                        file_path = os.path.join(debate_records_dir, filename)
+                        try:
+                            os.remove(file_path)
+                            listbox.delete(selection[0])
+                            self.status_var.set(f"已删除记录文件: {filename}")
+                            logger.info(f"已删除记录文件: {filename}")
+                        except Exception as e:
+                            logger.error(f"删除记录文件时出错: {str(e)}")
+                            messagebox.showerror("错误", f"删除记录文件时出错:\n{str(e)}")
+                else:
+                    messagebox.showwarning("警告", "请选择一个记录文件")
+            
+            ttk.Button(button_frame, text="删除", command=delete_selected).pack(side=LEFT, padx=(0, 10))
+            
+            # 关闭按钮
+            ttk.Button(button_frame, text="关闭", command=history_window.destroy).pack(side=LEFT)
+            
+        except Exception as e:
+            logger.error(f"查看历史记录时出错: {str(e)}")
+            messagebox.showerror("错误", f"查看历史记录时出错:\n{str(e)}")
+    
+    def display_debate_record(self, file_path):
+        """显示辩论记录"""
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            
+            debate_info = data['debate_info']
+            messages = data['messages']
+            
+            # 创建显示窗口
+            record_window = Toplevel(self.root)
+            record_window.title(f"辩论记录 - {debate_info['debate_id']}")
+            record_window.geometry("800x600")
+            record_window.minsize(600, 400)
+            
+            # 创建文本框和滚动条
+            text_frame = ttk.Frame(record_window, padding="10")
+            text_frame.pack(fill=BOTH, expand=True)
+            
+            text_frame.columnconfigure(0, weight=1)
+            text_frame.rowconfigure(0, weight=1)
+            
+            text_area = scrolledtext.ScrolledText(text_frame, wrap=WORD, state=DISABLED)
+            text_area.grid(row=0, column=0, sticky=(W, E, N, S))
+            
+            # 构建显示内容
+            content = f"=== 辩论记录详情 ===\n"
+            content += f"辩论ID: {debate_info['debate_id']}\n"
+            content += f"话题: {debate_info['topic']}\n"
+            content += f"最大轮数: {debate_info['max_rounds']}\n"
+            content += f"实际轮数: {debate_info['current_round']}\n"
+            content += f"总消息数: {debate_info['total_messages']}\n"
+            
+            if debate_info['start_time']:
+                start_time = datetime.fromisoformat(debate_info['start_time'])
+                content += f"开始时间: {start_time.strftime('%Y-%m-%d %H:%M:%S')}\n"
+            
+            if debate_info['end_time']:
+                end_time = datetime.fromisoformat(debate_info['end_time'])
+                content += f"结束时间: {end_time.strftime('%Y-%m-%d %H:%M:%S')}\n"
+            
+            if debate_info['duration']:
+                duration = int(debate_info['duration'])
+                minutes, seconds = divmod(duration, 60)
+                content += f"持续时间: {minutes}分{seconds}秒\n"
+            
+            content += "\n=== 辩论内容 ===\n\n"
+            
+            for msg in messages:
+                timestamp = datetime.fromisoformat(msg['timestamp'])
+                content += f"[{timestamp.strftime('%H:%M:%S')}] {msg['model_name']}: {msg['content']}\n\n"
+            
+            # 显示内容
+            text_area.config(state=NORMAL)
+            text_area.insert("1.0", content)
+            text_area.config(state=DISABLED)
+            
+        except Exception as e:
+            logger.error(f"显示辩论记录时出错: {str(e)}")
+            messagebox.showerror("错误", f"显示辩论记录时出错:\n{str(e)}")
+    
+    def set_api_key(self):
+        """设置API密钥"""
+        # 创建设置窗口
+        settings_window = Toplevel(self.root)
+        settings_window.title("API密钥设置")
+        settings_window.geometry("400x150")
+        settings_window.resizable(False, False)
+        
+        # 创建输入框
+        frame = ttk.Frame(settings_window, padding="20")
+        frame.pack(fill=BOTH, expand=True)
+        
+        ttk.Label(frame, text="API密钥:").grid(row=0, column=0, sticky=W, pady=(0, 10))
+        
+        api_key_var = StringVar(value=self.api_key)
+        api_key_entry = ttk.Entry(frame, textvariable=api_key_var, width=40, show="*")
+        api_key_entry.grid(row=1, column=0, columnspan=2, sticky=(W, E), pady=(0, 20))
+        
+        # 按钮框架
+        button_frame = ttk.Frame(frame)
+        button_frame.grid(row=2, column=0, columnspan=2, sticky=E)
+        
+        def save_api_key():
+            new_api_key = api_key_var.get().strip()
+            if new_api_key:
+                self.api_key = new_api_key
+                # 重新初始化模型管理器
+                self.model_manager = ModelManager(self.api_key)
+                self.status_var.set("API密钥已更新")
+                logger.info("API密钥已更新")
+                settings_window.destroy()
+            else:
+                messagebox.showwarning("警告", "请输入有效的API密钥")
+        
+        ttk.Button(button_frame, text="保存", command=save_api_key).pack(side=LEFT, padx=(0, 10))
+        ttk.Button(button_frame, text="取消", command=settings_window.destroy).pack(side=LEFT)
+    
+    def show_about(self):
+        """显示关于信息"""
+        about_text = """AI大模型辩论系统 GUI版本
+
+版本: 1.0
+作者: AI开发者
+日期: 2025年9月
+
+本系统支持以下功能:
+- 两个AI大模型实时辩论
+- 流式输出显示
+- 图形用户界面
+- 辩论记录保存和查看
+- 暂停/继续/停止控制
+
+支持的模型:
+- ZhipuAI/GLM-4.5
+- deepseek-ai/DeepSeek-V3.1
+"""
+        messagebox.showinfo("关于", about_text)
+    
+    def on_closing(self):
+        """窗口关闭事件"""
+        if self.is_debating:
+            if messagebox.askokcancel("确认", "正在辩论中，确定要退出吗？"):
+                self.is_debating = False
+                self.root.destroy()
+        else:
+            self.root.destroy()
+
+def main():
+    """主函数"""
+    # 创建根窗口
+    root = Tk()
+    
+    # 设置窗口图标（如果有的话）
+    try:
+        # root.iconbitmap('icon.ico')  # 如果有图标文件可以取消注释
+        pass
+    except:
+        pass
+    
+    # 创建GUI应用
+    app = DebateSystemGUI(root)
+    
+    # 设置窗口关闭事件
+    root.protocol("WM_DELETE_WINDOW", app.on_closing)
+    
+    # 运行主循环
+    root.mainloop()
+
+if __name__ == "__main__":
+    main() 

templates/index.html

@@ -0,0 +1,178 @@
+
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AI大模型辩论系统</title>
+    <style>
+        body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif; margin: 0; background-color: #f0f2f5; color: #333; height: 100vh; display: flex; flex-direction: column; }
+        .container { background-color: white; padding: 20px; border-radius: 8px; box-shadow: 0 4px 12px rgba(0,0,0,0.1); width: 95%; max-width: 1400px; margin: 20px auto; flex-grow: 1; display: flex; flex-direction: column; }
+        .main-layout { display: flex; gap: 20px; flex-grow: 1; min-height: 0; }
+        .sidebar { flex: 0 0 320px; display: flex; flex-direction: column; gap: 15px; }
+        .chat-area { flex: 1; display: flex; flex-direction: column; min-width: 0; }
+        .header { text-align: center; margin-bottom: 20px; flex-shrink: 0; }
+        .header h1 { color: #1a73e8; }
+        .controls, .control-group { margin-bottom: 20px; }
+        .controls { display: flex; gap: 10px; flex-wrap: wrap; align-items: flex-end; }
+        .control-group { flex: 1; min-width: 200px; }
+        label { display: block; margin-bottom: 5px; font-weight: 600; color: #555; }
+        input, select, button, textarea { width: 100%; padding: 10px; border: 1px solid #ddd; border-radius: 6px; box-sizing: border-box; font-size: 16px; }
+        textarea { resize: vertical; }
+        button { background-color: #1a73e8; color: white; border: none; cursor: pointer; transition: background-color 0.3s; }
+        button:hover { background-color: #1558b8; }
+        button:disabled { background-color: #ccc; cursor: not-allowed; }
+        .output-container { background-color: #f8f9fa; border: 1px solid #ddd; border-radius: 8px; padding: 20px; height: 500px; overflow-y: auto; display: flex; flex-direction: column; gap: 15px; }
+        .status { padding: 10px; border-radius: 6px; margin-bottom: 15px; border: 1px solid; }
+        .status.connected { background-color: #e6f4ea; color: #155724; border-color: #c3e6cb; }
+        .status.disconnected { background-color: #f8d7da; color: #721c24; border-color: #f5c6cb; }
+        
+        /* 聊天气泡样式 */
+        .message { display: flex; align-items: flex-start; gap: 10px; max-width: 80%; }
+        .message .avatar { width: 40px; height: 40px; border-radius: 50%; color: white; display: flex; align-items: center; justify-content: center; font-weight: bold; flex-shrink: 0; font-size: 18px; }
+        .message .content { background-color: #ffffff; padding: 10px 15px; border-radius: 18px; box-shadow: 0 1px 2px rgba(0,0,0,0.1); }
+        .message .sender { font-weight: bold; margin-bottom: 5px; color: #333; }
+        .message.glm45 { align-self: flex-start; }
+        .message.glm45 .avatar { background-color: #34a853; } /* Google Green */
+        .message.glm45 .content { border-top-left-radius: 4px; }
+        .message.deepseek_v31 { align-self: flex-end; flex-direction: row-reverse; }
+        .message.deepseek_v31 .avatar { background-color: #4285f4; } /* Google Blue */
+        .message.deepseek_v31 .content { background-color: #e7f3ff; border-top-right-radius: 4px; }
+        .message .text { white-space: pre-wrap; word-wrap: break-word; }
+        .message .text p { margin: 0 0 10px; }
+        .message .text h1, .message .text h2, .message .text h3 { margin: 15px 0 10px; border-bottom: 1px solid #eee; padding-bottom: 5px; }
+        .message .text ul, .message .text ol { padding-left: 20px; }
+        .message .text code { background-color: #eee; padding: 2px 4px; border-radius: 4px; font-family: "SFMono-Regular", Consolas, "Liberation Mono", Menlo, Courier, monospace; }
+        .message .text pre { background-color: #2d2d2d; color: #f8f8f2; padding: 15px; border-radius: 6px; overflow-x: auto; }
+        .message .text pre code { background-color: transparent; padding: 0; }
+        .round-separator { text-align: center; color: #888; font-size: 0.9em; margin: 20px 0; font-weight: 600; }
+
+        /* 响应式设计 - 针对手机等小屏幕设备 */
+        @media (max-width: 768px) {
+            body { padding: 0; }
+            .container { width: 100%; margin: 0; border-radius: 0; padding: 10px; height: 100%; }
+            .main-layout { flex-direction: column; }
+            .sidebar { flex: 0 0 auto; }
+            .header h1 { font-size: 1.5em; }
+            .controls { flex-direction: column; }
+            .control-group { min-width: unset; }
+        }
+    </style>
+    <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/dompurify/dist/purify.min.js"></script>
+</head>
+<body>
+    <div class="container">
+        <div class="header"><h1>AI大模型辩论系统</h1><p>观看两个AI大模型实时辩论</p></div>
+        
+        <div class="main-layout">
+            <div class="sidebar">
+                <div class="control-group"><label for="topic">辩论话题:</label><input type="text" id="topic" value="人工智能是否会取代人类的工作"></div>
+                <div class="control-group">
+                    <label for="initialPrompt">自定义初始提示 (可选):</label>
+                    <textarea id="initialPrompt" rows="6" placeholder="例如：请作为正方，用强势的语气开启辩论..."></textarea>
+                </div>
+                <div class="control-group"><label for="rounds">轮数:</label><input type="number" id="rounds" min="1" max="10" value="5"></div>
+                <div class="control-group"><label for="firstModel">首发模型:</label><select id="firstModel"><option value="glm45">ZhipuAI/GLM-4.5</option><option value="deepseek_v31">deepseek-ai/DeepSeek-V3.1</option></select></div>
+                <div class="controls">
+                    <button id="startBtn" disabled>开始辩论</button>
+                    <button id="stopBtn" disabled>停止辩论</button>
+                </div>
+            </div>
+            <div class="chat-area">
+                <label for="output">辩论实况:</label>
+                <div id="output" class="output-container"></div>
+            </div>
+        </div>
+    </div>
+    <script>
+        let websocket = null, isConnected = false, currentMessageElement = null, currentMessageContent = '';
+        const startBtn = document.getElementById('startBtn'), stopBtn = document.getElementById('stopBtn');
+        const outputDiv = document.getElementById('output');
+        
+        function handleWebSocketMessage(data) {
+            let shouldScroll = Math.abs(outputDiv.scrollHeight - outputDiv.clientHeight - outputDiv.scrollTop) < 10;
+            
+            switch (data.type) {
+                case 'debate_started':
+                    outputDiv.innerHTML = '';
+                    const topicDiv = document.createElement('div');
+                    topicDiv.className = 'round-separator';
+                    topicDiv.innerHTML = `<strong>话题:</strong> ${data.topic}`;
+                    outputDiv.appendChild(topicDiv);
+                    break;
+                case 'round_info':
+                    const separator = document.createElement('div');
+                    separator.className = 'round-separator';
+                    separator.textContent = data.message.trim();
+                    outputDiv.appendChild(separator);
+                    break;
+                case 'model_speaking':
+                    currentMessageContent = ''; // 重置当前消息内容
+                    const messageDiv = document.createElement('div');
+                    messageDiv.className = `message ${data.model}`;
+                    messageDiv.innerHTML = `
+                        <div class="avatar">${data.model.substring(0, 1).toUpperCase()}</div>
+                        <div class="content">
+                            <div class="sender">${data.model} (${data.role})</div>
+                            <div class="text"><i>正在思考...</i></div>
+                        </div>`;
+                    outputDiv.appendChild(messageDiv);
+                    currentMessageElement = messageDiv.querySelector('.text');
+                    break;
+                case 'stream_content':
+                    if (currentMessageElement) {
+                        currentMessageContent += data.content;
+                        currentMessageElement.innerHTML = DOMPurify.sanitize(marked.parse(currentMessageContent));
+                    }
+                    break;
+                case 'stream_end':
+                    currentMessageElement = null;
+                    break;
+                case 'debate_ended':
+                case 'debate_stopped':
+                    const endMsg = document.createElement('div');
+                    endMsg.className = 'round-separator';
+                    endMsg.textContent = data.message;
+                    outputDiv.appendChild(endMsg);
+                    startBtn.disabled = false; stopBtn.disabled = true;
+                    break;
+                case 'error':
+                    outputDiv.innerHTML += `<div class="round-separator" style="color: red;">错误: ${data.message}</div>`;
+                    break;
+            }
+            if(shouldScroll) {
+                outputDiv.scrollTop = outputDiv.scrollHeight;
+            }
+        }
+        
+        function connect() {
+            const wsUrl = `ws://${window.location.host}/ws`;
+            websocket = new WebSocket(wsUrl);
+            websocket.onopen = () => { isConnected = true; startBtn.disabled = false; };
+            websocket.onmessage = (event) => handleWebSocketMessage(JSON.parse(event.data));
+            websocket.onclose = () => { isConnected = false; startBtn.disabled = true; stopBtn.disabled = true; };
+            websocket.onerror = (error) => { console.error('WebSocket Error:', error); };
+        }
+
+        window.addEventListener('load', connect);
+
+        startBtn.addEventListener('click', () => {
+            if (!websocket) return;
+            const message = { 
+                action: "start_debate", 
+                topic: document.getElementById('topic').value, 
+                rounds: parseInt(document.getElementById('rounds').value), 
+                first_model: document.getElementById('firstModel').value,
+                initial_prompt: document.getElementById('initialPrompt').value
+            };
+            websocket.send(JSON.stringify(message));
+            startBtn.disabled = true; stopBtn.disabled = false;
+        });
+        stopBtn.addEventListener('click', () => {
+            if (!websocket) return;
+            websocket.send(JSON.stringify({ action: "stop_debate" }));
+        });
+    </script>
+</body>
+</html>