✨ refactor(core): 重构工具调用处理逻辑

.env.example

@@ -47,6 +47,4 @@ SCAN_LIMIT=200000
 # 重试次数
 MAX_RETRIES=5
 # 初始重试延迟
-RETRY_DELAY=1
-# 退避系数
-RETRY_BACKOFF=2
+RETRY_DELAY=1

app/core/config.py

@@ -118,7 +118,6 @@ class Settings(BaseSettings):
     # Retry Configuration
     MAX_RETRIES: int = int(os.getenv("MAX_RETRIES", "5"))
     RETRY_DELAY: float = float(os.getenv("RETRY_DELAY", "1.0"))  # 初始重试延迟（秒）
-    RETRY_BACKOFF: float = float(os.getenv("RETRY_BACKOFF", "2.0"))  # 退避系数
 
     # Browser Headers
     CLIENT_HEADERS: Dict[str, str] = {

app/core/openai.py

@@ -43,47 +43,24 @@ async def list_models():
 @router.post("/v1/chat/completions")
 async def chat_completions(request: OpenAIRequest, authorization: str = Header(...)):
     """Handle chat completion requests with ZAI transformer"""
-    logger.info(f"📥 收到 OpenAI 请求 - 模型: {request.model}, 流式: {request.stream}")
-    logger.debug(f"请求详情 - 消息数: {len(request.messages)}, 工具数: {len(request.tools) if request.tools else 0}")
-    
-    # 输出消息内容用于调试
-    for idx, msg in enumerate(request.messages):
-        content_preview = str(msg.content)[:1000] if msg.content else "None"
-        logger.debug(f"  消息[{idx}] - 角色: {msg.role}, 内容预览: {content_preview}...")
+    role = request.messages[0].role if request.messages else "unknown"
+    logger.info(f"😶‍🌫️ 收到 客户端 请求 - 模型: {request.model}, 流式: {request.stream}, 消息数: {len(request.messages)}, 角色: {role}, 工具数: {len(request.tools) if request.tools else 0}")
 
     try:
         # Validate API key (skip if SKIP_AUTH_TOKEN is enabled)
         if not settings.SKIP_AUTH_TOKEN:
             if not authorization.startswith("Bearer "):
-                logger.debug("缺少或无效的Authorization头")
                 raise HTTPException(status_code=401, detail="Missing or invalid Authorization header")
 
             api_key = authorization[7:]
             if api_key != settings.AUTH_TOKEN:
-                logger.debug(f"无效的API key: {api_key}")
                 raise HTTPException(status_code=401, detail="Invalid API key")
 
-            logger.debug(f"API key验证通过")
-        else:
-            logger.debug("SKIP_AUTH_TOKEN已启用，跳过API key验证")
-
-        # 输出原始请求体用于调试
-        request_dict = request.model_dump()
-        # logger.debug(f"🔄 原始 OpenAI 请求体: {json.dumps(request_dict, ensure_ascii=False, indent=2)}")
-        
         # 使用新的转换器转换请求
+        request_dict = request.model_dump()
         logger.info("🔄 开始转换请求格式: OpenAI -> Z.AI")
+        
         transformed = await transformer.transform_request_in(request_dict)
-
-        logger.info(
-            f"✅ 请求转换完成 - 上游模型: {transformed['body']['model']}, "
-            f"chat_id: {transformed['body']['chat_id']}"
-        )
-        logger.debug(
-            f"  特性配置 - enable_thinking: {transformed['body']['features']['enable_thinking']}, "
-            f"web_search: {transformed['body']['features']['web_search']}, "
-            f"mcp_servers: {transformed['body'].get('mcp_servers', [])}"
-        )
         # logger.debug(f"🔄 转换后 Z.AI 请求体: {json.dumps(transformed['body'], ensure_ascii=False, indent=2)}")
 
         # 调用上游API
@@ -97,11 +74,8 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
                 try:
                     # 如果是重试，重新获取令牌并更新请求
                     if retry_count > 0:
-                        delay = settings.RETRY_DELAY * (settings.RETRY_BACKOFF ** (retry_count - 1))
-                        logger.warning(
-                            f"🔄 重试请求 ({retry_count}/{settings.MAX_RETRIES}) - "
-                            f"等待 {delay:.1f} 秒后重试..."
-                        )
+                        delay = settings.RETRY_DELAY
+                        logger.warning(f"重试请求 ({retry_count}/{settings.MAX_RETRIES}) - 等待 {delay:.1f}s")
                         await asyncio.sleep(delay)
 
                         # 标记前一个token失败（如果不是匿名模式）
@@ -116,13 +90,10 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
                             raise Exception("重试时无法获取有效的认证令牌")
                         transformed["config"]["headers"]["Authorization"] = f"Bearer {new_token}"
                         current_token = new_token
-                        logger.debug(f"  新令牌: {new_token[:20] if new_token else 'None'}...")
 
                     async with httpx.AsyncClient(timeout=60.0) as client:
                         # 发送请求到上游
                         logger.info(f"🎯 发送请求到 Z.AI: {transformed['config']['url']}")
-                        logger.debug(f"  请求头数量: {len(transformed['config']['headers'])}")
-
                         async with client.stream(
                             "POST",
                             transformed["config"]["url"],
@@ -134,10 +105,7 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
                                 # 400 错误，触发重试
                                 error_text = await response.aread()
                                 error_msg = error_text.decode('utf-8', errors='ignore')
-                                logger.warning(
-                                    f"⚠️ 上游返回 400 错误 (尝试 {retry_count + 1}/{settings.MAX_RETRIES + 1})"
-                                )
-                                logger.debug(f"  错误详情: {error_msg}")
+                                logger.warning(f"❌ 上游返回 400 错误 (尝试 {retry_count + 1}/{settings.MAX_RETRIES + 1})")
 
                                 retry_count += 1
                                 last_error = f"400 Bad Request: {error_msg}"
@@ -164,7 +132,7 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
                                 logger.error(f"❌ 上游返回错误: {response.status_code}")
                                 error_text = await response.aread()
                                 error_msg = error_text.decode('utf-8', errors='ignore')
-                                logger.error(f"错误详情: {error_msg}")
+                                logger.error(f"❌ 错误详情: {error_msg}")
 
                                 error_response = {
                                     "error": {
@@ -193,7 +161,7 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
                                 chat_id = transformed["body"]["chat_id"]
                                 model = request.model
                                 tool_handler = SSEToolHandler(chat_id, model)
-                                logger.info(f"🔧 初始化工具处理器 - chat_id: {chat_id}, 工具数: {len(transformed['body'].get('tools', []))}")
+                                logger.info(f"🔧 初始化工具处理器: {len(transformed['body'].get('tools', []))} 个工具")
 
                             # 处理状态
                             has_thinking = False
@@ -207,11 +175,8 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
                             async for line in response.aiter_lines():
                                 line_count += 1
                                 if not line:
-                                    # logger.debug(f"  行[{line_count}]: 空行，跳过")
                                     continue
 
-                                logger.debug(f"  行[{line_count}]: 接收到数据 - {line[:1000]}..." if len(line) > 1000 else f"  行[{line_count}]: 接收到数据 - {line}")
-
                                 # 累积到buffer处理完整的数据行
                                 buffer += line + "\n"
 
@@ -225,11 +190,10 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
                                         chunk_str = current_line[5:].strip()
                                         if not chunk_str or chunk_str == "[DONE]":
                                             if chunk_str == "[DONE]":
-                                                logger.debug("🏁 收到结束信号 [DONE]")
                                                 yield "data: [DONE]\n\n"
                                             continue
 
-                                        logger.debug(f"  📦 解析数据块: {chunk_str[:1000]}..." if len(chunk_str) > 1000 else f"  📦 解析数据块: {chunk_str}")
+                                        logger.debug(f"📦 解析数据块: {chunk_str[:1000]}..." if len(chunk_str) > 1000 else f"📦 解析数据块: {chunk_str}")
 
                                         try:
                                             chunk = json.loads(chunk_str)
@@ -240,7 +204,7 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
 
                                                 # 记录每个阶段（只在阶段变化时记录）
                                                 if phase and phase != getattr(stream_response, '_last_phase', None):
-                                                    logger.info(f"📈 SSE 阶段变化: {getattr(stream_response, '_last_phase', 'None')} -> {phase}")
+                                                    logger.info(f"📈 SSE 阶段: {phase}")
                                                     stream_response._last_phase = phase
 
                                                 # 处理工具调用
@@ -274,7 +238,6 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
                                                             "object": "chat.completion.chunk",
                                                             "system_fingerprint": "fp_zai_001",
                                                         }
-                                                        logger.debug("    ➡️ 发送初始角色")
                                                         yield f"data: {json.dumps(role_chunk)}\n\n"
 
                                                     delta_content = data.get("delta_content", "")
@@ -367,7 +330,6 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
 
                                                     # 处理增量内容
                                                     elif delta_content:
-                                                        logger.debug(f"    📝 答案内容片段: {delta_content[:1000]}...")
                                                         # 如果还没有发送角色
                                                         if not has_thinking:
                                                             role_chunk = {
@@ -406,7 +368,7 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
                                                             "system_fingerprint": "fp_zai_001",
                                                         }
                                                         output_data = f"data: {json.dumps(content_chunk)}\n\n"
-                                                        logger.debug(f"    ➡️ 输出内容块到客户端: {output_data[:1000]}...")
+                                                        logger.debug(f"➡️ 输出内容块到客户端: {output_data[:1000]}...")
                                                         yield output_data
 
                                                     # 处理完成
@@ -432,15 +394,15 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
                                                                 "system_fingerprint": "fp_zai_001",
                                                             }
                                                             finish_output = f"data: {json.dumps(finish_chunk)}\n\n"
-                                                            logger.debug(f"    ➡️ 发送完成信号: {finish_output[:1000]}...")
+                                                            logger.debug(f"➡️ 发送完成信号: {finish_output[:1000]}...")
                                                             yield finish_output
-                                                            logger.debug("    ➡️ 发送 [DONE]")
+                                                            logger.debug("➡️ 发送 [DONE]")
                                                             yield "data: [DONE]\n\n"
 
                                         except json.JSONDecodeError as e:
-                                            logger.debug(f"JSON解析错误: {e}, 内容: {chunk_str[:1000]}")
+                                            logger.debug(f"❌ JSON解析错误: {e}, 内容: {chunk_str[:1000]}")
                                         except Exception as e:
-                                            logger.error(f"处理chunk错误: {e}")
+                                            logger.error(f"❌ 处理chunk错误: {e}")
 
                             # 确保发送结束信号
                             if not tool_handler or not tool_handler.has_tool_call:
@@ -452,7 +414,7 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
                             return
 
                 except Exception as e:
-                    logger.error(f"流处理错误: {e}")
+                    logger.error(f"❌ 流处理错误: {e}")
                     import traceback
                     logger.error(traceback.format_exc())
 
@@ -487,7 +449,7 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
                 logger.debug("📤 开始向客户端流式传输数据...")
                 async for chunk in stream_response():
                     chunk_count += 1
-                    logger.debug(f"  📤 发送块[{chunk_count}]: {chunk[:1000]}..." if len(chunk) > 1000 else f"  📤 发送块[{chunk_count}]: {chunk}")
+                    logger.debug(f"📤 发送块[{chunk_count}]: {chunk[:1000]}..." if len(chunk) > 1000 else f"  📤 发送块[{chunk_count}]: {chunk}")
                     yield chunk
                 logger.info(f"✅ 流式传输完成，共发送 {chunk_count} 个数据块")
             except Exception as e:
@@ -506,10 +468,10 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"处理请求时发生错误: {str(e)}")
+        logger.error(f"❌ 处理请求时发生错误: {str(e)}")
         import traceback
 
-        logger.error(f"错误堆栈: {traceback.format_exc()}")
+        logger.error(f"❌ 错误堆栈: {traceback.format_exc()}")
         raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
 
 

app/core/zai_transformer.py

@@ -92,7 +92,6 @@ def get_dynamic_headers(chat_id: str = "") -> Dict[str, str]:
     else:
         headers["Referer"] = "https://chat.z.ai/"
 
-    logger.debug(f"使用动态User-Agent: {user_agent[:80]}...")
     return headers
 
 
@@ -105,14 +104,13 @@ 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]}...")
+                    logger.debug(f"获取访客令牌成功: {token[:20]}...")
                     return token
         except Exception as e:
             logger.warning(f"获取访客令牌失败: {e}")
