Upload 31 files

.env.example

@@ -0,0 +1,60 @@
+# 代理服务配置文件示例
+# 复制此文件为 .env 并根据需要修改配置值
+
+# ========== API 基础配置 ==========
+# 客户端认证密钥（您自定义的 API 密钥，用于客户端访问本服务）
+AUTH_TOKEN=sk-your-api-key
+
+# 跳过客户端认证（仅开发环境使用）
+SKIP_AUTH_TOKEN=false
+
+# ========== Z.ai Token池配置 ==========
+# Token失败阈值（失败多少次后标记为不可用）
+TOKEN_FAILURE_THRESHOLD=3
+
+# Token恢复超时时间（秒，失败token在此时间后重新尝试）
+TOKEN_RECOVERY_TIMEOUT=1800
+
+# Token健康检查间隔（秒，定期检查token状态）
+TOKEN_HEALTH_CHECK_INTERVAL=300
+
+# Z.AI 匿名用户模式
+# false: 使用认证 Token 令牌，失败时自动降级为匿名请求
+# true: 自动从 Z.ai 获取临时访问令牌，避免对话历史共享
+ANONYMOUS_MODE=true
+
+# ========== Z.ai 认证token配置（可选） ===========
+# 使用独立的token文件配置（可选）
+# 如果需要认证token，在项目根目录创建 tokens.txt 文件，每行一个token或逗号分隔
+# 如果不需要认证token，想走匿名请求模式，可以注释掉或删除此配置项
+# AUTH_TOKENS_FILE=tokens.txt
+
+# ========== LongCat 配置 ==========
+# LongCat passport token（单个token）
+# LONGCAT_PASSPORT_TOKEN=your_passport_token_here
+
+# LongCat tokens 文件路径（多个token）
+# LONGCAT_TOKENS_FILE=longcat_tokens.txt
+
+# ========== 服务器配置 ==========
+# 服务监听端口
+LISTEN_PORT=8080
+
+# 服务名称（用于进程唯一性验证）
+SERVICE_NAME=z-ai2api-server
+
+# 调试日志
+DEBUG_LOGGING=false
+
+# Function Call 功能开关
+TOOL_SUPPORT=true
+
+# 工具调用扫描限制（字符数）
+SCAN_LIMIT=200000
+
+# ========== Z.AI 错误码400处理 ==========
+
+# 重试次数
+MAX_RETRIES=6
+# 初始重试延迟
+RETRY_DELAY=1

Dockerfile

@@ -1 +1,10 @@
-FROM sxuancoder/z-ai-api-server:latest
+FROM python:3.12-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY .. .
+
+CMD ["python", "main.py"]

app/__init__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from app import core, models, utils
+
+__all__ = ["core", "models", "utils"]

app/core/__init__.py

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

app/core/config.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import os
+from typing import Dict, List, Optional
+from pydantic_settings import BaseSettings
+from app.utils.logger import logger
+
+
+class Settings(BaseSettings):
+    """Application settings"""
+
+    # API Configuration
+    API_ENDPOINT: str = "https://chat.z.ai/api/chat/completions"
+    AUTH_TOKEN: str = os.getenv("AUTH_TOKEN", "sk-your-api-key")
+
+    # 认证token文件路径（可选）
+    AUTH_TOKENS_FILE: Optional[str] = os.getenv("AUTH_TOKENS_FILE")
+
+    # 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
+
+                    # 智能解析：同时支持换行和逗号分隔
+                    # 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文件路径，返回空列表
+        if not self.AUTH_TOKENS_FILE:
+            logger.debug("📄 未配置AUTH_TOKENS_FILE，跳过token文件加载")
+            return []
+
+        # 从文件加载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 []
+
+    @property
+    def longcat_token_list(self) -> List[str]:
+        """
+        解析 LongCat token 列表
+
+        从 LONGCAT_TOKENS_FILE 指定的文件加载 token（如果配置了文件路径）
+        """
+        # 如果未配置token文件路径，返回空列表
+        if not self.LONGCAT_TOKENS_FILE:
+            logger.debug("📄 未配置LONGCAT_TOKENS_FILE，跳过LongCat token文件加载")
+            return []
+
+        # 从文件加载token
+        tokens = self._load_tokens_from_file(self.LONGCAT_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} 个重复LongCat token，已自动去重")
+
+            return unique_tokens
+
+        return []
+
+    # Model Configuration
+    PRIMARY_MODEL: str = os.getenv("PRIMARY_MODEL", "GLM-4.5")
+    THINKING_MODEL: str = os.getenv("THINKING_MODEL", "GLM-4.5-Thinking")
+    SEARCH_MODEL: str = os.getenv("SEARCH_MODEL", "GLM-4.5-Search")
+    AIR_MODEL: str = os.getenv("AIR_MODEL", "GLM-4.5-Air")
+    GLM46_MODEL: str = os.getenv("GLM46_MODEL", "GLM-4.6")
+    GLM46_THINKING_MODEL: str = os.getenv("GLM46_THINKING_MODEL", "GLM-4.6-Thinking")
+    GLM46_SEARCH_MODEL: str = os.getenv("GLM46_SEARCH_MODEL", "GLM-4.6-Search")
+
+
+
+    # Provider Model Mapping
+    @property
+    def provider_model_mapping(self) -> Dict[str, str]:
+        """模型到提供商的映射"""
+        return {
+            # Z.AI models
+            "GLM-4.5": "zai",
+            "GLM-4.5-Thinking": "zai",
+            "GLM-4.5-Search": "zai",
+            "GLM-4.5-Air": "zai",
+            "GLM-4.6": "zai",
+            "GLM-4.6-Thinking": "zai",
+            "GLM-4.6-Search": "zai",
+            # K2Think models
+            "MBZUAI-IFM/K2-Think": "k2think",
+            # LongCat models
+            "LongCat-Flash": "longcat",
+            "LongCat": "longcat",
+            "LongCat-Search": "longcat",
+        }
+
+    # 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")
+
+    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"
+
+    # LongCat Configuration
+    LONGCAT_PASSPORT_TOKEN: Optional[str] = os.getenv("LONGCAT_PASSPORT_TOKEN")
+    LONGCAT_TOKENS_FILE: Optional[str] = os.getenv("LONGCAT_TOKENS_FILE")
+
+    # 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",
+        "Accept": "application/json, text/event-stream",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36 Edg/139.0.0.0",
+        "Accept-Language": "zh-CN",
+        "sec-ch-ua": '"Not;A=Brand";v="99", "Microsoft Edge";v="139", "Chromium";v="139"',
+        "sec-ch-ua-mobile": "?0",
+        "sec-ch-ua-platform": '"Windows"',
+        "X-FE-Version": "prod-fe-1.0.70",
+        "Origin": "https://chat.z.ai",
+    }
+
+    class Config:
+        env_file = ".env"
+
+
+settings = Settings()

app/core/openai.py

@@ -0,0 +1,268 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import time
+import json
+from typing import List, Dict, Any
+from fastapi import APIRouter, Header, HTTPException
+from fastapi.responses import StreamingResponse, JSONResponse
+
+from app.core.config import settings
+from app.models.schemas import OpenAIRequest, Message, ModelsResponse, Model, OpenAIResponse, Choice, Usage
+from app.utils.logger import get_logger
+from app.providers import get_provider_router
+from app.utils.token_pool import get_token_pool
+
+logger = get_logger()
+router = APIRouter()
+
+# 全局提供商路由器实例
+provider_router = None
+
+
+def get_provider_router_instance():
+    """获取提供商路由器实例"""
+    global provider_router
+    if provider_router is None:
+        provider_router = get_provider_router()
+    return provider_router
+
+
+def create_chunk(chat_id: str, model: str, delta: Dict[str, Any], finish_reason: str = None) -> Dict[str, Any]:
+    """创建标准的 OpenAI chunk 结构"""
+    return {
+        "choices": [{
+            "delta": delta,
+            "finish_reason": finish_reason,
+            "index": 0,
+            "logprobs": None,
+        }],
+        "created": int(time.time()),
+        "id": chat_id,
+        "model": model,
+        "object": "chat.completion.chunk",
+        "system_fingerprint": "fp_zai_001",
+    }
+
+
+async def handle_non_stream_response(stream_response, request: OpenAIRequest) -> JSONResponse:
+    """处理非流式响应"""
+    logger.info("📄 开始处理非流式响应")
+
+    # 收集所有流式数据
+    full_content = []
+    async for chunk_data in stream_response():
+        if chunk_data.startswith("data: "):
+            chunk_str = chunk_data[6:].strip()
+            if chunk_str and chunk_str != "[DONE]":
+                try:
+                    chunk = json.loads(chunk_str)
+                    if "choices" in chunk and chunk["choices"]:
+                        choice = chunk["choices"][0]
+                        if "delta" in choice and "content" in choice["delta"]:
+                            content = choice["delta"]["content"]
+                            if content:
+                                full_content.append(content)
+                except json.JSONDecodeError:
+                    continue
+
+    # 构建响应
+    response_data = OpenAIResponse(
+        id=f"chatcmpl-{int(time.time())}",
+        object="chat.completion",
+        created=int(time.time()),
+        model=request.model,
+        choices=[Choice(
+            index=0,
+            message=Message(
+                role="assistant",
+                content="".join(full_content),
+                tool_calls=None
+            ),
+            finish_reason="stop"
+        )],
+        usage=Usage(
+            prompt_tokens=0,
+            completion_tokens=0,
+            total_tokens=0
+        )
+    )
+
+    logger.info("✅ 非流式响应处理完成")
+    return JSONResponse(content=response_data.model_dump(exclude_none=True))
+
+
+@router.get("/v1/models")
+async def list_models():
+    """List available models from all providers"""
+    try:
+        router_instance = get_provider_router_instance()
+        models_data = router_instance.get_models_list()
+        return JSONResponse(content=models_data)
+    except Exception as e:
+        logger.error(f"❌ 获取模型列表失败: {e}")
+        # 返回默认模型列表作为后备
+        current_time = int(time.time())
+        fallback_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"),
+            ]
+        )
+        return fallback_response
+
+
+@router.post("/v1/chat/completions")
+async def chat_completions(request: OpenAIRequest, authorization: str = Header(...)):
+    """Handle chat completion requests with multi-provider architecture"""
+    role = request.messages[0].role if request.messages else "unknown"
+    logger.info(f"😶‍🌫️ 收到客户端请求 - 模型: {request.model}, 流式: {request.stream}, 消息数: {len(request.messages)}, 角色: {role}, 工具数: {len(request.tools) if request.tools else 0}")
+
+    try:
+        # Validate API key (skip if SKIP_AUTH_TOKEN is enabled)
+        if not settings.SKIP_AUTH_TOKEN:
+            if not authorization.startswith("Bearer "):
+                raise HTTPException(status_code=401, detail="Missing or invalid Authorization header")
+
+            api_key = authorization[7:]
+            if api_key != settings.AUTH_TOKEN:
+                raise HTTPException(status_code=401, detail="Invalid API key")
+
+        # 使用多提供商路由器处理请求
+        router_instance = get_provider_router_instance()
+        result = await router_instance.route_request(request)
+
+        # 检查是否有错误
+        if isinstance(result, dict) and "error" in result:
+            error_info = result["error"]
+            if error_info.get("code") == "model_not_found":
+                raise HTTPException(status_code=404, detail=error_info["message"])
+            else:
+                raise HTTPException(status_code=500, detail=error_info["message"])
+
+        # 处理响应
+        if request.stream:
+            # 流式响应
+            if hasattr(result, '__aiter__'):
+                # 结果是异步生成器
+                return StreamingResponse(
+                    result,
+                    media_type="text/event-stream",
+                    headers={
+                        "Cache-Control": "no-cache",
+                        "Connection": "keep-alive",
+                        "Access-Control-Allow-Origin": "*",
+                    }
+                )
+            else:
+                # 结果是字典，可能包含错误
+                raise HTTPException(status_code=500, detail="Expected streaming response but got non-streaming result")
+        else:
+            # 非流式响应
+            if isinstance(result, dict):
+                return JSONResponse(content=result)
+            else:
+                # 如果是异步生成器，需要收集所有内容
+                return await handle_non_stream_response(result, request)
+
+    except HTTPException:
+        # 重新抛出 HTTP 异常
+        raise
+    except Exception as e:
+        logger.error(f"❌ 请求处理失败: {e}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+
+# Token pool management endpoints
+
+
+@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池未初始化")
+
+        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'])
+
+        response = {
+            "status": "completed",
+            "message": f"健康检查已完成，耗时 {duration:.2f} 秒",
+            "summary": {
+                "total_tokens": total_tokens,
+                "healthy_tokens": healthy_tokens,
+                "unhealthy_tokens": total_tokens - healthy_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
+        }
+
+        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_endpoint(tokens: List[str]):
+    """动态更新token池"""
+    try:
+        from app.utils.token_pool import update_token_pool
+
+        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()
+
+        return {
+            "status": "updated",
+            "message": f"Token池已更新，共 {len(valid_tokens)} 个token",
+            "pool_info": token_pool.get_pool_status() if token_pool else None
+        }
+    except Exception as e:
+        logger.error(f"更新token池失败: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to update token pool: {str(e)}")

app/core/zai_transformer.py

@@ -0,0 +1,777 @@
+#!/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 app.core.config import settings
+from app.utils.logger import get_logger
+from app.utils.token_pool import get_token_pool, initialize_token_pool
+from app.utils.user_agent import get_random_user_agent
+
+logger = get_logger()
+
+
+def get_zai_dynamic_headers(chat_id: str = "") -> Dict[str, str]:
+    """
+    生成 Z.AI 特定的动态浏览器 headers，包含随机 User-Agent
+    使用通用的 UserAgent 工具，但添加 Z.AI 特定的业务逻辑
+
+    Args:
+        chat_id: 聊天 ID，用于生成正确的 Referer
+
+    Returns:
+        Dict[str, str]: 包含 Z.AI 特定配置的 headers
+    """
+    # 随机选择浏览器类型，偏向Chrome和Edge
+    browser_choices = ["chrome", "chrome", "chrome", "edge", "edge", "firefox", "safari"]
+    browser_type = random.choice(browser_choices)
+
+    user_agent = get_random_user_agent(browser_type)
+
+    # 提取版本信息
+    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}"'
+
+    # Z.AI 特定的 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",
+        "X-FE-Version": "prod-fe-1.0.79",
+        "Origin": "https://chat.z.ai",
+    }
+
+    # 添加浏览器特定的 sec-ch-ua headers
+    if sec_ch_ua:
+        headers["sec-ch-ua"] = sec_ch_ua
+        headers["sec-ch-ua-mobile"] = "?0"
+        headers["sec-ch-ua-platform"] = '"Windows"'
+
+    # 根据 chat_id 设置 Referer
+    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_zai_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}")
+
+        # 匿名模式下，如果获取访客令牌失败，直接返回空
+        logger.error("❌ 匿名模式下获取访客令牌失败")
+        return ""
+
+    # 非匿名模式：首先使用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，尝试降级到匿名模式...")
+    try:
+        headers = get_zai_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.info(f"✅ 降级到匿名模式成功: {token[:20]}...")
+                    return token
+    except Exception as e:
+        logger.warning(f"降级到匿名模式失败: {e}")
+
+    # 没有可用的token
+    logger.error("❌ 所有认证方式都失败了")
+    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_zai_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}")
+
+            # 匿名模式下，如果获取访客令牌失败，直接返回空
+            logger.error("❌ 匿名模式下获取访客令牌失败")
+            return ""
+
+        # 非匿名模式：首先使用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，尝试降级到匿名模式...")
+        try:
+            headers = get_zai_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.info(f"✅ 降级到匿名模式成功: {token[:20]}...")
+                        return token
+        except Exception as e:
+            logger.warning(f"降级到匿名模式失败: {e}")
+
+        # 没有可用的token
+        logger.error("❌ 所有认证方式都失败了")
+        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:
+            # 提供详细的配置建议
+            error_msg = "❌ 无法获取有效的认证令牌"
+            suggestions = []
+
+            if not settings.ANONYMOUS_MODE:
+                suggestions.append("1. 设置 ANONYMOUS_MODE=true 启用匿名模式")
+
+            if not settings.AUTH_TOKENS_FILE:
+                suggestions.append("2. 配置 AUTH_TOKENS_FILE 并创建对应的token文件")
+            elif settings.AUTH_TOKENS_FILE and not settings.auth_token_list:
+                suggestions.append(f"3. 检查token文件 '{settings.AUTH_TOKENS_FILE}' 是否存在且包含有效token")
+
+            if suggestions:
+                error_msg += "\n建议的解决方案：\n" + "\n".join(suggestions)
+
+            logger.error(error_msg)
+            raise Exception("无法获取有效的认证令牌，请检查配置")
+
+        # 确定请求的模型特性
+        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"  开始处理 {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_zai_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}")
+
+        # 返回转换后的请求数据
+        return {
+            "body": body,
+            "config": config,
+            "token": token
+        }
+
+    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

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

app/models/schemas.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from typing import Dict, List, Optional, Any, Union, Literal
+from pydantic import BaseModel
+
+
+class ContentPart(BaseModel):
+    """Content part model for OpenAI's new content format"""
+
+    type: str
+    text: Optional[str] = None
+
+
+class Message(BaseModel):
+    """Chat message model"""
+
+    role: str
+    content: Optional[Union[str, List[ContentPart]]] = None
+    reasoning_content: Optional[str] = None
+    tool_calls: Optional[List[Dict[str, Any]]] = None
+
+
+class OpenAIRequest(BaseModel):
+    """OpenAI-compatible request model"""
+
+    model: str
+    messages: List[Message]
+    stream: Optional[bool] = False
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+    tools: Optional[List[Dict[str, Any]]] = None
+    tool_choice: Optional[Any] = None
+
+
+class ModelItem(BaseModel):
+    """Model information item"""
+
+    id: str
+    name: str
+    owned_by: str
+
+
+class UpstreamRequest(BaseModel):
+    """Upstream service request model"""
+
+    stream: bool
+    model: str
+    messages: List[Message]
+    params: Dict[str, Any] = {}
+    features: Dict[str, Any] = {}
+    background_tasks: Optional[Dict[str, bool]] = None
+    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
+    variables: Optional[Dict[str, str]] = None
+    model_config = {"protected_namespaces": ()}
+
+
+class Delta(BaseModel):
+    """Stream delta model"""
+
+    role: Optional[str] = None
+    content: Optional[str] = "" or None
+    reasoning_content: Optional[str] = None
+    tool_calls: Optional[List[Dict[str, Any]]] = None
+
+
+class Choice(BaseModel):
+    """Response choice model"""
+
+    index: int
+    message: Optional[Message] = None
+    delta: Optional[Delta] = None
+    finish_reason: Optional[str] = None
+
+
+class Usage(BaseModel):
+    """Token usage statistics"""
+
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    total_tokens: int = 0
+
+
+class OpenAIResponse(BaseModel):
+    """OpenAI-compatible response model"""
+
+    id: str
+    object: str
+    created: int
+    model: str
+    choices: List[Choice]
+    usage: Optional[Usage] = None
+
+
+class UpstreamError(BaseModel):
+    """Upstream error model"""
+
+    detail: str
+    code: int
+
+
+class UpstreamDataInner(BaseModel):
+    """Inner upstream data model"""
+
+    error: Optional[UpstreamError] = None
+
+
+class UpstreamDataData(BaseModel):
+    """Upstream data content model"""
+
+    delta_content: str = ""
+    edit_content: str = ""
+    phase: str = ""
+    done: bool = False
+    usage: Optional[Usage] = None
+    error: Optional[UpstreamError] = None
+    inner: Optional[UpstreamDataInner] = None
+
+
+class UpstreamData(BaseModel):
+    """Upstream data model"""
+
+    type: str
+    data: UpstreamDataData
+    error: Optional[UpstreamError] = None
+
+
+class Model(BaseModel):
+    """Model information for listing"""
+
+    id: str
+    object: str = "model"
+    created: int
+    owned_by: str
+
+
+class ModelsResponse(BaseModel):
+    """Models list response model"""
+
+    object: str = "list"
+    data: List[Model]

