♻️ refactor(zai_transformer): 重构工具调用处理逻辑

- 添加新的工具调用状态管理机制
- 实现工具调用参数解析和错误处理
- 添加工具调用开始、参数和完成的chunk创建方法
- 优化other阶段处理，特别是工具调用结束标记的检测
- 添加详细的日志记录以便调试工具调用过程

app/__init__.py

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

app/core/__init__.py

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

app/core/config.py

@@ -1,6 +1,5 @@
-"""
-FastAPI application configuration module
-"""
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
 
 import os
 from typing import Dict, Optional
@@ -9,29 +8,34 @@ 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")
-    
+    BACKUP_TOKEN: str = os.getenv(
+        "BACKUP_TOKEN",
+        "eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjMxNmJjYjQ4LWZmMmYtNGExNS04NTNkLWYyYTI5YjY3ZmYwZiIsImVtYWlsIjoiR3Vlc3QtMTc1NTg0ODU4ODc4OEBndWVzdC5jb20ifQ.PktllDySS3trlyuFpTeIZf-7hl8Qu1qYF3BxjgIul0BrNux2nX9hVzIjthLXKMWAf9V0qM8Vm_iyDqkjPGsaiQ",
+    )
+
     # Model Configuration
     PRIMARY_MODEL: str = os.getenv("PRIMARY_MODEL", "GLM-4.5")
     THINKING_MODEL: str = os.getenv("THINKING_MODEL", "GLM-4.5-Thinking")
     SEARCH_MODEL: str = os.getenv("SEARCH_MODEL", "GLM-4.5-Search")
     AIR_MODEL: str = os.getenv("AIR_MODEL", "GLM-4.5-Air")
-    
+
     # Server Configuration
     LISTEN_PORT: int = int(os.getenv("LISTEN_PORT", "8080"))
     DEBUG_LOGGING: bool = os.getenv("DEBUG_LOGGING", "true").lower() == "true"
-    
+
     # Feature Configuration
-    THINKING_PROCESSING: str = os.getenv("THINKING_PROCESSING", "think")  # strip: 去除<details>标签；think: 转为<span>标签；raw: 保留原样
+    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"
-    
+
     # Browser Headers
     CLIENT_HEADERS: Dict[str, str] = {
         "Content-Type": "application/json",
@@ -44,9 +48,9 @@ class Settings(BaseSettings):
         "X-FE-Version": "prod-fe-1.0.70",
         "Origin": "https://chat.z.ai",
     }
-    
+
     class Config:
         env_file = ".env"
 
 
-settings = Settings()
+settings = Settings()

app/core/openai.py

@@ -1,24 +1,27 @@
-"""
-OpenAI API endpoints
-"""
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
 
 import time
+import json
 from datetime import datetime
-from typing import List
+from typing import List, Dict, Any
 from fastapi import APIRouter, Header, HTTPException
 from fastapi.responses import StreamingResponse
+import httpx
 
 from app.core.config import settings
-from app.models.schemas import (
-    OpenAIRequest, Message, UpstreamRequest, ModelItem, 
-    ModelsResponse, Model
-)
-from app.utils.helpers import debug_log, generate_request_ids, get_auth_token
-from app.utils.tools import process_messages_with_tools, content_to_string
-from app.core.response_handlers import StreamResponseHandler, NonStreamResponseHandler
+from app.models.schemas import OpenAIRequest, Message, ModelsResponse, Model
+from app.utils.logger import get_logger
+from app.core.zai_transformer import ZAITransformer, generate_uuid
+from app.utils.sse_tool_handler import SSEToolHandler
+
+logger = get_logger()
 
 router = APIRouter()
 
+# 全局转换器实例
+transformer = ZAITransformer()
+
 
 @router.get("/v1/models")
 async def list_models():
