update sth at 2025-10-15 15:46:55

.replit

@@ -0,0 +1,16 @@
+modules = ["python-3.11"]
+# 这是最关键的修改：我们强制 Replit 构建一个完整的 Python 3.11 环境。
+[nix]
+channel = "stable-23.11"
+packages = ["cargo", "libiconv", "libxcrypt", "python311", "rustc"]
+
+# 这是第二关键的修改：我们使用 FastAPI 官方推荐的 uvicorn 来启动服务器。
+# 这将彻底解决所有兼容性问题。
+run = "uvicorn main:app --host 0.0.0.0 --port 8080"
+
+# 这一行保持不变。
+entrypoint = "main.py"
+
+[[ports]]
+localPort = 8080
+externalPort = 8080

Dockerfile

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

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

app/__init__.py

@@ -0,0 +1,7 @@
+"""
+Application package initialization
+"""
+
+from app import core, models, utils
+
+__all__ = ["core", "models", "utils"]

app/api/admin.py

@@ -0,0 +1,60 @@
+"""
+Admin API endpoints for token management
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import HTTPBearer
+from fastapi.security.http import HTTPAuthorizationCredentials
+from typing import Dict, Any
+
+from app.core.config import settings
+from app.core.token_manager import token_manager
+
+router = APIRouter(prefix="/admin", tags=["admin"])
+security = HTTPBearer()
+
+
+def verify_admin_token(credentials: HTTPAuthorizationCredentials = Depends(security)) -> str:
+    """Verify admin authentication token"""
+    if settings.SKIP_AUTH_TOKEN:
+        return credentials.credentials
+    
+    if credentials.credentials != settings.AUTH_TOKEN:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid authentication credentials",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    return credentials.credentials
+
+
+@router.get("/token-stats")
+async def get_token_stats(token: str = Depends(verify_admin_token)) -> Dict[str, Any]:
+    """Get token pool statistics"""
+    return token_manager.get_token_stats()
+
+
+@router.post("/reload-tokens")
+async def reload_tokens(token: str = Depends(verify_admin_token)) -> Dict[str, str]:
+    """Force reload tokens from file"""
+    try:
+        token_manager.reload_tokens()
+        return {"message": "Token池已重新加载"}
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"重新加载失败: {str(e)}"
+        )
+
+
+@router.post("/reset-tokens")
+async def reset_tokens(token: str = Depends(verify_admin_token)) -> Dict[str, str]:
+    """Reset all tokens (clear failure counts)"""
+    try:
+        token_manager.reset_all_tokens()
+        return {"message": "所有token状态已重置"}
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"重置失败: {str(e)}"
+        )

app/core/__init__.py

@@ -0,0 +1,7 @@
+"""
+Core module initialization
+"""
+
+from app.core import config, response_handlers, openai
+
+__all__ = ["config", "response_handlers", "openai"]

app/core/config.py

@@ -0,0 +1,78 @@
+"""
+FastAPI application configuration module
+"""
+
+import os
+from typing import Dict, Optional
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    """Application settings"""
+    
+    # API Configuration
+    API_ENDPOINT: str = os.getenv("API_ENDPOINT", "https://chat.z.ai/api/chat/completions")
+    AUTH_TOKEN: str = os.getenv("AUTH_TOKEN", "sk-your-api-key")
+    BACKUP_TOKEN: str = os.getenv("BACKUP_TOKEN", "eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjMxNmJjYjQ4LWZmMmYtNGExNS04NTNkLWYyYTI5YjY3ZmYwZiIsImVtYWlsIjoiR3Vlc3QtMTc1NTg0ODU4ODc4OEBndWVzdC5jb20ifQ.PktllDySS3trlyuFpTeIZf-7hl8Qu1qYF3BxjgIul0BrNux2nX9hVzIjthLXKMWAf9V0qM8Vm_iyDqkjPGsaiQ")
+    
+    # Model Configuration
+    PRIMARY_MODEL: str = os.getenv("PRIMARY_MODEL", "GLM-4.5")
+    THINKING_MODEL: str = os.getenv("THINKING_MODEL", "GLM-4.5-Thinking")
+    SEARCH_MODEL: str = os.getenv("SEARCH_MODEL", "GLM-4.5-Search")
+    AIR_MODEL: str = os.getenv("AIR_MODEL", "GLM-4.5-Air")
+    GLM_46_MODEL: str = os.getenv("GLM_46_MODEL", "GLM-4.6")
+    GLM_46_THINKING_MODEL: str = os.getenv("GLM_46_THINKING_MODEL", "GLM-4.6-Thinking")
+    
+    # Server Configuration
+    LISTEN_PORT: int = int(os.getenv("LISTEN_PORT", "8080"))
+    DEBUG_LOGGING: bool = os.getenv("DEBUG_LOGGING", "true").lower() == "true"
+    
+    # Feature Configuration
+    THINKING_PROCESSING: str = os.getenv("THINKING_PROCESSING", "think")  # strip: 去除<details>标签；think: 转为<span>标签；raw: 保留原样
+    ANONYMOUS_MODE: bool = os.getenv("ANONYMOUS_MODE", "true").lower() == "true"
+    TOOL_SUPPORT: bool = os.getenv("TOOL_SUPPORT", "true").lower() == "true"
+    SCAN_LIMIT: int = int(os.getenv("SCAN_LIMIT", "200000"))
+    SKIP_AUTH_TOKEN: bool = os.getenv("SKIP_AUTH_TOKEN", "false").lower() == "true"
+    
+    # Signature Configuration - 强制禁用，忽略所有环境变量
+    ENABLE_SIGNATURE: bool = False  # 强制禁用签名验证
+    SIGNATURE_SECRET_KEY: str = "disabled"  # 已禁用
+    SIGNATURE_ALGORITHM: str = "disabled"   # 已禁用
+    
+    # Token Pool Configuration
+    TOKEN_FILE_PATH: str = os.getenv("TOKEN_FILE_PATH", "./tokens.txt")
+    TOKEN_MAX_FAILURES: int = int(os.getenv("TOKEN_MAX_FAILURES", "3"))
+    TOKEN_RELOAD_INTERVAL: int = int(os.getenv("TOKEN_RELOAD_INTERVAL", "60"))
+    
+    # Request Configuration
+    REQUEST_TIMEOUT: int = int(os.getenv("REQUEST_TIMEOUT", "120"))
+    CONNECTION_TIMEOUT: int = int(os.getenv("CONNECTION_TIMEOUT", "30"))
+    MAX_RETRIES: int = int(os.getenv("MAX_RETRIES", "3"))
+    
+    # Proxy Configuration
+    HTTP_PROXY: Optional[str] = os.getenv("HTTP_PROXY")
+    HTTPS_PROXY: Optional[str] = os.getenv("HTTPS_PROXY")
+    
+    # Browser Headers - 匹配真实F12调试信息
+    CLIENT_HEADERS: Dict[str, str] = {
+        "Accept": "*/*",
+        "Accept-Encoding": "gzip, deflate, br, zstd",
+        "Accept-Language": "zh-CN",
+        "Content-Type": "application/json", 
+        "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 Edg/140.0.0.0",
+        "Sec-Ch-Ua": '"Chromium";v="140", "Not=A?Brand";v="24", "Microsoft Edge";v="140"',
+        "Sec-Ch-Ua-Mobile": "?0",
+        "Sec-Ch-Ua-Platform": '"Windows"',
+        "Sec-Fetch-Dest": "empty",
+        "Sec-Fetch-Mode": "cors",
+        "Sec-Fetch-Site": "same-origin",
+        "X-Fe-Version": "prod-fe-1.0.83",  # 匹配F12信息中的版本
+        "Origin": "https://chat.z.ai",
+        "Connection": "keep-alive",
+    }
+    
+    class Config:
+        env_file = ".env"
+
+
+settings = Settings()

app/core/openai.py

@@ -0,0 +1,651 @@
+"""
+OpenAI API endpoints
+"""
+
+import time
+import json
+import asyncio
+from datetime import datetime
+from typing import List, Dict, Any
+from fastapi import APIRouter, Header, HTTPException
+from fastapi.responses import StreamingResponse
+import httpx
+
+from app.core.config import settings
+from app.models.schemas import OpenAIRequest, Message, ModelsResponse, Model
+from app.utils.helpers import debug_log
+from app.core.zai_transformer import ZAITransformer, generate_uuid
+from app.utils.sse_tool_handler import SSEToolHandler
+
+router = APIRouter()
+
+# 全局转换器实例
+transformer = ZAITransformer()
+
+
+@router.get("/v1/models")
+async def list_models():
+    """List available models"""
+    current_time = int(time.time())
+    response = ModelsResponse(
+        data=[
+            Model(id=settings.PRIMARY_MODEL, created=current_time, owned_by="z.ai"),
+            Model(id=settings.THINKING_MODEL, created=current_time, owned_by="z.ai"),
+            Model(id=settings.SEARCH_MODEL, created=current_time, owned_by="z.ai"),
+            Model(id=settings.AIR_MODEL, created=current_time, owned_by="z.ai"),
+            Model(id=settings.GLM_46_MODEL, created=current_time, owned_by="z.ai"),
+            Model(id=settings.GLM_46_THINKING_MODEL, created=current_time, owned_by="z.ai"),
+        ]
+    )
+    return response
+
+
+@router.post("/v1/chat/completions")
+async def chat_completions(request: OpenAIRequest, authorization: str = Header(...)):
+    """Handle chat completion requests with ZAI transformer"""
+    role = request.messages[0].role if request.messages else "unknown"
+    debug_log(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")
+            
+        # 使用新的转换器转换请求
+        request_dict = request.model_dump()
+        debug_log("🔄 开始转换请求格式: OpenAI -> Z.AI")
+        
+        transformed = await transformer.transform_request_in(request_dict)
+
+        # 调用上游API
+        async def stream_response():
+            """流式响应生成器（包含重试机制）"""
+            retry_count = 0
+            last_error = None
+            current_token = transformed.get("token", "")  # 获取当前使用的token
+
+            while retry_count <= settings.MAX_RETRIES:
+                try:
+                    # 如果是重试，重新获取令牌并更新请求
+                    if retry_count > 0:
+                        delay = 2.0
+                        debug_log(f"重试请求 ({retry_count}/{settings.MAX_RETRIES}) - 等待 {delay:.1f}s")
+                        await asyncio.sleep(delay)
+
+                        # 标记前一个token失败
+                        if current_token:
+                            transformer.mark_token_failure(current_token, Exception(f"Retry {retry_count}: {last_error}"))
+
+                        # 重新获取令牌
+                        debug_log("🔑 重新获取令牌用于重试...")
+                        new_token = await transformer.get_token()
+                        if not new_token:
+                            debug_log("❌ 重试时无法获取有效的认证令牌")
+                            raise Exception("重试时无法获取有效的认证令牌")
+                        transformed["config"]["headers"]["Authorization"] = f"Bearer {new_token}"
+                        current_token = new_token
+
+                    async with httpx.AsyncClient(timeout=60.0) as client:
+                        # 发送请求到上游
+                        # debug_log(f"🎯 发送请求到 Z.AI: {transformed['config']['url']}")
+                        async with client.stream(
+                            "POST",
+                            transformed["config"]["url"],
+                            json=transformed["body"],
+                            headers=transformed["config"]["headers"],
+                        ) as response:
+                            # 检查响应状态码
+                            if response.status_code == 400:
+                                # 400 错误，触发重试
+                                error_text = await response.aread()
+                                error_msg = error_text.decode('utf-8', errors='ignore')
+                                debug_log(f"❌ 上游返回 400 错误 (尝试 {retry_count + 1}/{settings.MAX_RETRIES + 1})")
+                                debug_log(f"上游错误响应: {error_msg}")
+
+                                retry_count += 1
+                                last_error = f"400 Bad Request: {error_msg}"
+
+                                # 如果还有重试机会，继续循环
+                                if retry_count <= settings.MAX_RETRIES:
+                                    continue
+                                else:
+                                    # 达到最大重试次数，抛出错误
+                                    debug_log(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 == 401:
+                                # 认证错误，可能需要重新获取token
+                                debug_log(f"❌ 认证失败 (401)，标记token失效")
+                                if current_token:
+                                    transformer.mark_token_failure(current_token, Exception("401 Unauthorized"))
+                                
+                                retry_count += 1
+                                last_error = "401 Unauthorized - Token may be invalid"
+                                
+                                if retry_count <= settings.MAX_RETRIES:
+                                    continue
+                                else:
+                                    error_response = {
+                                        "error": {
+                                            "message": "Authentication failed after retries",
+                                            "type": "auth_error",
+                                            "code": 401
+                                        }
+                                    }
+                                    yield f"data: {json.dumps(error_response)}\n\n"
+                                    yield "data: [DONE]\n\n"
+                                    return
+                            
+                            elif response.status_code == 429:
+                                # 速率限制，延长等待时间重试
+                                debug_log(f"❌ 速率限制 (429)，将延长等待时间重试")
+                                retry_count += 1
+                                last_error = "429 Rate Limited"
+                                
+                                if retry_count <= settings.MAX_RETRIES:
+                                    continue
+                                else:
+                                    error_response = {
+                                        "error": {
+                                            "message": "Rate limit exceeded",
+                                            "type": "rate_limit_error", 
+                                            "code": 429
+                                        }
+                                    }
+                                    yield f"data: {json.dumps(error_response)}\n\n"
+                                    yield "data: [DONE]\n\n"
+                                    return
+                            
+                            elif response.status_code != 200:
+                                # 其他错误，检查是否需要重试
+                                error_text = await response.aread()
+                                error_msg = error_text.decode('utf-8', errors='ignore')
+                                debug_log(f"❌ 上游返回错误: {response.status_code}, 详情: {error_msg}")
+                                
+                                # 某些错误可以重试
+                                retryable_codes = [502, 503, 504]
+                                if response.status_code in retryable_codes and retry_count < settings.MAX_RETRIES:
+                                    retry_count += 1
+                                    last_error = f"{response.status_code}: {error_msg}"
+                                    debug_log(f"⚠️ 服务器错误 {response.status_code}，准备重试")
+                                    continue
+                                
+                                # 不可重试的错误或已达到重试上限
+                                error_response = {
+                                    "error": {
+                                        "message": f"Upstream error: {response.status_code}",
+                                        "type": "upstream_error",
+                                        "code": response.status_code,
+                                        "details": error_msg[:500]  # 限制错误详情长度
+                                    }
+                                }
+                                yield f"data: {json.dumps(error_response)}\n\n"
+                                yield "data: [DONE]\n\n"
+                                return
+
+                            # 200 成功，处理响应
+                            debug_log(f"✅ Z.AI 响应成功，开始处理 SSE 流")
+                            if retry_count > 0:
+                                debug_log(f"✨ 第 {retry_count} 次重试成功")
+
+                            # 标记token使用成功
+                            if current_token:
+                                transformer.mark_token_success(current_token)
+
+                            # 初始化工具处理器（如果需要）
+                            has_tools = transformed["body"].get("tools") is not None
+                            has_mcp_servers = bool(transformed["body"].get("mcp_servers"))
+                            tool_handler = None
+
+                            # 如果有工具定义或MCP服务器，都需要工具处理器
+                            if has_tools or has_mcp_servers:
+                                chat_id = transformed["body"]["chat_id"]
+                                model = request.model
+                                tool_handler = SSEToolHandler(chat_id, model)
+
+                                if has_tools and has_mcp_servers:
+                                    debug_log(f"🔧 初始化工具处理器: {len(transformed['body'].get('tools', []))} 个OpenAI工具 + {len(transformed['body'].get('mcp_servers', []))} 个MCP服务器")
+                                elif has_tools:
+                                    debug_log(f"🔧 初始化工具处理器: {len(transformed['body'].get('tools', []))} 个OpenAI工具")
+                                elif has_mcp_servers:
+                                    debug_log(f"🔧 初始化工具处理器: {len(transformed['body'].get('mcp_servers', []))} 个MCP服务器")
+
+                            # 处理状态
+                            has_thinking = False
+                            thinking_signature = None
+                            first_thinking_chunk = True
+
+                            # 处理SSE流 - 优化的buffer处理
+                            buffer = bytearray()
+                            incomplete_line = ""
+                            line_count = 0
+                            chunk_count = 0
+                            last_activity = time.time()
+                            debug_log("📡 开始接收 SSE 流数据...")
+
+                            async for chunk in response.aiter_bytes():
+                                chunk_count += 1
+                                last_activity = time.time()
+                                
+                                if not chunk:
+                                    continue
+
+                                # 将新数据添加到buffer
+                                buffer.extend(chunk)
+                                
+                                # 尝试解码并处理完整的行
+                                try:
+                                    # 解码为字符串并处理
+                                    text_data = buffer.decode('utf-8')
+                                    
+                                    # 分割为行
+                                    lines = text_data.split('\n')
+                                    
+                                    # 最后一行可能不完整，保存到incomplete_line
+                                    if not text_data.endswith('\n'):
+                                        incomplete_line = lines[-1]
+                                        lines = lines[:-1]
+                                    else:
+                                        # 如果有未完成的行，将其与第一行合并
+                                        if incomplete_line:
+                                            lines[0] = incomplete_line + lines[0]
+                                            incomplete_line = ""
+                                    
+                                    # 清空buffer，开始处理新的数据
+                                    buffer = bytearray()
+                                    if incomplete_line:
+                                        buffer.extend(incomplete_line.encode('utf-8'))
+                                    
+                                    # 处理完整的行
+                                    for current_line in lines:
+                                        line_count += 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]":
+                                                    debug_log("📡 收到 [DONE] 信号")
+                                                    yield "data: [DONE]\n\n"
+                                                continue
+
+                                            # debug_log(f"📦 解析数据块: {chunk_str[:200]}..." if len(chunk_str) > 200 else f"📦 解析数据块: {chunk_str}")
+
+                                            try:
+                                                chunk = json.loads(chunk_str)
+
+                                                if chunk.get("type") == "chat:completion":
+                                                    data = chunk.get("data", {})
+                                                    phase = data.get("phase")
+
+                                                    # 记录每个阶段（只在阶段变化时记录）
+                                                    if phase and phase != getattr(stream_response, '_last_phase', None):
+                                                        debug_log(f"📈 SSE 阶段: {phase}")
+                                                        stream_response._last_phase = phase
+
+                                                    # 处理工具调用
+                                                    if phase == "tool_call" and tool_handler:
+                                                        for output in tool_handler.process_tool_call_phase(data, True):
+                                                            yield output
+
+                                                    # 处理其他阶段（工具结束）
+                                                    elif phase == "other" and tool_handler:
+                                                        for output in tool_handler.process_other_phase(data, True):
+                                                            yield output
+
+                                                    # 处理思考内容
+                                                    elif phase == "thinking":
+                                                        if not has_thinking:
+                                                            has_thinking = True
+                                                            # 发送初始角色
+                                                            role_chunk = {
+                                                                "choices": [
+                                                                    {
+                                                                        "delta": {"role": "assistant"},
+                                                                        "finish_reason": None,
+                                                                        "index": 0,
+                                                                        "logprobs": None,
+                                                                    }
+                                                                ],
+                                                                "created": int(time.time()),
+                                                                "id": transformed["body"]["chat_id"],
+                                                                "model": request.model,
+                                                                "object": "chat.completion.chunk",
+                                                                "system_fingerprint": "fp_zai_001",
+                                                            }
+                                                            yield f"data: {json.dumps(role_chunk)}\n\n"
+
+                                                        delta_content = data.get("delta_content", "")
+                                                        if delta_content:
+                                                            # 处理思考内容格式
+                                                            if delta_content.startswith("<details"):
+                                                                content = (
+                                                                    delta_content.split("</summary>\n>")[-1].strip()
+                                                                    if "</summary>\n>" in delta_content
+                                                                    else delta_content
+                                                                )
+                                                            else:
+                                                                content = delta_content
+                                                            
+                                                            # 第一个思考块添加<think>开始标签，其他块保持纯内容
+                                                            if first_thinking_chunk:
+                                                                formatted_content = f"<think>{content}"
+                                                                first_thinking_chunk = False
+                                                            else:
+                                                                formatted_content = content
+
+                                                            thinking_chunk = {
+                                                                "choices": [
+                                                                    {
+                                                                        "delta": {
+                                                                            "role": "assistant",
+                                                                            "content": formatted_content,
+                                                                        },
+                                                                        "finish_reason": None,
+                                                                        "index": 0,
+                                                                        "logprobs": None,
+                                                                    }
+                                                                ],
+                                                                "created": int(time.time()),
+                                                                "id": transformed["body"]["chat_id"],
+                                                                "model": request.model,
+                                                                "object": "chat.completion.chunk",
+                                                                "system_fingerprint": "fp_zai_001",
+                                                            }
+                                                            yield f"data: {json.dumps(thinking_chunk)}\n\n"
+
+                                                    # 处理答案内容
+                                                    elif phase == "answer":
+                                                        edit_content = data.get("edit_content", "")
+                                                        delta_content = data.get("delta_content", "")
+
+                                                        # 如果还没有发送角色，先发送角色chunk
+                                                        if not has_thinking:
+                                                            has_thinking = True  # 设置标志避免重复发送
+                                                            role_chunk = {
+                                                                "choices": [
+                                                                    {
+                                                                        "delta": {"role": "assistant"},
+                                                                        "finish_reason": None,
+                                                                        "index": 0,
+                                                                        "logprobs": None,
+                                                                    }
+                                                                ],
+                                                                "created": int(time.time()),
+                                                                "id": transformed["body"]["chat_id"],
+                                                                "model": request.model,
+                                                                "object": "chat.completion.chunk",
+                                                                "system_fingerprint": "fp_zai_001",
+                                                            }
+                                                            debug_log("➡️ 发送初始角色chunk")
+                                                            yield f"data: {json.dumps(role_chunk)}\n\n"
+
+                                                        # 处理思考结束和答案开始
+                                                        if edit_content and "</details>\n" in edit_content:
+                                                            if has_thinking and not first_thinking_chunk:
+                                                                # 发送思考���束标记</think>
+                                                                thinking_signature = str(int(time.time() * 1000))
+                                                                sig_chunk = {
+                                                                    "choices": [
+                                                                        {
+                                                                            "delta": {
+                                                                                "role": "assistant",
+                                                                                "content": "</think>",
+                                                                            },
+                                                                            "finish_reason": None,
+                                                                            "index": 0,
+                                                                            "logprobs": None,
+                                                                        }
+                                                                    ],
+                                                                    "created": int(time.time()),
+                                                                    "id": transformed["body"]["chat_id"],
+                                                                    "model": request.model,
+                                                                    "object": "chat.completion.chunk",
+                                                                    "system_fingerprint": "fp_zai_001",
+                                                                }
+                                                                yield f"data: {json.dumps(sig_chunk)}\n\n"
+
+                                                            # 提取答案内容
+                                                            content_after = edit_content.split("</details>\n")[-1]
+                                                            if content_after:
+                                                                content_chunk = {
+                                                                "choices": [
+                                                                    {
+                                                                        "delta": {
+                                                                            "role": "assistant",
+                                                                            "content": content_after,
+                                                                        },
+                                                                        "finish_reason": None,
+                                                                        "index": 0,
+                                                                        "logprobs": None,
+                                                                    }
+                                                                ],
+                                                                "created": int(time.time()),
+                                                                "id": transformed["body"]["chat_id"],
+                                                                "model": request.model,
+                                                                "object": "chat.completion.chunk",
+                                                                "system_fingerprint": "fp_zai_001",
+                                                            }
+                                                            yield f"data: {json.dumps(content_chunk)}\n\n"
+
+                                                        # 处理增量内容
+                                                        elif delta_content:
+                                                            # 如果还没有发送角色
+                                                            if not has_thinking:
+                                                                has_thinking = True  # 避免重复发送
+                                                                role_chunk = {
+                                                                    "choices": [
+                                                                        {
+                                                                            "delta": {"role": "assistant"},
+                                                                            "finish_reason": None,
+                                                                            "index": 0,
+                                                                            "logprobs": None,
+                                                                        }
+                                                                    ],
+                                                                    "created": int(time.time()),
+                                                                    "id": transformed["body"]["chat_id"],
+                                                                    "model": request.model,
+                                                                    "object": "chat.completion.chunk",
+                                                                    "system_fingerprint": "fp_zai_001",
+                                                                }
+                                                                debug_log("➡️ 发送初始角色chunk")
+                                                                yield f"data: {json.dumps(role_chunk)}\n\n"
+
+                                                            content_chunk = {
+                                                                "choices": [
+                                                                    {
+                                                                        "delta": {
+                                                                            "content": delta_content,
+                                                                        },
+                                                                        "finish_reason": None,
+                                                                        "index": 0,
+                                                                        "logprobs": None,
+                                                                    }
+                                                                ],
+                                                                "created": int(time.time()),
+                                                                "id": transformed["body"]["chat_id"],
+                                                                "model": request.model,
+                                                                "object": "chat.completion.chunk",
+                                                                "system_fingerprint": "fp_zai_001",
+                                                            }
+                                                            output_data = f"data: {json.dumps(content_chunk)}\n\n"
+                                                            # debug_log(f"➡️ 输出内容块到客户端: {delta_content[:50]}...")
+                                                            yield output_data
+
+                                                    # 处理完成 - 当收到usage信息时
+                                                    if data.get("usage"):
+                                                        debug_log(f"📦 完成响应 - 使用统计: {json.dumps(data['usage'])}")
+
+                                                        # 只有在非工具调用模式下才发送普通完成信号
+                                                        if not tool_handler or not tool_handler.has_tool_call:
+                                                            finish_chunk = {
+                                                                "choices": [
+                                                                    {
+                                                                        "delta": {},  # 空的delta表示结束
+                                                                        "finish_reason": "stop",
+                                                                        "index": 0,
+                                                                        "logprobs": None,
+                                                                    }
+                                                                ],
+                                                                "usage": data["usage"],
+                                                                "created": int(time.time()),
+                                                                "id": transformed["body"]["chat_id"],
+                                                                "model": request.model,
+                                                                "object": "chat.completion.chunk",
+                                                                "system_fingerprint": "fp_zai_001",
+                                                            }
+                                                            finish_output = f"data: {json.dumps(finish_chunk)}\n\n"
+                                                            debug_log("➡️ 发送完成信号")
+                                                            yield finish_output
+                                                            debug_log("➡️ 发送 [DONE]")
+                                                            yield "data: [DONE]\n\n"
+
+                                            except json.JSONDecodeError as e:
+                                                debug_log(f"❌ JSON解析错误: {e}, 内容: {chunk_str[:200]}")
+                                            except Exception as e:
+                                                debug_log(f"❌ 处理chunk错误: {e}")
+                                
+                                except UnicodeDecodeError:
+                                    # 如果解码失败，可能是数据不完整，继续接收
+                                    debug_log(f"⚠️ 数据解码失败，缓冲区大小: {len(buffer)}")
+                                    if len(buffer) > 1024 * 1024:  # 1MB限制
+                                        debug_log("❌ 缓冲区过大，清空重试")
+                                        buffer = bytearray()
+                                        incomplete_line = ""
+                                except Exception as e:
+                                    debug_log(f"❌ Buffer处理异常: {e}")
+                                    # 清空buffer继续处理
+                                    buffer = bytearray()
+                                    incomplete_line = ""
+                                
+                                # 检查是否长时间没有活动（超时检查）
+                                if time.time() - last_activity > 30:  # 30秒超时
+                                    debug_log("⚠️ 检测到长时间无活动，可能连接中断")
+                                    break
+
+                            # 确保发送结束信号
+                            if not tool_handler or not tool_handler.has_tool_call:
+                                debug_log("📤 发送最终 [DONE] 信号")
+                                yield "data: [DONE]\n\n"
+
+                            debug_log(f"✅ SSE 流处理完成，共处理 {line_count} 行数据，{chunk_count} 个数据块")
+                            
+                            # 检查处理完整性
+                            is_complete = True
+                            completion_issues = []
+                            
+                            if line_count == 0:
+                                is_complete = False
+                                completion_issues.append("没有处理任何数据行")
+                            elif chunk_count == 0:
+                                is_complete = False
+                                completion_issues.append("没有收到任何数据块")
+                            elif chunk_count > 0:
+                                debug_log(f"📊 平均每个数据块包含 {line_count/chunk_count:.1f} 行")
+                            
+                            # 检查工具调用完整性
+                            if tool_handler and tool_handler.has_tool_call:
+                                if not tool_handler.completed_tools:
+                                    completion_issues.append("工具调用未正常完成")
+                                else:
+                                    debug_log(f"✅ 工具调用完成: {len(tool_handler.completed_tools)} 个工具")
+                            
+                            # 检查思考内容完整性（只有真正的thinking模式才需要签名）
+                            # 注意：普通的answer阶段不需要thinking签名，只有thinking阶段才需要
+                            # if has_thinking and not thinking_signature:
+                            #     completion_issues.append("思考内容缺少签名")
+                            
+                            # 报告完整性状态
+                            if is_complete and not completion_issues:
+                                debug_log("✅ 响应完整性检查通过")
+                            else:
+                                debug_log(f"⚠️ 响应完整性问题: {', '.join(completion_issues)}")
+                                
+                                # 如果问题严重且还有重试机会，考虑重试
+                                critical_issues = ["没有处理任何数据行", "没有收到任何数据块"]
+                                has_critical_issue = any(issue in completion_issues for issue in critical_issues)
+                                
+                                if has_critical_issue and retry_count < settings.MAX_RETRIES:
+                                    debug_log("🔄 检测到严重完整性问题，准备重试")
+                                    retry_count += 1
+                                    last_error = f"Incomplete response: {', '.join(completion_issues)}"
+                                    continue
+                            
+                            # 成功处理完成，退出重试循环
+                            return
+
+                except Exception as e:
+                    debug_log(f"❌ 流处理错误: {e}")
+                    import traceback
+                    debug_log(traceback.format_exc())
+
+                    # 标记token失败
+                    if current_token:
+                        transformer.mark_token_failure(current_token, e)
+
+                    # 检查是否还可以重试
+                    retry_count += 1
+                    last_error = str(e)
+
+                    if retry_count > settings.MAX_RETRIES:
+                        # 达到最大重试次数，返回错误
+                        debug_log(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
+
+        # 返回流式响应
+        debug_log("🚀 启动 SSE 流式响应")
+        
+        # 创建一个包装的生成器来追踪数据流
+        async def logged_stream():
+            chunk_count = 0
+            try:
+                debug_log("📤 开始向客户端流式传输数据...")
+                async for chunk in stream_response():
+                    chunk_count += 1
+                    # debug_log(f"📤 发送块[{chunk_count}]: {chunk[:200]}..." if len(chunk) > 200 else f"  📤 发送块[{chunk_count}]: {chunk}")
+                    yield chunk
+                debug_log(f"✅ 流式传输完成，共发送 {chunk_count} 个数据块")
+            except Exception as e:
+                debug_log(f"❌ 流式传输中断: {e}")
+                raise
+        
+        return StreamingResponse(
+            logged_stream(),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+            },
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        debug_log(f"❌ 处理请求时发生错误: {str(e)}")
+        import traceback
+
+        debug_log(f"❌ 错误堆栈: {traceback.format_exc()}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")

app/core/response_handlers.py

@@ -0,0 +1,546 @@
+"""
+Response handlers for streaming and non-streaming responses
+"""
+
+import json
+import time
+from typing import Generator, Optional
+import requests
+from fastapi import HTTPException
+from fastapi.responses import JSONResponse, StreamingResponse
+
+from app.core.config import settings
+from app.models.schemas import (
+    Message, Delta, Choice, Usage, OpenAIResponse, 
+    UpstreamRequest, UpstreamData, UpstreamError, ModelItem
+)
+from app.utils.helpers import debug_log, call_upstream_api, transform_thinking_content
+from app.core.token_manager import token_manager
+from app.utils.sse_parser import SSEParser
+from app.utils.tools import extract_tool_invocations, remove_tool_json_content
+from app.utils.sse_tool_handler import SSEToolHandler
+
+
+def create_openai_response_chunk(
+    model: str,
+    delta: Optional[Delta] = None,
+    finish_reason: Optional[str] = None
+) -> OpenAIResponse:
+    """Create OpenAI response chunk for streaming"""
+    return OpenAIResponse(
+        id=f"chatcmpl-{int(time.time())}",
+        object="chat.completion.chunk",
+        created=int(time.time()),
+        model=model,
+        choices=[Choice(
+            index=0,
+            delta=delta or Delta(),
+            finish_reason=finish_reason
+        )]
+    )
+
+
+def handle_upstream_error(error: UpstreamError) -> Generator[str, None, None]:
+    """Handle upstream error response"""
+    debug_log(f"上游错误: code={error.code}, detail={error.detail}")
+    
+    # Send end chunk
+    end_chunk = create_openai_response_chunk(
+        model=settings.PRIMARY_MODEL,
+        finish_reason="stop"
+    )
+    yield f"data: {end_chunk.model_dump_json()}\n\n"
+    yield "data: [DONE]\n\n"
+
+
+class ResponseHandler:
+    """Base class for response handling"""
+    
+    def __init__(self, upstream_req: UpstreamRequest, chat_id: str, auth_token: str):
+        self.upstream_req = upstream_req
+        self.chat_id = chat_id
+        self.auth_token = auth_token
+    
+    def _call_upstream(self) -> requests.Response:
+        """Call upstream API with error handling"""
+        max_retries = settings.MAX_RETRIES
+        retry_count = 0
+        
+        while retry_count < max_retries:
+            try:
+                debug_log(f"尝试调用上游API (第 {retry_count + 1}/{max_retries} 次)")
+                response = call_upstream_api(self.upstream_req, self.chat_id, self.auth_token)
+                
+                # Check if response is successful
+                if response.status_code == 200:
+                    # Mark token as successful
+                    token_manager.mark_token_success(self.auth_token)
+                    debug_log("上游API调用成功")
+                    return response
+                elif response.status_code in [401, 403]:
+                    # Authentication/authorization error - mark token as failed
+                    debug_log(f"Token认证失败 (状态码: {response.status_code}): {self.auth_token[:20]}...")
+                    token_manager.mark_token_failed(self.auth_token)
+                    
+                    # Try to get a new token
+                    new_token = token_manager.get_next_token()
+                    if new_token and new_token != self.auth_token:
+                        debug_log(f"尝试使用新token: {new_token[:20]}...")
+                        self.auth_token = new_token
+                        retry_count += 1
+                        continue
+                    else:
+                        debug_log("没有更多可用token")
+                        return response
+                elif response.status_code in [429]:
+                    # Rate limit - don't mark token as failed, just retry
+                    debug_log(f"遇到速率限制 (状态码: {response.status_code})，等待后重试")
+                    if retry_count < max_retries - 1:
+                        import time
+                        time.sleep(2 ** retry_count)  # 指数退避
+                        retry_count += 1
+                        continue
+                    else:
+                        return response
+                elif response.status_code >= 500:
+                    # Server error - retry without marking token as failed
+                    debug_log(f"服务器错误 (状态码: {response.status_code})，稍后重试")
+                    if retry_count < max_retries - 1:
+                        import time
+                        time.sleep(1)
+                        retry_count += 1
+                        continue
+                    else:
+                        return response
+                else:
+                    # Other client errors, return response as-is
+                    debug_log(f"客户端错误 (状态码: {response.status_code})")
+                    return response
+                    
+            except Exception as e:
+                error_msg = str(e)
+                debug_log(f"调用上游失败 (尝试 {retry_count + 1}/{max_retries}): {error_msg}")
+                
+                # 判断是否是连接问题还是token问题
+                is_connection_error = any(keyword in error_msg.lower() for keyword in [
+                    'connection', 'timeout', 'network', 'dns', 'socket', 'ssl'
+                ])
+                
+                if is_connection_error:
+                    debug_log("检测到网络连接问题，不标记token失败")
+                    # 网络问题不标记token失败，直接重试
+                    if retry_count < max_retries - 1:
+                        import time
+                        time.sleep(2)  # 等待2秒后重试
+                        retry_count += 1
+                        continue
+                    else:
+                        raise Exception(f"网络连接问题，重试{max_retries}次后仍失败: {error_msg}")
+                else:
+                    # 其他错误可能是token问题，标记失败并尝试新token
+                    debug_log("检测到可能的token问题，标记token失败")
+                    token_manager.mark_token_failed(self.auth_token)
+                    
+                    # Try to get a new token
+                    new_token = token_manager.get_next_token()
+                    if new_token and new_token != self.auth_token and retry_count < max_retries - 1:
+                        debug_log(f"尝试使用新token: {new_token[:20]}...")
+                        self.auth_token = new_token
+                        retry_count += 1
+                        continue
+                    else:
+                        raise
+        
+        # If we get here, all retries failed
+        raise Exception("所有重试尝试均失败")
+    
+    def _handle_upstream_error(self, response: requests.Response) -> None:
+        """Handle upstream error response"""
+        debug_log(f"上游返回错误状态: {response.status_code}")
+        if settings.DEBUG_LOGGING:
+            debug_log(f"上游错误响应: {response.text}")
+
+
+class StreamResponseHandler(ResponseHandler):
+    """Handler for streaming responses"""
+    
+    def __init__(self, upstream_req: UpstreamRequest, chat_id: str, auth_token: str, has_tools: bool = False):
+        super().__init__(upstream_req, chat_id, auth_token)
+        self.has_tools = has_tools
+        self.buffered_content = ""
+        self.tool_calls = None
+        # Initialize SSE tool handler for improved tool processing
+        self.tool_handler = SSEToolHandler(chat_id, settings.PRIMARY_MODEL) if has_tools else None
+        # 思考状态跟踪
+        self.first_thinking_chunk = True
+    
+    def handle(self) -> Generator[str, None, None]:
+        """Handle streaming response"""
+        debug_log(f"开始处理流式响应 (chat_id={self.chat_id})")
+        
+        try:
+            response = self._call_upstream()
+        except Exception:
+            yield "data: {\"error\": \"Failed to call upstream\"}\n\n"
+            return
+        
+        if response.status_code != 200:
+            self._handle_upstream_error(response)
+            yield "data: {\"error\": \"Upstream error\"}\n\n"
+            return
+        
+        # Send initial role chunk
+        first_chunk = create_openai_response_chunk(
+            model=settings.PRIMARY_MODEL,
+            delta=Delta(role="assistant")
+        )
+        yield f"data: {first_chunk.model_dump_json()}\n\n"
+        
+        # Process stream
+        debug_log("开始读取上游SSE流")
+        sent_initial_answer = False
+        stream_ended_normally = False
+        
+        try:
+            with SSEParser(response, debug_mode=settings.DEBUG_LOGGING) as parser:
+                for event in parser.iter_json_data(UpstreamData):
+                    upstream_data = event['data']
+                    
+                    # Check for errors
+                    if self._has_error(upstream_data):
+                        error = self._get_error(upstream_data)
+                        yield from handle_upstream_error(error)
+                        stream_ended_normally = True
+                        break
+                    
+                    debug_log(f"解析成功 - 类型: {upstream_data.type}, 阶段: {upstream_data.data.phase}, "
+                             f"内容长度: {len(upstream_data.data.delta_content or '')}, 完成: {upstream_data.data.done}")
+                    
+                    # Process content
+                    yield from self._process_content_with_tools(upstream_data, sent_initial_answer)
+                    
+                    # Update sent_initial_answer flag if we sent content
+                    if not sent_initial_answer and (upstream_data.data.delta_content or upstream_data.data.edit_content):
+                        sent_initial_answer = True
+                    
+                    # Check if done
+                    if upstream_data.data.done or upstream_data.data.phase == "done":
+                        debug_log("检测到流结束信号")
+                        yield from self._send_end_chunk()
+                        stream_ended_normally = True
+                        break
+                        
+        except Exception as e:
+            debug_log(f"SSE流处理异常: {e}")
+            # 流异常结束，发送错误响应
+            if not stream_ended_normally:
+                error_chunk = create_openai_response_chunk(
+                    model=settings.PRIMARY_MODEL,
+                    delta=Delta(content=f"\n\n[系统提示: 连接中断，响应可能不完整]")
+                )
+                yield f"data: {error_chunk.model_dump_json()}\n\n"
+        
+        # 确保流正常结束
+        if not stream_ended_normally:
+            debug_log("流未正常结束，发送结束信号")
+            yield from self._send_end_chunk(force_stop=True)
+    
+    def _has_error(self, upstream_data: UpstreamData) -> bool:
+        """Check if upstream data contains error"""
+        return bool(
+            upstream_data.error or 
+            upstream_data.data.error or 
+            (upstream_data.data.inner and upstream_data.data.inner.error)
+        )
+    
+    def _get_error(self, upstream_data: UpstreamData) -> UpstreamError:
+        """Get error from upstream data"""
+        return (
+            upstream_data.error or 
+            upstream_data.data.error or 
+            (upstream_data.data.inner.error if upstream_data.data.inner else None)
+        )
+    
+    def _process_content(
+        self, 
+        upstream_data: UpstreamData, 
+        sent_initial_answer: bool
+    ) -> Generator[str, None, None]:
+        """Process content from upstream data"""
+        content = upstream_data.data.delta_content or upstream_data.data.edit_content
+        
+        if not content:
+            return
+        
+        # Transform thinking content
+        if upstream_data.data.phase == "thinking":
+            content = transform_thinking_content(content)
+        
+        # Buffer content if tools are enabled
+        if self.has_tools:
+            self.buffered_content += content
+        else:
+            # Handle initial answer content
+            if (not sent_initial_answer and 
+                upstream_data.data.edit_content and 
+                upstream_data.data.phase == "answer"):
+                
+                content = self._extract_edit_content(upstream_data.data.edit_content)
+                if content:
+                    debug_log(f"发送普通内容: {content}")
+                    chunk = create_openai_response_chunk(
+                        model=settings.PRIMARY_MODEL,
+                        delta=Delta(content=content)
+                    )
+                    yield f"data: {chunk.model_dump_json()}\n\n"
+                    sent_initial_answer = True
+            
+            # Handle delta content
+            if upstream_data.data.delta_content:
+                if content:
+                    if upstream_data.data.phase == "thinking":
+                        # 第一个思考块添加<think>开始标签，其他块保持纯内容
+                        if self.first_thinking_chunk:
+                            formatted_content = f"<think>{content}"
+                            self.first_thinking_chunk = False
+                        else:
+                            formatted_content = content
+                        
+                        debug_log(f"发送思考内容: {content}")
+                        chunk = create_openai_response_chunk(
+                            model=settings.PRIMARY_MODEL,
+                            delta=Delta(content=formatted_content)
+                        )
+                    else:
+                        # 如果从thinking阶段转到其他阶段，需要结束thinking标签
+                        if not self.first_thinking_chunk and upstream_data.data.phase == "answer":
+                            # 先发送思考结束标签
+                            thinking_end_chunk = create_openai_response_chunk(
+                                model=settings.PRIMARY_MODEL,
+                                delta=Delta(content="</think>")
+                            )
+                            yield f"data: {thinking_end_chunk.model_dump_json()}\n\n"
+                            # 重置状态
+                            self.first_thinking_chunk = True
+                        
+                        debug_log(f"发送普通内容: {content}")
+                        chunk = create_openai_response_chunk(
+                            model=settings.PRIMARY_MODEL,
+                            delta=Delta(content=content)
+                        )
+                    yield f"data: {chunk.model_dump_json()}\n\n"
+    
+    def _extract_edit_content(self, edit_content: str) -> str:
+        """Extract content from edit_content field"""
+        parts = edit_content.split("</details>")
+        return parts[1] if len(parts) > 1 else ""
+    
+    def _send_end_chunk(self, force_stop: bool = False) -> Generator[str, None, None]:
+        """Send end chunk and DONE signal"""
+        finish_reason = "stop"
+        
+        if self.has_tools and not force_stop:
+            # Try to extract tool calls from buffered content
+            self.tool_calls = extract_tool_invocations(self.buffered_content)
+            
+            if self.tool_calls:
+                debug_log(f"检测到工具调用: {len(self.tool_calls)} 个")
+                # Send tool calls with proper format
+                for i, tc in enumerate(self.tool_calls):
+                    tool_call_delta = {
+                        "index": i,
+                        "id": tc.get("id"),
+                        "type": tc.get("type", "function"),
+                        "function": tc.get("function", {}),
+                    }
+                    
+                    out_chunk = create_openai_response_chunk(
+                        model=settings.PRIMARY_MODEL,
+                        delta=Delta(tool_calls=[tool_call_delta])
+                    )
+                    yield f"data: {out_chunk.model_dump_json()}\n\n"
+                
+                finish_reason = "tool_calls"
+            else:
+                # Send regular content
+                trimmed_content = remove_tool_json_content(self.buffered_content)
+                if trimmed_content:
+                    debug_log(f"发送常规内容: {len(trimmed_content)} 字符")
+                    content_chunk = create_openai_response_chunk(
+                        model=settings.PRIMARY_MODEL,
+                        delta=Delta(content=trimmed_content)
+                    )
+                    yield f"data: {content_chunk.model_dump_json()}\n\n"
+        elif force_stop:
+            # 强制结束时，发送缓冲的内容（如果有）
+            if self.buffered_content:
+                debug_log(f"强制结束，发送缓冲内容: {len(self.buffered_content)} 字符")
+                content_chunk = create_openai_response_chunk(
+                    model=settings.PRIMARY_MODEL,
+                    delta=Delta(content=self.buffered_content)
+                )
+                yield f"data: {content_chunk.model_dump_json()}\n\n"
+        
+        # Send final chunk
+        end_chunk = create_openai_response_chunk(
+            model=settings.PRIMARY_MODEL,
+            finish_reason=finish_reason
+        )
+        yield f"data: {end_chunk.model_dump_json()}\n\n"
+        yield "data: [DONE]\n\n"
+        debug_log(f"流式响应完成 (finish_reason: {finish_reason})")
+
+
+    
+    def _process_content_with_tools(
+        self, 
+        upstream_data: UpstreamData, 
+        sent_initial_answer: bool
+    ) -> Generator[str, None, None]:
+        """Process content with improved tool handling"""
+        # Handle tool calls with improved SSE tool handler
+        if self.has_tools and self.tool_handler:
+            # Check if this is a tool_call phase
+            if upstream_data.data.phase == "tool_call":
+                # Use the improved tool handler for tool call processing
+                yield from self.tool_handler.process_tool_call_phase(
+                    upstream_data.data.model_dump(), 
+                    is_stream=True
+                )
+                return
+            elif upstream_data.data.phase == "other":
+                # Handle other phase which may contain tool completion signals
+                yield from self.tool_handler.process_other_phase(
+                    upstream_data.data.model_dump(), 
+                    is_stream=True
+                )
+                return
+        
+        # Fall back to original content processing
+        yield from self._process_content(upstream_data, sent_initial_answer)
+
+
+class NonStreamResponseHandler(ResponseHandler):
+    """Handler for non-streaming responses"""
+    
+    def __init__(self, upstream_req: UpstreamRequest, chat_id: str, auth_token: str, has_tools: bool = False):
+        super().__init__(upstream_req, chat_id, auth_token)
+        self.has_tools = has_tools
+        # 思考状态跟踪
+        self.first_thinking_chunk = True
+        self.in_thinking_phase = False
+    
+    def handle(self) -> JSONResponse:
+        """Handle non-streaming response"""
+        debug_log(f"开始处理非流式响应 (chat_id={self.chat_id})")
+        
+        try:
+            response = self._call_upstream()
+        except Exception as e:
+            debug_log(f"调用上游失败: {e}")
+            raise HTTPException(status_code=502, detail="Failed to call upstream")
+        
+        if response.status_code != 200:
+            self._handle_upstream_error(response)
+            raise HTTPException(status_code=502, detail="Upstream error")
+        
+        # Collect full response
+        full_content = []
+        debug_log("开始收集完整响应内容")
+        response_completed = False
+        
+        try:
+            with SSEParser(response, debug_mode=settings.DEBUG_LOGGING) as parser:
+                for event in parser.iter_json_data(UpstreamData):
+                    upstream_data = event['data']
+                    
+                    if upstream_data.data.delta_content:
+                        content = upstream_data.data.delta_content
+                        
+                        if upstream_data.data.phase == "thinking":
+                            content = transform_thinking_content(content)
+                            
+                            # 处理思考内容的分块格式
+                            if not self.in_thinking_phase:
+                                # 进入思考阶段，添加开始标签
+                                self.in_thinking_phase = True
+                                if self.first_thinking_chunk:
+                                    content = f"<think>{content}"
+                                    self.first_thinking_chunk = False
+                                else:
+                                    content = f"<think>{content}"
+                            # 如果已经在思考阶段，保持纯内容
+                        else:
+                            # 如果从thinking阶段转到其他阶段
+                            if self.in_thinking_phase:
+                                # 添加结束标签到前一个内容
+                                if full_content and not self.first_thinking_chunk:
+                                    full_content.append("</think>")
+                                self.in_thinking_phase = False
+                                self.first_thinking_chunk = True
+                        
+                        if content:
+                            full_content.append(content)
+                    
+                    if upstream_data.data.done or upstream_data.data.phase == "done":
+                        debug_log("检测到完成信号，停止收集")
+                        response_completed = True
+                        break
+                        
+        except Exception as e:
+            debug_log(f"非流式响应收集异常: {e}")
+            if not full_content:
+                # 如果没有收集到任何内容，抛出异常
+                raise HTTPException(status_code=502, detail=f"Response collection failed: {str(e)}")
+            else:
+                debug_log(f"部分内容收集成功，继续处理 ({len(full_content)} 个片段)")
+        
+        if not response_completed and not full_content:
+            debug_log("响应未完成且无内容，可能是连接问题")
+            raise HTTPException(status_code=502, detail="Incomplete response from upstream")
+        
+        # 如果响应结束时还在思考阶段，需要添加结束标签
+        if self.in_thinking_phase and not self.first_thinking_chunk:
+            full_content.append("</think>")
+        
+        final_content = "".join(full_content)
+        debug_log(f"内容收集完成，最终长度: {len(final_content)}")
+        
+        # Handle tool calls for non-streaming
+        tool_calls = None
+        finish_reason = "stop"
+        message_content = final_content
+        
+        if self.has_tools:
+            tool_calls = extract_tool_invocations(final_content)
+            if tool_calls:
+                # Content must be null when tool_calls are present (OpenAI spec)
+                message_content = None
+                finish_reason = "tool_calls"
+                debug_log(f"提取到工具调用: {json.dumps(tool_calls, ensure_ascii=False)}")
+            else:
+                # Remove tool JSON from content
+                message_content = remove_tool_json_content(final_content)
+                if not message_content:
+                    message_content = final_content  # 保留原内容如果清理后为空
+        
+        # Build response
+        response_data = OpenAIResponse(
+            id=f"chatcmpl-{int(time.time())}",
+            object="chat.completion",
+            created=int(time.time()),
+            model=settings.PRIMARY_MODEL,
+            choices=[Choice(
+                index=0,
+                message=Message(
+                    role="assistant",
+                    content=message_content,
+                    tool_calls=tool_calls
+                ),
+                finish_reason=finish_reason
+            )],
+            usage=Usage()
+        )
+        
+        debug_log("非流式响应发送完成")
+        return JSONResponse(content=response_data.model_dump(exclude_none=True))

app/core/token_manager.py

@@ -0,0 +1,264 @@
+"""
+Token pool management with load balancing and round-robin mechanism
+"""
+
+import os
+import time
+import threading
+from typing import List, Optional, Dict, Any, Set
+from dataclasses import dataclass, field
+
+
+def debug_log(message: str, *args) -> None:
+    """Log debug message if debug mode is enabled"""
+    # Import here to avoid circular import
+    try:
+        from app.core.config import settings
+        if settings.DEBUG_LOGGING:
+            if args:
+                print(f"[DEBUG] {message % args}")
+            else:
+                print(f"[DEBUG] {message}")
+    except:
+        # Fallback if settings not available
+        print(f"[DEBUG] {message}")
+
+
+@dataclass
+class TokenInfo:
+    """Token information with failure tracking"""
+    token: str
+    failure_count: int = 0
+    is_active: bool = True
+    last_failure_time: Optional[float] = None
+    last_used_time: Optional[float] = None
+
+
+class TokenManager:
+    """Token pool manager with load balancing and failure handling"""
+    
+    def __init__(self, token_file_path: str = None):
+        try:
+            from app.core.config import settings
+            self.token_file_path = token_file_path or getattr(settings, 'TOKEN_FILE_PATH', './tokens.txt')
+            self.max_failures = getattr(settings, 'TOKEN_MAX_FAILURES', 3)
+            self.reload_interval = getattr(settings, 'TOKEN_RELOAD_INTERVAL', 60)
+        except ImportError:
+            # Fallback values if settings not available
+            self.token_file_path = token_file_path or './tokens.txt'
+            self.max_failures = 3
+            self.reload_interval = 60
+        
+        self.tokens: List[TokenInfo] = []
+        self.current_index = 0
+        self.last_reload_time = 0
+        self._lock = threading.Lock()
+        
+        # Load tokens on initialization
+        self._load_tokens()
+    
+    def _load_tokens(self) -> None:
+        """Load tokens from file"""
+        try:
+            new_tokens = []
+            
+            # 首先尝试从tokens.txt文件加载token
+            if os.path.exists(self.token_file_path):
+                with open(self.token_file_path, 'r', encoding='utf-8') as f:
+                    lines = f.readlines()
+                
+                for line in lines:
+                    token = line.strip()
+                    if token and not token.startswith('#'):  # Skip empty lines and comments
+                        # Check if this token already exists to preserve failure count
+                        existing_token = next((t for t in self.tokens if t.token == token), None)
+                        if existing_token:
+                            new_tokens.append(existing_token)
+                        else:
+                            new_tokens.append(TokenInfo(token=token))
+                
+                if new_tokens:
+                    debug_log(f"从tokens.txt文件加载了 {len(new_tokens)} 个token")
+                else:
+                    debug_log("Token文件为空或无有效token")
+            
+            # 然后尝试从BACKUP_TOKEN环境变量加载token
+            try:
+                from app.core.config import settings
+                if hasattr(settings, 'BACKUP_TOKEN') and settings.BACKUP_TOKEN:
+                    # 支持多个BACKUP_TOKEN值，以逗号分隔
+                    backup_tokens = [token.strip() for token in settings.BACKUP_TOKEN.split(',') if token.strip()]
+                    
+                    # 添加不重复的backup token
+                    for backup_token in backup_tokens:
+                        # 检查是否已经存在相同的token
+                        existing_token = next((t for t in new_tokens if t.token == backup_token), None)
+                        if not existing_token:
+                            # 检查是否在原有tokens中存在，以保留失败计数
+                            old_token = next((t for t in self.tokens if t.token == backup_token), None)
+                            if old_token:
+                                new_tokens.append(old_token)
+                            else:
+                                new_tokens.append(TokenInfo(token=backup_token))
+                    
+                    debug_log(f"从BACKUP_TOKEN加载了 {len(backup_tokens)} 个token")
+            except ImportError:
+                pass
+            
+            # 如果没有任何token，尝试仅使用BACKUP_TOKEN
+            if not new_tokens:
+                try:
+                    from app.core.config import settings
+                    if hasattr(settings, 'BACKUP_TOKEN') and settings.BACKUP_TOKEN:
+                        # 支持多个BACKUP_TOKEN值，以逗号分隔
+                        backup_tokens = [token.strip() for token in settings.BACKUP_TOKEN.split(',') if token.strip()]
+                        new_tokens = [TokenInfo(token=token) for token in backup_tokens]
+                        debug_log(f"仅使用BACKUP_TOKEN，共{len(backup_tokens)}个token")
+                except ImportError:
+                    pass
+            
+            if new_tokens:
+                with self._lock:
+                    self.tokens = new_tokens
+                    # Reset index if it's out of bounds
+                    if self.current_index >= len(self.tokens):
+                        self.current_index = 0
+                    self.last_reload_time = time.time()
+                
+                debug_log(f"总共加载了 {len(self.tokens)} 个token")
+                active_count = sum(1 for t in self.tokens if t.is_active)
+                debug_log(f"活跃token数量: {active_count}")
+            else:
+                debug_log("没有找到任何可用的token")
+                
+        except Exception as e:
+            debug_log(f"加载token失败: {e}")
+    
+    def _should_reload(self) -> bool:
+        """Check if tokens should be reloaded"""
+        return time.time() - self.last_reload_time > self.reload_interval
+    
+    def get_next_token(self) -> Optional[str]:
+        """Get next available token using round-robin with load balancing"""
+        # Reload tokens if needed
+        if self._should_reload():
+            self._load_tokens()
+        
+        with self._lock:
+            if not self.tokens:
+                debug_log("没有可用的token")
+                return None
+            
+            # Find active tokens
+            active_tokens = [i for i, t in enumerate(self.tokens) if t.is_active]
+            
+            if not active_tokens:
+                debug_log("没有活跃的token，尝试重置失败计数")
+                # Reset all tokens if none are active (maybe temporary network issues)
+                for token in self.tokens:
+                    token.is_active = True
+                    token.failure_count = 0
+                active_tokens = list(range(len(self.tokens)))
+            
+            # Round-robin selection from active tokens
+            attempts = 0
+            max_attempts = len(active_tokens)
+            
+            while attempts < max_attempts:
+                # Find next active token starting from current_index
+                token_index = None
+                for i in range(len(self.tokens)):
+                    idx = (self.current_index + i) % len(self.tokens)
+                    if idx in active_tokens:
+                        token_index = idx
+                        break
+                
+                if token_index is not None:
+                    self.current_index = (token_index + 1) % len(self.tokens)
+                    token_info = self.tokens[token_index]
+                    token_info.last_used_time = time.time()
+                    debug_log(f"选择token[{token_index}]: {token_info.token[:20]}...")
+                    return token_info.token
+                
+                attempts += 1
+            
+            debug_log("无法找到可用的token")
+            return None
+    
+    def mark_token_failed(self, token: str) -> None:
+        """Mark a token as failed and deactivate if necessary"""
+        with self._lock:
+            for token_info in self.tokens:
+                if token_info.token == token:
+                    token_info.failure_count += 1
+                    token_info.last_failure_time = time.time()
+                    
+                    if token_info.failure_count >= self.max_failures:
+                        token_info.is_active = False
+                        debug_log(f"Token失效 (失败{token_info.failure_count}次): {token[:20]}...")
+                    else:
+                        debug_log(f"Token失败 ({token_info.failure_count}/{self.max_failures}): {token[:20]}...")
+                    break
+    
+    def mark_token_success(self, token: str) -> None:
+        """Mark a token as successful (reset failure count)"""
+        with self._lock:
+            for token_info in self.tokens:
+                if token_info.token == token:
+                    if token_info.failure_count > 0:
+                        debug_log(f"Token恢复正常: {token[:20]}...")
+                    token_info.failure_count = 0
+                    token_info.is_active = True
+                    break
+    
+    def get_token_stats(self) -> Dict[str, Any]:
+        """Get token pool statistics"""
+        with self._lock:
+            if not self.tokens:
+                return {
+                    "total": 0,
+                    "active": 0,
+                    "failed": 0,
+                    "tokens": []
+                }
+            
+            active_count = sum(1 for t in self.tokens if t.is_active)
+            failed_count = len(self.tokens) - active_count
+            
+            token_details = []
+            for i, token_info in enumerate(self.tokens):
+                token_details.append({
+                    "index": i,
+                    "token_preview": token_info.token[:20] + "...",
+                    "is_active": token_info.is_active,
+                    "failure_count": token_info.failure_count,
+                    "last_failure_time": token_info.last_failure_time,
+                    "last_used_time": token_info.last_used_time
+                })
+            
+            return {
+                "total": len(self.tokens),
+                "active": active_count,
+                "failed": failed_count,
+                "current_index": self.current_index,
+                "last_reload_time": self.last_reload_time,
+                "tokens": token_details
+            }
+    
+    def reset_all_tokens(self) -> None:
+        """Reset all tokens (clear failure counts and reactivate)"""
+        with self._lock:
+            for token_info in self.tokens:
+                token_info.is_active = True
+                token_info.failure_count = 0
+                token_info.last_failure_time = None
+            debug_log("已重置所有token状态")
+    
+    def reload_tokens(self) -> None:
+        """Force reload tokens from file"""
+        debug_log("强制重新加载token文件")
+        self._load_tokens()
+
+
+# Global token manager instance
+token_manager = TokenManager()

app/core/zai_transformer.py

@@ -0,0 +1,476 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import json
+import time
+import uuid
+import random
+import hashlib
+import hmac
+import urllib.parse
+from datetime import datetime
+from typing import Dict, List, Any, Optional, Generator, AsyncGenerator
+import httpx
+import asyncio
+from fake_useragent import UserAgent
+
+from app.core.config import settings
+from app.utils.helpers import debug_log
+from app.core.token_manager import token_manager
+
+# 全局 UserAgent 实例（单例模式）
+_user_agent_instance = None
+
+
+def get_user_agent_instance() -> UserAgent:
+    """获取或创建 UserAgent 实例（单例模式）"""
+    global _user_agent_instance
+    if _user_agent_instance is None:
+        _user_agent_instance = UserAgent()
+    return _user_agent_instance
+
+
+def get_dynamic_headers(chat_id: str = "", user_agent: str = "") -> Dict[str, str]:
+    """生成动态浏览器headers，包含随机User-Agent"""
+    if not user_agent:
+        ua = get_user_agent_instance()
+        # 随机选择浏览器类型，偏向Chrome和Edge
+        browser_choices = ["chrome", "chrome", "chrome", "edge", "edge", "firefox", "safari"]
+        browser_type = random.choice(browser_choices)
+
+        try:
+            if browser_type == "chrome":
+                user_agent = ua.chrome
+            elif browser_type == "edge":
+                user_agent = ua.edge
+            elif browser_type == "firefox":
+                user_agent = ua.firefox
+            elif browser_type == "safari":
+                user_agent = ua.safari
+            else:
+                user_agent = ua.random
+        except:
+            user_agent = ua.random
+
+    # 提取版本信息
+    chrome_version = "140"  # 更新版本号匹配F12信息
+    edge_version = "140"
+
+    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'"Chromium";v="{chrome_version}", "Not=A?Brand";v="24", "Microsoft Edge";v="{edge_version}"'
+    elif "Firefox/" in user_agent:
+        sec_ch_ua = None  # Firefox不使用sec-ch-ua
+    else:
+        sec_ch_ua = f'"Chromium";v="{chrome_version}", "Not=A?Brand";v="24", "Google Chrome";v="{chrome_version}"'
+
+    headers = {
+        "Accept": "*/*",
+        "Accept-Encoding": "gzip, deflate, br, zstd",
+        "Accept-Language": "zh-CN",
+        "Content-Type": "application/json",
+        "User-Agent": user_agent,
+        "X-Fe-Version": "prod-fe-1.0.83",  # 匹配F12信息中的版本
+        "Origin": "https://chat.z.ai",
+        "Connection": "keep-alive",
+        "Sec-Fetch-Dest": "empty",
+        "Sec-Fetch-Mode": "cors", 
+        "Sec-Fetch-Site": "same-origin",
+    }
+
+    if sec_ch_ua:
+        headers["Sec-Ch-Ua"] = sec_ch_ua
+        headers["Sec-Ch-Ua-Mobile"] = "?0"
+        headers["Sec-Ch-Ua-Platform"] = '"Windows"'
+
+    if chat_id:
+        headers["Referer"] = f"https://chat.z.ai/c/{chat_id}"
+    else:
+        headers["Referer"] = "https://chat.z.ai/"
+
+    return headers
+
+
+def generate_uuid() -> str:
+    """生成UUID v4"""
+    return str(uuid.uuid4())
+
+
+def generate_signature(data: str, timestamp: str, secret_key: str = "") -> str:
+    """生成请求签名
+    
+    Args:
+        data: 请求数据
+        timestamp: 时间戳
+        secret_key: 密钥（使用配置中的值）
+    
+    Returns:
+        签名字符串
+    """
+    if not settings.ENABLE_SIGNATURE:
+        return ""  # 如果禁用签名，返回空字符串
+        
+    if not secret_key:
+        secret_key = settings.SIGNATURE_SECRET_KEY
+    
+    # 构建签名字符串
+    sign_string = f"{data}{timestamp}{secret_key}"
+    
+    # 根据配置选择签名算法
+    if settings.SIGNATURE_ALGORITHM.lower() == "md5":
+        signature = hashlib.md5(sign_string.encode('utf-8')).hexdigest()
+    elif settings.SIGNATURE_ALGORITHM.lower() == "sha1":
+        signature = hashlib.sha1(sign_string.encode('utf-8')).hexdigest()
+    else:  # 默认使用sha256
+        signature = hashlib.sha256(sign_string.encode('utf-8')).hexdigest()
+    
+    return signature
+
+
+def build_query_params(
+    timestamp: int, 
+    request_id: str, 
+    token: str,
+    user_agent: str,
+    chat_id: str = ""
+) -> Dict[str, str]:
+    """构建查询参数，模拟真实的浏览器请求
+    
+    Args:
+        timestamp: 时间戳（毫秒）
+        request_id: 请求ID
+        token: 用户token
+        user_agent: 用户代理字符串
+        chat_id: 聊天ID
+        
+    Returns:
+        查询参数字典
+    """
+    # 生成用���ID（从token中提取或生成假的）
+    user_id = "guest-user-" + str(abs(hash(token)) % 1000000)
+    
+    # 编码用户代理
+    encoded_user_agent = urllib.parse.quote_plus(user_agent)
+    
+    # 当前时间相关
+    current_time = datetime.now()
+    local_time = current_time.isoformat() + "Z"
+    utc_time = current_time.strftime("%a, %d %b %Y %H:%M:%S GMT")
+    
+    # 构建当前URL
+    current_url = f"https://chat.z.ai/c/{chat_id}" if chat_id else "https://chat.z.ai/"
+    pathname = f"/c/{chat_id}" if chat_id else "/"
+    
+    query_params = {
+        "timestamp": str(timestamp),
+        "requestId": request_id,
+        "version": "0.0.1",
+        "platform": "web",
+        "user_id": user_id,
+        "token": token,
+        "user_agent": encoded_user_agent,
+        "language": "zh-CN",
+        "languages": "zh-CN,en,en-GB,en-US",
+        "timezone": "Asia/Shanghai",
+        "cookie_enabled": "true",
+        "screen_width": "1536",
+        "screen_height": "864",
+        "screen_resolution": "1536x864",
+        "viewport_height": "331",
+        "viewport_width": "1528",
+        "viewport_size": "1528x331",
+        "color_depth": "24",
+        "pixel_ratio": "1.25",
+        "current_url": urllib.parse.quote_plus(current_url),
+        "pathname": pathname,
+        "search": "",
+        "hash": "",
+        "host": "chat.z.ai",
+        "hostname": "chat.z.ai",
+        "protocol": "https:",
+        "referrer": "",
+        "title": "Chat with Z.ai - Free AI Chatbot powered by GLM-4.5",
+        "timezone_offset": "-480",
+        "local_time": local_time,
+        "utc_time": utc_time,
+        "is_mobile": "false",
+        "is_touch": "false",
+        "max_touch_points": "10",
+        "browser_name": "Chrome",
+        "os_name": "Windows",
+        # "signature_timestamp": str(timestamp),  # 已移除签名相关参数
+    }
+    
+    return query_params
+
+
+def get_auth_token_sync() -> str:
+    """同步获取认证令牌（用于非异步场景）"""
+    if settings.ANONYMOUS_MODE:
+        try:
+            headers = get_dynamic_headers()
+            with httpx.Client() as client:
+                response = client.get("https://chat.z.ai/api/v1/auths/", headers=headers, timeout=10.0)
+                if response.status_code == 200:
+                    data = response.json()
+                    token = data.get("token", "")
+                    if token:
+                        debug_log(f"获取访客令牌成功: {token[:20]}...")
+                        return token
+        except Exception as e:
+            debug_log(f"获取访客令牌失败: {e}")
+
+    # 使用token管理器获取备份令牌
+    token = token_manager.get_next_token()
+    if token:
+        debug_log(f"从token池获取令牌: {token[:20]}...")
+        return token
+
+    # 没有可用的token
+    debug_log("⚠️ 没有可用的备份token")
+    return ""
+
+
+class ZAITransformer:
+    """ZAI转换器类"""
+
+    def __init__(self):
+        """初始化转换器"""
+        self.name = "zai"
+        self.base_url = "https://chat.z.ai"
+        self.api_url = settings.API_ENDPOINT
+        self.auth_url = f"{self.base_url}/api/v1/auths/"
+
+        # 模型映射
+        self.model_mapping = {
+            settings.PRIMARY_MODEL: "0727-360B-API",  # GLM-4.5
+            settings.THINKING_MODEL: "0727-360B-API",  # GLM-4.5-Thinking
+            settings.SEARCH_MODEL: "0727-360B-API",  # GLM-4.5-Search
+            settings.AIR_MODEL: "0727-106B-API",  # GLM-4.5-Air
+            settings.GLM_46_MODEL: "GLM-4-6-API-V1",  # GLM-4.6
+            settings.GLM_46_THINKING_MODEL: "GLM-4-6-API-V1",  # GLM-4.6-Thinking
+        }
+
+    async def get_token(self) -> str:
+        """异步获取认证令牌"""
+        if settings.ANONYMOUS_MODE:
+            try:
+                headers = get_dynamic_headers()
+                async with httpx.AsyncClient() as client:
+                    response = await client.get(self.auth_url, headers=headers, timeout=10.0)
+                    if response.status_code == 200:
+                        data = response.json()
+                        token = data.get("token", "")
+                        if token:
+                            debug_log(f"获取访客令牌成功: {token[:20]}...")
+                            return token
+            except Exception as e:
+                debug_log(f"异步获取访客令牌失败: {e}")
+
+        # 使用token管理器获取备份令牌
+        token = token_manager.get_next_token()
+        if token:
+            debug_log(f"从token池获取令牌: {token[:20]}...")
+            return token
+
+        # 没有可用的token
+        debug_log("⚠️ 没有可用的备份token")
+        return ""
+
+    def mark_token_success(self, token: str):
+        """标记token使用成功"""
+        token_manager.mark_token_success(token)
+
+    def mark_token_failure(self, token: str, error: Exception = None):
+        """标记token使用失败"""
+        token_manager.mark_token_failed(token)
+
+    async def transform_request_in(self, request: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        转换OpenAI请求为z.ai格式
+        整合现有功能：模型映射、MCP服务器等
+        """
+        debug_log(f"🔄 开始转换 OpenAI 请求到 Z.AI 格式: {request.get('model', settings.PRIMARY_MODEL)} -> Z.AI")
+
+        # 获取认证令牌
+        token = await self.get_token()
+        debug_log(f"  使用令牌: {token[:20] if token else 'None'}...")
+
+        # 检查token是否有效
+        if not token:
+            debug_log("❌ 无法获取有效的认证令牌")
+            raise Exception("无法获取有效的认证令牌，请检查匿名模式配置或token池配置")
+
+        # 确定请求的模型特性
+        requested_model = request.get("model", settings.PRIMARY_MODEL)
+        is_thinking = (requested_model == settings.THINKING_MODEL or 
+                      requested_model == settings.GLM_46_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")
+        debug_log(f"  模型映射: {requested_model} -> {upstream_model_id}")
+        debug_log(f"  模型特性检测: is_search={is_search}, is_thinking={is_thinking}, is_air={is_air}")
+
+        # 处理消息列表
+        debug_log(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)
+                        ):
+                            debug_log(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")
+            debug_log(f"🔍 检测到搜索模型，添加 deep-web-search MCP 服务器")
+
+        debug_log(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"]
+            debug_log(f"启用工具支持: {len(request['tools'])} 个工具")
+        else:
+            body["tools"] = None
+
+        # 生成时间戳和请求ID
+        timestamp = int(time.time() * 1000)  # 毫秒时间戳
+        request_id = generate_uuid()
+        
+        # 构建请求配置
+        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 Edg/140.0.0.0"
+        dynamic_headers = get_dynamic_headers(chat_id, user_agent)
+        
+        # 构建查询参数
+        query_params = build_query_params(timestamp, request_id, token, user_agent, chat_id)
+        
+        # 签名已强制禁用 - 不生成任何签名
+        # request_body_str = json.dumps(body, ensure_ascii=False, separators=(',', ':'))
+        # signature = generate_signature(request_body_str, str(timestamp))
+        
+        # 构建完整的URL（包含查询参数）
+        url_with_params = f"{self.api_url}?" + "&".join([f"{k}={v}" for k, v in query_params.items()])
+
+        headers = {
+            **dynamic_headers,  # 使用动态生成的headers
+            "Authorization": f"Bearer {token}",
+            "Cache-Control": "no-cache",
+            "Pragma": "no-cache",
+        }
+        
+        # 签名功能已禁用
+        debug_log("  🔓 签名验证已禁用")
+
+        config = {
+            "url": url_with_params,
+            "headers": headers,
+        }
+
+        debug_log("✅ 请求转换完成")
+
+        # 记录关键的请求信息用于调试
+        debug_log(f"  📋 发送到Z.AI的关键信息:")
+        debug_log(f"    - 上游模型: {body['model']}")
+        debug_log(f"    - MCP服务器: {body['mcp_servers']}")
+        debug_log(f"    - web_search: {body['features']['web_search']}")
+        debug_log(f"    - auto_web_search: {body['features']['auto_web_search']}")
+        debug_log(f"    - 消息数量: {len(body['messages'])}")
+        tools_count = len(body.get('tools') or [])
+        debug_log(f"    - 工具数量: {tools_count}")
+
+        # 返回转换后的请求数据
+        return {
+            "body": body,
+            "config": config,
+            "token": token
+        }

app/models/__init__.py

@@ -0,0 +1,7 @@
+"""
+Models module initialization
+"""
+
+from app.models import schemas
+
+__all__ = ["schemas"]

app/models/schemas.py

@@ -0,0 +1,146 @@
+"""
+Application data models
+"""
+
+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[ModelItem] = None
+    tool_servers: Optional[List[str]] = None
+    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/utils/__init__.py

@@ -0,0 +1,7 @@
+"""
+Utils module initialization
+"""
+
+from app.utils import helpers, sse_parser, tools, reload_config
+
+__all__ = ["helpers", "sse_parser", "tools", "reload_config"]

app/utils/helpers.py

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

app/utils/reload_config.py

@@ -0,0 +1,85 @@
+"""
+热重载配置模块
+定义 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",  # 忽略测试目录
+]
+
+# 忽略的文件模式（正则表达式）
+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_parser.py

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

app/utils/sse_tool_handler.py

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

app/utils/tools.py

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

docker-compose.yml

@@ -0,0 +1,42 @@
+version: '3.8'
+
+services:
+  # 你的克隆士兵军团 (工人)
+  z-ai2api:
+    # 直接使用懒人镜像，我们不构建！
+    image: julienol/z-ai2api-python:latest
+    # 我们不直接暴露端口，所有流量都由总管 Nginx 处理
+    env_file:
+      - .env
+    volumes:
+      - ./tokens.txt:/app/tokens.txt:ro
+      - ./data:/app/data
+    restart: unless-stopped
+    # 部署指令：声明你想要 10 个一模一样的克隆士兵！
+    deploy:
+      replicas: 2
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8080/"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+
+  # 你的军队总管 (Nginx 负载均衡器)
+  nginx:
+    image: nginx:latest
+    container_name: z-ai-load-balancer
+    ports:
+      # 这是你帝国的唯一大门，所有访客都从这里进
+      - "8084:8084"
+    volumes:
+      # 把你的军规挂载到总管的大脑里
+      - ./nginx.conf:/etc/nginx/nginx.conf:ro
+    depends_on:
+      - z-ai2api # 确保士兵们先列队完毕，总管再上岗
+    restart: unless-stopped
+
+# 定义网络，让士兵和总管可以互相通信
+networks:
+  default:
+    driver: bridge

main.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Main application entry point
+"""
+
+from fastapi import FastAPI, Request, Response
+from fastapi.middleware.cors import CORSMiddleware
+
+from app.core.config import settings
+from app.core import openai
+from app.api import admin
+from app.utils.reload_config import RELOAD_CONFIG
+
+from granian import Granian
+
+# Create FastAPI app
+app = FastAPI(
+    title="OpenAI Compatible API Server",
+    description="An OpenAI-compatible API server for Z.AI chat service",
+    version="1.0.0",
+)
+
+# 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.include_router(admin.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():
+    Granian(
+        "main:app",
+        interface="asgi",
+        address="0.0.0.0",
+        port=settings.LISTEN_PORT,
+        reload=False,   # 生产环境请关闭热重载
+        **RELOAD_CONFIG,
+    ).serve()
+
+
+if __name__ == "__main__":
+    run_server()

nginx.conf

@@ -0,0 +1,33 @@
+events {
+    worker_connections 1024;
+}
+
+http {
+    # 定义你的克隆士兵军团
+    # Nginx 会自动找到所有名为 'z-ai2api' 的容器实例
+    upstream z_ai_workers {
+        # 'z-ai2api' 是我们在 docker-compose.yml 中定义的服务名
+        # Docker 的内部 DNS 会解析它，并把所有工人的 IP 地址都加进来
+        server z-ai2api:8080;
+    }
+
+    server {
+        # 这是你帝国的唯一入口，所有请求都从这里进来
+        listen 8084;
+
+        location / {
+            # 将请求转发给你的工人大军
+            proxy_pass http://z_ai_workers;
+            proxy_set_header Host $host;
+            proxy_set_header X-Real-IP $remote_addr;
+            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+            proxy_set_header X-Forwarded-Proto $scheme;
+            
+            # 确保流式响应和 WebSocket 正常工作
+            proxy_http_version 1.1;
+            proxy_set_header Upgrade $http_upgrade;
+            proxy_set_header Connection "upgrade";
+            proxy_buffering off; # 关键！关闭缓冲，让数据流实时通过
+        }
+    }
+}

requirements.txt

@@ -0,0 +1,19 @@
+fastapi
+uvicorn
+requests
+pydantic
+pydantic-settings
+pydantic-core
+typing-inspection
+fake-useragent
+brotli
+httpx
+brotli
+fake-useragent
+fastapi
+httpx
+pydantic
+pydantic-settings
+pydantic-core
+requests
+typing-inspection