Merge pull request #9 from ZyphrZero/dev

.env.example

@@ -2,36 +2,38 @@
 # 复制此文件为 .env 并根据需要修改配置值
 
 # ========== API 基础配置 ==========
-# Z.ai API 端点地址
-API_ENDPOINT=https://chat.z.ai/api/chat/completions
-
 # 客户端认证密钥（您自定义的 API 密钥，用于客户端访问本服务）
 AUTH_TOKEN=sk-your-api-key
 
 # 跳过客户端认证（仅开发环境使用）
 SKIP_AUTH_TOKEN=false
 
-# Z.ai 备用访问令牌（当匿名模式失败时使用）
-# 注意：这是用于访问 Z.ai 服务的令牌，不是客户端认证密钥
-BACKUP_TOKEN=eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjMxNmJjYjQ4LWZmMmYtNGExNS04NTNkLWYyYTI5YjY3ZmYwZiIsImVtYWlsIjoiR3Vlc3QtMTc1NTg0ODU4ODc4OEBndWVzdC5jb20ifQ.PktllDySS3trlyuFpTeIZf-7hl8Qu1qYF3BxjgIul0BrNux2nX9hVzIjthLXKMWAf9V0qM8Vm_iyDqkjPGsaiQ
+# ========== Token池配置 ==========
+# Token失败阈值（失败多少次后标记为不可用）
+TOKEN_FAILURE_THRESHOLD=3
+
+# Token恢复超时时间（秒，失败token在此时间后重新尝试）
+TOKEN_RECOVERY_TIMEOUT=1800
+
+# Token健康检查间隔（秒，定期检查token状态）
+TOKEN_HEALTH_CHECK_INTERVAL=300
+
+# Z.ai 认证token配置（当匿名模式失败时使用）
+#
+# 使用独立的token文件配置
+# 在项目根目录创建 tokens.txt 文件，每行一个token或逗号分隔
+AUTH_TOKENS_FILE=tokens.txt
 
 # ========== 服务器配置 ==========
 # 服务监听端口
 LISTEN_PORT=8080
 
-# 调试日志开关
+# 调试日志
 DEBUG_LOGGING=true
 
-# ========== 功能配置 ==========
-# 思考内容处理策略
-# think: 转换为 <span> 标签（OpenAI 兼容）
-# strip: 移除思考内容
-# raw: 保留原始格式
-THINKING_PROCESSING=think
-
-# 匿名模式开关（推荐启用）
+# 匿名用户模式
+# false: 使用认证用户令牌
 # true: 自动从 Z.ai 获取临时访问令牌，避免对话历史共享
-# false: 使用固定令牌 BACKUP_TOKEN
 ANONYMOUS_MODE=true
 
 # Function Call 功能开关
@@ -39,3 +41,10 @@ TOOL_SUPPORT=true
 
 # 工具调用扫描限制（字符数）
 SCAN_LIMIT=200000
+
+# ========== 错误码400处理 ==========
+
+# 重试次数
+MAX_RETRIES=5
+# 初始重试延迟
+RETRY_DELAY=1

.gitignore

@@ -13,6 +13,7 @@ main.onefile-build/
 *report.xml
 *.yaml
 logs/
+backup/
 
 # AI Toolset
 .augment/

README.md

@@ -1,30 +1,34 @@
 # Z.AI OpenAI API 代理服务
 
 ![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)