app/providers/__init__.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+多提供商架构包
+提供统一的提供商接口和路由机制
+"""
+
+from app.providers.base import BaseProvider, ProviderConfig, provider_registry
+from app.providers.zai_provider import ZAIProvider
+from app.providers.k2think_provider import K2ThinkProvider
+from app.providers.longcat_provider import LongCatProvider
+from app.providers.provider_factory import ProviderFactory, ProviderRouter, get_provider_router, initialize_providers
+
+__all__ = [
+    "BaseProvider",
+    "ProviderConfig", 
+    "provider_registry",
+    "ZAIProvider",
+    "K2ThinkProvider", 
+    "LongCatProvider",
+    "ProviderFactory",
+    "ProviderRouter",
+    "get_provider_router",
+    "initialize_providers"
+]

app/providers/base.py

@@ -0,0 +1,268 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+基础提供商抽象层
+定义统一的提供商接口规范
+"""
+
+import json
+import time
+import uuid
+from abc import ABC, abstractmethod
+from typing import Dict, List, Any, Optional, AsyncGenerator, Union
+from dataclasses import dataclass
+
+from app.models.schemas import OpenAIRequest, Message
+from app.utils.logger import get_logger
+
+logger = get_logger()
+
+
+@dataclass
+class ProviderConfig:
+    """提供商配置"""
+    name: str
+    api_endpoint: str
+    timeout: int = 30
+    headers: Optional[Dict[str, str]] = None
+    extra_config: Optional[Dict[str, Any]] = None
+
+
+@dataclass
+class ProviderResponse:
+    """提供商响应"""
+    success: bool
+    content: str = ""
+    error: Optional[str] = None
+    usage: Optional[Dict[str, int]] = None
+    extra_data: Optional[Dict[str, Any]] = None
+
+
+class BaseProvider(ABC):
+    """基础提供商抽象类"""
+    
+    def __init__(self, config: ProviderConfig):
+        """初始化提供商"""
+        self.config = config
+        self.name = config.name
+        self.logger = get_logger()
+        
+    @abstractmethod
+    async def chat_completion(
+        self, 
+        request: OpenAIRequest,
+        **kwargs
+    ) -> Union[Dict[str, Any], AsyncGenerator[str, None]]:
+        """
+        聊天完成接口
+        
+        Args:
+            request: OpenAI格式的请求
+            **kwargs: 额外参数
+            
+        Returns:
+            非流式: Dict[str, Any] - OpenAI格式的响应
+            流式: AsyncGenerator[str, None] - SSE格式的流式响应
+        """
+        pass
+    
+    @abstractmethod
+    async def transform_request(self, request: OpenAIRequest) -> Dict[str, Any]:
+        """
+        转换OpenAI请求为提供商特定格式
+        
+        Args:
+            request: OpenAI格式的请求
+            
+        Returns:
+            Dict[str, Any]: 提供商特定格式的请求
+        """
+        pass
+    
+    @abstractmethod
+    async def transform_response(
+        self, 
+        response: Any, 
+        request: OpenAIRequest
+    ) -> Union[Dict[str, Any], AsyncGenerator[str, None]]:
+        """
+        转换提供商响应为OpenAI格式
+        
+        Args:
+            response: 提供商的原始响应
+            request: 原始请求（用于构造响应）
+            
+        Returns:
+            Union[Dict[str, Any], AsyncGenerator[str, None]]: OpenAI格式的响应
+        """
+        pass
+    
+    def get_supported_models(self) -> List[str]:
+        """获取支持的模型列表"""
+        return []
+    
+    def create_chat_id(self) -> str:
+        """生成聊天ID"""
+        return f"chatcmpl-{uuid.uuid4().hex}"
+    
+    def create_openai_chunk(
+        self, 
+        chat_id: str, 
+        model: str, 
+        delta: Dict[str, Any], 
+        finish_reason: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """创建OpenAI格式的流式响应块"""
+        return {
+            "id": chat_id,
+            "object": "chat.completion.chunk",
+            "created": int(time.time()),
+            "model": model,
+            "choices": [{
+                "index": 0,
+                "delta": delta,
+                "finish_reason": finish_reason,
+                "logprobs": None,
+            }],
+            "system_fingerprint": f"fp_{self.name}_001",
+        }
+    
+    def create_openai_response(
+        self, 
+        chat_id: str, 
+        model: str, 
+        content: str, 
+        usage: Optional[Dict[str, int]] = None
+    ) -> Dict[str, Any]:
+        """创建OpenAI格式的非流式响应"""
+        return {
+            "id": chat_id,
+            "object": "chat.completion",
+            "created": int(time.time()),
+            "model": model,
+            "choices": [{
+                "index": 0,
+                "message": {
+                    "role": "assistant",
+                    "content": content
+                },
+                "finish_reason": "stop",
+                "logprobs": None,
+            }],
+            "usage": usage or {
+                "prompt_tokens": 0,
+                "completion_tokens": 0,
+                "total_tokens": 0
+            },
+            "system_fingerprint": f"fp_{self.name}_001",
+        }
+
+    def create_openai_response_with_reasoning(
+        self,
+        chat_id: str,
+        model: str,
+        content: str,
+        reasoning_content: str = None,
+        usage: Optional[Dict[str, int]] = None
+    ) -> Dict[str, Any]:
+        """创建包含推理内容的OpenAI格式非流式响应"""
+        message = {
+            "role": "assistant",
+            "content": content
+        }
+
+        # 只有当推理内容存在且不为空时才添加
+        if reasoning_content and reasoning_content.strip():
+            message["reasoning_content"] = reasoning_content
+
+        return {
+            "id": chat_id,
+            "object": "chat.completion",
+            "created": int(time.time()),
+            "model": model,
+            "choices": [{
+                "index": 0,
+                "message": message,
+                "finish_reason": "stop",
+                "logprobs": None,
+            }],
+            "usage": usage or {
+                "prompt_tokens": 0,
+                "completion_tokens": 0,
+                "total_tokens": 0
+            },
+            "system_fingerprint": f"fp_{self.name}_001",
+        }
+
+    async def format_sse_chunk(self, chunk: Dict[str, Any]) -> str:
+        """格式化SSE响应块"""
+        return f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n"
+    
+    async def format_sse_done(self) -> str:
+        """格式化SSE结束标记"""
+        return "data: [DONE]\n\n"
+    
+    def log_request(self, request: OpenAIRequest):
+        """记录请求日志"""
+        self.logger.info(f"🔄 {self.name} 处理请求: {request.model}")
+        self.logger.debug(f"  消息数量: {len(request.messages)}")
+        self.logger.debug(f"  流式模式: {request.stream}")
+        
+    def log_response(self, success: bool, error: Optional[str] = None):
+        """记录响应日志"""
+        if success:
+            self.logger.info(f"✅ {self.name} 响应成功")
+        else:
+            self.logger.error(f"❌ {self.name} 响应失败: {error}")
+    
+    def handle_error(self, error: Exception, context: str = "") -> Dict[str, Any]:
+        """统一错误处理"""
+        error_msg = f"{self.name} {context} 错误: {str(error)}"
+        self.logger.error(error_msg)
+        
+        return {
+            "error": {
+                "message": error_msg,
+                "type": "provider_error",
+                "code": "internal_error"
+            }
+        }
+
+
+class ProviderRegistry:
+    """提供商注册表"""
+    
+    def __init__(self):
+        self._providers: Dict[str, BaseProvider] = {}
+        self._model_mapping: Dict[str, str] = {}
+    
+    def register(self, provider: BaseProvider, models: List[str]):
+        """注册提供商"""
+        self._providers[provider.name] = provider
+        for model in models:
+            self._model_mapping[model] = provider.name
+        logger.info(f"📝 注册提供商: {provider.name}, 模型: {models}")
+    
+    def get_provider(self, model: str) -> Optional[BaseProvider]:
+        """根据模型获取提供商"""
+        provider_name = self._model_mapping.get(model)
+        if provider_name:
+            return self._providers.get(provider_name)
+        return None
+    
+    def get_provider_by_name(self, name: str) -> Optional[BaseProvider]:
+        """根据名称获取提供商"""
+        return self._providers.get(name)
+    
+    def list_models(self) -> List[str]:
+        """列出所有支持的模型"""
+        return list(self._model_mapping.keys())
+    
+    def list_providers(self) -> List[str]:
+        """列出所有提供商"""
+        return list(self._providers.keys())
+
+
+# 全局提供商注册表
+provider_registry = ProviderRegistry()

app/providers/k2think_provider.py

@@ -0,0 +1,509 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+K2Think 提供商适配器
+"""
+
+import json
+import re
+import time
+import uuid
+import httpx
+from typing import Dict, List, Any, Optional, AsyncGenerator, Union
+
+from app.providers.base import BaseProvider, ProviderConfig
+from app.models.schemas import OpenAIRequest, Message
+from app.utils.logger import get_logger
+
+logger = get_logger()
+
+
+class K2ThinkProvider(BaseProvider):
+    """K2Think 提供商"""
+    
+    def __init__(self):
+        config = ProviderConfig(
+            name="k2think",
+            api_endpoint="https://www.k2think.ai/api/guest/chat/completions",
+            timeout=30,
+            headers={
+                'Accept': 'text/event-stream',
+                'Accept-Encoding': 'gzip, deflate, br, zstd',
+                'Accept-Language': 'en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7',
+                'Content-Type': 'application/json',
+                'Origin': 'https://www.k2think.ai',
+                'Pragma': 'no-cache',
+                'Referer': 'https://www.k2think.ai/guest',
+                'Sec-Ch-Ua': '"Chromium";v="124", "Google Chrome";v="124", "Not-A.Brand";v="99"',
+                'Sec-Ch-Ua-Mobile': '?0',
+                'Sec-Ch-Ua-Platform': '"macOS"',
+                'Sec-Fetch-Dest': 'empty',
+                'Sec-Fetch-Mode': 'cors',
+                'Sec-Fetch-Site': 'same-origin',
+                'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+            }
+        )
+        super().__init__(config)
+
+        # K2Think 特定配置
+        self.handshake_url = "https://www.k2think.ai/guest"
+        self.new_chat_url = "https://www.k2think.ai/api/v1/chats/guest/new"
+        
+        # 内容解析正则表达式 - 使用DOTALL标志确保.匹配换行符
+        self.reasoning_pattern = re.compile(r'<details type="reasoning"[^>]*>.*?<summary>.*?</summary>(.*?)</details>', re.DOTALL)
+        self.answer_pattern = re.compile(r'<answer>(.*?)</answer>', re.DOTALL)
+    
+    def get_supported_models(self) -> List[str]:
+        """获取支持的模型列表"""
+        return ["MBZUAI-IFM/K2-Think"]
+    
+    def parse_cookies(self, headers) -> str:
+        """解析Cookie"""
+        cookies = []
+        for key, value in headers.items():
+            if key.lower() == 'set-cookie':
+                cookies.append(value.split(';')[0])
+        return '; '.join(cookies)
+    
+    def extract_reasoning_and_answer(self, content: str) -> tuple[str, str]:
+        """提取推理内容和答案内容"""
+        if not content:
+            return "", ""
+        
+        try:
+            reasoning_match = self.reasoning_pattern.search(content)
+            reasoning = reasoning_match.group(1).strip() if reasoning_match else ""
+            
+            answer_match = self.answer_pattern.search(content)
+            answer = answer_match.group(1).strip() if answer_match else ""
+            
+            return reasoning, answer
+        except Exception as e:
+            self.logger.error(f"提取K2内容错误: {e}")
+            return "", ""
+    
+    def calculate_delta(self, previous: str, current: str) -> str:
+        """计算内容增量"""
+        if not previous:
+            return current
+        if not current or len(current) < len(previous):
+            return ""
+        return current[len(previous):]
+    
+    def parse_api_response(self, obj: Any) -> tuple[str, bool]:
+        """解析API响应"""
+        if not obj or not isinstance(obj, dict):
+            return "", False
+        
+        if obj.get("done") is True:
+            return "", True
+        
+        choices = obj.get("choices", [])
+        if choices and len(choices) > 0:
+            delta = choices[0].get("delta", {})
+            return delta.get("content", ""), False
+        
+        content = obj.get("content")
+        if isinstance(content, str):
+            return content, False
+        
+        return "", False
+    
+    async def get_k2_auth_data(self, request: OpenAIRequest) -> Dict[str, Any]:
+        """获取K2Think认证数据"""
+        # 1. 握手请求 - 使用更简单的Accept-Encoding来避免Brotli问题
+        headers_for_handshake = {**self.config.headers}
+        headers_for_handshake['Accept-Encoding'] = 'gzip, deflate'  # 移除br和zstd
+
+        async with httpx.AsyncClient() as client:
+            handshake_response = await client.get(
+                self.handshake_url,
+                headers=headers_for_handshake,
+                follow_redirects=True
+            )
+            if not handshake_response.is_success:
+                try:
+                    # 使用httpx的text属性，它会自动处理解压缩和编码
+                    error_text = handshake_response.text
+                    raise Exception(f"K2 握手失败: {handshake_response.status_code} {error_text[:200]}")
+                except Exception as e:
+                    raise Exception(f"K2 握手失败: {handshake_response.status_code}")
+            
+            initial_cookies = self.parse_cookies(handshake_response.headers)
+        
+        # 2. 准备消息
+        prepared_messages = self.prepare_k2_messages(request.messages)
+        first_user_message = next((m for m in prepared_messages if m["role"] == "user"), None)
+        if not first_user_message:
+            raise Exception("没有找到用户消息来初始化对话")
+        
+        # 3. 创建新对话
+        message_id = str(uuid.uuid4())
+        now = int(time.time() * 1000)
+        model_id = request.model or "MBZUAI-IFM/K2-Think"
+        
+        new_chat_payload = {
+            "chat": {
+                "id": "",
+                "title": "Guest Chat",
+                "models": [model_id],
+                "params": {},
+                "history": {
+                    "messages": {
+                        message_id: {
+                            "id": message_id,
+                            "parentId": None,
+                            "childrenIds": [],
+                            "role": "user",
+                            "content": first_user_message["content"],
+                            "timestamp": now // 1000,
+                            "models": [model_id]
+                        }
+                    },
+                    "currentId": message_id
+                },
+                "messages": [{
+                    "id": message_id,
+                    "parentId": None,
+                    "childrenIds": [],
+                    "role": "user",
+                    "content": first_user_message["content"],
+                    "timestamp": now // 1000,
+                    "models": [model_id]
+                }],
+                "tags": [],
+                "timestamp": now
+            }
+        }
+        
+        headers_with_cookies = {**self.config.headers, 'Cookie': initial_cookies}
+        headers_with_cookies['Accept-Encoding'] = 'gzip, deflate'  # 移除br和zstd
+
+        async with httpx.AsyncClient() as client:
+            new_chat_response = await client.post(
+                self.new_chat_url,
+                headers=headers_with_cookies,
+                json=new_chat_payload,
+                follow_redirects=True
+            )
+            if not new_chat_response.is_success:
+                try:
+                    # 使用httpx的text属性，它会自动处理解压缩和编码
+                    error_text = new_chat_response.text
+                except Exception:
+                    error_text = f"Status: {new_chat_response.status_code}"
+                raise Exception(f"K2 新对话创建失败: {new_chat_response.status_code} {error_text[:200]}")
+
+            try:
+                new_chat_data = new_chat_response.json()
+            except Exception as e:
+                # 如果JSON解析失败，尝试获取原始内容
+                try:
+                    # 使用httpx的text属性，它会自动处理解压缩和编码
+                    content_str = new_chat_response.text
+                    self.logger.debug(f"K2 响应原始内容: {content_str[:500]}")
+                    raise Exception(f"K2 响应JSON解析失败: {e}, 原始内容: {content_str[:200]}")
+                except Exception as decode_error:
+                    # 如果text也失败，尝试手动处理
+                    try:
+                        raw_bytes = new_chat_response.content
+                        content_str = raw_bytes.decode('utf-8', errors='replace')
+                        raise Exception(f"K2 响应解析失败: {e}, 手动解码内容: {content_str[:200]}")
+                    except Exception:
+                        raise Exception(f"K2 响应解析完全失败: {e}, 解码错误: {decode_error}")
+            conversation_id = new_chat_data.get("id")
+            if not conversation_id:
+                raise Exception("无法从K2 /new端点获取conversation_id")
+            
+            chat_specific_cookies = self.parse_cookies(new_chat_response.headers)
+        
+        # 4. 组合最终Cookie
+        base_cookies = [initial_cookies, chat_specific_cookies]
+        base_cookies = [c for c in base_cookies if c]
+        final_cookie = '; '.join(base_cookies) + '; guest_conversation_count=1'
+        
+        # 5. 构建最终请求载荷
+        final_payload = {
+            "stream": True,
+            "model": model_id,
+            "messages": prepared_messages,
+            "conversation_id": conversation_id,
+            "params": {}
+        }
+        
+        # 添加可选参数
+        if request.temperature is not None:
+            final_payload["params"]["temperature"] = request.temperature
+        if request.max_tokens is not None:
+            final_payload["params"]["max_tokens"] = request.max_tokens
+        
+        final_headers = {**self.config.headers, 'Cookie': final_cookie}
+        
+        return {
+            "payload": final_payload,
+            "headers": final_headers
+        }
+    
+    def prepare_k2_messages(self, messages: List[Message]) -> List[Dict[str, Any]]:
+        """准备K2Think消息格式"""
+        result = []
+        system_content = ""
+        
+        for msg in messages:
+            if msg.role == "system":
+                system_content = system_content + "\n\n" + msg.content if system_content else msg.content
+            else:
+                content = msg.content
+                if isinstance(content, list):
+                    # 处理多模态内容，提取文本
+                    text_parts = [part.text for part in content if hasattr(part, 'text') and part.text]
+                    content = "\n".join(text_parts)
+                
+                result.append({
+                    "role": msg.role,
+                    "content": content
+                })
+        
+        # 将系统消息合并到第一个用户消息中
+        if system_content:
+            first_user_idx = next((i for i, m in enumerate(result) if m["role"] == "user"), -1)
+            if first_user_idx >= 0:
+                result[first_user_idx]["content"] = f"{system_content}\n\n{result[first_user_idx]['content']}"
+            else:
+                result.insert(0, {"role": "user", "content": system_content})
+        
+        return result
+
+    async def _handle_stream_request(
+        self,
+        transformed: Dict[str, Any],
+        request: OpenAIRequest
+    ) -> AsyncGenerator[str, None]:
+        """处理流式请求 - 在client.stream上下文内直接处理"""
+        chat_id = self.create_chat_id()
+        model = transformed["model"]
+
+        # 准备请求头
+        headers_for_request = {**transformed["headers"]}
+        headers_for_request['Accept-Encoding'] = 'gzip, deflate'
+
+        self.logger.info(f"🌊 开始K2Think流式请求")
+
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            async with client.stream(
+                "POST",
+                transformed["url"],
+                headers=headers_for_request,
+                json=transformed["payload"]
+            ) as response:
+                if not response.is_success:
+                    error_msg = f"K2Think API 错误: {response.status_code}"
+                    self.log_response(False, error_msg)
+                    # 对于流式响应，我们需要yield错误信息
+                    yield await self.format_sse_chunk({
+                        "error": {
+                            "message": error_msg,
+                            "type": "provider_error",
+                            "code": "api_error"
+                        }
+                    })
+                    return
+
+                # 发送初始角色块
+                yield await self.format_sse_chunk(
+                    self.create_openai_chunk(chat_id, model, {"role": "assistant"})
+                )
+
+                # 处理流式数据
+                accumulated_content = ""
+                previous_reasoning = ""
+                previous_answer = ""
+                reasoning_phase = True
+                chunk_count = 0
+
+                try:
+                    async for line in response.aiter_lines():
+                        chunk_count += 1
+                        self.logger.debug(f"📦 收到数据块 #{chunk_count}: {line[:100]}...")
+
+                        if not line.startswith("data:"):
+                            continue
+
+                        data_str = line[5:].strip()
+                        if self._is_end_marker(data_str):
+                            self.logger.debug(f"🏁 检测到结束标记: {data_str}")
+                            continue
+
+                        content = self._parse_data_string(data_str)
+                        if not content:
+                            continue
+
+                        accumulated_content = content
+                        current_reasoning, current_answer = self.extract_reasoning_and_answer(accumulated_content)
+
+                        # 处理推理阶段
+                        if reasoning_phase and current_reasoning:
+                            delta = self.calculate_delta(previous_reasoning, current_reasoning)
+                            if delta.strip():
+                                self.logger.debug(f"🧠 推理增量: {delta[:50]}...")
+                                yield await self.format_sse_chunk(
+                                    self.create_openai_chunk(chat_id, model, {"reasoning_content": delta})
+                                )
+                                previous_reasoning = current_reasoning
+
+                        # 切换到答案阶段
+                        if current_answer and reasoning_phase:
+                            reasoning_phase = False
+                            self.logger.debug("🔄 切换到答案阶段")
+                            # 发送剩余的推理内容
+                            final_reasoning_delta = self.calculate_delta(previous_reasoning, current_reasoning)
+                            if final_reasoning_delta.strip():
+                                yield await self.format_sse_chunk(
+                                    self.create_openai_chunk(chat_id, model, {"reasoning_content": final_reasoning_delta})
+                                )
+
+                        # 处理答案阶段
+                        if not reasoning_phase and current_answer:
+                            delta = self.calculate_delta(previous_answer, current_answer)
+                            if delta.strip():
+                                self.logger.debug(f"💬 答案增量: {delta[:50]}...")
+                                yield await self.format_sse_chunk(
+                                    self.create_openai_chunk(chat_id, model, {"content": delta})
+                                )
+                                previous_answer = current_answer
+
+                except Exception as e:
+                    self.logger.error(f"流式响应处理错误: {e}")
+                    yield await self.format_sse_chunk({
+                        "error": {
+                            "message": f"流式处理错误: {str(e)}",
+                            "type": "stream_error",
+                            "code": "processing_error"
+                        }
+                    })
+                    return
+
+                # 发送结束块
+                self.logger.info(f"✅ K2Think流式响应完成，共处理 {chunk_count} 个数据块")
+                yield await self.format_sse_chunk(
+                    self.create_openai_chunk(chat_id, model, {}, "stop")
+                )
+                yield await self.format_sse_done()
+
+    async def transform_request(self, request: OpenAIRequest) -> Dict[str, Any]:
+        """转换OpenAI请求为K2Think格式"""
+        self.logger.info(f"🔄 转换 OpenAI 请求到 K2Think 格式: {request.model}")
+        
+        auth_data = await self.get_k2_auth_data(request)
+        
+        return {
+            "url": self.config.api_endpoint,
+            "headers": auth_data["headers"],
+            "payload": auth_data["payload"],
+            "model": request.model
+        }
+    
+    async def chat_completion(
+        self,
+        request: OpenAIRequest
+    ) -> Union[Dict[str, Any], AsyncGenerator[str, None]]:
+        """聊天完成接口"""
+        self.log_request(request)
+
+        try:
+            # 转换请求
+            transformed = await self.transform_request(request)
+
+            # 发送请求 - 使用更兼容的压缩设置
+            headers_for_request = {**transformed["headers"]}
+            headers_for_request['Accept-Encoding'] = 'gzip, deflate'  # 移除br和zstd
+
+            if request.stream:
+                # 流式请求 - 直接在这里处理流式响应
+                return self._handle_stream_request(transformed, request)
+            else:
+                # 非流式请求 - 使用传统的 client.post()
+                async with httpx.AsyncClient(timeout=30.0) as client:
+                    response = await client.post(
+                        transformed["url"],
+                        headers=headers_for_request,
+                        json=transformed["payload"]
+                    )
+
+                    if not response.is_success:
+                        error_msg = f"K2Think API 错误: {response.status_code}"
+                        self.log_response(False, error_msg)
+                        return self.handle_error(Exception(error_msg))
+
+                    # 转换非流式响应
+                    return await self.transform_response(response, request, transformed)
+
+        except Exception as e:
+            self.log_response(False, str(e))
+            return self.handle_error(e, "请求处理")
+    
+    async def transform_response(
+        self,
+        response: httpx.Response,
+        request: OpenAIRequest,
+        transformed: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """转换K2Think响应为OpenAI格式 - 仅用于非流式请求"""
+        chat_id = self.create_chat_id()
+        model = transformed["model"]
+
+        # 流式请求现在由 _handle_stream_request 直接处理
+        # 这里只处理非流式请求
+        return await self._handle_non_stream_response(response, chat_id, model)
+
+    def _is_end_marker(self, data: str) -> bool:
+        """检查是否为结束标记"""
+        return not data or data in ["-1", "[DONE]", "DONE", "done"]
+    
+    def _parse_data_string(self, data_str: str) -> str:
+        """解析数据字符串"""
+        try:
+            obj = json.loads(data_str)
+            content, is_done = self.parse_api_response(obj)
+            return "" if is_done else content
+        except:
+            return data_str
+    
+    async def _handle_non_stream_response(
+        self,
+        response: httpx.Response,
+        chat_id: str,
+        model: str
+    ) -> Dict[str, Any]:
+        """处理K2Think非流式响应"""
+        # 聚合流式内容 - 使用httpx的aiter_lines，它���自动处理解压缩
+        final_content = ""
+
+        try:
+            # 使用aiter_lines()，httpx会自动处理压缩和编码
+            async for line in response.aiter_lines():
+                if not line.startswith("data:"):
+                    continue
+
+                data_str = line[5:].strip()
+                if self._is_end_marker(data_str):
+                    continue
+
+                content = self._parse_data_string(data_str)
+                if content:
+                    final_content = content
+
+        except Exception as e:
+            self.logger.error(f"非流式响应处理错误: {e}")
+            raise
+
+        # 提取推理内容和答案内容
+        reasoning, answer = self.extract_reasoning_and_answer(final_content)
+
+        # 清理内容格式
+        reasoning = reasoning.replace("\\n", "\n") if reasoning else ""
+        answer = answer.replace("\\n", "\n") if answer else final_content
+
+        # 创建包含推理内容的响应
+        return self.create_openai_response_with_reasoning(chat_id, model, answer, reasoning)

app/providers/longcat_provider.py

@@ -0,0 +1,466 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+LongCat 提供商适配器
+"""
+
+import json
+import time
+import httpx
+import random
+import asyncio
+from typing import Dict, List, Any, Optional, AsyncGenerator, Union
+
+from app.providers.base import BaseProvider, ProviderConfig
+from app.models.schemas import OpenAIRequest, Message
+from app.utils.logger import get_logger
+from app.utils.user_agent import get_dynamic_headers
+from app.core.config import settings
+
+logger = get_logger()
+
+
+class LongCatProvider(BaseProvider):
+    """LongCat 提供商"""
+
+    def __init__(self):
+        # 使用动态生成的 headers，不包含 User-Agent（将在请求时动态生成）
+        config = ProviderConfig(
+            name="longcat",
+            api_endpoint="https://longcat.chat/api/v1/chat-completion",
+            timeout=30,
+            headers={
+                'accept': 'text/event-stream,application/json',
+                'content-type': 'application/json',
+                'origin': 'https://longcat.chat',
+                'referer': 'https://longcat.chat/t',
+            }
+        )
+        super().__init__(config)
+        self.base_url = "https://longcat.chat"
+        self.session_create_url = f"{self.base_url}/api/v1/session-create"
+        self.session_delete_url = f"{self.base_url}/api/v1/session-delete"
+    
+    def get_supported_models(self) -> List[str]:
+        """获取支持的模型列表"""
+        return ["LongCat-Flash", "LongCat", "LongCat-Search"]
+
+    def get_passport_token(self) -> Optional[str]:
+        """获取 LongCat passport token"""
+        # 优先使用环境变量中的单个token
+        if settings.LONGCAT_PASSPORT_TOKEN:
+            return settings.LONGCAT_PASSPORT_TOKEN
+
+        # 从token文件中随机选择一个
+        token_list = settings.longcat_token_list
+        if token_list:
+            return random.choice(token_list)
+
+        return None
+
+    def create_headers_with_auth(self, token: str, user_agent: str, referer: str = None) -> Dict[str, str]:
+        """创建带认证的请求头"""
+        headers = {
+            "User-Agent": user_agent,
+            "Content-Type": "application/json",
+            "x-requested-with": "XMLHttpRequest",
+            "X-Client-Language": "zh",
+            "Cookie": f"passport_token_key={token}",
+            "Accept": "text/event-stream,application/json",
+            "Origin": "https://longcat.chat"
+        }
+        if referer:
+            headers["Referer"] = referer
+        else:
+            headers["Referer"] = f"{self.base_url}/"
+        return headers
+
+    async def create_session(self, token: str, user_agent: str) -> str:
+        """创建会话并返回 conversation_id"""
+        headers = self.create_headers_with_auth(token, user_agent)
+        data = {"model": "", "agentId": ""}
+
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.post(
+                self.session_create_url,
+                headers=headers,
+                json=data
+            )
+
+            if response.status_code != 200:
+                raise Exception(f"会话创建失败: {response.status_code}")
+
+            response_data = response.json()
+            if response_data.get("code") != 0:
+                raise Exception(f"会话创建错误: {response_data.get('message')}")
+
+            return response_data["data"]["conversationId"]
+
+    async def delete_session(self, conversation_id: str, token: str, user_agent: str) -> None:
+        """删除会话"""
+        try:
+            headers = self.create_headers_with_auth(
+                token,
+                user_agent,
+                f"{self.base_url}/c/{conversation_id}"
+            )
+
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                url = f"{self.session_delete_url}?conversationId={conversation_id}"
+                response = await client.get(url, headers=headers)
+
+                if response.status_code == 200:
+                    self.logger.debug(f"成功删除会话 {conversation_id}")
+                else:
+                    self.logger.warning(f"删除会话失败: {response.status_code}")
+        except Exception as e:
+            self.logger.error(f"删除会话出错: {e}")
+
+    def schedule_session_deletion(self, conversation_id: str, token: str, user_agent: str):
+        """异步删除会话（不等待）"""
+        asyncio.create_task(self.delete_session(conversation_id, token, user_agent))
+
+    def format_messages_for_longcat(self, messages: List[Message]) -> str:
+        """格式化消息为 LongCat 格式"""
+        formatted_messages = []
+        for msg in messages:
+            content = msg.content
+            if isinstance(content, list):
+                # 处理多模态内容，提取文本
+                text_parts = []
+                for part in content:
+                    if hasattr(part, 'text') and part.text:
+                        text_parts.append(part.text)
+                content = "\n".join(text_parts)
+            formatted_messages.append(f"{msg.role}:{content}")
+        return ";".join(formatted_messages)
+    
+    async def transform_request(self, request: OpenAIRequest) -> Dict[str, Any]:
+        """转换OpenAI请求为LongCat格式"""
+        # 获取认证token
+        passport_token = self.get_passport_token()
+        if not passport_token:
+            raise Exception("未配置 LongCat passport token，请设置 LONGCAT_PASSPORT_TOKEN 环境变量或 LONGCAT_TOKENS_FILE")
+
+        # 生成动态 User-Agent
+        dynamic_headers = get_dynamic_headers()
+        user_agent = dynamic_headers.get("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36")
+
+        # 创建会话
+        conversation_id = await self.create_session(passport_token, user_agent)
+
+        # 格式化消息内容
+        formatted_content = self.format_messages_for_longcat(request.messages)
+
+        # 构建LongCat请求载荷
+        payload = {
+            "conversationId": conversation_id,
+            "content": formatted_content,
+            "reasonEnabled": 0,
+            "searchEnabled": 1 if "search" in request.model.lower() else 0,
+            "parentMessageId": 0
+        }
+
+        # 创建带认证的请求头
+        headers = self.create_headers_with_auth(
+            passport_token,
+            user_agent,
+            f"{self.base_url}/c/{conversation_id}"
+        )
+
+        return {
+            "url": self.config.api_endpoint,
+            "headers": headers,
+            "payload": payload,
+            "model": request.model,
+            "conversation_id": conversation_id,
+            "passport_token": passport_token,
+            "user_agent": user_agent
+        }
+    
+    async def chat_completion(
+        self,
+        request: OpenAIRequest,
+        **kwargs
+    ) -> Union[Dict[str, Any], AsyncGenerator[str, None]]:
+        """聊天完成接口"""
+        self.log_request(request)
+
+        try:
+            # 转换请求
+            transformed = await self.transform_request(request)
+
+            # 发送请求
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                response = await client.post(
+                    transformed["url"],
+                    headers=transformed["headers"],
+                    json=transformed["payload"]
+                )
+
+                if not response.is_success:
+                    error_msg = f"LongCat API 错误: {response.status_code}"
+                    try:
+                        error_detail = await response.atext()
+                        self.logger.error(f"❌ API 错误详情: {error_detail}")
+                    except:
+                        pass
+                    self.log_response(False, error_msg)
+                    return self.handle_error(Exception(error_msg))
+
+                # 转换响应
+                return await self.transform_response(response, request, transformed)
+
+        except Exception as e:
+            self.logger.error(f"❌ LongCat 请求处理异常: {e}")
+            self.log_response(False, str(e))
+            return self.handle_error(e, "请求处理")
+    
+    async def transform_response(
+        self,
+        response: httpx.Response,
+        request: OpenAIRequest,
+        transformed: Dict[str, Any]
+    ) -> Union[Dict[str, Any], AsyncGenerator[str, None]]:
+        """转换LongCat响应为OpenAI格式"""
+        chat_id = self.create_chat_id()
+        model = transformed["model"]
+        conversation_id = transformed["conversation_id"]
+        passport_token = transformed["passport_token"]
+        user_agent = transformed["user_agent"]
+
+        if request.stream:
+            return self._handle_stream_response(
+                response, chat_id, model, conversation_id, passport_token, user_agent
+            )
+        else:
+            return await self._handle_non_stream_response(
+                response, chat_id, model, conversation_id, passport_token, user_agent
+            )
+    
+    async def _handle_stream_response(
+        self,
+        response: httpx.Response,
+        chat_id: str,
+        model: str,
+        conversation_id: str,
+        passport_token: str,
+        user_agent: str
+    ) -> AsyncGenerator[str, None]:
+        """处理LongCat流式响应"""
+        session_deleted = False
+
+        try:
+            # 发送初始角色块
+            yield await self.format_sse_chunk(
+                self.create_openai_chunk(chat_id, model, {"role": "assistant"})
+            )
+
+            stream_finished = False
+
+            async for line in response.aiter_lines():
+                line = line.strip()
+
+                # 首先检查是否是错误响应（JSON格式但不是SSE格式）
+                if not line.startswith('data:'):
+                    # 尝试解析为JSON错误响应
+                    try:
+                        error_data = json.loads(line)
+                        if isinstance(error_data, dict) and 'code' in error_data and 'message' in error_data:
+                            # 这是一个错误响应
+                            self.logger.error(f"❌ LongCat API 返回错误: {error_data}")
+                            error_message = error_data.get('message', '未知错误')
+                            error_code = error_data.get('code', 'unknown')
+
+                            # 使用统一的错误处理函数
+                            error_exception = Exception(f"LongCat API 错误 ({error_code}): {error_message}")
+                            error_response = self.handle_error(error_exception, "API响应")
+
+                            # 发送错误响应块
+                            yield await self.format_sse_chunk(error_response)
+                            yield await self.format_sse_done()
+
+                            # 清理会话
+                            if not session_deleted:
+                                self.schedule_session_deletion(conversation_id, passport_token, user_agent)
+                                session_deleted = True
+                            return
+                    except json.JSONDecodeError:
+                        # 不是JSON，跳过这行
+                        continue
+
+                    # 如果不是错误响应，跳过
+                    continue
+
+                data_str = line[5:].strip()
+                if data_str == '[DONE]':
+                    # 如果还没有发送完成块，发送一个
+                    if not stream_finished:
+                        yield await self.format_sse_chunk(
+                            self.create_openai_chunk(chat_id, model, {}, "stop")
+                        )
+                    yield await self.format_sse_done()
+
+                    # 清理会话
+                    if not session_deleted:
+                        self.schedule_session_deletion(conversation_id, passport_token, user_agent)
+                        session_deleted = True
+                    break
+
+                try:
+                    longcat_data = json.loads(data_str)
+
+                    # 获取 delta 内容
+                    choices = longcat_data.get("choices", [])
+                    if not choices:
+                        continue
+
+                    delta = choices[0].get("delta", {})
+                    content = delta.get("content")
+                    finish_reason = choices[0].get("finishReason")
+
+                    # 只有当内容不为空时才发送内容块
+                    if content is not None and content != "":
+                        openai_chunk = self.create_openai_chunk(
+                            chat_id,
+                            model,
+                            {"content": content}
+                        )
+                        yield await self.format_sse_chunk(openai_chunk)
+
+                    # 检查是否为流的结束
+                    # LongCat 使用 lastOne=true 来标识最后一个块
+                    if longcat_data.get("lastOne") and not stream_finished:
+                        yield await self.format_sse_chunk(
+                            self.create_openai_chunk(chat_id, model, {}, "stop")
+                        )
+                        yield await self.format_sse_done()
+                        stream_finished = True
+
+                        # 清理会话
+                        if not session_deleted:
+                            self.schedule_session_deletion(conversation_id, passport_token, user_agent)
+                            session_deleted = True
+                        break
+
+                    # 备用检查：如果有 finishReason 但没有 lastOne，也可能是结束
+                    elif finish_reason == "stop" and longcat_data.get("contentStatus") == "FINISHED" and not stream_finished:
+                        yield await self.format_sse_chunk(
+                            self.create_openai_chunk(chat_id, model, {}, "stop")
+                        )
+                        yield await self.format_sse_done()
+                        stream_finished = True
+
+                        # 清理会话
+                        if not session_deleted:
+                            self.schedule_session_deletion(conversation_id, passport_token, user_agent)
+                            session_deleted = True
+                        break
+
+                except json.JSONDecodeError as e:
+                    self.logger.error(f"❌ 解析LongCat流数据错误: {e}")
+                    continue
+                except Exception as e:
+                    self.logger.error(f"❌ 处理LongCat流数据错误: {e}")
+                    continue
+
+        except Exception as e:
+            self.logger.error(f"❌ LongCat流处理错误: {e}")
+            # 发送错误结束块（只有在还没有结束的情况下）
+            if not stream_finished:
+                yield await self.format_sse_chunk(
+                    self.create_openai_chunk(chat_id, model, {}, "stop")
+                )
+                yield await self.format_sse_done()
+        finally:
+            # 确保会话被清理
+            if not session_deleted:
+                self.schedule_session_deletion(conversation_id, passport_token, user_agent)
+    
+    async def _handle_non_stream_response(
+        self,
+        response: httpx.Response,
+        chat_id: str,
+        model: str,
+        conversation_id: str,
+        passport_token: str,
+        user_agent: str
+    ) -> Dict[str, Any]:
+        """处理LongCat非流式响应"""
+        full_content = ""
+        usage_info = {
+            "prompt_tokens": 0,
+            "completion_tokens": 0,
+            "total_tokens": 0
+        }
+
+        try:
+            async for line in response.aiter_lines():
+                line = line.strip()
+                if not line.startswith('data:'):
+                    # 检查是否是错误响应
+                    try:
+                        error_data = json.loads(line)
+                        if isinstance(error_data, dict) and 'code' in error_data and 'message' in error_data:
+                            # 这是一个错误响应
+                            self.logger.error(f"❌ LongCat API 返回错误: {error_data}")
+                            error_message = error_data.get('message', '未知错误')
+                            error_code = error_data.get('code', 'unknown')
+
+                            # 使用统一的错误处理函数
+                            error_exception = Exception(f"LongCat API 错误 ({error_code}): {error_message}")
+
+                            # 清理会话
+                            self.schedule_session_deletion(conversation_id, passport_token, user_agent)
+
+                            return self.handle_error(error_exception, "API响应")
+                    except json.JSONDecodeError:
+                        # 不是JSON，跳过这行
+                        pass
+                    continue
+
+                data_str = line[5:].strip()
+                if data_str == '[DONE]':
+                    break
+
+                try:
+                    chunk = json.loads(data_str)
+
+                    # 提取内容 - 只有当内容不为空时才添加
+                    choices = chunk.get("choices", [])
+                    if choices:
+                        delta = choices[0].get("delta", {})
+                        content = delta.get("content")
+                        if content is not None and content != "":
+                            full_content += content
+
+                    # 提取使用信息（通常在最后的块中）
+                    if chunk.get("tokenInfo"):
+                        token_info = chunk["tokenInfo"]
+                        usage_info = {
+                            "prompt_tokens": token_info.get("promptTokens", 0),
+                            "completion_tokens": token_info.get("completionTokens", 0),
+                            "total_tokens": token_info.get("totalTokens", 0)
+                        }
+
+                    # 如果是最后一个块，可以提前结束
+                    if chunk.get("lastOne"):
+                        break
+
+                except json.JSONDecodeError:
+                    continue
+
+        except Exception as e:
+            self.logger.error(f"❌ 处理LongCat非流式响应错误: {e}")
+            full_content = "处理响应时发生错误"
+        finally:
+            # 清理会话
+            self.schedule_session_deletion(conversation_id, passport_token, user_agent)
+
+        return self.create_openai_response(
+            chat_id,
+            model,
+            full_content.strip(),
+            usage_info
+        )

app/providers/provider_factory.py

@@ -0,0 +1,196 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+提供商工厂和路由机制
+负责根据模型名称自动选择合适的提供商
+"""
+
+import time
+from typing import Dict, List, Optional, Union, AsyncGenerator, Any
+from app.providers.base import BaseProvider, provider_registry
+from app.providers.zai_provider import ZAIProvider
+from app.providers.k2think_provider import K2ThinkProvider
+from app.providers.longcat_provider import LongCatProvider
+from app.models.schemas import OpenAIRequest
+from app.core.config import settings
+from app.utils.logger import get_logger
+
+logger = get_logger()
+
+
+class ProviderFactory:
+    """提供商工厂"""
+    
+    def __init__(self):
+        self._initialized = False
+        self._default_provider = "zai"
+    
+    def initialize(self):
+        """初始化所有提供商"""
+        if self._initialized:
+            return
+
+        try:
+            # 注册 Z.AI 提供商
+            zai_provider = ZAIProvider()
+            provider_registry.register(
+                zai_provider, 
+                zai_provider.get_supported_models()
+            )
+            
+            # 注册 K2Think 提供商
+            k2think_provider = K2ThinkProvider()
+            provider_registry.register(
+                k2think_provider,
+                k2think_provider.get_supported_models()
+            )
+            
+            # 注册 LongCat 提供商
+            longcat_provider = LongCatProvider()
+            provider_registry.register(
+                longcat_provider,
+                longcat_provider.get_supported_models()
+            )
+            
+            self._initialized = True
+            
+        except Exception as e:
+            logger.error(f"❌ 提供商工厂初始化失败: {e}")
+            raise
+    
+    def get_provider_for_model(self, model: str) -> Optional[BaseProvider]:
+        """根据模型名称获取提供商"""
+        if not self._initialized:
+            self.initialize()
+        
+        # 首先尝试从配置的映射中获取
+        provider_mapping = settings.provider_model_mapping
+        provider_name = provider_mapping.get(model)
+        
+        if provider_name:
+            provider = provider_registry.get_provider_by_name(provider_name)
+            if provider:
+                logger.debug(f"🎯 模型 {model} 映射到提供商 {provider_name}")
+                return provider
+        
+        # 尝试从注册表中直接获取
+        provider = provider_registry.get_provider(model)
+        if provider:
+            logger.debug(f"🎯 模型 {model} 找到提供商 {provider.name}")
+            return provider
+        
+        # 使用默认提供商
+        default_provider = provider_registry.get_provider_by_name(self._default_provider)
+        if default_provider:
+            logger.warning(f"⚠️ 模型 {model} 未找到专用提供商，使用默认提供商 {self._default_provider}")
+            return default_provider
+        
+        logger.error(f"❌ 无法为模型 {model} 找到任何提供商")
+        return None
+    
+    def list_supported_models(self) -> List[str]:
+        """列出所有支持的模型"""
+        if not self._initialized:
+            self.initialize()
+        return provider_registry.list_models()
+    
+    def list_providers(self) -> List[str]:
+        """列出所有提供商"""
+        if not self._initialized:
+            self.initialize()
+        return provider_registry.list_providers()
+    
+    def get_models_for_provider(self, provider_name: str) -> List[str]:
+        """获取指定提供商支持的模型"""
+        if not self._initialized:
+            self.initialize()
+        
+        provider = provider_registry.get_provider_by_name(provider_name)
+        if provider:
+            return provider.get_supported_models()
+        return []
+
+
+class ProviderRouter:
+    """提供商路由器"""
+    
+    def __init__(self):
+        self.factory = ProviderFactory()
+    
+    async def route_request(
+        self, 
+        request: OpenAIRequest,
+        **kwargs
+    ) -> Union[Dict[str, Any], AsyncGenerator[str, None]]:
+        """路由请求到合适的提供商"""
+        logger.info(f"🚦 路由请求: 模型={request.model}, 流式={request.stream}")
+        
+        # 获取提供商
+        provider = self.factory.get_provider_for_model(request.model)
+        if not provider:
+            error_msg = f"不支持的模型: {request.model}"
+            logger.error(f"❌ {error_msg}")
+            return {
+                "error": {
+                    "message": error_msg,
+                    "type": "invalid_request_error",
+                    "code": "model_not_found"
+                }
+            }
+        
+        logger.info(f"✅ 使用提供商: {provider.name}")
+        
+        try:
+            # 调用提供商处理请求
+            result = await provider.chat_completion(request, **kwargs)
+            logger.info(f"🎉 请求处理��成: {provider.name}")
+            return result
+            
+        except Exception as e:
+            error_msg = f"提供商 {provider.name} 处理请求失败: {str(e)}"
+            logger.error(f"❌ {error_msg}")
+            return provider.handle_error(e, "路由处理")
+    
+    def get_models_list(self) -> Dict[str, Any]:
+        """获取模型列表（OpenAI格式）"""
+        models = []
+        current_time = int(time.time())
+        
+        # 按提供商分组获取模型
+        for provider_name in self.factory.list_providers():
+            provider_models = self.factory.get_models_for_provider(provider_name)
+            for model in provider_models:
+                models.append({
+                    "id": model,
+                    "object": "model",
+                    "created": current_time,
+                    "owned_by": provider_name
+                })
+        
+        return {
+            "object": "list",
+            "data": models
+        }
+
+
+# 全局路由器实例
+_router: Optional[ProviderRouter] = None
+
+
+def get_provider_router() -> ProviderRouter:
+    """获取全局提供商路由器"""
+    global _router
+    if _router is None:
+        _router = ProviderRouter()
+        # 确保工厂已初始化
+        _router.factory.initialize()
+    return _router
+
+
+def initialize_providers():
+    """初始化提供商系统"""
+    logger.info("🚀 初始化提供商系统...")
+    router = get_provider_router()
+    logger.info("✅ 提供商系统初始化完成")
+    return router

app/providers/zai_provider.py

@@ -0,0 +1,764 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Z.AI 提供商适配器
+"""
+
+import json
+import time
+import uuid
+import httpx
+import asyncio
+from datetime import datetime
+from typing import Dict, List, Any, Optional, AsyncGenerator, Union
+
+from app.providers.base import BaseProvider, ProviderConfig
+from app.models.schemas import OpenAIRequest, Message
+from app.core.config import settings
+from app.utils.logger import get_logger
+from app.utils.token_pool import get_token_pool
+from app.core.zai_transformer import generate_uuid, get_zai_dynamic_headers
+from app.utils.sse_tool_handler import SSEToolHandler
+
+logger = get_logger()
+
+
+class ZAIProvider(BaseProvider):
+    """Z.AI 提供商"""
+    
+    def __init__(self):
+        config = ProviderConfig(
+            name="zai",
+            api_endpoint=settings.API_ENDPOINT,
+            timeout=30,
+            headers=get_zai_dynamic_headers()
+        )
+        super().__init__(config)
+        
+        # Z.AI 特定配置
+        self.base_url = "https://chat.z.ai"
+        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
+            settings.GLM46_MODEL: "GLM-4-6-API-V1",  # GLM-4.6
+            settings.GLM46_THINKING_MODEL: "GLM-4-6-API-V1",  # GLM-4.6-Thinking
+            settings.GLM46_SEARCH_MODEL: "GLM-4-6-API-V1",  # GLM-4.6-Search
+        }
+    
+    def get_supported_models(self) -> List[str]:
+        """获取支持的模型列表"""
+        return [
+            settings.PRIMARY_MODEL,
+            settings.THINKING_MODEL,
+            settings.SEARCH_MODEL,
+            settings.AIR_MODEL,
+            settings.GLM46_MODEL,
+            settings.GLM46_THINKING_MODEL,
+            settings.GLM46_SEARCH_MODEL,
+        ]
+    
+    async def get_token(self) -> str:
+        """获取认证令牌"""
+        # 如果启用匿名模式，只尝试获取访客令牌
+        if settings.ANONYMOUS_MODE:
+            try:
+                headers = get_zai_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:
+                            self.logger.debug(f"获取访客令牌成功: {token[:20]}...")
+                            return token
+            except Exception as e:
+                self.logger.warning(f"异步获取访客令牌失败: {e}")
+
+            # 匿名模式下，如果获取访客令牌失败，直接返回空
+            self.logger.error("❌ 匿名模式下获取访客令牌失败")
+            return ""
+
+        # 非匿名模式：首先使用token池获取备份令牌
+        token_pool = get_token_pool()
+        if token_pool:
+            token = token_pool.get_next_token()
+            if token:
+                self.logger.debug(f"从token池获取令牌: {token[:20]}...")
+                return token
+
+        # 如果token池为空或没有可用token，使用配置的AUTH_TOKEN
+        if settings.AUTH_TOKEN and settings.AUTH_TOKEN != "sk-your-api-key":
+            self.logger.debug("使用配置的AUTH_TOKEN")
+            return settings.AUTH_TOKEN
+
+        self.logger.error("❌ 无法获取有效的认证令牌")
+        return ""
+    
+    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(self, request: OpenAIRequest) -> Dict[str, Any]:
+        """转换OpenAI请求为Z.AI格式"""
+        self.logger.info(f"🔄 转换 OpenAI 请求到 Z.AI 格式: {request.model}")
+        
+        # 获取认证令牌
+        token = await self.get_token()
+        
+        # 处理消息格式
+        messages = []
+        for msg in request.messages:
+            if isinstance(msg.content, str):
+                messages.append({
+                    "role": msg.role,
+                    "content": msg.content
+                })
+            elif isinstance(msg.content, list):
+                # 处理多模态内容
+                content_parts = []
+                for part in msg.content:
+                    if hasattr(part, 'type') and hasattr(part, 'text'):
+                        content_parts.append({
+                            "type": part.type,
+                            "text": part.text
+                        })
+                messages.append({
+                    "role": msg.role,
+                    "content": content_parts
+                })
+        
+        # 确定请求的模型特性
+        requested_model = request.model
+        is_thinking = "-thinking" in requested_model.casefold()
+        is_search = "-search" in requested_model.casefold()
+        is_air = "-air" in requested_model.casefold()
+        
+        # 获取上游模型ID
+        upstream_model_id = self.model_mapping.get(requested_model, "0727-360B-API")
+        
+        # 构建MCP服务器列表
+        mcp_servers = []
+        if is_search and "-4.5" in requested_model:
+            mcp_servers.append("deep-web-search")
+            self.logger.info("🔍 检测到搜索模型，添加 deep-web-search MCP 服务器")
+        
+        # 构建上游请求体
+        chat_id = generate_uuid()
+        
+        body = {
+            "stream": True,  # 总是使用流式
+            "model": upstream_model_id,
+            "messages": messages,
+            "params": {},
+            "features": {
+                "image_generation": False,
+                "web_search": is_search,
+                "auto_web_search": is_search,
+                "preview_mode": False,
+                "flags": [],
+                "features": [
+                    {
+                        "type": "mcp",
+                        "server": "vibe-coding",
+                        "status": "hidden"
+                    },
+                    {
+                        "type": "mcp",
+                        "server": "ppt-maker",
+                        "status": "hidden"
+                    },
+                    {
+                        "type": "mcp",
+                        "server": "image-search",
+                        "status": "hidden"
+                    },
+                    {
+                        "type": "mcp",
+                        "server": "deep-research",
+                        "status": "hidden"
+                    },
+                    {
+                        "type": "tool_selector",
+                        "server": "tool_selector",
+                        "status": "hidden"
+                    },
+                    {
+                        "type": "mcp",
+                        "server": "advanced-search",
+                        "status": "hidden"
+                    }
+                ],
+                "enable_thinking": is_thinking,
+            },
+            "background_tasks": {
+                "title_generation": False,
+                "tags_generation": False,
+            },
+            "mcp_servers": mcp_servers,
+            "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.tools:
+            body["tools"] = request.tools
+            self.logger.info(f"启用工具支持: {len(request.tools)} 个工具")
+        else:
+            body["tools"] = None
+        
+        # 处理其他参数
+        if request.temperature is not None:
+            body["params"]["temperature"] = request.temperature
+        if request.max_tokens is not None:
+            body["params"]["max_tokens"] = request.max_tokens
+        
+        # 构建请求头
+        headers = get_zai_dynamic_headers(chat_id)
+        if token:
+            headers["Authorization"] = f"Bearer {token}"
+        
+        # 存储当前token用于错误处理
+        self._current_token = token
+
+        return {
+            "url": self.config.api_endpoint,
+            "headers": headers,
+            "body": body,
+            "token": token,
+            "chat_id": chat_id,
+            "model": requested_model
+        }
+    
+    async def chat_completion(
+        self,
+        request: OpenAIRequest,
+        **kwargs
+    ) -> Union[Dict[str, Any], AsyncGenerator[str, None]]:
+        """聊天完成接口"""
+        self.log_request(request)
+
+        try:
+            # 转换请求
+            transformed = await self.transform_request(request)
+
+            # 根据请求类型返回响应
+            if request.stream:
+                # 流式响应
+                return self._create_stream_response_with_retry(request, transformed)
+            else:
+                # 非流式响应
+                async with httpx.AsyncClient(timeout=30.0) as client:
+                    response = await client.post(
+                        transformed["url"],
+                        headers=transformed["headers"],
+                        json=transformed["body"]
+                    )
+
+                    if not response.is_success:
+                        error_msg = f"Z.AI API 错误: {response.status_code}"
+                        self.log_response(False, error_msg)
+                        return self.handle_error(Exception(error_msg))
+
+                    return await self.transform_response(response, request, transformed)
+
+        except Exception as e:
+            self.log_response(False, str(e))
+            return self.handle_error(e, "请求处理")
+
+    async def _create_stream_response_with_retry(
+        self,
+        request: OpenAIRequest,
+        transformed: Dict[str, Any]
+    ) -> AsyncGenerator[str, None]:
+        """创建带重试机制的流式响应生成器"""
+        retry_count = 0
+        last_error = None
+        current_token = transformed.get("token", "")
+
+        while retry_count <= settings.MAX_RETRIES:
+            try:
+                # 如果是重试，重新获取令牌并更新请求
+                if retry_count > 0:
+                    delay = settings.RETRY_DELAY
+                    self.logger.warning(f"重试请求 ({retry_count}/{settings.MAX_RETRIES}) - 等待 {delay:.1f}s")
+                    await asyncio.sleep(delay)
+
+                    # 标记前一个token失败（如果不是匿名模式）
+                    if current_token and not settings.ANONYMOUS_MODE:
+                        self.mark_token_failure(current_token, Exception(f"Retry {retry_count}: {last_error}"))
+
+                    # 重新获取令牌
+                    self.logger.info("🔑 重新获取令牌用于重试...")
+                    new_token = await self.get_token()
+                    if not new_token:
+                        self.logger.error("❌ 重试时无法获取有效的认证令牌")
+                        raise Exception("重试时无法获取有效的认证令牌")
+                    transformed["headers"]["Authorization"] = f"Bearer {new_token}"
+                    current_token = new_token
+
+                async with httpx.AsyncClient(timeout=60.0) as client:
+                    # 发送请求到上游
+                    self.logger.info(f"🎯 发送请求到 Z.AI: {transformed['url']}")
+                    async with client.stream(
+                        "POST",
+                        transformed["url"],
+                        json=transformed["body"],
+                        headers=transformed["headers"],
+                    ) as response:
+                        # 检查响应状态码
+                        if response.status_code == 400:
+                            # 400 错误，触发重试
+                            error_text = await response.aread()
+                            error_msg = error_text.decode('utf-8', errors='ignore')
+                            self.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:
+                                # 达到最大重试次数，抛出错误
+                                self.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:
+                            # 其他错误，直接返回
+                            self.logger.error(f"❌ 上游返回错误: {response.status_code}")
+                            error_text = await response.aread()
+                            error_msg = error_text.decode('utf-8', errors='ignore')
+                            self.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 成功，处理响应
+                        if retry_count > 0:
+                            self.logger.info(f"✨ 第 {retry_count} 次重试成功")
+
+                        # 标记token使用成功（如果不是匿名模式）
+                        if current_token and not settings.ANONYMOUS_MODE:
+                            token_pool = get_token_pool()
+                            if token_pool:
+                                token_pool.mark_token_success(current_token)
+
+                        # 处理流式响应
+                        chat_id = transformed["chat_id"]
+                        model = transformed["model"]
+                        async for chunk in self._handle_stream_response(response, chat_id, model, request, transformed):
+                            yield chunk
+                        return
+
+            except Exception as e:
+                self.logger.error(f"❌ 流处理错误: {e}")
+                import traceback
+                self.logger.error(traceback.format_exc())
+
+                # 标记token失败（如果不是匿名模式）
+                if current_token and not settings.ANONYMOUS_MODE:
+                    self.mark_token_failure(current_token, e)
+
+                # 检查是否还可以重试
+                retry_count += 1
+                last_error = str(e)
+
+                if retry_count > settings.MAX_RETRIES:
+                    # 达到最大重试次数，返回错误
+                    self.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
+    
+    async def transform_response(
+        self, 
+        response: httpx.Response, 
+        request: OpenAIRequest,
+        transformed: Dict[str, Any]
+    ) -> Union[Dict[str, Any], AsyncGenerator[str, None]]:
+        """转换Z.AI响应为OpenAI格式"""
+        chat_id = transformed["chat_id"]
+        model = transformed["model"]
+        
+        if request.stream:
+            return self._handle_stream_response(response, chat_id, model, request, transformed)
+        else:
+            return await self._handle_non_stream_response(response, chat_id, model)
+    
+    async def _handle_stream_response(
+        self,
+        response: httpx.Response,
+        chat_id: str,
+        model: str,
+        request: OpenAIRequest,
+        transformed: Dict[str, Any]
+    ) -> AsyncGenerator[str, None]:
+        """处理Z.AI流式响应"""
+        self.logger.info(f"✅ Z.AI 响应成功，开始处理 SSE 流")
+
+        # 初始化工具处理器（如果需要）
+        has_tools = transformed["body"].get("tools") is not None
+        tool_handler = None
+
+        if has_tools:
+            tool_handler = SSEToolHandler(model, stream=True)
+            self.logger.info(f"🔧 初始化工具处理器: {len(transformed['body'].get('tools', []))} 个工具")
+
+        # 处理状态
+        has_thinking = False
+        thinking_signature = None
+
+        # 处理SSE流
+        buffer = ""
+        line_count = 0
+        self.logger.debug("📡 开始接收 SSE 流数据...")
+
+        try:
+            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
+
+                        self.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(self, '_last_phase', None):
+                                    self.logger.info(f"📈 SSE 阶段: {phase}")
+                                    self._last_phase = phase
+
+                                # 使用工具处理器处理所有阶段
+                                if tool_handler:
+                                    # 构建 SSE 数据块，包含所有必要字段
+                                    sse_chunk = {
+                                        "phase": phase,
+                                        "edit_content": data.get("edit_content", ""),
+                                        "delta_content": data.get("delta_content", ""),
+                                        "edit_index": data.get("edit_index"),
+                                        "usage": data.get("usage", {})
+                                    }
+
+                                    # 处理工具调用并输出结果
+                                    for output in tool_handler.process_sse_chunk(sse_chunk):
+                                        yield output
+
+                                # 非工具调用模式 - 处理思考内容
+                                elif phase == "thinking":
+                                    if not has_thinking:
+                                        has_thinking = True
+                                        # 发送初始角色
+                                        role_chunk = self.create_openai_chunk(
+                                            chat_id,
+                                            model,
+                                            {"role": "assistant"}
+                                        )
+                                        yield await self.format_sse_chunk(role_chunk)
+
+                                    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 = self.create_openai_chunk(
+                                            chat_id,
+                                            model,
+                                            {
+                                                "role": "assistant",
+                                                "thinking": {"content": content}
+                                            }
+                                        )
+                                        yield await self.format_sse_chunk(thinking_chunk)
+
+                                # 处理答案内容
+                                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 = self.create_openai_chunk(
+                                                chat_id,
+                                                model,
+                                                {
+                                                    "role": "assistant",
+                                                    "thinking": {
+                                                        "content": "",
+                                                        "signature": thinking_signature,
+                                                    }
+                                                }
+                                            )
+                                            yield await self.format_sse_chunk(sig_chunk)
+
+                                        # 提取答案内容
+                                        content_after = edit_content.split("</details>\n")[-1]
+                                        if content_after:
+                                            content_chunk = self.create_openai_chunk(
+                                                chat_id,
+                                                model,
+                                                {
+                                                    "role": "assistant",
+                                                    "content": content_after
+                                                }
+                                            )
+                                            yield await self.format_sse_chunk(content_chunk)
+
+                                    # 处理增量内容
+                                    elif delta_content:
+                                        # 如果还没有发送角色
+                                        if not has_thinking:
+                                            role_chunk = self.create_openai_chunk(
+                                                chat_id,
+                                                model,
+                                                {"role": "assistant"}
+                                            )
+                                            yield await self.format_sse_chunk(role_chunk)
+
+                                        content_chunk = self.create_openai_chunk(
+                                            chat_id,
+                                            model,
+                                            {
+                                                "role": "assistant",
+                                                "content": delta_content
+                                            }
+                                        )
+                                        output_data = await self.format_sse_chunk(content_chunk)
+                                        self.logger.debug(f"➡️ 输出内容块到客户端: {output_data}")
+                                        yield output_data
+
+                                    # 处理完成
+                                    if data.get("usage"):
+                                        self.logger.info(f"📦 完成响应 - 使用统计: {json.dumps(data['usage'])}")
+
+                                        # 只有在非工具调用模式下才发送普通完成信号
+                                        if not tool_handler:
+                                            finish_chunk = self.create_openai_chunk(
+                                                chat_id,
+                                                model,
+                                                {"role": "assistant", "content": ""},
+                                                "stop"
+                                            )
+                                            finish_chunk["usage"] = data["usage"]
+
+                                            finish_output = await self.format_sse_chunk(finish_chunk)
+                                            self.logger.debug(f"➡️ 发送完成信号: {finish_output[:1000]}...")
+                                            yield finish_output
+                                            self.logger.debug("➡️ 发送 [DONE]")
+                                            yield "data: [DONE]\n\n"
+
+                        except json.JSONDecodeError as e:
+                            self.logger.debug(f"❌ JSON解析错误: {e}, 内容: {chunk_str[:1000]}")
+                        except Exception as e:
+                            self.logger.error(f"❌ 处理chunk错误: {e}")
+
+            # 工具处理器会自动发送结束信号，这里不需要重复发送
+            if not tool_handler:
+                self.logger.debug("📤 发送最终 [DONE] 信号")
+                yield "data: [DONE]\n\n"
+
+            self.logger.info(f"✅ SSE 流处理完成，共处理 {line_count} 行数据")
+
+        except Exception as e:
+            self.logger.error(f"❌ 流式响应处理错误: {e}")
+            import traceback
+            self.logger.error(traceback.format_exc())
+            # 发送错误结束块
+            yield await self.format_sse_chunk(
+                self.create_openai_chunk(chat_id, model, {}, "stop")
+            )
+            yield "data: [DONE]\n\n"
+    
+    async def _handle_non_stream_response(
+        self, 
+        response: httpx.Response, 
+        chat_id: str, 
+        model: str
+    ) -> Dict[str, Any]:
+        """处理非流式响应
+
+        说明：上游始终以 SSE 形式返回（transform_request 固定 stream=True），
+        因此这里需要聚合 aiter_lines() 的 data: 块，提取 usage、思考内容与答案内容，
+        并最终产出一次性 OpenAI 格式响应。
+        """
+        final_content = ""
+        reasoning_content = ""
+        usage_info: Dict[str, int] = {
+            "prompt_tokens": 0,
+            "completion_tokens": 0,
+            "total_tokens": 0,
+        }
+
+        try:
+            async for line in response.aiter_lines():
+                if not line:
+                    continue
+
+                line = line.strip()
+
+                # 仅处理以 data: 开头的 SSE 行，其余行尝试作为错误/JSON 忽略
+                if not line.startswith("data:"):
+                    # 尝试解析为错误 JSON
+                    try:
+                        maybe_err = json.loads(line)
+                        if isinstance(maybe_err, dict) and (
+                            "error" in maybe_err or "code" in maybe_err or "message" in maybe_err
+                        ):
+                            # 统一错误处理
+                            msg = (
+                                (maybe_err.get("error") or {}).get("message")
+                                if isinstance(maybe_err.get("error"), dict)
+                                else maybe_err.get("message")
+                            ) or "上游返回错误"
+                            return self.handle_error(Exception(msg), "API响应")
+                    except Exception:
+                        pass
+                    continue
+
+                data_str = line[5:].strip()
+                if not data_str or data_str in ("[DONE]", "DONE", "done"):
+                    continue
+
+                # 解析 SSE 数据块
+                try:
+                    chunk = json.loads(data_str)
+                except json.JSONDecodeError:
+                    continue
+
+                if chunk.get("type") != "chat:completion":
+                    continue
+
+                data = chunk.get("data", {})
+                phase = data.get("phase")
+                delta_content = data.get("delta_content", "")
+                edit_content = data.get("edit_content", "")
+
+                # 记录用量（通常在最后块中出现，但这里每次覆盖保持最新）
+                if data.get("usage"):
+                    try:
+                        usage_info = data["usage"]
+                    except Exception:
+                        pass
+
+                # 思考阶段聚合（去除 <details><summary>... 包裹头）
+                if phase == "thinking":
+                    if delta_content:
+                        if delta_content.startswith("<details"):
+                            cleaned = (
+                                delta_content.split("</summary>\n>")[-1].strip()
+                                if "</summary>\n>" in delta_content
+                                else delta_content
+                            )
+                        else:
+                            cleaned = delta_content
+                        reasoning_content += cleaned
+
+                # 答案阶段聚合
+                elif phase == "answer":
+                    # 当 edit_content 同时包含思考结束标记与答案时，提取答案部分
+                    if edit_content and "</details>\n" in edit_content:
+                        content_after = edit_content.split("</details>\n")[-1]
+                        if content_after:
+                            final_content += content_after
+                    elif delta_content:
+                        final_content += delta_content
+
+        except Exception as e:
+            self.logger.error(f"❌ 非流式响应处理错误: {e}")
+            import traceback
+            self.logger.error(traceback.format_exc())
+            # 返回统一错误响应
+            return self.handle_error(e, "非流式聚合")
+
+        # 清理并返回
+        final_content = (final_content or "").strip()
+        reasoning_content = (reasoning_content or "").strip()
+
+        # 若没有聚合到答案，但有思考内容，则保底返回思考内容
+        if not final_content and reasoning_content:
+            final_content = reasoning_content
+
+        # 返回包含推理内容的标准响应（若无推理则不会携带）
+        return self.create_openai_response_with_reasoning(
+            chat_id,
+            model,
+            final_content,
+            reasoning_content,
+            usage_info,
+        )

app/utils/__init__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from app.utils import sse_tool_handler, reload_config, logger
+
+__all__ = ["sse_tool_handler", "reload_config", "logger"]

app/utils/logger.py

@@ -0,0 +1,105 @@
+#!/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:
+        # 如果没有设置过logger，使用默认配置
+        logger.remove()  # 移除所有现有处理器
+        logger.add(sys.stderr, level="INFO", format="<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> | <level>{message}</level>")
+        app_logger = logger
+    return app_logger
+
+
+if __name__ == "__main__":
+    """Test the logger"""
+    import tempfile
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        try:
+            setup_logger(temp_dir, debug_mode=True)
+
+            logger.debug("这是一条调试日志")
+            logger.info("这是一条信息日志")
+            logger.warning("这是一条警告日志")
+            logger.error("这是一条错误日志")
+            logger.critical("这是一条严重日志")
+
+            try:
+                1 / 0
+            except ZeroDivisionError:
+                logger.exception("发生了除零异常")
+
+            print("✅ 日志测试完成")
+
+            logger.remove()
+
+        except Exception as e:
+            print(f"❌ 日志测试失败: {e}")
+            logger.remove()
+            raise

app/utils/reload_config.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+热重载配置模块
+定义 Granian 服务器热重载时需要忽略的目录和文件模式
+"""
+
+# 忽略的目录列表
+RELOAD_IGNORE_DIRS = [
+    "logs",  # 忽略日志目录
+    "storage",  # 忽略存储目录
+    "__pycache__",  # 忽略 Python 缓存
+    ".git",  # 忽略 git 目录
+    "node_modules",  # 忽略 node_modules
+    "migrations",  # 忽略数据库迁移目录
+    ".pytest_cache",  # 忽略 pytest 缓存
+    ".venv",  # 忽略虚拟环境
+    "venv",  # 忽略虚拟环境
+    "env",  # 忽略环境目录
+    ".mypy_cache",  # 忽略 mypy 缓存
+    ".ruff_cache",  # 忽略 ruff 缓存
+    "dist",  # 忽略构建分发目录
+    "build",  # 忽略构建目录
+    ".coverage",  # 忽略测试覆盖率文件
+    "htmlcov",  # 忽略覆盖率报告目录
+    "tests",  # 忽略测试目录
+    "z-ai2api-server.pid",  # 忽略 PID 文件
+]
+
+# 忽略的文件模式（正则表达式）
+RELOAD_IGNORE_PATTERNS = [
+    # 日志文件
+    r".*\.log$",
+    r".*\.log\.\d+$",
+    # 数据库文件
+    r".*\.sqlite3.*",
+    r".*\.db$",
+    r".*\.db-.*$",
+    # Python 相关
+    r".*\.pyc$",
+    r".*\.pyo$",
+    r".*\.pyd$",
+    # 临时文件
+    r".*\.tmp$",
+    r".*\.temp$",
+    r".*\.swp$",
+    r".*\.swo$",
+    r".*~$",
+    # 系统文件
+    r".*\.DS_Store$",
+    r".*Thumbs\.db$",
+    r".*\.directory$",
+    # 编辑器文件
+    r".*\.vscode.*",
+    r".*\.idea.*",
+    # 测试和覆盖率
+    r".*\.coverage$",
+    r".*\.pytest_cache.*",
+    # 构建文件
+    r".*\.egg-info.*",
+    r".*\.wheel$",
+    r".*\.whl$",
+    # 版本控制
+    r".*\.git.*",
+    r".*\.gitignore$",
+    r".*\.gitkeep$",
+    # 配置文件备份
+    r".*\.bak$",
+    r".*\.backup$",
+    r".*\.orig$",
+    # 锁文件
+    r".*\.lock$",
+    r".*\.pid$",
+]
+
+# 监视的路径（只监视应用相关代码）
+RELOAD_WATCH_PATHS = [
+    "app",  # 应用主目录
+    "main.py",  # 主入口文件
+]
+
+# 热重载配置
+RELOAD_CONFIG = {
+    "reload_ignore_dirs": RELOAD_IGNORE_DIRS,
+    "reload_ignore_patterns": RELOAD_IGNORE_PATTERNS,
+    "reload_paths": RELOAD_WATCH_PATHS,
+    "reload_tick": 100,  # 监视频率（毫秒）
+}

app/utils/sse_tool_handler.py

@@ -0,0 +1,612 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+SSE Tool Handler
+
+处理 Z.AI SSE 流数据并转换为 OpenAI 兼容格式的工具调用处理器。
+
+主要功能：
+- 解析 glm_block 格式的工具调用
+- 从 metadata.arguments 提取完整参数
+- 支持多阶段处理：thinking → tool_call → other → answer
+- 输出符合 OpenAI API 规范的流式响应
+"""
+
+import json
+import time
+from typing import Dict, Any, Generator
+from enum import Enum
+
+from app.utils.logger import get_logger
+
+logger = get_logger()
+
+
+class SSEPhase(Enum):
+    """SSE 处理阶段枚举"""
+    THINKING = "thinking"
+    TOOL_CALL = "tool_call"
+    OTHER = "other"
+    ANSWER = "answer"
+    DONE = "done"
+
+
+class SSEToolHandler:
+    """SSE 工具调用处理器"""
+
+    def __init__(self, model: str, stream: bool = True):
+        self.model = model
+        self.stream = stream
+
+        # 状态管理
+        self.current_phase = None
+        self.has_tool_call = False
+
+        # 工具调用状态
+        self.tool_id = ""
+        self.tool_name = ""
+        self.tool_args = ""
+        self.tool_call_usage = {}
+        self.content_index = 0  # 工具调用索引
+
+        # 性能优化：内容缓冲
+        self.content_buffer = ""
+        self.buffer_size = 0
+        self.last_flush_time = time.time()
+        self.flush_interval = 0.05  # 50ms 刷新间隔
+        self.max_buffer_size = 100  # 最大缓冲字符数
+
+        logger.debug(f"🔧 初始化工具处理器: model={model}, stream={stream}")
+
+    def process_sse_chunk(self, chunk_data: Dict[str, Any]) -> Generator[str, None, None]:
+        """
+        处理 SSE 数据块，返回 OpenAI 格式的流式响应
+
+        Args:
+            chunk_data: Z.AI SSE 数据块
+
+        Yields:
+            str: OpenAI 格式的 SSE 响应行
+        """
+        try:
+            phase = chunk_data.get("phase")
+            edit_content = chunk_data.get("edit_content", "")
+            delta_content = chunk_data.get("delta_content", "")
+            edit_index = chunk_data.get("edit_index")
+            usage = chunk_data.get("usage", {})
+
+            # 数据验证
+            if not phase:
+                logger.warning("⚠️ 收到无效的 SSE 块：缺少 phase 字段")
+                return
+
+            # 阶段变化检测和日志
+            if phase != self.current_phase:
+                # 阶段变化时强制刷新缓冲区
+                if hasattr(self, 'content_buffer') and self.content_buffer:
+                    yield from self._flush_content_buffer()
+
+                logger.info(f"📈 SSE 阶段变化: {self.current_phase} → {phase}")
+                content_preview = edit_content or delta_content
+                if content_preview:
+                    logger.debug(f"   📝 内容预览: {content_preview[:1000]}{'...' if len(content_preview) > 1000 else ''}")
+                if edit_index is not None:
+                    logger.debug(f"   📍 edit_index: {edit_index}")
+                self.current_phase = phase
+
+            # 根据阶段处理
+            if phase == SSEPhase.THINKING.value:
+                yield from self._process_thinking_phase(delta_content)
+
+            elif phase == SSEPhase.TOOL_CALL.value:
+                yield from self._process_tool_call_phase(edit_content)
+
+            elif phase == SSEPhase.OTHER.value:
+                yield from self._process_other_phase(usage, edit_content)
+
+            elif phase == SSEPhase.ANSWER.value:
+                yield from self._process_answer_phase(delta_content)
+
+            elif phase == SSEPhase.DONE.value:
+                yield from self._process_done_phase(chunk_data)
+            else:
+                logger.warning(f"⚠️ 未知的 SSE 阶段: {phase}")
+
+        except Exception as e:
+            logger.error(f"❌ 处理 SSE 块时发生错误: {e}")
+            logger.debug(f"   📦 错误块数据: {chunk_data}")
+            # 不中断流，继续处理后续块
+
+    def _process_thinking_phase(self, delta_content: str) -> Generator[str, None, None]:
+        """处理思考阶段"""
+        if not delta_content:
+            return
+
+        logger.debug(f"🤔 思考内容: +{len(delta_content)} 字符")
+
+        # 在流模式下输出思考内容
+        if self.stream:
+            chunk = self._create_content_chunk(delta_content)
+            yield f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n"
+
+    def _process_tool_call_phase(self, edit_content: str) -> Generator[str, None, None]:
+        """处理工具调用阶段"""
+        if not edit_content:
+            return
+
+        logger.debug(f"🔧 进入工具调用阶段，内容长度: {len(edit_content)}")
+
+        # 检测 glm_block 标记
+        if "<glm_block " in edit_content:
+            yield from self._handle_glm_blocks(edit_content)
+        else:
+            # 没有 glm_block 标记，可能是参数补充
+            if self.has_tool_call:
+                # 只累积���数部分，找到第一个 ", "result"" 之前的内容
+                result_pos = edit_content.find('", "result"')
+                if result_pos > 0:
+                    param_fragment = edit_content[:result_pos]
+                    self.tool_args += param_fragment
+                    logger.debug(f"📦 累积参数片段: {param_fragment}")
+                else:
+                    # 如果没有找到结束标记，累积整个内容（可能是中间片段）
+                    self.tool_args += edit_content
+                    logger.debug(f"📦 累积参数片段: {edit_content[:100]}...")
+
+    def _handle_glm_blocks(self, edit_content: str) -> Generator[str, None, None]:
+        """处理 glm_block 标记的内容"""
+        blocks = edit_content.split('<glm_block ')
+        logger.debug(f"📦 分割得到 {len(blocks)} 个块")
+
+        for index, block in enumerate(blocks):
+            if not block.strip():
+                continue
+
+            if index == 0:
+                # 第一个块：提取参数片段
+                if self.has_tool_call:
+                    logger.debug(f"📦 从第一个块提取参数片段")
+                    # 找到 "result" 的位置，提取之前的参数片段
+                    result_pos = edit_content.find('"result"')
+                    if result_pos > 0:
+                        # 往前退3个字符去掉 ", "
+                        param_fragment = edit_content[:result_pos - 3]
+                        self.tool_args += param_fragment
+                        logger.debug(f"📦 累积参数片段: {param_fragment}")
+                else:
+                    # 没有活跃工具调用，跳过第一个块
+                    continue
+            else:
+                # 后续块：处理新工具调用
+                if "</glm_block>" not in block:
+                    continue
+
+                # 如果有活跃的工具调用，先完成它
+                if self.has_tool_call:
+                    # 补全参数并完成工具调用
+                    self.tool_args += '"'  # 补全最后的引号
+                    yield from self._finish_current_tool()
+
+                # 处理新工具调用
+                yield from self._process_metadata_block(block)
+
+    def _process_metadata_block(self, block: str) -> Generator[str, None, None]:
+        """处理包含工具元数据的块"""
+        try:
+            # 提取 JSON 内容
+            start_pos = block.find('>')
+            end_pos = block.rfind('</glm_block>')
+
+            if start_pos == -1 or end_pos == -1:
+                logger.warning(f"❌ 无法找到 JSON 内容边界: {block[:1000]}...")
+                return
+
+            json_content = block[start_pos + 1:end_pos]
+            logger.debug(f"📦 提取的 JSON 内容: {json_content[:1000]}...")
+
+            # 解析工具元数据
+            metadata_obj = json.loads(json_content)
+
+            if "data" in metadata_obj and "metadata" in metadata_obj["data"]:
+                metadata = metadata_obj["data"]["metadata"]
+
+                # 开始新的工具调用
+                self.tool_id = metadata.get("id", f"call_{int(time.time() * 1000000)}")
+                self.tool_name = metadata.get("name", "unknown")
+                self.has_tool_call = True
+
+                # 只有在这是第二个及以后的工具调用时才递增 index
+                # 第一个工具调用应该使用 index 0
+
+                # 从 metadata.arguments 获取参数起始部分
+                if "arguments" in metadata:
+                    arguments_str = metadata["arguments"]
+                    # 去掉最后一个字符
+                    self.tool_args = arguments_str[:-1] if arguments_str.endswith('"') else arguments_str
+                    logger.debug(f"🎯 新工具调用: {self.tool_name}(id={self.tool_id}), 初始参数: {self.tool_args}")
+                else:
+                    self.tool_args = "{}"
+                    logger.debug(f"🎯 新工具调用: {self.tool_name}(id={self.tool_id}), 空参数")
+
+        except (json.JSONDecodeError, KeyError, AttributeError) as e:
+            logger.error(f"❌ 解析工具元数据失败: {e}, 块内容: {block[:1000]}...")
+
+        # 确保返回生成器（即使为空）
+        if False:  # 永远不会执行，但确保函数是生成器
+            yield
+
+    def _process_other_phase(self, usage: Dict[str, Any], edit_content: str = "") -> Generator[str, None, None]:
+        """处理其他阶段"""
+        # 保存使用统计信息
+        if usage:
+            self.tool_call_usage = usage
+            logger.debug(f"📊 保存使用统计: {usage}")
+
+        # 工具调用完成判断：检测到 "null," 开头的 edit_content
+        if self.has_tool_call and edit_content and edit_content.startswith("null,"):
+            logger.info(f"🏁 检测到工具调用结束标记")
+
+            # 完成当前工具调用
+            yield from self._finish_current_tool()
+
+            # 发��流结束标记
+            if self.stream:
+                yield "data: [DONE]\n\n"
+
+            # 重置状态
+            self._reset_all_state()
+
+    def _process_answer_phase(self, delta_content: str) -> Generator[str, None, None]:
+        """处理回答阶段（优化版本）"""
+        if not delta_content:
+            return
+
+        logger.info(f"📝 工具处理器收到答案内容: {delta_content[:50]}...")
+
+        # 添加到缓冲区
+        self.content_buffer += delta_content
+        self.buffer_size += len(delta_content)
+
+        current_time = time.time()
+        time_since_last_flush = current_time - self.last_flush_time
+
+        # 检查是否需要刷新缓冲区
+        should_flush = (
+            self.buffer_size >= self.max_buffer_size or  # 缓冲区满了
+            time_since_last_flush >= self.flush_interval or  # 时间间隔到了
+            '\n' in delta_content or  # 包含换行符
+            '。' in delta_content or '！' in delta_content or '？' in delta_content  # 包含句子结束符
+        )
+
+        if should_flush and self.content_buffer:
+            yield from self._flush_content_buffer()
+
+    def _flush_content_buffer(self) -> Generator[str, None, None]:
+        """刷新内容缓冲区"""
+        if not self.content_buffer:
+            return
+
+        logger.info(f"💬 工具处理器刷新缓冲区: {self.buffer_size} 字符 - {self.content_buffer[:50]}...")
+
+        if self.stream:
+            chunk = self._create_content_chunk(self.content_buffer)
+            output_data = f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n"
+            logger.info(f"➡️ 工具处理器输出: {output_data[:100]}...")
+            yield output_data
+
+        # 清空缓冲区
+        self.content_buffer = ""
+        self.buffer_size = 0
+        self.last_flush_time = time.time()
+
+    def _process_done_phase(self, chunk_data: Dict[str, Any]) -> Generator[str, None, None]:
+        """处理完成阶段"""
+        logger.info("🏁 对话完成")
+
+        # 先刷新任何剩余的缓冲内容
+        if self.content_buffer:
+            yield from self._flush_content_buffer()
+
+        # 完成任何未完成的工具调用
+        if self.has_tool_call:
+            yield from self._finish_current_tool()
+
+        # 发送流结束标记
+        if self.stream:
+            # 创建最终的完成块
+            final_chunk = {
+                "id": f"chatcmpl-{int(time.time())}",
+                "object": "chat.completion.chunk",
+                "created": int(time.time()),
+                "model": self.model,
+                "choices": [{
+                    "index": 0,
+                    "delta": {},
+                    "finish_reason": "stop"
+                }]
+            }
+
+            # 如果有 usage 信息，添加到最终块中
+            if "usage" in chunk_data:
+                final_chunk["usage"] = chunk_data["usage"]
+
+            yield f"data: {json.dumps(final_chunk, ensure_ascii=False)}\n\n"
+            yield "data: [DONE]\n\n"
+
+        # 重置所有状态
+        self._reset_all_state()
+
+    def _finish_current_tool(self) -> Generator[str, None, None]:
+        """完成当前工具调用"""
+        if not self.has_tool_call:
+            return
+
+        # 修复参数格式
+        fixed_args = self._fix_tool_arguments(self.tool_args)
+        logger.debug(f"✅ 完成工具调用: {self.tool_name}, 参数: {fixed_args}")
+
+        # 输出工具调用（开始 + 参数 + 完成）
+        if self.stream:
+            # 发送工具开始块
+            start_chunk = self._create_tool_start_chunk()
+            yield f"data: {json.dumps(start_chunk, ensure_ascii=False)}\n\n"
+
+            # 发送参数块
+            args_chunk = self._create_tool_arguments_chunk(fixed_args)
+            yield f"data: {json.dumps(args_chunk, ensure_ascii=False)}\n\n"
+
+            # 发送完成块
+            finish_chunk = self._create_tool_finish_chunk()
+            yield f"data: {json.dumps(finish_chunk, ensure_ascii=False)}\n\n"
+
+        # 重置工具状态
+        self._reset_tool_state()
+
+    def _fix_tool_arguments(self, raw_args: str) -> str:
+        """使用 json-repair 库修复工具参数格式"""
+        if not raw_args or raw_args == "{}":
+            return "{}"
+
+        logger.debug(f"🔧 开始修复参数: {raw_args[:1000]}{'...' if len(raw_args) > 1000 else ''}")
+
+        # 统一的修复流程：预处理 -> json-repair -> 后处理
+        try:
+            # 1. 预处理：只处理 json-repair 无法处理的问题
+            processed_args = self._preprocess_json_string(raw_args.strip())
+
+            # 2. 使用 json-repair 进行主要修复
+            from json_repair import repair_json
+            repaired_json = repair_json(processed_args)
+            logger.debug(f"🔧 json-repair 修复结果: {repaired_json}")
+
+            # 3. 解析并后处理
+            args_obj = json.loads(repaired_json)
+            args_obj = self._post_process_args(args_obj)
+
+            # 4. 生成最终结果
+            fixed_result = json.dumps(args_obj, ensure_ascii=False)
+
+            return fixed_result
+
+        except Exception as e:
+            logger.error(f"❌ JSON 修复失败: {e}, 原始参数: {raw_args[:1000]}..., 使用空参数")
+            return "{}"
+
+    def _post_process_args(self, args_obj: Dict[str, Any]) -> Dict[str, Any]:
+        """统一的后处理方法"""
+        # 修复路径中的过度转义
+        args_obj = self._fix_path_escaping_in_args(args_obj)
+
+        # 修复命令中的多余引号
+        args_obj = self._fix_command_quotes(args_obj)
+
+        return args_obj
+
+    def _preprocess_json_string(self, text: str) -> str:
+        """预处理 JSON 字符串，只处理 json-repair 无法处理的问题"""
+        import re
+
+        # 只保留 json-repair 无法处理的预处理步骤
+
+        # 1. 修复缺少开始括号的情况（json-repair 无法处理）
+        if not text.startswith('{') and text.endswith('}'):
+            text = '{' + text
+            logger.debug(f"🔧 补全开始括号")
+
+        # 2. 修复末尾多余的反斜杠和引号（json-repair 可能处理不当）
+        # 匹配模式：字符串值末尾的 \" 后面跟着 } 或 ,
+        # 例如：{"url":"https://www.bilibili.com\"} -> {"url":"https://www.bilibili.com"}
+        # 例如：{"url":"https://www.bilibili.com\",} -> {"url":"https://www.bilibili.com",}
+        pattern = r'([^\\])\\"([}\s,])'
+        if re.search(pattern, text):
+            text = re.sub(pattern, r'\1"\2', text)
+            logger.debug(f"🔧 修复末尾多余的反斜杠")
+
+        return text
+
+    def _fix_path_escaping_in_args(self, args_obj: Dict[str, Any]) -> Dict[str, Any]:
+        """修复参数对象中路径的过度转义问题"""
+        import re
+
+        # 需要检查的路径字段
+        path_fields = ['file_path', 'path', 'directory', 'folder']
+
+        for field in path_fields:
+            if field in args_obj and isinstance(args_obj[field], str):
+                path_value = args_obj[field]
+
+                # 检查是否是Windows路径且包含过度转义
+                if path_value.startswith('C:') and '\\\\' in path_value:
+                    logger.debug(f"🔍 检查路径字段 {field}: {repr(path_value)}")
+
+                    # 分析路径结构：正常路径应该是 C:\Users\...
+                    # 但过度转义的路径可能是 C:\Users\\Documents（多了一个反斜杠）
+                    # 我们需要找到不正常的双反斜杠模式并修复
+
+                    # 先检查是否有不正常的双反斜杠（不在路径开头）
+                    # 正常：C:\Users\Documents
+                    # 异常：C:\Users\\Documents 或 C:\Users\\\\Documents
+
+                    # 使用更精确的模式：匹配路径分隔符后的额外反斜杠
+                    # 但要保留正常的路径分隔符
+                    fixed_path = path_value
+
+                    # 检查是否有连续的多个反斜杠（超过正常的路径分隔符）
+                    if '\\\\' in path_value:
+                        # 计算反斜杠的数量，如果超过正常数量就修复
+                        parts = path_value.split('\\')
+                        # 重新组装路径，去除空的部分（由多余的反斜杠造成）
+                        clean_parts = [part for part in parts if part]
+                        if len(clean_parts) > 1:
+                            fixed_path = '\\'.join(clean_parts)
+
+                    logger.debug(f"🔍 修复后路径: {repr(fixed_path)}")
+
+                    if fixed_path != path_value:
+                        args_obj[field] = fixed_path
+                        logger.debug(f"🔧 修复字段 {field} 的路径转义: {path_value} -> {fixed_path}")
+                    else:
+                        logger.debug(f"🔍 路径无需修复: {path_value}")
+
+        return args_obj
+
+    def _fix_command_quotes(self, args_obj: Dict[str, Any]) -> Dict[str, Any]:
+        """修复命令中的多余引号问题"""
+        import re
+
+        # 检查命令字段
+        if 'command' in args_obj and isinstance(args_obj['command'], str):
+            command = args_obj['command']
+
+            # 检查是否以双引号结尾（多余的引号）
+            if command.endswith('""'):
+                logger.debug(f"🔧 发现命令末尾多余引号: {command}")
+                # 移除最后一个多余的引号
+                fixed_command = command[:-1]
+                args_obj['command'] = fixed_command
+                logger.debug(f"🔧 修复命令引号: {command} -> {fixed_command}")
+
+            # 检查其他可能的引号问题
+            # 例如：路径末尾的 \"" 模式
+            elif re.search(r'\\""+$', command):
+                logger.debug(f"🔧 发现命令末尾引号模式问题: {command}")
+                # 修复路径末尾的引号问题
+                fixed_command = re.sub(r'\\""+$', '\\"', command)
+                args_obj['command'] = fixed_command
+                logger.debug(f"🔧 修复命令引号模式: {command} -> {fixed_command}")
+
+        return args_obj
+
+    def _create_content_chunk(self, content: str) -> Dict[str, Any]:
+        """创建内容块"""
+        return {
+            "id": f"chatcmpl-{int(time.time())}",
+            "object": "chat.completion.chunk",
+            "created": int(time.time()),
+            "model": self.model,
+            "choices": [{
+                "index": 0,
+                "delta": {
+                    "role": "assistant",
+                    "content": content
+                },
+                "finish_reason": None
+            }]
+        }
+
+    def _create_tool_start_chunk(self) -> Dict[str, Any]:
+        """创建工具开始块"""
+        return {
+            "id": f"chatcmpl-{int(time.time())}",
+            "object": "chat.completion.chunk", 
+            "created": int(time.time()),
+            "model": self.model,
+            "choices": [{
+                "index": 0,
+                "delta": {
+                    "role": "assistant",
+                    "tool_calls": [{
+                        "index": self.content_index,
+                        "id": self.tool_id,
+                        "type": "function",
+                        "function": {
+                            "name": self.tool_name,
+                            "arguments": ""
+                        }
+                    }]
+                },
+                "finish_reason": None
+            }]
+        }
+
+    def _create_tool_arguments_chunk(self, arguments: str) -> Dict[str, Any]:
+        """创建工具参数块"""
+        return {
+            "id": f"chatcmpl-{int(time.time())}",
+            "object": "chat.completion.chunk",
+            "created": int(time.time()),
+            "model": self.model,
+            "choices": [{
+                "index": 0,
+                "delta": {
+                    "tool_calls": [{
+                        "index": self.content_index,
+                        "id": self.tool_id,
+                        "function": {
+                            "arguments": arguments
+                        }
+                    }]
+                },
+                "finish_reason": None
+            }]
+        }
+
+    def _create_tool_finish_chunk(self) -> Dict[str, Any]:
+        """创建工具完成块"""
+        chunk = {
+            "id": f"chatcmpl-{int(time.time())}",
+            "object": "chat.completion.chunk",
+            "created": int(time.time()),
+            "model": self.model,
+            "choices": [{
+                "index": 0,
+                "delta": {
+                    "tool_calls": []
+                },
+                "finish_reason": "tool_calls"
+            }]
+        }
+        
+        # 添加使用统计（如果有）
+        if self.tool_call_usage:
+            chunk["usage"] = self.tool_call_usage
+            
+        return chunk
+
+    def _reset_tool_state(self):
+        """重置工具状态"""
+        self.tool_id = ""
+        self.tool_name = ""
+        self.tool_args = ""
+        self.has_tool_call = False
+        # content_index 在单次对话中应该保持不变，只有在新的工具调用开始时才递增
+
+    def _reset_all_state(self):
+        """重置所有状态"""
+        # 先刷新任何剩余的缓冲内容
+        if hasattr(self, 'content_buffer') and self.content_buffer:
+            list(self._flush_content_buffer())  # 消费生成器
+
+        self._reset_tool_state()
+        self.current_phase = None
+        self.tool_call_usage = {}
+
+        # 重置缓冲区
+        self.content_buffer = ""
+        self.buffer_size = 0
+        self.last_flush_time = time.time()
+
+        # content_index 重置为 0，为下一轮对话做准备
+        self.content_index = 0
+        logger.debug("🔄 重置所有处理器状态")

app/utils/token_pool.py

@@ -0,0 +1,455 @@
+#!/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
+                # 预设为认证用户token，因为这些是用户手动配置的token
+                self.token_statuses[token] = TokenStatus(token=token, token_type="user")
+                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:
+                        # 预设为认证用户token，因为这些是用户手动配置的token
+                        self.token_statuses[token] = TokenStatus(token=token, token_type="user")
+                    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/user_agent.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+用户代理工具模块
+提供动态随机用户代理生成功能
+"""
+
+import random
+from typing import Dict, Optional
+from fake_useragent import UserAgent
+
+# 全局 UserAgent 实例（单例模式）
+_user_agent_instance: Optional[UserAgent] = 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_random_user_agent(browser_type: Optional[str] = None) -> str:
+    """
+    获取随机用户代理字符串
+
+    Args:
+        browser_type: 指定浏览器类型 ('chrome', 'firefox', 'safari', 'edge')
+                     如果为 None，则随机选择
+
+    Returns:
+        str: 用户代理字符串
+    """
+    ua = get_user_agent_instance()
+
+    # 如果没有指定浏览器类型，随机选择一个（偏向 Chrome 和 Edge）
+    if browser_type is None:
+        browser_choices = ["chrome", "chrome", "chrome", "edge", "edge", "firefox", "safari"]
+        browser_type = random.choice(browser_choices)
+
+    # 根据浏览器类型获取用户代理
+    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
+
+    return user_agent
+
+
+# 通用 UserAgent headers 生成函数
+def get_dynamic_headers(
+    referer: Optional[str] = None,
+    origin: Optional[str] = None,
+    browser_type: Optional[str] = None,
+    additional_headers: Optional[Dict[str, str]] = None
+) -> Dict[str, str]:
+    """
+    生成动态浏览器 headers，包含随机 User-Agent
+
+    Args:
+        referer: 引用页面 URL
+        origin: 源站 URL
+        browser_type: 指定浏览器类型
+        additional_headers: 额外的 headers
+
+    Returns:
+        Dict[str, str]: 包含动态 User-Agent 的 headers
+    """
+    user_agent = get_random_user_agent(browser_type)
+
+    # 基础 headers
+    headers = {
+        "User-Agent": user_agent,
+        "Accept": "application/json, text/event-stream",
+        "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
+        "Accept-Encoding": "gzip, deflate, br",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive",
+        "Pragma": "no-cache",
+    }
+
+    # 添加可选的 headers
+    if referer:
+        headers["Referer"] = referer
+
+    if origin:
+        headers["Origin"] = origin
+
+    # 根据用户代理添加浏览器特定的 headers
+    if "Chrome/" in user_agent or "Edg/" in user_agent:
+        # Chrome/Edge 特定的 headers
+        chrome_version = "139"
+        edge_version = "139"
+
+        try:
+            if "Chrome/" in user_agent:
+                chrome_version = user_agent.split("Chrome/")[1].split(".")[0]
+        except:
+            pass
+
+        try:
+            if "Edg/" in user_agent:
+                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"'
+            else:
+                sec_ch_ua = f'"Not_A Brand";v="8", "Chromium";v="{chrome_version}", "Google Chrome";v="{chrome_version}"'
+        except:
+            sec_ch_ua = f'"Not_A Brand";v="8", "Chromium";v="{chrome_version}", "Google Chrome";v="{chrome_version}"'
+
+        headers.update({
+            "sec-ch-ua": sec_ch_ua,
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "Sec-Fetch-Dest": "empty",
+            "Sec-Fetch-Mode": "cors",
+            "Sec-Fetch-Site": "same-origin",
+        })
+
+    # 添加额外的 headers
+    if additional_headers:
+        headers.update(additional_headers)
+
+    return headers
+
+

longcat_tokens.txt.example

@@ -0,0 +1,26 @@
+# LongCat Passport Token 配置文件（可选）
+#
+# 说明：
+# 1. 此文件是可选的，如果不需要多个token可以删除此文件
+# 2. 支持两种格式：每行一个token 或 逗号分隔的token
+# 3. 只包含有效的 passport_token_key 值
+# 4. 系统会自动去重和验证token有效性
+# 5. 自动跳过空格、换行符和空token
+# 6. 当设置了 LONGCAT_PASSPORT_TOKEN 环境变量时，优先使用环境变量中的token
+#
+# 格式1：纯换行分隔
+# token1
+# token2  
+# token3
+
+# 格式2：纯逗号分隔
+# token1,token2,token3
+
+# 格式3：混合格式
+# token1,token2
+# token3
+# token4,token5,token6
+# token7
+
+# 请在下方添加您的 LongCat passport token（使用任一格式）：
+

main.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import os
+import sys
+import psutil
+from contextlib import asynccontextmanager
+from fastapi import FastAPI, Response
+from fastapi.middleware.cors import CORSMiddleware
+
+from app.core.config import settings
+from app.core import openai
+from app.utils.reload_config import RELOAD_CONFIG
+from app.utils.logger import setup_logger
+from app.utils.token_pool import initialize_token_pool
+from app.providers import initialize_providers
+
+from granian import Granian
+
+
+# Setup logger
+logger = setup_logger(log_dir="logs", debug_mode=settings.DEBUG_LOGGING)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # 初始化提供商系统
+    initialize_providers()
+
+    # 初始化 token 池
+    token_list = settings.auth_token_list
+    if token_list:
+        token_pool = initialize_token_pool(
+            tokens=token_list,
+            failure_threshold=settings.TOKEN_FAILURE_THRESHOLD,
+            recovery_timeout=settings.TOKEN_RECOVERY_TIMEOUT
+        )
+
+    yield
+
+    logger.info("🔄 应用正在关闭...")
+
+
+# Create FastAPI app with lifespan
+app = FastAPI(lifespan=lifespan)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+    allow_headers=["Content-Type", "Authorization"],
+)
+
+# Include API routers
+app.include_router(openai.router)
+
+
+@app.options("/")
+async def handle_options():
+    """Handle OPTIONS requests"""
+    return Response(status_code=200)
+
+
+@app.get("/")
+async def root():
+    """Root endpoint"""
+    return {"message": "OpenAI Compatible API Server"}
+
+
+def run_server():
+    service_name = settings.SERVICE_NAME
+
+    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=False,  # 生产环境请关闭热重载
+            process_name=service_name,  # 设置进程名称
+            **RELOAD_CONFIG,    # 热重载配置
+        ).serve()
+    except KeyboardInterrupt:
+        logger.info("🛑 收到中断信号，正在关闭服务...")
+    except Exception as e:
+        logger.error(f"❌ 服务启动失败: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    run_server()

pyproject.toml

@@ -0,0 +1,67 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "z-ai2api-python"
+version = "0.1.0"
+description = "一个为 Z.ai 提供 OpenAI 兼容接口的 Python 代理服务"
+readme = "README.md"
+requires-python = ">=3.9,<=3.12"
+license = { text = "MIT" }
+authors = [{ name = "Contributors" }]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "fastapi==0.116.1",
+    "granian[reload,pname]==2.5.2",
+    "httpx==0.28.1",
+    "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",
+    "json-repair==0.44.1"
+]
+
+[project.scripts]
+z-ai2api = "main:app"
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]
+
+[tool.uv]
+dev-dependencies = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.21.0",
+    "requests>=2.30.0",
+    "ruff>=0.1.0",
+]
+
+[tool.ruff]
+line-length = 88
+target-version = "py38"
+select = ["E", "F", "I", "B"]
+ignore = []
+
+[tool.ruff.isort]
+known-first-party = []
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_functions = ["test_*"]

requirements.txt

@@ -0,0 +1,11 @@
+fastapi==0.116.1
+granian[reload,pname]==2.5.2
+httpx==0.28.1
+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
+json-repair==0.44.1

tests/test_comprehensive_fix.py

@@ -0,0 +1,289 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+全面测试 ZAI Provider 修复效果
+验证流式输出、工具调用、思考模式、重试机制等功能
+"""
+
+import asyncio
+import json
+import sys
+import os
+
+# 添加项目根目录到路径
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from app.providers.zai_provider import ZAIProvider
+from app.models.schemas import OpenAIRequest, Message
+from app.core.config import settings
+
+
+async def test_basic_stream():
+    """测试基本流式输出"""
+    print("🧪 测试基本流式输出...")
+    
+    provider = ZAIProvider()
+    
+    request = OpenAIRequest(
+        model=settings.PRIMARY_MODEL,
+        messages=[
+            Message(role="user", content="你好，请简单介绍一下自己")
+        ],
+        stream=True
+    )
+    
+    try:
+        response = await provider.chat_completion(request)
+        
+        if hasattr(response, '__aiter__'):
+            print("✅ 返回了异步生成器")
+            chunk_count = 0
+            content_chunks = []
+            
+            async for chunk in response:
+                chunk_count += 1
+                if chunk.startswith("data: ") and not chunk.strip().endswith("[DONE]"):
+                    try:
+                        chunk_data = json.loads(chunk[6:].strip())
+                        if "choices" in chunk_data and chunk_data["choices"]:
+                            choice = chunk_data["choices"][0]
+                            if "delta" in choice and "content" in choice["delta"]:
+                                content = choice["delta"]["content"]
+                                if content:
+                                    content_chunks.append(content)
+                    except:
+                        pass
+                
+                if chunk_count >= 10:  # 限制测试长度
+                    break
+            
+            full_content = "".join(content_chunks)
+            print(f"✅ 成功处理了 {chunk_count} 个数据块")
+            print(f"📝 内容预览: {full_content[:100]}...")
+            return len(content_chunks) > 0
+        else:
+            print("❌ 返回的不是流式响应")
+            return False
+            
+    except Exception as e:
+        print(f"❌ 基本流式测试失败: {e}")
+        return False
+
+
+async def test_thinking_mode():
+    """测试思考模式"""
+    print("\n🧪 测试思考模式...")
+    
+    provider = ZAIProvider()
+    
+    request = OpenAIRequest(
+        model=settings.THINKING_MODEL,
+        messages=[
+            Message(role="user", content="请解释一下量子计算的基本原理")
+        ],
+        stream=True
+    )
+    
+    try:
+        response = await provider.chat_completion(request)
+        
+        if hasattr(response, '__aiter__'):
+            print("✅ 返回了异步生成器")
+            chunk_count = 0
+            has_thinking = False
+            has_content = False
+            
+            async for chunk in response:
+                chunk_count += 1
+                
+                # 检查是否包含思考内容
+                if 'thinking' in chunk:
+                    has_thinking = True
+                    print("✅ 检测到思考内容")
+                
+                # 检查是否包含普通内容
+                if '"content"' in chunk and '"thinking"' not in chunk:
+                    has_content = True
+                    print("✅ 检测到答案内容")
+                
+                if chunk_count >= 20:  # 限制测试长度
+                    break
+            
+            print(f"✅ 成功处理了 {chunk_count} 个数据块")
+            print(f"🤔 思考模式: {'正常' if has_thinking else '未检测到'}")
+            print(f"💬 答案内容: {'正常' if has_content else '未检测到'}")
+            return True
+        else:
+            print("❌ 返回的不是流式响应")
+            return False
+            
+    except Exception as e:
+        print(f"❌ 思考模式测试失败: {e}")
+        return False
+
+
+async def test_tool_support():
+    """测试工具调用支持"""
+    print("\n🧪 测试工具调用支持...")
+    
+    if not settings.TOOL_SUPPORT:
+        print("⚠️ 工具支持已禁用，跳过测试")
+        return True
+    
+    provider = ZAIProvider()
+    
+    # 简单的工具定义
+    tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "get_weather",
+                "description": "获取指定城市的天气信息",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "city": {
+                            "type": "string",
+                            "description": "城市名称"
+                        }
+                    },
+                    "required": ["city"]
+                }
+            }
+        }
+    ]
+    
+    request = OpenAIRequest(
+        model=settings.PRIMARY_MODEL,
+        messages=[
+            Message(role="user", content="请帮我查询北京的天气")
+        ],
+        tools=tools,
+        stream=True
+    )
+    
+    try:
+        response = await provider.chat_completion(request)
+        
+        if hasattr(response, '__aiter__'):
+            print("✅ 返回了异步生成器")
+            chunk_count = 0
+            has_tool_call = False
+            
+            async for chunk in response:
+                chunk_count += 1
+                
+                # 检查是否包含工具调用
+                if 'tool_calls' in chunk:
+                    has_tool_call = True
+                    print("✅ 检测到工具调用")
+                
+                if chunk_count >= 30:  # 限制测试长度
+                    break
+            
+            print(f"✅ 成功处理了 {chunk_count} 个数据块")
+            print(f"🔧 工具调用: {'正常' if has_tool_call else '未检测到'}")
+            return True
+        else:
+            print("❌ 返回的不是流式响应")
+            return False
+            
+    except Exception as e:
+        print(f"❌ 工具调用测试失败: {e}")
+        return False
+
+
+async def test_error_handling():
+    """测试错误处理"""
+    print("\n🧪 测试错误处理...")
+    
+    provider = ZAIProvider()
+    
+    # 使用无效的消息来触发错误
+    request = OpenAIRequest(
+        model="invalid-model",
+        messages=[
+            Message(role="user", content="测试错误处理")
+        ],
+        stream=True
+    )
+    
+    try:
+        response = await provider.chat_completion(request)
+        
+        if hasattr(response, '__aiter__'):
+            chunk_count = 0
+            has_error = False
+            
+            async for chunk in response:
+                chunk_count += 1
+                
+                # 检查是否包含错误信息
+                if 'error' in chunk:
+                    has_error = True
+                    print("✅ 检测到错误处理")
+                
+                if chunk_count >= 5:  # 限制测试长度
+                    break
+            
+            print(f"✅ 错误处理测试完成，处理了 {chunk_count} 个数据块")
+            return True
+        else:
+            print("✅ 返回了错误响应（非流式）")
+            return True
+            
+    except Exception as e:
+        print(f"✅ 正确捕获了异常: {type(e).__name__}")
+        return True
+
+
+async def main():
+    """主测试函数"""
+    print("🚀 开始全面测试 ZAI Provider 修复效果\n")
+    
+    # 显示配置信息
+    print("📋 当前配置:")
+    print(f"  - 匿名模式: {settings.ANONYMOUS_MODE}")
+    print(f"  - 工具支持: {settings.TOOL_SUPPORT}")
+    print(f"  - 最大重试: {settings.MAX_RETRIES}")
+    print(f"  - 重试延迟: {settings.RETRY_DELAY}s")
+    print()
+    
+    tests = [
+        ("基本流式输出", test_basic_stream),
+        ("思考模式", test_thinking_mode),
+        ("工具调用支持", test_tool_support),
+        ("错误处理", test_error_handling),
+    ]
+    
+    passed = 0
+    total = len(tests)
+    
+    for test_name, test_func in tests:
+        try:
+            print(f"{'='*50}")
+            result = await test_func()
+            if result:
+                passed += 1
+                print(f"✅ {test_name} 测试通过")
+            else:
+                print(f"❌ {test_name} 测试失败")
+        except Exception as e:
+            print(f"❌ {test_name} 测试异常: {e}")
+        
+        print()
+    
+    print(f"{'='*50}")
+    print(f"📊 测试结果: {passed}/{total} 通过")
+    
+    if passed == total:
+        print("🎉 所有测试都通过了！ZAI Provider 修复成功")
+    elif passed >= total * 0.75:
+        print("✅ 大部分测试通过，ZAI Provider 基本修复成功")
+    else:
+        print("⚠️ 多个测试失败，需要进一步检查")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

