refactor(app/utils): 重构工具调用处理逻辑

- 完善了工具调用结束的处理逻辑，包括参数解析和状态重置
- 调整了工具调用完成后的响应格式，使其更加规范

app/utils/sse_tool_handler.py

@@ -35,12 +35,14 @@ class SSEToolHandler:
         """
         if not self.has_tool_call:
             self.has_tool_call = True
-            logger.debug("进入工具调用阶段")
+            logger.debug("🔧 进入工具调用阶段")
 
         edit_content = data.get("edit_content", "")
         if not edit_content:
             return
 
+        logger.debug(f"📦 解析数据块: {edit_content}")
+
         # 分割glm_block块
         blocks = edit_content.split("<glm_block >")
 
@@ -48,28 +50,34 @@ class SSEToolHandler:
             if not block:
                 continue
 
+            logger.debug(f"  📦 处理块 {index}: {block[:200]}...")
+
             if "</glm_block>" not in block:
                 # 这个块不完整，可能是参数片段
                 if index == 0:
                     # 第一个块的参数片段
                     self.tool_args += block
+                    logger.debug(f"  📦 累积参数片段: {block}")
                 continue
 
             if index == 0:
                 # 第一个块：提取参数片段（到"result"之前）
+                # 提取到 '"result"' 之前的内容
                 if '"result"' in edit_content:
-                    args_fragment = edit_content[: edit_content.index('"result"') - 3]
+                    result_index = edit_content.index('"result"')
+                    args_fragment = edit_content[:result_index - 3]
                     self.tool_args += args_fragment
-                    logger.debug(f"从第一个块提取参数片段: {args_fragment}")
+                    logger.debug(f"📦 从第一个块提取参数片段: {args_fragment}")
             else:
                 # 后续块：新的工具调用
                 # 如果当前有工具正在处理，先完成它
                 if self.tool_id:
+                    logger.debug(f"  🎯 完成当前工具: {self.tool_name}")
                     yield from self._finish_current_tool(is_stream)
 
                 # 解析新工具信息
                 try:
-                    block_content = block[: block.index("</glm_block>")]
+                    block_content = block[:block.index("</glm_block>")]
                     content = json.loads(block_content)
                     metadata = content.get("data", {}).get("metadata", {})
 
@@ -81,8 +89,8 @@ class SSEToolHandler:
                     # 累积参数（去掉最后的}以便后续累积）
                     self.tool_args = json.dumps(arguments, ensure_ascii=False)[:-1]
 
-                    logger.debug(f"新工具调用: {self.tool_name}(id={self.tool_id})")
-                    logger.debug(f"初始参数: {self.tool_args}")
+                    logger.debug(f"🎯 新工具调用: {self.tool_name}(id={self.tool_id})")
+                    logger.debug(f"  📦 初始参数: {self.tool_args}")
 
                     if is_stream:
                         yield self._create_tool_start_chunk()
@@ -90,40 +98,32 @@ class SSEToolHandler:
                     self.content_index += 1
 
                 except (json.JSONDecodeError, KeyError) as e:
-                    logger.error(f"解析工具块失败: {e}")
+                    logger.error(f"❌ 解析工具块失败: {e}")
+                    logger.error(f"  📦 块内容: {block[:500]}")
 
     def _finish_current_tool(self, is_stream: bool) -> Generator[str, None, None]:
-        """完成当前工具调用"""
         if not self.tool_id:
             return
 
         try:
-            # 处理不同的参数状态
-            if not self.tool_args or self.tool_args == "{":
-                # 空参数或只有开始括号
-                params = {}
-            else:
-                # 尝试补充结束符
-                test_args = self.tool_args
-
-                # 检查是否需要补充结束引号
-                quote_count = test_args.count('"')
-                if quote_count % 2 != 0:
-                    test_args += '"'
+            test_args = self.tool_args + '"'
 
-                # 检查是否需要补充结束括号
-                if not test_args.endswith("}"):
-                    test_args += "}"
+            logger.debug(f"✅ 工具参数解析成功: {self.tool_name}")
+            logger.debug(f"  📦 最终参数字符串: {test_args}")
 
-                params = json.loads(test_args)
+            # 解析参数
+            params = json.loads(test_args)
 
-            logger.debug(f"完成工具调用: {self.tool_name} with params: {params}")
+            logger.debug(f"✅ 完成工具调用: {self.tool_name} with params: {params}")
 
             if is_stream:
                 yield self._create_tool_arguments_chunk(params)
 
         except json.JSONDecodeError as e:
-            logger.error(f"工具参数解析失败: {e}, 原始参数: {self.tool_args[:200]}")
+            logger.error(f"❌ 工具参数解析失败: {e}")
+            logger.error(f"  📦 原始参数: {self.tool_args[:200]}")
+            logger.error(f"  📦 测试参数: {test_args[:200] if 'test_args' in locals() else 'N/A'}")
+            # 解析失败时使用空参数
             params = {}
             if is_stream:
                 yield self._create_tool_arguments_chunk(params)
@@ -144,21 +144,81 @@ class SSEToolHandler:
         # 保存usage信息
         if self.has_tool_call and usage:
             self.tool_call_usage = usage
-            logger.debug(f"保存工具调用usage: {usage}")
+            logger.debug(f"💾 保存工具调用usage: {usage}")
 
         # 检测工具调用结束标记 "null,"
         if self.has_tool_call and edit_content and edit_content.startswith("null,"):
-            logger.debug("检测到工具调用结束标记: null,")
-
-            # 完成最后一个工具调用
-            if self.tool_id:
-                yield from self._finish_current_tool(is_stream)
-
-            # 发送结束信号
-            if is_stream:
-                logger.info("    发送工具调用完成信号")
-                yield self._create_tool_finish_chunk()
-                yield "data: [DONE]\n\n"
+            logger.debug("🏁 检测到工具调用结束标记: null,")
+
+            # 补充引号并完成最后一个工具调用
+            self.tool_args += '"'
+            self.has_tool_call = False
+
+            try:
+                # 解析最终参数
+                params = json.loads(self.tool_args)
+                logger.debug(f"✅ 最终工具参数解析成功: {params}")
+
+                if is_stream:
+                    # 创建工具参数块
+                    tool_call_delta = {
+                        "id": self.tool_id,
+                        "type": "function",
+                        "function": {
+                            "name": None,
+                            "arguments": json.dumps(params, ensure_ascii=False),
+                        },
+                    }
+                    delta_res = {
+                        "choices": [
+                            {
+                                "delta": {
+                                    "role": "assistant",
+                                    "content": None,
+                                    "tool_calls": [tool_call_delta],
+                                },
+                                "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",
+                    }
+                    yield f"data: {json.dumps(delta_res, ensure_ascii=False)}\n\n"
+
+                    # 发送工具完成信号
+                    finish_res = {
+                        "choices": [
+                            {
+                                "delta": {
+                                    "role": "assistant",
+                                    "content": None,
+                                    "tool_calls": [],
+                                },
+                                "finish_reason": "tool_calls",
+                                "index": 0,
+                                "logprobs": None,
+                            }
+                        ],
+                        "created": int(time.time()),
+                        "id": self.chat_id,
+                        "usage": self.tool_call_usage or None,
+                        "model": self.model,
+                        "object": "chat.completion.chunk",
+                        "system_fingerprint": "fp_zai_001",
+                    }
+
+                    logger.info("🏁 发送工具调用完成信号")
+                    yield f"data: {json.dumps(finish_res, ensure_ascii=False)}\n\n"
+                    yield "data: [DONE]\n\n"
+
+            except json.JSONDecodeError as e:
+                logger.error(f"❌ 最终参数解析失败: {e}")
+                logger.error(f"  📦 参数内容: {self.tool_args}")
 
             # 重置所有状态
             self._reset_all_state()
@@ -218,7 +278,7 @@ class SSEToolHandler:
                         ],
                     },
                     "finish_reason": None,
-                    "index": 0,
+                    "index": self.content_index,  # 使用正确的索引
                     "logprobs": None,
                 }
             ],
@@ -243,7 +303,7 @@ class SSEToolHandler:
             ],
             "created": int(time.time()),
             "id": self.chat_id,
-            "usage": self.tool_call_usage,
+            "usage": self.tool_call_usage or None,
             "model": self.model,
             "object": "chat.completion.chunk",
             "system_fingerprint": "fp_zai_001",

tests/test_tool_call_fix.py

@@ -0,0 +1,215 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+测试修复后的工具调用功能
+"""
+
+import json
+import asyncio
+import httpx
+from typing import Dict, Any
+
+# 测试配置
+TEST_URL = "http://localhost:8080/v1/chat/completions"
+TEST_AUTH_TOKEN = "sk-test-key"
+
+# 测试工具定义
+TEST_TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "get_weather",
+            "description": "获取指定城市的天气信息",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "city": {
+                        "type": "string",
+                        "description": "城市名称"
+                    },
+                    "unit": {
+                        "type": "string",
+                        "enum": ["celsius", "fahrenheit"],
+                        "description": "温度单位"
+                    }
+                },
+                "required": ["city"]
+            }
+        }
+    }
+]
+
+async def test_tool_call_streaming():
+    """测试流式工具调用"""
+    print("🧪 开始测试流式工具调用...")
+    
+    payload = {
+        "model": "glm-4.5",
+        "messages": [
+            {
+                "role": "user", 
+                "content": "请帮我查询北京的天气，使用摄氏度"
+            }
+        ],
+        "tools": TEST_TOOLS,
+        "stream": True,
+        "temperature": 0.7
+    }
+    
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {TEST_AUTH_TOKEN}"
+    }
+    
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            async with client.stream(
+                "POST", 
+                TEST_URL, 
+                json=payload, 
+                headers=headers
+            ) as response:
+                print(f"📡 响应状态: {response.status_code}")
+                print(f"📡 响应头: {dict(response.headers)}")
+                
+                if response.status_code != 200:
+                    error_text = await response.aread()
+                    print(f"❌ 请求失败: {error_text.decode()}")
+                    return
+                
+                print("\n📦 开始接收流式数据:")
+                print("-" * 80)
+                
+                chunk_count = 0
+                tool_calls_found = False
+                
+                async for line in response.aiter_lines():
+                    if not line:
+                        continue
+                        
+                    if line.startswith("data: "):
+                        chunk_count += 1
+                        data_str = line[6:].strip()
+                        
+                        if data_str == "[DONE]":
+                            print(f"🏁 [{chunk_count:03d}] 流结束: [DONE]")
+                            break
+                            
+                        try:
+                            chunk = json.loads(data_str)
+                            
+                            # 检查是否包含工具调用
+                            choices = chunk.get("choices", [])
+                            if choices:
+                                choice = choices[0]
+                                delta = choice.get("delta", {})
+                                tool_calls = delta.get("tool_calls", [])
+                                
+                                if tool_calls:
+                                    tool_calls_found = True
+                                    print(f"🔧 [{chunk_count:03d}] 工具调用块:")
+                                    for tool_call in tool_calls:
+                                        print(f"    ID: {tool_call.get('id', 'N/A')}")
+                                        print(f"    类型: {tool_call.get('type', 'N/A')}")
+                                        function = tool_call.get('function', {})
+                                        print(f"    函数名: {function.get('name', 'N/A')}")
+                                        print(f"    参数: {function.get('arguments', 'N/A')}")
+                                        print(f"    参数类型: {type(function.get('arguments', 'N/A'))}")
+                                
+                                finish_reason = choice.get("finish_reason")
+                                if finish_reason:
+                                    print(f"🏁 [{chunk_count:03d}] 完成原因: {finish_reason}")
+                                
+                                # 显示其他内容
+                                content = delta.get("content")
+                                if content:
+                                    print(f"💬 [{chunk_count:03d}] 内容: {content}")
+                            
+                            # 显示usage信息
+                            usage = chunk.get("usage")
+                            if usage:
+                                print(f"📊 [{chunk_count:03d}] 使用统计: {usage}")
+                                
+                        except json.JSONDecodeError as e:
+                            print(f"❌ [{chunk_count:03d}] JSON解析错误: {e}")
+                            print(f"    原始数据: {data_str[:200]}...")
+                
+                print("-" * 80)
+                print(f"✅ 测试完成，共处理 {chunk_count} 个数据块")
+                print(f"🔧 工具调用检测: {'成功' if tool_calls_found else '失败'}")
+                
+    except Exception as e:
+        print(f"❌ 测试异常: {e}")
+        import traceback
+        traceback.print_exc()
+
+async def test_tool_call_non_streaming():
+    """测试非流式工具调用"""
+    print("\n🧪 开始测试非流式工具调用...")
+    
+    payload = {
+        "model": "glm-4.5",
+        "messages": [
+            {
+                "role": "user", 
+                "content": "请帮我查询上海的天气"
+            }
+        ],
+        "tools": TEST_TOOLS,
+        "stream": False,
+        "temperature": 0.7
+    }
+    
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {TEST_AUTH_TOKEN}"
+    }
+    
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.post(TEST_URL, json=payload, headers=headers)
+            
+            print(f"📡 响应状态: {response.status_code}")
+            
+            if response.status_code == 200:
+                result = response.json()
+                print("📦 响应结果:")
+                print(json.dumps(result, indent=2, ensure_ascii=False))
+                
+                # 检查工具调用
+                choices = result.get("choices", [])
+                if choices:
+                    message = choices[0].get("message", {})
+                    tool_calls = message.get("tool_calls", [])
+                    if tool_calls:
+                        print(f"🔧 发现 {len(tool_calls)} 个工具调用")
+                        for i, tool_call in enumerate(tool_calls):
+                            print(f"  工具 {i+1}: {tool_call}")
+                    else:
+                        print("❌ 未发现工具调用")
+            else:
+                print(f"❌ 请求失败: {response.text}")
+                
+    except Exception as e:
+        print(f"❌ 测试异常: {e}")
+
+async def main():
+    """主测试函数"""
+    print("🚀 开始工具调用修复验证测试")
+    print("=" * 80)
+    
+    # 测试流式工具调用
+    await test_tool_call_streaming()
+    
+    # 等待一下
+    await asyncio.sleep(2)
+    
+    # 测试非流式工具调用
+    await test_tool_call_non_streaming()
+    
+    print("\n" + "=" * 80)
+    print("🎯 测试完成")
+
+if __name__ == "__main__":
+    asyncio.run(main())