-![Python: 3.8+](https://img.shields.io/badge/python-3.8+-green.svg)
+![Python: 3.9-3.12](https://img.shields.io/badge/python-3.9--3.12-green.svg)
 ![FastAPI](https://img.shields.io/badge/framework-FastAPI-009688.svg)
-![Version: 1.2.0](https://img.shields.io/badge/version-1.2.0-brightgreen.svg)
+![Version: 0.1.0](https://img.shields.io/badge/version-0.1.0-brightgreen.svg)
 
-轻量级 OpenAI API 兼容代理服务，通过 Claude Code Router 接入 Z.AI，支持 GLM-4.5 系列模型的完整功能。
+> 🎯 **项目愿景**：提供完全兼容 OpenAI API 的 Z.AI 代理服务，让用户无需修改现有代码即可接入 GLM-4.5 系列模型。
+
+轻量级、高性能的 OpenAI API 兼容代理服务，通过 Claude Code Router 接入 Z.AI，支持 GLM-4.5 系列模型的完整功能。
 
 ## ✨ 核心特性
 
 - 🔌 **完全兼容 OpenAI API** - 无缝集成现有应用
 - 🤖 **Claude Code 支持** - 通过 Claude Code Router 接入 Claude Code (**CCR 工具请升级到 v1.0.47 以上**)
 - 🚀 **高性能流式响应** - Server-Sent Events (SSE) 支持
-- 🛠️ **增强工具调用** - 改进的 Function Call 实现
+- 🛠️ **增强工具调用** - 改进的 Function Call 实现，支持复杂工具链
 - 🧠 **思考模式支持** - 智能处理模型推理过程
 - 🔍 **搜索模型集成** - GLM-4.5-Search 网络搜索能力
 - 🐳 **Docker 部署** - 一键容器化部署
 - 🛡️ **会话隔离** - 匿名模式保护隐私
 - 🔧 **灵活配置** - 环境变量灵活配置
 - 📊 **多模型映射** - 智能上游模型路由
+- 🔄 **Token 池管理** - 自动轮询、容错恢复、动态更新
+- 🛡️ **错误处理** - 完善的异常捕获和重试机制
 
 ## 🚀 快速开始
 
 ### 环境要求
 
-- Python 3.8+
+- Python 3.9-3.12
 - pip 或 uv (推荐)
 
 ### 安装运行
@@ -44,7 +48,9 @@ pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
 python main.py
 ```
 
-服务启动后访问：http://localhost:8080/docs
+>  服务启动后访问接口文档：http://localhost:8080/docs  
+> 💡 **提示**：默认端口为 8080，可通过环境变量 `LISTEN_PORT` 修改  
+> ⚠️ **注意**：请勿将 `AUTH_TOKEN` 泄露给其他人，请使用 `AUTH_TOKENS` 配置多个认证令牌  
 
 ### 基础使用
 
@@ -142,21 +148,51 @@ for chunk in response:
 | 变量名                | 默认值                                    | 说明                   |
 | --------------------- | ----------------------------------------- | ---------------------- |
 | `AUTH_TOKEN`          | `sk-your-api-key`                         | 客户端认证密钥         |
-| `API_ENDPOINT`        | `https://chat.z.ai/api/chat/completions`  | 上游 API 地址          |
 | `LISTEN_PORT`         | `8080`                                    | 服务监听端口           |
 | `DEBUG_LOGGING`       | `true`                                    | 调试日志开关           |
-| `THINKING_PROCESSING` | `think`                                   | 思考内容处理策略       |
-| `ANONYMOUS_MODE`      | `true`                                    | 匿名模式开关           |
+| `ANONYMOUS_MODE`      | `true`                                    | 匿名用户模式开关           |
 | `TOOL_SUPPORT`        | `true`                                    | Function Call 功能开关 |
 | `SKIP_AUTH_TOKEN`     | `false`                                   | 跳过认证令牌验证       |
 | `SCAN_LIMIT`          | `200000`                                  | 扫描限制               |
-| `BACKUP_TOKEN`        | `eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9...` | Z.ai 固定访问令牌      |
+| `AUTH_TOKENS_FILE`  | `tokens.txt`                              | 认证token文件路径 |
+
+> 💡 详细配置请查看 `.env.example` 文件  
+
+## 🔄 Token池机制
+
+### 功能特性
+
+- **负载均衡**：轮询使用多个auth token，分散请求负载
+- **自动容错**：token失败时自动切换到下一个可用token
+- **健康监控**：基于Z.AI API的role字段精确验证token类型
+- **自动恢复**：失败token在超时后自动重新尝试
+- **动态管理**：支持运行时更新token池
+- **智能去重**：自动检测和去除重复token
+- **类型验证**：只接受认证用户token (role: "user")，拒绝匿名token (role: "guest")
+
+### Token配置方式
+
+创建 `tokens.txt` 文件，支持多种格式的混合使用：
+1. 每行一个token（换行分隔）
+2. 逗号分隔的token
+3. 混合格式（同时支持换行和逗号分隔）
+
+## 监控API
 
-### 思考内容处理策略
+```bash
+# 查看token池状态
+curl http://localhost:8080/v1/token-pool/status
+
+# 手动健康检查
+curl -X POST http://localhost:8080/v1/token-pool/health-check
+
+# 动态更新token池
+curl -X POST http://localhost:8080/v1/token-pool/update \
+  -H "Content-Type: application/json" \
+  -d '["new_token1", "new_token2"]'
+```
 
-- `think` - 转换为 `<thinking>` 标签（OpenAI 兼容）
-- `strip` - 移除思考内容
-- `raw` - 保留原始格式
+详细文档请参考：[Token池功能说明](TOKEN_POOL_README.md)
 
 ## 🎯 使用场景
 
@@ -203,6 +239,12 @@ if response.choices[0].message.tool_calls:
 **Q: 如何获取 AUTH_TOKEN？**
 A: `AUTH_TOKEN` 为自己自定义的 api key，在环境变量中配置，需要保证客户端与服务端一致。
 
+**Q: 遇到 "Illegal header value b'Bearer '" 错误怎么办？**
+A: 这通常是因为 Token 获取失败导致的。请检查：
+- 匿名模式是否正确配置（`ANONYMOUS_MODE=true`）
+- Token 文件是否存在且格式正确（`tokens.txt`）
+- 网络连接是否正常，能否访问 Z.AI API
+
 **Q: 如何通过 Claude Code 使用本服务？**
 
 A: 创建 [zai.js](https://gist.githubusercontent.com/musistudio/b35402d6f9c95c64269c7666b8405348/raw/f108d66fa050f308387938f149a2b14a295d29e9/gistfile1.txt) 这个 ccr 插件放在`./.claude-code-router/plugins`目录下，配置 `./.claude-code-router/config.json` 指向本服务地址，使用 `AUTH_TOKEN` 进行认证。
@@ -287,32 +329,25 @@ A: 通过环境变量配置，推荐使用 `.env` 文件。
 
 要使用完整的多模态功能，需要获取正式的 Z.ai API Token：
 
-### 方式 1: 通过 Z.ai 网站
-
-1. 访问 [Z.ai 官网](https://chat.z.ai)
-2. 注册账户并登录，进入 [Z.ai API Keys](https://z.ai/manage-apikey/apikey-list) 设置页面，在该页面设置 _**个人 API Token**_
-3. 将 Token 放置在 `BACKUP_TOKEN` 环境变量中
-
-### 方式 2: 浏览器开发者工具（临时方案）
-
 1. 打开 [Z.ai 聊天界面](https://chat.z.ai)
 2. 按 F12 打开开发者工具
 3. 切换到 "Application" 或 "存储" 标签
 4. 查看 Local Storage 中的认证 token
 5. 复制 token 值设置为环境变量
 
-> ⚠️ **注意**: 方式 2 获取的 token 可能有时效性，建议使用方式 1 获取长期有效的 API Token。  
-> ❗ **重要提示**: 多模态模型需要**官方 Z.ai API 非匿名 Token**，匿名 token 不支持多媒体处理。
+> ❗ **重要提示**: 获取的 token 可能有时效性，多模态模型需要**官方 Z.ai API 非匿名 Token**，匿名 token 不支持多媒体处理  
 
 ## 🛠️ 技术栈
 
 | 组件            | 技术                                                                              | 版本    | 说明                                       |
 | --------------- | --------------------------------------------------------------------------------- | ------- | ------------------------------------------ |
-| **Web 框架**    | [FastAPI](https://fastapi.tiangolo.com/)                                          | 0.104.1 | 高性能异步 Web 框架，支持自动 API 文档生成 |
+| **Web 框架**    | [FastAPI](https://fastapi.tiangolo.com/)                                          | 0.116.1 | 高性能异步 Web 框架，支持自动 API 文档生成 |
 | **ASGI 服务器** | [Granian](https://github.com/emmett-framework/granian)                            | 2.5.2   | 基于 Rust 的高性能 ASGI 服务器，支持热重载 |
-| **HTTP 客户端** | [Requests](https://requests.readthedocs.io/)                                      | 2.32.5  | 简洁易用的 HTTP 库，用于上游 API 调用      |
+| **HTTP 客户端** | [HTTPX](https://www.python-httpx.org/) / [Requests](https://requests.readthedocs.io/) | 0.27.0 / 2.32.5 | 异步/同步 HTTP 库，用于上游 API 调用      |
 | **数据验证**    | [Pydantic](https://pydantic.dev/)                                                 | 2.11.7  | 类型安全的数据验证与序列化                 |
 | **配置管理**    | [Pydantic Settings](https://docs.pydantic.dev/latest/concepts/pydantic_settings/) | 2.10.1  | 基于 Pydantic 的配置管理                   |
+| **日志系统**    | [Loguru](https://loguru.readthedocs.io/)                                          | 0.7.3   | 高性能结构化日志库                         |
+| **用户代理**    | [Fake UserAgent](https://pypi.org/project/fake-useragent/)                        | 2.2.0   | 动态用户代理生成                           |
 
 ## 🏗️ 技术架构
 
@@ -338,27 +373,27 @@ A: 通过环境变量配置，推荐使用 `.env` 文件。
 
 ```
 z.ai2api_python/
-├── app/
-│   ├── core/
-│   │   ├── __init__.py
-│   │   ├── config.py          # 配置管理
-│   │   ├── openai.py          # OpenAI API 实现
-│   │   └── response_handlers.py  # 响应处理器
-│   ├── models/
-│   │   ├── __init__.py
-│   │   └── schemas.py         # Pydantic 模型定义
-│   ├── utils/
-│   │   ├── __init__.py
-│   │   ├── helpers.py         # 辅助函数
-│   │   ├── tools.py           # 增强工具调用处理
-│   │   └── sse_parser.py      # SSE 流式解析器
-│   └── __init__.py
-├── tests/                     # 单元测试
-├── deploy/                    # Docker 部署配置
-├── main.py                    # FastAPI 应用入口
-├── requirements.txt           # Python 依赖
-├── .env.example              # 环境变量示例
-└── README.md                  # 项目文档
+├── app/                          # 主应用模块
+│   ├── core/                     # 核心模块
+│   │   ├── config.py            # 配置管理（Pydantic Settings）
+│   │   ├── openai.py            # OpenAI API 兼容层
+│   │   └── zai_transformer.py   # Z.AI 请求/响应转换器
+│   ├── models/                   # 数据模型
+│   │   └── schemas.py           # Pydantic 数据模型
+│   └── utils/                    # 工具模块
+│       ├── logger.py            # Loguru 日志系统
+│       ├── reload_config.py     # 热重载配置
+│       ├── sse_tool_handler.py  # SSE 工具调用处理器
+│       └── token_pool.py        # Token 池管理
+├── tests/                        # 测试文件
+├── deploy/                       # 部署配置
+│   ├── Dockerfile               # Docker 镜像构建
+│   └── docker-compose.yml       # 容器编排
+├── main.py                       # FastAPI 应用入口
+├── requirements.txt              # 依赖清单
+├── pyproject.toml               # 项目配置
+├── tokens.txt.example           # Token 配置文件
+└── .env.example                 # 环境变量示例
 ```
 
 ## ⭐ Star History

app/__init__.py

@@ -1,6 +1,5 @@
-"""
-Application package initialization
-"""
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
 
 from app import core, models, utils
 

app/core/__init__.py

@@ -1,7 +1,6 @@
-"""
-Core module initialization
-"""
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
 
-from app.core import config, response_handlers, openai
+from app.core import config, zai_transformer, openai
 
-__all__ = ["config", "response_handlers", "openai"]
+__all__ = ["config", "zai_transformer", "openai"]

app/core/config.py

@@ -1,37 +1,124 @@
-"""
-FastAPI application configuration module
-"""
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
 
 import os
-from typing import Dict, Optional
+from typing import Dict, List, Optional
 from pydantic_settings import BaseSettings
+from app.utils.logger import logger
 
 
 class Settings(BaseSettings):
     """Application settings"""
-    
+
     # API Configuration
-    API_ENDPOINT: str = os.getenv("API_ENDPOINT", "https://chat.z.ai/api/chat/completions")
+    API_ENDPOINT: str = "https://chat.z.ai/api/chat/completions"
     AUTH_TOKEN: str = os.getenv("AUTH_TOKEN", "sk-your-api-key")
-    BACKUP_TOKEN: str = os.getenv("BACKUP_TOKEN", "eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjMxNmJjYjQ4LWZmMmYtNGExNS04NTNkLWYyYTI5YjY3ZmYwZiIsImVtYWlsIjoiR3Vlc3QtMTc1NTg0ODU4ODc4OEBndWVzdC5jb20ifQ.PktllDySS3trlyuFpTeIZf-7hl8Qu1qYF3BxjgIul0BrNux2nX9hVzIjthLXKMWAf9V0qM8Vm_iyDqkjPGsaiQ")
-    
+
+    # 认证token文件路径
+    AUTH_TOKENS_FILE: str = os.getenv("AUTH_TOKENS_FILE", "tokens.txt")
+
+    # Token池配置
+    TOKEN_HEALTH_CHECK_INTERVAL: int = int(os.getenv("TOKEN_HEALTH_CHECK_INTERVAL", "300"))  # 5分钟
+    TOKEN_FAILURE_THRESHOLD: int = int(os.getenv("TOKEN_FAILURE_THRESHOLD", "3"))  # 失败3次后标记为不可用
+    TOKEN_RECOVERY_TIMEOUT: int = int(os.getenv("TOKEN_RECOVERY_TIMEOUT", "1800"))  # 30分钟后重试失败的token
+
+    def _load_tokens_from_file(self, file_path: str) -> List[str]:
+        """
+        从文件加载token列表
+
+        支持多种格式的混合使用：
+        1. 每行一个token（换行分隔）
+        2. 逗号分隔的token
+        3. 混合格式（同时支持换行和逗号分隔）
+        """
+        tokens = []
+        try:
+            if os.path.exists(file_path):
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    content = f.read().strip()
+
+                    if not content:
+                        logger.debug(f"📄 Token文件为空: {file_path}")
+                        return tokens
+
+                    logger.debug(f"📄 开始解析token文件: {file_path}")
+
+                    # 智能解析：同时支持换行和逗号分隔
+                    # 1. 先按换行符分割处理每一行
+                    lines = content.split('\n')
+
+                    for line in lines:
+                        line = line.strip()
+                        # 跳过空行和注释行
+                        if not line or line.startswith('#'):
+                            continue
+
+                        # 2. 检查当前行是否包含逗号分隔
+                        if ',' in line:
+                            # 按逗号分割当前行
+                            comma_tokens = line.split(',')
+                            for token in comma_tokens:
+                                token = token.strip()
+                                if token:  # 跳过空token
+                                    tokens.append(token)
+                        else:
+                            # 整行作为一个token
+                            tokens.append(line)
+
+                logger.info(f"📄 从文件加载了 {len(tokens)} 个token: {file_path}")
+            else:
+                logger.debug(f"📄 Token文件不存在: {file_path}")
+        except Exception as e:
+            logger.error(f"❌ 读取token文件失败 {file_path}: {e}")
+        return tokens
+
+    @property
+    def auth_token_list(self) -> List[str]:
+        """
+        解析认证token列表
+
+        仅从AUTH_TOKENS_FILE指定的文件加载token
+        """
+        # 从文件加载token
+        tokens = self._load_tokens_from_file(self.AUTH_TOKENS_FILE)
+
+        # 去重，保持顺序
+        if tokens:
+            seen = set()
+            unique_tokens = []
+            for token in tokens:
+                if token not in seen:
+                    unique_tokens.append(token)
+                    seen.add(token)
+
+            # 记录去重信息
+            duplicate_count = len(tokens) - len(unique_tokens)
+            if duplicate_count > 0:
+                logger.warning(f"⚠️ 检测到 {duplicate_count} 个重复token，已自动去重")
+
+            return unique_tokens
+
+        return []
+
     # Model Configuration
     PRIMARY_MODEL: str = os.getenv("PRIMARY_MODEL", "GLM-4.5")
     THINKING_MODEL: str = os.getenv("THINKING_MODEL", "GLM-4.5-Thinking")
     SEARCH_MODEL: str = os.getenv("SEARCH_MODEL", "GLM-4.5-Search")
     AIR_MODEL: str = os.getenv("AIR_MODEL", "GLM-4.5-Air")
-    
+
     # Server Configuration
     LISTEN_PORT: int = int(os.getenv("LISTEN_PORT", "8080"))
     DEBUG_LOGGING: bool = os.getenv("DEBUG_LOGGING", "true").lower() == "true"
-    
-    # Feature Configuration
-    THINKING_PROCESSING: str = os.getenv("THINKING_PROCESSING", "think")  # strip: 去除<details>标签；think: 转为<span>标签；raw: 保留原样
+
     ANONYMOUS_MODE: bool = os.getenv("ANONYMOUS_MODE", "true").lower() == "true"
     TOOL_SUPPORT: bool = os.getenv("TOOL_SUPPORT", "true").lower() == "true"
     SCAN_LIMIT: int = int(os.getenv("SCAN_LIMIT", "200000"))
     SKIP_AUTH_TOKEN: bool = os.getenv("SKIP_AUTH_TOKEN", "false").lower() == "true"
-    
+
+    # Retry Configuration
+    MAX_RETRIES: int = int(os.getenv("MAX_RETRIES", "5"))
+    RETRY_DELAY: float = float(os.getenv("RETRY_DELAY", "1.0"))  # 初始重试延迟（秒）
+
     # Browser Headers
     CLIENT_HEADERS: Dict[str, str] = {
         "Content-Type": "application/json",
@@ -44,9 +131,9 @@ class Settings(BaseSettings):
         "X-FE-Version": "prod-fe-1.0.70",
         "Origin": "https://chat.z.ai",
     }
-    
+
     class Config:
         env_file = ".env"
 
 
-settings = Settings()
+settings = Settings()

app/core/openai.py

@@ -1,24 +1,29 @@
-"""
-OpenAI API endpoints
-"""
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
 
 import time
+import json
+import asyncio
 from datetime import datetime
-from typing import List
+from typing import List, Dict, Any
 from fastapi import APIRouter, Header, HTTPException
 from fastapi.responses import StreamingResponse
+import httpx
 
 from app.core.config import settings
-from app.models.schemas import (
-    OpenAIRequest, Message, UpstreamRequest, ModelItem, 
-    ModelsResponse, Model
-)
-from app.utils.helpers import debug_log, generate_request_ids, get_auth_token
-from app.utils.tools import process_messages_with_tools, content_to_string
-from app.core.response_handlers import StreamResponseHandler, NonStreamResponseHandler
+from app.models.schemas import OpenAIRequest, Message, ModelsResponse, Model
+from app.utils.logger import get_logger
+from app.core.zai_transformer import ZAITransformer, generate_uuid
+from app.utils.sse_tool_handler import SSEToolHandler
+from app.utils.token_pool import get_token_pool
+
+logger = get_logger()
 
 router = APIRouter()
 
+# 全局转换器实例
+transformer = ZAITransformer()
+
 
 @router.get("/v1/models")
 async def list_models():
@@ -26,150 +31,555 @@ async def list_models():
     current_time = int(time.time())
     response = ModelsResponse(
         data=[
-            Model(
-                id=settings.PRIMARY_MODEL,
-                created=current_time,
-                owned_by="z.ai"
-            ),
-            Model(
-                id=settings.THINKING_MODEL,
-                created=current_time,
-                owned_by="z.ai"
-            ),
-            Model(
-                id=settings.SEARCH_MODEL,
-                created=current_time,
-                owned_by="z.ai"
-            ),
-            Model(
-                id=settings.AIR_MODEL,
-                created=current_time,
-                owned_by="z.ai"
-            ),
+            Model(id=settings.PRIMARY_MODEL, created=current_time, owned_by="z.ai"),
+            Model(id=settings.THINKING_MODEL, created=current_time, owned_by="z.ai"),
+            Model(id=settings.SEARCH_MODEL, created=current_time, owned_by="z.ai"),
+            Model(id=settings.AIR_MODEL, created=current_time, owned_by="z.ai"),
         ]
     )
     return response
 
 
 @router.post("/v1/chat/completions")
-async def chat_completions(
-    request: OpenAIRequest,
-    authorization: str = Header(...)
-):
-    """Handle chat completion requests"""
-    debug_log("收到chat completions请求")
-    
+async def chat_completions(request: OpenAIRequest, authorization: str = Header(...)):
+    """Handle chat completion requests with ZAI transformer"""
+    role = request.messages[0].role if request.messages else "unknown"
+    logger.info(f"😶‍🌫️ 收到 客户端 请求 - 模型: {request.model}, 流式: {request.stream}, 消息数: {len(request.messages)}, 角色: {role}, 工具数: {len(request.tools) if request.tools else 0}")
+
     try:
         # Validate API key (skip if SKIP_AUTH_TOKEN is enabled)
         if not settings.SKIP_AUTH_TOKEN:
             if not authorization.startswith("Bearer "):
-                debug_log("缺少或无效的Authorization头")
                 raise HTTPException(status_code=401, detail="Missing or invalid Authorization header")
-            
+
             api_key = authorization[7:]
             if api_key != settings.AUTH_TOKEN:
-                debug_log(f"无效的API key: {api_key}")
                 raise HTTPException(status_code=401, detail="Invalid API key")
-            
-            debug_log(f"API key验证通过，AUTH_TOKEN={api_key[:8]}......")
-        else:
-            debug_log("SKIP_AUTH_TOKEN已启用，跳过API key验证")
-        debug_log(f"请求解析成功 - 模型: {request.model}, 流式: {request.stream}, 消息数: {len(request.messages)}")
-        
-        # Generate IDs
-        chat_id, msg_id = generate_request_ids()
-        
-        # Process messages with tools
-        processed_messages = process_messages_with_tools(
-            [m.model_dump() for m in request.messages],
-            request.tools,
-            request.tool_choice
-        )
-        
-        # Convert back to Message objects
-        upstream_messages: List[Message] = []
-        for msg in processed_messages:
-            content = content_to_string(msg.get("content"))
-            
-            upstream_messages.append(Message(
-                role=msg["role"],
-                content=content,
-                reasoning_content=msg.get("reasoning_content")
-            ))
+
+        # 使用新的转换器转换请求
+        request_dict = request.model_dump()
+        logger.info("🔄 开始转换请求格式: OpenAI -> Z.AI")
         
-        # Determine model features
-        is_thinking = request.model == settings.THINKING_MODEL
-        is_search = request.model == settings.SEARCH_MODEL
-        is_air = request.model == settings.AIR_MODEL
-        search_mcp = "deep-web-search" if is_search else ""
+        transformed = await transformer.transform_request_in(request_dict)
+        # logger.debug(f"🔄 转换后 Z.AI 请求体: {json.dumps(transformed['body'], ensure_ascii=False, indent=2)}")
+
+        # 调用上游API
+        async def stream_response():
+            """流式响应生成器（包含重试机制）"""
+            retry_count = 0
+            last_error = None
+            current_token = transformed.get("token", "")  # 获取当前使用的token
+
+            while retry_count <= settings.MAX_RETRIES:
+                try:
+                    # 如果是重试，重新获取令牌并更新请求
+                    if retry_count > 0:
+                        delay = settings.RETRY_DELAY
+                        logger.warning(f"重试请求 ({retry_count}/{settings.MAX_RETRIES}) - 等待 {delay:.1f}s")
+                        await asyncio.sleep(delay)
+
+                        # 标记前一个token失败（如果不是匿名模式）
+                        if current_token and not settings.ANONYMOUS_MODE:
+                            transformer.mark_token_failure(current_token, Exception(f"Retry {retry_count}: {last_error}"))
+
+                        # 重新获取令牌
+                        logger.info("🔑 重新获取令牌用于重试...")
+                        new_token = await transformer.get_token()
+                        if not new_token:
+                            logger.error("❌ 重试时无法获取有效的认证令牌")
+                            raise Exception("重试时无法获取有效的认证令牌")
+                        transformed["config"]["headers"]["Authorization"] = f"Bearer {new_token}"
+                        current_token = new_token
+
+                    async with httpx.AsyncClient(timeout=60.0) as client:
+                        # 发送请求到上游
+                        logger.info(f"🎯 发送请求到 Z.AI: {transformed['config']['url']}")
+                        async with client.stream(
+                            "POST",
+                            transformed["config"]["url"],
+                            json=transformed["body"],
+                            headers=transformed["config"]["headers"],
+                        ) as response:
+                            # 检查响应状态码
+                            if response.status_code == 400:
+                                # 400 错误，触发重试
+                                error_text = await response.aread()
+                                error_msg = error_text.decode('utf-8', errors='ignore')
+                                logger.warning(f"❌ 上游返回 400 错误 (尝试 {retry_count + 1}/{settings.MAX_RETRIES + 1})")
+
+                                retry_count += 1
+                                last_error = f"400 Bad Request: {error_msg}"
+
+                                # 如果还有重试机会，继续循环
+                                if retry_count <= settings.MAX_RETRIES:
+                                    continue
+                                else:
+                                    # 达到最大重试次数，抛出错误
+                                    logger.error(f"❌ 达到最大重试次数 ({settings.MAX_RETRIES})，请求失败")
+                                    error_response = {
+                                        "error": {
+                                            "message": f"Request failed after {settings.MAX_RETRIES} retries: {last_error}",
+                                            "type": "upstream_error",
+                                            "code": 400
+                                        }
+                                    }
+                                    yield f"data: {json.dumps(error_response)}\n\n"
+                                    yield "data: [DONE]\n\n"
+                                    return
+
+                            elif response.status_code != 200:
+                                # 其他错误，直接返回
+                                logger.error(f"❌ 上游返回错误: {response.status_code}")
+                                error_text = await response.aread()
+                                error_msg = error_text.decode('utf-8', errors='ignore')
+                                logger.error(f"❌ 错误详情: {error_msg}")
+
+                                error_response = {
+                                    "error": {
+                                        "message": f"Upstream error: {response.status_code}",
+                                        "type": "upstream_error",
+                                        "code": response.status_code
+                                    }
+                                }
+                                yield f"data: {json.dumps(error_response)}\n\n"
+                                yield "data: [DONE]\n\n"
+                                return
+
+                            # 200 成功，处理响应
+                            logger.info(f"✅ Z.AI 响应成功，开始处理 SSE 流")
+                            if retry_count > 0:
+                                logger.info(f"✨ 第 {retry_count} 次重试成功")
+
+                            # 标记token使用成功（如果不是匿名模式）
+                            if current_token and not settings.ANONYMOUS_MODE:
+                                transformer.mark_token_success(current_token)
+
+                            # 初始化工具处理器（如果需要）
+                            has_tools = transformed["body"].get("tools") is not None
+                            tool_handler = None
+                            if has_tools:
+                                chat_id = transformed["body"]["chat_id"]
+                                model = request.model
+                                tool_handler = SSEToolHandler(chat_id, model)
+                                logger.info(f"🔧 初始化工具处理器: {len(transformed['body'].get('tools', []))} 个工具")
+
+                            # 处理状态
+                            has_thinking = False
+                            thinking_signature = None
+
+                            # 处理SSE流
+                            buffer = ""
+                            line_count = 0
+                            logger.debug("📡 开始接收 SSE 流数据...")
+
+                            async for line in response.aiter_lines():
+                                line_count += 1
+                                if not line:
+                                    continue
+
+                                # 累积到buffer处理完整的数据行
+                                buffer += line + "\n"
+
+                                # 检查是否有完整的data行
+                                while "\n" in buffer:
+                                    current_line, buffer = buffer.split("\n", 1)
+                                    if not current_line.strip():
+                                        continue
+
+                                    if current_line.startswith("data:"):
+                                        chunk_str = current_line[5:].strip()
+                                        if not chunk_str or chunk_str == "[DONE]":
+                                            if chunk_str == "[DONE]":
+                                                yield "data: [DONE]\n\n"
+                                            continue
+
+                                        logger.debug(f"📦 解析数据块: {chunk_str[:1000]}..." if len(chunk_str) > 1000 else f"📦 解析数据块: {chunk_str}")
+
+                                        try:
+                                            chunk = json.loads(chunk_str)
+
+                                            if chunk.get("type") == "chat:completion":
+                                                data = chunk.get("data", {})
+                                                phase = data.get("phase")
+
+                                                # 记录每个阶段（只在阶段变化时记录）
+                                                if phase and phase != getattr(stream_response, '_last_phase', None):
+                                                    logger.info(f"📈 SSE 阶段: {phase}")
+                                                    stream_response._last_phase = phase
+
+                                                # 处理工具调用
+                                                if phase == "tool_call" and tool_handler:
+                                                    for output in tool_handler.process_tool_call_phase(data, True):
+                                                        yield output
+
+                                                # 处理其他阶段（工具结束）
+                                                elif phase == "other" and tool_handler:
+                                                    for output in tool_handler.process_other_phase(data, True):
+                                                        yield output
+
+                                                # 处理思考内容
+                                                elif phase == "thinking":
+                                                    if not has_thinking:
+                                                        has_thinking = True
+                                                        has_thinking = True
+                                                        # 发送初始角色
+                                                        role_chunk = {
+                                                            "choices": [
+                                                                {
+                                                                    "delta": {"role": "assistant"},
+                                                                    "finish_reason": None,
+                                                                    "index": 0,
+                                                                    "logprobs": None,
+                                                                }
+                                                            ],
+                                                            "created": int(time.time()),
+                                                            "id": transformed["body"]["chat_id"],
+                                                            "model": request.model,
+                                                            "object": "chat.completion.chunk",
+                                                            "system_fingerprint": "fp_zai_001",
+                                                        }
+                                                        yield f"data: {json.dumps(role_chunk)}\n\n"
+
+                                                    delta_content = data.get("delta_content", "")
+                                                    if delta_content:
+                                                        # 处理思考内容格式
+                                                        if delta_content.startswith("<details"):
+                                                            content = (
+                                                                delta_content.split("</summary>\n>")[-1].strip()
+                                                                if "</summary>\n>" in delta_content
+                                                                else delta_content
+                                                            )
+                                                        else:
+                                                            content = delta_content
+
+                                                        thinking_chunk = {
+                                                            "choices": [
+                                                                {
+                                                                    "delta": {
+                                                                        "role": "assistant",
+                                                                        "thinking": {"content": content},
+                                                                    },
+                                                                    "finish_reason": None,
+                                                                    "index": 0,
+                                                                    "logprobs": None,
+                                                                }
+                                                            ],
+                                                            "created": int(time.time()),
+                                                            "id": transformed["body"]["chat_id"],
+                                                            "model": request.model,
+                                                            "object": "chat.completion.chunk",
+                                                            "system_fingerprint": "fp_zai_001",
+                                                        }
+                                                        yield f"data: {json.dumps(thinking_chunk)}\n\n"
+
+                                                # 处理答案内容
+                                                elif phase == "answer":
+                                                    edit_content = data.get("edit_content", "")
+                                                    delta_content = data.get("delta_content", "")
+
+                                                    # 处理思考结束和答案开始
+                                                    if edit_content and "</details>\n" in edit_content:
+                                                        if has_thinking:
+                                                            # 发送思考签名
+                                                            thinking_signature = str(int(time.time() * 1000))
+                                                            sig_chunk = {
+                                                                "choices": [
+                                                                    {
+                                                                        "delta": {
+                                                                            "role": "assistant",
+                                                                            "thinking": {
+                                                                                "content": "",
+                                                                                "signature": thinking_signature,
+                                                                            },
+                                                                        },
+                                                                        "finish_reason": None,
+                                                                        "index": 0,
+                                                                        "logprobs": None,
+                                                                    }
+                                                                ],
+                                                                "created": int(time.time()),
+                                                                "id": transformed["body"]["chat_id"],
+                                                                "model": request.model,
+                                                                "object": "chat.completion.chunk",
+                                                                "system_fingerprint": "fp_zai_001",
+                                                            }
+                                                            yield f"data: {json.dumps(sig_chunk)}\n\n"
+
+                                                        # 提取答案内容
+                                                        content_after = edit_content.split("</details>\n")[-1]
+                                                        if content_after:
+                                                            content_chunk = {
+                                                                "choices": [
+                                                                    {
+                                                                        "delta": {
+                                                                            "role": "assistant",
+                                                                            "content": content_after,
+                                                                        },
+                                                                        "finish_reason": None,
+                                                                        "index": 0,
+                                                                        "logprobs": None,
+                                                                    }
+                                                                ],
+                                                                "created": int(time.time()),
+                                                                "id": transformed["body"]["chat_id"],
+                                                                "model": request.model,
+                                                                "object": "chat.completion.chunk",
+                                                                "system_fingerprint": "fp_zai_001",
+                                                            }
+                                                            yield f"data: {json.dumps(content_chunk)}\n\n"
+
+                                                    # 处理增量内容
+                                                    elif delta_content:
+                                                        # 如果还没有发送角色
+                                                        if not has_thinking:
+                                                            role_chunk = {
+                                                                "choices": [
+                                                                    {
+                                                                        "delta": {"role": "assistant"},
+                                                                        "finish_reason": None,
+                                                                        "index": 0,
+                                                                        "logprobs": None,
+                                                                    }
+                                                                ],
+                                                                "created": int(time.time()),
+                                                                "id": transformed["body"]["chat_id"],
+                                                                "model": request.model,
+                                                                "object": "chat.completion.chunk",
+                                                                "system_fingerprint": "fp_zai_001",
+                                                            }
+                                                            yield f"data: {json.dumps(role_chunk)}\n\n"
+
+                                                        content_chunk = {
+                                                            "choices": [
+                                                                {
+                                                                    "delta": {
+                                                                        "role": "assistant",
+                                                                        "content": delta_content,
+                                                                    },
+                                                                    "finish_reason": None,
+                                                                    "index": 0,
+                                                                    "logprobs": None,
+                                                                }
+                                                            ],
+                                                            "created": int(time.time()),
+                                                            "id": transformed["body"]["chat_id"],
+                                                            "model": request.model,
+                                                            "object": "chat.completion.chunk",
+                                                            "system_fingerprint": "fp_zai_001",
+                                                        }
+                                                        output_data = f"data: {json.dumps(content_chunk)}\n\n"
+                                                        logger.debug(f"➡️ 输出内容块到客户端: {output_data[:1000]}...")
+                                                        yield output_data
+
+                                                    # 处理完成
+                                                    if data.get("usage"):
+                                                        logger.info(f"📦 完成响应 - 使用统计: {json.dumps(data['usage'])}")
+
+                                                        # 只有在非工具调用模式下才发送普通完成信号
+                                                        if not tool_handler or not tool_handler.has_tool_call:
+                                                            finish_chunk = {
+                                                                "choices": [
+                                                                    {
+                                                                        "delta": {"role": "assistant", "content": ""},
+                                                                        "finish_reason": "stop",
+                                                                        "index": 0,
+                                                                        "logprobs": None,
+                                                                    }
+                                                                ],
+                                                                "usage": data["usage"],
+                                                                "created": int(time.time()),
+                                                                "id": transformed["body"]["chat_id"],
+                                                                "model": request.model,
+                                                                "object": "chat.completion.chunk",
+                                                                "system_fingerprint": "fp_zai_001",
+                                                            }
+                                                            finish_output = f"data: {json.dumps(finish_chunk)}\n\n"
+                                                            logger.debug(f"➡️ 发送完成信号: {finish_output[:1000]}...")
+                                                            yield finish_output
+                                                            logger.debug("➡️ 发送 [DONE]")
+                                                            yield "data: [DONE]\n\n"
+
+                                        except json.JSONDecodeError as e:
+                                            logger.debug(f"❌ JSON解析错误: {e}, 内容: {chunk_str[:1000]}")
+                                        except Exception as e:
+                                            logger.error(f"❌ 处理chunk错误: {e}")
+
+                            # 确保发送结束信号
+                            if not tool_handler or not tool_handler.has_tool_call:
+                                logger.debug("📤 发送最终 [DONE] 信号")
+                                yield "data: [DONE]\n\n"
+
+                            logger.info(f"✅ SSE 流处理完成，共处理 {line_count} 行数据")
+                            # 成功处理完成，退出重试循环
+                            return
+
+                except Exception as e:
+                    logger.error(f"❌ 流处理错误: {e}")
+                    import traceback
+                    logger.error(traceback.format_exc())
+
+                    # 标记token失败（如果不是匿名模式）
+                    if current_token and not settings.ANONYMOUS_MODE:
+                        transformer.mark_token_failure(current_token, e)
+
+                    # 检查是否还可以重试
+                    retry_count += 1
+                    last_error = str(e)
+
+                    if retry_count > settings.MAX_RETRIES:
+                        # 达到最大重试次数，返回错误
+                        logger.error(f"❌ 达到最大重试次数 ({settings.MAX_RETRIES})，流处理失败")
+                        error_response = {
+                            "error": {
+                                "message": f"Stream processing failed after {settings.MAX_RETRIES} retries: {last_error}",
+                                "type": "stream_error"
+                            }
+                        }
+                        yield f"data: {json.dumps(error_response)}\n\n"
+                        yield "data: [DONE]\n\n"
+                        return
+
+        # 返回流式响应
+        logger.info("🚀 启动 SSE 流式响应")
         
-        # Determine upstream model ID based on requested model
-        if is_air:
-            upstream_model_id = "0727-106B-API"  # AIR model upstream ID
-            upstream_model_name = "GLM-4.5-Air"
-        else:
-            upstream_model_id = "0727-360B-API"  # Default upstream model ID
-            upstream_model_name = "GLM-4.5"
+        # 创建一个包装的生成器来追踪数据流
+        async def logged_stream():
+            chunk_count = 0
+            try:
+                logger.debug("📤 开始向客户端流式传输数据...")
+                async for chunk in stream_response():
+                    chunk_count += 1
+                    logger.debug(f"📤 发送块[{chunk_count}]: {chunk[:1000]}..." if len(chunk) > 1000 else f"  📤 发送块[{chunk_count}]: {chunk}")
+                    yield chunk
+                logger.info(f"✅ 流式传输完成，共发送 {chunk_count} 个数据块")
+            except Exception as e:
+                logger.error(f"❌ 流式传输中断: {e}")
+                raise
         
-        # Build upstream request
-        upstream_req = UpstreamRequest(
-            stream=True,  # Always use streaming from upstream
-            chat_id=chat_id,
-            id=msg_id,
-            model=upstream_model_id,  # Dynamic upstream model ID
-            messages=upstream_messages,
-            params={},
-            features={
-                "enable_thinking": is_thinking,
-                "web_search": is_search,
-                "auto_web_search": is_search,
-            },
-            background_tasks={
-                "title_generation": False,
-                "tags_generation": False,
+        return StreamingResponse(
+            logged_stream(),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
             },
-            mcp_servers=[search_mcp] if search_mcp else [],
-            model_item=ModelItem(
-                id=upstream_model_id,
-                name=upstream_model_name,
-                owned_by="openai"
-            ),
-            tool_servers=[],
-            variables={
-                "{{USER_NAME}}": "User",
-                "{{USER_LOCATION}}": "Unknown",
-                "{{CURRENT_DATETIME}}": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-            }
         )
-        
-        # Get authentication token
-        auth_token = get_auth_token()
-        
-        # Check if tools are enabled and present
-        has_tools = (settings.TOOL_SUPPORT and 
-                    request.tools and 
-                    len(request.tools) > 0 and 
-                    request.tool_choice != "none")
-        
-        # Handle response based on stream flag
-        if request.stream:
-            handler = StreamResponseHandler(upstream_req, chat_id, auth_token, has_tools)
-            return StreamingResponse(
-                handler.handle(),
-                media_type="text/event-stream",
-                headers={
-                    "Cache-Control": "no-cache",
-                    "Connection": "keep-alive",
-                }
-            )
-        else:
-            handler = NonStreamResponseHandler(upstream_req, chat_id, auth_token, has_tools)
-            return handler.handle()
-            
+
     except HTTPException:
         raise
     except Exception as e:
-        debug_log(f"处理请求时发生错误: {str(e)}")
+        logger.error(f"❌ 处理请求时发生错误: {str(e)}")
         import traceback
-        debug_log(f"错误堆栈: {traceback.format_exc()}")
-        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+        logger.error(f"❌ 错误堆栈: {traceback.format_exc()}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+
+@router.get("/v1/token-pool/status")
+async def get_token_pool_status():
+    """获取token池状态信息"""
+    try:
+        token_pool = get_token_pool()
+        if not token_pool:
+            return {
+                "status": "disabled",
+                "message": "Token池未初始化，当前仅使用匿名模式",
+                "anonymous_mode": settings.ANONYMOUS_MODE,
+                "auth_tokens_file": settings.AUTH_TOKENS_FILE,
+                "auth_tokens_configured": len(settings.auth_token_list) > 0
+            }
+
+        pool_status = token_pool.get_pool_status()
+        return {
+            "status": "active",
+            "pool_info": pool_status,
+            "config": {
+                "anonymous_mode": settings.ANONYMOUS_MODE,
+                "failure_threshold": settings.TOKEN_FAILURE_THRESHOLD,
+                "recovery_timeout": settings.TOKEN_RECOVERY_TIMEOUT,
+                "health_check_interval": settings.TOKEN_HEALTH_CHECK_INTERVAL
+            }
+        }
+    except Exception as e:
+        logger.error(f"获取token池状态失败: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to get token pool status: {str(e)}")
+
+
+@router.post("/v1/token-pool/health-check")
+async def trigger_health_check():
+    """手动触发token池健康检查"""
+    try:
+        token_pool = get_token_pool()
+        if not token_pool:
+            raise HTTPException(status_code=404, detail="Token池未初始化")
+
+        # 记录开始时间
+        import time
+        start_time = time.time()
+
+        logger.info("🔍 API触发Token池健康检查...")
+        await token_pool.health_check_all()
+
+        # 计算耗时
+        duration = time.time() - start_time
+
+        pool_status = token_pool.get_pool_status()
+
+        # 统计健康检查结果 - 基于实际的健康状态
+        total_tokens = pool_status['total_tokens']
+        healthy_tokens = sum(1 for token_info in pool_status['tokens'] if token_info['is_healthy'])
+        unhealthy_tokens = total_tokens - healthy_tokens
+
+        # 构建响应
+        response = {
+            "status": "completed",
+            "message": f"健康检查已完成，耗时 {duration:.2f} 秒",
+            "summary": {
+                "total_tokens": total_tokens,
+                "healthy_tokens": healthy_tokens,
+                "unhealthy_tokens": unhealthy_tokens,
+                "health_rate": f"{(healthy_tokens/total_tokens*100):.1f}%" if total_tokens > 0 else "0%",
+                "duration_seconds": round(duration, 2)
+            },
+            "pool_info": pool_status
+        }
+
+        # 添加建议
+        if unhealthy_tokens > 0:
+            response["recommendations"] = []
+            if unhealthy_tokens == total_tokens:
+                response["recommendations"].append("所有token都不健康，请检查token配置和网络连接")
+            else:
+                response["recommendations"].append(f"有 {unhealthy_tokens} 个token不健康，建议检查这些token的有效性")
+
+        logger.info(f"✅ API健康检查完成: {healthy_tokens}/{total_tokens} 个token健康")
+        return response
+    except Exception as e:
+        logger.error(f"健康检查失败: {e}")
+        raise HTTPException(status_code=500, detail=f"Health check failed: {str(e)}")
+
+
+@router.post("/v1/token-pool/update")
+async def update_token_pool(tokens: List[str]):
+    """动态更新token池"""
+    try:
+        from app.utils.token_pool import update_token_pool
+
+        # 过滤空token
+        valid_tokens = [token.strip() for token in tokens if token.strip()]
+        if not valid_tokens:
+            raise HTTPException(status_code=400, detail="至少需要提供一个有效的token")
+
+        update_token_pool(valid_tokens)
+
+        token_pool = get_token_pool()
+        pool_status = token_pool.get_pool_status() if token_pool else None
+
+        return {
+            "status": "updated",
+            "message": f"Token池已更新，共 {len(valid_tokens)} 个token",
+            "pool_info": pool_status
+        }
+    except Exception as e:
+        logger.error(f"更新token池失败: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to update token pool: {str(e)}")

app/core/response_handlers.py

@@ -1,333 +0,0 @@
-"""
-Response handlers for streaming and non-streaming responses
-"""
-
-import json
-import time
-from typing import Generator, Optional
-import requests
-from fastapi import HTTPException
-from fastapi.responses import JSONResponse, StreamingResponse
-
-from app.core.config import settings
-from app.models.schemas import (
-    Message, Delta, Choice, Usage, OpenAIResponse, 
-    UpstreamRequest, UpstreamData, UpstreamError, ModelItem
-)
-from app.utils.helpers import debug_log, call_upstream_api, transform_thinking_content
-from app.utils.sse_parser import SSEParser
-from app.utils.tools import extract_tool_invocations, remove_tool_json_content
-
-
-def create_openai_response_chunk(
-    model: str,
-    delta: Optional[Delta] = None,
-    finish_reason: Optional[str] = None
-) -> OpenAIResponse:
-    """Create OpenAI response chunk for streaming"""
-    return OpenAIResponse(
-        id=f"chatcmpl-{int(time.time())}",
-        object="chat.completion.chunk",
-        created=int(time.time()),
-        model=model,
-        choices=[Choice(
-            index=0,
-            delta=delta or Delta(),
-            finish_reason=finish_reason
-        )]
-    )
-
-
-def handle_upstream_error(error: UpstreamError) -> Generator[str, None, None]:
-    """Handle upstream error response"""
-    debug_log(f"上游错误: code={error.code}, detail={error.detail}")
-    
-    # Send end chunk
-    end_chunk = create_openai_response_chunk(
-        model=settings.PRIMARY_MODEL,
-        finish_reason="stop"
-    )
-    yield f"data: {end_chunk.model_dump_json()}\n\n"
-    yield "data: [DONE]\n\n"
-
-
-class ResponseHandler:
-    """Base class for response handling"""
-    
-    def __init__(self, upstream_req: UpstreamRequest, chat_id: str, auth_token: str):
-        self.upstream_req = upstream_req
-        self.chat_id = chat_id
-        self.auth_token = auth_token
-    
-    def _call_upstream(self) -> requests.Response:
-        """Call upstream API with error handling"""
-        try:
-            return call_upstream_api(self.upstream_req, self.chat_id, self.auth_token)
-        except Exception as e:
-            debug_log(f"调用上游失败: {e}")
-            raise
-    
-    def _handle_upstream_error(self, response: requests.Response) -> None:
-        """Handle upstream error response"""
-        debug_log(f"上游返回错误状态: {response.status_code}")
-        if settings.DEBUG_LOGGING:
-            debug_log(f"上游错误响应: {response.text}")
-
-
-class StreamResponseHandler(ResponseHandler):
-    """Handler for streaming responses"""
-    
-    def __init__(self, upstream_req: UpstreamRequest, chat_id: str, auth_token: str, has_tools: bool = False):
-        super().__init__(upstream_req, chat_id, auth_token)
-        self.has_tools = has_tools
-        self.buffered_content = ""
-        self.tool_calls = None
-    
-    def handle(self) -> Generator[str, None, None]:
-        """Handle streaming response"""
-        debug_log(f"开始处理流式响应 (chat_id={self.chat_id})")
-        
-        try:
-            response = self._call_upstream()
-        except Exception:
-            yield "data: {\"error\": \"Failed to call upstream\"}\n\n"
-            return
-        
-        if response.status_code != 200:
-            self._handle_upstream_error(response)
-            yield "data: {\"error\": \"Upstream error\"}\n\n"
-            return
-        
-        # Send initial role chunk
-        first_chunk = create_openai_response_chunk(
-            model=settings.PRIMARY_MODEL,
-            delta=Delta(role="assistant")
-        )
-        yield f"data: {first_chunk.model_dump_json()}\n\n"
-        
-        # Process stream
-        debug_log("开始读取上游SSE流")
-        sent_initial_answer = False
-        
-        with SSEParser(response, debug_mode=settings.DEBUG_LOGGING) as parser:
-            for event in parser.iter_json_data(UpstreamData):
-                upstream_data = event['data']
-                
-                # Check for errors
-                if self._has_error(upstream_data):
-                    error = self._get_error(upstream_data)
-                    yield from handle_upstream_error(error)
-                    break
-                
-                debug_log(f"解析成功 - 类型: {upstream_data.type}, 阶段: {upstream_data.data.phase}, "
-                         f"内容长度: {len(upstream_data.data.delta_content)}, 完成: {upstream_data.data.done}")
-                
-                # Process content
-                yield from self._process_content(upstream_data, sent_initial_answer)
-                
-                # Check if done
-                if upstream_data.data.done or upstream_data.data.phase == "done":
-                    debug_log("检测到流结束信号")
-                    yield from self._send_end_chunk()
-                    break
-    
-    def _has_error(self, upstream_data: UpstreamData) -> bool:
-        """Check if upstream data contains error"""
-        return bool(
-            upstream_data.error or 
-            upstream_data.data.error or 
-            (upstream_data.data.inner and upstream_data.data.inner.error)
-        )
-    
-    def _get_error(self, upstream_data: UpstreamData) -> UpstreamError:
-        """Get error from upstream data"""
-        return (
-            upstream_data.error or 
-            upstream_data.data.error or 
-            (upstream_data.data.inner.error if upstream_data.data.inner else None)
-        )
-    
-    def _process_content(
-        self, 
-        upstream_data: UpstreamData, 
-        sent_initial_answer: bool
-    ) -> Generator[str, None, None]:
-        """Process content from upstream data"""
-        content = upstream_data.data.delta_content or upstream_data.data.edit_content
-        
-        if not content:
-            return
-        
-        # Transform thinking content
-        if upstream_data.data.phase == "thinking":
-            content = transform_thinking_content(content)
-        
-        # Buffer content if tools are enabled
-        if self.has_tools:
-            self.buffered_content += content
-        else:
-            # Handle initial answer content
-            if (not sent_initial_answer and 
-                upstream_data.data.edit_content and 
-                upstream_data.data.phase == "answer"):
-                
-                content = self._extract_edit_content(upstream_data.data.edit_content)
-                if content:
-                    debug_log(f"发送普通内容: {content}")
-                    chunk = create_openai_response_chunk(
-                        model=settings.PRIMARY_MODEL,
-                        delta=Delta(content=content)
-                    )
-                    yield f"data: {chunk.model_dump_json()}\n\n"
-                    sent_initial_answer = True
-            
-            # Handle delta content
-            if upstream_data.data.delta_content:
-                if content:
-                    if upstream_data.data.phase == "thinking":
-                        debug_log(f"发送思考内容: {content}")
-                        chunk = create_openai_response_chunk(
-                            model=settings.PRIMARY_MODEL,
-                            delta=Delta(reasoning_content=content)
-                        )
-                    else:
-                        debug_log(f"发送普通内容: {content}")
-                        chunk = create_openai_response_chunk(
-                            model=settings.PRIMARY_MODEL,
-                            delta=Delta(content=content)
-                        )
-                    yield f"data: {chunk.model_dump_json()}\n\n"
-    
-    def _extract_edit_content(self, edit_content: str) -> str:
-        """Extract content from edit_content field"""
-        parts = edit_content.split("</details>")
-        return parts[1] if len(parts) > 1 else ""
-    
-    def _send_end_chunk(self) -> Generator[str, None, None]:
-        """Send end chunk and DONE signal"""
-        finish_reason = "stop"
-        
-        if self.has_tools:
-            # Try to extract tool calls from buffered content
-            self.tool_calls = extract_tool_invocations(self.buffered_content)
-            
-            if self.tool_calls:
-                # Send tool calls with proper format
-                for i, tc in enumerate(self.tool_calls):
-                    tool_call_delta = {
-                        "index": i,
-                        "id": tc.get("id"),
-                        "type": tc.get("type", "function"),
-                        "function": tc.get("function", {}),
-                    }
-                    
-                    out_chunk = create_openai_response_chunk(
-                        model=settings.PRIMARY_MODEL,
-                        delta=Delta(tool_calls=[tool_call_delta])
-                    )
-                    yield f"data: {out_chunk.model_dump_json()}\n\n"
-                
-                finish_reason = "tool_calls"
-            else:
-                # Send regular content
-                trimmed_content = remove_tool_json_content(self.buffered_content)
-                if trimmed_content:
-                    content_chunk = create_openai_response_chunk(
-                        model=settings.PRIMARY_MODEL,
-                        delta=Delta(content=trimmed_content)
-                    )
-                    yield f"data: {content_chunk.model_dump_json()}\n\n"
-        
-        # Send final chunk
-        end_chunk = create_openai_response_chunk(
-            model=settings.PRIMARY_MODEL,
-            finish_reason=finish_reason
-        )
-        yield f"data: {end_chunk.model_dump_json()}\n\n"
-        yield "data: [DONE]\n\n"
-        debug_log("流式响应完成")
-
-
-class NonStreamResponseHandler(ResponseHandler):
-    """Handler for non-streaming responses"""
-    
-    def __init__(self, upstream_req: UpstreamRequest, chat_id: str, auth_token: str, has_tools: bool = False):
-        super().__init__(upstream_req, chat_id, auth_token)
-        self.has_tools = has_tools
-    
-    def handle(self) -> JSONResponse:
-        """Handle non-streaming response"""
-        debug_log(f"开始处理非流式响应 (chat_id={self.chat_id})")
-        
-        try:
-            response = self._call_upstream()
-        except Exception as e:
-            debug_log(f"调用上游失败: {e}")
-            raise HTTPException(status_code=502, detail="Failed to call upstream")
-        
-        if response.status_code != 200:
-            self._handle_upstream_error(response)
-            raise HTTPException(status_code=502, detail="Upstream error")
-        
-        # Collect full response
-        full_content = []
-        debug_log("开始收集完整响应内容")
-        
-        with SSEParser(response, debug_mode=settings.DEBUG_LOGGING) as parser:
-            for event in parser.iter_json_data(UpstreamData):
-                upstream_data = event['data']
-                
-                if upstream_data.data.delta_content:
-                    content = upstream_data.data.delta_content
-                    
-                    if upstream_data.data.phase == "thinking":
-                        content = transform_thinking_content(content)
-                    
-                    if content:
-                        full_content.append(content)
-                
-                if upstream_data.data.done or upstream_data.data.phase == "done":
-                    debug_log("检测到完成信号，停止收集")
-                    break
-        
-        final_content = "".join(full_content)
-        debug_log(f"内容收集完成，最终长度: {len(final_content)}")
-        
-        # Handle tool calls for non-streaming
-        tool_calls = None
-        finish_reason = "stop"
-        message_content = final_content
-        
-        if self.has_tools:
-            tool_calls = extract_tool_invocations(final_content)
-            if tool_calls:
-                # Content must be null when tool_calls are present (OpenAI spec)
-                message_content = None
-                finish_reason = "tool_calls"
-                debug_log(f"提取到工具调用: {json.dumps(tool_calls, ensure_ascii=False)}")
-            else:
-                # Remove tool JSON from content
-                message_content = remove_tool_json_content(final_content)
-                if not message_content:
-                    message_content = final_content  # 保留原内容如果清理后为空
-        
-        # Build response
-        response_data = OpenAIResponse(
-            id=f"chatcmpl-{int(time.time())}",
-            object="chat.completion",
-            created=int(time.time()),
-            model=settings.PRIMARY_MODEL,
-            choices=[Choice(
-                index=0,
-                message=Message(
-                    role="assistant",
-                    content=message_content,
-                    tool_calls=tool_calls
-                ),
-                finish_reason=finish_reason
-            )],
-            usage=Usage()
-        )
-        
-        debug_log("非流式响应发送完成")
-        return JSONResponse(content=response_data.model_dump(exclude_none=True))

app/core/zai_transformer.py

@@ -0,0 +1,726 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import json
+import time
+import uuid
+import random
+import requests
+from datetime import datetime
+from typing import Dict, List, Any, Optional, Generator, AsyncGenerator
+import httpx
+import asyncio
+from fake_useragent import UserAgent
+
+from app.core.config import settings
+from app.utils.logger import get_logger
+from app.utils.token_pool import get_token_pool, initialize_token_pool
+
+logger = get_logger()
+
+# 全局 UserAgent 实例（单例模式）
+_user_agent_instance = None
+
+
+def get_user_agent_instance() -> UserAgent:
+    """获取或创建 UserAgent 实例（单例模式）"""
+    global _user_agent_instance
+    if _user_agent_instance is None:
+        _user_agent_instance = UserAgent()
+    return _user_agent_instance
+
+
+def get_dynamic_headers(chat_id: str = "") -> Dict[str, str]:
+    """生成动态浏览器headers，包含随机User-Agent"""
+    ua = get_user_agent_instance()
+
+    # 随机选择浏览器类型，偏向Chrome和Edge
+    browser_choices = ["chrome", "chrome", "chrome", "edge", "edge", "firefox", "safari"]
+    browser_type = random.choice(browser_choices)
+
+    try:
+        if browser_type == "chrome":
+            user_agent = ua.chrome
+        elif browser_type == "edge":
+            user_agent = ua.edge
+        elif browser_type == "firefox":
+            user_agent = ua.firefox
+        elif browser_type == "safari":
+            user_agent = ua.safari
+        else:
+            user_agent = ua.random
+    except:
+        user_agent = ua.random
+
+    # 提取版本信息
+    chrome_version = "139"
+    edge_version = "139"
+
+    if "Chrome/" in user_agent:
+        try:
+            chrome_version = user_agent.split("Chrome/")[1].split(".")[0]
+        except:
+            pass
+
+    if "Edg/" in user_agent:
+        try:
+            edge_version = user_agent.split("Edg/")[1].split(".")[0]
+            sec_ch_ua = f'"Microsoft Edge";v="{edge_version}", "Chromium";v="{chrome_version}", "Not_A Brand";v="24"'
+        except:
+            sec_ch_ua = f'"Not_A Brand";v="8", "Chromium";v="{chrome_version}", "Google Chrome";v="{chrome_version}"'
+    elif "Firefox/" in user_agent:
+        sec_ch_ua = None  # Firefox不使用sec-ch-ua
+    else:
+        sec_ch_ua = f'"Not_A Brand";v="8", "Chromium";v="{chrome_version}", "Google Chrome";v="{chrome_version}"'
+
+    headers = {
+        "Content-Type": "application/json",
+        "Accept": "application/json, text/event-stream",
+        "User-Agent": user_agent,
+        "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
+        "X-FE-Version": "prod-fe-1.0.79",
+        "Origin": "https://chat.z.ai",
+    }
+
+    if sec_ch_ua:
+        headers["sec-ch-ua"] = sec_ch_ua
+        headers["sec-ch-ua-mobile"] = "?0"
+        headers["sec-ch-ua-platform"] = '"Windows"'
+
+    if chat_id:
+        headers["Referer"] = f"https://chat.z.ai/c/{chat_id}"
+    else:
+        headers["Referer"] = "https://chat.z.ai/"
+
+    return headers
+
+
+def generate_uuid() -> str:
+    """生成UUID v4"""
+    return str(uuid.uuid4())
+
+
+def get_auth_token_sync() -> str:
+    """同步获取认证令牌（用于非异步场景）"""
+    if settings.ANONYMOUS_MODE:
+        try:
+            headers = get_dynamic_headers()
+            response = requests.get("https://chat.z.ai/api/v1/auths/", headers=headers, timeout=10)
+            if response.status_code == 200:
+                data = response.json()
+                token = data.get("token", "")
+                if token:
+                    logger.debug(f"获取访客令牌成功: {token[:20]}...")
+                    return token
+        except Exception as e:
+            logger.warning(f"获取访客令牌失败: {e}")
+
+    # 使用token池获取备份令牌
+    token_pool = get_token_pool()
+    if token_pool:
+        token = token_pool.get_next_token()
+        if token:
+            logger.debug(f"从token池获取令牌: {token[:20]}...")
+            return token
+
+    # 没有可用的token
+    logger.warning("⚠️ 没有可用的备份token")
+    return ""
+
+
+class ZAITransformer:
+    """ZAI转换器类"""
+
+    def __init__(self):
+        """初始化转换器"""
+        self.name = "zai"
+        self.base_url = "https://chat.z.ai"
+        self.api_url = settings.API_ENDPOINT
+        self.auth_url = f"{self.base_url}/api/v1/auths/"
+
+        # 模型映射
+        self.model_mapping = {
+            settings.PRIMARY_MODEL: "0727-360B-API",  # GLM-4.5
+            settings.THINKING_MODEL: "0727-360B-API",  # GLM-4.5-Thinking
+            settings.SEARCH_MODEL: "0727-360B-API",  # GLM-4.5-Search
+            settings.AIR_MODEL: "0727-106B-API",  # GLM-4.5-Air
+        }
+
+    async def get_token(self) -> str:
+        """异步获取认证令牌"""
+        if settings.ANONYMOUS_MODE:
+            try:
+    
+                headers = get_dynamic_headers()
+                async with httpx.AsyncClient() as client:
+                    response = await client.get(self.auth_url, headers=headers, timeout=10.0)
+                    if response.status_code == 200:
+                        data = response.json()
+                        token = data.get("token", "")
+                        if token:
+                            logger.debug(f"获取访客令牌成功: {token[:20]}...")
+                            return token
+            except Exception as e:
+                logger.warning(f"异步获取访客令牌失败: {e}")
+
+        # 使用token池获取备份令牌
+        token_pool = get_token_pool()
+        if token_pool:
+            token = token_pool.get_next_token()
+            if token:
+                logger.debug(f"从token池获取令牌: {token[:20]}...")
+                return token
+
+        # 没有可用的token
+        logger.warning("⚠️ 没有可用的备份token")
+        return ""
+
+    def mark_token_success(self, token: str):
+        """标记token使用成功"""
+        token_pool = get_token_pool()
+        if token_pool:
+            token_pool.mark_token_success(token)
+
+    def mark_token_failure(self, token: str, error: Exception = None):
+        """标记token使用失败"""
+        token_pool = get_token_pool()
+        if token_pool:
+            token_pool.mark_token_failure(token, error)
+
+    async def transform_request_in(self, request: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        转换OpenAI请求为z.ai格式
+        整合现有功能：模型映射、MCP服务器等
+        """
+        logger.info(f"🔄 开始转换 OpenAI 请求到 Z.AI 格式: {request.get('model', settings.PRIMARY_MODEL)} -> Z.AI")
+
+        # 获取认证令牌
+        token = await self.get_token()
+        logger.debug(f"  使用令牌: {token[:20] if token else 'None'}...")
+
+        # 检查token是否有效
+        if not token:
+            logger.error("❌ 无法获取有效的认证令牌")
+            raise Exception("无法获取有效的认证令牌，请检查匿名模式配置或token池配置")
+
+        # 确定请求的模型特性
+        requested_model = request.get("model", settings.PRIMARY_MODEL)
+        is_thinking = requested_model == settings.THINKING_MODEL or request.get("reasoning", False)
+        is_search = requested_model == settings.SEARCH_MODEL
+        is_air = requested_model == settings.AIR_MODEL
+
+        # 获取上游模型ID（使用模型映射）
+        upstream_model_id = self.model_mapping.get(requested_model, "0727-360B-API")
+        logger.debug(f"  模型映射: {requested_model} -> {upstream_model_id}")
+        logger.debug(f"  模型特性检测: is_search={is_search}, is_thinking={is_thinking}, is_air={is_air}")
+        logger.debug(f"  SEARCH_MODEL配置: {settings.SEARCH_MODEL}")
+
+        # 处理消息列表
+        logger.debug(f"  开始处理 {len(request.get('messages', []))} 条消息")
+        messages = []
+        for idx, orig_msg in enumerate(request.get("messages", [])):
+            msg = orig_msg.copy()
+
+            # 处理system角色转换
+            if msg.get("role") == "system":
+
+                msg["role"] = "user"
+                content = msg.get("content")
+
+                if isinstance(content, list):
+                    msg["content"] = [
+                        {"type": "text", "text": "This is a system command, you must enforce compliance."}
+                    ] + content
+                elif isinstance(content, str):
+                    msg["content"] = f"This is a system command, you must enforce compliance.{content}"
+
+            # 处理user角色的图片内容
+            elif msg.get("role") == "user":
+                content = msg.get("content")
+                if isinstance(content, list):
+                    new_content = []
+                    for part_idx, part in enumerate(content):
+                        # 处理图片URL（支持base64和http URL）
+                        if (
+                            part.get("type") == "image_url"
+                            and part.get("image_url", {}).get("url")
+                            and isinstance(part["image_url"]["url"], str)
+                        ):
+                            logger.debug(f"    消息[{idx}]内容[{part_idx}]: 检测到图片URL")
+                            # 直接传递图片内容
+                            new_content.append(part)
+                        else:
+                            new_content.append(part)
+                    msg["content"] = new_content
+
+            # 处理assistant消息中的reasoning_content
+            elif msg.get("role") == "assistant" and msg.get("reasoning_content"):
+
+                # 如果有reasoning_content，保留它
+                pass
+
+            messages.append(msg)
+
+        # 构建MCP服务器列表
+        mcp_servers = []
+        if is_search:
+            mcp_servers.append("deep-web-search")
+            logger.info(f"🔍 检测到搜索模型，添加 deep-web-search MCP 服务器")
+        else:
+            logger.debug(f"  非搜索模型，不添加 MCP ��务器")
+
+        logger.debug(f"  MCP服务器列表: {mcp_servers}")
+            
+        # 构建上游请求体
+        chat_id = generate_uuid()
+        
+        body = {
+            "stream": True,  # 总是使用流式
+            "model": upstream_model_id,  # 使用映射后的模型ID
+            "messages": messages,
+            "params": {},
+            "features": {
+                "image_generation": False,
+                "web_search": is_search,
+                "auto_web_search": is_search,
+                "preview_mode": False,
+                "flags": [],
+                "features": [],
+                "enable_thinking": is_thinking,
+            },
+            "background_tasks": {
+                "title_generation": False,
+                "tags_generation": False,
+            },
+            "mcp_servers": mcp_servers,  # 保留MCP服务器支持
+            "variables": {
+                "{{USER_NAME}}": "Guest",
+                "{{USER_LOCATION}}": "Unknown",
+                "{{CURRENT_DATETIME}}": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                "{{CURRENT_DATE}}": datetime.now().strftime("%Y-%m-%d"),
+                "{{CURRENT_TIME}}": datetime.now().strftime("%H:%M:%S"),
+                "{{CURRENT_WEEKDAY}}": datetime.now().strftime("%A"),
+                "{{CURRENT_TIMEZONE}}": "UTC",
+                "{{USER_LANGUAGE}}": "zh-CN",
+            },
+            "model_item": {},
+            "chat_id": chat_id,
+            "id": generate_uuid(),
+        }
+
+        # 处理工具支持
+        if settings.TOOL_SUPPORT and not is_thinking and request.get("tools"):
+            body["tools"] = request["tools"]
+            logger.info(f"启用工具支持: {len(request['tools'])} 个工具")
+        else:
+            body["tools"] = None
+
+        # 构建请求配置
+        dynamic_headers = get_dynamic_headers(chat_id)
+
+        config = {
+            "url": self.api_url,  # 使用原始URL
+            "headers": {
+                **dynamic_headers,  # 使用动态生成的headers
+                "Authorization": f"Bearer {token}",
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "Pragma": "no-cache",
+                "Sec-Fetch-Dest": "empty",
+                "Sec-Fetch-Mode": "cors",
+                "Sec-Fetch-Site": "same-origin",
+            },
+        }
+
+        logger.info("✅ 请求转换完成")
+
+        # 记录关键的请求信息用于调试
+        logger.debug(f"  📋 发送到Z.AI的关键信息:")
+        logger.debug(f"    - 上游模型: {body['model']}")
+        logger.debug(f"    - MCP服务器: {body['mcp_servers']}")
+        logger.debug(f"    - web_search: {body['features']['web_search']}")
+        logger.debug(f"    - auto_web_search: {body['features']['auto_web_search']}")
+        logger.debug(f"    - 消息数量: {len(body['messages'])}")
+
+        return {"body": body, "config": config, "token": token}
+
+    async def transform_response_out(
+        self, response_stream: Generator, context: Dict[str, Any]
+    ) -> Generator[str, None, None]:
+        """
+        转换z.ai响应为OpenAI格式
+        支持流式和非流式输出
+        """
+        is_stream = context.get("req", {}).get("body", {}).get("stream", True)
+
+        # 初始化结果对象（用于非流式）
+        result = {
+            "id": "",
+            "choices": [
+                {
+                    "finish_reason": None,
+                    "index": 0,
+                    "message": {
+                        "content": "",
+                        "role": "assistant",
+                    },
+                }
+            ],
+            "created": int(time.time()),
+            "model": context.get("req", {}).get("body", {}).get("model", ""),
+            "object": "chat.completion",
+            "usage": {
+                "completion_tokens": 0,
+                "prompt_tokens": 0,
+                "total_tokens": 0,
+            },
+        }
+
+        # 状态变量
+        current_id = ""
+        current_model = context.get("req", {}).get("body", {}).get("model", "")
+        has_tool_call = False
+        tool_args = ""
+        tool_id = ""
+        tool_call_usage = None
+        content_index = 0
+        has_thinking = False
+
+        async for line in response_stream:
+            if not line.strip():
+                continue
+
+            if line.startswith("data:"):
+                chunk_str = line[5:].strip()
+                if not chunk_str:
+                    continue
+
+                try:
+                    chunk = json.loads(chunk_str)
+
+                    if chunk.get("type") == "chat:completion":
+                        data = chunk.get("data", {})
+
+                        # 保存ID和模型信息
+                        if data.get("id"):
+                            current_id = data["id"]
+                        if data.get("model"):
+                            current_model = data["model"]
+
+                        # 处理不同阶段
+                        phase = data.get("phase")
+
+                        if phase == "tool_call":
+                            # 处理工具调用
+                            if not has_tool_call:
+                                has_tool_call = True
+
+                                if is_stream:
+                                    # 发送初始角色
+                                    role_chunk = {
+                                        "choices": [
+                                            {
+                                                "delta": {"role": "assistant"},
+                                                "finish_reason": None,
+                                                "index": 0,
+                                            }
+                                        ],
+                                        "created": int(time.time()),
+                                        "id": current_id,
+                                        "model": current_model,
+                                        "object": "chat.completion.chunk",
+                                    }
+                                    yield f"data: {json.dumps(role_chunk)}\n\n"
+
+                            # 处理工具调用块
+                            tool_call_id = data.get("tool_call", {}).get("id", "")
+                            tool_name = data.get("tool_call", {}).get("name", "")
+                            delta_args = data.get("delta_tool_call", {}).get("arguments", "")
+
+                            if tool_call_id and tool_call_id != tool_id:
+                                # 新工具调用
+                                if tool_id and is_stream:
+                                    # 关闭前一个工具调用
+                                    close_chunk = {
+                                        "choices": [
+                                            {
+                                                "delta": {
+                                                    "tool_calls": [
+                                                        {"index": content_index, "function": {"arguments": ""}}
+                                                    ]
+                                                },
+                                                "finish_reason": None,
+                                                "index": 0,
+                                            }
+                                        ],
+                                        "created": int(time.time()),
+                                        "id": current_id,
+                                        "model": current_model,
+                                        "object": "chat.completion.chunk",
+                                    }
+                                    yield f"data: {json.dumps(close_chunk)}\n\n"
+                                    content_index += 1
+
+                                tool_id = tool_call_id
+                                tool_args = ""
+
+                                if is_stream:
+                                    # 发送新工具调用
+                                    new_tool_chunk = {
+                                        "choices": [
+                                            {
+                                                "delta": {
+                                                    "tool_calls": [
+                                                        {
+                                                            "index": content_index,
+                                                            "id": tool_call_id,
+                                                            "type": "function",
+                                                            "function": {"name": tool_name, "arguments": ""},
+                                                        }
+                                                    ]
+                                                },
+                                                "finish_reason": None,
+                                                "index": 0,
+                                            }
+                                        ],
+                                        "created": int(time.time()),
+                                        "id": current_id,
+                                        "model": current_model,
+                                        "object": "chat.completion.chunk",
+                                    }
+                                    yield f"data: {json.dumps(new_tool_chunk)}\n\n"
+
+                            # 处理参数增量
+                            if delta_args:
+                                tool_args += delta_args
+                                if is_stream:
+                                    args_chunk = {
+                                        "choices": [
+                                            {
+                                                "delta": {
+                                                    "tool_calls": [
+                                                        {
+                                                            "index": content_index,
+                                                            "function": {"arguments": delta_args},
+                                                        }
+                                                    ]
+                                                },
+                                                "finish_reason": None,
+                                                "index": 0,
+                                            }
+                                        ],
+                                        "created": int(time.time()),
+                                        "id": current_id,
+                                        "model": current_model,
+                                        "object": "chat.completion.chunk",
+                                    }
+                                    yield f"data: {json.dumps(args_chunk)}\n\n"
+
+                        elif phase == "thinking":
+                            # 处理思考内容
+                            if not has_thinking:
+                                has_thinking = True
+                                # 初始化thinking字段
+                                if not is_stream:
+                                    result["choices"][0]["message"]["thinking"] = {"content": ""}
+
+                                if is_stream:
+                                    # 发送初始角色
+                                    role_chunk = {
+                                        "choices": [
+                                            {
+                                                "delta": {"role": "assistant"},
+                                                "finish_reason": None,
+                                                "index": 0,
+                                            }
+                                        ],
+                                        "created": int(time.time()),
+                                        "id": current_id,
+                                        "model": current_model,
+                                        "object": "chat.completion.chunk",
+                                    }
+                                    yield f"data: {json.dumps(role_chunk)}\n\n"
+
+                            delta_content = data.get("delta_content", "")
+                            if delta_content:
+                                # 处理思考内容格式
+                                if delta_content.startswith("<details"):
+                                    content = (
+                                        delta_content.split("</summary>\n>")[-1].strip()
+                                        if "</summary>\n>" in delta_content
+                                        else delta_content
+                                    )
+                                else:
+                                    content = delta_content
+
+                                if is_stream:
+                                    thinking_chunk = {
+                                        "choices": [
+                                            {
+                                                "delta": {"thinking": {"content": content}},
+                                                "finish_reason": None,
+                                                "index": 0,
+                                            }
+                                        ],
+                                        "created": int(time.time()),
+                                        "id": current_id,
+                                        "model": current_model,
+                                        "object": "chat.completion.chunk",
+                                    }
+                                    yield f"data: {json.dumps(thinking_chunk)}\n\n"
+                                else:
+                                    result["choices"][0]["message"]["thinking"]["content"] += content
+
+                        elif phase == "answer":
+                            # 处理答案内容
+                            edit_content = data.get("edit_content", "")
+                            delta_content = data.get("delta_content", "")
+
+                            # 处理思考结束和答案开始
+                            if edit_content and "</details>\n" in edit_content:
+                                if has_thinking:
+                                    signature = str(int(time.time() * 1000))
+
+                                    if is_stream:
+                                        # 发送思考签名
+                                        sig_chunk = {
+                                            "choices": [
+                                                {
+                                                    "delta": {
+                                                        "role": "assistant",
+                                                        "thinking": {"content": "", "signature": signature},
+                                                    },
+                                                    "finish_reason": None,
+                                                    "index": 0,
+                                                }
+                                            ],
+                                            "created": int(time.time()),
+                                            "id": current_id,
+                                            "model": current_model,
+                                            "object": "chat.completion.chunk",
+                                        }
+                                        yield f"data: {json.dumps(sig_chunk)}\n\n"
+                                        content_index += 1
+                                    else:
+                                        result["choices"][0]["message"]["thinking"]["signature"] = signature
+
+                                # 提取答案内容
+                                content_after = edit_content.split("</details>\n")[-1]
+                                if content_after:
+                                    if is_stream:
+                                        content_chunk = {
+                                            "choices": [
+                                                {
+                                                    "delta": {"role": "assistant", "content": content_after},
+                                                    "finish_reason": None,
+                                                    "index": 0,
+                                                }
+                                            ],
+                                            "created": int(time.time()),
+                                            "id": current_id,
+                                            "model": current_model,
+                                            "object": "chat.completion.chunk",
+                                        }
+                                        yield f"data: {json.dumps(content_chunk)}\n\n"
+                                    else:
+                                        result["choices"][0]["message"]["content"] += content_after
+
+                            # 处理增量内容
+                            elif delta_content:
+                                if is_stream:
+                                    # 如果还没有发送角色
+                                    if not has_thinking and not has_tool_call:
+                                        role_chunk = {
+                                            "choices": [
+                                                {
+                                                    "delta": {"role": "assistant"},
+                                                    "finish_reason": None,
+                                                    "index": 0,
+                                                }
+                                            ],
+                                            "created": int(time.time()),
+                                            "id": current_id,
+                                            "model": current_model,
+                                            "object": "chat.completion.chunk",
+                                        }
+                                        yield f"data: {json.dumps(role_chunk)}\n\n"
+
+                                    content_chunk = {
+                                        "choices": [
+                                            {
+                                                "delta": {"role": "assistant", "content": delta_content},
+                                                "finish_reason": None,
+                                                "index": 0,
+                                            }
+                                        ],
+                                        "created": int(time.time()),
+                                        "id": current_id,
+                                        "model": current_model,
+                                        "object": "chat.completion.chunk",
+                                    }
+                                    yield f"data: {json.dumps(content_chunk)}\n\n"
+                                else:
+                                    result["choices"][0]["message"]["content"] += delta_content
+
+                            # 处理完成
+                            if data.get("usage"):
+                                usage = data["usage"]
+                                if is_stream:
+                                    finish_chunk = {
+                                        "choices": [
+                                            {
+                                                "delta": {"role": "assistant", "content": ""},
+                                                "finish_reason": "stop",
+                                                "index": 0,
+                                            }
+                                        ],
+                                        "usage": usage,
+                                        "created": int(time.time()),
+                                        "id": current_id,
+                                        "model": current_model,
+                                        "object": "chat.completion.chunk",
+                                    }
+                                    yield f"data: {json.dumps(finish_chunk)}\n\n"
+                                    yield "data: [DONE]\n\n"
+                                else:
+                                    result["id"] = current_id
+                                    result["model"] = current_model
+                                    result["usage"] = usage
+                                    result["choices"][0]["finish_reason"] = "stop"
+
+                        elif phase == "other":
+                            # 处理其他阶段（可能包含usage信息）
+                            if data.get("usage"):
+                                tool_call_usage = data["usage"]
+                                if has_tool_call and is_stream:
+                                    # 关闭最后一个工具调用并发送完成
+                                    if tool_id:
+                                        close_chunk = {
+                                            "choices": [
+                                                {
+                                                    "delta": {
+                                                        "tool_calls": [
+                                                            {"index": content_index, "function": {"arguments": ""}}
+                                                        ]
+                                                    },
+                                                    "finish_reason": "tool_calls",
+                                                    "index": 0,
+                                                }
+                                            ],
+                                            "usage": tool_call_usage,
+                                            "created": int(time.time()),
+                                            "id": current_id,
+                                            "model": current_model,
+                                            "object": "chat.completion.chunk",
+                                        }
+                                        yield f"data: {json.dumps(close_chunk)}\n\n"
+                                        yield "data: [DONE]\n\n"
+
+                except json.JSONDecodeError as e:
+                    logger.debug(f"JSON解析错误: {e}")
+                except Exception as e:
+                    logger.error(f"处理chunk错误: {e}")
+
+        # 非流式模式返回完整结果
+        if not is_stream:
+            yield json.dumps(result)

app/models/__init__.py

@@ -1,7 +1,6 @@
-"""
-Models module initialization
-"""
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
 
 from app.models import schemas
 
-__all__ = ["schemas"]
+__all__ = ["schemas"]

app/models/schemas.py

@@ -1,6 +1,5 @@
-"""
-Application data models
-"""
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
 
 from typing import Dict, List, Optional, Any, Union, Literal
 from pydantic import BaseModel
@@ -54,8 +53,8 @@ class UpstreamRequest(BaseModel):
     chat_id: Optional[str] = None
     id: Optional[str] = None
     mcp_servers: Optional[List[str]] = None
-    model_item: Optional[ModelItem] = None
-    tool_servers: Optional[List[str]] = None
+    model_item: Optional[Dict[str, Any]] = {}  # Model item dictionary
+    tools: Optional[List[Dict[str, Any]]] = None  # Add tools field for OpenAI compatibility
     variables: Optional[Dict[str, str]] = None
     model_config = {"protected_namespaces": ()}
 

app/utils/__init__.py

@@ -1,7 +1,6 @@
-"""
-Utils module initialization
-"""
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
 
-from app.utils import helpers, sse_parser, tools, reload_config
+from app.utils import sse_tool_handler, reload_config, logger
 
-__all__ = ["helpers", "sse_parser", "tools", "reload_config"]
+__all__ = ["sse_tool_handler", "reload_config", "logger"]

app/utils/helpers.py

@@ -1,211 +0,0 @@
-"""
-Utility functions for the application
-"""
-
-import json
-import re
-import time
-import random
-from typing import Dict, List, Optional, Any, Tuple, Generator
-import requests
-from fake_useragent import UserAgent
-
-from app.core.config import settings
-
-# 全局 UserAgent 实例，避免每次调用都创建新实例
-_user_agent_instance = None
-
-def get_user_agent_instance() -> UserAgent:
-    """获取或创建 UserAgent 实例（单例模式）"""
-    global _user_agent_instance
-    if _user_agent_instance is None:
-        _user_agent_instance = UserAgent()
-    return _user_agent_instance
-
-
-def debug_log(message: str, *args) -> None:
-    """Log debug message if debug mode is enabled"""
-    if settings.DEBUG_LOGGING:
-        if args:
-            print(f"[DEBUG] {message % args}")
-        else:
-            print(f"[DEBUG] {message}")
-
-
-def generate_request_ids() -> Tuple[str, str]:
-    """Generate unique IDs for chat and message"""
-    timestamp = int(time.time())
-    chat_id = f"{timestamp * 1000}-{timestamp}"
-    msg_id = str(timestamp * 1000000)
-    return chat_id, msg_id
-
-
-def get_browser_headers(referer_chat_id: str = "") -> Dict[str, str]:
-    """Get browser headers for API requests with dynamic User-Agent"""
-    
-    # 获取 UserAgent 实例
-    ua = get_user_agent_instance()
-    
-    # 随机选择一个浏览器类型，偏向使用 Chrome 和 Edge
-    browser_choices = ['chrome', 'chrome', 'chrome', 'edge', 'edge', 'firefox', 'safari']
-    browser_type = random.choice(browser_choices)
-    
-    try:
-        # 根据浏览器类型获取 User-Agent
-        if browser_type == 'chrome':
-            user_agent = ua.chrome
-        elif browser_type == 'edge':
-            user_agent = ua.edge
-        elif browser_type == 'firefox':
-            user_agent = ua.firefox
-        elif browser_type == 'safari':
-            user_agent = ua.safari
-        else:
-            user_agent = ua.random
-    except:
-        # 如果获取失败，使用随机 User-Agent
-        user_agent = ua.random
-    
-    # 提取浏览器版本信息
-    chrome_version = "139"  # 默认版本
-    edge_version = "139"
-    
-    if "Chrome/" in user_agent:
-        try:
-            chrome_version = user_agent.split("Chrome/")[1].split(".")[0]
-        except:
-            pass
-    
-    if "Edg/" in user_agent:
-        try:
-            edge_version = user_agent.split("Edg/")[1].split(".")[0]
-            # Edge 基于 Chromium，使用 Edge 特定的 sec-ch-ua
-            sec_ch_ua = f'"Microsoft Edge";v="{edge_version}", "Chromium";v="{chrome_version}", "Not_A Brand";v="24"'
-        except:
-            sec_ch_ua = f'"Not_A Brand";v="8", "Chromium";v="{chrome_version}", "Google Chrome";v="{chrome_version}"'
-    elif "Firefox/" in user_agent:
-        # Firefox 不使用 sec-ch-ua
-        sec_ch_ua = None
-    else:
-        # Chrome 或其他基于 Chromium 的浏览器
-        sec_ch_ua = f'"Not_A Brand";v="8", "Chromium";v="{chrome_version}", "Google Chrome";v="{chrome_version}"'
-    
-    # 构建动态 Headers
-    headers = {
-        "Content-Type": "application/json",
-        "Accept": "application/json, text/event-stream",
-        "User-Agent": user_agent,
-        "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8,en-US;q=0.7",
-        "sec-ch-ua-mobile": "?0",
-        "sec-ch-ua-platform": '"Windows"',
-        "sec-fetch-dest": "empty",
-        "sec-fetch-mode": "cors",
-        "sec-fetch-site": "same-origin",
-        "X-FE-Version": "prod-fe-1.0.70",
-        "Origin": settings.CLIENT_HEADERS["Origin"],
-        "Cache-Control": "no-cache",
-        "Pragma": "no-cache",
-    }
-    
-    # 只有基于 Chromium 的浏览器才添加 sec-ch-ua
-    if sec_ch_ua:
-        headers["sec-ch-ua"] = sec_ch_ua
-    
-    # 添加 Referer
-    if referer_chat_id:
-        headers["Referer"] = f"{settings.CLIENT_HEADERS['Origin']}/c/{referer_chat_id}"
-    
-    # 调试日志
-    if settings.DEBUG_LOGGING:
-        debug_log(f"使用 User-Agent: {user_agent[:100]}...")
-    
-    return headers
-
-
-def get_anonymous_token() -> str:
-    """Get anonymous token for authentication"""
-    headers = get_browser_headers()
-    headers.update({
-        "Accept": "*/*",
-        "Accept-Language": "zh-CN,zh;q=0.9",
-        "Referer": f"{settings.CLIENT_HEADERS['Origin']}/",
-    })
-    
-    try:
-        response = requests.get(
-            f"{settings.CLIENT_HEADERS['Origin']}/api/v1/auths/",
-            headers=headers,
-            timeout=10.0
-        )
-        
-        if response.status_code != 200:
-            raise Exception(f"anon token status={response.status_code}")
-        
-        data = response.json()
-        token = data.get("token")
-        if not token:
-            raise Exception("anon token empty")
-        
-        return token
-    except Exception as e:
-        debug_log(f"获取匿名token失败: {e}")
-        raise
-
-
-def get_auth_token() -> str:
-    """Get authentication token (anonymous or fixed)"""
-    if settings.ANONYMOUS_MODE:
-        try:
-            token = get_anonymous_token()
-            debug_log(f"匿名token获取成功: {token[:10]}...")
-            return token
-        except Exception as e:
-            debug_log(f"匿名token获取失败，回退固定token: {e}")
-    
-    return settings.BACKUP_TOKEN
-
-
-def transform_thinking_content(content: str) -> str:
-    """Transform thinking content according to configuration"""
-    # Remove summary tags
-    content = re.sub(r'(?s)<summary>.*?</summary>', '', content)
-    # Clean up remaining tags
-    content = content.replace("</thinking>", "").replace("<Full>", "").replace("</Full>", "")
-    content = content.strip()
-    
-    if settings.THINKING_PROCESSING == "think":
-        content = re.sub(r'<details[^>]*>', '<span>', content)
-        content = content.replace("</details>", "</span>")
-    elif settings.THINKING_PROCESSING == "strip":
-        content = re.sub(r'<details[^>]*>', '', content)
-        content = content.replace("</details>", "")
-    
-    # Remove line prefixes
-    content = content.lstrip("> ")
-    content = content.replace("\n> ", "\n")
-    
-    return content.strip()
-
-
-def call_upstream_api(
-    upstream_req: Any,
-    chat_id: str,
-    auth_token: str
-) -> requests.Response:
-    """Call upstream API with proper headers"""
-    headers = get_browser_headers(chat_id)
-    headers["Authorization"] = f"Bearer {auth_token}"
-    
-    debug_log(f"调用上游API: {settings.API_ENDPOINT}")
-    debug_log(f"上游请求体: {upstream_req.model_dump_json()}")
-    
-    response = requests.post(
-        settings.API_ENDPOINT,
-        json=upstream_req.model_dump(exclude_none=True),
-        headers=headers,
-        timeout=60.0,
-        stream=True
-    )
-    
-    debug_log(f"上游响应状态: {response.status_code}")
-    return response

app/utils/logger.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import sys
+from pathlib import Path
+from loguru import logger
+
+# Global logger instance
+app_logger = None
+
+
+def setup_logger(log_dir, log_retention_days=7, log_rotation="1 day", debug_mode=False):
+    """
+    Create a logger instance
+
+    Parameters:
+        log_dir (str): 日志目录
+        log_retention_days (int): 日志保留天数
+        log_rotation (str): 日志轮转间隔
+        debug_mode (bool): 是否开启调试模式
+    """
+    global app_logger
+
+    try:
+        logger.remove()
+
+        log_level = "DEBUG" if debug_mode else "INFO"
+
+        console_format = (
+            "<green>{time:HH:mm:ss}</green> | <level>{level: <8}</level> | <level>{message}</level>"
+            if not debug_mode
+            else "<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | "
+            "<cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> | <level>{message}</level>"
+        )
+
+        logger.add(sys.stderr, level=log_level, format=console_format, colorize=True)
+
+        if debug_mode:
+            log_path = Path(log_dir)
+            log_path.mkdir(parents=True, exist_ok=True)
+
+            log_file = log_path / "{time:YYYY-MM-DD}.log"
+            file_format = "{time:YYYY-MM-DD HH:mm:ss.SSS} | {level: <8} | {name}:{function}:{line} | {message}"
+
+            logger.add(
+                str(log_file),
+                level=log_level,
+                format=file_format,
+                rotation=log_rotation,
+                retention=f"{log_retention_days} days",
+                encoding="utf-8",
+                compression="zip",
+                enqueue=True,
+                catch=True,
+            )
+
+        app_logger = logger
+
+        return logger
+
+    except Exception as e:
+        logger.remove()
+        logger.add(sys.stderr, level="ERROR")
+        logger.error(f"日志系统配置失败: {e}")
+        raise
+
+
+def get_logger():
+    """Get the logger instance"""
+    global app_logger
+    if app_logger is None:
+
+        app_logger = logger
+        logger.add(sys.stderr, level="INFO")
+    return app_logger
+
+
+if __name__ == "__main__":
+    """Test the logger"""
+    import tempfile
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        try:
+            setup_logger(temp_dir, debug_mode=True)
+
+            logger.debug("这是一条调试日志")
+            logger.info("这是一条信息日志")
+            logger.warning("这是一条警告日志")
+            logger.error("这是一条错误日志")
+            logger.critical("这是一条严重日志")
+
+            try:
+                1 / 0
+            except ZeroDivisionError:
+                logger.exception("发生了除零异常")
+
+            print("✅ 日志测试完成")
+
+            logger.remove()
+
+        except Exception as e:
+            print(f"❌ 日志测试失败: {e}")
+            logger.remove()
+            raise

app/utils/reload_config.py

@@ -1,3 +1,6 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
 """
 热重载配置模块
 定义 Granian 服务器热重载时需要忽略的目录和文件模式

app/utils/sse_parser.py

@@ -1,127 +0,0 @@
-"""
-SSE (Server-Sent Events) parser for streaming responses
-"""
-
-import json
-from typing import Dict, Any, Generator, Optional, Type
-import requests
-
-
-class SSEParser:
-    """Server-Sent Events parser for streaming responses"""
-
-    def __init__(self, response: requests.Response, debug_mode: bool = False):
-        """Initialize SSE parser
-
-        Args:
-            response: requests.Response object with stream=True
-            debug_mode: Enable debug logging
-        """
-        self.response = response
-        self.debug_mode = debug_mode
-        self.buffer = ""
-        self.line_count = 0
-
-    def debug_log(self, format_str: str, *args) -> None:
-        """Log debug message if debug mode is enabled"""
-        if self.debug_mode:
-            if args:
-                print(f"[SSE_PARSER] {format_str % args}")
-            else:
-                print(f"[SSE_PARSER] {format_str}")
-
-    def iter_events(self) -> Generator[Dict[str, Any], None, None]:
-        """Iterate over SSE events
-
-        Yields:
-            dict: Parsed SSE event data
-        """
-        self.debug_log("开始解析 SSE 流")
-
-        for line in self.response.iter_lines():
-            self.line_count += 1
-
-            # Skip empty lines
-            if not line:
-                continue
-
-            # Decode bytes
-            if isinstance(line, bytes):
-                try:
-                    line = line.decode("utf-8")
-                except UnicodeDecodeError:
-                    self.debug_log(f"第{self.line_count}行解码失败，跳过")
-                    continue
-
-            # Skip comment lines
-            if line.startswith(":"):
-                continue
-
-            # Parse field-value pairs
-            if ":" in line:
-                field, value = line.split(":", 1)
-                field = field.strip()
-                value = value.lstrip()
-
-                if field == "data":
-                    self.debug_log(f"收到数据 (第{self.line_count}行): {value}")
-
-                    # Try to parse JSON
-                    try:
-                        data = json.loads(value)
-                        yield {"type": "data", "data": data, "raw": value}
-                    except json.JSONDecodeError:
-                        yield {"type": "data", "data": value, "raw": value, "is_json": False}
-
-                elif field == "event":
-                    yield {"type": "event", "event": value}
-
-                elif field == "id":
-                    yield {"type": "id", "id": value}
-
-                elif field == "retry":
-                    try:
-                        retry = int(value)
-                        yield {"type": "retry", "retry": retry}
-                    except ValueError:
-                        self.debug_log(f"无效的 retry 值: {value}")
-
-    def iter_data_only(self) -> Generator[Dict[str, Any], None, None]:
-        """Iterate only over data events"""
-        for event in self.iter_events():
-            if event["type"] == "data":
-                yield event
-
-    def iter_json_data(self, model_class: Optional[Type] = None) -> Generator[Dict[str, Any], None, None]:
-        """Iterate only over JSON data events with optional validation
-
-        Args:
-            model_class: Optional Pydantic model class for validation
-
-        Yields:
-            dict: JSON data events
-        """
-        for event in self.iter_events():
-            if event["type"] == "data" and event.get("is_json", True):
-                try:
-                    if model_class:
-                        data = model_class.model_validate_json(event["raw"])
-                        yield {"type": "data", "data": data, "raw": event["raw"]}
-                    else:
-                        yield event
-                except Exception as e:
-                    self.debug_log(f"数据验证失败: {e}")
-                    continue
-
-    def close(self) -> None:
-        """Close the response connection"""
-        if hasattr(self.response, "close"):
-            self.response.close()
-
-    def __enter__(self):
-        """Context manager entry"""
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
-        """Context manager exit"""
-        self.close()

app/utils/sse_tool_handler.py

@@ -0,0 +1,694 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+SSE Tool Handler - 处理工具调用的SSE流
+基于 Z.AI 原生的 edit_index 和 edit_content 机制，更原生地处理工具调用
+"""
+
+import json
+import re
+import time
+from typing import Dict, Any, Optional, Generator, List
+
+from app.utils.logger import get_logger
+
+logger = get_logger()
+
+
+class SSEToolHandler:
+
+    def __init__(self, chat_id: str, model: str):
+        self.chat_id = chat_id
+        self.model = model
+
+        # 工具调用状态
+        self.has_tool_call = False
+        self.tool_call_usage = None  # 工具调用的usage信息
+        self.content_index = 0
+        self.has_thinking = False
+
+        self.content_buffer = bytearray()  # 使用字节数组提高性能
+        self.last_edit_index = 0  # 上次编辑的位置
+
+        # 工具调用解析状态
+        self.active_tools = {}  # 活跃的工具调用 {tool_id: tool_info}
+        self.completed_tools = []  # 已完成的工具调用
+        self.tool_blocks_cache = {}  # 缓存解析的工具块
+
+    def process_tool_call_phase(self, data: Dict[str, Any], is_stream: bool = True) -> Generator[str, None, None]:
+        """
+        处理tool_call阶段
+        """
+        if not self.has_tool_call:
+            self.has_tool_call = True
+            logger.debug("🔧 进入工具调用阶段")
+
+        edit_content = data.get("edit_content", "")
+        edit_index = data.get("edit_index", 0)
+
+        if not edit_content:
+            return
+
+        # logger.debug(f"📦 接收内容片段 [index={edit_index}]: {edit_content[:1000]}...")
+
+        # 更新内容缓冲区
+        self._apply_edit_to_buffer(edit_index, edit_content)
+
+        # 尝试解析和处理工具调用
+        yield from self._process_tool_calls_from_buffer(is_stream)
+
+    def _apply_edit_to_buffer(self, edit_index: int, edit_content: str):
+        """
+        在指定位置替换/插入内容更新内容缓冲区
+        """
+        edit_bytes = edit_content.encode('utf-8')
+        required_length = edit_index + len(edit_bytes)
+
+        # 扩展缓冲区到所需长度（如果需要）
+        if len(self.content_buffer) < edit_index:
+            # 如果edit_index超出当前缓冲区，用空字节填充
+            self.content_buffer.extend(b'\x00' * (edit_index - len(self.content_buffer)))
+
+        # 确保缓冲区足够长以容纳新内容
+        if len(self.content_buffer) < required_length:
+            self.content_buffer.extend(b'\x00' * (required_length - len(self.content_buffer)))
+
+        # 在指定位置替换内容（不是插入，而是覆盖）
+        end_index = edit_index + len(edit_bytes)
+        self.content_buffer[edit_index:end_index] = edit_bytes
+
+        # logger.debug(f"📝 缓冲区更新 [index={edit_index}, 长度={len(self.content_buffer)}]")
+
+    def _process_tool_calls_from_buffer(self, is_stream: bool) -> Generator[str, None, None]:
+        """
+        从内容缓冲区中解析和处理工具调用
+        """
+        try:
+            # 解码内容并清理空字节
+            content_str = self.content_buffer.decode('utf-8', errors='ignore').replace('\x00', '')
+            yield from self._extract_and_process_tools(content_str, is_stream)
+        except Exception as e:
+            logger.debug(f"📦 内容解析暂时失败，等待更多数据: {e}")
+            # 不抛出异常，继续等待更多数据
+
+    def _extract_and_process_tools(self, content_str: str, is_stream: bool) -> Generator[str, None, None]:
+        """
+        从内容字符串中提取和处理工具调用
+        """
+        # 查找所有 glm_block，包括不完整的
+        pattern = r'<glm_block\s*>(.*?)(?:</glm_block>|$)'
+        matches = re.findall(pattern, content_str, re.DOTALL)
+
+        for block_content in matches:
+            # 尝试解析每个块
+            yield from self._process_single_tool_block(block_content, is_stream)
+
+    def _process_single_tool_block(self, block_content: str, is_stream: bool) -> Generator[str, None, None]:
+        """
+        处理单个工具块，支持增量解析
+        """
+        try:
+            # 尝试修复和解析完整的JSON
+            fixed_content = self._fix_json_structure(block_content)
+            tool_data = json.loads(fixed_content)
+            metadata = tool_data.get("data", {}).get("metadata", {})
+
+            tool_id = metadata.get("id", "")
+            tool_name = metadata.get("name", "")
+            arguments_raw = metadata.get("arguments", "{}")
+
+            if not tool_id or not tool_name:
+                return
+
+            logger.debug(f"🎯 解析完整工具块: {tool_name}(id={tool_id}), 参数: {arguments_raw}")
+
+            # 检查是否是新工具或更新的工具
+            yield from self._handle_tool_update(tool_id, tool_name, arguments_raw, is_stream)
+
+        except json.JSONDecodeError as e:
+            logger.debug(f"📦 JSON解析失败: {e}, 尝试部分解析")
+            # JSON 不完整，尝试部分解析
+            yield from self._handle_partial_tool_block(block_content, is_stream)
+        except Exception as e:
+            logger.debug(f"📦 工具块处理失败: {e}")
+
+    def _fix_json_structure(self, content: str) -> str:
+        """
+        修复JSON结构中的常见问题
+        """
+        if not content:
+            return content
+
+        # 计算括号平衡
+        open_braces = content.count('{')
+        close_braces = content.count('}')
+
+        # 如果闭括号多于开括号，移除多余的闭括号
+        if close_braces > open_braces:
+            excess = close_braces - open_braces
+            fixed_content = content
+            for _ in range(excess):
+                # 从右侧移除多余的闭括号
+                last_brace_pos = fixed_content.rfind('}')
+                if last_brace_pos != -1:
+                    fixed_content = fixed_content[:last_brace_pos] + fixed_content[last_brace_pos + 1:]
+            return fixed_content
+
+        return content
+
+    def _handle_tool_update(self, tool_id: str, tool_name: str, arguments_raw: str, is_stream: bool) -> Generator[str, None, None]:
+        """
+        处理工具的创建或更新 - 更可靠的参数完整性检查
+        """
+        # 解析参数
+        try:
+            if isinstance(arguments_raw, str):
+                # 先处理转义和清理
+                cleaned_args = self._clean_arguments_string(arguments_raw)
+                arguments = json.loads(cleaned_args) if cleaned_args.strip() else {}
+            else:
+                arguments = arguments_raw
+        except json.JSONDecodeError:
+            logger.debug(f"📦 参数解析失败，暂不处理: {arguments_raw}")
+            # 参数解析失败时，不创建或更新工具，等待更完整的数据
+            return
+
+        # 检查参数是否看起来完整（基本的完整性验证）
+        is_args_complete = self._is_arguments_complete(arguments, arguments_raw)
+
+        # 检查是否是新工具
+        if tool_id not in self.active_tools:
+            logger.debug(f"🎯 发现新工具: {tool_name}(id={tool_id}), 参数完整性: {is_args_complete}")
+
+            self.active_tools[tool_id] = {
+                "id": tool_id,
+                "name": tool_name,
+                "arguments": arguments,
+                "arguments_raw": arguments_raw,
+                "status": "active",
+                "sent_start": False,
+                "last_sent_args": {},  # 跟踪上次发送的参数
+                "args_complete": is_args_complete,
+                "pending_send": True  # 标记需要发送
+            }
+
+            # 只有在参数看起来完整时才发送工具开始信号
+            if is_stream and is_args_complete:
+                yield self._create_tool_start_chunk(tool_id, tool_name, arguments)
+                self.active_tools[tool_id]["sent_start"] = True
+                self.active_tools[tool_id]["last_sent_args"] = arguments.copy()
+                self.active_tools[tool_id]["pending_send"] = False
+                logger.debug(f"📤 发送完整工具开始: {tool_name}(id={tool_id})")
+
+        else:
+            # 更新现有工具
+            current_tool = self.active_tools[tool_id]
+
+            # 检查是否有实质性改进
+            if self._is_significant_improvement(current_tool["arguments"], arguments,
+                                               current_tool["arguments_raw"], arguments_raw):
+                logger.debug(f"🔄 工具参数有实质性改进: {tool_name}(id={tool_id})")
+
+                current_tool["arguments"] = arguments
+                current_tool["arguments_raw"] = arguments_raw
+                current_tool["args_complete"] = is_args_complete
+
+                # 如果之前没有发送过开始信号，且现在参数完整，发送开始信号
+                if is_stream and not current_tool["sent_start"] and is_args_complete:
+                    yield self._create_tool_start_chunk(tool_id, tool_name, arguments)
+                    current_tool["sent_start"] = True
+                    current_tool["last_sent_args"] = arguments.copy()
+                    current_tool["pending_send"] = False
+                    logger.debug(f"📤 发送延迟的工具开始: {tool_name}(id={tool_id})")
+
+                # 如果已经发送过开始信号，且参数有显著改进，发送参数更新
+                elif is_stream and current_tool["sent_start"] and is_args_complete:
+                    if self._should_send_argument_update(current_tool["last_sent_args"], arguments):
+                        yield self._create_tool_arguments_chunk(tool_id, arguments)
+                        current_tool["last_sent_args"] = arguments.copy()
+                        logger.debug(f"📤 发送参数更新: {tool_name}(id={tool_id})")
+
+    def _is_arguments_complete(self, arguments: Dict[str, Any], arguments_raw: str) -> bool:
+        """
+        检查参数��否看起来完整
+        """
+        if not arguments:
+            return False
+
+        # 检查原始字符串是否看起来完整
+        if not arguments_raw or not arguments_raw.strip():
+            return False
+
+        # 检查是否有明显的截断迹象
+        raw_stripped = arguments_raw.strip()
+
+        # 如果原始字符串不以}结尾，可能是截断的
+        if not raw_stripped.endswith('}') and not raw_stripped.endswith('"'):
+            return False
+
+        # 检查是否有不完整的URL（常见的截断情况）
+        for key, value in arguments.items():
+            if isinstance(value, str):
+                # 检查URL是否看起来完整
+                if 'http' in value.lower():
+                    # 如果URL太短或以不完整的域名结尾，可能是截断的
+                    if len(value) < 10 or value.endswith('.go') or value.endswith('.goo'):
+                        return False
+
+                # 检查其他可能的截断迹象
+                if len(value) > 0 and value[-1] in ['.', '/', ':', '=']:
+                    # 以这些字符结尾可能表示截断
+                    return False
+
+        return True
+
+    def _is_significant_improvement(self, old_args: Dict[str, Any], new_args: Dict[str, Any],
+                                   old_raw: str, new_raw: str) -> bool:
+        """
+        检查新参数是否比旧参数有显著改进
+        """
+        # 如果新参数为空，不是改进
+        if not new_args:
+            return False
+        
+        if len(new_args) > len(old_args):
+            return True
+
+        # 检查值的改进
+        for key, new_value in new_args.items():
+            old_value = old_args.get(key, "")
+
+            if isinstance(new_value, str) and isinstance(old_value, str):
+                # 如果新值明显更长且更完整，是改进
+                if len(new_value) > len(old_value) + 5:  # 至少长5个字符才算显著改进
+                    return True
+
+                # 如果旧值看起来是截断的，新值更完整，是改进
+                if old_value.endswith(('.go', '.goo', '.com/', 'http')) and len(new_value) > len(old_value):
+                    return True
+
+        # 检查原始字符串的改进
+        if len(new_raw) > len(old_raw) + 10:  # 原始字符串显著增长
+            return True
+
+        return False
+
+    def _should_send_argument_update(self, last_sent: Dict[str, Any], new_args: Dict[str, Any]) -> bool:
+        """
+        判断是否应该发送参数更新 - 更严格的标准
+        """
+        # 如果参数完全相同，不发送
+        if last_sent == new_args:
+            return False
+
+        # 如果新参数为空但之前有参数，不发送（避免倒退）
+        if not new_args and last_sent:
+            return False
+
+        # 如果新参数有更多键，发送更新
+        if len(new_args) > len(last_sent):
+            return True
+
+        # 检查是否有值变得显著更完整
+        for key, new_value in new_args.items():
+            last_value = last_sent.get(key, "")
+            if isinstance(new_value, str) and isinstance(last_value, str):
+                # 只有在值显著增长时才发送更新（避免微小变化）
+                if len(new_value) > len(last_value) + 5:
+                    return True
+            elif new_value != last_value and new_value:  # 确保新值不为空
+                return True
+
+        return False
+
+    def _handle_partial_tool_block(self, block_content: str, is_stream: bool) -> Generator[str, None, None]:
+        """
+        处理不完整的工具块，尝试提取可用信息
+        """
+        try:
+            # 尝试提取工具ID和名称
+            id_match = re.search(r'"id":\s*"([^"]+)"', block_content)
+            name_match = re.search(r'"name":\s*"([^"]+)"', block_content)
+
+            if id_match and name_match:
+                tool_id = id_match.group(1)
+                tool_name = name_match.group(1)
+
+                # 尝试提取参数部分
+                args_match = re.search(r'"arguments":\s*"([^"]*)', block_content)
+                partial_args = args_match.group(1) if args_match else ""
+
+                logger.debug(f"📦 部分工具块: {tool_name}(id={tool_id}), 部分参数: {partial_args[:50]}")
+
+                # 如果是新工具，先创建记录
+                if tool_id not in self.active_tools:
+                    # 尝试解析部分参数为字典
+                    partial_args_dict = self._parse_partial_arguments(partial_args)
+
+                    self.active_tools[tool_id] = {
+                        "id": tool_id,
+                        "name": tool_name,
+                        "arguments": partial_args_dict,
+                        "status": "partial",
+                        "sent_start": False,
+                        "last_sent_args": {},
+                        "args_complete": False,
+                        "partial_args": partial_args
+                    }
+
+                    if is_stream:
+                        yield self._create_tool_start_chunk(tool_id, tool_name, partial_args_dict)
+                        self.active_tools[tool_id]["sent_start"] = True
+                        self.active_tools[tool_id]["last_sent_args"] = partial_args_dict.copy()
+                else:
+                    # 更新部分参数
+                    self.active_tools[tool_id]["partial_args"] = partial_args
+                    # 尝试更新解析的参数
+                    new_partial_dict = self._parse_partial_arguments(partial_args)
+                    if new_partial_dict != self.active_tools[tool_id]["arguments"]:
+                        self.active_tools[tool_id]["arguments"] = new_partial_dict
+
+        except Exception as e:
+            logger.debug(f"📦 部分块解析失败: {e}")
+
+    def _clean_arguments_string(self, arguments_raw: str) -> str:
+        """
+        清理和标准化参数字符串，改进对不完整JSON的处理
+        """
+        if not arguments_raw:
+            return "{}"
+
+        # 移除首尾空白
+        cleaned = arguments_raw.strip()
+
+        # 处理特殊值
+        if cleaned.lower() == "null":
+            return "{}"
+
+        # 处理转义的JSON字符串
+        if cleaned.startswith('{\\"') and cleaned.endswith('\\"}'):
+            # 这是一个转义的JSON字符串，需要反转义
+            cleaned = cleaned.replace('\\"', '"')
+        elif cleaned.startswith('"{\\"') and cleaned.endswith('\\"}'):
+            # 双重转义的情况
+            cleaned = cleaned[1:-1].replace('\\"', '"')
+        elif cleaned.startswith('"') and cleaned.endswith('"'):
+            # 简单的引号包围，去除外层引号
+            cleaned = cleaned[1:-1]
+
+        # 处理不完整的JSON字符串
+        cleaned = self._fix_incomplete_json(cleaned)
+
+        # 标准化空格（移除JSON中的多余空格，但保留字符串值中的空格）
+        try:
+            # 先尝试解析，然后重新序列化以标准化格式
+            parsed = json.loads(cleaned)
+            if parsed is None:
+                return "{}"
+            cleaned = json.dumps(parsed, ensure_ascii=False, separators=(',', ':'))
+        except json.JSONDecodeError:
+            # 如果解析失败，只做基本的空格清理
+            logger.debug(f"📦 JSON标准化失败，保持原样: {cleaned[:50]}...")
+
+        return cleaned
+
+    def _fix_incomplete_json(self, json_str: str) -> str:
+        """
+        修复不完整的JSON字符串
+        """
+        if not json_str:
+            return "{}"
+
+        # 确保以{开头
+        if not json_str.startswith('{'):
+            json_str = '{' + json_str
+
+        # 处理不完整的字符串值
+        if json_str.count('"') % 2 != 0:
+            # 奇数个引号，可能有未闭合的字符串
+            json_str += '"'
+
+        # 确保以}结尾
+        if not json_str.endswith('}'):
+            json_str += '}'
+
+        return json_str
+
+    def _parse_partial_arguments(self, arguments_raw: str) -> Dict[str, Any]:
+        """
+        解析不完整的参数字符串，尽可能提取有效信息
+        """
+        if not arguments_raw or arguments_raw.strip() == "" or arguments_raw.strip().lower() == "null":
+            return {}
+
+        try:
+            # 先尝试清理字符串
+            cleaned = self._clean_arguments_string(arguments_raw)
+            result = json.loads(cleaned)
+            # 确保返回字典类型
+            return result if isinstance(result, dict) else {}
+        except json.JSONDecodeError:
+            pass
+
+        try:
+            # 尝试修复常见的JSON问题
+            fixed_args = arguments_raw.strip()
+
+            # 处理转义字符
+            if '\\' in fixed_args:
+                fixed_args = fixed_args.replace('\\"', '"')
+
+            # 如果不是以{开头，添加{
+            if not fixed_args.startswith('{'):
+                fixed_args = '{' + fixed_args
+
+            # 如果不是以}结尾，尝试添加}
+            if not fixed_args.endswith('}'):
+                # 计算未闭合的引号和括号
+                quote_count = fixed_args.count('"') - fixed_args.count('\\"')
+                if quote_count % 2 != 0:
+                    fixed_args += '"'
+                fixed_args += '}'
+
+            return json.loads(fixed_args)
+        except json.JSONDecodeError:
+            # 尝试提取键值对
+            return self._extract_key_value_pairs(arguments_raw)
+        except Exception:
+            # 如果所有方法都失败，返回空字典
+            return {}
+
+    def _extract_key_value_pairs(self, text: str) -> Dict[str, Any]:
+        """
+        从文本中提取键值对，作为最后的解析尝试
+        """
+        result = {}
+        try:
+            # 使用正则表达式提取简单的键值对
+            import re
+
+            # 匹配 "key": "value" 或 "key": value 格式
+            pattern = r'"([^"]+)":\s*"([^"]*)"'
+            matches = re.findall(pattern, text)
+
+            for key, value in matches:
+                result[key] = value
+
+            # 匹配数字值
+            pattern = r'"([^"]+)":\s*(\d+)'
+            matches = re.findall(pattern, text)
+
+            for key, value in matches:
+                try:
+                    result[key] = int(value)
+                except ValueError:
+                    result[key] = value
+
+            # 匹配布尔值
+            pattern = r'"([^"]+)":\s*(true|false)'
+            matches = re.findall(pattern, text)
+
+            for key, value in matches:
+                result[key] = value.lower() == 'true'
+
+        except Exception:
+            pass
+
+        return result
+
+    def _complete_active_tools(self, is_stream: bool) -> Generator[str, None, None]:
+        """
+        完成所有活跃的工具调用 - 处理待发送的工具
+        """
+        tools_to_send = []
+
+        for tool_id, tool in self.active_tools.items():
+            # 如果工具还没有发送过且参数看起来完整，现在发送
+            if is_stream and tool.get("pending_send", False) and not tool.get("sent_start", False):
+                if tool.get("args_complete", False):
+                    logger.debug(f"📤 完成时发送待发送工具: {tool['name']}(id={tool_id})")
+                    yield self._create_tool_start_chunk(tool_id, tool["name"], tool["arguments"])
+                    tool["sent_start"] = True
+                    tool["pending_send"] = False
+                    tools_to_send.append(tool)
+                else:
+                    logger.debug(f"⚠️ 跳过不完整的工具: {tool['name']}(id={tool_id})")
+
+            tool["status"] = "completed"
+            self.completed_tools.append(tool)
+            logger.debug(f"✅ 完成工具调用: {tool['name']}(id={tool_id})")
+
+        self.active_tools.clear()
+
+        if is_stream and (self.completed_tools or tools_to_send):
+            # 发送工具完成信号
+            yield self._create_tool_finish_chunk()
+
+    def process_other_phase(self, data: Dict[str, Any], is_stream: bool = True) -> Generator[str, None, None]:
+        """
+        处理other阶段 - 检测工具调用结束和状态更新
+        """
+        edit_content = data.get("edit_content", "")
+        edit_index = data.get("edit_index", 0)
+        usage = data.get("usage")
+
+        # 保存usage信息
+        if self.has_tool_call and usage:
+            self.tool_call_usage = usage
+            logger.debug(f"💾 保存工具调用usage: {usage}")
+
+        # 如果有edit_content，继续更新内容缓冲区
+        if edit_content:
+            self._apply_edit_to_buffer(edit_index, edit_content)
+            # 继续处理可能的工具调用更新
+            yield from self._process_tool_calls_from_buffer(is_stream)
+
+        # 检测工具调用结束的多种标记
+        if self.has_tool_call and self._is_tool_call_finished(edit_content):
+            logger.debug("🏁 检测到工具调用结束")
+
+            # 完成所有活跃的工具
+            yield from self._complete_active_tools(is_stream)
+
+            if is_stream:
+                logger.info("🏁 发送工具调用完成信号")
+                yield "data: [DONE]"
+
+            # 重置工具调用状态
+            self.has_tool_call = False
+
+    def _is_tool_call_finished(self, edit_content: str) -> bool:
+        """
+        检测工具调用是否结束的多种标记
+        """
+        if not edit_content:
+            return False
+
+        # 检测各种结束标记
+        end_markers = [
+            "null,",  # 原有的结束标记
+            '"status": "completed"',  # 状态完成标记
+            '"is_error": false',  # 错误状态标记
+        ]
+
+        for marker in end_markers:
+            if marker in edit_content:
+                logger.debug(f"🔍 检测到结束标记: {marker}")
+                return True
+
+        # 检查是否所有工具都有完整的结构
+        if self.active_tools and '"status": "completed"' in self.content_buffer:
+            return True
+
+        return False
+
+    def _reset_all_state(self):
+        """重置所有状态"""
+        self.has_tool_call = False
+        self.tool_call_usage = None
+        self.content_index = 0
+        self.content_buffer = bytearray()
+        self.last_edit_index = 0
+        self.active_tools.clear()
+        self.completed_tools.clear()
+        self.tool_blocks_cache.clear()
+
+    def _create_tool_start_chunk(self, tool_id: str, tool_name: str, initial_args: Dict[str, Any] = None) -> str:
+        """创建工具调用开始的chunk，支持初始参数"""
+        # 使用提供的初始参数，如果没有则使用空字典
+        args_dict = initial_args or {}
+        args_str = json.dumps(args_dict, ensure_ascii=False)
+
+        chunk = {
+            "choices": [
+                {
+                    "delta": {
+                        "role": "assistant",
+                        "content": None,
+                        "tool_calls": [
+                            {
+                                "id": tool_id,
+                                "type": "function",
+                                "function": {"name": tool_name, "arguments": args_str},
+                            }
+                        ],
+                    },
+                    "finish_reason": None,
+                    "index": self.content_index,
+                    "logprobs": None,
+                }
+            ],
+            "created": int(time.time()),
+            "id": self.chat_id,
+            "model": self.model,
+            "object": "chat.completion.chunk",
+            "system_fingerprint": "fp_zai_001",
+        }
+        return f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n"
+
+    def _create_tool_arguments_chunk(self, tool_id: str, arguments: Dict) -> str:
+        """创建工具参数的chunk - 只包含参数更新，不包含函数名"""
+        chunk = {
+            "choices": [
+                {
+                    "delta": {
+                        "tool_calls": [
+                            {
+                                "id": tool_id,
+                                "function": {"arguments": json.dumps(arguments, ensure_ascii=False)},
+                            }
+                        ],
+                    },
+                    "finish_reason": None,
+                    "index": self.content_index,
+                    "logprobs": None,
+                }
+            ],
+            "created": int(time.time()),
+            "id": self.chat_id,
+            "model": self.model,
+            "object": "chat.completion.chunk",
+            "system_fingerprint": "fp_zai_001",
+        }
+        return f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n"
+
+    def _create_tool_finish_chunk(self) -> str:
+        """创建工具调用完成的chunk"""
+        chunk = {
+            "choices": [
+                {
+                    "delta": {"role": "assistant", "content": None, "tool_calls": []},
+                    "finish_reason": "tool_calls",
+                    "index": 0,
+                    "logprobs": None,
+                }
+            ],
+            "created": int(time.time()),
+            "id": self.chat_id,
+            "usage": self.tool_call_usage or None,
+            "model": self.model,
+            "object": "chat.completion.chunk",
+            "system_fingerprint": "fp_zai_001",
+        }
+        return f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n"

app/utils/token_pool.py

@@ -0,0 +1,454 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Token池管理器
+实现AUTH_TOKEN的轮询机制，提供负载均衡和容错功能
+"""
+
+import asyncio
+import time
+from typing import Dict, List, Optional, Tuple
+from dataclasses import dataclass, field
+from threading import Lock
+import httpx
+import requests
+
+from app.utils.logger import logger
+
+
+@dataclass
+class TokenStatus:
+    """Token状态信息"""
+    token: str
+    is_available: bool = True
+    failure_count: int = 0
+    last_failure_time: float = 0.0
+    last_success_time: float = 0.0
+    total_requests: int = 0
+    successful_requests: int = 0
+    token_type: str = "unknown"  # "user", "guest", "unknown"
+    
+    @property
+    def success_rate(self) -> float:
+        """成功率"""
+        if self.total_requests == 0:
+            return 1.0
+        return self.successful_requests / self.total_requests
+    
+    @property
+    def is_healthy(self) -> bool:
+        """
+        是否健康
+
+        健康的定义：
+        1. 必须是认证用户token (token_type = "user")
+        2. 当前可用 (is_available = True)
+        3. 成功率 >= 50% 或者总请求数 <= 3（新token容错）
+
+        注意：guest token不应该在AUTH_TOKENS中
+        """
+        # guest token永远不健康
+        if self.token_type == "guest":
+            return False
+
+        # 未知类型token不健康
+        if self.token_type != "user":
+            return False
+
+        # 不可用的token不健康
+        if not self.is_available:
+            return False
+
+        # 对于认证用户token，基于成功率判断
+        # 新token或请求数很少时，给予容错
+        if self.total_requests <= 3:
+            return self.failure_count == 0
+
+        # 基于成功率判断健康状态
+        return self.success_rate >= 0.5
+
+
+class TokenPool:
+    """Token池管理器"""
+    
+    def __init__(self, tokens: List[str], failure_threshold: int = 3, recovery_timeout: int = 1800):
+        """
+        初始化Token池
+        
+        Args:
+            tokens: token列表
+            failure_threshold: 失败阈值，超过此次数将标记为不可用
+            recovery_timeout: 恢复超时时间（秒），失败token在此时间后重新尝试
+        """
+        self.failure_threshold = failure_threshold
+        self.recovery_timeout = recovery_timeout
+        self._lock = Lock()
+        self._current_index = 0
+        
+        # 初始化token状态
+        self.token_statuses: Dict[str, TokenStatus] = {}
+        original_count = len(tokens)
+        unique_tokens = []
+
+        # 去重处理
+        for token in tokens:
+            if token and token not in self.token_statuses:  # 过滤空token和重复token
+                self.token_statuses[token] = TokenStatus(token=token)
+                unique_tokens.append(token)
+
+        duplicate_count = original_count - len(unique_tokens)
+        if duplicate_count > 0:
+            logger.warning(f"⚠️ 检测到 {duplicate_count} 个重复token，已自动去重")
+
+        if not self.token_statuses:
+            logger.warning("⚠️ Token池为空，将依赖匿名模式")
+        else:
+            logger.info(f"🔧 初始化Token池，共 {len(self.token_statuses)} 个token")
+    
+    def get_next_token(self) -> Optional[str]:
+        """
+        获取下一个可用的token（轮询算法）
+        
+        Returns:
+            可用的token，如果没有可用token则返回None
+        """
+        with self._lock:
+            if not self.token_statuses:
+                return None
+            
+            available_tokens = self._get_available_tokens()
+            if not available_tokens:
+                # 尝试恢复过期的失败token
+                self._try_recover_failed_tokens()
+                available_tokens = self._get_available_tokens()
+                
+                if not available_tokens:
+                    logger.warning("⚠️ 没有可用的token")
+                    return None
+            
+            # 轮询选择token
+            token = available_tokens[self._current_index % len(available_tokens)]
+            self._current_index = (self._current_index + 1) % len(available_tokens)
+
+            return token
+    
+    def _get_available_tokens(self) -> List[str]:
+        """
+        获取当前可用的认证用户token列表
+
+        只返回满足以下条件的token：
+        1. is_available = True (可用状态)
+        2. token_type = "user" (认证用户token)
+
+        这确保轮询机制只会选择有效的认证用户token，跳过匿名用户token
+        """
+        available_user_tokens = [
+            status.token for status in self.token_statuses.values()
+            if status.is_available and status.token_type == "user"
+        ]
+
+        # 如果没有可用的认证用户token
+        if not available_user_tokens and self.token_statuses:
+            guest_tokens = [
+                status.token for status in self.token_statuses.values()
+                if status.token_type == "guest"
+            ]
+            if guest_tokens:
+                logger.warning(f"⚠️ 检测到 {len(guest_tokens)} 个匿名用户token，轮询机制将跳过这些token")
+
+        return available_user_tokens
+    
+    def _try_recover_failed_tokens(self):
+        """尝试恢复失败的token"""
+        current_time = time.time()
+        recovered_count = 0
+        
+        for status in self.token_statuses.values():
+            if (not status.is_available and 
+                current_time - status.last_failure_time > self.recovery_timeout):
+                status.is_available = True
+                status.failure_count = 0
+                recovered_count += 1
+                logger.info(f"🔄 恢复失败token: {status.token[:20]}...")
+        
+        if recovered_count > 0:
+            logger.info(f"✅ 恢复了 {recovered_count} 个失败的token")
+    
+    def mark_token_success(self, token: str):
+        """标记token使用成功"""
+        with self._lock:
+            if token in self.token_statuses:
+                status = self.token_statuses[token]
+                status.total_requests += 1
+                status.successful_requests += 1
+                status.last_success_time = time.time()
+                status.failure_count = 0  # 重置失败计数
+                
+                if not status.is_available:
+                    status.is_available = True
+                    logger.info(f"✅ Token恢复可用: {token[:20]}...")
+    
+    def mark_token_failure(self, token: str, error: Exception = None):
+        """标记token使用失败"""
+        with self._lock:
+            if token in self.token_statuses:
+                status = self.token_statuses[token]
+                status.total_requests += 1
+                status.failure_count += 1
+                status.last_failure_time = time.time()
+                
+                if status.failure_count >= self.failure_threshold:
+                    status.is_available = False
+                    logger.warning(f"🚫 Token已禁用: {token[:20]}... (失败 {status.failure_count} 次)")
+    
+    def get_pool_status(self) -> Dict:
+        """获取token池状态信息"""
+        with self._lock:
+            available_count = len(self._get_available_tokens())
+            total_count = len(self.token_statuses)
+
+            # 统计健康token数量
+            healthy_count = sum(1 for status in self.token_statuses.values() if status.is_healthy)
+
+            status_info = {
+                "total_tokens": total_count,
+                "available_tokens": available_count,
+                "unavailable_tokens": total_count - available_count,
+                "healthy_tokens": healthy_count,
+                "unhealthy_tokens": total_count - healthy_count,
+                "current_index": self._current_index,
+                "tokens": []
+            }
+
+            for token, status in self.token_statuses.items():
+                status_info["tokens"].append({
+                    "token": f"{token[:10]}...{token[-10:]}",
+                    "token_type": status.token_type,
+                    "is_available": status.is_available,
+                    "failure_count": status.failure_count,
+                    "success_count": status.successful_requests,
+                    "success_rate": f"{status.success_rate:.2%}",
+                    "total_requests": status.total_requests,
+                    "is_healthy": status.is_healthy,
+                    "last_failure_time": status.last_failure_time,
+                    "last_success_time": status.last_success_time
+                })
+
+            return status_info
+    
+    def update_tokens(self, new_tokens: List[str]):
+        """动态更新token列表"""
+        with self._lock:
+            # 保留现有token的状态信息
+            old_statuses = self.token_statuses.copy()
+            self.token_statuses.clear()
+
+            original_count = len(new_tokens)
+            unique_tokens = []
+
+            # 去重并添加新token，保留已存在token的状态
+            for token in new_tokens:
+                if token and token not in self.token_statuses:  # 过滤空token和重复token
+                    if token in old_statuses:
+                        self.token_statuses[token] = old_statuses[token]
+                    else:
+                        self.token_statuses[token] = TokenStatus(token=token)
+                    unique_tokens.append(token)
+
+            # 记录去重信息
+            duplicate_count = original_count - len(unique_tokens)
+            if duplicate_count > 0:
+                logger.warning(f"⚠️ 更新时检测到 {duplicate_count} 个重复token，已自动去重")
+
+            # 重置索引
+            self._current_index = 0
+
+            logger.info(f"🔄 更新Token池，共 {len(self.token_statuses)} 个token")
+    
+    async def health_check_token(self, token: str, auth_url: str = "https://chat.z.ai/api/v1/auths/") -> bool:
+        """
+        异步健康检查单个token
+
+        使用Z.AI认证API验证token的有效性，通过检查响应内容判断token是否有效
+
+        Args:
+            token: 要检查的token
+            auth_url: 认证URL
+
+        Returns:
+            token是否健康
+        """
+        try:
+            # 构建完整的请求头，模拟真实浏览器请求
+            headers = {
+                "Accept": "*/*",
+                "Accept-Language": "zh-CN,zh;q=0.9",
+                "Authorization": f"Bearer {token}",
+                "Connection": "keep-alive",
+                "Content-Type": "application/json",
+                "DNT": "1",
+                "Referer": "https://chat.z.ai/",
+                "Sec-Fetch-Dest": "empty",
+                "Sec-Fetch-Mode": "cors",
+                "Sec-Fetch-Site": "same-origin",
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36",
+                "sec-ch-ua": '"Chromium";v="140", "Not=A?Brand";v="24", "Google Chrome";v="140"',
+                "sec-ch-ua-mobile": "?0",
+                "sec-ch-ua-platform": "Windows"
+            }
+
+            async with httpx.AsyncClient(timeout=15.0) as client:
+                response = await client.get(auth_url, headers=headers)
+
+                # 验证token有效性并获取类型
+                token_type, is_healthy = self._validate_token_response(response)
+
+                # 更新token类型
+                if token in self.token_statuses:
+                    self.token_statuses[token].token_type = token_type
+
+                if is_healthy:
+                    self.mark_token_success(token)
+                else:
+                    # 简化错误信息，只记录关键错误类型
+                    if token_type == "guest":
+                        error_msg = "匿名用户token"
+                    elif response.status_code != 200:
+                        error_msg = f"HTTP {response.status_code}"
+                    else:
+                        error_msg = "认证失败"
+
+                    self.mark_token_failure(token, Exception(error_msg))
+
+                return is_healthy
+
+        except (httpx.TimeoutException, httpx.ConnectError, Exception) as e:
+            self.mark_token_failure(token, e)
+            return False
+
+    def _validate_token_response(self, response: httpx.Response) -> bool:
+        """
+        基于Z.AI API响应中的role字段验证token类型
+
+        验证规则：
+        - role: "user" = 认证用户token（有效，可用于AUTH_TOKENS）
+        - role: "guest" = 匿名用户token（无效，不应在AUTH_TOKENS中）
+        - 无role字段或其他值 = 无效token
+
+        Args:
+            response: HTTP响应对象
+
+        Returns:
+            token是否为有效的认证用户token
+        """
+        # 首先检查HTTP状态码
+        if response.status_code != 200:
+            return ("unknown", False)
+
+        try:
+            # 尝试解析JSON响应
+            response_data = response.json()
+
+            if not isinstance(response_data, dict):
+                return ("unknown", False)
+
+            # 检查是否包含错误信息
+            if "error" in response_data:
+                return ("unknown", False)
+
+            if "message" in response_data and "error" in response_data.get("message", "").lower():
+                return ("unknown", False)
+
+            # 核心验证：检查role字段
+            role = response_data.get("role")
+
+            if role == "user":
+                return ("user", True)
+            elif role == "guest":
+            
+                if not hasattr(self, '_guest_token_warned'):
+                    logger.warning("⚠️ 检测到匿名用户token，建议仅在AUTH_TOKENS中配置认证用户token")
+                    self._guest_token_warned = True
+                return ("guest", False)
+            else:
+                return ("unknown", False)
+
+        except (ValueError, Exception):
+            return ("unknown", False)
+
+    async def health_check_all(self, auth_url: str = "https://chat.z.ai/api/v1/auths/"):
+        """异步健康检查所有token"""
+        if not self.token_statuses:
+            logger.warning("⚠️ Token池为空，跳过健康检查")
+            return
+
+        total_tokens = len(self.token_statuses)
+        logger.info(f"🔍 开始Token池健康检查... (共 {total_tokens} 个token)")
+
+        # 并发执行所有token的健康检查
+        tasks = []
+        token_list = list(self.token_statuses.keys())
+
+        for token in token_list:
+            task = self.health_check_token(token, auth_url)
+            tasks.append(task)
+
+        # 执行并收集结果
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        # 统计结果
+        healthy_count = 0
+        failed_count = 0
+        exception_count = 0
+
+        for i, result in enumerate(results):
+            if result is True:
+                healthy_count += 1
+            elif result is False:
+                failed_count += 1
+            else:
+                # 异常情况
+                exception_count += 1
+                token = token_list[i]
+                logger.error(f"💥 Token {token[:20]}... 健康检查异常: {result}")
+
+        health_rate = (healthy_count / total_tokens) * 100 if total_tokens > 0 else 0
+
+        if healthy_count == 0 and total_tokens > 0:
+            logger.warning(f"⚠️ 健康检查完成: 0/{total_tokens} 个token健康 - 请检查token配置")
+        elif failed_count > 0:
+            logger.warning(f"⚠️ 健康检查完成: {healthy_count}/{total_tokens} 个token健康 ({health_rate:.1f}%)")
+        else:
+            logger.info(f"✅ 健康检查完成: {healthy_count}/{total_tokens} 个token健康")
+
+        if exception_count > 0:
+            logger.error(f"💥 {exception_count} 个token检查异常")
+
+
+# 全局token池实例
+_token_pool: Optional[TokenPool] = None
+_pool_lock = Lock()
+
+
+def get_token_pool() -> Optional[TokenPool]:
+    """获取全局token池实例"""
+    return _token_pool
+
+
+def initialize_token_pool(tokens: List[str], failure_threshold: int = 3, recovery_timeout: int = 1800) -> TokenPool:
+    """初始化全局token池"""
+    global _token_pool
+    with _pool_lock:
+        _token_pool = TokenPool(tokens, failure_threshold, recovery_timeout)
+        return _token_pool
+
+
+def update_token_pool(tokens: List[str]):
+    """更新全局token池"""
+    global _token_pool
+    with _pool_lock:
+        if _token_pool:
+            _token_pool.update_tokens(tokens)
+        else:
+            _token_pool = TokenPool(tokens)

app/utils/tools.py

@@ -1,325 +0,0 @@
-"""
-Tool processing utilities
-"""
-
-import json
-import re
-import time
-from typing import Dict, List, Optional, Any
-
-from app.core.config import settings
-
-
-def content_to_string(content: Any) -> str:
-    """Convert content from various formats to string (following app.py pattern)"""
-    if isinstance(content, str):
-        return content
-    if isinstance(content, list):
-        parts = []
-        for p in content:
-            if isinstance(p, dict) and p.get("type") == "text":
-                parts.append(p.get("text", ""))
-            elif isinstance(p, str):
-                parts.append(p)
-        return " ".join(parts)
-    return ""
-
-
-def generate_tool_prompt(tools: List[Dict[str, Any]]) -> str:
-    """Generate tool injection prompt with enhanced formatting"""
-    if not tools:
-        return ""
-
-    tool_definitions = []
-    for tool in tools:
-        if tool.get("type") != "function":
-            continue
-
-        function_spec = tool.get("function", {}) or {}
-        function_name = function_spec.get("name", "unknown")
-        function_description = function_spec.get("description", "")
-        parameters = function_spec.get("parameters", {}) or {}
-
-        # Create structured tool definition
-        tool_info = [f"## {function_name}", f"**Purpose**: {function_description}"]
-
-        # Add parameter details
-        parameter_properties = parameters.get("properties", {}) or {}
-        required_parameters = set(parameters.get("required", []) or [])
-
-        if parameter_properties:
-            tool_info.append("**Parameters**:")
-            for param_name, param_details in parameter_properties.items():
-                param_type = (param_details or {}).get("type", "any")
-                param_desc = (param_details or {}).get("description", "")
-                requirement_flag = "**Required**" if param_name in required_parameters else "*Optional*"
-                tool_info.append(f"- `{param_name}` ({param_type}) - {requirement_flag}: {param_desc}")
-
-        tool_definitions.append("\n".join(tool_info))
-
-    if not tool_definitions:
-        return ""
-
-    # Build comprehensive tool prompt
-    prompt_template = (
-        "\n\n# AVAILABLE FUNCTIONS\n" + "\n\n---\n".join(tool_definitions) + "\n\n# USAGE INSTRUCTIONS\n"
-        "When you need to execute a function, respond ONLY with a JSON object containing tool_calls:\n"
-        "```json\n"
-        "{\n"
-        '  "tool_calls": [\n'
-        "    {\n"
-        '      "id": "call_xxx",\n'
-        '      "type": "function",\n'
-        '      "function": {\n'
-        '        "name": "function_name",\n'
-        '        "arguments": "{\\"param1\\": \\"value1\\"}"\n'
-        "      }\n"
-        "    }\n"
-        "  ]\n"
-        "}\n"
-        "```\n"
-        "Important: No explanatory text before or after the JSON. The 'arguments' field must be a JSON string, not an object.\n"
-    )
-
-    return prompt_template
-
-
-def process_messages_with_tools(
-    messages: List[Dict[str, Any]], tools: Optional[List[Dict[str, Any]]] = None, tool_choice: Optional[Any] = None
-) -> List[Dict[str, Any]]:
-    """Process messages and inject tool prompts"""
-    processed: List[Dict[str, Any]] = []
-
-    if tools and settings.TOOL_SUPPORT and (tool_choice != "none"):
-        tools_prompt = generate_tool_prompt(tools)
-        has_system = any(m.get("role") == "system" for m in messages)
-
-        if has_system:
-            for m in messages:
-                if m.get("role") == "system":
-                    mm = dict(m)
-                    content = content_to_string(mm.get("content", ""))
-                    mm["content"] = content + tools_prompt
-                    processed.append(mm)
-                else:
-                    processed.append(m)
-        else:
-            processed = [{"role": "system", "content": "你是一个有用的助手。" + tools_prompt}] + messages
-
-        # Add tool choice hints
-        if tool_choice in ("required", "auto"):
-            if processed and processed[-1].get("role") == "user":
-                last = dict(processed[-1])
-                content = content_to_string(last.get("content", ""))
-                last["content"] = content + "\n\n请根据需要使用提供的工具函数。"
-                processed[-1] = last
-        elif isinstance(tool_choice, dict) and tool_choice.get("type") == "function":
-            fname = (tool_choice.get("function") or {}).get("name")
-            if fname and processed and processed[-1].get("role") == "user":
-                last = dict(processed[-1])
-                content = content_to_string(last.get("content", ""))
-                last["content"] = content + f"\n\n请使用 {fname} 函数来处理这个请求。"
-                processed[-1] = last
-    else:
-        processed = list(messages)
-
-    # Handle tool/function messages
-    final_msgs: List[Dict[str, Any]] = []
-    for m in processed:
-        role = m.get("role")
-        if role in ("tool", "function"):
-            tool_name = m.get("name", "unknown")
-            tool_content = content_to_string(m.get("content", ""))
-            if isinstance(tool_content, dict):
-                tool_content = json.dumps(tool_content, ensure_ascii=False)
-
-            # 确保内容不为空且不包含 None
-            content = f"工具 {tool_name} 返回结果:\n```json\n{tool_content}\n```"
-            if not content.strip():
-                content = f"工具 {tool_name} 执行完成"
-
-            final_msgs.append(
-                {
-                    "role": "assistant",
-                    "content": content,
-                }
-            )
-        else:
-            # For regular messages, ensure content is string format
-            final_msg = dict(m)
-            content = content_to_string(final_msg.get("content", ""))
-            final_msg["content"] = content
-            final_msgs.append(final_msg)
-
-    return final_msgs
-
-
-# Tool Extraction Patterns
-TOOL_CALL_FENCE_PATTERN = re.compile(r"```json\s*(\{.*?\})\s*```", re.DOTALL)
-# 注意：TOOL_CALL_INLINE_PATTERN 已被移除，因为它会导致过度匹配
-# 现在在 remove_tool_json_content 函数中使用基于括号平衡的方法
-FUNCTION_CALL_PATTERN = re.compile(r"调用函数\s*[：:]\s*([\w\-\.]+)\s*(?:参数|arguments)[：:]\s*(\{.*?\})", re.DOTALL)
-
-
-def extract_tool_invocations(text: str) -> Optional[List[Dict[str, Any]]]:
-    """Extract tool invocations from response text"""
-    if not text:
-        return None
-
-    # Limit scan size for performance
-    scannable_text = text[: settings.SCAN_LIMIT]
-
-    # Attempt 1: Extract from JSON code blocks
-    json_blocks = TOOL_CALL_FENCE_PATTERN.findall(scannable_text)
-    for json_block in json_blocks:
-        try:
-            parsed_data = json.loads(json_block)
-            tool_calls = parsed_data.get("tool_calls")
-            if tool_calls and isinstance(tool_calls, list):
-                # Ensure arguments field is a string
-                for tc in tool_calls:
-                    if "function" in tc:
-                        func = tc["function"]
-                        if "arguments" in func:
-                            if isinstance(func["arguments"], dict):
-                                # Convert dict to JSON string
-                                func["arguments"] = json.dumps(func["arguments"], ensure_ascii=False)
-                            elif not isinstance(func["arguments"], str):
-                                func["arguments"] = json.dumps(func["arguments"], ensure_ascii=False)
-                return tool_calls
-        except (json.JSONDecodeError, AttributeError):
-            continue
-
-    # Attempt 2: Extract inline JSON objects using bracket balance method
-    # 查找包含 "tool_calls" 的 JSON 对象
-    i = 0
-    while i < len(scannable_text):
-        if scannable_text[i] == '{':
-            # 尝试找到匹配的右括号
-            brace_count = 1
-            j = i + 1
-            in_string = False
-            escape_next = False
-            
-            while j < len(scannable_text) and brace_count > 0:
-                if escape_next:
-                    escape_next = False
-                elif scannable_text[j] == '\\':
-                    escape_next = True
-                elif scannable_text[j] == '"' and not escape_next:
-                    in_string = not in_string
-                elif not in_string:
-                    if scannable_text[j] == '{':
-                        brace_count += 1
-                    elif scannable_text[j] == '}':
-                        brace_count -= 1
-                j += 1
-            
-            if brace_count == 0:
-                # 找到了完整的 JSON 对象
-                json_str = scannable_text[i:j]
-                try:
-                    parsed_data = json.loads(json_str)
-                    tool_calls = parsed_data.get("tool_calls")
-                    if tool_calls and isinstance(tool_calls, list):
-                        # Ensure arguments field is a string
-                        for tc in tool_calls:
-                            if "function" in tc:
-                                func = tc["function"]
-                                if "arguments" in func:
-                                    if isinstance(func["arguments"], dict):
-                                        # Convert dict to JSON string
-                                        func["arguments"] = json.dumps(func["arguments"], ensure_ascii=False)
-                                    elif not isinstance(func["arguments"], str):
-                                        func["arguments"] = json.dumps(func["arguments"], ensure_ascii=False)
-                        return tool_calls
-                except (json.JSONDecodeError, AttributeError):
-                    pass
-            
-            i += 1
-        else:
-            i += 1
-
-    # Attempt 3: Parse natural language function calls
-    natural_lang_match = FUNCTION_CALL_PATTERN.search(scannable_text)
-    if natural_lang_match:
-        function_name = natural_lang_match.group(1).strip()
-        arguments_str = natural_lang_match.group(2).strip()
-        try:
-            # Validate JSON format
-            json.loads(arguments_str)
-            return [
-                {
-                    "id": f"call_{int(time.time() * 1000000)}",
-                    "type": "function",
-                    "function": {"name": function_name, "arguments": arguments_str},
-                }
-            ]
-        except json.JSONDecodeError:
-            return None
-
-    return None
-
-
-def remove_tool_json_content(text: str) -> str:
-    """Remove tool JSON content from response text - using bracket balance method"""
-    
-    def remove_tool_call_block(match: re.Match) -> str:
-        json_content = match.group(1)
-        try:
-            parsed_data = json.loads(json_content)
-            if "tool_calls" in parsed_data:
-                return ""
-        except (json.JSONDecodeError, AttributeError):
-            pass
-        return match.group(0)
-    
-    # Step 1: Remove fenced tool JSON blocks
-    cleaned_text = TOOL_CALL_FENCE_PATTERN.sub(remove_tool_call_block, text)
-    
-    # Step 2: Remove inline tool JSON - 使用基于括号平衡的智能方法
-    # 查找所有可能的 JSON 对象并精确删除包含 tool_calls 的对象
-    result = []
-    i = 0
-    while i < len(cleaned_text):
-        if cleaned_text[i] == '{':
-            # 尝试找到匹配的右括号
-            brace_count = 1
-            j = i + 1
-            in_string = False
-            escape_next = False
-            
-            while j < len(cleaned_text) and brace_count > 0:
-                if escape_next:
-                    escape_next = False
-                elif cleaned_text[j] == '\\':
-                    escape_next = True
-                elif cleaned_text[j] == '"' and not escape_next:
-                    in_string = not in_string
-                elif not in_string:
-                    if cleaned_text[j] == '{':
-                        brace_count += 1
-                    elif cleaned_text[j] == '}':
-                        brace_count -= 1
-                j += 1
-            
-            if brace_count == 0:
-                # 找到了完整的 JSON 对象
-                json_str = cleaned_text[i:j]
-                try:
-                    parsed = json.loads(json_str)
-                    if "tool_calls" in parsed:
-                        # 这是一个工具调用，跳过它
-                        i = j
-                        continue
-                except:
-                    pass
-            
-            # 不是工具调用或无法解析，保留这个字符
-            result.append(cleaned_text[i])
-            i += 1
-        else:
-            result.append(cleaned_text[i])
-            i += 1
-    
-    return ''.join(result).strip()

deploy/docker-compose.yml

@@ -15,8 +15,6 @@ services:
       - SKIP_AUTH_TOKEN=false
       # Server Configurations
       - DEBUG_LOGGING=true
-      # Feature Configuration
-      - THINKING_PROCESSING=think
       - ANONYMOUS_MODE=true
       - TOOL_SUPPORT=true
       - SCAN_LIMIT=200000

main.py

@@ -1,25 +1,40 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-"""
-Main application entry point
-"""
-
-from fastapi import FastAPI, Request, Response
+from contextlib import asynccontextmanager
+from fastapi import FastAPI, Response
 from fastapi.middleware.cors import CORSMiddleware
 
 from app.core.config import settings
 from app.core import openai
 from app.utils.reload_config import RELOAD_CONFIG
+from app.utils.logger import setup_logger
+from app.utils.token_pool import initialize_token_pool
 
 from granian import Granian
 
-# Create FastAPI app
-app = FastAPI(
-    title="OpenAI Compatible API Server",
-    description="An OpenAI-compatible API server for Z.AI chat service",
-    version="1.0.0",
-)
+
+# Setup logger
+logger = setup_logger(log_dir="logs", debug_mode=settings.DEBUG_LOGGING)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    token_list = settings.auth_token_list
+    if token_list:
+        token_pool = initialize_token_pool(
+            tokens=token_list,
+            failure_threshold=settings.TOKEN_FAILURE_THRESHOLD,
+            recovery_timeout=settings.TOKEN_RECOVERY_TIMEOUT
+        )
+
+    yield
+
+    logger.info("🔄 应用正在关闭...")
+
+
+# Create FastAPI app with lifespan
+app = FastAPI(lifespan=lifespan)
 
 # Add CORS middleware
 app.add_middleware(
@@ -52,7 +67,7 @@ def run_server():
         interface="asgi",
         address="0.0.0.0",
         port=settings.LISTEN_PORT,
-        reload=False,   # 生产环境请关闭热重载
+        reload=False,  # 生产环境请关闭热重载
         **RELOAD_CONFIG,
     ).serve()
 

pyproject.toml

@@ -32,6 +32,8 @@ dependencies = [
     "pydantic-core==2.33.2",
     "typing-inspection==0.4.1",
     "fake-useragent==2.2.0",
+    "loguru==0.7.3",
+    "httpx==0.27.0"
 ]
 
 [project.scripts]

requirements.txt

@@ -1,8 +1,10 @@
-fastapi==0.104.1
+fastapi==0.116.1
 granian[reload]==2.5.2
 requests==2.32.5
+httpx==0.27.0
 pydantic==2.11.7
 pydantic-settings==2.10.1
 pydantic-core==2.33.2
 typing-inspection==0.4.1
-fake-useragent==2.2.0
+fake-useragent==2.2.0
+loguru==0.7.3

tests/test_final_verification.py

@@ -1,56 +0,0 @@
-"""验证 tools.py 修复后的功能"""
-
-import sys
-sys.path.append('E:\\GitHub\\z.ai2api_python')
-
-from app.utils.tools import remove_tool_json_content
-
-def test_remove_tool_json():
-    print("=" * 60)
-    print("验证 tools.py 中的 remove_tool_json_content 函数")
-    print("=" * 60)
-    
-    # 测试案例 1: 纯工具调用 JSON（应该被完全移除）
-    test1 = '{"tool_calls": [{"id": "call_1", "type": "function"}]}'
-    result1 = remove_tool_json_content(test1)
-    print(f"\n测试1 - 纯工具调用:")
-    print(f"输入: {test1}")
-    print(f"输出: '{result1}'")
-    print("[PASS] 通过" if result1 == "" else "[FAIL] 失败")
-    
-    # 测试案例 2: 混合内容
-    test2 = '''这是开始文本
-{"tool_calls": [{"id": "call_2", "type": "function"}]}
-这是结束文本'''
-    result2 = remove_tool_json_content(test2)
-    print(f"\n测试2 - 混合内容:")
-    print(f"输入: {repr(test2)}")
-    print(f"输出: {repr(result2)}")
-    expected2 = "这是开始文本\n\n这是结束文本"
-    print("[PASS] 通过" if result2 == expected2 else "[FAIL] 失败")
-    
-    # 测试案例 3: 普通 JSON（不应被删除）
-    test3 = '{"data": {"result": "success"}}'
-    result3 = remove_tool_json_content(test3)
-    print(f"\n测试3 - 普通JSON:")
-    print(f"输入: {test3}")
-    print(f"输出: '{result3}'")
-    print("[PASS] 通过" if result3 == test3 else "[FAIL] 失败")
-    
-    # 测试案例 4: 代码块中的工具调用
-    test4 = '''正常文本
-```json
-{"tool_calls": [{"id": "call_3"}]}
-```
-保留文本'''
-    result4 = remove_tool_json_content(test4)
-    print(f"\n测试4 - 代码块中的工具调用:")
-    print(f"输入: {repr(test4)}")
-    print(f"输出: {repr(result4)}")
-    print("[PASS] 通过" if "保留文本" in result4 and "tool_calls" not in result4 else "[FAIL] 失败")
-
-if __name__ == "__main__":
-    test_remove_tool_json()
-    print("\n" + "=" * 60)
-    print("所有测试完成！正则表达式问题已成功修复。")
-    print("=" * 60)

tests/test_function_call.py

@@ -1,70 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import json
-import requests
-
-# API 配置
-API_BASE = "http://localhost:8080"
-API_KEY = "sk-your-api-key"
-
-def test_weather_query():
-    """测试天气查询"""
-    print("=" * 50)
-    print("上海天气查询测试")
-    print("=" * 50)
-    
-    # 工具定义
-    tool = {
-        "type": "function",
-        "function": {
-            "name": "get_weather",
-            "description": "查询指定城市的天气信息",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "city": {"type": "string", "description": "城市名称"},
-                    "date": {"type": "string", "description": "查询日期（可选）"}
-                },
-                "required": ["city"]
-            }
-        }
-    }
-    
-    # 发送请求
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {API_KEY}"
-    }
-    
-    data = {
-        "model": "GLM-4.5",
-        "messages": [
-            {"role": "user", "content": "查询上海2025年9月3日的天气"}
-        ],
-        "tools": [tool]
-    }
-    
-    print("\n发送请求...")
-    response = requests.post(f"{API_BASE}/v1/chat/completions", 
-                           headers=headers, 
-                           json=data)
-    
-    if response.status_code == 200:
-        result = response.json()
-        message = result["choices"][0]["message"]
-        
-        print("\n模型响应:")
-        if message.get("tool_calls"):
-            print("检测到工具调用:")
-            for tc in message["tool_calls"]:
-                print(f"  - 工具: {tc['function']['name']}")
-                print(f"  - 参数: {tc['function']['arguments']}")
-        else:
-            print("未检测到工具调用")
-            print(f"内容: {message.get('content', '无内容')[:100]}...")
-    else:
-        print(f"请求失败: {response.status_code}")
-        print(f"错误信息: {response.text}")
-
-if __name__ == "__main__":
-    test_weather_query()

tests/test_multimodal_quick.py

@@ -1,3 +1,6 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
 """
 glm-4.5v 多模态功能测试
 """
@@ -5,9 +8,7 @@ import requests
 import json
 
 # 创建一个1x1像素的红色图片作为测试
-tiny_red_image = (
-    "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFBQIAX8jx0gAAAABJRU5ErkJggg=="
-)
+tiny_red_image = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFBQIAX8jx0gAAAABJRU5ErkJggg=="
 
 # API配置
 api_url = "http://localhost:8080/v1/chat/completions"
@@ -20,36 +21,25 @@ request_data = {
         {
             "role": "user",
             "content": [  # content必须是数组
-                {
-                    "type": "text",
-                    "text": "这是什么颜色的图片？"
-                },
-                {
-                    "type": "image_url",
-                    "image_url": {
-                        "url": tiny_red_image
-                    }
-                }
-            ]
+                {"type": "text", "text": "这是什么颜色的图片？"},
+                {"type": "image_url", "image_url": {"url": tiny_red_image}},
+            ],
         }
     ],
-    "stream": False
+    "stream": False,
 }
 
 print("发送的请求:")
 print(json.dumps(request_data, indent=2, ensure_ascii=False))
-print("\n" + "="*60)
+print("\n" + "=" * 60)
 
 # 发送请求
-headers = {
-    "Authorization": f"Bearer {api_key}",
-    "Content-Type": "application/json"
-}
+headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
 
 try:
     response = requests.post(api_url, json=request_data, headers=headers)
     print(f"响应状态码: {response.status_code}")
-    
+
     if response.status_code == 200:
         result = response.json()
         print("\n模型回复:")
@@ -57,6 +47,6 @@ try:
     else:
         print("\n错误响应:")
         print(response.text)
-        
+
 except Exception as e:
-    print(f"\n发生错误: {e}")
+    print(f"\n发生错误: {e}")

tests/test_re.py

@@ -1,226 +0,0 @@
-"""测试和修复正则表达式问题"""
-
-import json
-import re
-
-# 原始的正则表达式（来自 tools.py）
-TOOL_CALL_FENCE_PATTERN = re.compile(r"```json\s*(\{.*?\})\s*```", re.DOTALL)
-TOOL_CALL_INLINE_PATTERN_OLD = re.compile(r"(\{[^{}]{0,10000}\"tool_calls\".*?\})", re.DOTALL)
-
-# 改进的正则表达式
-# 方案1：更精确的匹配 - 只匹配包含 tool_calls 的完整 JSON 对象
-TOOL_CALL_INLINE_PATTERN_NEW = re.compile(
-    r'\{(?:[^{}]|\{[^{}]*\})*"tool_calls"\s*:\s*\[[^\]]*\](?:[^{}]|\{[^{}]*\})*\}',
-    re.MULTILINE
-)
-
-def remove_tool_json_content_old(text: str) -> str:
-    """原始的移除工具JSON内容函数"""
-    
-    def remove_tool_call_block(match: re.Match) -> str:
-        json_content = match.group(1)
-        try:
-            parsed_data = json.loads(json_content)
-            if "tool_calls" in parsed_data:
-                return ""
-        except (json.JSONDecodeError, AttributeError):
-            pass
-        return match.group(0)
-    
-    # Remove fenced tool JSON blocks
-    cleaned_text = TOOL_CALL_FENCE_PATTERN.sub(remove_tool_call_block, text)
-    # Remove inline tool JSON
-    cleaned_text = TOOL_CALL_INLINE_PATTERN_OLD.sub("", cleaned_text)
-    return cleaned_text.strip()
-
-def remove_tool_json_content_new(text: str) -> str:
-    """改进的移除工具JSON内容函数 - 使用基于括号平衡的方法"""
-    
-    def remove_tool_call_block(match: re.Match) -> str:
-        json_content = match.group(1)
-        try:
-            parsed_data = json.loads(json_content)
-            if "tool_calls" in parsed_data:
-                return ""
-        except (json.JSONDecodeError, AttributeError):
-            pass
-        return match.group(0)
-    
-    # Step 1: Remove fenced tool JSON blocks
-    cleaned_text = TOOL_CALL_FENCE_PATTERN.sub(remove_tool_call_block, text)
-    
-    # Step 2: Remove inline tool JSON - 使用更智能的方法
-    # 查找所有可能的 JSON 对象
-    result = []
-    i = 0
-    while i < len(cleaned_text):
-        if cleaned_text[i] == '{':
-            # 尝试找到匹配的右括号
-            brace_count = 1
-            j = i + 1
-            in_string = False
-            escape_next = False
-            
-            while j < len(cleaned_text) and brace_count > 0:
-                if escape_next:
-                    escape_next = False
-                elif cleaned_text[j] == '\\':
-                    escape_next = True
-                elif cleaned_text[j] == '"' and not escape_next:
-                    in_string = not in_string
-                elif not in_string:
-                    if cleaned_text[j] == '{':
-                        brace_count += 1
-                    elif cleaned_text[j] == '}':
-                        brace_count -= 1
-                j += 1
-            
-            if brace_count == 0:
-                # 找到了完整的 JSON 对象
-                json_str = cleaned_text[i:j]
-                try:
-                    parsed = json.loads(json_str)
-                    if "tool_calls" in parsed:
-                        # 这是一个工具调用，跳过它
-                        i = j
-                        continue
-                except:
-                    pass
-            
-            # 不是工具调用或无法解析，保留这个字符
-            result.append(cleaned_text[i])
-            i += 1
-        else:
-            result.append(cleaned_text[i])
-            i += 1
-    
-    return ''.join(result).strip()
-
-# 测试用例
-test_cases = [
-    # 测试案例 1: 只有工具调用JSON，应该被完全删除
-    {
-        "name": "纯工具调用JSON",
-        "input": """{"tool_calls": [{"id": "call_1", "type": "function", "function": {"name": "test", "arguments": "{}"}}]}""",
-        "expected": ""
-    },
-    
-    # 测试案例 2: 包含工具调用的 JSON 代码块
-    {
-        "name": "代码块中的工具调用",
-        "input": """这是一些正常的文本内容。
-
-```json
-{
-  "tool_calls": [
-    {
-      "id": "call_123",
-      "type": "function",
-      "function": {
-        "name": "test_function",
-        "arguments": "{\\"param\\": \\"value\\"}"
-      }
-    }
-  ]
-}
-```
-
-这部分内容应该被保留。""",
-        "expected": """这是一些正常的文本内容。
-
-
-
-这部分内容应该被保留。"""
-    },
-    
-    # 测试案例 3: 混合内容
-    {
-        "name": "混合内容",
-        "input": """让我为您执行一个函数调用：
-
-{"tool_calls": [{"id": "call_789", "type": "function", "function": {"name": "search", "arguments": "{\\"query\\": \\"test\\"}"}}]}
-
-函数执行结果如下：
-- 找到了相关内容
-- 处理完成
-
-这里还有其他重要信息需要保留。""",
-        "expected": """让我为您执行一个函数调用：
-
-
-
-函数执行结果如下：
-- 找到了相关内容
-- 处理完成
-
-这里还有其他重要信息需要保留。"""
-    },
-    
-    # 测试案例 4: 不应该被删除的普通 JSON
-    {
-        "name": "普通JSON（应保留）",
-        "input": """这是一个普通的 JSON 示例：
-{"data": {"result": "success"}}
-
-这不是工具调用，应该保留。""",
-        "expected": """这是一个普通的 JSON 示例：
-{"data": {"result": "success"}}
-
-这不是工具调用，应该保留。"""
-    },
-    
-    # 测试案例 5: 嵌套的复杂JSON
-    {
-        "name": "嵌套复杂JSON",
-        "input": """开始文本
-{"tool_calls": [{"id": "call_1", "function": {"name": "test", "arguments": "{\\"nested\\": {\\"deep\\": \\"value\\"}}"}}]}
-中间文本
-{"normal": {"data": "keep this"}}
-结束文本""",
-        "expected": """开始文本
-
-中间文本
-{"normal": {"data": "keep this"}}
-结束文本"""
-    }
-]
-
-def run_tests():
-    print("=" * 80)
-    print("测试正则表达式处理")
-    print("=" * 80)
-    
-    passed = 0
-    failed = 0
-    
-    for test_case in test_cases:
-        print(f"\n测试案例: {test_case['name']}")
-        print("-" * 40)
-        print("输入文本:")
-        print(repr(test_case['input']))
-        
-        print("\n使用原始函数处理后:")
-        result_old = remove_tool_json_content_old(test_case['input'])
-        print(repr(result_old))
-        
-        print("\n使用改进函数处理后:")
-        result_new = remove_tool_json_content_new(test_case['input'])
-        print(repr(result_new))
-        
-        print("\n期望结果:")
-        print(repr(test_case['expected']))
-        
-        # 检查新函数是否正确
-        if result_new == test_case['expected']:
-            print("[PASS] 新函数通过测试")
-            passed += 1
-        else:
-            print("[FAIL] 新函数测试失败")
-            failed += 1
-        
-        print("-" * 40)
-    
-    print(f"\n\n总结: {passed} 个通过, {failed} 个失败")
-
-if __name__ == "__main__":
-    run_tests()

tests/test_tool_call.py

@@ -1,145 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-测试工具调用功能
-"""
-
-import json
-import requests
-
-# 配置
-BASE_URL = "http://localhost:8080"
-API_KEY = "your-api-key"  # 替换为实际的 API key
-
-def test_tool_call():
-    """测试工具调用功能"""
-    
-    # 定义一个简单的工具
-    tools = [
-        {
-            "type": "function",
-            "function": {
-                "name": "get_weather",
-                "description": "获取指定城市的天气信息",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "location": {
-                            "type": "string",
-                            "description": "城市名称，例如：北京、上海"
-                        },
-                        "unit": {
-                            "type": "string",
-                            "description": "温度单位",
-                            "enum": ["celsius", "fahrenheit"]
-                        }
-                    },
-                    "required": ["location"]
-                }
-            }
-        }
-    ]
-    
-    # 构建请求
-    request_data = {
-        "model": "GLM-4.5",
-        "messages": [
-            {
-                "role": "user",
-                "content": "北京的天气怎么样？"
-            }
-        ],
-        "tools": tools,
-        "tool_choice": "auto",
-        "stream": False
-    }
-    
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {API_KEY}"
-    }
-    
-    print("=" * 60)
-    print("测试工具调用 (非流式)")
-    print("=" * 60)
-    
-    # 发送请求
-    response = requests.post(
-        f"{BASE_URL}/v1/chat/completions",
-        json=request_data,
-        headers=headers
-    )
-    
-    print(f"状态码: {response.status_code}")
-    
-    if response.status_code == 200:
-        result = response.json()
-        print("\n响应内容:")
-        print(json.dumps(result, ensure_ascii=False, indent=2))
-        
-        # 检查是否有工具调用
-        if result.get("choices"):
-            choice = result["choices"][0]
-            if choice.get("message", {}).get("tool_calls"):
-                print("\n✅ 检测到工具调用!")
-                for tc in choice["message"]["tool_calls"]:
-                    print(f"  - 函数: {tc.get('function', {}).get('name')}")
-                    print(f"    参数: {tc.get('function', {}).get('arguments')}")
-            else:
-                print("\n⚠️ 未检测到工具调用")
-                if choice.get("message", {}).get("content"):
-                    print(f"内容: {choice['message']['content'][:200]}")
-    else:
-        print(f"\n错误响应: {response.text}")
-    
-    # 测试流式响应
-    print("\n" + "=" * 60)
-    print("测试工具调用 (流式)")
-    print("=" * 60)
-    
-    request_data["stream"] = True
-    
-    response = requests.post(
-        f"{BASE_URL}/v1/chat/completions",
-        json=request_data,
-        headers=headers,
-        stream=True
-    )
-    
-    print(f"状态码: {response.status_code}")
-    
-    if response.status_code == 200:
-        print("\n流式响应:")
-        tool_calls_detected = False
-        
-        for line in response.iter_lines():
-            if line:
-                line_str = line.decode('utf-8')
-                if line_str.startswith("data: "):
-                    data = line_str[6:]
-                    if data == "[DONE]":
-                        print("流结束")
-                        break
-                    
-                    try:
-                        chunk = json.loads(data)
-                        if chunk.get("choices"):
-                            delta = chunk["choices"][0].get("delta", {})
-                            if delta.get("tool_calls"):
-                                tool_calls_detected = True
-                                print(f"检测到工具调用: {json.dumps(delta['tool_calls'], ensure_ascii=False)}")
-                            elif delta.get("content"):
-                                print(f"内容: {delta['content']}", end="")
-                    except json.JSONDecodeError:
-                        pass
-        
-        if tool_calls_detected:
-            print("\n\n✅ 流式响应中检测到工具调用!")
-        else:
-            print("\n\n⚠️ 流式响应中未检测到工具调用")
-    else:
-        print(f"\n错误响应: {response.text}")
-
-
-if __name__ == "__main__":
-    test_tool_call()

tests/test_tool_call_fix.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+测试工具调用
+"""
+
+import json
+import urllib.request
+import urllib.parse
+from typing import Dict, Any
+
+def test_tool_call():
+    """测试工具调用功能"""
+
+    # 测试请求
+    test_request = {
+        "model": "glm-4.5",
+        "messages": [
+            {
+                "role": "user",
+                "content": "请打开Google网站"
+            }
+        ],
+        "tools": [
+            {
+                "type": "function",
+                "function": {
+                    "name": "playwri-browser_navigate",
+                    "description": "Navigate to a URL in the browser",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "url": {
+                                "type": "string",
+                                "description": "The URL to navigate to"
+                            }
+                        },
+                        "required": ["url"]
+                    }
+                }
+            }
+        ],
+        "stream": True
+    }
+
+    print("🚀 发送工具调用测试请求...")
+    print(f"📦 请求内容: {json.dumps(test_request, ensure_ascii=False, indent=2)}")
+
+    # 准备HTTP请求
+    url = "http://localhost:8080/v1/chat/completions"
+    data = json.dumps(test_request).encode('utf-8')
+
+    req = urllib.request.Request(url, data=data)
+    req.add_header('Content-Type', 'application/json')
+    req.add_header('Authorization', 'Bearer sk-test-key')
+
+    try:
+        with urllib.request.urlopen(req) as response:
+            print(f"📈 响应状态: {response.status}")
+
+            if response.status == 200:
+                print("✅ 开始接收流式响应...")
+
+                tool_calls_found = []
+                chunk_count = 0
+
+                for line in response:
+                    line = line.decode('utf-8').strip()
+                    if line.startswith('data: '):
+                        chunk_count += 1
+                        data_str = line[6:]  # 去掉 'data: ' 前缀
+
+                        if data_str == '[DONE]':
+                            print("🏁 接收到结束信号")
+                            break
+
+                        try:
+                            chunk = json.loads(data_str)
+
+                            # 检查是否包含工具调用
+                            if 'choices' in chunk and chunk['choices']:
+                                choice = chunk['choices'][0]
+                                if 'delta' in choice and 'tool_calls' in choice['delta']:
+                                    tool_calls = choice['delta']['tool_calls']
+                                    if tool_calls:
+                                        for tool_call in tool_calls:
+                                            print(f"🔧 发现工具调用: {json.dumps(tool_call, ensure_ascii=False, indent=2)}")
+                                            tool_calls_found.append(tool_call)
+
+                                # 检查完成原因
+                                if choice.get('finish_reason') == 'tool_calls':
+                                    print("✅ 工具调用完成")
+
+                        except json.JSONDecodeError as e:
+                            print(f"❌ JSON解析错误: {e}, 数据: {data_str[:200]}")
+
+                print(f"📊 总共接收到 {chunk_count} 个数据块")
+                print(f"🔧 发现 {len(tool_calls_found)} 个工具调用")
+
+                # 分析工具调用格式
+                for i, tool_call in enumerate(tool_calls_found):
+                    print(f"\n🔍 工具调用 {i+1} 分析:")
+                    print(f"  ID: {tool_call.get('id', 'N/A')}")
+                    print(f"  类型: {tool_call.get('type', 'N/A')}")
+
+                    if 'function' in tool_call:
+                        func = tool_call['function']
+                        print(f"  函数名: {func.get('name', 'N/A')}")
+
+                        arguments = func.get('arguments', '')
+                        print(f"  参数类型: {type(arguments)}")
+                        print(f"  参数内容: {arguments}")
+
+                        # 尝试解析参数
+                        if isinstance(arguments, str) and arguments:
+                            try:
+                                parsed_args = json.loads(arguments)
+                                print(f"  ✅ 参数解析成功: {parsed_args}")
+                            except json.JSONDecodeError as e:
+                                print(f"  ❌ 参数解析失败: {e}")
+                        elif isinstance(arguments, dict):
+                            print(f"  ⚠️  参数是对象格式（应该是字符串）: {arguments}")
+
+            else:
+                error_text = response.read().decode('utf-8')
+                print(f"❌ 请求失败: {error_text}")
+
+    except Exception as e:
+        print(f"❌ 请求异常: {e}")
+
+if __name__ == "__main__":
+    test_tool_call()

tokens.txt.example

@@ -0,0 +1,25 @@
+# 认证Token配置文件
+#
+# 说明：
+# 1. 支持两种格式：每行一个token 或 逗号分隔的token
+# 2. 只包含认证用户token (role: "user")，不要添加匿名用户token (role: "guest")
+# 3. 系统会自动去重和验证token有效性
+# 4. 修改此文件后无需重启服务，系统会自动重新加载
+# 5. 自动跳过空格、换行符和空token
+#
+# 格式1：纯换行分隔
+# token1
+# token2  
+# token3
+
+# 格式2：纯逗号分隔
+# token1,token2,token3
+
+# 格式3：混合格式
+# token1,token2
+# token3
+# token4,token5,token6
+# token7
+
+# 请在下方添加您的认证用户token（使用任一格式）：
+