@@ -152,7 +150,7 @@ class ZAITransformer:
         """异步获取认证令牌"""
         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)
@@ -160,7 +158,7 @@ class ZAITransformer:
                         data = response.json()
                         token = data.get("token", "")
                         if token:
-                            logger.debug(f"成功获取访客令牌: {token[:20]}...")
+                            logger.debug(f"获取访客令牌成功: {token[:20]}...")
                             return token
             except Exception as e:
                 logger.warning(f"异步获取访客令牌失败: {e}")
@@ -194,8 +192,8 @@ class ZAITransformer:
         转换OpenAI请求为z.ai格式
         整合现有功能：模型映射、MCP服务器等
         """
-        logger.info("🔄 开始转换 OpenAI 请求到 Z.AI 格式")
-        
+        logger.info(f"🔄 开始转换 OpenAI 请求到 Z.AI 格式: {request.get('model', settings.PRIMARY_MODEL)} -> Z.AI")
+
         # 获取认证令牌
         token = await self.get_token()
         logger.debug(f"  使用令牌: {token[:20] if token else 'None'}...")
@@ -210,12 +208,12 @@ class ZAITransformer:
         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
-        
-        logger.info(f"  模型分析 - 请求模型: {requested_model}, 思考模式: {is_thinking}, 搜索模式: {is_search}, Air模式: {is_air}")
 
         # 获取上游模型ID（使用模型映射）
         upstream_model_id = self.model_mapping.get(requested_model, "0727-360B-API")
         logger.debug(f"  模型映射: {requested_model} -> {upstream_model_id}")
+        logger.debug(f"  模型特性检测: is_search={is_search}, is_thinking={is_thinking}, is_air={is_air}")
+        logger.debug(f"  SEARCH_MODEL配置: {settings.SEARCH_MODEL}")
 
         # 处理消息列表
         logger.debug(f"  开始处理 {len(request.get('messages', []))} 条消息")
@@ -225,7 +223,7 @@ class ZAITransformer:
 
             # 处理system角色转换
             if msg.get("role") == "system":
-                logger.debug(f"    消息[{idx}]: 转换 system -> user 角色")
+
                 msg["role"] = "user"
                 content = msg.get("content")
 
@@ -257,7 +255,7 @@ class ZAITransformer:
 
             # 处理assistant消息中的reasoning_content
             elif msg.get("role") == "assistant" and msg.get("reasoning_content"):
-                logger.debug(f"    消息[{idx}]: 保留reasoning_content")
+
                 # 如果有reasoning_content，保留它
                 pass
 
@@ -267,11 +265,14 @@ class ZAITransformer:
         mcp_servers = []
         if is_search:
             mcp_servers.append("deep-web-search")
-            logger.info("  启用 MCP 服务器: deep-web-search")
+            logger.info(f"🔍 检测到搜索模型，添加 deep-web-search MCP 服务器")
+        else:
+            logger.debug(f"  非搜索模型，不添加 MCP 服务器")
 
+        logger.debug(f"  MCP服务器列表: {mcp_servers}")
+            
         # 构建上游请求体
         chat_id = generate_uuid()
-        logger.info(f"  生成 chat_id: {chat_id}")
         
         body = {
             "stream": True,  # 总是使用流式
@@ -303,7 +304,6 @@ class ZAITransformer:
                 "{{USER_LANGUAGE}}": "zh-CN",
             },
             "model_item": {},
-            "tool_servers": [],  # 保留工具服务器字段
             "chat_id": chat_id,
             "id": generate_uuid(),
         }
@@ -311,18 +311,12 @@ class ZAITransformer:
         # 处理工具支持
         if settings.TOOL_SUPPORT and not is_thinking and request.get("tools"):
             body["tools"] = request["tools"]
-            logger.info(f"  启用工具支持: {len(request['tools'])} 个工具")
-            for tool_idx, tool in enumerate(request["tools"]):
-                tool_name = tool.get("function", {}).get("name", "unknown")
-                logger.debug(f"    工具[{tool_idx}]: {tool_name}")
+            logger.info(f"启用工具支持: {len(request['tools'])} 个工具")
         else:
             body["tools"] = None
-            if request.get("tools"):
-                logger.debug(f"  工具支持已禁用或在思考模式下，忽略 {len(request.get('tools', []))} 个工具")
 
         # 构建请求配置
         dynamic_headers = get_dynamic_headers(chat_id)
-        logger.debug(f"  生成动态请求头 - User-Agent: {dynamic_headers.get('User-Agent', '')[:80]}...")
 
         config = {
             "url": self.api_url,  # 使用原始URL
@@ -339,9 +333,14 @@ class ZAITransformer:
         }
 
         logger.info("✅ 请求转换完成")
-        logger.debug(f"  目标URL: {config['url']}")
-        logger.debug(f"  请求头数量: {len(config['headers'])}")
-        logger.debug(f"  消息数: {len(body['messages'])}, 工具数: {len(body.get('tools', [])) if body.get('tools') else 0}")
+
+        # 记录关键的请求信息用于调试
+        logger.debug(f"  📋 发送到Z.AI的关键信息:")
+        logger.debug(f"    - 上游模型: {body['model']}")
+        logger.debug(f"    - MCP服务器: {body['mcp_servers']}")
+        logger.debug(f"    - web_search: {body['features']['web_search']}")
+        logger.debug(f"    - auto_web_search: {body['features']['auto_web_search']}")
+        logger.debug(f"    - 消息数量: {len(body['messages'])}")
 
         return {"body": body, "config": config, "token": token}
 
@@ -718,7 +717,7 @@ class ZAITransformer:
                                         yield "data: [DONE]\n\n"
 
                 except json.JSONDecodeError as e:
-                    logger.debug(f"JSON解析错误: {e}, 内容: {chunk_str[:100]}")
+                    logger.debug(f"JSON解析错误: {e}")
                 except Exception as e:
                     logger.error(f"处理chunk错误: {e}")
 

app/models/schemas.py

@@ -54,7 +54,6 @@ class UpstreamRequest(BaseModel):
     id: Optional[str] = None
     mcp_servers: Optional[List[str]] = 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/sse_tool_handler.py

@@ -28,7 +28,6 @@ class SSEToolHandler:
         self.content_index = 0
         self.has_thinking = False
 
-        # 原生内容重建机制 - 基于 Z.AI 的 edit_index 机制
         self.content_buffer = bytearray()  # 使用字节数组提高性能
         self.last_edit_index = 0  # 上次编辑的位置
 
@@ -39,7 +38,7 @@ class SSEToolHandler:
 
     def process_tool_call_phase(self, data: Dict[str, Any], is_stream: bool = True) -> Generator[str, None, None]:
         """
