feat(core): 重构配置模块并添加新功能

- 重构了配置模块，简化了结构并提高了可维护性
- 添加了新的配置项，如备用访问令牌和思考内容处理策略
- 移除了与 token 池相关的配置和功能
- 更新了环境变量示例和文档说明

.env.example

@@ -2,41 +2,36 @@
 # 复制此文件为 .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
 
-# ========== 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
+# Z.ai 备用访问令牌（当匿名模式失败时使用）
+# 注意：这是用于访问 Z.ai 服务的令牌，不是客户端认证密钥
+BACKUP_TOKEN=eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjMxNmJjYjQ4LWZmMmYtNGExNS04NTNkLWYyYTI5YjY3ZmYwZiIsImVtYWlsIjoiR3Vlc3QtMTc1NTg0ODU4ODc4OEBndWVzdC5jb20ifQ.PktllDySS3trlyuFpTeIZf-7hl8Qu1qYF3BxjgIul0BrNux2nX9hVzIjthLXKMWAf9V0qM8Vm_iyDqkjPGsaiQ
 
 # ========== 服务器配置 ==========
 # 服务监听端口
 LISTEN_PORT=8080
 
-# 服务名称（用于进程唯一性验证）
-SERVICE_NAME=z-ai2api-server
-
-# 调试日志
+# 调试日志开关
 DEBUG_LOGGING=true
 
-# 匿名用户模式
-# false: 使用认证用户令牌
+# ========== 功能配置 ==========
+# 思考内容处理策略
+# think: 转换为 <span> 标签（OpenAI 兼容）
+# strip: 移除思考内容
+# raw: 保留原始格式
+THINKING_PROCESSING=think
+
+# 匿名模式开关（推荐启用）
 # true: 自动从 Z.ai 获取临时访问令牌，避免对话历史共享
+# false: 使用固定令牌 BACKUP_TOKEN
 ANONYMOUS_MODE=true
 
 # Function Call 功能开关
@@ -44,10 +39,3 @@ TOOL_SUPPORT=true
 
 # 工具调用扫描限制（字符数）
 SCAN_LIMIT=200000
-
-# ========== 错误码400处理 ==========
-
-# 重试次数
-MAX_RETRIES=6
-# 初始重试延迟
-RETRY_DELAY=1

.github/workflows/docker-build-push.yml

@@ -0,0 +1,73 @@
+name: Build and Push Docker Image
+
+on:
+  # Trigger on push to main branch
+  push:
+    branches:
+      - main
+      - master
+    tags:
+      - 'v*'
+  
+  # Allow manual trigger
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: 'Docker image tag'
+        required: false
+        default: 'latest'
+
+env:
+  REGISTRY: docker.io
+  IMAGE_NAME: julienol/z-ai2api-python
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+      
+    - name: Log in to Docker Hub
+      uses: docker/login-action@v3
+      with:
+        username: ${{ secrets.DOCKER_USERNAME }}
+        password: ${{ secrets.DOCKER_PASSWORD }}
+    
+    - name: Extract metadata
+      id: meta
+      uses: docker/metadata-action@v5
+      with:
+        images: ${{ env.IMAGE_NAME }}
+        tags: |
+          type=ref,event=branch
+          type=ref,event=pr
+          type=semver,pattern={{version}}
+          type=semver,pattern={{major}}.{{minor}}
+          type=semver,pattern={{major}}
+          type=raw,value=latest,enable={{is_default_branch}}
+          type=raw,value=${{ github.event.inputs.tag }},enable=${{ github.event_name == 'workflow_dispatch' }}
+    
+    - name: Build and push Docker image
+      uses: docker/build-push-action@v5
+      with:
+        context: .
+        file: ./Dockerfile
+        push: true
+        tags: ${{ steps.meta.outputs.tags }}
+        labels: ${{ steps.meta.outputs.labels }}
+        platforms: linux/amd64,linux/arm64
+        cache-from: type=gha
+        cache-to: type=gha,mode=max
+        
+    - name: Update Docker Hub description
+      uses: peter-evans/dockerhub-description@v4
+      with:
+        username: ${{ secrets.DOCKER_USERNAME }}
+        password: ${{ secrets.DOCKER_PASSWORD }}
+        repository: ${{ env.IMAGE_NAME }}
+        readme-filepath: ./README.md

.gitignore

@@ -5,7 +5,6 @@
 .conda/
 *.zip
 *.txt
-*.pid
 docs/
 output/
 main.build/
@@ -14,8 +13,6 @@ main.onefile-build/
 *report.xml
 *.yaml
 logs/
-backup/
-uv.lock
 
 # AI Toolset
 .augment/

Dockerfile

@@ -0,0 +1,46 @@
+# Use Python 3.12 slim image for better performance and smaller size
+FROM python:3.12-slim
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1
+
+# Set work directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends curl && \
+    rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies with Brotli support
+RUN pip install --no-cache-dir -r requirements.txt && \
+    pip install --no-cache-dir brotli
+
+# Copy application code
+COPY . .
+
+# Create non-root user for security
+RUN useradd --create-home --shell /bin/bash app && \
+    chown -R app:app /app
+
+# Create tokens directory and set permissions
+RUN mkdir -p /app/data && \
+    chown -R app:app /app/data
+
+USER app
+
+# Expose port
+EXPOSE 8080
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8080/ || exit 1
+
+# Run the application
+CMD ["python", "main.py"]

README.md

@@ -1,34 +1,30 @@
 # Z.AI OpenAI API 代理服务
 
 ![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)