tests/test_done_phase.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+"""
+测试 done 阶段处理
+"""
+
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from app.utils.sse_tool_handler import SSEToolHandler
+import json
+
+def test_done_phase_handling():
+    """测试 done 阶段的处理"""
+    
+    handler = SSEToolHandler("test-model", stream=True)
+    
+    print("🧪 测试 done 阶段处理\n")
+    
+    # 模拟完整的对话流程
+    test_chunks = [
+        # 回答阶段
+        {
+            "phase": "answer",
+            "delta_content": "这是回答内容",
+            "edit_content": ""
+        },
+        # 完成阶段
+        {
+            "phase": "done",
+            "done": True,
+            "delta_content": "",
+            "usage": {
+                "prompt_tokens": 100,
+                "completion_tokens": 50,
+                "total_tokens": 150
+            }
+        }
+    ]
+    
+    output_chunks = []
+    
+    for i, chunk in enumerate(test_chunks, 1):
+        print(f"处理块 {i}: phase={chunk['phase']}")
+        
+        results = list(handler.process_sse_chunk(chunk))
+        output_chunks.extend(results)
+        
+        print(f"  输出数量: {len(results)}")
+        for j, result in enumerate(results):
+            if result.strip() == "data: [DONE]":
+                print(f"  输出 {j+1}: [DONE] 标记")
+            else:
+                print(f"  输出 {j+1}: {result[:80]}{'...' if len(result) > 80 else ''}")
+        print()
+    
+    print(f"📊 测试结果:")
+    print(f"  总输出块数量: {len(output_chunks)}")
+    
+    # 验证输出内容
+    has_content = False
+    has_final_chunk = False
+    has_done_marker = False
+    has_usage = False
+    
+    for output in output_chunks:
+        if output.startswith("data: "):
+            json_str = output[6:].strip()
+            if json_str == "[DONE]":
+                has_done_marker = True
+                print("  ✅ 找到 [DONE] 标记")
+            elif json_str:
+                try:
+                    data = json.loads(json_str)
+                    if "choices" in data and data["choices"]:
+                        delta = data["choices"][0].get("delta", {})
+                        content = delta.get("content", "")
+                        finish_reason = data["choices"][0].get("finish_reason")
+                        
+                        if content:
+                            has_content = True
+                            print(f"  ✅ 找到内容: '{content}'")
+                        
+                        if finish_reason == "stop":
+                            has_final_chunk = True
+                            print("  ✅ 找到最终完成块")
+                        
+                        if "usage" in data:
+                            has_usage = True
+                            print(f"  ✅ 找到 usage 信息: {data['usage']}")
+                            
+                except json.JSONDecodeError as e:
+                    print(f"  ❌ JSON 解析错误: {e}")
+    
+    # 验证结果
+    success = has_content and has_final_chunk and has_done_marker
+    
+    print(f"\n📋 验证结果:")
+    print(f"  包含回答内容: {'✅' if has_content else '❌'}")
+    print(f"  包含最终完成块: {'✅' if has_final_chunk else '❌'}")
+    print(f"  包含 [DONE] 标记: {'✅' if has_done_marker else '❌'}")
+    print(f"  包含 usage 信息: {'✅' if has_usage else '❌'}")
+    
+    if success:
+        print("\n✅ done 阶段处理测试通过！")
+        return True
+    else:
+        print("\n❌ done 阶段处理测试失败！")
+        return False
+
+def test_done_phase_with_tool_call():
+    """测试带工具调用的 done 阶段处理"""
+    
+    handler = SSEToolHandler("test-model", stream=True)
+    
+    print("🧪 测试带工具调用的 done 阶段处理\n")
+    
+    # 模拟工具调用 + 回答 + 完成的流程
+    test_chunks = [
+        # 工具调用开始
+        {
+            "phase": "tool_call",
+            "edit_content": '<glm_block view="">{"type": "mcp", "data": {"metadata": {"id": "call_test", "name": "test_tool", "arguments": "{}", "result": "", "display_result": "", "duration": "...", "status": "completed", "is_error": false, "mcp_server": {"name": "mcp-server"}}, "thought": null, "ppt": null, "browser": null}}</glm_block>',
+            "edit_index": 100
+        },
+        # 工具调用结束
+        {
+            "phase": "other",
+            "edit_content": 'null, "display_result": "", "duration": "...", "status": "completed", "is_error": false, "mcp_server": {"name": "mcp-server"}}, "thought": null, "ppt": null, "browser": null}}</glm_block>',
+            "edit_index": 200
+        },
+        # 回答阶段
+        {
+            "phase": "answer",
+            "delta_content": "工具调用完成，这是回答。",
+            "edit_content": ""
+        },
+        # 完成阶段
+        {
+            "phase": "done",
+            "done": True,
+            "delta_content": ""
+        }
+    ]
+    
+    output_chunks = []
+    
+    for i, chunk in enumerate(test_chunks, 1):
+        print(f"处理块 {i}: phase={chunk['phase']}")
+        
+        results = list(handler.process_sse_chunk(chunk))
+        output_chunks.extend(results)
+        
+        print(f"  输出数量: {len(results)}")
+        print()
+    
+    # 检查是否有工具调用、回答内容和完成标记
+    has_tool_call = any("tool_calls" in output for output in output_chunks)
+    has_answer_content = any("工具调用完成" in output for output in output_chunks)
+    has_done_marker = any(output.strip() == "data: [DONE]" for output in output_chunks)
+    
+    print(f"📊 混合流程测试结果:")
+    print(f"  包含工具调用: {'✅' if has_tool_call else '❌'}")
+    print(f"  包含回答内容: {'✅' if has_answer_content else '❌'}")
+    print(f"  包含 [DONE] 标记: {'✅' if has_done_marker else '❌'}")
+    
+    success = has_tool_call and has_answer_content and has_done_marker
+    
+    if success:
+        print("\n✅ 混合流程 done 阶段测试通过！")
+        return True
+    else:
+        print("\n❌ 混合流程 done 阶段测试失败！")
+        return False
+
+def test_done_phase_warning_fix():
+    """测试 done 阶段不再产生警告"""
+    
+    handler = SSEToolHandler("test-model", stream=True)
+    
+    print("🧪 测试 done 阶段警告修复\n")
+    
+    # 模拟 done 阶段
+    chunk = {
+        "phase": "done",
+        "done": True,
+        "delta_content": ""
+    }
+    
+    print("处理 done 阶段块...")
+    
+    # 捕获日志输出（这里我们主要检查是否有异常）
+    try:
+        results = list(handler.process_sse_chunk(chunk))
+        print(f"  成功处理，输出 {len(results)} 个块")
+        
+        # 检查是否有 [DONE] 标记
+        has_done = any(output.strip() == "data: [DONE]" for output in results)
+        print(f"  包含 [DONE] 标记: {'✅' if has_done else '❌'}")
+        
+        print("\n✅ done 阶段不再产生警告！")
+        return True
+        
+    except Exception as e:
+        print(f"\n❌ 处理 done 阶段时出错: {e}")
+        return False
+
+if __name__ == "__main__":
+    print("🔧 测试 done 阶段处理\n")
+    
+    test1_success = test_done_phase_handling()
+    print("\n" + "="*50 + "\n")
+    test2_success = test_done_phase_with_tool_call()
+    print("\n" + "="*50 + "\n")
+    test3_success = test_done_phase_warning_fix()
+    
+    print("\n" + "="*50)
+    print("🎯 总结:")
+    print(f"  done 阶段基本处理: {'✅ 通过' if test1_success else '❌ 失败'}")
+    print(f"  done 阶段混合流程: {'✅ 通过' if test2_success else '❌ 失败'}")
+    print(f"  done 阶段警告修复: {'✅ 通过' if test3_success else '❌ 失败'}")
+    
+    if test1_success and test2_success and test3_success:
+        print("\n🎉 所有测试通过！done 阶段处理完善！")
+        print("\n💡 修复效果:")
+        print("  - 不再显示 '未知的 SSE 阶段: done' 警告")
+        print("  - 正确处理对话完成流程")
+        print("  - 自动刷新缓冲区和完成工具调用")
+        print("  - 发送标准的 OpenAI 完成标记")
+    else:
+        print("\n❌ 部分测试失败，需要进一步调试")