-        处理tool_call阶段 - 基于原生edit_index机制处理工具调用
+        处理tool_call阶段
         """
         if not self.has_tool_call:
             self.has_tool_call = True
@@ -53,7 +52,7 @@ class SSEToolHandler:
 
         # logger.debug(f"📦 接收内容片段 [index={edit_index}]: {edit_content[:1000]}...")
 
-        # 使用原生的edit_index机制更新内容缓冲区
+        # 更新内容缓冲区
         self._apply_edit_to_buffer(edit_index, edit_content)
 
         # 尝试解析和处理工具调用
@@ -61,8 +60,7 @@ class SSEToolHandler:
 
     def _apply_edit_to_buffer(self, edit_index: int, edit_content: str):
         """
-        基于edit_index原生地更新内容缓冲区
-        这是Z.AI的核心机制：在指定位置替换/插入内容
+        在指定位置替换/插入内容更新内容缓冲区
         """
         edit_bytes = edit_content.encode('utf-8')
         required_length = edit_index + len(edit_bytes)
@@ -97,7 +95,6 @@ class SSEToolHandler:
     def _extract_and_process_tools(self, content_str: str, is_stream: bool) -> Generator[str, None, None]:
         """
         从内容字符串中提取和处理工具调用
-        使用更原生的方式解析 glm_block
         """
         # 查找所有 glm_block，包括不完整的
         pattern = r'<glm_block\s*>(.*?)(?:</glm_block>|$)'
@@ -162,7 +159,7 @@ class SSEToolHandler:
 
     def _handle_tool_update(self, tool_id: str, tool_name: str, arguments_raw: str, is_stream: bool) -> Generator[str, None, None]:
         """