-![Python: 3.9-3.12](https://img.shields.io/badge/python-3.9--3.12-green.svg)
+![Python: 3.8+](https://img.shields.io/badge/python-3.8+-green.svg)
 ![FastAPI](https://img.shields.io/badge/framework-FastAPI-009688.svg)
-![Version: 0.1.0](https://img.shields.io/badge/version-0.1.0-brightgreen.svg)
+![Version: 1.2.0](https://img.shields.io/badge/version-1.2.0-brightgreen.svg)
 
-> 🎯 **项目愿景**：提供完全兼容 OpenAI API 的 Z.AI 代理服务，让用户无需修改现有代码即可接入 GLM-4.5 系列模型。
-
-轻量级、高性能的 OpenAI API 兼容代理服务，通过 Claude Code Router 接入 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 实现
 - 🧠 **思考模式支持** - 智能处理模型推理过程
-- 🐳 **Docker 部署** - 一键容器化部署(环境变量请参考`.env.example`)
+- 🔍 **搜索模型集成** - GLM-4.5-Search 网络搜索能力
+- 🐳 **Docker 部署** - 一键容器化部署
 - 🛡️ **会话隔离** - 匿名模式保护隐私
 - 🔧 **灵活配置** - 环境变量灵活配置
 - 📊 **多模型映射** - 智能上游模型路由
-- 🔄 **Token 池管理** - 自动轮询、容错恢复、动态更新
-- 🛡️ **错误处理** - 完善的异常捕获和重试机制
-- 🔒 **服务唯一性** - 基于进程名称(pname)的服务唯一性验证，防止重复启动
 
 ## 🚀 快速开始
 
 ### 环境要求
 
-- Python 3.9-3.12
+- Python 3.8+
 - pip 或 uv (推荐)
 
 ### 安装运行
@@ -48,9 +44,7 @@ pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
 python main.py
 ```
 
->  服务启动后访问接口文档：http://localhost:8080/docs  
-> 💡 **提示**：默认端口为 8080，可通过环境变量 `LISTEN_PORT` 修改  
-> ⚠️ **注意**：请勿将 `AUTH_TOKEN` 泄露给其他人，请使用 `AUTH_TOKENS` 配置多个认证令牌  
+服务启动后访问：http://localhost:8080/docs
 
 ### 基础使用
 
@@ -148,51 +142,21 @@ 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`                                    | 调试日志开关           |
-| `ANONYMOUS_MODE`      | `true`                                    | 匿名用户模式开关           |
+| `THINKING_PROCESSING` | `think`                                   | 思考内容处理策略       |
+| `ANONYMOUS_MODE`      | `true`                                    | 匿名模式开关           |
 | `TOOL_SUPPORT`        | `true`                                    | Function Call 功能开关 |
 | `SKIP_AUTH_TOKEN`     | `false`                                   | 跳过认证令牌验证       |
 | `SCAN_LIMIT`          | `200000`                                  | 扫描限制               |
-| `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配置方式
+| `BACKUP_TOKEN`        | `eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9...` | Z.ai 固定访问令牌      |
 
-创建 `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"]'
-```
-
-详细文档请参考：[Token池功能说明](TOKEN_POOL_README.md)
+- `think` - 转换为 `<thinking>` 标签（OpenAI 兼容）
+- `strip` - 移除思考内容
+- `raw` - 保留原始格式
 
 ## 🎯 使用场景
 
@@ -239,19 +203,6 @@ 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: 启动时提示"服务已在运行"怎么办？**
-A: 这是服务唯一性验证功能，防止重复启动。解决方法：
-- 检查是否已有服务实例在运行：`ps aux | grep z-ai2api-server`
-- 停止现有实例后再启动新的
-- 如果确认没有实例运行，删除 PID 文件：`rm z-ai2api-server.pid`
-- 可通过环境变量 `SERVICE_NAME` 自定义服务名称避免冲突
-
 **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` 进行认证。
@@ -336,25 +287,32 @@ 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 值设置为环境变量
 
-> ❗ **重要提示**: 获取的 token 可能有时效性，多模态模型需要**官方 Z.ai API 非匿名 Token**，匿名 token 不支持多媒体处理  
+> ⚠️ **注意**: 方式 2 获取的 token 可能有时效性，建议使用方式 1 获取长期有效的 API Token。  
+> ❗ **重要提示**: 多模态模型需要**官方 Z.ai API 非匿名 Token**，匿名 token 不支持多媒体处理。
 
 ## 🛠️ 技术栈
 
 | 组件            | 技术                                                                              | 版本    | 说明                                       |
 | --------------- | --------------------------------------------------------------------------------- | ------- | ------------------------------------------ |
-| **Web 框架**    | [FastAPI](https://fastapi.tiangolo.com/)                                          | 0.116.1 | 高性能异步 Web 框架，支持自动 API 文档生成 |
+| **Web 框架**    | [FastAPI](https://fastapi.tiangolo.com/)                                          | 0.104.1 | 高性能异步 Web 框架，支持自动 API 文档生成 |
 | **ASGI 服务器** | [Granian](https://github.com/emmett-framework/granian)                            | 2.5.2   | 基于 Rust 的高性能 ASGI 服务器，支持热重载 |
-| **HTTP 客户端** | [HTTPX](https://www.python-httpx.org/) / [Requests](https://requests.readthedocs.io/) | 0.27.0 / 2.32.5 | 异步/同步 HTTP 库，用于上游 API 调用      |
+| **HTTP 客户端** | [Requests](https://requests.readthedocs.io/)                                      | 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   | 动态用户代理生成                           |
 
 ## 🏗️ 技术架构
 
@@ -380,36 +338,29 @@ A: 通过环境变量配置，推荐使用 `.env` 文件。
 
 ```
 z.ai2api_python/
-├── 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                 # 环境变量示例
+├── 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                  # 项目文档
 ```
 
-## ⭐ Star History
-
-If you like this project, please give it a star ⭐  
-
-[![Star History Chart](https://api.star-history.com/svg?repos=ZyphrZero/z.ai2api_python&type=Date)](https://star-history.com/#ZyphrZero/z.ai2api_python&Date)
-
-
 ## 🤝 贡献指南
 
 我们欢迎所有形式的贡献！

app/__init__.py

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

app/core/__init__.py

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

app/core/config.py

@@ -1,125 +1,37 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
+"""
+FastAPI application configuration module
+"""
 
 import os
-from typing import Dict, List, Optional
+from typing import Dict, Optional
 from pydantic_settings import BaseSettings
-from app.utils.logger import logger
 
 
 class Settings(BaseSettings):
     """Application settings"""
-
+    
     # API Configuration
-    API_ENDPOINT: str = "https://chat.z.ai/api/chat/completions"
+    API_ENDPOINT: str = os.getenv("API_ENDPOINT", "https://chat.z.ai/api/chat/completions")
     AUTH_TOKEN: str = os.getenv("AUTH_TOKEN", "sk-your-api-key")
-
-    # 认证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 []
-
+    BACKUP_TOKEN: str = os.getenv("BACKUP_TOKEN", "eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjMxNmJjYjQ4LWZmMmYtNGExNS04NTNkLWYyYTI5YjY3ZmYwZiIsImVtYWlsIjoiR3Vlc3QtMTc1NTg0ODU4ODc4OEBndWVzdC5jb20ifQ.PktllDySS3trlyuFpTeIZf-7hl8Qu1qYF3BxjgIul0BrNux2nX9hVzIjthLXKMWAf9V0qM8Vm_iyDqkjPGsaiQ")
+    
     # 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"
-    SERVICE_NAME: str = os.getenv("SERVICE_NAME", "z-ai2api-server")
-
+    
+    # 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",
@@ -132,9 +44,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,29 +1,24 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
+"""
+OpenAI API endpoints
+"""
 
 import time
-import json
-import asyncio
 from datetime import datetime
-from typing import List, Dict, Any
+from typing import List
 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, 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()
+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
 
 router = APIRouter()
 
-# 全局转换器实例
-transformer = ZAITransformer()
-
 
 @router.get("/v1/models")
 async def list_models():
@@ -31,564 +26,150 @@ 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 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}")
-
+async def chat_completions(
+    request: OpenAIRequest,
+    authorization: str = Header(...)
+):
+    """Handle chat completion requests"""
+    debug_log("收到chat completions请求")
+    
     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")
-
-        # 使用新的转换器转换请求
-        request_dict = request.model_dump()
-        logger.info("🔄 开始转换请求格式: OpenAI -> Z.AI")
+            
+            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)}")
         
-        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
-                            has_mcp_servers = bool(transformed["body"].get("mcp_servers"))
-                            tool_handler = None
-
-                            # 如果有工具定义或MCP服务器，都需要工具处理器
-                            if has_tools or has_mcp_servers:
-                                chat_id = transformed["body"]["chat_id"]
-                                model = request.model
-                                tool_handler = SSEToolHandler(chat_id, model)
-
-                                if has_tools and has_mcp_servers:
-                                    logger.info(f"🔧 初始化工具处理器: {len(transformed['body'].get('tools', []))} 个OpenAI工具 + {len(transformed['body'].get('mcp_servers', []))} 个MCP服务器")
-                                elif has_tools:
-                                    logger.info(f"🔧 初始化工具处理器: {len(transformed['body'].get('tools', []))} 个OpenAI工具")
-                                elif has_mcp_servers:
-                                    logger.info(f"🔧 初始化工具处理器: {len(transformed['body'].get('mcp_servers', []))} 个MCP服务器")
-
-                            # 处理状态
-                            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}")
-                                                        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 流式响应")
+        # Generate IDs
+        chat_id, msg_id = generate_request_ids()
         
-        # 创建一个包装的生成器来追踪数据流
-        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
+        # Process messages with tools
+        processed_messages = process_messages_with_tools(
+            [m.model_dump() for m in request.messages],
+            request.tools,
+            request.tool_choice
+        )
         
-        return StreamingResponse(
-            logged_stream(),
-            media_type="text/event-stream",
-            headers={
-                "Cache-Control": "no-cache",
-                "Connection": "keep-alive",
+        # 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")
+            ))
+        
+        # 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 ""
+        
+        # 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"
+        
+        # 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,
+            },
+            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:
-        logger.error(f"❌ 处理请求时发生错误: {str(e)}")
+        debug_log(f"处理请求时发生错误: {str(e)}")
         import traceback
-
-        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)}")
+        debug_log(f"错误堆栈: {traceback.format_exc()}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")

app/core/response_handlers.py

@@ -0,0 +1,333 @@
+"""
+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

@@ -1,730 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-import json
-import time
-import uuid
-import random
-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()
-            with httpx.Client() as client:
-                response = client.get("https://chat.z.ai/api/v1/auths/", 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 ""
-
-
-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}}": "Asia/Shanghai",  # 使用更合适的时区
-                "{{USER_LANGUAGE}}": "zh-CN",
-            },
-            "model_item": {
-                "id": upstream_model_id,
-                "name": requested_model,
-                "owned_by": "z.ai"
-            },
-            "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'])}")
-        tools_count = len(body.get('tools') or [])
-        logger.debug(f"    - 工具数量: {tools_count}")
-        
-    async def transform_response_out(
-        self, response_stream: Generator, context: Dict[str, Any]
-    ) -> AsyncGenerator[str, 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,6 +1,7 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
+"""
+Models module initialization
+"""
 
 from app.models import schemas
 
-__all__ = ["schemas"]
+__all__ = ["schemas"]

app/models/schemas.py

@@ -1,5 +1,6 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
+"""
+Application data models
+"""
 
 from typing import Dict, List, Optional, Any, Union, Literal
 from pydantic import BaseModel
@@ -53,8 +54,8 @@ class UpstreamRequest(BaseModel):
     chat_id: Optional[str] = None
     id: Optional[str] = None
     mcp_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
+    model_item: Optional[ModelItem] = None
+    tool_servers: Optional[List[str]] = None
     variables: Optional[Dict[str, str]] = None
     model_config = {"protected_namespaces": ()}
 

app/utils/__init__.py

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

app/utils/helpers.py

@@ -0,0 +1,211 @@
+"""
+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

@@ -1,104 +0,0 @@
-#!/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/process_manager.py

@@ -1,303 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-"""
-进程管理模块
-提供服务唯一性验证和进程管理功能
-"""
-
-import os
-import sys
-import time
-import psutil
-from typing import Optional, List
-from pathlib import Path
-
-from app.utils.logger import get_logger
-
-logger = get_logger()
-
-
-class ProcessManager:
-    """进程管理器 - 负责服务唯一性验证和进程管理"""
-    
-    def __init__(self, service_name: str = "z-ai2api-server", port: int = 8080):
-        """
-        初始化进程管理器
-        
-        Args:
-            service_name: 服务名称，用于进程名称标识
-            port: 服务端口，用于唯一性检查
-        """
-        self.service_name = service_name
-        self.port = port
-        self.current_pid = os.getpid()
-        self.pid_file = Path(f"{service_name}.pid")
-        
-    def check_service_uniqueness(self) -> bool:
-        """
-        检查服务唯一性
-
-        通过以下方式验证：
-        1. 检查 PID 文件
-        2. 检查端口是否被占用
-        3. 检查进程名称 (pname) 是否已存在（可选）
-
-        Returns:
-            bool: True 表示可以启动服务，False 表示已有实例运行
-        """
-        logger.info(f"🔍 检查服务唯一性: {self.service_name} (端口: {self.port})")
-
-        # 1. 优先检查 PID 文件（最可靠）
-        if self._check_pid_file():
-            return False
-
-        # 2. 检查端口占用
-        if self._check_port_usage():
-            return False
-
-        # 3. 检查进程名称（作为额外保障）
-        if self._check_process_by_name():
-            return False
-
-        logger.info("✅ 服务唯一性检查通过，可以启动服务")
-        return True
-    
-    def _check_process_by_name(self) -> bool:
-        """
-        通过进程名称检查是否已有实例运行
-
-        这是一个保守的检查，只检查明确的服务进程标识
-
-        Returns:
-            bool: True 表示发现同名进程，False 表示未发现
-        """
-        try:
-            running_processes = []
-
-            for proc in psutil.process_iter(['pid', 'name', 'cmdline']):
-                try:
-                    proc_info = proc.info
-
-                    # 跳过当前进程
-                    if proc_info['pid'] == self.current_pid:
-                        continue
-
-                    # 只检查进程名称直接匹配服务名称的情况
-                    # 这通常发生在使用 Granian 的 process_name 参数时
-                    if proc_info['name'] and proc_info['name'] == self.service_name:
-                        running_processes.append(proc_info)
-                        continue
-
-                    # 检查命令行参数中是否包含明确的服务标识
-                    cmdline = proc_info.get('cmdline', [])
-                    if cmdline and len(cmdline) >= 2:
-                        cmdline_str = ' '.join(cmdline)
-
-                        # 只检查通过 Granian 启动且明确指定了进程名称的服务
-                        if (f'--process-name={self.service_name}' in cmdline_str or
-                            f'process_name={self.service_name}' in cmdline_str):
-                            running_processes.append(proc_info)
-
-                except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
-                    # 进程可能已经结束或无权限访问
-                    continue
-
-            if running_processes:
-                logger.warning(f"⚠️ 发现 {len(running_processes)} 个同名进程正在运行:")
-                for proc_info in running_processes:
-                    cmdline = proc_info.get('cmdline', [])
-                    cmdline_preview = ' '.join(cmdline[:3]) + '...' if len(cmdline) > 3 else ' '.join(cmdline)
-                    logger.warning(f"   PID: {proc_info['pid']}, 名称: {proc_info['name']}, 命令: {cmdline_preview}")
-                logger.warning(f"❌ 服务 {self.service_name} 已在运行，请先停止现有实例")
-                return True
-
-            return False
-
-        except Exception as e:
-            logger.error(f"❌ 检查进程名称时发生错误: {e}")
-            return False
-    
-    def _check_port_usage(self) -> bool:
-        """
-        检查端口是否被占用
-        
-        Returns:
-            bool: True 表示端口被占用，False 表示端口可用
-        """
-        try:
-            # 获取所有网络连接
-            connections = psutil.net_connections(kind='inet')
-            
-            for conn in connections:
-                if (conn.laddr.port == self.port and 
-                    conn.status in [psutil.CONN_LISTEN, psutil.CONN_ESTABLISHED]):
-                    
-                    # 尝试获取占用端口的进程信息
-                    try:
-                        proc = psutil.Process(conn.pid) if conn.pid else None
-                        proc_name = proc.name() if proc else "未知进程"
-                        logger.warning(f"⚠️ 端口 {self.port} 已被占用")
-                        logger.warning(f"   占用进程: PID {conn.pid}, 名称: {proc_name}")
-                        logger.warning(f"❌ 无法启动服务，端口 {self.port} 不可用")
-                        return True
-                    except (psutil.NoSuchProcess, psutil.AccessDenied):
-                        logger.warning(f"⚠️ 端口 {self.port} 已被占用（无法获取进程信息）")
-                        return True
-            
-            return False
-            
-        except Exception as e:
-            logger.error(f"❌ 检查端口占用时发生错误: {e}")
-            return False
-    
-    def _check_pid_file(self) -> bool:
-        """
-        检查 PID 文件
-        
-        Returns:
-            bool: True 表示发现有效的 PID 文件，False 表示无冲突
-        """
-        try:
-            if not self.pid_file.exists():
-                return False
-            
-            # 读取 PID 文件
-            pid_content = self.pid_file.read_text().strip()
-            if not pid_content.isdigit():
-                logger.warning(f"⚠️ PID 文件格式无效: {self.pid_file}")
-                self._cleanup_pid_file()
-                return False
-            
-            old_pid = int(pid_content)
-            
-            # 检查进程是否仍在运行
-            try:
-                proc = psutil.Process(old_pid)
-                if proc.is_running():
-                    logger.warning(f"⚠️ 发现有效的 PID 文件: {self.pid_file}")
-                    logger.warning(f"   进程 PID {old_pid} 仍在运行: {proc.name()}")
-                    logger.warning(f"❌ 服务可能已在运行，请检查进程或删除 PID 文件")
-                    return True
-                else:
-                    logger.info(f"🧹 清理无效的 PID 文件: {self.pid_file}")
-                    self._cleanup_pid_file()
-                    return False
-            except psutil.NoSuchProcess:
-                logger.info(f"🧹 清理过期的 PID 文件: {self.pid_file}")
-                self._cleanup_pid_file()
-                return False
-                
-        except Exception as e:
-            logger.error(f"❌ 检查 PID 文件时发生错误: {e}")
-            return False
-    
-    def _cleanup_pid_file(self):
-        """清理 PID 文件"""
-        try:
-            if self.pid_file.exists():
-                self.pid_file.unlink()
-                logger.debug(f"🧹 已删除 PID 文件: {self.pid_file}")
-        except Exception as e:
-            logger.error(f"❌ 删除 PID 文件失败: {e}")
-    
-    def create_pid_file(self):
-        """创建 PID 文件"""
-        try:
-            self.pid_file.write_text(str(self.current_pid))
-            logger.info(f"📝 创建 PID 文件: {self.pid_file} (PID: {self.current_pid})")
-        except Exception as e:
-            logger.error(f"❌ 创建 PID 文件失败: {e}")
-    
-    def cleanup_on_exit(self):
-        """退出时清理资源"""
-        logger.info(f"🧹 清理进程资源 (PID: {self.current_pid})")
-        self._cleanup_pid_file()
-    
-    def get_running_instances(self) -> List[dict]:
-        """
-        获取所有运行中的服务实例
-
-        Returns:
-            List[dict]: 运行中的实例信息列表
-        """
-        instances = []
-
-        try:
-            for proc in psutil.process_iter(['pid', 'name', 'cmdline', 'create_time']):
-                try:
-                    proc_info = proc.info
-
-                    # 跳过当前进程
-                    if proc_info['pid'] == self.current_pid:
-                        continue
-
-                    # 使用与 _check_process_by_name 相同的保守逻辑
-                    is_service = False
-
-                    # 只检查进程名称直接匹配服务名称的情况
-                    if proc_info['name'] and proc_info['name'] == self.service_name:
-                        is_service = True
-
-                    # 检查命令行参数中是否包含明确的服务标识
-                    cmdline = proc_info.get('cmdline', [])
-                    if cmdline and len(cmdline) >= 2:
-                        cmdline_str = ' '.join(cmdline)
-
-                        # 只检查通过 Granian 启动且明确指定了进程名称的服务
-                        if (f'--process-name={self.service_name}' in cmdline_str or
-                            f'process_name={self.service_name}' in cmdline_str):
-                            is_service = True
-
-                    if is_service:
-                        instances.append({
-                            'pid': proc_info['pid'],
-                            'name': proc_info['name'],
-                            'cmdline': cmdline,
-                            'create_time': proc_info['create_time'],
-                            'start_time': time.strftime('%Y-%m-%d %H:%M:%S',
-                                                      time.localtime(proc_info['create_time']))
-                        })
-
-                except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
-                    continue
-
-        except Exception as e:
-            logger.error(f"❌ 获取运行实例时发生错误: {e}")
-
-        return instances
-
-
-def ensure_service_uniqueness(service_name: str = "z-ai2api-server", port: int = 8080) -> bool:
-    """
-    确保服务唯一性的便捷函数
-    
-    Args:
-        service_name: 服务名称
-        port: 服务端口
-        
-    Returns:
-        bool: True 表示可以启动，False 表示应该退出
-    """
-    manager = ProcessManager(service_name, port)
-    
-    if not manager.check_service_uniqueness():
-        logger.error("❌ 服务唯一性检查失败，程序退出")
-        
-        # 显示运行中的实例
-        instances = manager.get_running_instances()
-        if instances:
-            logger.info("📋 当前运行的实例:")
-            for instance in instances:
-                logger.info(f"   PID: {instance['pid']}, 启动时间: {instance['start_time']}")
-        
-        return False
-    
-    # 创建 PID 文件
-    manager.create_pid_file()
-    
-    # 注册退出清理
-    import atexit
-    atexit.register(manager.cleanup_on_exit)
-    
-    return True

app/utils/reload_config.py

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

app/utils/sse_parser.py

@@ -0,0 +1,127 @@
+"""
+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

@@ -1,694 +0,0 @@
-#!/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

@@ -1,453 +0,0 @@
-#!/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
-
-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

@@ -0,0 +1,325 @@
+"""
+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/Dockerfile

@@ -5,6 +5,6 @@ WORKDIR /app
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-COPY .. .
+COPY . .
 
 CMD ["python", "main.py"]

deploy/docker-compose.yml

@@ -2,19 +2,19 @@ version: '3.8'
 
 services:
   api-server:
-    build: 
-      context: ..
-      dockerfile: deploy/Dockerfile
+    image: julienol/z-ai2api-python:latest
     container_name: z-ai-api-server
     ports:
-      - "8080:8080"
+      - "8084:8080"
     environment:
       # Auth Configuration
-      - AUTH_TOKEN=sk-your-api-key
+      - AUTH_TOKEN=sk-123456
       # 是否跳过api key验证
       - SKIP_AUTH_TOKEN=false
       # Server Configurations
       - DEBUG_LOGGING=true
+      # Feature Configuration
+      - THINKING_PROCESSING=think
       - ANONYMOUS_MODE=true
       - TOOL_SUPPORT=true
       - SCAN_LIMIT=200000

docker-compose.yml

@@ -0,0 +1,31 @@
+version: '3.8'
+
+services:
+  z-ai2api:
+    image: julienol/z-ai2api-python:latest
+    container_name: z-ai2api-python
+    ports:
+      - "8084:8080"
+    env_file:
+      - .env
+    volumes:
+      # 挂载token文件（如果使用token池功能）
+      - ./tokens.txt:/app/tokens.txt:ro
+      # 可选：挂载数据目录用于持久化token状态
+      - ./data:/app/data
+    restart: unless-stopped
+    # 添加宿主机网络访问支持
+    # extra_hosts:
+    #   - "host.docker.internal:host-gateway"
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8080/"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+    networks:
+      - z-ai2api-network
+
+networks:
+  z-ai2api-network:
+    driver: bridge

main.py

@@ -1,44 +1,25 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-import os
-import sys
-import psutil
-from contextlib import asynccontextmanager
-from fastapi import FastAPI, Response
+"""
+Main application entry point
+"""
+
+from fastapi import FastAPI, Request, 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 app.utils.process_manager import ensure_service_uniqueness
 
 from granian import Granian
 
-
-# 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)
+# 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",
+)
 
 # Add CORS middleware
 app.add_middleware(
@@ -66,32 +47,14 @@ async def root():
 
 
 def run_server():
-    # 服务唯一性检查
-    service_name = settings.SERVICE_NAME
-    if not ensure_service_uniqueness(service_name=service_name, port=settings.LISTEN_PORT):
-        logger.error("❌ 服务已在运行，程序退出")
-        sys.exit(1)
-
-    logger.info(f"🚀 启动 {service_name} 服务...")
-    logger.info(f"📡 监听地址: 0.0.0.0:{settings.LISTEN_PORT}")
-    logger.info(f"🔧 调试模式: {'开启' if settings.DEBUG_LOGGING else '关闭'}")
-    logger.info(f"🔐 匿名模式: {'开启' if settings.ANONYMOUS_MODE else '关闭'}")
-
-    try:
-        Granian(
-            "main:app",
-            interface="asgi",
-            address="0.0.0.0",
-            port=settings.LISTEN_PORT,
-            reload=True,  # 生产环境请关闭热重载
-            process_name=service_name,  # 设置进程名称
-            **RELOAD_CONFIG,
-        ).serve()
-    except KeyboardInterrupt:
-        logger.info("🛑 收到中断信号，正在关闭服务...")
-    except Exception as e:
-        logger.error(f"❌ 服务启动失败: {e}")
-        sys.exit(1)
+    Granian(
+        "main:app",
+        interface="asgi",
+        address="0.0.0.0",
+        port=settings.LISTEN_PORT,
+        reload=False,   # 生产环境请关闭热重载
+        **RELOAD_CONFIG,
+    ).serve()
 
 
 if __name__ == "__main__":

pyproject.toml

@@ -24,16 +24,14 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
 ]
 dependencies = [
-    "fastapi==0.116.1",
-    "granian[reload,pname]==2.5.2",
-    "httpx==0.28.1",
+    "fastapi==0.104.1",
+    "granian[reload]==2.5.2",
+    "requests==2.32.5",
     "pydantic==2.11.7",
     "pydantic-settings==2.10.1",
     "pydantic-core==2.33.2",
     "typing-inspection==0.4.1",
     "fake-useragent==2.2.0",
-    "loguru==0.7.3",
-    "psutil>=7.0.0",
 ]
 
 [project.scripts]

requirements.txt

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

tests/test_comprehensive_tool_calls.py

@@ -1,254 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-"""
-全面的工具调用测试套件
-覆盖各种工具类型、参数格式、传输模式和边界情况
-"""
-
-import json
-import time
-from typing import Dict, Any, List
-from app.utils.sse_tool_handler import SSEToolHandler
-from app.utils.logger import get_logger
-
-logger = get_logger()
-
-class TestResult:
-    """测试结果统计"""
-    def __init__(self, test_name: str):
-        self.test_name = test_name
-        self.passed = 0
-        self.failed = 0
-        self.errors = []
-    
-    def add_pass(self):
-        self.passed += 1
-    
-    def add_fail(self, error_msg: str):
-        self.failed += 1
-        self.errors.append(error_msg)
-    
-    def print_summary(self):
-        total = self.passed + self.failed
-        success_rate = (self.passed / total * 100) if total > 0 else 0
-        
-        print(f"\n📊 {self.test_name} 测试汇总:")
-        print(f"  总测试数: {total}")
-        print(f"  ✅ 通过: {self.passed}")
-        print(f"  ❌ 失败: {self.failed}")
-        print(f"  📈 成功率: {success_rate:.1f}%")
-        
-        if self.errors:
-            print(f"\n❌ 失败详情:")
-            for i, error in enumerate(self.errors, 1):
-                print(f"  {i}. {error}")
-
-def test_various_tool_types():
-    """测试各种类型的工具调用"""
-    
-    result = TestResult("工具类型测试")
-    
-    # 定义各种工具类型的测试用例
-    tool_scenarios = [
-        {
-            "name": "浏览器导航工具",
-            "tool_name": "browser_navigate",
-            "arguments": '{"url": "https://www.google.com"}',
-            "expected_args": {"url": "https://www.google.com"},
-            "description": "测试浏览器导航工具的URL参数"
-        },
-        {
-            "name": "天气查询工具",
-            "tool_name": "get_weather",
-            "arguments": '{"city": "北京", "unit": "celsius"}',
-            "expected_args": {"city": "北京", "unit": "celsius"},
-            "description": "测试天气查询工具的城市和单位参数"
-        },
-        {
-            "name": "文件操作工具",
-            "tool_name": "file_write",
-            "arguments": '{"path": "/tmp/test.txt", "content": "Hello World", "encoding": "utf-8"}',
-            "expected_args": {"path": "/tmp/test.txt", "content": "Hello World", "encoding": "utf-8"},
-            "description": "测试文件写入工具的多参数"
-        },
-        {
-            "name": "搜索工具",
-            "tool_name": "web_search",
-            "arguments": '{"query": "Python编程", "limit": 10, "safe_search": true}',
-            "expected_args": {"query": "Python编程", "limit": 10, "safe_search": True},
-            "description": "测试搜索工具的混合类型参数"
-        },
-        {
-            "name": "数据库查询工具",
-            "tool_name": "db_query",
-            "arguments": '{"sql": "SELECT * FROM users WHERE age > ?", "params": [18], "timeout": 30.5}',
-            "expected_args": {"sql": "SELECT * FROM users WHERE age > ?", "params": [18], "timeout": 30.5},
-            "description": "测试数据库工具的复杂参数结构"
-        },
-        {
-            "name": "API调用工具",
-            "tool_name": "api_call",
-            "arguments": '{"method": "POST", "url": "https://api.example.com/data", "headers": {"Content-Type": "application/json"}, "body": {"key": "value"}}',
-            "expected_args": {"method": "POST", "url": "https://api.example.com/data", "headers": {"Content-Type": "application/json"}, "body": {"key": "value"}},
-            "description": "测试API调用工具的嵌套对象参数"
-        },
-        {
-            "name": "图像处理工具",
-            "tool_name": "image_resize",
-            "arguments": '{"input_path": "image.jpg", "output_path": "resized.jpg", "width": 800, "height": 600, "maintain_aspect": false}',
-            "expected_args": {"input_path": "image.jpg", "output_path": "resized.jpg", "width": 800, "height": 600, "maintain_aspect": False},
-            "description": "测试图像处理工具的数值和布尔参数"
-        },
-        {
-            "name": "邮件发送工具",
-            "tool_name": "send_email",
-            "arguments": '{"to": ["user1@example.com", "user2@example.com"], "subject": "测试邮件", "body": "这是一封测试邮件\\n包含换行符", "attachments": []}',
-            "expected_args": {"to": ["user1@example.com", "user2@example.com"], "subject": "测试邮件", "body": "这是一封测试邮件\n包含换行符", "attachments": []},
-            "description": "测试邮件工具的数组参数和转义字符"
-        }
-    ]
-    
-    print("🔧 测试各种类型的工具调用")
-    print("=" * 80)
-    
-    for i, scenario in enumerate(tool_scenarios, 1):
-        print(f"\n测试 {i}: {scenario['name']}")
-        print(f"描述: {scenario['description']}")
-        
-        try:
-            handler = SSEToolHandler("test_chat_id", "GLM-4.5")
-            
-            # 构造完整的工具调用数据
-            tool_data = {
-                "edit_index": 0,
-                "edit_content": f'<glm_block >{{"type": "mcp", "data": {{"metadata": {{"id": "call_{i}", "name": "{scenario["tool_name"]}", "arguments": "{scenario["arguments"]}", "result": "", "status": "completed"}}}}, "thought": null}}</glm_block>',
-                "phase": "tool_call"
-            }
-            
-            # 处理工具调用
-            chunks = list(handler.process_tool_call_phase(tool_data, is_stream=False))
-            
-            # 验证结果
-            if handler.active_tools:
-                tool = list(handler.active_tools.values())[0]
-                actual_args = tool["arguments"]
-                expected_args = scenario["expected_args"]
-                
-                if actual_args == expected_args:
-                    print(f"  ✅ 参数解析正确: {actual_args}")
-                    result.add_pass()
-                else:
-                    error_msg = f"{scenario['name']}: 参数不匹配 - 期望: {expected_args}, 实际: {actual_args}"
-                    print(f"  ❌ {error_msg}")
-                    result.add_fail(error_msg)
-            else:
-                error_msg = f"{scenario['name']}: 未检测到工具调用"
-                print(f"  ❌ {error_msg}")
-                result.add_fail(error_msg)
-                
-        except Exception as e:
-            error_msg = f"{scenario['name']}: 处理异常 - {str(e)}"
-            print(f"  ❌ {error_msg}")
-            result.add_fail(error_msg)
-    
-    result.print_summary()
-    return result
-
-def test_parameter_formats():
-    """测试各种参数格式"""
-    
-    result = TestResult("参数格式测试")
-    
-    # 定义各种参数格式的测试用例
-    format_scenarios = [
-        {
-            "name": "空参数",
-            "arguments": "{}",
-            "expected": {},
-            "description": "测试空参数对象"
-        },
-        {
-            "name": "null参数",
-            "arguments": "null",
-            "expected": {},
-            "description": "测试null参数值"
-        },
-        {
-            "name": "转义JSON字符串",
-            "arguments": '{\\"key\\": \\"value\\"}',
-            "expected": {"key": "value"},
-            "description": "测试转义的JSON字符串"
-        },
-        {
-            "name": "包含特殊字符",
-            "arguments": '{"text": "Hello\\nWorld\\t!", "emoji": "😀🎉", "unicode": "中文测试"}',
-            "expected": {"text": "Hello\nWorld\t!", "emoji": "😀🎉", "unicode": "中文测试"},
-            "description": "测试包含换行符、制表符、emoji和中文的参数"
-        },
-        {
-            "name": "数值类型",
-            "arguments": '{"int": 42, "float": 3.14159, "negative": -100, "zero": 0}',
-            "expected": {"int": 42, "float": 3.14159, "negative": -100, "zero": 0},
-            "description": "测试各种数值类型参数"
-        },
-        {
-            "name": "布尔类型",
-            "arguments": '{"true_val": true, "false_val": false}',
-            "expected": {"true_val": True, "false_val": False},
-            "description": "测试布尔类型参数"
-        },
-        {
-            "name": "数组参数",
-            "arguments": '{"empty_array": [], "string_array": ["a", "b", "c"], "mixed_array": [1, "two", true, null]}',
-            "expected": {"empty_array": [], "string_array": ["a", "b", "c"], "mixed_array": [1, "two", True, None]},
-            "description": "测试各种数组类型参数"
-        },
-        {
-            "name": "嵌套对象",
-            "arguments": '{"nested": {"level1": {"level2": {"value": "deep"}}}, "array_of_objects": [{"id": 1}, {"id": 2}]}',
-            "expected": {"nested": {"level1": {"level2": {"value": "deep"}}}, "array_of_objects": [{"id": 1}, {"id": 2}]},
-            "description": "测试深度嵌套的对象和对象数组"
-        },
-        {
-            "name": "长字符串",
-            "arguments": '{"long_text": "' + "A" * 1000 + '"}',
-            "expected": {"long_text": "A" * 1000},
-            "description": "测试长字符串参数"
-        },
-        {
-            "name": "包含引号的字符串",
-            "arguments": '{"quoted": "He said \\"Hello\\" to me", "single_quote": "It\'s working"}',
-            "expected": {"quoted": 'He said "Hello" to me', "single_quote": "It's working"},
-            "description": "测试包含引号的字符串参数"
-        }
-    ]
-    
-    print("\n📝 测试各种参数格式")
-    print("=" * 80)
-    
-    for i, scenario in enumerate(format_scenarios, 1):
-        print(f"\n测试 {i}: {scenario['name']}")
-        print(f"描述: {scenario['description']}")
-        
-        try:
-            handler = SSEToolHandler("test_chat_id", "GLM-4.5")
-            
-            # 直接测试参数解析
-            result_args = handler._parse_partial_arguments(scenario["arguments"])
-            
-            if result_args == scenario["expected"]:
-                print(f"  ✅ 参数解析正确")
-                result.add_pass()
-            else:
-                error_msg = f"{scenario['name']}: 参数解析错误 - 期望: {scenario['expected']}, 实际: {result_args}"
-                print(f"  ❌ {error_msg}")
-                result.add_fail(error_msg)
-                
-        except Exception as e:
-            error_msg = f"{scenario['name']}: 解析异常 - {str(e)}"
-            print(f"  ❌ {error_msg}")
-            result.add_fail(error_msg)
-    
-    result.print_summary()
-    return result

tests/test_final_verification.py

@@ -0,0 +1,56 @@
+"""验证 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

@@ -0,0 +1,70 @@
+# -*- 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_live_server.py

@@ -1,112 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-"""
-测试当前运行的服务器是否正确处理GLM-4.5-Search模型
-"""
-
-import asyncio
-import json
-import httpx
-from app.core.config import settings
-
-async def test_live_server():
-    """测试实际运行的服务器"""
-    
-    print("🧪 测试当前运行的服务器...")
-    print(f"服务器地址: http://localhost:{settings.LISTEN_PORT}")
-    print()
-    
-    try:
-        async with httpx.AsyncClient() as client:
-            # 测试搜索模型请求
-            search_request = {
-                "model": "GLM-4.5-Search",
-                "messages": [
-                    {"role": "user", "content": "请搜索今天北京的天气"}
-                ],
-                "stream": True  # 使用流式以便观察日志
-            }
-            
-            headers = {
-                "Content-Type": "application/json",
-                "Authorization": f"Bearer {settings.AUTH_TOKEN}"
-            }
-            
-            print(f"📤 发送GLM-4.5-Search请求...")
-            print(f"请求内容: {json.dumps(search_request, ensure_ascii=False, indent=2)}")
-            print()
-            
-            # 发送请求并接收流式响应
-            async with client.stream(
-                "POST",
-                f"http://localhost:{settings.LISTEN_PORT}/v1/chat/completions",
-                json=search_request,
-                headers=headers,
-                timeout=30.0
-            ) as response:
-                
-                print(f"📥 响应状态: {response.status_code}")
-                
-                if response.status_code == 200:
-                    print(f"✅ 请求成功，开始接收流式响应...")
-                    print(f"💡 请查看服务器日志以确认是否正确添加了 deep-web-search MCP 服务器")
-                    print()
-                    
-                    # 读取前几个响应块
-                    chunk_count = 0
-                    async for line in response.aiter_lines():
-                        if line.startswith("data: "):
-                            chunk_count += 1
-                            if chunk_count <= 3:  # 只显示前3个块
-                                data = line[6:]  # 去掉 "data: " 前缀
-                                if data.strip() and data.strip() != "[DONE]":
-                                    try:
-                                        chunk_data = json.loads(data)
-                                        content = chunk_data.get("choices", [{}])[0].get("delta", {}).get("content", "")
-                                        if content:
-                                            print(f"📦 响应块 {chunk_count}: {content}")
-                                    except:
-                                        pass
-                            elif chunk_count > 10:  # 读取足够的块后停止
-                                break
-                    
-                    print(f"\n✅ 流式响应正常，共接收 {chunk_count} 个数据块")
-                    print(f"🔍 请检查服务器日志中是否包含以下信息:")
-                    print(f"   - '模型特性检测: is_search=True'")
-                    print(f"   - '🔍 检测到搜索模型，添加 deep-web-search MCP 服务器'")
-                    print(f"   - 'MCP服务器列表: [\"deep-web-search\"]'")
-                    
-                else:
-                    error_text = await response.aread()
-                    print(f"❌ 请求失败: {response.status_code}")
-                    print(f"错误信息: {error_text.decode('utf-8', errors='ignore')}")
-                    
-    except httpx.ConnectError:
-        print(f"❌ 无法连接到服务器 localhost:{settings.LISTEN_PORT}")
-        print(f"   请确保服务器正在运行: python main.py")
-    except Exception as e:
-        print(f"❌ 请求异常: {e}")
-
-async def main():
-    """主函数"""
-    print("=" * 60)
-    print("GLM-4.5-Search 实时服务器测试")
-    print("=" * 60)
-    print()
-    
-    await test_live_server()
-    
-    print()
-    print("=" * 60)
-    print("测试完成")
-    print("=" * 60)
-    print()
-    print("📋 检查清单:")
-    print("1. 服务器是否正常响应 GLM-4.5-Search 请求？")
-    print("2. 日志中是否显示 'is_search=True'？")
-    print("3. 日志中是否显示添加 deep-web-search MCP 服务器？")
-    print("4. 如果以上信息缺失，请重启服务器以加载最新代码")
-
-if __name__ == "__main__":
-    asyncio.run(main())

tests/test_model_comparison.py

@@ -1,118 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-"""
-对比不同模型的搜索行为
-"""
-
-import asyncio
-import json
-import httpx
-from app.core.config import settings
-
-async def test_model(model_name: str, question: str):
-    """测试特定模型的响应"""
-    
-    print(f"🧪 测试模型: {model_name}")
-    print(f"问题: {question}")
-    print()
-    
-    try:
-        async with httpx.AsyncClient() as client:
-            request_data = {
-                "model": model_name,
-                "messages": [
-                    {"role": "user", "content": question}
-                ],
-                "stream": False  # 使用非流式以便完整查看响应
-            }
-            
-            headers = {
-                "Content-Type": "application/json",
-                "Authorization": f"Bearer {settings.AUTH_TOKEN}"
-            }
-            
-            response = await client.post(
-                f"http://localhost:{settings.LISTEN_PORT}/v1/chat/completions",
-                json=request_data,
-                headers=headers,
-                timeout=60.0
-            )
-            
-            if response.status_code == 200:
-                result = response.json()
-                content = result["choices"][0]["message"]["content"]
-                print(f"✅ 响应成功:")
-                print(f"内容: {content[:200]}...")
-                print()
-                
-                # 检查是否包含搜索相关的内容
-                search_indicators = [
-                    "搜索", "查询", "实时", "最新", "网络", "互联网",
-                    "search", "query", "real-time", "latest", "web", "internet"
-                ]
-                
-                has_search_content = any(indicator in content.lower() for indicator in search_indicators)
-                if has_search_content:
-                    print(f"🔍 检测到搜索相关内容")
-                else:
-                    print(f"❌ 未检测到搜索相关内容")
-                
-                return content
-            else:
-                print(f"❌ 请求失败: {response.status_code}")
-                print(f"错误: {response.text}")
-                return None
-                
-    except Exception as e:
-        print(f"❌ 请求异常: {e}")
-        return None
-
-async def main():
-    """主测试函数"""
-    print("=" * 80)
-    print("GLM模型搜索能力对比测试")
-    print("=" * 80)
-    print()
-    
-    # 测试问题
-    search_question = "请搜索今天北京的天气情况"
-    general_question = "你好，请介绍一下自己"
-    
-    models_to_test = [
-        "GLM-4.5",
-        "GLM-4.5-Search", 
-        "GLM-4.5-Thinking",
-        "GLM-4.5-Air"
-    ]
-    
-    print("🔍 测试搜索相关问题:")
-    print(f"问题: {search_question}")
-    print("-" * 80)
-    
-    for model in models_to_test:
-        await test_model(model, search_question)
-        print("-" * 40)
-    
-    print()
-    print("💬 测试一般问题:")
-    print(f"问题: {general_question}")
-    print("-" * 80)
-    
-    for model in models_to_test:
-        await test_model(model, general_question)
-        print("-" * 40)
-    
-    print()
-    print("=" * 80)
-    print("测试完成")
-    print("=" * 80)
-    print()
-    print("📋 分析要点:")
-    print("1. GLM-4.5-Search 是否表现出不同的搜索行为？")
-    print("2. 其他模型是否都拒绝搜索请求？")
-    print("3. 模型响应中是否包含实际的搜索结果？")
-    print("4. 检查服务器日志中的MCP服务器配置是否正确")
-
-if __name__ == "__main__":
-    asyncio.run(main())

tests/test_multimodal_quick.py

@@ -1,6 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
 """
 glm-4.5v 多模态功能测试
 """
@@ -8,7 +5,9 @@ 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"
@@ -21,25 +20,36 @@ 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模型回复:")
@@ -47,6 +57,6 @@ try:
     else:
         print("\n错误响应:")
         print(response.text)
-
+        
 except Exception as e:
-    print(f"\n发生错误: {e}")
+    print(f"\n发生错误: {e}")

tests/test_re.py

@@ -0,0 +1,226 @@
+"""测试和修复正则表达式问题"""
+
+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_search_model.py

@@ -1,180 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-"""
-测试GLM-4.5-Search模型的deep-web-search MCP服务器功能
-"""
-
-import asyncio
-import json
-import httpx
-from app.core.config import settings
-from app.core.zai_transformer import ZAITransformer
-from app.utils.logger import setup_logger
-
-# 设置日志
-logger = setup_logger(log_dir="logs", debug_mode=True)
-
-async def test_search_model_mcp():
-    """测试搜索模型的MCP服务器配置"""
-    
-    # 创建转换器实例
-    transformer = ZAITransformer()
-    
-    # 模拟OpenAI请求 - 使用GLM-4.5-Search模型
-    openai_request = {
-        "model": "GLM-4.5-Search",
-        "messages": [
-            {"role": "user", "content": "请搜索一下今天的新闻"}
-        ],
-        "stream": True
-    }
-    
-    print(f"🧪 测试请求:")
-    print(f"  模型: {openai_request['model']}")
-    print(f"  SEARCH_MODEL配置: {settings.SEARCH_MODEL}")
-    print(f"  模型匹配: {openai_request['model'] == settings.SEARCH_MODEL}")
-    print()
-    
-    try:
-        # 转换请求
-        transformed = await transformer.transform_request_in(openai_request)
-        
-        print(f"✅ 转换成功!")
-        print(f"  上游模型: {transformed['body']['model']}")
-        print(f"  MCP服务器: {transformed['body']['mcp_servers']}")
-        print(f"  web_search特性: {transformed['body']['features']['web_search']}")
-        print(f"  auto_web_search特性: {transformed['body']['features']['auto_web_search']}")
-        print()
-        
-        # 检查是否正确添加了deep-web-search
-        mcp_servers = transformed['body']['mcp_servers']
-        if "deep-web-search" in mcp_servers:
-            print("✅ deep-web-search MCP服务器已正确添加!")
-        else:
-            print("❌ deep-web-search MCP服务器未添加!")
-            print(f"   实际MCP服务器列表: {mcp_servers}")
-        
-        return transformed
-        
-    except Exception as e:
-        print(f"❌ 转换失败: {e}")
-        return None
-
-async def test_non_search_model():
-    """测试非搜索模型不应该添加MCP服务器"""
-    
-    transformer = ZAITransformer()
-    
-    # 模拟OpenAI请求 - 使用普通GLM-4.5模型
-    openai_request = {
-        "model": "GLM-4.5",
-        "messages": [
-            {"role": "user", "content": "你好"}
-        ],
-        "stream": True
-    }
-    
-    print(f"🧪 测试普通模型:")
-    print(f"  模型: {openai_request['model']}")
-    print()
-    
-    try:
-        # 转换请求
-        transformed = await transformer.transform_request_in(openai_request)
-        
-        print(f"✅ 转换成功!")
-        print(f"  上游模型: {transformed['body']['model']}")
-        print(f"  MCP服务器: {transformed['body']['mcp_servers']}")
-        print(f"  web_search特性: {transformed['body']['features']['web_search']}")
-        print()
-        
-        # 检查MCP服务器列表应该为空
-        mcp_servers = transformed['body']['mcp_servers']
-        if not mcp_servers:
-            print("✅ 普通模型正确地没有添加MCP服务器!")
-        else:
-            print(f"❌ 普通模型意外添加了MCP服务器: {mcp_servers}")
-        
-        return transformed
-        
-    except Exception as e:
-        print(f"❌ 转换失败: {e}")
-        return None
-
-async def test_actual_request():
-    """测试实际的HTTP请求"""
-    
-    print(f"🌐 测试实际HTTP请求到本地服务器...")
-    
-    # 检查服务器是否运行
-    try:
-        async with httpx.AsyncClient() as client:
-            # 测试服务器是否可达
-            response = await client.get(f"http://localhost:{settings.LISTEN_PORT}/v1/models", timeout=5.0)
-            if response.status_code != 200:
-                print(f"❌ 服务器未运行或不可达: {response.status_code}")
-                return
-                
-            print(f"✅ 服务器运行正常")
-            
-            # 发送搜索模型请求
-            search_request = {
-                "model": "GLM-4.5-Search",
-                "messages": [
-                    {"role": "user", "content": "搜索今天的天气"}
-                ],
-                "stream": False
-            }
-            
-            headers = {
-                "Content-Type": "application/json",
-                "Authorization": f"Bearer {settings.AUTH_TOKEN}"
-            }
-            
-            print(f"📤 发送搜索请求...")
-            response = await client.post(
-                f"http://localhost:{settings.LISTEN_PORT}/v1/chat/completions",
-                json=search_request,
-                headers=headers,
-                timeout=30.0
-            )
-            
-            print(f"📥 响应状态: {response.status_code}")
-            if response.status_code == 200:
-                print(f"✅ 请求成功!")
-                # 不打印完整响应，只显示状态
-            else:
-                print(f"❌ 请求失败: {response.text}")
-                
-    except httpx.ConnectError:
-        print(f"❌ 无法连接到服务器 localhost:{settings.LISTEN_PORT}")
-        print(f"   请确保服务器正在运行: python main.py")
-    except Exception as e:
-        print(f"❌ 请求异常: {e}")
-
-async def main():
-    """主测试函数"""
-    print("=" * 60)
-    print("GLM-4.5-Search MCP服务器测试")
-    print("=" * 60)
-    print()
-    
-    # 测试1: 搜索模型应该添加MCP服务器
-    await test_search_model_mcp()
-    print()
-    
-    # 测试2: 普通模型不应该添加MCP服务器
-    await test_non_search_model()
-    print()
-    
-    # 测试3: 实际HTTP请求（如果服务器运行）
-    await test_actual_request()
-    print()
-    
-    print("=" * 60)
-    print("测试完成")
-    print("=" * 60)
-
-if __name__ == "__main__":
-    asyncio.run(main())

tests/test_service_uniqueness.py

@@ -1,173 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-"""
-测试服务唯一性验证功能
-"""
-
-import time
-import subprocess
-import sys
-from pathlib import Path
-
-from app.core.config import settings
-from app.utils.process_manager import ProcessManager, ensure_service_uniqueness
-from app.utils.logger import setup_logger
-
-# 设置日志
-logger = setup_logger(log_dir="logs", debug_mode=True)
-
-
-def test_process_manager():
-    """测试进程管理器功能"""
-    print("=" * 60)
-    print("测试进程管理器功能")
-    print("=" * 60)
-    
-    service_name = "test-z-ai2api-server"
-    port = 8081
-    
-    # 创建进程管理器
-    manager = ProcessManager(service_name=service_name, port=port)
-    
-    print(f"\n1. 测试服务唯一性检查...")
-    print(f"   服务名称: {service_name}")
-    print(f"   端口: {port}")
-    
-    # 第一次检查应该通过
-    result1 = manager.check_service_uniqueness()
-    print(f"   第一次检查结果: {'✅ 通过' if result1 else '❌ 失败'}")
-    
-    if result1:
-        # 创建 PID 文件
-        manager.create_pid_file()
-        print(f"   已创建 PID 文件: {manager.pid_file}")
-        
-        # 第二次检查应该失败（因为 PID 文件存在且进程运行中）
-        manager2 = ProcessManager(service_name=service_name, port=port)
-        result2 = manager2.check_service_uniqueness()
-        print(f"   第二次检查结果: {'✅ 通过' if result2 else '❌ 失败（预期）'}")
-        
-        # 清理
-        manager.cleanup_on_exit()
-        print(f"   已清理 PID 文件")
-        
-        # 第三次检查应该通过
-        manager3 = ProcessManager(service_name=service_name, port=port)
-        result3 = manager3.check_service_uniqueness()
-        print(f"   第三次检查结果: {'✅ 通过' if result3 else '❌ 失败'}")
-
-
-def test_convenience_function():
-    """测试便捷函数"""
-    print("\n" + "=" * 60)
-    print("测试便捷函数")
-    print("=" * 60)
-    
-    service_name = "test-convenience-server"
-    port = 8082
-    
-    print(f"\n2. 测试便捷函数...")
-    print(f"   服务名称: {service_name}")
-    print(f"   端口: {port}")
-    
-    # 第一次调用应该成功
-    result1 = ensure_service_uniqueness(service_name=service_name, port=port)
-    print(f"   第一次调用结果: {'✅ 成功' if result1 else '❌ 失败'}")
-    
-    if result1:
-        # 第二次调用应该失败
-        result2 = ensure_service_uniqueness(service_name=service_name, port=port)
-        print(f"   第二次调用结果: {'✅ 成功' if result2 else '❌ 失败（预期）'}")
-        
-        # 手动清理
-        pid_file = Path(f"{service_name}.pid")
-        if pid_file.exists():
-            pid_file.unlink()
-            print(f"   已手动清理 PID 文件")
-
-
-def test_real_service():
-    """测试真实服务场景"""
-    print("\n" + "=" * 60)
-    print("测试真实服务场景")
-    print("=" * 60)
-    
-    service_name = settings.SERVICE_NAME
-    port = settings.LISTEN_PORT
-    
-    print(f"\n3. 测试真实服务场景...")
-    print(f"   服务名称: {service_name}")
-    print(f"   端口: {port}")
-    
-    # 检查当前是否有服务运行
-    manager = ProcessManager(service_name=service_name, port=port)
-    instances = manager.get_running_instances()
-    
-    if instances:
-        print(f"   发现 {len(instances)} 个运行中的实例:")
-        for instance in instances:
-            print(f"     PID: {instance['pid']}, 启动时间: {instance['start_time']}")
-    else:
-        print("   未发现运行中的实例")
-    
-    # 测试唯一性检查
-    result = manager.check_service_uniqueness()
-    print(f"   唯一性检查结果: {'✅ 可以启动' if result else '❌ 已有实例运行'}")
-
-
-def test_port_conflict():
-    """测试端口冲突检测"""
-    print("\n" + "=" * 60)
-    print("测试端口冲突检测")
-    print("=" * 60)
-    
-    print(f"\n4. 测试端口冲突检测...")
-    
-    # 尝试检测一些常用端口
-    test_ports = [80, 443, 8080, 3000, 5000]
-    
-    for port in test_ports:
-        manager = ProcessManager(service_name="test-port-check", port=port)
-        is_occupied = manager._check_port_usage()
-        print(f"   端口 {port}: {'❌ 被占用' if is_occupied else '✅ 可用'}")
-
-
-def main():
-    """主测试函数"""
-    print("🧪 Z.AI2API 服务唯一性验证测试")
-    print("=" * 60)
-    print("此测试将验证以下功能:")
-    print("1. 进程管理器基本功能")
-    print("2. 便捷函数功能")
-    print("3. 真实服务场景")
-    print("4. 端口冲突检测")
-    print("=" * 60)
-    
-    try:
-        # 运行所有测试
-        test_process_manager()
-        test_convenience_function()
-        test_real_service()
-        test_port_conflict()
-        
-        print("\n" + "=" * 60)
-        print("✅ 所有测试完成")
-        print("=" * 60)
-        
-        print("\n📋 使用说��:")
-        print("1. 启动服务时会自动进行唯一性检查")
-        print("2. 如果检测到已有实例运行，新实例将拒绝启动")
-        print("3. 可以通过环境变量 SERVICE_NAME 自定义服务名称")
-        print("4. PID 文件会在服务正常退出时自动清理")
-        print("5. 异常退出的 PID 文件会在下次启动时自动清理")
-        
-    except Exception as e:
-        logger.error(f"❌ 测试过程中发生错误: {e}")
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

tests/test_sse_optimization.py

@@ -1,131 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-"""
-测试 SSE 工具调用处理器的优化效果
-"""
-
-import json
-import time
-from app.utils.sse_tool_handler import SSEToolHandler
-from app.utils.logger import get_logger
-
-logger = get_logger()
-
-def test_tool_call_processing():
-    """测试工具调用处理的优化效果"""
-    
-    # 创建处理器
-    handler = SSEToolHandler("test_chat_id", "GLM-4.5")
-    
-    # 模拟 Z.AI 的原始响应数据（基于文档中的示例）
-    test_data_sequence = [
-        # 第一个数据块 - 工具调用开始
-        {
-            "edit_index": 22,
-            "edit_content": '\n\n<glm_block >{"type": "mcp", "data": {"metadata": {"id": "call_fyh97tn03ow", "name": "playwri-browser_navigate", "arguments": "{\\"url\\":\\"https://www.goo',
-            "phase": "tool_call"
-        },
-        # 第二个数据块 - 参数补全
-        {
-            "edit_index": 176,
-            "edit_content": 'gle.com\\"}", "result": "", "display_result": "", "duration": "...", "status": "completed", "is_error": false, "mcp_server": {"name": "mcp-server"}}, "thought": null, "ppt": null, "browser": null}}</glm_block>',
-            "phase": "tool_call"
-        },
-        # 第三个数据块 - 工具调用结束
-        {
-            "edit_index": 199,
-            "edit_content": 'null, "display_result": "", "duration": "...", "status": "completed", "is_error": false, "mcp_server": {"name": "mcp-server"}}, "thought": null, "ppt": null, "browser": null}}</glm_block>',
-            "phase": "other"
-        }
-    ]
-    
-    print("🧪 开始测试 SSE 工具调用处理器优化...")
-    
-    # 处理数据序列
-    all_chunks = []
-    for i, data in enumerate(test_data_sequence):
-        print(f"\n📦 处理数据块 {i+1}: phase={data['phase']}, edit_index={data['edit_index']}")
-        
-        if data["phase"] == "tool_call":
-            chunks = list(handler.process_tool_call_phase(data, is_stream=True))
-        else:
-            chunks = list(handler.process_other_phase(data, is_stream=True))
-        
-        all_chunks.extend(chunks)
-        
-        # 打印生成的块
-        for j, chunk in enumerate(chunks):
-            if chunk.strip():
-                print(f"  📤 输出块 {j+1}: {chunk[:100]}...")
-    
-    print(f"\n✅ 测试完成，共生成 {len(all_chunks)} 个输出块")
-    
-    # 验证工具调用是否正确解析
-    print(f"🔧 活跃工具数: {len(handler.active_tools)}")
-    print(f"✅ 完成工具数: {len(handler.completed_tools)}")
-    
-    # 打印最终的内容缓冲区
-    try:
-        final_content = handler.content_buffer.decode('utf-8', errors='ignore')
-        print(f"\n📝 最终内容缓冲区长度: {len(final_content)}")
-        print(f"📝 内容预览: {final_content[:200]}...")
-    except Exception as e:
-        print(f"❌ 内容缓冲区解析失败: {e}")
-
-def test_partial_arguments_parsing():
-    """测试部分参数解析功能"""
-    
-    handler = SSEToolHandler("test_chat_id", "GLM-4.5")
-    
-    # 测试各种不完整的参数
-    test_cases = [
-        '{"url":"https://www.goo',  # 不完整的URL
-        '{"city":"北京',  # 缺少引号和括号
-        '{"query":"test", "limit":',  # 不完整的数值
-        '{"name":"test"',  # 缺少结束括号
-        '',  # 空字符串
-        '{',  # 只有开始括号
-    ]
-    
-    print("\n🧪 测试部分参数解析...")
-    
-    for i, test_arg in enumerate(test_cases):
-        print(f"\n📦 测试用例 {i+1}: {test_arg}")
-        result = handler._parse_partial_arguments(test_arg)
-        print(f"  ✅ 解析结果: {result}")
-
-def test_performance():
-    """测试性能优化效果"""
-    
-    print("\n🚀 测试性能优化效果...")
-    
-    # 创建大量数据进行性能测试
-    handler = SSEToolHandler("test_chat_id", "GLM-4.5")
-    
-    # 模拟大量的编辑操作
-    start_time = time.time()
-    
-    for i in range(1000):
-        edit_data = {
-            "edit_index": i * 10,
-            "edit_content": f"test_content_{i}",
-            "phase": "tool_call"
-        }
-        list(handler.process_tool_call_phase(edit_data, is_stream=False))
-    
-    end_time = time.time()
-    
-    print(f"⏱️ 处理1000次编辑操作耗时: {end_time - start_time:.3f}秒")
-    print(f"📊 平均每次操作耗时: {(end_time - start_time) * 1000 / 1000:.3f}毫秒")
-
-if __name__ == "__main__":
-    try:
-        test_tool_call_processing()
-        test_partial_arguments_parsing()
-        test_performance()
-        print("\n🎉 所有测试完成！")
-    except Exception as e:
-        logger.error(f"❌ 测试失败: {e}")
-        import traceback
-        traceback.print_exc()

tests/test_tool_call.py

@@ -0,0 +1,145 @@
+#!/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

@@ -1,133 +0,0 @@
-#!/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()

tests/test_tool_handler_optimized.py

@@ -1,492 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-"""
-测试优化后的SSE工具调用处理器
-基于真实的Z.AI响应格式和日志数据进行全面测试
-"""
-
-import json
-import time
-import traceback
-from typing import List, Dict, Any
-from app.utils.sse_tool_handler import SSEToolHandler
-from app.utils.logger import get_logger
-
-logger = get_logger()
-
-
-class TestResult:
-    """测试结果类"""
-    def __init__(self, name: str):
-        self.name = name
-        self.passed = 0
-        self.failed = 0
-        self.errors = []
-
-    def add_pass(self):
-        self.passed += 1
-
-    def add_fail(self, error: str):
-        self.failed += 1
-        self.errors.append(error)
-
-    def print_summary(self):
-        total = self.passed + self.failed
-        success_rate = (self.passed / total * 100) if total > 0 else 0
-
-        print(f"\n📊 {self.name} 测试结果:")
-        print(f"  ✅ 通过: {self.passed}")
-        print(f"  ❌ 失败: {self.failed}")
-        print(f"  📈 成功率: {success_rate:.1f}%")
-
-        if self.errors:
-            print(f"  🔍 错误详情:")
-            for i, error in enumerate(self.errors, 1):
-                print(f"    {i}. {error}")
-
-
-def parse_openai_chunk(chunk_data: str) -> Dict[str, Any]:
-    """解析OpenAI格式的chunk数据"""
-    try:
-        if chunk_data.startswith("data: "):
-            chunk_data = chunk_data[6:]  # 移除 "data: " 前缀
-        if chunk_data.strip() == "[DONE]":
-            return {"type": "done"}
-        return json.loads(chunk_data)
-    except json.JSONDecodeError:
-        return {"type": "invalid", "raw": chunk_data}
-
-
-def extract_tool_calls(chunks: List[str]) -> List[Dict[str, Any]]:
-    """从chunk列表中提取工具调用信息"""
-    tools = []
-    current_tool = None
-
-    for chunk in chunks:
-        parsed = parse_openai_chunk(chunk)
-        if parsed.get("type") == "invalid":
-            continue
-
-        choices = parsed.get("choices", [])
-        if not choices:
-            continue
-
-        delta = choices[0].get("delta", {})
-        tool_calls = delta.get("tool_calls", [])
-
-        for tc in tool_calls:
-            if tc.get("function", {}).get("name"):  # 新工具开始
-                current_tool = {
-                    "id": tc.get("id"),
-                    "name": tc["function"]["name"],
-                    "arguments": ""
-                }
-                tools.append(current_tool)
-            elif tc.get("function", {}).get("arguments") and current_tool:  # 参数累积
-                current_tool["arguments"] += tc["function"]["arguments"]
-
-    # 解析最终参数
-    for tool in tools:
-        try:
-            tool["parsed_arguments"] = json.loads(tool["arguments"]) if tool["arguments"] else {}
-        except json.JSONDecodeError:
-            tool["parsed_arguments"] = {}
-
-    return tools
-
-
-def test_real_world_scenarios():
-    """测试基于真实Z.AI响应的工具调用处理"""
-
-    result = TestResult("真实场景测试")
-
-    # 基于实际日志的测试数据
-    test_scenarios = [
-        {
-            "name": "浏览器导航工具调用",
-            "description": "模拟打开Google网站的工具调用",
-            "expected_tools": [
-                {
-                    "name": "playwri-browser_navigate",
-                    "id": "call_fyh97tn03ow",
-                    "arguments": {"url": "https://www.google.com"}
-                }
-            ],
-            "data_sequence": [
-                {
-                    "edit_index": 22,
-                    "edit_content": '\n\n<glm_block >{"type": "mcp", "data": {"metadata": {"id": "call_fyh97tn03ow", "name": "playwri-browser_navigate", "arguments": "{\\"url\\":\\"https://www.goo',
-                    "phase": "tool_call"
-                },
-                {
-                    "edit_index": 176,
-                    "edit_content": 'gle.com\\"}", "result": "", "display_result": "", "duration": "...", "status": "completed", "is_error": false, "mcp_server": {"name": "mcp-server"}}, "thought": null, "ppt": null, "browser": null}}</glm_block>',
-                    "phase": "tool_call"
-                },
-                {
-                    "edit_index": 199,
-                    "edit_content": 'null, "display_result": "", "duration": "...", "status": "completed", "is_error": false, "mcp_server": {"name": "mcp-server"}}, "thought": null, "ppt": null, "browser": null}}</glm_block>',
-                    "phase": "other"
-                }
-            ]
-        },
-        {
-            "name": "天气查询工具调用",
-            "description": "模拟查询上海天气的工具调用",
-            "expected_tools": [
-                {
-                    "name": "search",
-                    "id": "call_qsn2jby8al",
-                    "arguments": {"queries": ["今天上海天气", "上海天气预报 今天"]}
-                }
-            ],
-            "data_sequence": [
-                {
-                    "edit_index": 16,
-                    "edit_content": '\n\n<glm_block >{"type": "mcp", "data": {"metadata": {"id": "call_qsn2jby8al", "name": "search", "arguments": "{\\"queries\\":[\\"今天上海天气\\", \\"',
-                    "phase": "tool_call"
-                },
-                {
-                    "edit_index": 183,
-                    "edit_content": '上海天气预报 今天\\"]}", "result": "", "display_result": "", "duration": "...", "status": "completed", "is_error": false, "mcp_server": {"name": "mcp-server"}}, "thought": null, "ppt": null, "browser": null}}</glm_block>',
-                    "phase": "tool_call"
-                }
-            ]
-        },
-        {
-            "name": "多工具调用序列",
-            "description": "模拟连续的多个工具调用",
-            "expected_tools": [
-                {
-                    "name": "search",
-                    "id": "call_001",
-                    "arguments": {"query": "北京天气"}
-                },
-                {
-                    "name": "visit_page",
-                    "id": "call_002",
-                    "arguments": {"url": "https://weather.com"}
-                }
-            ],
-            "data_sequence": [
-                {
-                    "edit_index": 0,
-                    "edit_content": '<glm_block >{"type": "mcp", "data": {"metadata": {"id": "call_001", "name": "search", "arguments": "{\\"query\\":\\"北京天气\\"}", "result": "", "status": "completed"}}, "thought": null}}</glm_block>',
-                    "phase": "tool_call"
-                },
-                {
-                    "edit_index": 200,
-                    "edit_content": '\n\n<glm_block >{"type": "mcp", "data": {"metadata": {"id": "call_002", "name": "visit_page", "arguments": "{\\"url\\":\\"https://weather.com\\"}", "result": "", "status": "completed"}}, "thought": null}}</glm_block>',
-                    "phase": "tool_call"
-                }
-            ]
-        }
-    ]
-
-    print(f"\n🧪 开始执行 {len(test_scenarios)} 个真实场景测试...")
-
-    # 执行每个测试场景
-    for i, scenario in enumerate(test_scenarios, 1):
-        print(f"\n{'='*60}")
-        print(f"测试 {i}: {scenario['name']}")
-        print(f"描述: {scenario['description']}")
-        print('='*60)
-
-        try:
-            # 创建新的处理器实例
-            handler = SSEToolHandler("test_chat_id", "GLM-4.5")
-
-            # 处理数据序列
-            all_chunks = []
-            for j, data in enumerate(scenario["data_sequence"]):
-                print(f"\n📦 处理数据块 {j+1}: phase={data['phase']}, edit_index={data['edit_index']}")
-
-                if data["phase"] == "tool_call":
-                    chunks = list(handler.process_tool_call_phase(data, is_stream=True))
-                else:
-                    chunks = list(handler.process_other_phase(data, is_stream=True))
-
-                all_chunks.extend(chunks)
-
-            # 提取工具调用信息
-            extracted_tools = extract_tool_calls(all_chunks)
-
-            # 验证结果
-            expected_tools = scenario["expected_tools"]
-
-            print(f"\n📊 验证结果:")
-            print(f"  期望工具数: {len(expected_tools)}")
-            print(f"  实际工具数: {len(extracted_tools)}")
-
-            # 详细验证每个工具
-            for k, expected_tool in enumerate(expected_tools):
-                if k < len(extracted_tools):
-                    actual_tool = extracted_tools[k]
-
-                    # 验证工具名称
-                    name_match = actual_tool["name"] == expected_tool["name"]
-                    # 验证工具ID
-                    id_match = actual_tool["id"] == expected_tool["id"]
-                    # 验证参数
-                    args_match = actual_tool["parsed_arguments"] == expected_tool["arguments"]
-
-                    if name_match and id_match and args_match:
-                        print(f"  ✅ 工具 {k+1}: {expected_tool['name']} - 验证通过")
-                        result.add_pass()
-                    else:
-                        error_details = []
-                        if not name_match:
-                            error_details.append(f"名称不匹配: 期望'{expected_tool['name']}', 实际'{actual_tool['name']}'")
-                        if not id_match:
-                            error_details.append(f"ID不匹配: 期望'{expected_tool['id']}', 实际'{actual_tool['id']}'")
-                        if not args_match:
-                            error_details.append(f"参数不匹配: 期望{expected_tool['arguments']}, 实际{actual_tool['parsed_arguments']}")
-
-                        error_msg = f"工具 {k+1} 验证失败: {'; '.join(error_details)}"
-                        print(f"  ❌ {error_msg}")
-                        result.add_fail(error_msg)
-                else:
-                    error_msg = f"缺少工具 {k+1}: {expected_tool['name']}"
-                    print(f"  ❌ {error_msg}")
-                    result.add_fail(error_msg)
-
-            # 显示提取的工具详情
-            if extracted_tools:
-                print(f"\n🔍 提取的工具详情:")
-                for tool in extracted_tools:
-                    print(f"  - {tool['name']}(id={tool['id']})")
-                    print(f"    参数: {tool['parsed_arguments']}")
-
-        except Exception as e:
-            error_msg = f"测试 {scenario['name']} 执行失败: {str(e)}"
-            print(f"❌ {error_msg}")
-            result.add_fail(error_msg)
-            logger.error(f"测试执行异常: {e}")
-
-    result.print_summary()
-    return result
-
-
-def test_edge_cases():
-    """测试边界情况和异常处理"""
-
-    result = TestResult("边界情况测试")
-
-    edge_cases = [
-        {
-            "name": "空内容处理",
-            "data": {"edit_index": 0, "edit_content": "", "phase": "tool_call"},
-            "should_pass": True
-        },
-        {
-            "name": "无效JSON处理",
-            "data": {"edit_index": 0, "edit_content": '<glm_block >{"invalid": json}}</glm_block>', "phase": "tool_call"},
-            "should_pass": True  # 应该优雅处理，不崩溃
-        },
-        {
-            "name": "不完整的glm_block",
-            "data": {"edit_index": 0, "edit_content": '<glm_block >{"type": "mcp", "data": {"metadata": {"id": "test"', "phase": "tool_call"},
-            "should_pass": True
-        },
-        {
-            "name": "超大edit_index",
-            "data": {"edit_index": 999999, "edit_content": "test", "phase": "tool_call"},
-            "should_pass": True
-        },
-        {
-            "name": "特殊字符处理",
-            "data": {"edit_index": 0, "edit_content": '<glm_block >{"type": "mcp", "data": {"metadata": {"id": "test", "name": "test", "arguments": "{\\"text\\":\\"测试\\u4e2d\\u6587\\"}"}}}</glm_block>', "phase": "tool_call"},
-            "should_pass": True
-        }
-    ]
-
-    print(f"\n🧪 开始执行 {len(edge_cases)} 个边界情况测试...")
-
-    for i, case in enumerate(edge_cases, 1):
-        print(f"\n📦 测试 {i}: {case['name']}")
-
-        try:
-            handler = SSEToolHandler("test_chat_id", "GLM-4.5")
-
-            # 处理数据
-            if case["data"]["phase"] == "tool_call":
-                chunks = list(handler.process_tool_call_phase(case["data"], is_stream=True))
-            else:
-                chunks = list(handler.process_other_phase(case["data"], is_stream=True))
-
-            # 检查是否按预期处理
-            if case["should_pass"]:
-                print(f"  ✅ 成功处理，生成 {len(chunks)} 个输出块")
-                result.add_pass()
-            else:
-                print(f"  ❌ 应该失败但成功了")
-                result.add_fail(f"{case['name']}: 应该失败但成功了")
-
-        except Exception as e:
-            if case["should_pass"]:
-                error_msg = f"{case['name']}: 意外异常 - {str(e)}"
-                print(f"  ❌ {error_msg}")
-                result.add_fail(error_msg)
-            else:
-                print(f"  ✅ 按预期失败: {str(e)}")
-                result.add_pass()
-
-    result.print_summary()
-    return result
-
-
-def test_performance():
-    """测试性能表现"""
-
-    result = TestResult("性能测试")
-
-    print(f"\n🚀 开始性能测试...")
-
-    # 测试大量小块数据的处理性能
-    handler = SSEToolHandler("test_chat_id", "GLM-4.5")
-
-    start_time = time.time()
-
-    # 模拟1000次小的编辑操作
-    for i in range(1000):
-        data = {
-            "edit_index": i * 5,
-            "edit_content": f"chunk_{i}",
-            "phase": "tool_call"
-        }
-        list(handler.process_tool_call_phase(data, is_stream=False))
-
-    end_time = time.time()
-    duration = end_time - start_time
-
-    print(f"⏱️ 处理1000次编辑操作耗时: {duration:.3f}秒")
-    print(f"📊 平均每次操作耗时: {duration * 1000 / 1000:.3f}毫秒")
-
-    # 性能基准：每次操作应该在1毫秒以内
-    if duration < 1.0:  # 1秒内完成1000次操作
-        print("✅ 性能测试通过")
-        result.add_pass()
-    else:
-        error_msg = f"性能测试失败: 耗时{duration:.3f}秒，超过1秒基准"
-        print(f"❌ {error_msg}")
-        result.add_fail(error_msg)
-
-    result.print_summary()
-    return result
-
-
-def test_argument_parsing():
-    """测试参数解析功能"""
-
-    result = TestResult("参数解析测试")
-
-    print(f"\n🧪 开始参数解析测试...")
-
-    handler = SSEToolHandler("test", "test")
-
-    test_cases = [
-        ('{"city": "北京"}', {"city": "北京"}),
-        ('{"city": "北京', {"city": "北京"}),  # 缺少闭合括号
-        ('{"city": "北京"', {"city": "北京"}),  # 缺少闭合括号但有引号
-        ('{\\"city\\": \\"北京\\"}', {"city": "北京"}),  # 转义的JSON
-        ('{}', {}),  # 空参数
-        ('null', {}),  # null参数
-        ('{"array": [1,2,3], "nested": {"key": "value"}}', {"array": [1,2,3], "nested": {"key": "value"}}),  # 复杂参数
-        ('{"url":"https://www.goo', {"url": "https://www.goo"}),  # 不完整的URL
-        ('', {}),  # 空字符串
-        ('{', {}),  # 只有开始括号
-    ]
-
-    for i, (input_str, expected) in enumerate(test_cases, 1):
-        try:
-            parsed_result = handler._parse_partial_arguments(input_str)
-            success = parsed_result == expected
-
-            if success:
-                print(f"✅ 测试 {i}: 解析成功")
-                result.add_pass()
-            else:
-                error_msg = f"测试 {i} 失败: 输入'{input_str[:30]}...', 期望{expected}, 实际{parsed_result}"
-                print(f"❌ {error_msg}")
-                result.add_fail(error_msg)
-
-        except Exception as e:
-            error_msg = f"测试 {i} 异常: 输入'{input_str[:30]}...', 错误: {str(e)}"
-            print(f"❌ {error_msg}")
-            result.add_fail(error_msg)
-
-    result.print_summary()
-    return result
-
-
-def run_all_tests():
-    """运行所有测试"""
-
-    print("🧪 SSE工具调用处理器优化测试套件")
-    print("="*60)
-
-    all_results = []
-
-    try:
-        # 运行真实场景测试
-        print("\n1️⃣ 真实场景测试")
-        all_results.append(test_real_world_scenarios())
-
-        # 运行边界情况测试
-        print("\n2️⃣ 边界情况测试")
-        all_results.append(test_edge_cases())
-
-        # 运行参数解析测试
-        print("\n3️⃣ 参数解析测试")
-        all_results.append(test_argument_parsing())
-
-        # 运行性能测试
-        print("\n4️⃣ 性能测试")
-        all_results.append(test_performance())
-
-        # 汇总结果
-        print("\n" + "="*60)
-        print("📊 测试汇总")
-        print("="*60)
-
-        total_passed = sum(r.passed for r in all_results)
-        total_failed = sum(r.failed for r in all_results)
-        total_tests = total_passed + total_failed
-
-        print(f"总测试数: {total_tests}")
-        print(f"✅ 通过: {total_passed}")
-        print(f"❌ 失败: {total_failed}")
-
-        if total_tests > 0:
-            success_rate = (total_passed / total_tests) * 100
-            print(f"📈 总体成功率: {success_rate:.1f}%")
-
-            if success_rate >= 90:
-                print("🎉 测试结果优秀！")
-            elif success_rate >= 70:
-                print("👍 测试结果良好")
-            else:
-                print("⚠️ 需要改进")
-
-        # 显示失败的测试
-        failed_tests = []
-        for result in all_results:
-            failed_tests.extend(result.errors)
-
-        if failed_tests:
-            print(f"\n🔍 失败测试详情:")
-            for i, error in enumerate(failed_tests, 1):
-                print(f"  {i}. {error}")
-
-        return total_failed == 0
-
-    except Exception as e:
-        print(f"❌ 测试套件执行失败: {e}")
-        traceback.print_exc()
-        return False
-
-
-if __name__ == "__main__":
-    success = run_all_tests()
-    exit(0 if success else 1)

tokens.txt.example

@@ -1,25 +0,0 @@
-# 认证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（使用任一格式）：
-