tests/test_longcat_connection.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+测试 LongCat API 连接性
+"""
+
+import asyncio
+import httpx
+import json
+
+# LongCat API 端点
+LONGCAT_API_ENDPOINT = "https://longcat.chat/api/v1/chat-completion-oversea"
+
+async def test_longcat_api():
+    """测试 LongCat API 连接"""
+    print(f"🧪 测试 LongCat API 连接...")
+    print(f"📡 API 端点: {LONGCAT_API_ENDPOINT}")
+    
+    headers = {
+        'accept': 'text/event-stream,application/json',
+        'content-type': 'application/json',
+        'origin': 'https://longcat.chat',
+        'referer': 'https://longcat.chat/t',
+        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36'
+    }
+    
+    payload = {
+        "stream": True,
+        "temperature": 0.7,
+        "content": "Hello",
+        "messages": [
+            {
+                "role": "user",
+                "content": "Hello"
+            }
+        ]
+    }
+    
+    print(f"📤 发送请求...")
+    print(f"📋 Headers: {json.dumps(headers, indent=2)}")
+    print(f"📋 Payload: {json.dumps(payload, indent=2)}")
+    
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.post(
+                LONGCAT_API_ENDPOINT,
+                headers=headers,
+                json=payload
+            )
+            
+            print(f"📡 响应状态码: {response.status_code}")
+            print(f"📋 响应头: {dict(response.headers)}")
+            
+            if not response.is_success:
+                error_text = await response.atext()
+                print(f"❌ API 错误: {error_text}")
+                return False
+            
+            print(f"✅ 连接成功，开始读取流数据...")
+            
+            line_count = 0
+            async for line in response.aiter_lines():
+                line_count += 1
+                line = line.strip()
+                print(f"📥 第 {line_count} 行: {line}")
+                
+                if line_count > 10:  # 只读取前10行
+                    print(f"⏹️ 停止读取（已读取 {line_count} 行）")
+                    break
+                    
+                if line.startswith('data:'):
+                    data_str = line[5:].strip()
+                    if data_str == '[DONE]':
+                        print(f"🏁 收到结束标记")
+                        break
+                    
+                    try:
+                        data = json.loads(data_str)
+                        print(f"📦 解析成功: {json.dumps(data, ensure_ascii=False, indent=2)}")
+                    except json.JSONDecodeError as e:
+                        print(f"❌ JSON 解析失败: {e}")
+            
+            print(f"✅ 测试完成，共读取 {line_count} 行")
+            return True
+            
+    except httpx.TimeoutException:
+        print(f"❌ 请求超时")
+        return False
+    except httpx.ConnectError as e:
+        print(f"❌ 连接错误: {e}")
+        return False
+    except Exception as e:
+        print(f"❌ 未知错误: {e}")
+        import traceback
+        print(f"❌ 错误堆栈: {traceback.format_exc()}")
+        return False
+
+async def test_simple_request():
+    """测试简单的非流式请求"""
+    print(f"\n🧪 测试简单的非流式请求...")
+    
+    headers = {
+        'accept': 'application/json',
+        'content-type': 'application/json',
+        'origin': 'https://longcat.chat',
+        'referer': 'https://longcat.chat/t',
+        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+    }
+    
+    payload = {
+        "stream": False,
+        "temperature": 0.7,
+        "content": "Hello",
+        "messages": [
+            {
+                "role": "user",
+                "content": "Hello"
+            }
+        ]
+    }
+    
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.post(
+                LONGCAT_API_ENDPOINT,
+                headers=headers,
+                json=payload
+            )
+            
+            print(f"📡 响应状态码: {response.status_code}")
+            
+            if response.is_success:
+                content = await response.atext()
+                print(f"✅ 响应内容: {content[:500]}...")
+                return True
+            else:
+                error_text = await response.atext()
+                print(f"❌ 错误响应: {error_text}")
+                return False
+                
+    except Exception as e:
+        print(f"❌ 请求失败: {e}")
+        return False
+
+async def main():
+    """运行所有测试"""
+    print("🚀 开始 LongCat API 连接测试...\n")
+    
+    # 测试流式请求
+    stream_result = await test_longcat_api()
+    
+    # 测试非流式请求
+    simple_result = await test_simple_request()
+    
+    print(f"\n📊 测试结果:")
+    print(f"  流式请求: {'✅ 成功' if stream_result else '❌ 失败'}")
+    print(f"  非流式请求: {'✅ 成功' if simple_result else '❌ 失败'}")
+    
+    if stream_result and simple_result:
+        print(f"🎉 所有测试通过！")
+    else:
+        print(f"⚠️ 部分测试失败，请检查网络连接和 API 端点")
+
+if __name__ == "__main__":
+    asyncio.run(main())

tests/test_multiple_tools.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""
+测试多个工具调用的处理逻辑
+"""
+
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from app.utils.sse_tool_handler import SSEToolHandler
+
+def test_multiple_tool_calls():
+    """测试多个工具调用的处理"""
+    
+    handler = SSEToolHandler("test-model", stream=False)
+    
+    print("🧪 测试多个工具调用处理\n")
+    
+    # 模拟真实的多工具调用序列（基于日志）
+    test_chunks = [
+        # 第一个工具调用开始
+        {
+            "phase": "tool_call",
+            "edit_content": '<glm_block view="">{"type": "mcp", "data": {"metadata": {"id": "call_5y5gir0mygx", "name": "mcp__playwright__browser_navigate", "arguments": "{\\"url\\":\\"https://www.bil", "result": "", "display_result": "", "duration": "...", "status": "completed", "is_error": false, "mcp_server": {"name": "mcp-server"}}, "thought": null, "ppt": null, "browser": null}}</glm_block>',
+            "edit_index": 24
+        },
+        # 第一个工具调用参数补充
+        {
+            "phase": "tool_call",
+            "edit_content": 'ibili.com\\"}',
+            "edit_index": 194
+        },
+        # 第一个工具调用结束
+        {
+            "phase": "other",
+            "edit_content": 'null, "display_result": "", "duration": "...", "status": "completed", "is_error": false, "mcp_server": {"name": "mcp-server"}}, "thought": null, "ppt": null, "browser": null}}</glm_block>',
+            "edit_index": 219
+        },
+        # 第二个工具调用开始
+        {
+            "phase": "tool_call", 
+            "edit_content": '<glm_block view="">{"type": "mcp", "data": {"metadata": {"id": "call_j8r24x6xtg", "name": "mcp__playwright__browser_snapshot", "arguments": "{}", "result": "", "display_result": "", "duration": "...", "status": "completed", "is_error": false, "mcp_server": {"name": "mcp-server"}}, "thought": null, "ppt": null, "browser": null}}</glm_block>',
+            "edit_index": 406
+        },
+        # 第二个工具调用结束
+        {
+            "phase": "other",
+            "edit_content": 'null, "display_result": "", "duration": "...", "status": "completed", "is_error": false, "mcp_server": {"name": "mcp-server"}}, "thought": null, "ppt": null, "browser": null}}</glm_block>',
+            "edit_index": 566
+        },
+        # 第三个工具调用开始（重复的 navigate）
+        {
+            "phase": "tool_call",
+            "edit_content": '<glm_block view="">{"type": "mcp", "data": {"metadata": {"id": "call_scvwo0xaoil", "name": "mcp__playwright__browser_navigate", "arguments": "{\\"url\\":\\"https://www.bil", "result": "", "display_result": "", "duration": "...", "status": "completed", "is_error": false, "mcp_server": {"name": "mcp-server"}}, "thought": null, "ppt": null, "browser": null}}</glm_block>',
+            "edit_index": 753
+        },
+        # 第三个工具调用参数补充
+        {
+            "phase": "tool_call",
+            "edit_content": 'ibili.com\\"}',
+            "edit_index": 925
+        },
+        # 第三个工具调用结束
+        {
+            "phase": "other",
+            "edit_content": 'null, "display_result": "", "duration": "...", "status": "completed", "is_error": false, "mcp_server": {"name": "mcp-server"}}, "thought": null, "ppt": null, "browser": null}}</glm_block>',
+            "edit_index": 950
+        }
+    ]
+    
+    tool_calls_completed = []
+    
+    for i, chunk in enumerate(test_chunks, 1):
+        print(f"处理块 {i}: edit_index={chunk['edit_index']}, phase={chunk['phase']}")
+        
+        # 记录处理前的工具状态
+        old_tool_id = handler.tool_id
+        old_tool_name = handler.tool_name
+        old_has_tool_call = handler.has_tool_call
+
+        # 处理块
+        results = list(handler.process_sse_chunk(chunk))
+
+        # 检查是否有新工具调用开始
+        if handler.tool_id != old_tool_id and handler.tool_id:
+            print(f"  🎯 新工具调用开始: {handler.tool_name} (id: {handler.tool_id})")
+
+        # 检查是否有工具调用完成
+        if old_has_tool_call and not handler.has_tool_call:
+            tool_calls_completed.append({
+                "name": old_tool_name or "unknown",
+                "id": old_tool_id
+            })
+            print(f"  ✅ 工具调用完成: {old_tool_name or 'unknown'}")
+        
+        print(f"  当前状态: has_tool_call={handler.has_tool_call}, tool_id={handler.tool_id}")
+        print()
+    
+    print(f"📊 测试结果:")
+    print(f"  完成的工具调用数量: {len(tool_calls_completed)}")
+    for i, tool in enumerate(tool_calls_completed, 1):
+        print(f"  {i}. {tool['name']} (id: {tool['id']})")
+    
+    # 验证是否正确处理了所有工具调用
+    expected_tools = [
+        "mcp__playwright__browser_navigate",
+        "mcp__playwright__browser_snapshot", 
+        "mcp__playwright__browser_navigate"
+    ]
+    
+    completed_tool_names = [tool['name'] for tool in tool_calls_completed]
+    
+    if completed_tool_names == expected_tools:
+        print("\n✅ 测试通过！正确处理了所有工具调用")
+        print("📝 结论：重复的工具调用是上游发送的，我们的处理逻辑是正确的")
+        return True
+    else:
+        print(f"\n❌ 测试失败！")
+        print(f"  期望: {expected_tools}")
+        print(f"  实际: {completed_tool_names}")
+        return False
+
+if __name__ == "__main__":
+    success = test_multiple_tool_calls()
+    
+    if success:
+        print("\n🎯 总结：")
+        print("1. 我们的 API 代理正确处理了每个不同的工具调用")
+        print("2. 重复的工具调用是上游 Z.AI 模型发送的，不是我们的问题")
+        print("3. 每个工具调用都有不同的 ID，说明这是模型的有意行为")
+        print("4. 可能的原因：模型重试、验证操作、或处理复杂任务的策略")
+    else:
+        print("\n❌ 需要进一步调试处理逻辑")