@@ -26,150 +29,322 @@ async def list_models():
     current_time = int(time.time())
     response = ModelsResponse(
         data=[
-            Model(
-                id=settings.PRIMARY_MODEL,
-                created=current_time,
-                owned_by="z.ai"
-            ),
-            Model(
-                id=settings.THINKING_MODEL,
-                created=current_time,
-                owned_by="z.ai"
-            ),
-            Model(
-                id=settings.SEARCH_MODEL,
-                created=current_time,
-                owned_by="z.ai"
-            ),
-            Model(
-                id=settings.AIR_MODEL,
-                created=current_time,
-                owned_by="z.ai"
-            ),
+            Model(id=settings.PRIMARY_MODEL, created=current_time, owned_by="z.ai"),
+            Model(id=settings.THINKING_MODEL, created=current_time, owned_by="z.ai"),
+            Model(id=settings.SEARCH_MODEL, created=current_time, owned_by="z.ai"),
+            Model(id=settings.AIR_MODEL, created=current_time, owned_by="z.ai"),
         ]
     )
     return response
 
 
 @router.post("/v1/chat/completions")
-async def chat_completions(
-    request: OpenAIRequest,
-    authorization: str = Header(...)
-):
-    """Handle chat completion requests"""
-    debug_log("收到chat completions请求")
-    
+async def chat_completions(request: OpenAIRequest, authorization: str = Header(...)):
+    """Handle chat completion requests with ZAI transformer"""
+    logger.debug("收到chat completions请求")
+
     try:
         # Validate API key (skip if SKIP_AUTH_TOKEN is enabled)
         if not settings.SKIP_AUTH_TOKEN:
             if not authorization.startswith("Bearer "):
-                debug_log("缺少或无效的Authorization头")
+                logger.debug("缺少或无效的Authorization头")
                 raise HTTPException(status_code=401, detail="Missing or invalid Authorization header")
-            
+
             api_key = authorization[7:]
             if api_key != settings.AUTH_TOKEN:
-                debug_log(f"无效的API key: {api_key}")
+                logger.debug(f"无效的API key: {api_key}")
                 raise HTTPException(status_code=401, detail="Invalid API key")
-            
-            debug_log(f"API key验证通过，AUTH_TOKEN={api_key[:8]}......")
+
+            logger.debug(f"API key验证通过")
         else:
-            debug_log("SKIP_AUTH_TOKEN已启用，跳过API key验证")
-        debug_log(f"请求解析成功 - 模型: {request.model}, 流式: {request.stream}, 消息数: {len(request.messages)}")
-        
-        # Generate IDs
-        chat_id, msg_id = generate_request_ids()
-        
-        # Process messages with tools
-        processed_messages = process_messages_with_tools(
-            [m.model_dump() for m in request.messages],
-            request.tools,
-            request.tool_choice
+            logger.debug("SKIP_AUTH_TOKEN已启用，跳过API key验证")
+
+        logger.debug(f"请求解析成功 - 模型: {request.model}, 流式: {request.stream}, 消息数: {len(request.messages)}")
+
+        # 使用新的转换器转换请求
+        request_dict = request.model_dump()
+        transformed = await transformer.transform_request_in(request_dict)
+
+        logger.debug(
+            f"请求转换完成 - 上游模型: {transformed['body']['model']}, "
+            f"enable_thinking: {transformed['body']['features']['enable_thinking']}, "
+            f"mcp_servers: {transformed['body'].get('mcp_servers', [])}"
         )
-        
-        # Convert back to Message objects
-        upstream_messages: List[Message] = []
-        for msg in processed_messages:
-            content = content_to_string(msg.get("content"))
-            
-            upstream_messages.append(Message(
-                role=msg["role"],
-                content=content,
-                reasoning_content=msg.get("reasoning_content")
-            ))
-        
-        # Determine model features
-        is_thinking = request.model == settings.THINKING_MODEL
-        is_search = request.model == settings.SEARCH_MODEL
-        is_air = request.model == settings.AIR_MODEL
-        search_mcp = "deep-web-search" if is_search else ""
-        
-        # Determine upstream model ID based on requested model
-        if is_air:
-            upstream_model_id = "0727-106B-API"  # AIR model upstream ID
-            upstream_model_name = "GLM-4.5-Air"
-        else:
-            upstream_model_id = "0727-360B-API"  # Default upstream model ID
-            upstream_model_name = "GLM-4.5"
-        
-        # Build upstream request
-        upstream_req = UpstreamRequest(
-            stream=True,  # Always use streaming from upstream
-            chat_id=chat_id,
-            id=msg_id,
-            model=upstream_model_id,  # Dynamic upstream model ID
-            messages=upstream_messages,
-            params={},
-            features={
-                "enable_thinking": is_thinking,
-                "web_search": is_search,
-                "auto_web_search": is_search,
-            },
-            background_tasks={
-                "title_generation": False,
-                "tags_generation": False,
+
+        # 调用上游API
+        async def stream_response():
+            """流式响应生成器"""
+            try:
+                async with httpx.AsyncClient(timeout=60.0) as client:
+                    # 发送请求到上游
+                    async with client.stream(
+                        "POST",
+                        transformed["config"]["url"],
+                        json=transformed["body"],
+                        headers=transformed["config"]["headers"],
+                    ) as response:
+                        if response.status_code != 200:
+                            logger.error(f"上游返回错误: {response.status_code}")
+                            error_text = await response.aread()
+                            logger.error(f"错误详情: {error_text.decode('utf-8', errors='ignore')}")
+                            yield f"data: {json.dumps({'error': 'Upstream error'})}\n\n"
+                            return
+
+                        # 初始化工具处理器（如果需要）
+                        has_tools = transformed["body"].get("tools") is not None
+                        tool_handler = None
+                        if has_tools:
+                            chat_id = transformed["body"]["chat_id"]
+                            model = request.model
+                            tool_handler = SSEToolHandler(chat_id, model)
+                            logger.debug(f"初始化工具处理器 - chat_id: {chat_id}")
+
+                        # 处理状态
+                        has_thinking = False
+                        thinking_signature = None
+
+                        # 处理SSE流
+                        buffer = ""
+                        async for line in response.aiter_lines():
+                            if not line:
+                                continue
+
+                            # 累积到buffer处理完整的数据行
+                            buffer += line + "\n"
+
+                            # 检查是否有完整的data行
+                            while "\n" in buffer:
+                                current_line, buffer = buffer.split("\n", 1)
+                                if not current_line.strip():
+                                    continue
+
+                                if current_line.startswith("data:"):
+                                    chunk_str = current_line[5:].strip()
+                                    if not chunk_str or chunk_str == "[DONE]":
+                                        if chunk_str == "[DONE]":
+                                            yield "data: [DONE]\n\n"
+                                        continue
+
+                                    try:
+                                        chunk = json.loads(chunk_str)
+
+                                        if chunk.get("type") == "chat:completion":
+                                            data = chunk.get("data", {})
+                                            phase = data.get("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
+
+                                                    thinking_chunk = {
+                                                        "choices": [
+                                                            {
+                                                                "delta": {
+                                                                    "role": "assistant",
+                                                                    "thinking": {"content": content},
+                                                                },
+                                                                "finish_reason": None,
+                                                                "index": 0,
+                                                                "logprobs": None,
+                                                            }
+                                                        ],
+                                                        "created": int(time.time()),
+                                                        "id": transformed["body"]["chat_id"],
+                                                        "model": request.model,
+                                                        "object": "chat.completion.chunk",
+                                                        "system_fingerprint": "fp_zai_001",
+                                                    }
+                                                    yield f"data: {json.dumps(thinking_chunk)}\n\n"
+
+                                            # 处理答案内容
+                                            elif phase == "answer":
+                                                edit_content = data.get("edit_content", "")
+                                                delta_content = data.get("delta_content", "")
+
+                                                # 处理思考结束和答案开始
+                                                if edit_content and "</details>\n" in edit_content:
+                                                    if has_thinking:
+                                                        # 发送思考签名
+                                                        thinking_signature = str(int(time.time() * 1000))
+                                                        sig_chunk = {
+                                                            "choices": [
+                                                                {
+                                                                    "delta": {
+                                                                        "role": "assistant",
+                                                                        "thinking": {
+                                                                            "content": "",
+                                                                            "signature": thinking_signature,
+                                                                        },
+                                                                    },
+                                                                    "finish_reason": None,
+                                                                    "index": 0,
+                                                                    "logprobs": None,
+                                                                }
+                                                            ],
+                                                            "created": int(time.time()),
+                                                            "id": transformed["body"]["chat_id"],
+                                                            "model": request.model,
+                                                            "object": "chat.completion.chunk",
+                                                            "system_fingerprint": "fp_zai_001",
+                                                        }
+                                                        yield f"data: {json.dumps(sig_chunk)}\n\n"
+
+                                                    # 提取答案内容
+                                                    content_after = edit_content.split("</details>\n")[-1]
+                                                    if content_after:
+                                                        content_chunk = {
+                                                            "choices": [
+                                                                {
+                                                                    "delta": {
+                                                                        "role": "assistant",
+                                                                        "content": content_after,
+                                                                    },
+                                                                    "finish_reason": None,
+                                                                    "index": 0,
+                                                                    "logprobs": None,
+                                                                }
+                                                            ],
+                                                            "created": int(time.time()),
+                                                            "id": transformed["body"]["chat_id"],
+                                                            "model": request.model,
+                                                            "object": "chat.completion.chunk",
+                                                            "system_fingerprint": "fp_zai_001",
+                                                        }
+                                                        yield f"data: {json.dumps(content_chunk)}\n\n"
+
+                                                # 处理增量内容
+                                                elif delta_content:
+                                                    # 如果还没有发送角色
+                                                    if not has_thinking:
+                                                        role_chunk = {
+                                                            "choices": [
+                                                                {
+                                                                    "delta": {"role": "assistant"},
+                                                                    "finish_reason": None,
+                                                                    "index": 0,
+                                                                    "logprobs": None,
+                                                                }
+                                                            ],
+                                                            "created": int(time.time()),
+                                                            "id": transformed["body"]["chat_id"],
+                                                            "model": request.model,
+                                                            "object": "chat.completion.chunk",
+                                                            "system_fingerprint": "fp_zai_001",
+                                                        }
+                                                        yield f"data: {json.dumps(role_chunk)}\n\n"
+
+                                                    content_chunk = {
+                                                        "choices": [
+                                                            {
+                                                                "delta": {
+                                                                    "role": "assistant",
+                                                                    "content": delta_content,
+                                                                },
+                                                                "finish_reason": None,
+                                                                "index": 0,
+                                                                "logprobs": None,
+                                                            }
+                                                        ],
+                                                        "created": int(time.time()),
+                                                        "id": transformed["body"]["chat_id"],
+                                                        "model": request.model,
+                                                        "object": "chat.completion.chunk",
+                                                        "system_fingerprint": "fp_zai_001",
+                                                    }
+                                                    yield f"data: {json.dumps(content_chunk)}\n\n"
+
+                                                # 处理完成
+                                                if data.get("usage"):
+                                                    finish_chunk = {
+                                                        "choices": [
+                                                            {
+                                                                "delta": {"role": "assistant", "content": ""},
+                                                                "finish_reason": "stop",
+                                                                "index": 0,
+                                                                "logprobs": None,
+                                                            }
+                                                        ],
+                                                        "usage": data["usage"],
+                                                        "created": int(time.time()),
+                                                        "id": transformed["body"]["chat_id"],
+                                                        "model": request.model,
+                                                        "object": "chat.completion.chunk",
+                                                        "system_fingerprint": "fp_zai_001",
+                                                    }
+                                                    yield f"data: {json.dumps(finish_chunk)}\n\n"
+                                                    yield "data: [DONE]\n\n"
+
+                                    except json.JSONDecodeError as e:
+                                        logger.debug(f"JSON解析错误: {e}, 内容: {chunk_str[:100]}")
+                                    except Exception as e:
+                                        logger.error(f"处理chunk错误: {e}")
+
+                        # 确保发送结束信号
+                        if not tool_handler or not tool_handler.state.has_tool_call:
+                            yield "data: [DONE]\n\n"
+
+            except Exception as e:
+                logger.error(f"流处理错误: {e}")
+                import traceback
+
+                logger.error(traceback.format_exc())
+                yield f"data: {json.dumps({'error': str(e)})}\n\n"
+
+        # 返回流式响应
+        return StreamingResponse(
+            stream_response(),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
             },
-            mcp_servers=[search_mcp] if search_mcp else [],
-            model_item=ModelItem(
-                id=upstream_model_id,
-                name=upstream_model_name,
-                owned_by="openai"
-            ),
-            tool_servers=[],
-            variables={
-                "{{USER_NAME}}": "User",
-                "{{USER_LOCATION}}": "Unknown",
-                "{{CURRENT_DATETIME}}": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-            }
         )
-        
-        # Get authentication token
-        auth_token = get_auth_token()
-        
-        # Check if tools are enabled and present
-        has_tools = (settings.TOOL_SUPPORT and 
-                    request.tools and 
-                    len(request.tools) > 0 and 
-                    request.tool_choice != "none")
-        
-        # Handle response based on stream flag
-        if request.stream:
-            handler = StreamResponseHandler(upstream_req, chat_id, auth_token, has_tools)
-            return StreamingResponse(
-                handler.handle(),
-                media_type="text/event-stream",
-                headers={
-                    "Cache-Control": "no-cache",
-                    "Connection": "keep-alive",
-                }
-            )
-        else:
-            handler = NonStreamResponseHandler(upstream_req, chat_id, auth_token, has_tools)
-            return handler.handle()
-            
+
     except HTTPException:
         raise
     except Exception as e:
-        debug_log(f"处理请求时发生错误: {str(e)}")
+        logger.error(f"处理请求时发生错误: {str(e)}")
         import traceback
-        debug_log(f"错误堆栈: {traceback.format_exc()}")
-        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+        logger.error(f"错误堆栈: {traceback.format_exc()}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")

app/core/response_handlers.py

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

app/core/zai_transformer.py

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

app/models/__init__.py

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

app/models/schemas.py

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

app/utils/__init__.py

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

app/utils/helpers.py

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

app/utils/logger.py

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

app/utils/reload_config.py

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

app/utils/sse_parser.py

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

app/utils/sse_tool_handler.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+SSE Tool Handler - 处理工具调用的SSE流
+实现glm_block分割和工具参数累积逻辑
+"""
+
+import json
+import time
+import uuid
+from typing import Dict, Any, Optional, Generator, List
+from dataclasses import dataclass, field
+
+from app.utils.logger import get_logger
+
+logger = get_logger()
+
+
+@dataclass
+class ToolCallState:
+    """工具调用状态管理"""
+
+    has_tool_call: bool = False
+    tool_args: str = ""
+    tool_id: str = ""
+    tool_name: str = ""
+    tool_calls: List[Dict] = field(default_factory=list)
+    tool_call_index: int = 0
+    tool_call_usage: Optional[Dict] = None
+    tool_call_buffer: str = ""  # 累积buffer用于处理分割的内容
+    is_first_block: bool = True  # 是否是第一个块
+
+
+class SSEToolHandler:
+    """
+    SSE工具处理器 - 实现工具调用逻辑
+    包含glm_block分割解析和参数累积机制
+    """
+
+    def __init__(self, chat_id: str, model: str):
+        self.chat_id = chat_id
+        self.model = model
+        self.state = ToolCallState()
+        self.has_thinking = False
+        self.content_index = 0
+
+    def process_tool_call_phase(self, data: Dict[str, Any], is_stream: bool = True) -> Generator[str, None, None]:
+        """
+        处理tool_call阶段
+        """
+        if not self.state.has_tool_call:
+            self.state.has_tool_call = True
+            logger.debug("进入工具调用阶段")
+
+        edit_content = data.get("edit_content", "")
+        if not edit_content:
+            return
+
+        # 分割glm_block块
+        blocks = edit_content.split("<glm_block >")
+
+        for index, block in enumerate(blocks):
+            if not block or "</glm_block>" not in block:
+                continue
+
+            if index == 0:
+                # 第一个块：提取到"result"之前的内容作为参数片段
+                if '"result"' in edit_content:
+                    # 提取到result之前的内容（去掉", "result"）
+                    args_fragment = edit_content[: edit_content.index('"result"') - 3]
+                    self.state.tool_args += args_fragment
+                    logger.debug(f"从第一个块提取参数片段: {args_fragment}")
+                else:
+                    # 如果没有result字段，这是一个分片的参数
+                    # 提取到</glm_block>之前的所有内容（但不包括</glm_block>）
+                    if "</glm_block>" in block:
+                        end_idx = block.index("</glm_block>")
+                        args_fragment = block[:end_idx]
+                    else:
+                        args_fragment = block
+
+                    # 直接累积参数片段，不做修改
+                    self.state.tool_args += args_fragment
+                    logger.debug(f"累积参数片段: {args_fragment}")
+            else:
+                # 后续块：包含工具元数据
+                try:
+                    # 提取块内容（去掉</glm_block>）
+                    block_content = block[: block.index("</glm_block>")]
+                    content = json.loads(block_content)
+                    metadata = content.get("data", {}).get("metadata", {})
+
+                    # 新工具调用
+                    tool_id = metadata.get("id", "")
+                    tool_name = metadata.get("name", "")
+                    arguments = metadata.get("arguments", {})
+
+                    if tool_id and tool_id != self.state.tool_id:
+                        # 如果有前一个工具调用未完成，先完成它
+                        if self.state.tool_id and self.state.tool_args:
+                            # 补充最后的引号
+                            if not self.state.tool_args.endswith("}"):
+                                self.state.tool_args += '"'
+                            yield from self._complete_tool_call(is_stream)
+
+                        # 保存新工具信息s
+                        self.state.tool_id = tool_id
+                        self.state.tool_name = tool_name
+                        # 开始新的参数累积（去掉最后的}以便后续累积）
+                        self.state.tool_args = json.dumps(arguments, ensure_ascii=False)[:-1]
+
+                        logger.debug(f"新工具调用: {tool_name}(id={tool_id})")
+                        logger.debug(f"初始参数: {self.state.tool_args}")
+
+                        if is_stream:
+                            yield self._create_tool_start_chunk()
+
+                        self.content_index += 1
+
+                except (json.JSONDecodeError, KeyError) as e:
+                    logger.error(f"解析工具块失败: {e}, block: {block_content}")
+
+        # 检查参数是否完整
+        if self.state.tool_args:
+            try:
+                # 尝试补充}并解析
+                test_args = (
+                    self.state.tool_args + "}" if not self.state.tool_args.endswith("}") else self.state.tool_args
+                )
+                json.loads(test_args)
+                self.state.tool_args_complete = True
+                logger.debug(f"参数完整: {test_args}")
+            except json.JSONDecodeError:
+                logger.debug(f"参数未完整，当前长度: {len(self.state.tool_args)}")
+
+    def _complete_tool_call(self, is_stream: bool) -> Generator[str, None, None]:
+        """完成当前工具调用"""
+        try:
+            # 尝试解析参数
+            # 参数应该已经在process_other_phase中补充完整
+            params = None
+
+            try:
+                params = json.loads(self.state.tool_args)
+                logger.debug(f"参数解析成功: {json.dumps(params, ensure_ascii=False)[:100]}")
+            except json.JSONDecodeError as e:
+                logger.error(f"解析失败: {e}")
+                logger.error(f"原始参数: {self.state.tool_args[:200]}")
+                # 使用空参数
+                params = {}
+
+            logger.debug(f"完成工具调用: {self.state.tool_name} with params: {params}")
+
+            if is_stream:
+                # 发送参数
+                yield self._create_tool_arguments_chunk(params)
+
+        except Exception as e:
+            logger.error(f"处理工具参数异常: {e}")
+        finally:
+            # 重置状态
+            self.state.tool_args = ""
+            self.state.tool_id = ""
+            self.state.tool_name = ""
+            self.state.tool_args_complete = False
+
+    def process_other_phase(self, data: Dict[str, Any], is_stream: bool = True) -> Generator[str, None, None]:
+        """
+        处理other阶段
+        主要处理工具调用的结束
+        """
+        edit_content = data.get("edit_content", "")
+        usage = data.get("usage")
+
+        # 保存usage（如果在工具调用模式）
+        if self.state.has_tool_call and usage:
+            self.state.tool_call_usage = usage
+            logger.debug(f"保存工具调用usage: {usage}")
+
+        # 检查工具调用结束标记
+        if self.state.has_tool_call and edit_content and edit_content.startswith("null,"):
+            logger.debug("检测到工具调用结束标记: null,")
+
+            # 如果有未完成的工具调用，完成它
+            if self.state.tool_id and self.state.tool_args:
+                # 补充结束引号
+                self.state.tool_args += '"'
+
+                logger.debug(f"准备完成工具调用，当前参数: {self.state.tool_args}")
+                yield from self._complete_tool_call(is_stream)
+
+            # 发送完成信号
+            if is_stream:
+                yield self._create_tool_finish_chunk()
+                yield "data: [DONE]\n\n"
+
+            # 重置所有状态
+            self.state.has_tool_call = False
+            self.state.tool_call_usage = None
+            self.state.tool_call_buffer = ""
+            self.state.tool_args = ""
+            self.state.tool_id = ""
+            self.state.tool_name = ""
+            self.state.tool_args_complete = False
+            self.state.is_first_block = True
+
+    def _create_tool_start_chunk(self) -> str:
+        """创建工具调用开始的chunk"""
+        chunk = {
+            "choices": [
+                {
+                    "delta": {
+                        "role": "assistant",
+                        "content": None,
+                        "tool_calls": [
+                            {
+                                "id": self.state.tool_id,
+                                "type": "function",
+                                "function": {"name": self.state.tool_name, "arguments": ""},
+                            }
+                        ],
+                    },
+                    "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, arguments: Dict) -> str:
+        """创建工具参数的chunk"""
+        chunk = {
+            "choices": [
+                {
+                    "delta": {
+                        "role": "assistant",
+                        "content": None,
+                        "tool_calls": [
+                            {
+                                "id": self.state.tool_id,
+                                "type": "function",
+                                "function": {"name": None, "arguments": json.dumps(arguments, ensure_ascii=False)},
+                            }
+                        ],
+                    },
+                    "finish_reason": None,
+                    "index": 0,
+                    "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.state.tool_call_usage,
+            "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

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

main.py

@@ -1,19 +1,20 @@
 #!/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.utils.reload_config import RELOAD_CONFIG
+from app.utils.logger import setup_logger
 
 from granian import Granian
 
+
+# Setup logger
+logger = setup_logger(log_dir="logs", debug_mode=settings.DEBUG_LOGGING)
+
 # Create FastAPI app
 app = FastAPI(
     title="OpenAI Compatible API Server",
@@ -52,7 +53,7 @@ def run_server():
         interface="asgi",
         address="0.0.0.0",
         port=settings.LISTEN_PORT,
-        reload=False,   # 生产环境请关闭热重载
+        reload=False,  # 生产环境请关闭热重载
         **RELOAD_CONFIG,
     ).serve()
 

pyproject.toml

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

requirements.txt

@@ -5,4 +5,5 @@ pydantic==2.11.7
 pydantic-settings==2.10.1
 pydantic-core==2.33.2
 typing-inspection==0.4.1
-fake-useragent==2.2.0
+fake-useragent==2.2.0
+loguru==0.7.3

tests/test_final_verification.py

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

tests/test_function_call.py

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

tests/test_multimodal_quick.py

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

tests/test_re.py

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

tests/test_tool_call.py

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