Upload 15 files

.github/workflows/docker-image.yml

@@ -0,0 +1,44 @@
+name: Docker Image CI
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Set repository owner to lowercase
+        id: repo_owner
+        run: echo "owner_lc=${GITHUB_REPOSITORY_OWNER,,}" >> $GITHUB_ENV
+
+      - name: Build and push Docker image to GHCR
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: ./Dockerfile
+          push: true
+          tags: ghcr.io/${{ env.owner_lc }}/od2api_plus:latest
+
+      - name: Logout from GitHub Container Registry
+        run: docker logout ghcr.io

Dockerfile

@@ -1 +1,33 @@
-FROM ondemand-api-proxy:latest
+# Use official Python base image
+FROM python:3.9-slim
+
+# Set working directory inside the container
+WORKDIR /app
+
+# Copy requirements file
+COPY requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 复制核心应用文件
+COPY app.py .
+COPY auth.py .
+COPY client.py .
+COPY routes.py .
+COPY utils.py .
+COPY config.py .
+COPY retry.py .
+COPY static/ static/
+COPY templates/ templates/
+
+RUN chmod -R 0755 /app
+
+# Expose the port (Flask 默认端口)
+EXPOSE 5000
+
+# 设置 UTF-8 避免中文乱码
+ENV LANG=C.UTF-8
+
+# 启动主程序
+CMD ["python", "app.py"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Drunkweng
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,10 +1,273 @@
----
-title: Ond
-emoji: 🐨
-colorFrom: green
-colorTo: green
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# OnDemand-API-Proxy 代理服务
+
+## 本项目仅供学习交流使用，请勿用于其他用途
+
+一款基于 Flask 的 API 代理服务，提供兼容 OpenAI API 的接口，支持多种大型语言模型，实现多账户轮询和会话管理。
+
+## 功能特点
+
+- **兼容 OpenAI API**：提供标准的 `/v1/models` 和 `/v1/chat/completions` 接口
+- **多模型支持**：支持 GPT-4o、Claude 3.7 Sonnet、Gemini 2.0 Flash 等多种模型
+- **多轮对话**：通过会话管理保持对话上下文
+- **账户轮换**：自动轮询使用多个 on-demand.io 账户，平衡负载
+- **会话管理**：自动处理会话超时和重新连接
+- **统计面板**：提供实时使用统计和图表展示
+- **可配置的认证**：支持通过环境变量或配置文件设置 API 访问令牌
+- **Docker 支持**：易于部署到 Hugging Face Spaces 或其他容器环境
+
+## 支持的模型
+
+服务支持以下模型（部分列表）：
+
+| API 模型名称 | 实际使用模型 |
+|------------|------------|
+| `gpt-4o` | predefined-openai-gpt4o |
+| `gpt-4o-mini` | predefined-openai-gpt4o-mini |
+| `gpt-3.5-turbo` / `gpto3-mini` | predefined-openai-gpto3-mini |
+| `gpt-4-turbo` / `gpt-4.1` | predefined-openai-gpt4.1 |
+| `gpt-4.1-mini` | predefined-openai-gpt4.1-mini |
+| `gpt-4.1-nano` | predefined-openai-gpt4.1-nano |
+| `claude-3.5-sonnet` / `claude-3.7-sonnet` | predefined-claude-3.7-sonnet |
+| `claude-3-opus` | predefined-claude-3-opus |
+| `claude-3-haiku` | predefined-claude-3-haiku |
+| `gemini-1.5-pro` / `gemini-2.0-flash` | predefined-gemini-2.0-flash |
+| `deepseek-v3` | predefined-deepseek-v3 |
+| `deepseek-r1` | predefined-deepseek-r1 |
+
+## 配置说明
+
+### 配置文件 (config.json)
+
+配置文件支持以下参数：
+
+```json
+{
+  "api_access_token": "你的自定义访问令牌",
+  "accounts": [
+    {"email": "账户[email protected]", "password": "密码1"},
+    {"email": "账户[email protected]", "password": "密码2"}
+  ],
+  "session_timeout_minutes": 30,
+  "max_retries": 3,
+  "retry_delay": 1,
+  "request_timeout": 30,
+  "stream_timeout": 120,
+  "rate_limit": 60,
+  "debug_mode": false
+}
+```
+
+### 环境变量
+
+所有配置也可以通过环境变量设置：
+
+- `API_ACCESS_TOKEN`: API 访问令牌
+- `ONDEMAND_ACCOUNTS`: JSON 格式的账户信息
+- `SESSION_TIMEOUT_MINUTES`: 会话超时时间（分钟）
+- `MAX_RETRIES`: 最大重试次数
+- `RETRY_DELAY`: 重试延迟（秒）
+- `REQUEST_TIMEOUT`: 请求超时（秒）
+- `STREAM_TIMEOUT`: 流式请求超时（秒）
+- `RATE_LIMIT`: 速率限制（每分钟请求数）
+- `DEBUG_MODE`: 调试模式（true/false）
+
+## API 接口说明
+
+### 获取模型列表
+
+```
+GET /v1/models
+```
+
+返回支持的模型列表，格式与 OpenAI API 兼容。
+
+### 聊天补全
+
+```
+POST /v1/chat/completions
+```
+
+**请求头：**
+```
+Authorization: Bearer 你的API访问令牌
+Content-Type: application/json
+```
+
+**请求体：**
+```json
+{
+  "model": "gpt-4o",
+  "messages": [
+    {"role": "system", "content": "你是一个有用的助手。"},
+    {"role": "user", "content": "你好，请介绍一下自己。"}
+  ],
+  "temperature": 0.7,
+  "max_tokens": 2000,
+  "stream": false
+}
+```
+
+**参数说明：**
+- `model`: 使用的模型名称
+- `messages`: 对话消息数组
+- `temperature`: 温度参数（0-1）
+- `max_tokens`: 最大生成令牌数
+- `stream`: 是否使用流式响应
+- `top_p`: 核采样参数（0-1）
+- `frequency_penalty`: 频率惩罚（0-2）
+- `presence_penalty`: 存在惩罚（0-2）
+
+## 统计面板
+
+访问根路径 `/` 可以查看使用统计面板，包括：
+
+- 总请求数和成功率
+- Token 使用统计
+- 每日和每小时使用量图表
+- 模型使用情况
+- 最近请求历史
+
+## 部署指南
+
+### Hugging Face Spaces 部署（推荐）
+
+1. **创建 Hugging Face 账户**：
+   - 访问 [https://huggingface.co/](https://huggingface.co/) 注册账户
+
+2. **创建 Space**：
+   - 点击 [创建新的 Space](https://huggingface.co/new-space)
+   - 填写 Space 名称
+   - **重要**：选择 `Docker` 作为 Space 类型
+   - 设置权限（公开或私有）
+
+3. **上传代码**：
+   - 将以下文件上传到你的 Space 代码仓库：
+     - `app.py`（主程序）
+     - `routes.py`（路由定义）
+     - `config.py`（配置管理）
+     - `auth.py`（认证模块）
+     - `client.py`（客户端实现）
+     - `utils.py`（工具函数）
+     - `requirements.txt`（依赖列表）
+     - `Dockerfile`（Docker 配置）
+     - `templates/`（模板目录）
+     - `static/`（静态资源目录）
+
+4. **配置账户信息和 API 访问令牌**：
+   - 进入 Space 的 "Settings" → "Repository secrets"
+   - 添加 `ONDEMAND_ACCOUNTS` Secret：
+     ```json
+     {
+       "accounts": [
+         {"email": "你的邮箱[email protected]", "password": "你的密码1"},
+         {"email": "你的邮箱[email protected]", "password": "你的密码2"}
+       ]
+     }
+     ```
+   - 添加 `API_ACCESS_TOKEN` Secret 设置自定义访问令牌
+     - 如果不设置，将使用默认值 "sk-2api-ondemand-access-token-2025"
+
+5. **可选配置**：
+   - 添加其他环境变量如 `SESSION_TIMEOUT_MINUTES`、`RATE_LIMIT` 等
+
+6. **完成部署**：
+   - Hugging Face 会自动构建 Docker 镜像并部署你的 API
+   - 访问你的 Space URL（如 `https://你的用户名-你的space名称.hf.space`）
+
+### 本地部署
+
+1. **克隆代码**：
+   ```bash
+   git clone https://github.com/你的用户名/ondemand-api-proxy.git
+   cd ondemand-api-proxy
+   ```
+
+2. **安装依赖**：
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. **配置**：
+   - 创建 `config.json` 文件：
+     ```json
+     {
+       "api_access_token": "你的自定义访问令牌",
+       "accounts": [
+         {"email": "账户[email protected]", "password": "密码1"},
+         {"email": "账户[email protected]", "password": "密码2"}
+       ]
+     }
+     ```
+   - 或设置环境变量
+
+4. **启动服务**：
+   ```bash
+   python app.py
+   ```
+   
+5. **访问服务**：
+   - API 接口：`http://localhost:5000/v1/chat/completions`
+   - 统计面板：`http://localhost:5000/`
+
+### Docker 部署
+
+```bash
+# 构建镜像
+docker build -t ondemand-api-proxy .
+
+# 运行容器
+docker run -p 7860:7860 \
+  -e API_ACCESS_TOKEN="你的访问令牌" \
+  -e ONDEMAND_ACCOUNTS='{"accounts":[{"email":"账户[email protected]","password":"密码1"}]}' \
+  ondemand-api-proxy
+```
+
+## 客户端连接
+
+### Cherry Studio 连接
+
+1. 打开 Cherry Studio
+2. 进入设置 → API 设置
+3. 选择 "OpenAI API"
+4. API 密钥填入你配置的 API 访问令牌
+5. API 地址填入你的服务地址（如 `https://你的用户名-你的space名称.hf.space/v1`）
+
+### 其他 OpenAI 兼容客户端
+
+任何支持 OpenAI API 的客户端都可以连接到此服务，只需将 API 地址修改为你的服务地址即可。
+
+## 故障排除
+
+### 常见问题
+
+1. **认证失败**：
+   - 检查 API 访问令牌是否正确配置
+   - 确认请求头中包含 `Authorization: Bearer 你的令牌`
+
+2. **账户连接问题**：
+   - 确认 on-demand.io 账户信息正确
+   - 检查账户是否被限制或封禁
+
+3. **模型不可用**：
+   - 确认请求的模型名称在支持列表中
+   - 检查 on-demand.io 是否支持该模型
+
+4. **统计图表显示错误**：
+   - 清除浏览器缓存后重试
+   - 检查浏览器控制台是否有错误信息
+
+## 安全建议
+
+1. **永远不要**在代码中硬编码账户信息和访问令牌
+2. 使用环境变量或安全的配置管理系统存储敏感信息
+3. 定期更换 API 访问令牌
+4. 限制 API 的访问范围，只允许受信任的客户端连接
+5. 启用速率限制防止滥用
+
+## 贡献与反馈
+
+欢迎提交 Issue 和 Pull Request 来改进此项目。如有任何问题或建议，请随时联系。
+
+## 许可证
+
+本项目采用 MIT 许可证。

app.py

@@ -0,0 +1,33 @@
+import os
+from flask import Flask
+from utils import logger
+import config
+from auth import start_cleanup_thread
+from routes import register_routes
+
+def create_app():
+    """创建并配置Flask应用"""
+    config.init_config() # 调整到 create_app 开头
+    app = Flask(__name__)
+    
+    # 启动会话清理线程
+    start_cleanup_thread()
+    
+    # 注册路由
+    register_routes(app)
+    
+    return app
+
+if __name__ == "__main__":
+    # 初始化配置 # 已移至 create_app
+    
+    # 创建应用
+    app = create_app()
+    
+    # 获取端口
+    port = int(os.getenv("PORT", 7860))
+    print(f"[系统] Flask 应用将在 0.0.0.0:{port} 启动 (Flask 开发服)")
+    
+    # 启动应用
+    flask_debug_mode = config.get_config_value("FLASK_DEBUG", default=False) # 从配置获取调试模式
+    app.run(host='0.0.0.0', port=port, debug=flask_debug_mode)

auth.py

@@ -0,0 +1,112 @@
+import threading
+import time
+from datetime import datetime, timedelta
+from functools import wraps
+# from flask import request, jsonify # 移除冗余导入
+from utils import logger
+import config
+
+class RateLimiter:
+    """请求速率限制器 (基于token/IP)"""
+    def __init__(self, limit_per_minute=None): # 允许传入参数，但优先配置
+        # 优先从配置读取，如果未配置或传入了明确值，则使用该值
+        # 配置项: "rate_limit"
+        configured_limit = config.get_config_value("rate_limit", default=60) # 默认60次/分钟
+        self.limit = limit_per_minute if limit_per_minute is not None else configured_limit
+        self.window_size = 60  # 窗口大小（秒）
+        self.requests = {}  # {identifier: [timestamp1, timestamp2, ...]}
+        self.lock = threading.Lock()
+    
+    def is_allowed(self, identifier: str) -> bool:
+        """
+        检查标识符请求是否允许
+        
+        参数:
+            identifier: 唯一标识 (token/IP)
+            
+        返回:
+            bool: 允许则True，否则False
+        """
+        with self.lock:
+            now = time.time()
+            if identifier not in self.requests:
+                self.requests[identifier] = []
+            
+            # 清理过期请求
+            self.requests[identifier] = [t for t in self.requests[identifier] if now - t < self.window_size]
+            
+            # 检查请求数是否超限
+            if len(self.requests[identifier]) >= self.limit:
+                return False
+            
+            # 记录当前请求
+            self.requests[identifier].append(now)
+            return True
+
+def session_cleanup():
+    """定期清理过期会话"""
+    # 获取配置
+    config_instance = config.config_instance
+    
+    with config_instance.client_sessions_lock:
+        current_time = datetime.now()
+        total_expired = 0
+        
+        # 遍历用户
+        for user_id in list(config_instance.client_sessions.keys()):
+            user_sessions = config_instance.client_sessions[user_id]
+            expired_accounts = []
+            
+            # 遍历账户会话
+            for account_email, session_data in user_sessions.items():
+                last_time = session_data["last_time"]
+                if current_time - last_time > timedelta(minutes=config_instance.get('session_timeout_minutes')):
+                    expired_accounts.append(account_email)
+                    # 记录过期会话信息 (上下文/IP)
+                    context_info = session_data.get("context", "无上下文")
+                    ip_info = session_data.get("ip", "无IP")
+                    # 上下文预览(前30字符)，防日志过长
+                    context_preview = context_info[:30] + "..." if len(context_info) > 30 else context_info
+                    logger.debug(f"过期会话: 用户={user_id[:8]}..., 账户={account_email}, 上下文={context_preview}, IP={ip_info}")
+            
+            # 删除过期账户会话
+            for account_email in expired_accounts:
+                del user_sessions[account_email]
+                total_expired += 1
+            
+            # 若用户无会话，则删除
+            if not user_sessions:
+                del config_instance.client_sessions[user_id]
+        
+        if total_expired:
+            logger.info(f"已清理 {total_expired} 个过期会话")
+
+_cleanup_thread_started = False
+_cleanup_thread_lock = threading.Lock()
+
+def start_cleanup_thread():
+    """启动会话定期清理线程 (幂等)"""
+    global _cleanup_thread_started
+    with _cleanup_thread_lock:
+        if _cleanup_thread_started:
+            logger.debug("会话清理线程已运行，跳过此次启动。")
+            return
+        
+        def cleanup_worker():
+            while True:
+                # 循环内获取最新配置，防动态更新
+                try:
+                    timeout_minutes = config.get_config_value('session_timeout_minutes', default=30) # 默认值
+                    sleep_interval = timeout_minutes * 60 / 2
+                    if sleep_interval <= 0: # 防无效休眠间隔
+                        logger.warning(f"无效会话清理休眠间隔: {sleep_interval}s, 用默认15分钟。")
+                        sleep_interval = 15 * 60
+                    time.sleep(sleep_interval)
+                    session_cleanup()
+                except Exception as e:
+                    logger.error(f"会话清理线程异常: {e}", exc_info=True) # 添加 exc_info=True 获取更详细的堆栈
+
+        cleanup_thread = threading.Thread(target=cleanup_worker, daemon=True, name="SessionCleanupThread")
+        cleanup_thread.start()
+        _cleanup_thread_started = True
+        logger.info("会话清理线程启动成功。")

client.py

@@ -0,0 +1,468 @@
+import requests
+import json
+import base64
+import threading
+import time
+import uuid
+from datetime import datetime
+from typing import Dict, Optional, Any
+
+from utils import logger, mask_email
+import config
+from retry import with_retry
+
+class OnDemandAPIClient:
+    """OnDemand API 客户端，处理认证、会话管理和查询"""
+    
+    def __init__(self, email: str, password: str, client_id: str = "default_client"):
+        """初始化客户端
+        
+        Args:
+            email: OnDemand账户邮箱
+            password: OnDemand账户密码
+            client_id: 客户端标识符，用于日志记录
+        """
+        self.email = email
+        self.password = password
+        self.client_id = client_id
+        self.token = ""
+        self.refresh_token = ""
+        self.user_id = ""
+        self.company_id = ""
+        self.session_id = ""
+        self.base_url = "https://gateway.on-demand.io/v1"
+        self.chat_base_url = "https://api.on-demand.io/chat/v1/client"  # 恢复为原始路径
+        self.last_error: Optional[str] = None
+        self.last_activity = datetime.now()
+        self.lock = threading.RLock()  # 可重入锁，用于线程安全操作
+
+        # 新增属性
+        self._associated_user_identifier: Optional[str] = None
+        self._associated_request_ip: Optional[str] = None
+        self._current_request_context_hash: Optional[str] = None # 新增：用于暂存当前请求的上下文哈希
+        
+        # 隐藏密码的日志
+        masked_email = mask_email(email)
+        logger.info(f"已为 {masked_email} 初始化 OnDemandAPIClient (ID: {client_id})")
+    
+    def _log(self, message: str, level: str = "INFO"):
+        """内部日志方法，使用结构化日志记录
+        
+        Args:
+            message: 日志消息
+            level: 日志级别
+        """
+        masked_email = mask_email(self.email)
+        log_method = getattr(logger, level.lower(), logger.info)
+        log_method(f"[{self.client_id} / {masked_email}] {message}")
+        self.last_activity = datetime.now()  # 更新最后活动时间
+
+    def get_authorization(self) -> str:
+        """生成登录用 Basic Authorization 头"""
+        text = f"{self.email}:{self.password}"
+        encoded = base64.b64encode(text.encode("utf-8")).decode("utf-8")
+        return encoded
+    
+    def _do_request(self, method: str, url: str, headers: Dict[str, str],
+                   data: Optional[Dict] = None, stream: bool = False,
+                   timeout: int = None) -> requests.Response:
+        """执行HTTP请求的实际逻辑，不包含重试
+        
+        Args:
+            method: HTTP方法 (GET, POST等)
+            url: 请求URL
+            headers: HTTP头
+            data: 请求数据
+            stream: 是否使用流式传输
+            timeout: 请求超时时间
+            
+        Returns:
+            requests.Response对象
+            
+        Raises:
+            requests.exceptions.RequestException: 请求失败
+        """
+        if method.upper() == 'GET':
+            response = requests.get(url, headers=headers, stream=stream, timeout=timeout)
+        elif method.upper() == 'POST':
+            json_data = json.dumps(data) if data else None
+            response = requests.post(url, data=json_data, headers=headers, stream=stream, timeout=timeout)
+        else:
+            raise ValueError(f"不支持的HTTP方法: {method}")
+        
+        response.raise_for_status()
+        return response
+    
+    @with_retry()
+    def sign_in(self, context: Optional[str] = None) -> bool:
+        """登录以获取 token, refreshToken, userId, 和 companyId"""
+        with self.lock:  # 线程安全
+            self.last_error = None
+            url = f"{self.base_url}/auth/user/signin"
+            payload = {"accountType": "default"}
+            headers = {
+                'User-Agent': "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.0.0",
+                'Accept': "application/json, text/plain, */*",
+                'Content-Type': "application/json",
+                'Authorization': f"Basic {self.get_authorization()}",  # 登录时使用 Basic 认证
+                'Referer': "https://app.on-demand.io/"
+            }
+            if context:
+                self._current_request_context_hash = context
+            
+            try:
+                masked_email = mask_email(self.email)
+                self._log(f"尝试登录 {masked_email}...")
+                
+                # 使用不带重试的_do_request，因为重试逻辑由装饰器处理
+                response = self._do_request('POST', url, headers, payload, timeout=config.get_config_value('request_timeout'))
+                data = response.json()
+                
+                if config.get_config_value('debug_mode'):
+                    # 在调试模式下记录响应，但隐藏敏感信息
+                    debug_data = data.copy()
+                    if 'data' in debug_data and 'tokenData' in debug_data['data']:
+                        debug_data['data']['tokenData']['token'] = '***REDACTED***'
+                        debug_data['data']['tokenData']['refreshToken'] = '***REDACTED***'
+                    self._log(f"登录原始响应: {json.dumps(debug_data, indent=2, ensure_ascii=False)}", "DEBUG")
+                
+                self.token = data.get('data', {}).get('tokenData', {}).get('token', '')
+                self.refresh_token = data.get('data', {}).get('tokenData', {}).get('refreshToken', '')
+                self.user_id = data.get('data', {}).get('user', {}).get('userId', '')
+                self.company_id = data.get('data', {}).get('user', {}).get('default_company_id', '')
+                
+                if self.token and self.user_id and self.company_id:
+                    self._log(f"登录成功。已获取必要的凭证。")
+                    return True
+                else:
+                    self.last_error = "登录成功，但未能从响应中提取必要的字段。"
+                    self._log(f"登录失败: {self.last_error}", level="ERROR")
+                    return False
+                    
+            except requests.exceptions.RequestException as e:
+                self.last_error = f"登录请求失败: {e}"
+                self._log(f"登录失败: {e}", level="ERROR")
+                raise  # 重新抛出异常，让装饰器处理重试
+                
+            except json.JSONDecodeError as e:
+                self.last_error = f"登录 JSON 解码失败: {e}. 响应文本: {response.text if 'response' in locals() else 'N/A'}"
+                self._log(self.last_error, level="ERROR")
+                return False
+                
+            except Exception as e:
+                self.last_error = f"登录过程中发生意外错误: {e}"
+                self._log(self.last_error, level="ERROR")
+                return False
+
+    @with_retry()
+    def refresh_token_if_needed(self) -> bool:
+        """如果令牌过期或无效，则刷新令牌
+        
+        Returns:
+            bool: 刷新成功返回True，否则返回False
+        """
+        with self.lock:  # 线程安全
+            self.last_error = None
+            if not self.refresh_token:
+                self.last_error = "没有可用的 refresh token 来刷新令牌。"
+                self._log(self.last_error, level="WARNING")
+                return False
+
+            url = f"{self.base_url}/auth/user/refresh_token"
+            payload = {"data": {"token": self.token, "refreshToken": self.refresh_token}}
+            headers = {'Content-Type': "application/json"}
+            
+            try:
+                self._log("尝试刷新令牌...")
+                
+                # 使用不带重试的_do_request，因为重试逻辑由装饰器处理
+                response = self._do_request('POST', url, headers, payload, timeout=config.get_config_value('request_timeout'))
+                data = response.json()
+                
+                if config.get_config_value('debug_mode'):
+                    # 在调试模式下记录响应，但隐藏敏感信息
+                    debug_data = data.copy()
+                    if 'data' in debug_data:
+                        if 'token' in debug_data['data']:
+                            debug_data['data']['token'] = '***REDACTED***'
+                        if 'refreshToken' in debug_data['data']:
+                            debug_data['data']['refreshToken'] = '***REDACTED***'
+                    self._log(f"刷新令牌原始响应: {json.dumps(debug_data, indent=2, ensure_ascii=False)}", "DEBUG")
+                
+                new_token = data.get('data', {}).get('token', '')
+                new_refresh_token = data.get('data', {}).get('refreshToken', '')  # OnDemand 可能不总返回新的 refresh token
+                
+                if new_token:
+                    self.token = new_token
+                    if new_refresh_token:  # 仅当返回了新的 refresh token 时才更新
+                        self.refresh_token = new_refresh_token
+                    self._log("令牌刷新成功。")
+                    return True
+                else:
+                    self.last_error = "令牌刷新成功，但响应中没有新的 token。"
+                    self._log(f"令牌刷新失败: {self.last_error}", level="ERROR")
+                    return False
+                    
+            except requests.exceptions.RequestException as e:
+                self.last_error = f"令牌刷新请求失败: {e}"
+                self._log(f"令牌刷新失败: {e}", level="ERROR")
+                
+                # 如果是认证错误，可能需要完全重新登录
+                if hasattr(e, 'response') and e.response is not None and e.response.status_code == 401:
+                    self._log("令牌刷新返回401错误，可能需要完全重新登录", level="WARNING")
+                
+                raise  # 重新抛出异常，让装饰器处理重试
+                
+            except json.JSONDecodeError as e:
+                self.last_error = f"令牌刷新 JSON 解码失败: {e}. 响应文本: {response.text if 'response' in locals() else 'N/A'}"
+                self._log(self.last_error, level="ERROR")
+                return False
+                
+            except Exception as e:
+                self.last_error = f"令牌刷新过程中发生意外错误: {e}"
+                self._log(self.last_error, level="ERROR")
+                return False
+
+    @with_retry()
+    def create_session(self, external_user_id: str = "openai-adapter-user", external_context: Optional[str] = None) -> bool:
+        """为聊天创建一个新会话
+        
+        Args:
+            external_user_id: 外部用户ID前缀，会附加UUID确保唯一性
+            external_context: 外部上下文哈希 (可选)
+            
+        Returns:
+            bool: 创建成功返回True，否则返回False
+        """
+        with self.lock:  # 线程安全
+            self.last_error = None
+            if external_context:
+                self._current_request_context_hash = external_context
+            if not self.token or not self.user_id or not self.company_id:
+                self.last_error = "创建会话缺少 token, user_id, 或 company_id。正在尝试登录。"
+                self._log(self.last_error, level="WARNING")
+                if not self.sign_in():  # 如果未登录，尝试登录
+                    self.last_error = f"无法创建会话：登录失败。最近的客户端错误: {self.last_error}"
+                    return False  # 如果登录失败，则无法继续
+
+            url = f"{self.chat_base_url}/sessions"
+            # 确保 externalUserId 对于每个会话是唯一的，以避免冲突
+            unique_id = f"{external_user_id}-{uuid.uuid4().hex}"
+            payload = {"externalUserId": unique_id, "pluginIds": []}
+            headers = {
+                'Content-Type': "application/json",
+                'Authorization': f"Bearer {self.token}",  # 恢复为原始认证方式
+                'x-company-id': self.company_id,
+                'x-user-id': self.user_id
+            }
+            
+            self._log(f"尝试创建会话，company_id: {self.company_id}, user_id: {self.user_id}, external_id: {unique_id}")
+            
+            try:
+                try:
+                    # 首先尝试创建会话，使用不带重试的_do_request
+                    response = self._do_request('POST', url, headers, payload, timeout=config.get_config_value('request_timeout'))
+                except requests.exceptions.HTTPError as e:
+                    # 如果是401错误，尝试刷新令牌
+                    if e.response.status_code == 401:
+                        self._log("创建会话时令牌过期，尝试刷新...", level="INFO")
+                        if self.refresh_token_if_needed():
+                            headers['Authorization'] = f"Bearer {self.token}"  # 使用新令牌更新头
+                            response = self._do_request('POST', url, headers, payload, timeout=config.get_config_value('request_timeout'))
+                        else:  # 刷新失败，尝试完全重新登录
+                            self._log("令牌刷新失败。尝试完全重新登录以创建会话。", level="WARNING")
+                            if self.sign_in():
+                                headers['Authorization'] = f"Bearer {self.token}"
+                                response = self._do_request('POST', url, headers, payload, timeout=config.get_config_value('request_timeout'))
+                            else:
+                                self.last_error = f"会话创建失败：令牌刷新和重新登录均失败。最近的客户端错误: {self.last_error}"
+                                self._log(self.last_error, level="ERROR")
+                                return False
+                    else:
+                        # 其他HTTP错误，直接抛出
+                        raise
+                
+                data = response.json()
+                
+                if config.get_config_value('debug_mode'):
+                    self._log(f"创建会话原始响应: {json.dumps(data, indent=2, ensure_ascii=False)}", "DEBUG")
+                
+                session_id_val = data.get('data', {}).get('id', '')
+                if session_id_val:
+                    self.session_id = session_id_val
+                    self._log(f"会话创建成功。会话 ID: {self.session_id}")
+                    return True
+                else:
+                    self.last_error = f"会话创建成功，但响应中没有会话 ID。"
+                    self._log(f"会话创建失败: {self.last_error}", level="ERROR")
+                    return False
+                    
+            except requests.exceptions.RequestException as e:
+                self.last_error = f"会话创建请求失败: {e}"
+                self._log(f"会话创建失败: {e}", level="ERROR")
+                raise  # 重新抛出异常，让装饰器处理重试
+                
+            except json.JSONDecodeError as e:
+                self.last_error = f"会话创建 JSON 解码失败: {e}. 响应文本: {response.text if 'response' in locals() else 'N/A'}"
+                self._log(self.last_error, level="ERROR")
+                return False
+                
+            except Exception as e:
+                self.last_error = f"会话创建过程中发生意外错误: {e}"
+                self._log(self.last_error, level="ERROR")
+                return False
+
+    @with_retry()
+    def send_query(self, query: str, endpoint_id: str = "predefined-claude-3.7-sonnet",
+                  stream: bool = False, model_configs_input: Optional[Dict] = None,
+                  full_query_override: Optional[str] = None) -> Dict:
+        """向聊天会话发送查询，并处理流式或非流式响应
+        
+        Args:
+            query: 查询文本 (如果提供了 full_query_override，则此参数被忽略)
+            endpoint_id: OnDemand端点ID
+            stream: 是否使用流式响应
+            model_configs_input: 模型配置参数，如temperature、maxTokens等
+            
+        Returns:
+            Dict: 包含响应内容或流对象的字典
+        """
+        with self.lock:  # 线程安全
+            self.last_error = None
+            
+            # 会话检查和创建
+            if not self.session_id:
+                self.last_error = "没有可用的会话 ID。正在尝试创建新会话。"
+                self._log(self.last_error, level="WARNING")
+                if not self.create_session():
+                    self.last_error = f"查询失败：会话创建失败。最近的客户端错误: {self.last_error}"
+                    self._log(self.last_error, level="ERROR")
+                    return {"error": self.last_error}
+            
+            if not self.token:
+                self.last_error = "发送查询没有可用的 token。"
+                self._log(self.last_error, level="ERROR")
+                return {"error": self.last_error}
+
+            url = f"{self.chat_base_url}/sessions/{self.session_id}/query"
+            
+            # 处理 query 输入
+            current_query = ""
+            if query is None:
+                self._log("警告：查询内容为None，已替换为空字符串", level="WARNING")
+            elif not isinstance(query, str):
+                current_query = str(query)
+                self._log(f"警告：查询内容不是字符串类型，已转换为字符串: {type(query)} -> {type(current_query)}", level="WARNING")
+            else:
+                current_query = query
+
+            # 优先使用 full_query_override
+            query_to_send = full_query_override if full_query_override is not None else current_query
+            if full_query_override is not None:
+                self._log(f"使用 full_query_override (长度: {len(full_query_override)}) 代替原始 query。", "DEBUG")
+
+            payload = {
+                "endpointId": endpoint_id,
+                "query": query_to_send, # 使用处理后的 query 或 override
+                "pluginIds": [],
+                "responseMode": "stream" if stream else "sync",
+                "debugMode": "on" if config.get_config_value('debug_mode') else "off",
+                "fulfillmentOnly": False
+            }
+            
+            # 处理 model_configs_input
+            if model_configs_input:
+                # 直接使用传入的 model_configs_input，只包含非 None 值
+                # API 应该能处理额外的、非预期的配置项，或者忽略它们
+                # 如果API严格要求特定字段，那么这里的逻辑需要更精确地过滤
+                processed_model_configs = {k: v for k, v in model_configs_input.items() if v is not None}
+                if processed_model_configs: # 只有当有有效配置时才添加modelConfigs
+                    payload["modelConfigs"] = processed_model_configs
+            
+            self._log(f"最终的payload: {json.dumps(payload, ensure_ascii=False)}", level="DEBUG")
+            
+            headers = {
+                'Content-Type': "application/json",
+                'Authorization': f"Bearer {self.token}",
+                'x-company-id': self.company_id
+            }
+            
+            truncated_query_log = current_query[:100] + "..." if len(current_query) > 100 else current_query
+            self._log(f"向端点 {endpoint_id} 发送查询 (stream={stream})。查询内容: {truncated_query_log}")
+
+            try:
+                response = self._do_request('POST', url, headers, payload, stream=True, timeout=config.get_config_value('stream_timeout'))
+
+                if stream:
+                    self._log("返回流式响应对象供外部处理")
+                    return {"stream": True, "response_obj": response}
+                else: # stream (方法参数) 为 False
+                    full_answer = ""
+                    try:
+                        # 既然 _do_request 总是 stream=True，我们仍然需要消耗这个流。
+                        # OnDemand API 在 responseMode="sync" 时，理论上应该直接返回完整内容。
+                        
+                        response_body = response.text # 读取整个响应体
+                        response.close() # 确保连接关闭
+
+                        self._log(f"非流式响应原始文本 (前500字符): {response_body[:500]}", "DEBUG")
+                        
+                        try:
+                            # 优先尝试将整个响应体按单个JSON对象解析
+                            data = json.loads(response_body)
+                            if isinstance(data, dict):
+                                if "answer" in data and isinstance(data["answer"], str):
+                                    full_answer = data["answer"]
+                                elif "content" in data and isinstance(data["content"], str): # 备选字段
+                                    full_answer = data["content"]
+                                elif data.get("eventType") == "fulfillment" and "answer" in data:
+                                     full_answer = data.get("answer", "")
+                                else:
+                                    if not full_answer: # 避免覆盖已找到的答案
+                                        self._log(f"非流式响应解析为JSON后，未在顶层或常见字段找到答案: {response_body[:200]}", "WARNING")
+                            else:
+                                self._log(f"非流式响应解析为JSON后，不是字典类型: {type(data)}", "WARNING")
+                        
+                        except json.JSONDecodeError:
+                            # 如果直接解析JSON失败，再尝试按行解析SSE（作为后备）
+                            self._log(f"非流式响应直接解析JSON失败，尝试按SSE行解析: {response_body[:200]}", "WARNING")
+                            for line in response_body.splitlines():
+                                if line:
+                                    decoded_line = line #已经是str
+                                    if decoded_line.startswith("data:"):
+                                        json_str = decoded_line[len("data:"):].strip()
+                                        if json_str == "[DONE]":
+                                            break
+                                        try:
+                                            event_data = json.loads(json_str)
+                                            if event_data.get("eventType", "") == "fulfillment":
+                                                full_answer += event_data.get("answer", "")
+                                        except json.JSONDecodeError:
+                                            self._log(f"非流式后备SSE解析时 JSONDecodeError: {json_str}", level="WARNING")
+                                            continue
+                        
+                        self._log(f"非流式响应接收完毕。聚合内容长度: {len(full_answer)}")
+                        return {"stream": False, "content": full_answer}
+
+                    except requests.exceptions.RequestException as e: # 这应该在 _do_request 中捕获并重试
+                        self.last_error = f"非流式请求时发生错误: {e}"
+                        self._log(self.last_error, level="ERROR")
+                        # 如果 _do_request 抛异常到这里，说明重试也失败了
+                        # raise e # 或者返回错误结构体，让上层处理
+                        return {"error": self.last_error, "stream": False, "content": ""}
+                    except Exception as e:
+                        self.last_error = f"非流式处理中发生意外错误: {e}"
+                        self._log(self.last_error, level="ERROR")
+                        return {"error": self.last_error, "stream": False, "content": ""}
+            
+            except requests.exceptions.RequestException as e:
+                self.last_error = f"请求失败: {e}"
+                self._log(f"查询失败: {e}", level="ERROR")
+                raise
+                
+            except Exception as e:
+                error_message = f"send_query 过程中发生意外错误: {e}"
+                error_type = type(e).__name__
+                self.last_error = error_message
+                self._log(f"{error_message} (错误类型: {error_type})", level="CRITICAL")
+                return {"error": str(e)}

config.py

@@ -0,0 +1,400 @@
+import os
+import json
+import time
+from collections import defaultdict
+import threading
+from typing import Dict, List, Any, Optional, Union, get_type_hints
+from datetime import datetime, timedelta
+from utils import logger, load_config
+
+
+class Config:
+    """配置管理类，用于存储和管理所有配置"""
+    
+    # 默认配置值
+    _defaults = {
+        "ondemand_session_timeout_minutes": 30,  # OnDemand 会话的活跃超时时间（分钟）
+        "session_timeout_minutes": 3600,  # 会话不活动超时时间（分钟）- 增加以减少创建新会话的频率
+        "max_retries": 5,  # 默认重试次数 - 增加以处理更多错误
+        "retry_delay": 3,  # 默认重试延迟（秒）- 增加以减少请求频率
+        "request_timeout": 45,  # 默认请求超时（秒）- 增加以允许更长的处理时间
+        "stream_timeout": 180,  # 流式请求的默认超时（秒）- 增加以允许更长的处理时间
+        "rate_limit": 30,  # 默认速率限制（每分钟请求数）- 减少以避免触发API速率限制
+        "account_cooldown_seconds": 300,  # 账户冷却期（秒）- 在遇到429错误后暂时不使用该账户
+        "debug_mode": False,  # 调试模式
+        "api_access_token": "sk-2api-ondemand-access-token-2025",  # API访问认证Token
+        "stats_file_path": "stats_data.json",  # 统计数据文件路径
+        "stats_backup_path": "stats_data_backup.json",  # 统计数据备份文件路径
+        "stats_save_interval": 300,  # 每5分钟保存一次统计数据
+        "max_history_items": 1000,  # 最多保存的历史记录数量
+        "default_endpoint_id": "predefined-claude-3.7-sonnet"  # 备用/默认端点 ID
+    }
+    
+    # 模型名称映射：OpenAI 模型名 -> on-demand.io endpointId
+    _model_mapping = {
+        "gpt-3.5-turbo": "predefined-openai-gpto3-mini",
+        "gpto3-mini": "predefined-openai-gpto3-mini",
+        "gpt-4o": "predefined-openai-gpt4o",
+        "gpt-4o-mini": "predefined-openai-gpt4o-mini",
+        "gpt-4-turbo": "predefined-openai-gpt4.1",  # gpt-4.1 的别名
+        "gpt-4.1": "predefined-openai-gpt4.1",
+        "gpt-4.1-mini": "predefined-openai-gpt4.1-mini",
+        "gpt-4.1-nano": "predefined-openai-gpt4.1-nano",
+        "deepseek-v3": "predefined-deepseek-v3",
+        "deepseek-r1": "predefined-deepseek-r1",
+        "claude-3.5-sonnet": "predefined-claude-3.5-sonnet",
+        "claude-3.7-sonnet": "predefined-claude-3.7-sonnet",
+        "claude-3-opus": "predefined-claude-3-opus",
+        "claude-3-haiku": "predefined-claude-3-haiku",
+        "gemini-1.5-pro": "predefined-gemini-2.0-flash",
+        "gemini-2.0-flash": "predefined-gemini-2.0-flash",
+        # 根据需要添加更多映射
+    }
+    
+    def __init__(self):
+        """初始化配置对象"""
+        # 从默认值初始化配置
+        self._config = self._defaults.copy()
+        
+        # 用量统计
+        self.usage_stats = {
+            "total_requests": 0,
+            "successful_requests": 0,
+            "failed_requests": 0,
+            "model_usage": defaultdict(int),  # 模型使用次数
+            "account_usage": defaultdict(int),  # 账户使用次数
+            "daily_usage": defaultdict(int),  # 每日使用次数
+            "hourly_usage": defaultdict(int),  # 每小时使用次数
+            "request_history": [],  # 请求历史记录
+            "total_prompt_tokens": 0,  # 总提示tokens
+            "total_completion_tokens": 0,  # 总完成tokens
+            "total_tokens": 0,  # 总tokens
+            "model_tokens": defaultdict(int),  # 每个模型的tokens使用量
+            "daily_tokens": defaultdict(int),  # 每日tokens使用量
+            "hourly_tokens": defaultdict(int),  # 每小时tokens使用量
+            "last_saved": datetime.now().isoformat()  # 最后保存时间
+        }
+        
+        # 线程锁
+        self.usage_stats_lock = threading.Lock()  # 用于线程安全的统计数据访问
+        self.account_index_lock = threading.Lock()  # 用于线程安全的账户选择
+        self.client_sessions_lock = threading.Lock()  # 用于线程安全的会话管理
+        
+        # 当前账户索引（用于创建新客户端会话时的轮询选择）
+        self.current_account_index = 0
+        
+        # 内存中存储每个客户端的会话和最后交互时间
+        # 格式: {用户标识符: {账户邮箱: {"client": OnDemandAPIClient实例, "last_time": datetime对象}}}
+        # 这样确保不同用户的会话是隔离的，每个用户只能访问自己的会话
+        self.client_sessions = {}
+        
+        # 账户信息
+        self.accounts = []
+        
+        # 账户冷却期记录 - 存储因速率限制而暂时不使用的账户
+        # 格式: {账户邮箱: 冷却期结束时间(datetime对象)}
+        self.account_cooldowns = {}
+    
+    def get(self, key: str, default: Any = None) -> Any:
+        """获取配置值"""
+        return self._config.get(key, default)
+    
+    def set(self, key: str, value: Any) -> None:
+        """设置配置值"""
+        self._config[key] = value
+    
+    def update(self, config_dict: Dict[str, Any]) -> None:
+        """批量更新配置值"""
+        self._config.update(config_dict)
+    
+    def get_model_endpoint(self, model_name: str) -> str:
+        """获取模型对应的端点ID"""
+        return self._model_mapping.get(model_name, self.get("default_endpoint_id"))
+    
+    def load_from_file(self) -> bool:
+        """从配置文件加载配置"""
+        try:
+            # utils.load_config() 当前不接受 file_path 参数，因此移除
+            config_data = load_config()
+            if config_data:
+                # 更新配置
+                for key, value in config_data.items():
+                    if key != "accounts":  # 账户信息单独处理
+                        self.set(key, value)
+                
+                # 处理账户信息
+                if "accounts" in config_data:
+                    self.accounts = config_data["accounts"]
+                
+                logger.info("已从配置文件加载配置")
+                return True
+            return False
+        except Exception as e:
+            logger.error(f"加载配置文件时出错: {e}")
+            return False
+    
+    def load_from_env(self) -> None:
+        """从环境变量加载配置"""
+        # 从环境变量加载账户信息
+        if not self.accounts:
+            accounts_env = os.getenv("ONDEMAND_ACCOUNTS", "")
+            if accounts_env:
+                try:
+                    self.accounts = json.loads(accounts_env).get('accounts', [])
+                    logger.info("已从环境变量加载账户信息")
+                except json.JSONDecodeError:
+                    logger.error("解码 ONDEMAND_ACCOUNTS 环境变量失败")
+        
+        # 从环境变量加载其他设置
+        env_mappings = {
+            "ondemand_session_timeout_minutes": "ONDEMAND_SESSION_TIMEOUT_MINUTES",
+            "session_timeout_minutes": "SESSION_TIMEOUT_MINUTES",
+            "max_retries": "MAX_RETRIES",
+            "retry_delay": "RETRY_DELAY",
+            "request_timeout": "REQUEST_TIMEOUT",
+            "stream_timeout": "STREAM_TIMEOUT",
+            "rate_limit": "RATE_LIMIT",
+            "debug_mode": "DEBUG_MODE",
+            "api_access_token": "API_ACCESS_TOKEN"
+        }
+        
+        for config_key, env_key in env_mappings.items():
+            env_value = os.getenv(env_key)
+            if env_value is not None:
+                # 根据默认值的类型进行转换
+                default_value = self.get(config_key)
+                if isinstance(default_value, bool):
+                    self.set(config_key, env_value.lower() == 'true')
+                elif isinstance(default_value, int):
+                    self.set(config_key, int(env_value))
+                elif isinstance(default_value, float):
+                    self.set(config_key, float(env_value))
+                else:
+                    self.set(config_key, env_value)
+
+    def save_stats_to_file(self):
+        """将统计数据保存到文件中"""
+        try:
+            with self.usage_stats_lock:
+                # 创建统计数据的副本
+                stats_copy = {
+                    "total_requests": self.usage_stats["total_requests"],
+                    "successful_requests": self.usage_stats["successful_requests"],
+                    "failed_requests": self.usage_stats["failed_requests"],
+                    "model_usage": dict(self.usage_stats["model_usage"]),
+                    "account_usage": dict(self.usage_stats["account_usage"]),
+                    "daily_usage": dict(self.usage_stats["daily_usage"]),
+                    "hourly_usage": dict(self.usage_stats["hourly_usage"]),
+                    "request_history": list(self.usage_stats["request_history"]),
+                    "total_prompt_tokens": self.usage_stats["total_prompt_tokens"],
+                    "total_completion_tokens": self.usage_stats["total_completion_tokens"],
+                    "total_tokens": self.usage_stats["total_tokens"],
+                    "model_tokens": dict(self.usage_stats["model_tokens"]),
+                    "daily_tokens": dict(self.usage_stats["daily_tokens"]),
+                    "hourly_tokens": dict(self.usage_stats["hourly_tokens"]),
+                    "last_saved": datetime.now().isoformat()
+                }
+                
+                stats_file_path = self.get("stats_file_path")
+                stats_backup_path = self.get("stats_backup_path")
+                
+                # 先保存到备份文件，然后重命名，避免写入过程中的文件损坏
+                with open(stats_backup_path, 'w', encoding='utf-8') as f:
+                    json.dump(stats_copy, f, ensure_ascii=False, indent=2)
+                
+                # 如果主文件存在，先删除它
+                if os.path.exists(stats_file_path):
+                    os.remove(stats_file_path)
+                
+                # 将备份文件重命名为主文件
+                os.rename(stats_backup_path, stats_file_path)
+                
+                logger.info(f"统计数据已保存到 {stats_file_path}")
+                self.usage_stats["last_saved"] = datetime.now().isoformat()
+        except Exception as e:
+            logger.error(f"保存统计数据时出错: {e}")
+
+    def load_stats_from_file(self):
+        """从文件中加载统计数据"""
+        try:
+            stats_file_path = self.get("stats_file_path")
+            if os.path.exists(stats_file_path):
+                with open(stats_file_path, 'r', encoding='utf-8') as f:
+                    saved_stats = json.load(f)
+                
+                with self.usage_stats_lock:
+                    # 更新基本计数器
+                    self.usage_stats["total_requests"] = saved_stats.get("total_requests", 0)
+                    self.usage_stats["successful_requests"] = saved_stats.get("successful_requests", 0)
+                    self.usage_stats["failed_requests"] = saved_stats.get("failed_requests", 0)
+                    self.usage_stats["total_prompt_tokens"] = saved_stats.get("total_prompt_tokens", 0)
+                    self.usage_stats["total_completion_tokens"] = saved_stats.get("total_completion_tokens", 0)
+                    self.usage_stats["total_tokens"] = saved_stats.get("total_tokens", 0)
+                    
+                    # 更新字典类型的统计数据
+                    for model, count in saved_stats.get("model_usage", {}).items():
+                        self.usage_stats["model_usage"][model] = count
+                    
+                    for account, count in saved_stats.get("account_usage", {}).items():
+                        self.usage_stats["account_usage"][account] = count
+                    
+                    for day, count in saved_stats.get("daily_usage", {}).items():
+                        self.usage_stats["daily_usage"][day] = count
+                    
+                    for hour, count in saved_stats.get("hourly_usage", {}).items():
+                        self.usage_stats["hourly_usage"][hour] = count
+                    
+                    for model, tokens in saved_stats.get("model_tokens", {}).items():
+                        self.usage_stats["model_tokens"][model] = tokens
+                    
+                    for day, tokens in saved_stats.get("daily_tokens", {}).items():
+                        self.usage_stats["daily_tokens"][day] = tokens
+                    
+                    for hour, tokens in saved_stats.get("hourly_tokens", {}).items():
+                        self.usage_stats["hourly_tokens"][hour] = tokens
+                    
+                    # 更新请求历史
+                    self.usage_stats["request_history"] = saved_stats.get("request_history", [])
+                    
+                    # 限制历史记录数量
+                    max_history_items = self.get("max_history_items")
+                    if len(self.usage_stats["request_history"]) > max_history_items:
+                        self.usage_stats["request_history"] = self.usage_stats["request_history"][-max_history_items:]
+                
+                logger.info(f"已从 {stats_file_path} 加载统计数据")
+                return True
+            else:
+                logger.info(f"未找到统计数据文件 {stats_file_path}，将使用默认值")
+                return False
+        except Exception as e:
+            logger.error(f"加载统计数据时出错: {e}")
+            return False
+
+    def start_stats_save_thread(self):
+        """启动定期保存统计数据的线程"""
+        def save_stats_periodically():
+            while True:
+                time.sleep(self.get("stats_save_interval"))
+                self.save_stats_to_file()
+        
+        save_thread = threading.Thread(target=save_stats_periodically, daemon=True)
+        save_thread.start()
+        logger.info(f"统计数据保存线程已启动，每 {self.get('stats_save_interval')} 秒保存一次")
+
+    def init(self):
+        """初始化配置，从配置文件或环境变量加载设置"""
+        # 从配置文件加载配置
+        self.load_from_file()
+        
+        # 从环境变量加载配置
+        self.load_from_env()
+        
+        # 验证账户信息
+        if not self.accounts:
+            error_msg = "在 config.json 或环境变量 ONDEMAND_ACCOUNTS 中未找到账户信息"
+            logger.critical(error_msg)
+            # 不抛出异常，而是继续运行
+            logger.warning("将继续运行，但没有账户信息，可能会导致功能受限")
+        
+        logger.info("已加载API访问Token")
+        
+        # 加载之前保存的统计数据
+        self.load_stats_from_file()
+        
+        # 启动定期保存统计数据的线程
+        self.start_stats_save_thread()
+
+    def get_next_ondemand_account_details(self):
+        """获取下一个 OnDemand 账户的邮箱和密码，用于轮询。
+        会跳过处于冷却期的账户。"""
+        with self.account_index_lock:
+            current_time = datetime.now()
+            
+            # 清理过期的冷却记录
+            expired_cooldowns = [email for email, end_time in self.account_cooldowns.items()
+                               if end_time < current_time]
+            for email in expired_cooldowns:
+                del self.account_cooldowns[email]
+                logger.info(f"账户 {email} 的冷却期已结束，现在可用")
+            
+            # 尝试最多len(self.accounts)次，以找到一个不在冷却期的账户
+            for _ in range(len(self.accounts)):
+                account_details = self.accounts[self.current_account_index]
+                email = account_details.get('email')
+                
+                # 更新索引到下一个账户，为下次调用做准备
+                self.current_account_index = (self.current_account_index + 1) % len(self.accounts)
+                
+                # 检查账户是否在冷却期
+                if email in self.account_cooldowns:
+                    cooldown_end = self.account_cooldowns[email]
+                    remaining_seconds = (cooldown_end - current_time).total_seconds()
+                    logger.warning(f"账户 {email} 仍在冷却期中，还剩 {remaining_seconds:.1f} 秒")
+                    continue  # 尝试下一个账户
+                
+                # 找到一个可用账户
+                logger.info(f"[系统] 新会话将使用账户: {email}")
+                return email, account_details.get('password')
+            
+            # 如果所有账户都在冷却期，使用第一个账户（即使它在冷却期）
+            logger.warning("所有账户都在冷却期！使用第一个账户，尽管它可能会触发速率限制")
+            account_details = self.accounts[0]
+            return account_details.get('email'), account_details.get('password')
+
+
+# 创建全局配置实例
+config_instance = Config()
+
+def init_config():
+    """初始化配置的兼容函数，用于向后兼容"""
+    config_instance.init()
+
+
+def get_config_value(name: str, default: Any = None) -> Any:
+    """
+    获取当前配置变量的最新值。
+    推荐外部通过 config.get_config_value('变量名') 获取配置。
+    对于 accounts, model_mapping, usage_stats, client_sessions，请使用新增的专用getter函数。
+    """
+    return config_instance.get(name, default)
+
+# 新增的类型安全的getter函数
+def get_accounts() -> List[Dict[str, str]]:
+    """获取账户信息列表"""
+    return config_instance.accounts
+
+def get_model_mapping() -> Dict[str, str]:
+    """获取模型名称到端点ID的映射"""
+    return config_instance._model_mapping
+
+def get_usage_stats() -> Dict[str, Any]:
+    """获取用量统计数据"""
+    return config_instance.usage_stats
+
+def get_client_sessions() -> Dict[str, Any]:
+    """获取客户端会话信息"""
+    return config_instance.client_sessions
+
+def get_next_ondemand_account_details():
+    """获取下一个账户的兼容函数"""
+    return config_instance.get_next_ondemand_account_details()
+
+def set_account_cooldown(email, cooldown_seconds=None):
+    """设置账户冷却期
+    
+    Args:
+        email: 账户邮箱
+        cooldown_seconds: 冷却时间（秒），如果为None则使用默认配置
+    """
+    if cooldown_seconds is None:
+        cooldown_seconds = config_instance.get('account_cooldown_seconds')
+    
+    cooldown_end = datetime.now() + timedelta(seconds=cooldown_seconds)
+    with config_instance.account_index_lock:  # 使用相同的锁保护冷却期字典
+        config_instance.account_cooldowns[email] = cooldown_end
+        logger.warning(f"账户 {email} 已设置冷却期 {cooldown_seconds} 秒，将于 {cooldown_end.strftime('%Y-%m-%d %H:%M:%S')} 结束")
+
+
+# ⚠️ 警告：为保证配置动态更新，请勿使用 from config import XXX，只使用 import config 并通过 config.get_config_value('变量名') 获取配置。
+# 这样可确保配置值始终是最新的。
+# (｡•ᴗ-)ﾉﾞ 你的聪明小助手温馨提示~

requirements.txt

@@ -0,0 +1,4 @@
+flask
+requests
+tiktoken
+regex

retry.py

@@ -0,0 +1,408 @@
+import time
+import logging
+import functools
+import requests
+from abc import ABC, abstractmethod
+from typing import Callable, Any, Dict, Optional, Type, Union, TypeVar, cast
+
+# 导入配置模块
+import config
+
+# 类型变量定义
+T = TypeVar('T')
+
+class RetryStrategy(ABC):
+    """重试策略的抽象基类"""
+    
+    @abstractmethod
+    def should_retry(self, exception: Exception, retry_count: int, max_retries: int) -> bool:
+        """
+        判断是否应该重试
+        
+        Args:
+            exception: 捕获的异常
+            retry_count: 当前重试次数
+            max_retries: 最大重试次数
+            
+        Returns:
+            bool: 是否应该重试
+        """
+        pass
+    
+    @abstractmethod
+    def get_retry_delay(self, retry_count: int, base_delay: int) -> float:
+        """
+        计算重试延迟时间
+        
+        Args:
+            retry_count: 当前重试次数
+            base_delay: 基础延迟时间（秒）
+            
+        Returns:
+            float: 重试延迟时间（秒）
+        """
+        pass
+    
+    @abstractmethod
+    def log_retry_attempt(self, logger: logging.Logger, exception: Exception, 
+                         retry_count: int, max_retries: int, delay: float) -> None:
+        """
+        记录重试尝试
+        
+        Args:
+            logger: 日志记录器
+            exception: 捕获的异常
+            retry_count: 当前重试次数
+            max_retries: 最大重试次数
+            delay: 重试延迟时间
+        """
+        pass
+    
+    @abstractmethod
+    def on_retry(self, exception: Exception, retry_count: int) -> None:
+        """
+        重试前的回调函数，可以执行额外操作
+        
+        Args:
+            exception: 捕获的异常
+            retry_count: 当前重试次数
+        """
+        pass
+
+
+class ExponentialBackoffStrategy(RetryStrategy):
+    """指数退避重试策略，适用于连接错误"""
+    
+    def should_retry(self, exception: Exception, retry_count: int, max_retries: int) -> bool:
+        return (isinstance(exception, requests.exceptions.ConnectionError) and 
+                retry_count < max_retries)
+    
+    def get_retry_delay(self, retry_count: int, base_delay: int) -> float:
+        # 指数退避: base_delay * 2^(retry_count)
+        return base_delay * (2 ** retry_count)
+    
+    def log_retry_attempt(self, logger: logging.Logger, exception: Exception,
+                         retry_count: int, max_retries: int, delay: float) -> None:
+        # 检查logger是否为函数对象（如client._log）
+        if callable(logger) and not isinstance(logger, logging.Logger):
+            # 如果是函数，直接调用它
+            logger(f"连接错误，{delay:.1f}秒后重试 ({retry_count}/{max_retries}): {exception}", "WARNING")
+        else:
+            # 如果是Logger对象，调用warning方法
+            logger.warning(f"连接错误，{delay:.1f}秒后重试 ({retry_count}/{max_retries}): {exception}")
+    
+    def on_retry(self, exception: Exception, retry_count: int) -> None:
+        # 连接错误不需要额外操作
+        pass
+
+
+class LinearBackoffStrategy(RetryStrategy):
+    """线性退避重试策略，适用于超时错误"""
+    
+    def should_retry(self, exception: Exception, retry_count: int, max_retries: int) -> bool:
+        return (isinstance(exception, requests.exceptions.Timeout) and 
+                retry_count < max_retries)
+    
+    def get_retry_delay(self, retry_count: int, base_delay: int) -> float:
+        # 线性退避: base_delay * retry_count
+        return base_delay * retry_count
+    
+    def log_retry_attempt(self, logger: logging.Logger, exception: Exception,
+                         retry_count: int, max_retries: int, delay: float) -> None:
+        # 检查logger是否为函数对象（如client._log）
+        if callable(logger) and not isinstance(logger, logging.Logger):
+            # 如果是函数，直接调用它
+            logger(f"请求超时，{delay:.1f}秒后重试 ({retry_count}/{max_retries}): {exception}", "WARNING")
+        else:
+            # 如果是Logger对象，调用warning方法
+            logger.warning(f"请求超时，{delay:.1f}秒后重试 ({retry_count}/{max_retries}): {exception}")
+    
+    def on_retry(self, exception: Exception, retry_count: int) -> None:
+        # 超时错误不需要额外操作
+        pass
+
+
+class ServerErrorStrategy(RetryStrategy):
+    """服务器错误重试策略，适用于5xx错误"""
+    
+    def should_retry(self, exception: Exception, retry_count: int, max_retries: int) -> bool:
+        if not isinstance(exception, requests.exceptions.HTTPError):
+            return False
+        
+        response = getattr(exception, 'response', None)
+        if response is None:
+            return False
+        
+        return (500 <= response.status_code < 600 and retry_count < max_retries)
+    
+    def get_retry_delay(self, retry_count: int, base_delay: int) -> float:
+        # 线性退避: base_delay * retry_count
+        return base_delay * retry_count
+    
+    def log_retry_attempt(self, logger: logging.Logger, exception: Exception,
+                         retry_count: int, max_retries: int, delay: float) -> None:
+        response = getattr(exception, 'response', None)
+        status_code = response.status_code if response else 'unknown'
+        # 检查logger是否为函数对象（如client._log）
+        if callable(logger) and not isinstance(logger, logging.Logger):
+            # 如果是函数，直接调用它
+            logger(f"服务器错误 {status_code}，{delay:.1f}秒后重试 ({retry_count}/{max_retries})", "WARNING")
+        else:
+            # 如果是Logger对象，调用warning方法
+            logger.warning(f"服务器错误 {status_code}，{delay:.1f}秒后重试 ({retry_count}/{max_retries})")
+    
+    def on_retry(self, exception: Exception, retry_count: int) -> None:
+        # 服务器错误不需要额外操作
+        pass
+
+
+class RateLimitStrategy(RetryStrategy):
+    """速率限制重试策略，适用于429错误，包括账号切换逻辑和延迟重试"""
+    
+    def __init__(self, client=None):
+        """
+        初始化速率限制重试策略
+        
+        Args:
+            client: API客户端实例，用于切换账号
+        """
+        self.client = client
+        self.consecutive_429_count = 0  # 连续429错误计数器
+    
+    def should_retry(self, exception: Exception, retry_count: int, max_retries: int) -> bool:
+        if not isinstance(exception, requests.exceptions.HTTPError):
+            return False
+        
+        response = getattr(exception, 'response', None)
+        if response is None:
+            return False
+        
+        is_rate_limit = response.status_code == 429
+        if is_rate_limit:
+            self.consecutive_429_count += 1
+        else:
+            self.consecutive_429_count = 0  # 重置计数器
+            
+        return is_rate_limit
+    
+    def get_retry_delay(self, retry_count: int, base_delay: int) -> float:
+        # 根据用户反馈，429错误时不需要延迟，立即重试
+        return 0
+    
+    def log_retry_attempt(self, logger: logging.Logger, exception: Exception,
+                         retry_count: int, max_retries: int, delay: float) -> None:
+        # 检查logger是否为函数对象（如client._log）
+        message = ""
+        if self.consecutive_429_count > 1:
+            message = f"连续第{self.consecutive_429_count}次速率限制错误，尝试立即重试"
+        else:
+            message = "速率限制错误，尝试切换账号"
+            
+        if callable(logger) and not isinstance(logger, logging.Logger):
+            # 如果是函数，直接调用它
+            logger(message, "WARNING")
+        else:
+            # 如果是Logger对象，调用warning方法
+            logger.warning(message)
+    
+    def on_retry(self, exception: Exception, retry_count: int) -> None:
+        # 新增: 获取关联信息
+        user_identifier = getattr(self.client, '_associated_user_identifier', None)
+        request_ip = getattr(self.client, '_associated_request_ip', None) # request_ip 可能在某些情况下需要
+
+        # 只有在首次429错误或账号池中有多个账号时才切换账号
+        if self.consecutive_429_count == 1 or (self.consecutive_429_count > 0 and self.consecutive_429_count % 3 == 0):
+            if self.client and hasattr(self.client, 'email'):
+                # 记录当前账号进入冷却期
+                current_email = self.client.email # 这是切换前的 email
+                config.set_account_cooldown(current_email)
+                
+                # 获取新账号
+                new_email, new_password = config.get_next_ondemand_account_details()
+                if new_email:
+                    # 更新客户端信息
+                    self.client.email = new_email # 这是切换后的 email
+                    self.client.password = new_password
+                    self.client.token = ""
+                    self.client.refresh_token = ""
+                    self.client.session_id = ""  # 重置会话ID，确保创建新会话
+                    
+                    # 尝试使用新账号登录并创建会话
+                    try:
+                        # 获取当前请求的上下文哈希，以便在切换账号后重新登录和创建会话时使用
+                        current_context_hash = getattr(self.client, '_current_request_context_hash', None)
+                        
+                        self.client.sign_in(context=current_context_hash)
+                        if self.client.create_session(external_context=current_context_hash):
+                            # 如果成功登录并创建会话，记录日志并设置标志位
+                            if hasattr(self.client, '_log'):
+                                self.client._log(f"成功切换到账号 {new_email} 并使用上下文哈希 '{current_context_hash}' 重新登录和创建新会话。", "INFO")
+                            # 设置标志位，通知调用方下次需要发送完整历史
+                            setattr(self.client, '_new_session_requires_full_history', True)
+                            if hasattr(self.client, '_log'):
+                                self.client._log(f"已设置 _new_session_requires_full_history = True，下次查询应发送完整历史。", "INFO")
+                        else:
+                            # 会话创建失败，记录错误
+                            if hasattr(self.client, '_log'):
+                                self.client._log(f"切换到账号 {new_email} 后，创建新会话失败。", "WARNING")
+                                # 确保在这种情况下不设置需要完整历史的标志，因为会话本身就没成功
+                                setattr(self.client, '_new_session_requires_full_history', False)
+
+
+                        # --- 新增: 更新 client_sessions ---
+                        if not user_identifier:
+                            if hasattr(self.client, '_log'):
+                                self.client._log("RateLimitStrategy: _associated_user_identifier not found on client. Cannot update client_sessions.", "ERROR")
+                            # 即使没有 user_identifier，账号切换和会话创建也已发生，只是无法更新全局会话池
+                        else:
+                            old_email_in_strategy = current_email # 切换前的 email
+                            new_email_in_strategy = self.client.email # 切换后的 email (即 new_email)
+
+                            with config.config_instance.client_sessions_lock:
+                                if user_identifier in config.config_instance.client_sessions:
+                                    user_specific_sessions = config.config_instance.client_sessions[user_identifier]
+
+                                    # 1. 移除旧 email 的条目 (如果存在)
+                                    #    我们只移除那些 client 实例确实是当前 self.client 的条目，
+                                    #    或者更简单地，如果旧 email 存在，就移除它，因为 user_identifier
+                                    #    现在应该通过 new_email 使用这个（已被修改的）client 实例。
+                                    if old_email_in_strategy in user_specific_sessions:
+                                        # 检查 client 实例是否匹配可能不可靠，因为 client 内部状态已变。
+                                        # 直接删除旧 email 的条目，因为这个 user_identifier + client 组合现在用新 email。
+                                        del user_specific_sessions[old_email_in_strategy]
+                                        if hasattr(self.client, '_log'):
+                                            self.client._log(f"RateLimitStrategy: Removed session for old email '{old_email_in_strategy}' for user '{user_identifier}'.", "INFO")
+                                    
+                                    # 2. 添加/更新新 email 的条目
+                                    #    确保它指向当前这个已被修改的 self.client 实例
+                                    #    并重置 active_context_hash。
+                                    #    IP 地址应来自 self.client._associated_request_ip 或 routes.py 中设置的值。
+                                    #    由于 routes.py 在创建/分配会话时已将 IP 存入 client_sessions，
+                                    #    这里我们主要关注 client 实例和 active_context_hash。
+                                    #    如果 request_ip 在 self.client 中可用，则使用它，否则尝试保留已有的。
+                                    ip_to_use = request_ip if request_ip else user_specific_sessions.get(new_email_in_strategy, {}).get("ip", "unknown_ip_in_retry_update")
+                                    
+                                    # 需要导入 datetime
+                                    from datetime import datetime
+                                    
+                                    # 从 client 实例获取原始请求的上下文哈希
+                                    # 这个哈希应该由 routes.py 在调用 send_query 之前设置到 client 实例上
+                                    active_hash_for_new_session = getattr(self.client, '_current_request_context_hash', None)
+
+                                    user_specific_sessions[new_email_in_strategy] = {
+                                        "client": self.client, # 关键: 指向当前更新了 email/session_id 的 client 实例
+                                        "active_context_hash": active_hash_for_new_session, # 使用来自 client 实例的哈希
+                                        "last_time": datetime.now(), # 更新时间
+                                        "ip": ip_to_use
+                                    }
+                                    log_message_hash_part = f"set to '{active_hash_for_new_session}' (from client instance's _current_request_context_hash)" if active_hash_for_new_session is not None else "set to None (_current_request_context_hash not found on client instance)"
+                                    if hasattr(self.client, '_log'):
+                                        self.client._log(f"RateLimitStrategy: Updated/added session for new email '{new_email_in_strategy}' for user '{user_identifier}'. active_context_hash {log_message_hash_part}.", "INFO")
+                                else:
+                                    if hasattr(self.client, '_log'):
+                                        self.client._log(f"RateLimitStrategy: User '{user_identifier}' not found in client_sessions during update attempt.", "WARNING")
+                        # --- 更新 client_sessions 结束 ---
+
+                    except Exception as e:
+                        # 登录或创建会话失败，记录错误但不抛出异常
+                        # 让后续的重试机制处理
+                        if hasattr(self.client, '_log'):
+                            self.client._log(f"切换到账号 {new_email} 后登录或创建会话失败: {e}", "WARNING")
+                            # 此处不应更新 client_sessions，因为新账号的会话未成功建立
+
+
+class RetryHandler:
+    """重试处理器，管理多个重试策略"""
+    
+    def __init__(self, client=None, logger=None):
+        """
+        初始化重试处理器
+        
+        Args:
+            client: API客户端实例，用于切换账号
+            logger: 日志记录器或日志函数
+        """
+        self.client = client
+        # 如果logger是None，使用默认logger
+        # 如果logger是函数或Logger对象，直接使用
+        self.logger = logger or logging.getLogger(__name__)
+        self.strategies = [
+            ExponentialBackoffStrategy(),
+            LinearBackoffStrategy(),
+            ServerErrorStrategy(),
+            RateLimitStrategy(client)
+        ]
+    
+    def retry_operation(self, operation: Callable[..., T], *args, **kwargs) -> T:
+        """
+        使用重试策略执行操作
+        
+        Args:
+            operation: 要执行的操作
+            *args: 操作的位置参数
+            **kwargs: 操作的关键字参数
+            
+        Returns:
+            操作的结果
+            
+        Raises:
+            Exception: 如果所有重试都失败，则抛出最后一个异常
+        """
+        max_retries = config.get_config_value('max_retries')
+        base_delay = config.get_config_value('retry_delay')
+        retry_count = 0
+        last_exception = None
+        
+        while True:
+            try:
+                return operation(*args, **kwargs)
+            except Exception as e:
+                last_exception = e
+                
+                # 查找适用的重试策略
+                strategy = next((s for s in self.strategies if s.should_retry(e, retry_count, max_retries)), None)
+                
+                if strategy:
+                    retry_count += 1
+                    delay = strategy.get_retry_delay(retry_count, base_delay)
+                    strategy.log_retry_attempt(self.logger, e, retry_count, max_retries, delay)
+                    strategy.on_retry(e, retry_count)
+                    
+                    if delay > 0:
+                        time.sleep(delay)
+                else:
+                    # 没有适用的重试策略，或者已达到最大重试次数
+                    raise
+
+
+def with_retry(max_retries: Optional[int] = None, retry_delay: Optional[int] = None):
+    """
+    重试装饰器，用于装饰需要重试的方法
+    
+    Args:
+        max_retries: 最大重试次数，如果为None则使用配置值
+        retry_delay: 基础重试延迟，如果为None则使用配置值
+        
+    Returns:
+        装饰后的函数
+    """
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(self, *args, **kwargs):
+            # 获取配置值
+            _max_retries = max_retries or config.get_config_value('max_retries')
+            _retry_delay = retry_delay or config.get_config_value('retry_delay')
+            
+            # 创建重试处理器
+            handler = RetryHandler(client=self, logger=getattr(self, '_log', None))
+            
+            # 定义要重试的操作
+            def operation():
+                return func(self, *args, **kwargs)
+            
+            # 执行操作并处理重试
+            return handler.retry_operation(operation)
+        
+        return wrapper
+    
+    return decorator

routes.py

@@ -0,0 +1,1043 @@
+import json
+import time
+import uuid
+import html
+import hashlib # Added import
+from datetime import datetime
+from typing import Dict, List, Any, Optional
+from flask import request, Response, stream_with_context, jsonify, render_template, redirect, url_for, flash
+from datetime import datetime
+
+from utils import logger, generate_request_id, count_tokens, count_message_tokens
+import config
+from auth import RateLimiter
+from client import OnDemandAPIClient
+from datetime import timedelta
+
+# 初始化速率限制器
+# rate_limiter 将在 config_instance 定义后初始化
+
+# 获取配置实例
+config_instance = config.config_instance
+rate_limiter = RateLimiter(config_instance.get('rate_limit_per_minute', 60))  # 从配置读取，默认为60
+
+# 模型价格配置将从 config_instance 获取
+# 默认价格也将从 config_instance 获取
+
+def format_datetime(timestamp):
+    """将ISO格式时间戳格式化为更易读的格式"""
+    if not timestamp or timestamp == "从未保存":
+        return timestamp
+    
+    try:
+        # 处理ISO格式时间戳
+        if 'T' in timestamp:
+            dt = datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
+            return dt.strftime('%Y-%m-%d %H:%M:%S')
+        # 处理已经是格式化字符串的情况
+        return timestamp
+    except Exception:
+        return timestamp
+
+def format_number(value):
+    """根据数值大小自动转换单位"""
+    if value is None or value == '-':
+        return '-'
+    
+    try:
+        value = float(value)
+        if value >= 1000000000000:  # 万亿 (T)
+            return f"{value/1000000000000:.2f}T"
+        elif value >= 1000000000:  # 十亿 (G)
+            return f"{value/1000000000:.2f}G"
+        elif value >= 1000000:  # 百万 (M)
+            return f"{value/1000000:.2f}M"
+        elif value >= 1000:  # 千 (K)
+            return f"{value/1000:.2f}K"
+        elif value == 0:  # 零
+            return "0"
+        elif abs(value) < 0.01:  # 非常小的数值，使用科学计数法
+            return f"{value:.2e}"
+        else:
+            return f"{value:.0f}" if value == int(value) else f"{value:.2f}"
+    except (ValueError, TypeError):
+        return str(value)
+
+def format_duration(ms):
+    """将毫秒格式化为更易读的格式"""
+    if ms is None or ms == '-':
+        return '-'
+    
+    try:
+        ms = float(ms)  # 使用float而不是int，以支持小数
+        if ms >= 86400000:  # 超过1天 (24*60*60*1000)
+            return f"{ms/86400000:.2f}天"
+        elif ms >= 3600000:  # 超过1小时 (60*60*1000)
+            return f"{ms/3600000:.2f}小时"
+        elif ms >= 60000:  # 超过1分钟 (60*1000)
+            return f"{ms/60000:.2f}分钟"
+        elif ms >= 1000:  # 超过1秒
+            return f"{ms/1000:.2f}秒"
+        else:
+            return f"{ms:.0f}" if ms == int(ms) else f"{ms:.2f}毫秒"
+    except (ValueError, TypeError):
+        return str(ms)
+
+def _update_usage_statistics(
+    config_inst,
+    request_id: str,
+    requested_model_name: str,
+    account_email: Optional[str],
+    is_success: bool,
+    duration_ms: int,
+    is_stream: bool,
+    prompt_tokens_val: int,
+    completion_tokens_val: int,
+    total_tokens_val: int,
+    prompt_length: Optional[int] = None,
+    completion_length: Optional[int] = None,
+    error_message: Optional[str] = None,
+    used_actual_tokens_for_history: bool = False
+):
+    """更新使用统计与请求历史的辅助函数。"""
+    with config_inst.usage_stats_lock:
+        config_inst.usage_stats["total_requests"] += 1
+        
+        current_email_for_stats = account_email if account_email else "unknown_account"
+
+        if is_success:
+            config_inst.usage_stats["successful_requests"] += 1
+            config_inst.usage_stats["model_usage"].setdefault(requested_model_name, 0)
+            config_inst.usage_stats["model_usage"][requested_model_name] += 1
+            
+            config_inst.usage_stats["account_usage"].setdefault(current_email_for_stats, 0)
+            config_inst.usage_stats["account_usage"][current_email_for_stats] += 1
+
+            config_inst.usage_stats["total_prompt_tokens"] += prompt_tokens_val
+            config_inst.usage_stats["total_completion_tokens"] += completion_tokens_val
+            config_inst.usage_stats["total_tokens"] += total_tokens_val
+            config_inst.usage_stats["model_tokens"].setdefault(requested_model_name, 0)
+            config_inst.usage_stats["model_tokens"][requested_model_name] += total_tokens_val
+
+            today = datetime.now().strftime("%Y-%m-%d")
+            hour = datetime.now().strftime("%Y-%m-%d %H:00")
+            
+            config_inst.usage_stats["daily_usage"].setdefault(today, 0)
+            config_inst.usage_stats["daily_usage"][today] += 1
+            
+            config_inst.usage_stats["hourly_usage"].setdefault(hour, 0)
+            config_inst.usage_stats["hourly_usage"][hour] += 1
+            
+            config_inst.usage_stats["daily_tokens"].setdefault(today, 0)
+            config_inst.usage_stats["daily_tokens"][today] += total_tokens_val
+            
+            config_inst.usage_stats["hourly_tokens"].setdefault(hour, 0)
+            config_inst.usage_stats["hourly_tokens"][hour] += total_tokens_val
+        else:
+            config_inst.usage_stats["failed_requests"] += 1
+
+        history_entry = {
+            "id": request_id,
+            "timestamp": datetime.now().isoformat(),
+            "model": requested_model_name,
+            "account": current_email_for_stats,
+            "success": is_success,
+            "duration_ms": duration_ms,
+            "stream": is_stream,
+        }
+
+        if is_success:
+            if prompt_length is not None:
+                history_entry["prompt_length"] = prompt_length
+            if completion_length is not None:
+                history_entry["completion_length"] = completion_length
+            
+            if is_stream:
+                if used_actual_tokens_for_history:
+                    history_entry["prompt_tokens"] = prompt_tokens_val
+                    history_entry["completion_tokens"] = completion_tokens_val
+                    history_entry["total_tokens"] = total_tokens_val
+                else:
+                    history_entry["prompt_tokens"] = prompt_tokens_val
+                    history_entry["estimated_completion_tokens"] = completion_tokens_val
+                    history_entry["estimated_total_tokens"] = total_tokens_val
+            else: 
+                history_entry["prompt_tokens"] = prompt_tokens_val
+                history_entry["completion_tokens"] = completion_tokens_val
+                history_entry["total_tokens"] = total_tokens_val
+        else: 
+            if error_message:
+                history_entry["error"] = error_message
+            if prompt_tokens_val > 0:
+                 history_entry["prompt_tokens_attempted"] = prompt_tokens_val
+
+        config_inst.usage_stats["request_history"].append(history_entry)
+        max_history_items = config_inst.get('max_history_items', 1000)
+        if len(config_inst.usage_stats["request_history"]) > max_history_items:
+            config_inst.usage_stats["request_history"] = \
+                config_inst.usage_stats["request_history"][-max_history_items:]
+
+def _generate_hash_for_full_history(full_messages_list: List[Dict[str, str]], req_id: str) -> Optional[str]:
+    """
+    Generates a SHA256 hash from a list of messages, considering all messages.
+    """
+    if not full_messages_list:
+        logger.debug(f"[{req_id}] (_generate_hash_for_full_history) No messages to hash.")
+        return None
+    try:
+        # Ensure consistent serialization for hashing
+        # Context meaning is only in role and content
+        simplified_history = [{"role": msg.get("role"), "content": msg.get("content")} for msg in full_messages_list]
+        serialized_history = json.dumps(simplified_history, sort_keys=True)
+        return hashlib.sha256(serialized_history.encode('utf-8')).hexdigest()
+    except (TypeError, ValueError) as e:
+        logger.error(f"[{req_id}] (_generate_hash_for_full_history) Failed to serialize full history messages for hashing: {e}")
+        return None
+
+def _update_client_context_hash_after_reply(
+    original_request_messages: List[Dict[str, str]],
+    assistant_reply_content: str,
+    request_id: str,
+    user_identifier: str, # Corresponds to 'token' in chat_completions
+    email_for_stats: Optional[str],
+    current_ondemand_client_instance: Optional[OnDemandAPIClient],
+    config_inst: config.Config,
+    logger_instance # Pass logger directly
+):
+    """
+    Helper to update the client's active_context_hash after a successful reply
+    using the full conversation history up to the assistant's reply.
+    """
+    if not assistant_reply_content or not email_for_stats or not current_ondemand_client_instance:
+        logger_instance.debug(f"[{request_id}] 更新客户端上下文哈希的条件不足（回复内容 '{bool(assistant_reply_content)}', 邮箱 '{email_for_stats}', 客户端实例 '{bool(current_ondemand_client_instance)}'），跳过。")
+        return
+
+    assistant_message = {"role": "assistant", "content": assistant_reply_content}
+    # original_request_messages should be the messages list as it was when the request came in.
+    full_history_up_to_assistant_reply = original_request_messages + [assistant_message]
+    
+    next_active_context_hash = _generate_hash_for_full_history(full_history_up_to_assistant_reply, request_id)
+    
+    if next_active_context_hash:
+        with config_inst.client_sessions_lock:
+            if user_identifier in config_inst.client_sessions and \
+               email_for_stats in config_inst.client_sessions[user_identifier]:
+                
+                session_data_to_update = config_inst.client_sessions[user_identifier][email_for_stats]
+                client_in_session = session_data_to_update.get("client")
+
+                # DEBUGGING LOGS START
+                logger_instance.debug(f"[{request_id}] HASH_UPDATE_DEBUG: client_in_session id={id(client_in_session)}, email={getattr(client_in_session, 'email', 'N/A')}, session_id={getattr(client_in_session, 'session_id', 'N/A')}")
+                logger_instance.debug(f"[{request_id}] HASH_UPDATE_DEBUG: current_ondemand_client_instance id={id(current_ondemand_client_instance)}, email={getattr(current_ondemand_client_instance, 'email', 'N/A')}, session_id={getattr(current_ondemand_client_instance, 'session_id', 'N/A')}")
+                logger_instance.debug(f"[{request_id}] HASH_UPDATE_DEBUG: Comparison result (client_in_session == current_ondemand_client_instance): {client_in_session == current_ondemand_client_instance}")
+                logger_instance.debug(f"[{request_id}] HASH_UPDATE_DEBUG: Comparison result (client_in_session is current_ondemand_client_instance): {client_in_session is current_ondemand_client_instance}")
+                # DEBUGGING LOGS END
+
+                if client_in_session == current_ondemand_client_instance:
+                    old_hash = session_data_to_update.get("active_context_hash")
+                    session_data_to_update["active_context_hash"] = next_active_context_hash
+                    session_data_to_update["last_time"] = datetime.now()
+                    logger_instance.info(f"[{request_id}] 客户端 (账户: {email_for_stats}) 的 active_context_hash 已从 '{old_hash}' 更新为 '{next_active_context_hash}' 以反映对话进展。")
+                else:
+                    logger_instance.warning(f"[{request_id}] 尝试更新哈希时，发现 email_for_stats '{email_for_stats}' 对应的存储客户端与当前使用的 ondemand_client 不一致。跳过更新。")
+            else:
+                logger_instance.warning(f"[{request_id}] 尝试更新哈希时，在 client_sessions 中未找到用户 '{user_identifier}' 或账户 '{email_for_stats}'。跳过更新。")
+    else:
+        logger_instance.warning(f"[{request_id}] 未能为下一次交互生成新的 active_context_hash (基于回复 '{bool(assistant_reply_content)}'). 客户端的哈希未更新。")
+ 
+def _get_context_key_from_messages(messages: List[Dict[str, str]], req_id: str) -> Optional[str]:
+    """
+    从末次用户消息前的消息列表生成上下文哈希密钥。
+    """
+    if not messages:
+        logger.debug(f"[{req_id}] 无消息可供生成上下文密钥。")
+        return None
+
+    last_user_msg_idx = -1
+    for i in range(len(messages) - 1, -1, -1):
+        if messages[i].get('role') == 'user':
+            last_user_msg_idx = i
+            break
+    
+    # 若无用户消息或用户消息为首条，则无先前历史可生成上下文密钥。
+    if last_user_msg_idx <= 0:
+        logger.debug(f"[{req_id}] 无先前历史可生成上下文密钥 (last_user_msg_idx: {last_user_msg_idx})。")
+        return None
+    
+    historical_messages = messages[:last_user_msg_idx]
+    if not historical_messages: # 应由 last_user_msg_idx <= 0 捕获，此处为额外保障
+        logger.debug(f"[{req_id}] 上下文密钥的历史消息列表为空。")
+        return None
+
+    try:
+        # 确保哈希序列化的一致性
+        # 上下文意义仅关注角色和内容
+        simplified_history = [{"role": msg.get("role"), "content": msg.get("content")} for msg in historical_messages]
+        serialized_history = json.dumps(simplified_history, sort_keys=True)
+        return hashlib.sha256(serialized_history.encode('utf-8')).hexdigest()
+    except (TypeError, ValueError) as e:
+        logger.error(f"[{req_id}] 序列化历史消息以生成上下文密钥失败: {e}")
+        return None
+
+def register_routes(app):
+    """注册所有路由到Flask应用"""
+    
+    # 注册自定义过滤器
+    app.jinja_env.filters['format_datetime'] = format_datetime
+    app.jinja_env.filters['format_number'] = format_number
+    app.jinja_env.filters['format_duration'] = format_duration
+    
+    @app.route('/health', methods=['GET'])
+    def health_check():
+        """健康检查端点，返回服务状态"""
+        return {"status": "ok", "message": "2API服务运行正常"}, 200
+    
+    @app.route('/v1/models', methods=['GET'])
+    def list_models():
+        """以 OpenAI 格式返回可用模型列表。"""
+        data = []
+        # 获取当前时间戳，用于 'created' 字段
+        created_time = int(time.time())
+        model_mapping = config_instance._model_mapping
+        for openai_name in model_mapping.keys():  # 仅列出已映射的模型
+            data.append({
+                "id": openai_name,
+                "object": "model",
+                "created": created_time,
+                "owned_by": "on-demand.io"  # 或根据模型来源填写 "openai", "anthropic" 等
+            })
+        return {"object": "list", "data": data}
+    
+    @app.route('/v1/chat/completions', methods=['POST'])
+    def chat_completions():
+        """处理聊天补全请求，兼容 OpenAI 格式。"""
+        request_id = generate_request_id()  # 生成唯一的请求 ID
+        logger.info(f"[{request_id}] CHAT_COMPLETIONS_ENTRY_POINT") # 最早的日志点
+        client_ip = request.remote_addr  # 获取客户端 IP 地址，仅用于日志记录
+        logger.info(f"[{request_id}] 收到来自 IP: {client_ip} 的 /v1/chat/completions 请求")
+
+        # 尝试在更早的位置打印一些调试信息
+        logger.info(f"[{request_id}] DEBUG_ENTRY: 进入 chat_completions。")
+        
+        # 验证访问令牌
+        auth_header = request.headers.get('Authorization')
+        if not auth_header or not auth_header.startswith('Bearer '):
+            logger.warning(f"[{request_id}] 未提供认证令牌或格式错误")
+            return {"error": {"message": "缺少有效的认证令牌", "type": "auth_error", "code": "missing_token"}}, 401
+        
+        # 获取API访问令牌
+        api_access_token = config_instance.get('api_access_token')
+        token = auth_header[7:]  # 去掉 'Bearer ' 前缀
+        if token != api_access_token:
+            logger.warning(f"[{request_id}] 提供了无效的认证令牌")
+            return {"error": {"message": "无效的认证令牌", "type": "auth_error", "code": "invalid_token"}}, 401
+
+        # 检查速率限制 - 使用token而不是IP进行限制
+        if not rate_limiter.is_allowed(token):
+            logger.warning(f"[{request_id}] 用户 {token[:8]}... 超过速率限制")
+            return {"error": {"message": "请求频率过高，请稍后再试", "type": "rate_limit_error", "code": "rate_limit_exceeded"}}, 429
+
+        openai_data = request.get_json()
+        if not openai_data:
+            logger.error(f"[{request_id}] 请求体不是有效的JSON")
+            return {"error": {"message": "请求体必须是 JSON。", "type": "invalid_request_error", "code": None}}, 400
+        
+        if app.config.get('DEBUG_MODE', False):
+            logger.debug(f"[{request_id}] OpenAI 请求数据: {json.dumps(openai_data, indent=2, ensure_ascii=False)}")
+
+        # 从 OpenAI 请求中提取参数
+        # Capture the initial messages from the request for later use in rolling hash update
+        initial_messages_from_request: List[Dict[str, str]] = openai_data.get('messages', [])
+        messages: List[Dict[str, str]] = initial_messages_from_request # Keep 'messages' for existing logic
+        stream_requested: bool = openai_data.get('stream', False)
+        # 如果请求中没有指定模型，则使用映射表中的一个默认模型，或者最终的 DEFAULT_ENDPOINT_ID
+        model_mapping = config_instance._model_mapping
+        default_endpoint_id = config_instance.get('default_endpoint_id')
+        requested_model_name: str = openai_data.get('model', list(model_mapping.keys())[0] if model_mapping else default_endpoint_id)
+        
+        # 从请求中获取参数，如果未提供则为 None
+        temperature: Optional[float] = openai_data.get('temperature')
+        max_tokens: Optional[int] = openai_data.get('max_tokens')
+        top_p: Optional[float] = openai_data.get('top_p')
+        frequency_penalty: Optional[float] = openai_data.get('frequency_penalty')
+        presence_penalty: Optional[float] = openai_data.get('presence_penalty')
+
+        if not messages:
+            logger.error(f"[{request_id}] 缺少 'messages' 字段")
+            return {"error": {"message": "缺少 'messages' 字段。", "type": "invalid_request_error", "code": "missing_messages"}}, 400
+
+        # 为 on-demand.io 构建查询
+        # on-demand.io 通常接受单个查询字符串，上下文由其会话管理。
+        # 我们将发送最新的用户查询，可选地以系统提示为前缀。
+        # --- 上下文感知会话管理与查询构建 (v2) ---
+
+        # 1. 提取消息组件与上下文密钥
+        logger.info(f"[{request_id}] DEBUG_PRE_HASH_COMPUTATION: 即将计算 request_context_hash。")
+        request_context_hash = _get_context_key_from_messages(messages, request_id)
+        logger.info(f"[{request_id}] 请求上下文哈希值: {repr(request_context_hash)}") # 使用 repr()
+
+        logger.info(f"[{request_id}] DEBUG_POINT_A: 即将初始化 historical_messages。")
+        historical_messages = []
+        logger.info(f"[{request_id}] DEBUG_POINT_B: historical_messages 初始化为空列表。即将检查 request_context_hash ({repr(request_context_hash)}).")
+
+        if request_context_hash: # 注意：空字符串的布尔值为 False
+            logger.info(f"[{request_id}] DEBUG_POINT_C: request_context_hash ({repr(request_context_hash)}) 为真，进入历史提取块。")
+            last_user_idx = -1
+            try:
+                for i in range(len(messages) - 1, -1, -1):
+                    if messages[i].get('role') == 'user': last_user_idx = i; break
+            except Exception as e_loop:
+                logger.error(f"[{request_id}] DEBUG_LOOP_ERROR: 在查找 last_user_idx 的循环中发生错误: {e_loop}")
+                last_user_idx = -1 # 确保安全
+
+            logger.info(f"[{request_id}] DEBUG_POINT_D: last_user_idx = {last_user_idx}")
+            if last_user_idx > 0:
+                try:
+                    historical_messages = messages[:last_user_idx]
+                    logger.info(f"[{request_id}] DEBUG_POINT_E: historical_messages 赋值自 messages[:{last_user_idx}]")
+                except Exception as e_slice:
+                    logger.error(f"[{request_id}] DEBUG_SLICE_ERROR: 在切片 messages[:{last_user_idx}] 时发生错误: {e_slice}")
+                    historical_messages = [] # 确保安全
+            
+            if historical_messages:
+                logger.info(f"[{request_id}] DEBUG_HISTORICAL_CONTENT: 'historical_messages' 提取后内容: {json.dumps(historical_messages, ensure_ascii=False, indent=2)}")
+            else:
+                logger.info(f"[{request_id}] DEBUG_HISTORICAL_EMPTY: 'historical_messages' 提取后为空列表。last_user_idx={last_user_idx}, request_context_hash='{request_context_hash}'")
+        
+        elif not request_context_hash: # request_context_hash is None or empty string
+             logger.info(f"[{request_id}] DEBUG_HISTORICAL_NOHASH: 'request_context_hash' ({repr(request_context_hash)}) 为假, 'historical_messages' 保持为空列表。")
+
+        logger.info(f"[{request_id}] DEBUG_POST_HISTORICAL_EXTRACTION: 即将提取 system 和 user query。")
+        current_system_prompts_contents = [msg['content'] for msg in messages if msg.get('role') == 'system' and msg.get('content')]
+        system_prompt_combined = "\n".join(current_system_prompts_contents)
+        
+        current_user_messages_contents = [msg['content'] for msg in messages if msg.get('role') == 'user' and msg.get('content')]
+        current_user_query = current_user_messages_contents[-1] if current_user_messages_contents else ""
+
+        if not current_user_query: # 此检查至关重要
+            logger.error(f"[{request_id}] 'messages' 中未找到有效的 'user' 角色的消息内容。")
+            # 记录调试消息
+            logger.debug(f"[{request_id}] 接收到的消息: {json.dumps(messages, ensure_ascii=False)}")
+            return {"error": {"message": "'messages' 中未找到有效的 'user' 角色的消息内容。", "type": "invalid_request_error", "code": "no_user_message"}}, 400
+ 
+        user_identifier = token
+        # 记录请求开始时间，确保在所有路径中 duration_ms 可用
+        request_start_time = time.time()
+        ondemand_client = None
+        email_for_stats = None # 此为 OnDemandAPIClient 所用账户的邮箱
+        # 初始化 is_newly_assigned_context，默认为 True，如果后续阶段匹配成功会被修改
+        is_newly_assigned_context = True
+        
+        # 获取会话超时配置
+        ondemand_session_timeout_minutes = config_instance.get('ondemand_session_timeout_minutes', 30)
+        logger.info(f"[{request_id}] OnDemand 会话超时设置为: {ondemand_session_timeout_minutes} 分钟。")
+        # 将分钟转换为 timedelta 对象，便于比较
+        session_timeout_delta = timedelta(minutes=ondemand_session_timeout_minutes)
+
+        with config_instance.client_sessions_lock:
+            current_time_dt = datetime.now() # 使用 datetime 对象进行比较
+            if user_identifier not in config_instance.client_sessions:
+                config_instance.client_sessions[user_identifier] = {}
+            user_sessions_for_id = config_instance.client_sessions[user_identifier]
+
+            # 阶段 0: 优先复用“活跃”会话
+            # 遍历时按 last_time 降序排列，优先选择最近使用的活跃会话
+            sorted_sessions = sorted(
+                user_sessions_for_id.items(),
+                key=lambda item: item[1].get("last_time", datetime.min),
+                reverse=True
+            )
+
+            for acc_email_p0, session_data_p0 in sorted_sessions:
+                client_p0 = session_data_p0.get("client")
+                last_time_p0 = session_data_p0.get("last_time")
+
+                if client_p0 and client_p0.token and client_p0.session_id and last_time_p0:
+                    if (current_time_dt - last_time_p0) < session_timeout_delta: # 使用 session_timeout_delta
+                        stored_active_hash = session_data_p0.get("active_context_hash")
+                        hash_match_status = "匹配" if stored_active_hash == request_context_hash else "不匹配"
+                        logger.info(f"[{request_id}] 阶段0: 找到账户 {acc_email_p0} 的活跃会话。请求上下文哈希 ({request_context_hash or 'None'}) 与存储哈希 ({stored_active_hash or 'None'}) {hash_match_status}。")
+
+                        # 新增：检查上下文哈希是否匹配
+                        if stored_active_hash == request_context_hash:
+                            # 如果哈希匹配，则复用此客户端
+                            ondemand_client = client_p0
+                            email_for_stats = acc_email_p0
+                            ondemand_client._associated_user_identifier = user_identifier
+                            ondemand_client._associated_request_ip = client_ip
+                            session_data_p0["last_time"] = current_time_dt # 使用 current_time_dt
+                            session_data_p0["ip"] = client_ip
+                            is_newly_assigned_context = False # 复用现有活跃会话
+                            logger.info(f"[{request_id}] 阶段0: 上下文哈希匹配，复用账户 {email_for_stats} 的活跃会话。")
+                            break # 已找到并复用活跃客户端
+                        else:
+                            logger.info(f"[{request_id}] 阶段0: 上下文哈希不匹配，跳过复用此活跃会话。")
+                            # Continue the loop to check other sessions or proceed to Stage 1
+
+            # 阶段 1: 若阶段0失败，则查找已服务此 context_hash 的客户端 (精确哈希匹配)
+            if not ondemand_client and request_context_hash: # 只有在 request_context_hash 存在时才进行阶段1匹配
+                for acc_email_p1, session_data_p1 in user_sessions_for_id.items(): # 无需再次排序，因为阶段0已处理最优选择
+                    client_p1 = session_data_p1.get("client")
+                    if client_p1 and client_p1.token and client_p1.session_id and \
+                       session_data_p1.get("active_context_hash") == request_context_hash:
+                        
+                        # 检查此精确匹配的会话是否也“活跃”，如果不活跃，可能不如创建一个新的
+                        last_time_p1 = session_data_p1.get("last_time")
+                        if last_time_p1 and (current_time_dt - last_time_p1) >= session_timeout_delta: # 使用 session_timeout_delta
+                            logger.info(f"[{request_id}] 阶段1: 找到精确哈希匹配的账户 {acc_email_p1}，但其会话已超时。将跳过并尝试创建新会话。")
+                            continue # 跳过这个超时的精确匹配
+
+                        ondemand_client = client_p1
+                        email_for_stats = acc_email_p1
+                        ondemand_client._associated_user_identifier = user_identifier
+                        ondemand_client._associated_request_ip = client_ip
+                        session_data_p1["last_time"] = current_time_dt # 使用 current_time_dt
+                        session_data_p1["ip"] = client_ip
+                        is_newly_assigned_context = False # 精确上下文匹配
+                        logger.info(f"[{request_id}] 阶段1: 上下文精确匹配。复用账户 {email_for_stats} 的客户端 (上下文哈希: {request_context_hash})。")
+                        break # 已找到客户端
+            
+            # 阶段 2: 若阶段0和阶段1均失败，则必须创建新客户端会话
+            if not ondemand_client:
+                logger.info(f"[{request_id}] 阶段0及阶段1均未找到可复用会话 (请求上下文哈希: {request_context_hash or 'None'})。尝试获取/创建新客户端会话。")
+                MAX_ACCOUNT_ATTEMPTS = config_instance.get('max_account_attempts', 3) # 从配置获取或默认3
+                for attempt in range(MAX_ACCOUNT_ATTEMPTS):
+                        new_ondemand_email, new_ondemand_password = config.get_next_ondemand_account_details()
+                        if not new_ondemand_email:
+                            logger.error(f"[{request_id}] 尝试 {attempt+1} 次后，配置中无可用 OnDemand 账户。")
+                            break
+
+                        email_for_stats = new_ondemand_email # 本次尝试暂设值
+                        
+                        # 检查 user_identifier 是否已对 new_ondemand_email 存在会话数据，但可能 client 实例需要重建
+                        # 或者这是一个全新的账户分配给此 user_identifier
+                        
+                        # 总是尝试创建新的 OnDemandAPIClient 实例和新的 OnDemand session_id
+                        # 因为到这一步意味着我们没有找到合适的现有活跃会话来复用其 session_id
+                        logger.info(f"[{request_id}] 阶段2: 为账户 {new_ondemand_email} 创建新客户端实例和会话 (尝试 {attempt+1})。")
+                        client_id_for_log = f"{user_identifier[:8]}-{new_ondemand_email.split('@')[0]}-{request_id[:4]}" # 更具区分度的 client_id
+                        temp_ondemand_client = OnDemandAPIClient(new_ondemand_email, new_ondemand_password, client_id=client_id_for_log)
+                        
+                        if not temp_ondemand_client.sign_in() or not temp_ondemand_client.create_session():
+                            logger.error(f"[{request_id}] 为 {new_ondemand_email} 初始化新客户端会话失败: {temp_ondemand_client.last_error}")
+                            # 此处不将 ondemand_client 设为 None，因为 email_for_stats 需要在失败统计时使用
+                            # email_for_stats = None # 移除，以确保失败统计时有邮箱
+                            continue # 尝试下一账户
+                        
+                        ondemand_client = temp_ondemand_client # 成功创建，赋值
+                        ondemand_client._associated_user_identifier = user_identifier
+                        ondemand_client._associated_request_ip = client_ip
+                                                 
+                        user_sessions_for_id[new_ondemand_email] = {
+                            "client": ondemand_client,
+                            "last_time": current_time_dt, # 使用 current_time_dt
+                            "ip": client_ip,
+                            "active_context_hash": request_context_hash # 新会话关联到当前请求的上下文哈希
+                        }
+                        is_newly_assigned_context = True # 这是一个新的 OnDemand 会话，或者为现有账户分配了新的上下文
+                        logger.info(f"[{request_id}] 阶段2: 已为账户 {email_for_stats} 成功创建/分配新客户端会话 (is_newly_assigned_context=True, 关联上下文哈希: {request_context_hash or 'None'})。")
+                        break # 跳出账户尝试循环，客户端就绪
+                
+                if not ondemand_client: # 获取/创建客户端尝试均失败
+                    # is_newly_assigned_context 此时应保持为 True (其默认值)
+                    last_attempt_error = temp_ondemand_client.last_error if 'temp_ondemand_client' in locals() and temp_ondemand_client else '未知错误'
+                    logger.error(f"[{request_id}] 尝试 {MAX_ACCOUNT_ATTEMPTS} 次后获取/创建客户端失败 (is_newly_assigned_context 保持为 {is_newly_assigned_context})。最后一次尝试失败原因: {last_attempt_error}")
+                    
+                    prompt_tok_val_err, _, _ = count_message_tokens(messages, requested_model_name)
+                    _update_usage_statistics(
+                        config_inst=config_instance, request_id=request_id, requested_model_name=requested_model_name,
+                        account_email=email_for_stats, # 可能为最后尝试的邮箱或None
+                        is_success=False, duration_ms=int((time.time() - request_start_time) * 1000), # request_start_time 可能未定义
+                        is_stream=stream_requested, prompt_tokens_val=prompt_tok_val_err or 0,
+                        completion_tokens_val=0, total_tokens_val=prompt_tok_val_err or 0,
+                        error_message=f"多次尝试后获取/创建客户端会话失败。最后一次尝试失败原因: {last_attempt_error}"
+                    )
+                    return {"error": {"message": f"当前无法与 OnDemand 服务建立会话。最后一次尝试失败原因: {last_attempt_error}", "type": "api_error", "code": "ondemand_session_unavailable"}}, 503
+
+        # --- 会话管理结束 ---
+
+        # 4. 基于 is_newly_assigned_context 构建 final_query_to_ondemand
+        final_query_to_ondemand = ""
+        query_parts = []
+
+        # 在构建查询之前，记录关键变量的状态
+        logger.debug(f"[{request_id}] 查询构建前状态：is_newly_assigned_context={is_newly_assigned_context}, request_context_hash='{request_context_hash}', historical_messages_empty={not bool(historical_messages)}")
+        if historical_messages: # 只在列表非空时尝试序列化
+            logger.debug(f"[{request_id}] 查询构建前状态：historical_messages 内容: {json.dumps(historical_messages, ensure_ascii=False, indent=2)}")
+        else:
+            logger.debug(f"[{request_id}] 查询构建前状态：historical_messages 为空列表。")
+
+        if is_newly_assigned_context:
+            # 阶段2：新建/重分配会话
+            logger.info(f"[{request_id}] 查询构建：会话为新建/重分配 (is_newly_assigned_context=True, 账户: {email_for_stats})。")
+            
+            # 在新建会话时，如果存在系统提示，则添加到 query_parts
+            if system_prompt_combined:
+                query_parts.append(f"System: {system_prompt_combined}")
+                logger.debug(f"[{request_id}] 查询构建：新建会话，添加了合并的系统提示。")
+
+            if request_context_hash and historical_messages: # 有历史上下文 (historical_messages 已在前面提取)
+                logger.info(f"[{request_id}] 查询构建：存在历史上下文 ({request_context_hash})，将发送历史消息。")
+                formatted_historical_parts = []
+                for msg in historical_messages: # historical_messages 是 messages[:last_user_idx]
+                    role = msg.get('role', 'unknown').capitalize()
+                    content = msg.get('content', '')
+                    if content: formatted_historical_parts.append(f"{role}: {content}")
+                if formatted_historical_parts: query_parts.append("\n".join(formatted_historical_parts))
+            else: # 无历史上下文 (例如对话首条消息，或 request_context_hash 为 None)
+                logger.info(f"[{request_id}] 查询构建：无历史上下文。仅发送当前用户查询。") # 系统提示已在前面处理
+
+        else:
+            # 阶段0或阶段1：复用现有会话
+            # 不发送 historical_messages 和 system prompt，信任 OnDemand API 通过 session_id 维护上下文
+            stored_active_hash = "N/A"
+            if ondemand_client: # ondemand_client 应该总是存在的，除非前面逻辑有误
+                 # 尝试从 client_sessions 获取最新的哈希，因为 client 实例可能刚被更新
+                client_session_data = config_instance.client_sessions.get(user_identifier, {}).get(email_for_stats, {})
+                stored_active_hash = client_session_data.get('active_context_hash', 'N/A')
+
+            hash_match_status = "匹配" if stored_active_hash == request_context_hash else "不匹配"
+            logger.info(f"[{request_id}] 查询构建：复用现有会话 (is_newly_assigned_context=False, 账户: {email_for_stats})。不发送历史消息或系统提示。请求上下文哈希 ({request_context_hash or 'None'}) 与存储哈希 ({stored_active_hash or 'None'}) {hash_match_status}。")
+
+        # 始终添加当前用户查询
+        if current_user_query: # current_user_query 是 messages 中最后一个用户消息的内容
+            query_parts.append(f"User: {current_user_query}")
+            logger.debug(f"[{request_id}] 查询构建：添加了当前用户查询。")
+        else: # 此情况应在早期被捕获 (messages 中无 user role)
+            logger.error(f"[{request_id}] 严重错误: 最终查询构建时 current_user_query 为空！")
+            if not query_parts: query_parts.append(" ") # 确保查询非空
+
+        final_query_to_ondemand = "\n\n".join(filter(None, query_parts))
+        if not final_query_to_ondemand.strip(): # 确保查询字符串实际有内容
+            logger.warning(f"[{request_id}] 构建的查询为空或全为空格。发送占位符查询。")
+            final_query_to_ondemand = " "
+        
+        logger.info(f"[{request_id}] 构建的 OnDemand 查询 (前1000字符): {final_query_to_ondemand[:1000]}...")
+
+        # 根据请求的模型名称获取 on-demand.io 的 endpoint_id
+        endpoint_id = model_mapping.get(requested_model_name, default_endpoint_id)
+        if requested_model_name not in model_mapping:
+            logger.warning(f"[{request_id}] 模型 '{requested_model_name}' 不在映射表中, 将使用默认端点 '{default_endpoint_id}'.")
+
+        # 构建模型配置，只包含用户明确提供的参数
+        model_configs = {}
+        
+        # 构建模型配置，只包含用户明确提供的参数 (值为None的参数不会被包含)
+        if temperature is not None:
+            model_configs["temperature"] = temperature
+        if max_tokens is not None:
+            model_configs["maxTokens"] = max_tokens
+        if top_p is not None:
+            model_configs["topP"] = top_p
+        if frequency_penalty is not None:
+            model_configs["frequency_penalty"] = frequency_penalty
+        if presence_penalty is not None:
+            model_configs["presence_penalty"] = presence_penalty
+            
+        logger.info(f"[{request_id}] 构建的模型配置: {json.dumps(model_configs, ensure_ascii=False)}")
+ 
+        # request_start_time 已移至会话管理之前
+        
+        # 在调用 send_query 之前，将 request_context_hash 存储到 ondemand_client 实例上
+        # 以便在 RateLimitStrategy 中进行账户切换时可以访问到它
+        if ondemand_client: #确保 ondemand_client 不是 None
+            ondemand_client._current_request_context_hash = request_context_hash
+            logger.debug(f"[{request_id}] Stored request_context_hash ('{request_context_hash}') onto ondemand_client instance before send_query.")
+        else:
+            logger.error(f"[{request_id}] CRITICAL: ondemand_client is None before send_query. This should not happen.")
+            # 可以在这里决定是否提前返回错误，或者让后续的 send_query 调用失败
+            # 为安全起见，如果 ondemand_client 为 None，后续调用会 AttributeError
+
+        # 使用特定于此 IP 的客户端实例向 OnDemand API 发送查询
+        ondemand_result = ondemand_client.send_query(final_query_to_ondemand, endpoint_id=endpoint_id,
+                                                     stream=stream_requested, model_configs_input=model_configs)
+            
+        # 处理响应
+        if stream_requested:
+            # 流式响应
+            def generate_openai_stream(captured_initial_request_messages: List[Dict[str, str]]):
+                full_assistant_reply_parts = [] # For aggregating streamed reply
+                stream_response_obj = ondemand_result.get("response_obj")
+                if not stream_response_obj:  # 确保 response_obj 存在
+                    # 计算token数量（仅提示部分，因为流式响应无法准确计算完成tokens）
+                    prompt_tokens, _, _ = count_message_tokens(messages, requested_model_name)
+                    # 确保prompt_tokens不为None
+                    if prompt_tokens is None:
+                        prompt_tokens = 0
+                    # 错误情况下，完成tokens为0
+                    estimated_completion_tokens = 0
+                    # 错误情况下，总tokens等于提示tokens
+                    estimated_total_tokens = prompt_tokens
+                    
+                    error_json = {
+                        "id": request_id,
+                        "object": "chat.completion.chunk",
+                        "created": int(time.time()),
+                        "model": requested_model_name,
+                        "choices": [{"delta": {"content": "[流错误：未获取到响应对象]"}, "index": 0, "finish_reason": "error"}],
+                        "usage": {  # 添加token统计信息
+                            "prompt_tokens": prompt_tokens,
+                            "completion_tokens": estimated_completion_tokens,
+                            "total_tokens": estimated_total_tokens
+                        }
+                    }
+                    yield f"data: {json.dumps(error_json, ensure_ascii=False)}\n\n"
+                    yield "data: [DONE]\n\n"
+                    return
+
+                logger.info(f"[{request_id}] 开始流式传输 OpenAI 格式的响应。")
+                # 初始化token计数变量
+                actual_input_tokens = None
+                actual_output_tokens = None
+                actual_total_tokens = None
+                
+                try:
+                    for line in stream_response_obj.iter_lines():
+                        if line:
+                            decoded_line = line.decode('utf-8')
+                            if decoded_line.startswith("data:"):
+                                json_str = decoded_line[len("data:"):].strip()
+                                if json_str == "[DONE]":  # 这是 on-demand.io 的结束标记
+                                    break  # 我们将在循环外发送 OpenAI 的 [DONE]
+                                try:
+                                    event_data = json.loads(json_str)
+                                    event_type = event_data.get("eventType", "")
+                                    
+                                    # 处理内容块
+                                    if event_type == "fulfillment":
+                                        content_chunk = event_data.get("answer", "")
+                                        if content_chunk is not None:  # 确保 content_chunk 不是 None
+                                            full_assistant_reply_parts.append(content_chunk) # Aggregate
+                                            openai_chunk = {
+                                                "id": request_id,
+                                                "object": "chat.completion.chunk",
+                                                "created": int(time.time()),
+                                                "model": requested_model_name,
+                                                "choices": [
+                                                    {
+                                                        "delta": {"content": content_chunk},
+                                                        "index": 0,
+                                                        "finish_reason": None  # 流式传输过程中 finish_reason 为 None
+                                                    }
+                                                ]
+                                            }
+                                            yield f"data: {json.dumps(openai_chunk, ensure_ascii=False)}\n\n"
+                                    
+                                    # 从metrics事件中提取准确的token计数
+                                    elif event_type == "metricsLog":
+                                        public_metrics = event_data.get("publicMetrics", {})
+                                        if public_metrics:
+                                            # 确保获取到的token计数是整数，避免None值
+                                            actual_input_tokens = public_metrics.get("inputTokens", 0)
+                                            if actual_input_tokens is None:
+                                                actual_input_tokens = 0
+                                                
+                                            actual_output_tokens = public_metrics.get("outputTokens", 0)
+                                            if actual_output_tokens is None:
+                                                actual_output_tokens = 0
+                                                
+                                            actual_total_tokens = public_metrics.get("totalTokens", 0)
+                                            if actual_total_tokens is None:
+                                                actual_total_tokens = 0
+                                                
+                                            logger.info(f"[{request_id}] 从metricsLog获取到准确的token计数: 输入={actual_input_tokens}, 输出={actual_output_tokens}, 总计={actual_total_tokens}")
+                                            
+                                except json.JSONDecodeError:
+                                    logger.warning(f"[{request_id}] 流式传输中 JSONDecodeError: {json_str}")
+                                    continue  # 跳过无法解析的行
+                    
+                    # 如果没有从metrics中获取到准确的token计数，则使用估算方法
+                    if actual_input_tokens == 0 or actual_output_tokens == 0 or actual_total_tokens == 0:
+                        logger.warning(f"[{request_id}] 未从metricsLog获取到有效的token计数，使用估算方法")
+                        prompt_tokens, _, _ = count_message_tokens(messages, requested_model_name)
+                        # 确保prompt_tokens不为None
+                        if prompt_tokens is None:
+                            prompt_tokens = 0
+                        estimated_completion_tokens = max(1, prompt_tokens // 2)  # 确保至少为1
+                        estimated_total_tokens = prompt_tokens + estimated_completion_tokens
+                    else:
+                        # 使用从metrics中获取的准确token计数
+                        prompt_tokens = actual_input_tokens
+                        estimated_completion_tokens = actual_output_tokens
+                        estimated_total_tokens = actual_total_tokens
+                    
+                    # 循环结束后，发送 OpenAI 流的终止块
+                    final_chunk = {
+                        "id": request_id,
+                        "object": "chat.completion.chunk",
+                        "created": int(time.time()),
+                        "model": requested_model_name,
+                        "choices": [{"delta": {}, "index": 0, "finish_reason": "stop"}],  # 标准的结束方式
+                        "usage": {  # 添加token统计信息
+                            "prompt_tokens": prompt_tokens,
+                            "completion_tokens": estimated_completion_tokens,
+                            "total_tokens": estimated_total_tokens
+                        }
+                    }
+                    yield f"data: {json.dumps(final_chunk, ensure_ascii=False)}\n\n"
+                    yield "data: [DONE]\n\n"  # OpenAI 流的最终结束标记
+                    logger.info(f"[{request_id}] 完成 OpenAI 格式响应的流式传输。")
+                    
+                    full_streamed_reply = "".join(full_assistant_reply_parts)
+
+                    # 更新使用统计
+                    request_duration_val = int((time.time() - request_start_time) * 1000)
+                    final_prompt_tokens_for_stats = actual_input_tokens if actual_input_tokens is not None and actual_input_tokens > 0 else prompt_tokens
+                    final_completion_tokens_for_stats = actual_output_tokens if actual_output_tokens is not None and actual_output_tokens > 0 else estimated_completion_tokens
+                    final_total_tokens_for_stats = actual_total_tokens if actual_total_tokens is not None and actual_total_tokens > 0 else estimated_total_tokens
+                    used_actual_for_history = actual_input_tokens is not None and actual_input_tokens > 0
+
+                    _update_usage_statistics(
+                        config_inst=config_instance,
+                        request_id=request_id,
+                        requested_model_name=requested_model_name,
+                        account_email=ondemand_client.email,
+                        is_success=True,
+                        duration_ms=request_duration_val,
+                        is_stream=True,
+                        prompt_tokens_val=final_prompt_tokens_for_stats,
+                        completion_tokens_val=final_completion_tokens_for_stats,
+                        total_tokens_val=final_total_tokens_for_stats,
+                        prompt_length=len(final_query_to_ondemand),
+                        used_actual_tokens_for_history=used_actual_for_history
+                    )
+
+                    # 更新客户端的 active_context_hash 以反映对话进展
+                    _update_client_context_hash_after_reply(
+                        original_request_messages=captured_initial_request_messages,
+                        assistant_reply_content=full_streamed_reply,
+                        request_id=request_id,
+                        user_identifier=token, # user_identifier is token
+                        email_for_stats=ondemand_client.email, # <--- 使用 ondemand_client 当前的 email
+                        current_ondemand_client_instance=ondemand_client,
+                        config_inst=config_instance,
+                        logger_instance=logger
+                    )
+                except Exception as e:  # 捕获流处理过程中的任何异常
+                    logger.error(f"[{request_id}] 流式传输过程中发生错误: {e}")
+                    # 在流错误的情况下，不更新 active_context_hash，因为它可能基于不完整的对话
+                    # 计算token数量（仅提示部分，因为流式响应无法准确计算完成tokens）
+                    prompt_tokens, _, _ = count_message_tokens(messages, requested_model_name)
+                    # 确保prompt_tokens不为None
+                    if prompt_tokens is None:
+                        prompt_tokens = 0
+                    # 错误情况下，完成tokens为0
+                    estimated_completion_tokens = 0
+                    # 错误情况下，总tokens等于提示tokens
+                    estimated_total_tokens = prompt_tokens
+                    
+                    error_json = {  # 发送一个错误块
+                        "id": request_id,
+                        "object": "chat.completion.chunk",
+                        "created": int(time.time()),
+                        "model": requested_model_name,
+                        "choices": [{"delta": {"content": f"[流处理异常: {str(e)}]"}, "index": 0, "finish_reason": "error"}],
+                        "usage": {  # 添加token统计信息
+                            "prompt_tokens": prompt_tokens,
+                            "completion_tokens": estimated_completion_tokens,
+                            "total_tokens": estimated_total_tokens
+                        }
+                    }
+                    yield f"data: {json.dumps(error_json, ensure_ascii=False)}\n\n"
+                    yield "data: [DONE]\n\n"
+                    
+                    # 更新使用统计 - 失败的流式请求
+                    request_duration_val = int((time.time() - request_start_time) * 1000)
+                    _update_usage_statistics(
+                        config_inst=config_instance,
+                        request_id=request_id,
+                        requested_model_name=requested_model_name,
+                        account_email=ondemand_client.email if ondemand_client else email_for_stats,
+                        is_success=False,
+                        duration_ms=request_duration_val,
+                        is_stream=True,
+                        prompt_tokens_val=prompt_tokens if prompt_tokens is not None else 0,
+                        completion_tokens_val=0,
+                        total_tokens_val=prompt_tokens if prompt_tokens is not None else 0,
+                        error_message=str(e)
+                    )
+                finally:
+                    if stream_response_obj:  # 确保关闭响应对象
+                        stream_response_obj.close()
+ 
+            return Response(stream_with_context(generate_openai_stream(initial_messages_from_request)), content_type='text/event-stream; charset=utf-8')
+        else:
+            # 非流式响应
+            final_content = ondemand_result.get("content", "")
+            
+            # 计算token数量
+            prompt_tokens, completion_tokens, total_tokens = count_message_tokens(messages, requested_model_name)
+            completion_tokens_actual = count_tokens(final_content, requested_model_name)
+            total_tokens_actual = prompt_tokens + completion_tokens_actual
+            
+            openai_response = {
+                "id": request_id,
+                "object": "chat.completion",
+                "created": int(time.time()),
+                "model": requested_model_name,
+                "choices": [
+                    {
+                        "message": {
+                            "role": "assistant",
+                            "content": final_content
+                        },
+                        "finish_reason": "stop",  # 假设成功完成则为 "stop"
+                        "index": 0
+                    }
+                ],
+                "usage": {  # 计算token数量
+                    "prompt_tokens": prompt_tokens,
+                    "completion_tokens": completion_tokens_actual,
+                    "total_tokens": total_tokens_actual
+                }
+            }
+            logger.info(f"[{request_id}] 发送非流式 OpenAI 格式的响应。")
+            
+            # 更新使用统计 - 非流式成功请求
+            request_duration_val = int((time.time() - request_start_time) * 1000)
+            _update_usage_statistics(
+                config_inst=config_instance,
+                request_id=request_id,
+                requested_model_name=requested_model_name,
+                account_email=ondemand_client.email,
+                is_success=True,
+                duration_ms=request_duration_val,
+                is_stream=False,
+                prompt_tokens_val=prompt_tokens,
+                completion_tokens_val=completion_tokens_actual,
+                total_tokens_val=total_tokens_actual,
+                prompt_length=len(final_query_to_ondemand),
+                completion_length=len(final_content) if final_content else 0,
+                used_actual_tokens_for_history=True
+            )
+
+            # 更新客户端的 active_context_hash 以反映对话进展
+            _update_client_context_hash_after_reply(
+                original_request_messages=initial_messages_from_request,
+                assistant_reply_content=final_content,
+                request_id=request_id,
+                user_identifier=token, # user_identifier is token
+                email_for_stats=ondemand_client.email, # <--- 使用 ondemand_client 当前的 email
+                current_ondemand_client_instance=ondemand_client,
+                config_inst=config_instance,
+                logger_instance=logger
+            )
+            
+            return openai_response
+    
+    @app.route('/', methods=['GET'])
+    def show_stats():
+        """显示用量统计信息的HTML页面"""
+        current_time = datetime.now()
+        current_time_str = current_time.strftime('%Y-%m-%d %H:%M:%S')
+        current_date = current_time.strftime('%Y-%m-%d')
+        
+        with config_instance.usage_stats_lock:
+            # 复制基础统计数据
+            total_requests = config_instance.usage_stats["total_requests"]
+            successful_requests = config_instance.usage_stats["successful_requests"]
+            failed_requests = config_instance.usage_stats["failed_requests"]
+            total_prompt_tokens = config_instance.usage_stats["total_prompt_tokens"]
+            total_completion_tokens = config_instance.usage_stats["total_completion_tokens"]
+            total_tokens = config_instance.usage_stats["total_tokens"]
+            
+            # 计算成功率（整数百分比）
+            success_rate = int((successful_requests / total_requests * 100) if total_requests > 0 else 0)
+            
+            # 计算平均响应时间
+            successful_history = [req for req in config_instance.usage_stats["request_history"] if req.get('success', False)]
+            total_duration = sum(req.get('duration_ms', 0) for req in successful_history)
+            avg_duration = (total_duration / successful_requests) if successful_requests > 0 else 0
+            
+            # 计算最快响应时间
+            min_duration = min([req.get('duration_ms', float('inf')) for req in successful_history]) if successful_history else 0
+            
+            # 计算今日请求数和增长率
+            today_requests = config_instance.usage_stats["daily_usage"].get(current_date, 0)
+            # 确保不会出现除以零或None值的情况
+            if total_requests is None or today_requests is None:
+                growth_rate = 0
+            elif total_requests == today_requests or (total_requests - today_requests) <= 0:
+                growth_rate = 100  # 如果所有请求都是今天的，增长率为100%
+            else:
+                growth_rate = (today_requests / (total_requests - today_requests) * 100)
+            
+            # 计算估算成本 - 使用模型价格配置
+            total_cost = 0.0
+            model_costs = {}  # 存储每个模型的成本
+            
+            # 获取请求历史中的token使用情况
+            for req in successful_history:
+                model_name = req.get('model', '')
+                # 从配置获取模型价格
+                all_model_prices = config_instance.get('model_prices', {})
+                default_model_price = config_instance.get('default_model_price', {'input': 0.50 / 1000000, 'output': 2.00 / 1000000}) # 提供备用默认值
+                model_price = all_model_prices.get(model_name, default_model_price)
+                
+                # 获取输入和输出token数量
+                input_tokens = req.get('prompt_tokens', 0)
+                
+                # 根据是否有准确的completion_tokens字段决定使用哪个字段
+                if 'completion_tokens' in req:
+                    output_tokens = req.get('completion_tokens', 0)
+                else:
+                    output_tokens = req.get('estimated_completion_tokens', 0)
+                
+                # 计算此次请求的成本
+                request_cost = (input_tokens * model_price['input']) + (output_tokens * model_price['output'])
+                total_cost += request_cost
+                
+                # 累加到模型成本中
+                if model_name not in model_costs:
+                    model_costs[model_name] = 0
+                model_costs[model_name] += request_cost
+            
+            # 计算平均成本
+            avg_cost = (total_cost / successful_requests) if successful_requests > 0 else 0
+            
+            # ���取最常用模型
+            model_usage = dict(config_instance.usage_stats["model_usage"])
+            top_models = sorted(model_usage.items(), key=lambda x: x[1], reverse=True)
+            top_model = top_models[0] if top_models else None
+            
+            # 构建完整的统计数据字典
+            stats = {
+                "total_requests": total_requests,
+                "successful_requests": successful_requests,
+                "failed_requests": failed_requests,
+                "success_rate": success_rate,
+                "avg_duration": avg_duration,
+                "min_duration": min_duration,
+                "today_requests": today_requests,
+                "growth_rate": growth_rate,
+                "total_prompt_tokens": total_prompt_tokens,
+                "total_completion_tokens": total_completion_tokens,
+                "total_tokens": total_tokens,
+                "total_cost": total_cost,
+                "avg_cost": avg_cost,
+                "model_usage": model_usage,
+                "model_costs": model_costs,  # 添加每个模型的成本
+                "top_model": top_model,
+                "model_tokens": dict(config_instance.usage_stats["model_tokens"]),
+                "account_usage": dict(config_instance.usage_stats["account_usage"]),
+                "daily_usage": dict(sorted(config_instance.usage_stats["daily_usage"].items(), reverse=True)[:30]),  # 最近30天
+                "hourly_usage": dict(sorted(config_instance.usage_stats["hourly_usage"].items(), reverse=True)[:48]),  # 最近48小时
+                "request_history": list(config_instance.usage_stats["request_history"][:50]),
+                "daily_tokens": dict(sorted(config_instance.usage_stats["daily_tokens"].items(), reverse=True)[:30]),  # 最近30天
+                "hourly_tokens": dict(sorted(config_instance.usage_stats["hourly_tokens"].items(), reverse=True)[:48]),  # 最近48小时
+                "last_saved": config_instance.usage_stats.get("last_saved", "从未保存")
+            }
+        
+        # 使用render_template渲染模板
+        return render_template('stats.html', stats=stats, current_time=current_time_str)
+    
+    @app.route('/save_stats', methods=['POST'])
+    def save_stats():
+        """手动保存统计数据"""
+        try:
+            config_instance.save_stats_to_file()
+            logger.info("统计数据已手动保存")
+            return redirect(url_for('show_stats'))
+        except Exception as e:
+            logger.error(f"手动保存统计数据时出错: {e}")
+            return jsonify({"status": "error", "message": str(e)}), 500

static/css/styles.css

@@ -0,0 +1,698 @@
+:root {
+    --primary-color: #3498db;
+    --secondary-color: #2c3e50;
+    --success-color: #27ae60;
+    --info-color: #3498db;
+    --warning-color: #f39c12;
+    --danger-color: #e74c3c;
+    --light-bg: #f5f5f5;
+    --card-bg: #f8f9fa;
+    --border-color: #ddd;
+    --shadow-color: rgba(0,0,0,0.1);
+    --text-color: #333;
+    --heading-color: #2c3e50;
+    --button-hover: #2980b9;
+    --save-button: #e67e22;
+    --save-button-hover: #d35400;
+    --refresh-button: #2ecc71;
+    --refresh-button-hover: #27ae60;
+    --chart-bg: #fff;
+    --table-header-bg: #3498db;
+    --table-row-hover: #f5f5f5;
+    --table-border: #ddd;
+    --success-text: #27ae60;
+    --fail-text: #e74c3c;
+    --header-height: 60px;
+    --footer-height: 60px;
+}
+
+/* 暗黑模式变量 */
+body.dark-mode {
+    --primary-color: #2980b9;
+    --secondary-color: #34495e;
+    --light-bg: #1a1a1a;
+    --card-bg: #2c2c2c;
+    --border-color: #444;
+    --shadow-color: rgba(0,0,0,0.3);
+    --text-color: #f5f5f5;
+    --heading-color: #f5f5f5;
+    --button-hover: #3498db;
+    --chart-bg: #2c2c2c;
+    --table-header-bg: #2980b9;
+    --table-row-hover: #3a3a3a;
+    --table-border: #444;
+    --save-button: #d35400;
+    --save-button-hover: #e67e22;
+    --refresh-button: #27ae60;
+    --refresh-button-hover: #2ecc71;
+}
+
+* {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+body {
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    margin: 0;
+    padding: 0;
+    background-color: var(--light-bg);
+    color: var(--text-color);
+    line-height: 1.6;
+    transition: background-color 0.3s ease, color 0.3s ease;
+}
+
+body.dark-mode {
+    background-color: var(--light-bg);
+    color: var(--text-color);
+}
+
+/* 主布局结构 */
+.dashboard-wrapper {
+    display: flex;
+    min-height: 100vh;
+    position: relative;
+    flex-direction: column;
+}
+
+/* 主内容区域 */
+.main-content {
+    flex: 1;
+    min-height: 100vh;
+    display: flex;
+    flex-direction: column;
+}
+
+/* 主内容头部 */
+.main-header {
+    background-color: var(--card-bg);
+    padding: 1rem 1.5rem;
+    box-shadow: 0 2px 5px var(--shadow-color);
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    position: sticky;
+    top: 0;
+    z-index: 90;
+    height: var(--header-height);
+}
+
+.header-left {
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+}
+
+.header-left h1 {
+    font-size: 1.8rem;
+    margin: 0;
+    color: var(--primary-color);
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.header-right {
+    display: flex;
+    align-items: center;
+    gap: 1.5rem;
+}
+
+/* 自动刷新进度条 */
+.auto-refresh-bar {
+    background-color: var(--card-bg);
+    padding: 0.5rem 1rem;
+    margin-bottom: 1rem;
+    border-radius: 4px;
+    box-shadow: 0 1px 3px var(--shadow-color);
+}
+
+.refresh-progress {
+    height: 4px;
+    background-color: rgba(0,0,0,0.1);
+    border-radius: 2px;
+    margin-bottom: 0.5rem;
+    overflow: hidden;
+}
+
+.progress-bar {
+    height: 100%;
+    background-color: var(--primary-color);
+    width: 0;
+    transition: width 1s linear;
+    border-radius: 2px;
+}
+
+.refresh-info {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    font-size: 0.85rem;
+}
+
+h1, h2, h3 {
+    color: var(--heading-color);
+    margin-bottom: 1rem;
+}
+
+/* 仪表盘部分 */
+.dashboard-section {
+    padding: 1rem 1.5rem;
+    display: none;
+}
+
+.dashboard-section.active-section {
+    display: block;
+}
+
+.section-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1.5rem;
+}
+
+.section-header h2 {
+    font-size: 1.5rem;
+    margin: 0;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.section-header h2 i {
+    color: var(--primary-color);
+}
+
+.time-info {
+    font-size: 0.9rem;
+    color: var(--text-color);
+    opacity: 0.8;
+}
+
+.time-info span {
+    margin-right: 1rem;
+}
+
+.time-info i {
+    margin-right: 0.5rem;
+    color: var(--primary-color);
+}
+
+.actions {
+    display: flex;
+    gap: 0.5rem;
+}
+
+.save-button, .refresh-button {
+    background-color: var(--save-button);
+    color: white;
+    border: none;
+    padding: 0.5rem 1rem;
+    border-radius: 4px;
+    cursor: pointer;
+    font-weight: 600;
+    transition: all 0.3s ease;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.save-button:hover {
+    background-color: var(--save-button-hover);
+    transform: translateY(-2px);
+    box-shadow: 0 4px 8px rgba(0,0,0,0.1);
+}
+
+.refresh-button {
+    background-color: var(--refresh-button);
+}
+
+.refresh-button:hover {
+    background-color: var(--refresh-button-hover);
+    transform: translateY(-2px);
+    box-shadow: 0 4px 8px rgba(0,0,0,0.1);
+}
+
+/* 统计卡片网格 */
+.stats-overview {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+    gap: 1.5rem;
+    margin-bottom: 2rem;
+}
+
+/* 统计卡片样式 */
+.stats-card {
+    background-color: var(--card-bg);
+    border-radius: 10px;
+    padding: 1.5rem;
+    box-shadow: 0 2px 5px var(--shadow-color);
+    transition: transform 0.3s ease, box-shadow 0.3s ease;
+    border-top: 4px solid var(--primary-color);
+    position: relative;
+    overflow: hidden;
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+}
+
+.stats-card.primary {
+    border-top-color: var(--primary-color);
+}
+
+.stats-card.success {
+    border-top-color: var(--success-color);
+}
+
+.stats-card.info {
+    border-top-color: var(--info-color);
+}
+
+.stats-card.warning {
+    border-top-color: var(--warning-color);
+}
+
+.stats-card.danger {
+    border-top-color: var(--danger-color);
+}
+
+.stats-card.secondary {
+    border-top-color: var(--secondary-color);
+}
+
+.stats-icon {
+    width: 50px;
+    height: 50px;
+    border-radius: 50%;
+    background-color: rgba(52, 152, 219, 0.1);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 1.5rem;
+    color: var(--primary-color);
+}
+
+.stats-card.primary .stats-icon {
+    background-color: rgba(52, 152, 219, 0.1);
+    color: var(--primary-color);
+}
+
+.stats-card.success .stats-icon {
+    background-color: rgba(39, 174, 96, 0.1);
+    color: var(--success-color);
+}
+
+.stats-card.info .stats-icon {
+    background-color: rgba(52, 152, 219, 0.1);
+    color: var(--info-color);
+}
+
+.stats-card.warning .stats-icon {
+    background-color: rgba(243, 156, 18, 0.1);
+    color: var(--warning-color);
+}
+
+.stats-card.danger .stats-icon {
+    background-color: rgba(231, 76, 60, 0.1);
+    color: var(--danger-color);
+}
+
+.stats-card.secondary .stats-icon {
+    background-color: rgba(44, 62, 80, 0.1);
+    color: var(--secondary-color);
+}
+
+.stats-content {
+    flex: 1;
+}
+
+.stats-card::after {
+    content: '';
+    position: absolute;
+    bottom: 0;
+    right: 0;
+    width: 30%;
+    height: 4px;
+    background-color: var(--primary-color);
+    opacity: 0.3;
+}
+
+.stats-card:hover {
+    transform: translateY(-5px);
+    box-shadow: 0 5px 15px var(--shadow-color);
+}
+
+.stats-card h3 {
+    font-size: 1rem;
+    color: var(--text-color);
+    opacity: 0.8;
+    margin-bottom: 0.5rem;
+}
+
+.stats-number {
+    font-size: 2rem;
+    font-weight: bold;
+    color: var(--primary-color);
+    margin: 0.5rem 0;
+    display: flex;
+    align-items: center;
+}
+
+/* 图表布局 */
+.dashboard-charts {
+    margin-top: 2rem;
+}
+
+.chart-row {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 1.5rem;
+    margin-bottom: 1.5rem;
+}
+
+.chart-card {
+    background-color: var(--card-bg);
+    border-radius: 10px;
+    box-shadow: 0 2px 5px var(--shadow-color);
+    overflow: hidden;
+}
+
+.chart-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 1rem 1.5rem;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.chart-header h3 {
+    margin: 0;
+    font-size: 1.1rem;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.chart-header h3 i {
+    color: var(--primary-color);
+}
+
+.chart-body {
+    padding: 1rem;
+    height: 300px;
+}
+
+/* 表格样式 */
+.table-container {
+    max-height: 500px;
+    overflow-y: auto;
+    border-radius: 10px;
+    box-shadow: 0 2px 5px var(--shadow-color);
+    margin-bottom: 1rem;
+}
+
+table {
+    width: 100%;
+    border-collapse: collapse;
+    margin-top: 1rem;
+    background-color: var(--card-bg);
+    border-radius: 10px;
+    overflow: hidden;
+    box-shadow: 0 2px 5px var(--shadow-color);
+}
+
+th, td {
+    padding: 1rem;
+    text-align: left;
+    border-bottom: 1px solid var(--table-border);
+}
+
+th {
+    background-color: var(--table-header-bg);
+    color: white;
+    font-weight: 600;
+    position: sticky;
+    top: 0;
+    z-index: 10;
+}
+
+th[data-sort] {
+    cursor: pointer;
+}
+
+th[data-sort] i {
+    margin-left: 0.5rem;
+    font-size: 0.8rem;
+}
+
+th.asc i, th.desc i {
+    color: #fff;
+}
+
+tr:last-child td {
+    border-bottom: none;
+}
+
+tr:hover {
+    background-color: var(--table-row-hover);
+}
+
+td.success {
+    color: var(--success-text);
+    font-weight: 600;
+}
+
+td.fail {
+    color: var(--fail-text);
+    font-weight: 600;
+}
+
+.history-section {
+    margin-top: 2rem;
+}
+
+.history-actions {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1rem;
+    flex-wrap: wrap;
+    gap: 1rem;
+}
+
+.search-box {
+    position: relative;
+    flex: 1;
+    min-width: 200px;
+}
+
+.search-box input {
+    width: 100%;
+    padding: 0.5rem 1rem 0.5rem 2.5rem;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    font-size: 1rem;
+    background-color: var(--card-bg);
+    color: var(--text-color);
+}
+
+.search-box i {
+    position: absolute;
+    left: 0.8rem;
+    top: 50%;
+    transform: translateY(-50%);
+    color: var(--primary-color);
+}
+
+.pagination {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-top: 1rem;
+}
+
+.pagination button {
+    background-color: var(--primary-color);
+    color: white;
+    border: none;
+    padding: 0.5rem 1rem;
+    border-radius: 4px;
+    cursor: pointer;
+    transition: background-color 0.3s ease;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.pagination button:disabled {
+    background-color: #ccc;
+    cursor: not-allowed;
+}
+
+.pagination button:not(:disabled):hover {
+    background-color: var(--button-hover);
+}
+
+#page-info {
+    font-size: 0.9rem;
+    color: var(--text-color);
+}
+
+/* 页脚样式 */
+.main-footer {
+    margin-top: auto;
+    padding: 1rem 1.5rem;
+    border-top: 1px solid var(--border-color);
+    background-color: var(--card-bg);
+    box-shadow: 0 -2px 5px var(--shadow-color);
+}
+
+.footer-content {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.footer-logo h3 {
+    margin: 0;
+    font-size: 1.2rem;
+    color: var(--primary-color);
+}
+
+.footer-logo h3 span {
+    font-weight: normal;
+    opacity: 0.8;
+}
+
+.footer-info {
+    font-size: 0.85rem;
+    opacity: 0.8;
+}
+
+#countdown {
+    font-weight: bold;
+    color: var(--primary-color);
+}
+
+/* 状态徽章样式 */
+.status-badge {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.3rem;
+    padding: 0.3rem 0.6rem;
+    border-radius: 20px;
+    font-size: 0.85rem;
+    font-weight: 600;
+}
+
+.status-badge.success {
+    background-color: rgba(39, 174, 96, 0.1);
+    color: var(--success-color);
+}
+
+.status-badge.fail {
+    background-color: rgba(231, 76, 60, 0.1);
+    color: var(--fail-text);
+}
+
+/* 模型徽章样式 */
+.model-badge {
+    display: inline-block;
+    padding: 0.3rem 0.6rem;
+    border-radius: 20px;
+    font-size: 0.85rem;
+    background-color: rgba(52, 152, 219, 0.1);
+    color: var(--primary-color);
+}
+
+.model-badge.small {
+    font-size: 0.75rem;
+    padding: 0.2rem 0.4rem;
+}
+
+/* 账户头像样式 */
+.account-avatar {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 30px;
+    height: 30px;
+    border-radius: 50%;
+    background-color: var(--primary-color);
+    color: white;
+    font-weight: bold;
+}
+
+.account-avatar.small {
+    width: 24px;
+    height: 24px;
+    font-size: 0.8rem;
+}
+
+.account-cell {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+/* 趋势指示器 */
+.stats-trend {
+    display: flex;
+    align-items: center;
+    gap: 0.3rem;
+    font-size: 0.85rem;
+    margin-top: 0.5rem;
+}
+
+.stats-trend.positive {
+    color: var(--success-color);
+}
+
+.stats-trend.negative {
+    color: var(--danger-color);
+}
+
+.stats-detail {
+    font-size: 0.85rem;
+    opacity: 0.8;
+    margin-top: 0.5rem;
+}
+
+/* 响应式设计优化 */
+@media (max-width: 992px) {
+    .chart-row {
+        grid-template-columns: 1fr;
+    }
+    
+    .stats-overview {
+        grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+    }
+}
+
+@media (max-width: 768px) {
+    .stats-overview {
+        grid-template-columns: 1fr;
+    }
+    
+    .chart-body {
+        height: 250px;
+    }
+    
+    table {
+        display: block;
+        overflow-x: auto;
+    }
+    
+    .history-actions {
+        flex-direction: column;
+        align-items: stretch;
+    }
+    
+    .footer-content {
+        flex-direction: column;
+        gap: 1rem;
+        text-align: center;
+    }
+}

static/js/scripts.js

@@ -0,0 +1,457 @@
+// 全局变量
+let refreshInterval = 60; // 默认刷新间隔（秒）
+let autoRefreshEnabled = true; // 默认启用自动刷新
+let chartInstances = {}; // 存储图表实例的对象
+let darkModeEnabled = localStorage.getItem('theme') === 'dark'; // 深色模式状态
+
+// 格式化大数值的函数
+function formatChartNumber(value) {
+    if (value >= 1000000000) {
+        return (value / 1000000000).toFixed(1) + 'G';
+    } else if (value >= 1000000) {
+        return (value / 1000000).toFixed(1) + 'M';
+    } else if (value >= 1000) {
+        return (value / 1000).toFixed(1) + 'K';
+    }
+    return value;
+}
+
+// 页面加载完成后执行
+document.addEventListener('DOMContentLoaded', function() {
+    // 初始化图表
+    initializeCharts();
+    
+    // 设置自动刷新
+    setupAutoRefresh();
+    
+    // 主题切换
+    setupThemeToggle();
+    
+    // 加载保存的主题
+    loadSavedTheme();
+    
+    // 添加表格交互功能
+    enhanceTableInteraction();
+    
+    // 添加保存统计数据按钮事件
+    setupSaveStatsButton();
+    
+    // 更新页脚信息
+    updateFooterInfo();
+    
+    // 表格排序和筛选
+    const table = document.getElementById('history-table');
+    if (table) {
+        const headers = table.querySelectorAll('th[data-sort]');
+        const rows = Array.from(table.querySelectorAll('tbody tr'));
+        const rowsPerPage = 10;
+        let currentPage = 1;
+        let filteredRows = [...rows];
+        
+        // 初始化分页
+        function initPagination() {
+            const totalPages = Math.ceil(filteredRows.length / rowsPerPage);
+            document.getElementById('total-pages').textContent = totalPages;
+            document.getElementById('current-page').textContent = currentPage;
+            document.getElementById('prev-page').disabled = currentPage === 1;
+            document.getElementById('next-page').disabled = currentPage === totalPages || totalPages === 0;
+            
+            // 显示当前页的行
+            const startIndex = (currentPage - 1) * rowsPerPage;
+            const endIndex = startIndex + rowsPerPage;
+            
+            rows.forEach(row => row.style.display = 'none');
+            filteredRows.slice(startIndex, endIndex).forEach(row => row.style.display = '');
+        }
+        
+        // 排序功能
+        headers.forEach(header => {
+            header.addEventListener('click', () => {
+                const sortBy = header.getAttribute('data-sort');
+                const isAscending = header.classList.contains('asc');
+                
+                // 移除所有排序指示器
+                headers.forEach(h => {
+                    h.classList.remove('asc', 'desc');
+                    h.querySelector('i').className = 'fas fa-sort';
+                });
+                
+                // 设置当前排序方向
+                if (isAscending) {
+                    header.classList.add('desc');
+                    header.querySelector('i').className = 'fas fa-sort-down';
+                } else {
+                    header.classList.add('asc');
+                    header.querySelector('i').className = 'fas fa-sort-up';
+                }
+                
+                // 排序行
+                filteredRows.sort((a, b) => {
+                    let aValue, bValue;
+                    
+                    if (sortBy === 'id') {
+                        aValue = a.cells[0].getAttribute('title');
+                        bValue = b.cells[0].getAttribute('title');
+                    } else if (sortBy === 'timestamp') {
+                        aValue = a.cells[1].textContent;
+                        bValue = b.cells[1].textContent;
+                    } else if (sortBy === 'duration' || sortBy === 'total') {
+                        const aText = a.cells[sortBy === 'duration' ? 5 : 6].textContent;
+                        const bText = b.cells[sortBy === 'duration' ? 5 : 6].textContent;
+                        aValue = aText === '-' ? 0 : parseInt(aText.replace(/,/g, '').replace(/[KMG]/g, ''));
+                        bValue = bText === '-' ? 0 : parseInt(bText.replace(/,/g, '').replace(/[KMG]/g, ''));
+                    } else {
+                        aValue = a.cells[sortBy === 'model' ? 2 : (sortBy === 'account' ? 3 : 4)].textContent;
+                        bValue = b.cells[sortBy === 'model' ? 2 : (sortBy === 'account' ? 3 : 4)].textContent;
+                    }
+                    
+                    if (aValue < bValue) return isAscending ? -1 : 1;
+                    if (aValue > bValue) return isAscending ? 1 : -1;
+                    return 0;
+                });
+                
+                // 更新显示
+                currentPage = 1;
+                initPagination();
+            });
+        });
+        
+        // 搜索功能
+        const searchInput = document.getElementById('history-search');
+        if (searchInput) {
+            searchInput.addEventListener('input', function() {
+                const searchTerm = this.value.toLowerCase();
+                
+                filteredRows = rows.filter(row => {
+                    const rowText = Array.from(row.cells).map(cell => cell.textContent.toLowerCase()).join(' ');
+                    return rowText.includes(searchTerm);
+                });
+                
+                currentPage = 1;
+                initPagination();
+            });
+        }
+        
+        // 分页控制
+        const prevPageBtn = document.getElementById('prev-page');
+        const nextPageBtn = document.getElementById('next-page');
+        
+        if (prevPageBtn) {
+            prevPageBtn.addEventListener('click', () => {
+                if (currentPage > 1) {
+                    currentPage--;
+                    initPagination();
+                }
+            });
+        }
+        
+        if (nextPageBtn) {
+            nextPageBtn.addEventListener('click', () => {
+                const totalPages = Math.ceil(filteredRows.length / rowsPerPage);
+                if (currentPage < totalPages) {
+                    currentPage++;
+                    initPagination();
+                }
+            });
+        }
+        
+        // 初始化表格
+        initPagination();
+    }
+    
+    // 刷新按钮
+    const refreshBtn = document.getElementById('refresh-btn');
+    if (refreshBtn) {
+        refreshBtn.addEventListener('click', () => {
+            location.reload();
+        });
+    }
+});
+
+// 初始化图表
+function initializeCharts() {
+    try {
+        // 注册Chart.js插件
+        Chart.register(ChartDataLabels);
+        
+        // 设置全局默认值
+        Chart.defaults.font.family = 'Nunito, sans-serif';
+        Chart.defaults.color = getComputedStyle(document.documentElement).getPropertyValue('--text-color');
+        
+        // 每日请求趋势图表
+        const dailyChartElement = document.getElementById('dailyChart');
+        if (dailyChartElement) {
+            const labels = JSON.parse(dailyChartElement.dataset.labels || '[]');
+            const values = JSON.parse(dailyChartElement.dataset.values || '[]');
+            
+            const dailyChart = new Chart(dailyChartElement, {
+                type: 'line',
+                data: {
+                    labels: labels,
+                    datasets: [{
+                        label: '请求数',
+                        data: values,
+                        backgroundColor: 'rgba(52, 152, 219, 0.2)',
+                        borderColor: 'rgba(52, 152, 219, 1)',
+                        borderWidth: 2,
+                        pointBackgroundColor: 'rgba(52, 152, 219, 1)',
+                        pointRadius: 4,
+                        tension: 0.3,
+                        fill: true
+                    }]
+                },
+                options: {
+                    responsive: true,
+                    maintainAspectRatio: false,
+                    plugins: {
+                        legend: {
+                            display: false
+                        },
+                        tooltip: {
+                            mode: 'index',
+                            intersect: false,
+                            backgroundColor: 'rgba(0, 0, 0, 0.7)',
+                            titleFont: {
+                                size: 14
+                            },
+                            bodyFont: {
+                                size: 13
+                            },
+                            padding: 10,
+                            displayColors: false
+                        },
+                        datalabels: {
+                            display: false
+                        }
+                    },
+                    scales: {
+                        x: {
+                            grid: {
+                                display: false
+                            },
+                            ticks: {
+                                maxRotation: 45,
+                                minRotation: 45
+                            }
+                        },
+                        y: {
+                            beginAtZero: true,
+                            grid: {
+                                color: 'rgba(200, 200, 200, 0.1)'
+                            },
+                            ticks: {
+                                precision: 0
+                            }
+                        }
+                    }
+                }
+            });
+            
+            chartInstances['dailyChart'] = dailyChart;
+        }
+        
+        // 模型使用分布图表
+        const modelChartElement = document.getElementById('modelChart');
+        if (modelChartElement) {
+            const labels = JSON.parse(modelChartElement.dataset.labels || '[]');
+            const values = JSON.parse(modelChartElement.dataset.values || '[]');
+            
+            const modelChart = new Chart(modelChartElement, {
+                type: 'pie',
+                data: {
+                    labels: labels,
+                    datasets: [{
+                        label: '模型使用次数',
+                        data: values,
+                        backgroundColor: [
+                            'rgba(255, 99, 132, 0.5)',
+                            'rgba(54, 162, 235, 0.5)',
+                            'rgba(255, 206, 86, 0.5)',
+                            'rgba(75, 192, 192, 0.5)',
+                            'rgba(153, 102, 255, 0.5)',
+                            'rgba(255, 159, 64, 0.5)',
+                            'rgba(199, 199, 199, 0.5)',
+                            'rgba(83, 102, 255, 0.5)',
+                            'rgba(40, 159, 64, 0.5)',
+                            'rgba(210, 199, 199, 0.5)'
+                        ],
+                        borderColor: [
+                            'rgba(255, 99, 132, 1)',
+                            'rgba(54, 162, 235, 1)',
+                            'rgba(255, 206, 86, 1)',
+                            'rgba(75, 192, 192, 1)',
+                            'rgba(153, 102, 255, 1)',
+                            'rgba(255, 159, 64, 1)',
+                            'rgba(199, 199, 199, 1)',
+                            'rgba(83, 102, 255, 1)',
+                            'rgba(40, 159, 64, 1)',
+                            'rgba(210, 199, 199, 1)'
+                        ],
+                        borderWidth: 1
+                    }]
+                },
+                options: {
+                    responsive: true,
+                    maintainAspectRatio: false,
+                    plugins: {
+                        tooltip: {
+                            callbacks: {
+                                label: function(context) {
+                                    let label = context.label || '';
+                                    if (label) {
+                                        label += ': ';
+                                    }
+                                    label += formatChartNumber(context.parsed);
+                                    return label;
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+            
+            chartInstances['modelChart'] = modelChart;
+        }
+    } catch (error) {
+        console.error('初始化图表失败:', error);
+    }
+}
+
+// 设置自动刷新功能
+function setupAutoRefresh() {
+    // 获取已有的刷新进度条元素
+    const progressBar = document.getElementById('refresh-progress-bar');
+    const countdownElement = document.getElementById('countdown');
+    let countdownTimer;
+    
+    // 倒计时功能
+    let countdown = refreshInterval;
+    
+    function startCountdown() {
+        if (countdownTimer) clearInterval(countdownTimer);
+        
+        countdown = refreshInterval;
+        countdownElement.textContent = countdown;
+        
+        // 重置进度条
+        progressBar.style.width = '100%';
+        
+        if (autoRefreshEnabled) {
+            // 设置进度条动画
+            progressBar.style.transition = `width ${refreshInterval}s linear`;
+            progressBar.style.width = '0%';
+            
+            countdownTimer = setInterval(function() {
+                countdown--;
+                if (countdown <= 0) {
+                    countdown = refreshInterval;
+                    location.reload();
+                }
+                countdownElement.textContent = countdown;
+            }, 1000);
+        } else {
+            // 暂停进度条动画
+            progressBar.style.transition = 'none';
+            progressBar.style.width = '0%';
+        }
+    }
+    
+    // 立即启动倒计时
+    startCountdown();
+}
+
+// 设置主题切换
+function setupThemeToggle() {
+    // 在简化版中，我们移除了主题切换按钮，但保留功能以备将来使用
+    const themeToggleBtn = document.getElementById('theme-toggle-btn');
+    if (themeToggleBtn) {
+        themeToggleBtn.addEventListener('click', function() {
+            document.body.classList.toggle('dark-mode');
+            darkModeEnabled = document.body.classList.contains('dark-mode');
+            
+            localStorage.setItem('theme', darkModeEnabled ? 'dark' : 'light');
+            
+            // 更新所有图表的颜色
+            updateChartsTheme();
+        });
+    }
+}
+
+// 加载保存的主题
+function loadSavedTheme() {
+    if (darkModeEnabled) {
+        document.body.classList.add('dark-mode');
+        const themeToggleBtn = document.querySelector('#theme-toggle-btn i');
+        if (themeToggleBtn) {
+            themeToggleBtn.classList.remove('fa-moon');
+            themeToggleBtn.classList.add('fa-sun');
+        }
+    }
+}
+
+// 更新图表主题
+function updateChartsTheme() {
+    // 更新所有图表的颜色主题
+    Object.values(chartInstances).forEach(chart => {
+        // 更新网格线颜色
+        if (chart.options.scales && chart.options.scales.y) {
+            chart.options.scales.y.grid.color = darkModeEnabled ? 'rgba(255, 255, 255, 0.1)' : 'rgba(0, 0, 0, 0.1)';
+            chart.options.scales.x.grid.color = darkModeEnabled ? 'rgba(255, 255, 255, 0.1)' : 'rgba(0, 0, 0, 0.1)';
+            
+            // 更新刻度颜色
+            chart.options.scales.y.ticks.color = darkModeEnabled ? '#ddd' : '#666';
+            chart.options.scales.x.ticks.color = darkModeEnabled ? '#ddd' : '#666';
+        }
+        
+        // 更新图例颜色
+        if (chart.options.plugins && chart.options.plugins.legend) {
+            chart.options.plugins.legend.labels.color = darkModeEnabled ? '#ddd' : '#666';
+        }
+        
+        chart.update();
+    });
+}
+
+// 设置保存统计数据按钮事件
+function setupSaveStatsButton() {
+    const saveButton = document.querySelector('.save-button');
+    if (saveButton) {
+        // 添加点击动画效果
+        saveButton.addEventListener('click', function() {
+            this.classList.add('saving');
+            setTimeout(() => {
+                this.classList.remove('saving');
+            }, 1000);
+        });
+    }
+}
+
+// 添加表格交互功能
+function enhanceTableInteraction() {
+    // 为请求历史表格添加高亮效果
+    const historyRows = document.querySelectorAll('#history-table tbody tr');
+    historyRows.forEach(row => {
+        row.addEventListener('mouseenter', function() {
+            this.classList.add('highlight');
+        });
+        
+        row.addEventListener('mouseleave', function() {
+            this.classList.remove('highlight');
+        });
+    });
+}
+
+// 更新页脚信息
+function updateFooterInfo() {
+    const footer = document.querySelector('.main-footer');
+    if (!footer) return;
+    
+    // 获取当前年份
+    const currentYear = new Date().getFullYear();
+    
+    // 更新版权年份
+    const copyrightText = footer.querySelector('p:first-child');
+    if (copyrightText) {
+        copyrightText.textContent = `© ${currentYear} 2API 统计面板 | 版本 1.0.1`;
+    }
+}

templates/stats.html

@@ -0,0 +1,240 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta http-equiv="refresh" content="60">
+    <title>2API 用量统计</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/[email protected]"></script>
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
+    <link href="https://fonts.googleapis.com/css2?family=Nunito:wght@300;400;600;700&display=swap" rel="stylesheet">
+</head>
+<body>
+    <div class="dashboard-wrapper">
+        <header class="main-header">
+            <div class="header-left">
+                <h1><i class="fas fa-chart-line"></i> 2API 监控面板</h1>
+            </div>
+            <div class="header-right">
+                <div class="time-info">
+                    <span><i class="fas fa-clock"></i> 最后更新: {{ current_time }}</span>
+                    <span><i class="fas fa-save"></i> 最后保存: {{ stats.last_saved|format_datetime if stats.last_saved != "从未保存" else "从未保存" }}</span>
+                </div>
+                <div class="actions">
+                    <form action="/save_stats" method="post">
+                        <button type="submit" class="save-button" title="保存统计数据"><i class="fas fa-save"></i></button>
+                    </form>
+                    <button id="refresh-btn" class="refresh-button" title="刷新数据"><i class="fas fa-sync-alt"></i></button>
+                </div>
+            </div>
+        </header>
+
+        <div class="main-content">
+            <div class="auto-refresh-bar">
+                <div class="refresh-progress">
+                    <div class="progress-bar" id="refresh-progress-bar" style="width: 100%;"></div>
+                </div>
+                <div class="refresh-info">
+                    <span>数据将在 <span id="countdown">60</span> 秒后自动刷新</span>
+                </div>
+            </div>
+        
+            <!-- 统计概览部分 -->
+            <section id="dashboard" class="dashboard-section active-section">
+                <div class="section-header">
+                    <h2><i class="fas fa-tachometer-alt"></i> 统计概览</h2>
+                </div>
+
+                <div class="stats-overview">
+                    <div class="stats-card primary">
+                        <div class="stats-icon">
+                            <i class="fas fa-server"></i>
+                        </div>
+                        <div class="stats-content">
+                            <h3>总请求数</h3>
+                            <div class="stats-number">{{ stats.total_requests|format_number }}</div>
+                            <div class="stats-trend positive">
+                                <i class="fas fa-arrow-up"></i>
+                                {{ stats.growth_rate|round(2) }}% 今日
+                            </div>
+                        </div>
+                    </div>
+
+                    <div class="stats-card success">
+                        <div class="stats-icon">
+                            <i class="fas fa-check-circle"></i>
+                        </div>
+                        <div class="stats-content">
+                            <h3>成功率</h3>
+                            <div class="stats-number">{{ stats.success_rate }}%</div>
+                            <div class="stats-detail">
+                                成功: {{ stats.successful_requests|format_number }} / 失败: {{ stats.failed_requests|format_number }}
+                            </div>
+                        </div>
+                    </div>
+
+                    <div class="stats-card info">
+                        <div class="stats-icon">
+                            <i class="fas fa-bolt"></i>
+                        </div>
+                        <div class="stats-content">
+                            <h3>平均响应时间</h3>
+                            <div class="stats-number">
+                                {{ stats.avg_duration|format_duration }}
+                            </div>
+                            <div class="stats-detail">
+                                最快: {{ stats.min_duration|format_duration }}
+                            </div>
+                        </div>
+                    </div>
+
+                    <div class="stats-card warning">
+                        <div class="stats-icon">
+                            <i class="fas fa-coins"></i>
+                        </div>
+                        <div class="stats-content">
+                            <h3>总 Tokens</h3>
+                            <div class="stats-number">{{ stats.total_tokens|format_number }}</div>
+                            <div class="stats-detail">
+                                提示: {{ stats.total_prompt_tokens|format_number }} / 完成: {{ stats.total_completion_tokens|format_number }}
+                            </div>
+                        </div>
+                    </div>
+
+                    <div class="stats-card danger">
+                        <div class="stats-icon">
+                            <i class="fas fa-dollar-sign"></i>
+                        </div>
+                        <div class="stats-content">
+                            <h3>估算成本</h3>
+                            <div class="stats-number">
+                                ${{ stats.total_cost | round(2) }}
+                            </div>
+                            <div class="stats-detail">
+                                平均: ${{ stats.avg_cost | round(2) }}/请求
+                            </div>
+                        </div>
+                    </div>
+
+                    <div class="stats-card secondary">
+                        <div class="stats-icon">
+                            <i class="fas fa-robot"></i>
+                        </div>
+                        <div class="stats-content">
+                            <h3>模型使用</h3>
+                            <div class="stats-number">{{ stats.model_usage.keys()|list|length }}</div>
+                            <div class="stats-detail">
+                                {% if stats.top_model %}
+                                    最常用: {{ stats.top_model[0] }} ({{ stats.top_model[1] }}次)
+                                {% else %}
+                                    暂无模型使用数据
+                                {% endif %}
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- 简化的图表部分 -->
+                <div class="dashboard-charts">
+                    <div class="chart-row">
+                        <div class="chart-card">
+                            <div class="chart-header">
+                                <h3><i class="fas fa-calendar-day"></i> 每日请求趋势</h3>
+                            </div>
+                            <div class="chart-body">
+                                <canvas id="dailyChart"
+                                    data-labels='{{ stats.daily_usage.keys()|list|tojson }}'
+                                    data-values='{{ stats.daily_usage.values()|list|tojson }}'></canvas>
+                            </div>
+                        </div>
+                        
+                        <div class="chart-card">
+                            <div class="chart-header">
+                                <h3><i class="fas fa-robot"></i> 模型使用分布</h3>
+                            </div>
+                            <div class="chart-body">
+                                <canvas id="modelChart"
+                                    data-labels='{{ stats.model_usage.keys()|list|tojson }}'
+                                    data-values='{{ stats.model_usage.values()|list|tojson }}'></canvas>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </section>
+        
+            <!-- 简化的请求历史部分 -->
+            <section id="history" class="dashboard-section">
+                <div class="section-header">
+                    <h2><i class="fas fa-history"></i> 请求历史</h2>
+                    <div class="history-actions">
+                        <div class="search-box">
+                            <input type="text" id="history-search" placeholder="搜索请求...">
+                            <i class="fas fa-search"></i>
+                        </div>
+                    </div>
+                </div>
+                
+                <div class="table-container">
+                    <table id="history-table" class="data-table">
+                        <thead>
+                            <tr>
+                                <th data-sort="id">请求ID <i class="fas fa-sort"></i></th>
+                                <th data-sort="timestamp">时间 <i class="fas fa-sort"></i></th>
+                                <th data-sort="model">模型 <i class="fas fa-sort"></i></th>
+                                <th data-sort="account">账户 <i class="fas fa-sort"></i></th>
+                                <th data-sort="status">状态 <i class="fas fa-sort"></i></th>
+                                <th data-sort="duration">耗时(ms) <i class="fas fa-sort"></i></th>
+                                <th data-sort="total">总Tokens <i class="fas fa-sort"></i></th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            {% for req in stats.request_history|reverse %}
+                            <tr data-model="{{ req.model }}" data-status="{{ 'success' if req.success else 'fail' }}" data-id="{{ req.id }}">
+                                <td title="{{ req.id }}">{{ req.id[:8] }}...</td>
+                                <td>{{ req.timestamp|format_datetime }}</td>
+                                <td><span class="model-badge small">{{ req.model }}</span></td>
+                                <td title="{{ req.account }}">
+                                    <div class="account-cell">
+                                        <span class="account-avatar small">{{ req.account[0]|upper }}</span>
+                                        <span>{{ req.account.split('@')[0] }}</span>
+                                    </div>
+                                </td>
+                                <td class="{{ 'success' if req.success else 'fail' }}">
+                                    <span class="status-badge {{ 'success' if req.success else 'fail' }}">
+                                        <i class="fas {{ 'fa-check-circle' if req.success else 'fa-times-circle' }}"></i>
+                                        {{ '成功' if req.success else '失败' }}
+                                    </span>
+                                </td>
+                                <td>{{ req.duration_ms|format_duration }}</td>
+                                <td>{{ (req.total_tokens if req.total_tokens is defined else req.estimated_total_tokens if req.estimated_total_tokens is defined else '-')|format_number if (req.total_tokens is defined or req.estimated_total_tokens is defined) else '-' }}</td>
+                            </tr>
+                            {% endfor %}
+                        </tbody>
+                    </table>
+                </div>
+                <div class="pagination">
+                    <button id="prev-page" disabled><i class="fas fa-chevron-left"></i> 上一页</button>
+                    <span id="page-info">第 <span id="current-page">1</span> 页，共 <span id="total-pages">1</span> 页</span>
+                    <button id="next-page"><i class="fas fa-chevron-right"></i> 下一页</button>
+                </div>
+            </section>
+            
+            <footer class="main-footer">
+                <div class="footer-content">
+                    <div class="footer-logo">
+                        <h3>2API <span>统计面板</span></h3>
+                    </div>
+                    <div class="footer-info">
+                        <p>© 2025 2API 统计面板 | 版本 1.0.1</p>
+                        <p>数据每60秒自动刷新</p>
+                    </div>
+                </div>
+            </footer>
+        </div>
+    </div>
+    
+    <script src="{{ url_for('static', filename='js/scripts.js') }}"></script>
+</body>
+</html>

utils.py

@@ -0,0 +1,158 @@
+import logging
+import json
+import os
+import time
+import tiktoken
+from datetime import datetime
+from typing import Dict, Any, Optional, Tuple
+
+# 配置日志
+def setup_logging():
+    """配置日志系统"""
+    log_path = os.environ.get("LOG_PATH", "/tmp/2api.log")
+    log_level_str = os.environ.get("LOG_LEVEL", "INFO").upper()
+    log_level = getattr(logging, log_level_str, logging.INFO)
+    log_format = os.environ.get("LOG_FORMAT", "%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+
+    file_handler = logging.FileHandler(log_path, encoding='utf-8')
+    stream_handler = logging.StreamHandler()
+    logging.basicConfig(
+        level=log_level,
+        format=log_format,
+        handlers=[stream_handler, file_handler]
+    )
+    return logging.getLogger('2api')
+
+logger = setup_logging()
+
+def load_config():
+    """从 config.json 加载配置（如果存在），否则使用环境变量"""
+    default_config_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'config.json')
+    CONFIG_FILE = os.environ.get("CONFIG_FILE_PATH", default_config_path)
+    config = {}
+
+    if os.path.exists(CONFIG_FILE):
+        try:
+            with open(CONFIG_FILE, 'r', encoding='utf-8') as f:
+                config = json.load(f)
+                logger.info(f"已从 {CONFIG_FILE} 加载配置")
+        except (json.JSONDecodeError, IOError) as e:
+            logger.error(f"加载配置文件失败: {e}")
+            config = {}
+    
+    return config
+
+def mask_email(email: str) -> str:
+    """隐藏邮箱中间部分，保护隐私"""
+    if not email or '@' not in email:
+        return "无效邮箱"
+    
+    parts = email.split('@')
+    username = parts[0]
+    domain = parts[1]
+    
+    if len(username) <= 3:
+        masked_username = username[0] + '*' * (len(username) - 1)
+    else:
+        masked_username = username[0] + '*' * (len(username) - 2) + username[-1]
+    
+    return f"{masked_username}@{domain}"
+
+def generate_request_id() -> str:
+    """生成唯一的请求ID"""
+    return f"chatcmpl-{os.urandom(16).hex()}"
+
+def count_tokens(text: str, model: str = "gpt-3.5-turbo") -> int:
+    """
+    计算文本的token数量
+
+    Args:
+        text: 要计算token数量的文本
+        model: 模型名称，默认为gpt-3.5-turbo
+        
+    Returns:
+        int: token数量
+    """
+    # 类型保护，防止text为None或非字符串类型
+    if text is None:
+        text = ""
+    elif not isinstance(text, str):
+        text = str(text)
+    try:
+        # 根据模型名称获取编码器
+        if "gpt-4" in model:
+            encoding = tiktoken.encoding_for_model("gpt-4")
+        elif "gpt-3.5" in model:
+            encoding = tiktoken.encoding_for_model("gpt-3.5-turbo")
+        elif "claude" in model:
+            # Claude模型使用cl100k_base编码器
+            encoding = tiktoken.get_encoding("cl100k_base")
+        else:
+            # 默认使用cl100k_base编码器
+            encoding = tiktoken.get_encoding("cl100k_base")
+        
+        # 计算token数量
+        tokens = encoding.encode(text)
+        return len(tokens)
+    except Exception as e:
+        logger.error(f"计算token数量时出错: {e}")
+        # 如果出错，使用简单的估算方法（每4个字符约为1个token）
+        return len(text) // 4
+
+def count_message_tokens(messages: list, model: str = "gpt-3.5-turbo") -> Tuple[int, int, int]:
+    """
+    计算OpenAI格式消息列表的token数量
+    
+    Args:
+        messages: OpenAI格式的消息列表
+        model: 模型名称，默认为gpt-3.5-turbo
+        
+    Returns:
+        Tuple[int, int, int]: (提示tokens数, 完成tokens数, 总tokens数)
+    """
+    # 类型保护，防止messages为None或非列表类型
+    if messages is None:
+        messages = []
+    elif not isinstance(messages, list):
+        logger.warning(f"count_message_tokens 收到非列表类型的消息: {type(messages)}")
+        messages = []
+    
+    prompt_tokens = 0
+    completion_tokens = 0
+    
+    try:
+        # 计算提示tokens
+        for message in messages:
+            # 确保message是字典类型
+            if not isinstance(message, dict):
+                logger.warning(f"跳过非字典类型的消息: {type(message)}")
+                continue
+                
+            role = message.get('role', '')
+            content = message.get('content', '')
+            
+            if role and content:
+                # 每条消息的基本token开销
+                prompt_tokens += 4  # 每条消息的基本开销
+                
+                # 角色名称的token
+                prompt_tokens += 1  # 角色名称的开销
+                
+                # 内容的token
+                prompt_tokens += count_tokens(content, model)
+                
+                # 如果是assistant角色，计算完成tokens
+                if role == 'assistant':
+                    completion_tokens += count_tokens(content, model)
+        
+        # 消息结束的token
+        prompt_tokens += 2  # 消息结束的开销
+        
+        # 计算总tokens
+        total_tokens = prompt_tokens + completion_tokens
+        
+        return prompt_tokens, completion_tokens, total_tokens
+    except Exception as e:
+        logger.error(f"计算消息token数量时出错: {e}")
+        # 返回安全的默认值
+        return 0, 0, 0