tests/test_simple_performance.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""
+简化的性能测试，避免过多日志输出
+"""
+
+import sys
+import os
+import time
+import json
+import logging
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# 临时禁用日志以避免性能测试中的噪音
+logging.getLogger().setLevel(logging.CRITICAL)
+
+from app.utils.sse_tool_handler import SSEToolHandler
+
+def test_optimized_performance():
+    """测试优化后的性能"""
+    
+    print("🧪 测试优化后的 JSON 修复性能\n")
+    
+    # 测试用例
+    test_cases = [
+        {
+            "name": "简单JSON",
+            "input": '{"command":"echo hello","description":"test"}',
+            "iterations": 100
+        },
+        {
+            "name": "复杂命令行参数",
+            "input": '{"command":"echo \\"添加更多内容\\uff1a$(date)\\\\\\" >> \\\\\\"C:\\\\\\\\Users\\\\\\\\test\\\\\\\\1.txt\\\\\\"\\"","description":"test"}',
+            "iterations": 50
+        },
+        {
+            "name": "缺少开始括号",
+            "input": '"command":"echo hello","description":"test"}',
+            "iterations": 50
+        },
+        {
+            "name": "Windows路径问题",
+            "input": '{"path":"C:\\\\\\\\Users\\\\\\\\Documents","command":"dir"}',
+            "iterations": 50
+        }
+    ]
+    
+    handler = SSEToolHandler("test-model", stream=False)
+    
+    total_time = 0
+    total_iterations = 0
+    
+    for test_case in test_cases:
+        print(f"测试: {test_case['name']}")
+        print(f"  输入长度: {len(test_case['input'])} 字符")
+        print(f"  迭代次数: {test_case['iterations']}")
+        
+        # 预热
+        for _ in range(5):
+            handler._fix_tool_arguments(test_case['input'])
+        
+        # 性能测试
+        start_time = time.time()
+        for _ in range(test_case['iterations']):
+            result = handler._fix_tool_arguments(test_case['input'])
+        end_time = time.time()
+        
+        duration = end_time - start_time
+        if duration > 0:
+            avg_time = duration / test_case['iterations'] * 1000  # 毫秒
+            throughput = test_case['iterations'] / duration
+        else:
+            avg_time = 0
+            throughput = float('inf')
+        
+        print(f"  总时间: {duration:.4f}s")
+        print(f"  平均时间: {avg_time:.4f}ms")
+        print(f"  吞吐量: {throughput:.1f} ops/s")
+        
+        total_time += duration
+        total_iterations += test_case['iterations']
+        
+        # 验证结果正确性
+        try:
+            parsed = json.loads(result)
+            print(f"  ✅ 结果有效")
+        except:
+            print(f"  ❌ 结果无效")
+        
+        print()
+    
+    print(f"📊 总体性能:")
+    print(f"  总时间: {total_time:.4f}s")
+    print(f"  总迭代: {total_iterations}")
+    if total_time > 0:
+        print(f"  平均性能: {total_iterations/total_time:.1f} ops/s")
+        print(f"  平均延迟: {total_time/total_iterations*1000:.4f}ms")
+    else:
+        print(f"  平均性能: ∞ ops/s")
+        print(f"  平均延迟: 0.0000ms")
+
+def test_code_simplification_benefits():
+    """测试代码简化的好处"""
+    
+    print("\n🧪 测试代码简化的好处\n")
+    
+    # 测试不同复杂度的JSON
+    test_cases = [
+        '{"command":"echo hello"}',  # 简单
+        '{"command":"echo \\"hello\\"","description":"test"}',  # 转义引号
+        '"command":"echo hello","description":"test"}',  # 缺少开始括号
+        '{"command":"echo hello > file.txt\\"","description":"test"}',  # 多余引号
+    ]
+    
+    handler = SSEToolHandler("test-model", stream=False)
+    
+    print("测试各种JSON修复场景:")
+    for i, test_input in enumerate(test_cases, 1):
+        print(f"\n场景 {i}: {test_input[:50]}{'...' if len(test_input) > 50 else ''}")
+        
+        start_time = time.time()
+        result = handler._fix_tool_arguments(test_input)
+        end_time = time.time()
+        
+        duration = (end_time - start_time) * 1000  # 毫秒
+        
+        try:
+            parsed = json.loads(result)
+            status = "✅ 成功"
+        except:
+            status = "❌ 失败"
+            
+        print(f"  处理时间: {duration:.4f}ms")
+        print(f"  修复状态: {status}")
+        print(f"  结果长度: {len(result)} 字符")
+
+def test_memory_efficiency():
+    """测试内存效率"""
+    
+    print("\n🧪 测试内存效率\n")
+    
+    try:
+        import psutil
+        process = psutil.Process()
+        
+        # 基线内存
+        baseline_memory = process.memory_info().rss / 1024 / 1024  # MB
+        print(f"基线内存: {baseline_memory:.2f} MB")
+        
+        handler = SSEToolHandler("test-model", stream=False)
+        
+        # 测试大量小JSON
+        test_data = '{"command":"echo test","description":"test"}'
+        
+        start_memory = process.memory_info().rss / 1024 / 1024
+        
+        for i in range(100):
+            result = handler._fix_tool_arguments(test_data)
+        
+        end_memory = process.memory_info().rss / 1024 / 1024
+        
+        print(f"处理100次后内存: {end_memory:.2f} MB")
+        print(f"内存增长: {end_memory - baseline_memory:.2f} MB")
+        print(f"平均每次处理: {(end_memory - start_memory) / 100 * 1024:.2f} KB")
+        
+    except ImportError:
+        print("psutil 未安装，跳过内存测试")
+
+if __name__ == "__main__":
+    test_optimized_performance()
+    test_code_simplification_benefits()
+    test_memory_efficiency()
+    
+    print("\n🎯 优化总结:")
+    print("✅ 简化了预处理逻辑")
+    print("✅ 统一了修复流程") 
+    print("✅ 减少了代码复杂度")
+    print("✅ 保持了修复质量")
+    print("✅ 提高了可维护性")

tokens.txt.example

@@ -0,0 +1,26 @@
+# 认证Token配置文件（可选）
+#
+# 说明：
+# 1. 此文件是可选的，如果不需要备用token可以删除此文件
+# 2. 支持两种格式：每行一个token 或 逗号分隔的token
+# 3. 只包含认证用户token (role: "user")，不要添加匿名用户token (role: "guest")
+# 4. 系统会自动去重和验证token有效性
+# 5. 自动跳过空格、换行符和空token
+# 6. 当匿名模式正常工作时，此文件中的token不会被使用
+#
+# 格式1：纯换行分隔
+# token1
+# token2  
+# token3
+
+# 格式2：纯逗号分隔
+# token1,token2,token3
+
+# 格式3：混合格式
+# token1,token2
+# token3
+# token4,token5,token6
+# token7
+
+# 请在下方添加您的认证用户token（使用任一格式）：
+