-        处理工具的创建或更新
+        处理工具的创建或更新 - 更可靠的参数完整性检查
         """
         # 解析参数
         try:
@@ -173,36 +170,157 @@ class SSEToolHandler:
             else:
                 arguments = arguments_raw
         except json.JSONDecodeError:
-            logger.debug(f"📦 参数解析失败，使用部分参数: {arguments_raw[:100]}")
-            arguments = self._parse_partial_arguments(arguments_raw)
+            logger.debug(f"📦 参数解析失败，暂不处理: {arguments_raw}")
+            # 参数解析失败时，不创建或更新工具，等待更完整的数据
+            return
+
+        # 检查参数是否看起来完整（基本的完整性验证）
+        is_args_complete = self._is_arguments_complete(arguments, arguments_raw)
 
         # 检查是否是新工具
         if tool_id not in self.active_tools:
-            logger.debug(f"🎯 发现新工具: {tool_name}(id={tool_id})")
+            logger.debug(f"🎯 发现新工具: {tool_name}(id={tool_id}), 参数完整性: {is_args_complete}")
 
             self.active_tools[tool_id] = {
                 "id": tool_id,
                 "name": tool_name,
                 "arguments": arguments,
+                "arguments_raw": arguments_raw,
                 "status": "active",
                 "sent_start": False,
-                "sent_args": False
+                "last_sent_args": {},  # 跟踪上次发送的参数
+                "args_complete": is_args_complete,
+                "pending_send": True  # 标记需要发送
             }
 
-            if is_stream:
-                # 发送工具开始信号
-                yield self._create_tool_start_chunk(tool_id, tool_name)
+            # 只有在参数看起来完整时才发送工具开始信号
+            if is_stream and is_args_complete:
+                yield self._create_tool_start_chunk(tool_id, tool_name, arguments)
                 self.active_tools[tool_id]["sent_start"] = True
+                self.active_tools[tool_id]["last_sent_args"] = arguments.copy()
+                self.active_tools[tool_id]["pending_send"] = False
+                logger.debug(f"📤 发送完整工具开始: {tool_name}(id={tool_id})")
+
+        else:
+            # 更新现有工具
+            current_tool = self.active_tools[tool_id]
+
+            # 检查是否有实质性改进
+            if self._is_significant_improvement(current_tool["arguments"], arguments,
+                                               current_tool["arguments_raw"], arguments_raw):
+                logger.debug(f"🔄 工具参数有实质性改进: {tool_name}(id={tool_id})")
+
+                current_tool["arguments"] = arguments
+                current_tool["arguments_raw"] = arguments_raw
+                current_tool["args_complete"] = is_args_complete
+
+                # 如果之前没有发送过开始信号，且现在参数完整，发送开始信号
+                if is_stream and not current_tool["sent_start"] and is_args_complete:
+                    yield self._create_tool_start_chunk(tool_id, tool_name, arguments)
+                    current_tool["sent_start"] = True
+                    current_tool["last_sent_args"] = arguments.copy()
+                    current_tool["pending_send"] = False
+                    logger.debug(f"📤 发送延迟的工具开始: {tool_name}(id={tool_id})")
+
+                # 如果已经发送过开始信号，且参数有显著改进，发送参数更新
+                elif is_stream and current_tool["sent_start"] and is_args_complete:
+                    if self._should_send_argument_update(current_tool["last_sent_args"], arguments):
+                        yield self._create_tool_arguments_chunk(tool_id, arguments)
+                        current_tool["last_sent_args"] = arguments.copy()
+                        logger.debug(f"📤 发送参数更新: {tool_name}(id={tool_id})")
+
+    def _is_arguments_complete(self, arguments: Dict[str, Any], arguments_raw: str) -> bool:
+        """
+        检查参数是否看起来完整
+        """
+        if not arguments:
+            return False
+
+        # 检查原始字符串是否看起来完整
+        if not arguments_raw or not arguments_raw.strip():
+            return False
+
+        # 检查是否有明显的截断迹象
+        raw_stripped = arguments_raw.strip()
+
+        # 如果原始字符串不以}结尾，可能是截断的
+        if not raw_stripped.endswith('}') and not raw_stripped.endswith('"'):
+            return False
+
+        # 检查是否有不完整的URL（常见的截断情况）
+        for key, value in arguments.items():
+            if isinstance(value, str):
+                # 检查URL是否看起来完整
+                if 'http' in value.lower():
+                    # 如果URL太短或以不完整的域名结尾，可能是截断的
+                    if len(value) < 10 or value.endswith('.go') or value.endswith('.goo'):
+                        return False
+
+                # 检查其他可能的截断迹象
+                if len(value) > 0 and value[-1] in ['.', '/', ':', '=']:
+                    # 以这些字符结尾可能表示截断
+                    return False
+
+        return True
+
+    def _is_significant_improvement(self, old_args: Dict[str, Any], new_args: Dict[str, Any],
+                                   old_raw: str, new_raw: str) -> bool:
+        """
+        检查新参数是否比旧参数有显著改进
+        """
+        # 如果新参数为空，不是改进
+        if not new_args:
+            return False
+        
+        if len(new_args) > len(old_args):
+            return True
+
+        # 检查值的改进
+        for key, new_value in new_args.items():
+            old_value = old_args.get(key, "")
+
+            if isinstance(new_value, str) and isinstance(old_value, str):
+                # 如果新值明显更长且更完整，是改进
+                if len(new_value) > len(old_value) + 5:  # 至少长5个字符才算显著改进
+                    return True
+
+                # 如果旧值看起来是截断的，新值更完整，是改进
+                if old_value.endswith(('.go', '.goo', '.com/', 'http')) and len(new_value) > len(old_value):
+                    return True
+
+        # 检查原始字符串的改进
+        if len(new_raw) > len(old_raw) + 10:  # 原始字符串显著增长
+            return True
+
+        return False
+
+    def _should_send_argument_update(self, last_sent: Dict[str, Any], new_args: Dict[str, Any]) -> bool:
+        """
+        判断是否应该发送参数更新 - 更严格的标准
+        """
+        # 如果参数完全相同，不发送
+        if last_sent == new_args:
+            return False
+
+        # 如果新参数为空但之前有参数，不发送（避免倒退）
+        if not new_args and last_sent:
+            return False
+
+        # 如果新参数有更多键，发送更新
+        if len(new_args) > len(last_sent):
+            return True
 
-        # 更新参数（如果有变化）
-        current_tool = self.active_tools[tool_id]
-        if current_tool["arguments"] != arguments:
-            current_tool["arguments"] = arguments
+        # 检查是否有值变得显著更完整
+        for key, new_value in new_args.items():
+            last_value = last_sent.get(key, "")
+            if isinstance(new_value, str) and isinstance(last_value, str):
+                # 只有在值显著增长时才发送更新（避免微小变化）
+                if len(new_value) > len(last_value) + 5:
+                    return True
+            elif new_value != last_value and new_value:  # 确保新值不为空
+                return True
 
-            if is_stream and current_tool["sent_start"] and not current_tool["sent_args"]:
-                # 发送工具参数
-                yield self._create_tool_arguments_chunk(tool_id, arguments)
-                current_tool["sent_args"] = True
+        return False
 
     def _handle_partial_tool_block(self, block_content: str, is_stream: bool) -> Generator[str, None, None]:
         """
@@ -225,29 +343,38 @@ class SSEToolHandler:
 
                 # 如果是新工具，先创建记录
                 if tool_id not in self.active_tools:
+                    # 尝试解析部分参数为字典
+                    partial_args_dict = self._parse_partial_arguments(partial_args)
+
                     self.active_tools[tool_id] = {
                         "id": tool_id,
                         "name": tool_name,
-                        "arguments": {},
+                        "arguments": partial_args_dict,
                         "status": "partial",
                         "sent_start": False,
-                        "sent_args": False,
+                        "last_sent_args": {},
+                        "args_complete": False,
                         "partial_args": partial_args
                     }
 
                     if is_stream:
-                        yield self._create_tool_start_chunk(tool_id, tool_name)
+                        yield self._create_tool_start_chunk(tool_id, tool_name, partial_args_dict)
                         self.active_tools[tool_id]["sent_start"] = True
+                        self.active_tools[tool_id]["last_sent_args"] = partial_args_dict.copy()
                 else:
                     # 更新部分参数
                     self.active_tools[tool_id]["partial_args"] = partial_args
+                    # 尝试更新解析的参数
+                    new_partial_dict = self._parse_partial_arguments(partial_args)
+                    if new_partial_dict != self.active_tools[tool_id]["arguments"]:
+                        self.active_tools[tool_id]["arguments"] = new_partial_dict
 
         except Exception as e:
             logger.debug(f"📦 部分块解析失败: {e}")
 
     def _clean_arguments_string(self, arguments_raw: str) -> str:
         """
-        清理和标准化参数字符串
+        清理和标准化参数字符串，改进对不完整JSON的处理
         """
         if not arguments_raw:
             return "{}"
@@ -266,6 +393,12 @@ class SSEToolHandler:
         elif cleaned.startswith('"{\\"') and cleaned.endswith('\\"}'):
             # 双重转义的情况
             cleaned = cleaned[1:-1].replace('\\"', '"')
+        elif cleaned.startswith('"') and cleaned.endswith('"'):
+            # 简单的引号包围，去除外层引号
+            cleaned = cleaned[1:-1]
+
+        # 处理不完整的JSON字符串
+        cleaned = self._fix_incomplete_json(cleaned)
 
         # 标准化空格（移除JSON中的多余空格，但保留字符串值中的空格）
         try:
@@ -276,10 +409,32 @@ class SSEToolHandler:
             cleaned = json.dumps(parsed, ensure_ascii=False, separators=(',', ':'))
         except json.JSONDecodeError:
             # 如果解析失败，只做基本的空格清理
-            pass
+            logger.debug(f"📦 JSON标准化失败，保持原样: {cleaned[:50]}...")
 
         return cleaned
 
+    def _fix_incomplete_json(self, json_str: str) -> str:
+        """
+        修复不完整的JSON字符串
+        """
+        if not json_str:
+            return "{}"
+
+        # 确保以{开头
+        if not json_str.startswith('{'):
+            json_str = '{' + json_str
+
+        # 处理不完整的字符串值
+        if json_str.count('"') % 2 != 0:
+            # 奇数个引号，可能有未闭合的字符串
+            json_str += '"'
+
+        # 确保以}结尾
+        if not json_str.endswith('}'):
+            json_str += '}'
+
+        return json_str
+
     def _parse_partial_arguments(self, arguments_raw: str) -> Dict[str, Any]:
         """
         解析不完整的参数字符串，尽可能提取有效信息
@@ -364,16 +519,29 @@ class SSEToolHandler:
 
     def _complete_active_tools(self, is_stream: bool) -> Generator[str, None, None]:
         """
-        完成所有活跃的工具调用
+        完成所有活跃的工具调用 - 处理待发送的工具
         """
+        tools_to_send = []
+
         for tool_id, tool in self.active_tools.items():
+            # 如果工具还没有发送过且参数看起来完整，现在发送
+            if is_stream and tool.get("pending_send", False) and not tool.get("sent_start", False):
+                if tool.get("args_complete", False):
+                    logger.debug(f"📤 完成时发送待发送工具: {tool['name']}(id={tool_id})")
+                    yield self._create_tool_start_chunk(tool_id, tool["name"], tool["arguments"])
+                    tool["sent_start"] = True
+                    tool["pending_send"] = False
+                    tools_to_send.append(tool)
+                else:
+                    logger.debug(f"⚠️ 跳过不完整的工具: {tool['name']}(id={tool_id})")
+
             tool["status"] = "completed"
             self.completed_tools.append(tool)
             logger.debug(f"✅ 完成工具调用: {tool['name']}(id={tool_id})")
 
         self.active_tools.clear()
 
-        if is_stream and self.completed_tools:
+        if is_stream and (self.completed_tools or tools_to_send):
             # 发送工具完成信号
             yield self._create_tool_finish_chunk()
 
@@ -405,7 +573,7 @@ class SSEToolHandler:
 
             if is_stream:
                 logger.info("🏁 发送工具调用完成信号")
-                yield "data: [DONE]\n\n"
+                yield "data: [DONE]"
 
             # 重置工具调用状态
             self.has_tool_call = False
@@ -446,8 +614,12 @@ class SSEToolHandler:
         self.completed_tools.clear()
         self.tool_blocks_cache.clear()
 
-    def _create_tool_start_chunk(self, tool_id: str, tool_name: str) -> str:
-        """创建工具调用开始的chunk"""
+    def _create_tool_start_chunk(self, tool_id: str, tool_name: str, initial_args: Dict[str, Any] = None) -> str:
+        """创建工具调用开始的chunk，支持初始参数"""
+        # 使用提供的初始参数，如果没有则使用空字典
+        args_dict = initial_args or {}
+        args_str = json.dumps(args_dict, ensure_ascii=False)
+
         chunk = {
             "choices": [
                 {
@@ -458,7 +630,7 @@ class SSEToolHandler:
                             {
                                 "id": tool_id,
                                 "type": "function",
-                                "function": {"name": tool_name, "arguments": "{}"},
+                                "function": {"name": tool_name, "arguments": args_str},
                             }
                         ],
                     },
@@ -476,18 +648,15 @@ class SSEToolHandler:
         return f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n"
 
     def _create_tool_arguments_chunk(self, tool_id: str, arguments: Dict) -> str:
-        """创建工具参数的chunk"""
+        """创建工具参数的chunk - 只包含参数更新，不包含函数名"""
         chunk = {
             "choices": [
                 {
                     "delta": {
-                        "role": "assistant",
-                        "content": None,
                         "tool_calls": [
                             {
                                 "id": tool_id,
-                                "type": "function",
-                                "function": {"name": None, "arguments": json.dumps(arguments, ensure_ascii=False)},
+                                "function": {"arguments": json.dumps(arguments, ensure_ascii=False)},
                             }
                         ],
                     },