tamar-model-client 0.2.6__py3-none-any.whl → 0.2.7__py3-none-any.whl

tamar_model_client/__init__.py

@@ -3,6 +3,7 @@ from .async_client import AsyncTamarModelClient
 from .exceptions import ModelManagerClientError, ConnectionError, ValidationError
 from .json_formatter import JSONFormatter
 from . import logging_icons
+from .tool_call_helper import ToolCallHelper
 
 __all__ = [
     "TamarModelClient",
@@ -12,4 +13,5 @@ __all__ = [
     "ValidationError",
     "JSONFormatter",
     "logging_icons",
+    "ToolCallHelper",
 ]

tamar_model_client/async_client.py

@@ -623,7 +623,7 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
             origin_request_id
         )
         stream_iter = self.stub.Invoke(request, metadata=fresh_metadata, timeout=invoke_timeout).__aiter__()
-        chunk_timeout = 30.0  # 单个数据块的超时时间
+        chunk_timeout = self.stream_chunk_timeout  # 单个数据块的超时时间
         
         try:
             while True:

tamar_model_client/core/base_client.py

@@ -296,6 +296,10 @@ class BaseClient(ABC):
                 if hasattr(grpc.StatusCode, error_name):
                     self.never_fallback_errors.add(getattr(grpc.StatusCode, error_name))
 
+        # 流式响应单个数据块的超时时间（秒）
+        # AI模型生成可能需要更长时间，默认设置为120秒
+        self.stream_chunk_timeout = float(os.getenv('MODEL_CLIENT_STREAM_CHUNK_TIMEOUT', '120.0'))
+
         if self.fast_fallback_enabled:
             self.logger.info(
                 "🚀 Fast fallback enabled",

tamar_model_client/core/response_handler.py

@@ -22,20 +22,87 @@ class ResponseHandler:
     @staticmethod
     def build_model_response(grpc_response) -> ModelResponse:
         """
-        从 gRPC 响应构建 ModelResponse 对象
+        从 gRPC 响应构建增强的 ModelResponse 对象
+        
+        新增功能：
+        1. 自动提取 tool_calls（对标 OpenAI SDK）
+        2. 提取 finish_reason（对标 OpenAI SDK）
+        3. 支持多种 provider 格式转换
         
         Args:
             grpc_response: gRPC 服务返回的响应对象
             
         Returns:
-            ModelResponse: 客户端响应对象
+            ModelResponse: 增强的客户端响应对象
         """
+        raw_response = ResponseHandler._parse_json_field(grpc_response.raw_response)
+        
+        # 提取 tool_calls 和 finish_reason
+        tool_calls = None
+        finish_reason = None
+        
+        if raw_response and isinstance(raw_response, dict):
+            # OpenAI/Azure OpenAI 格式
+            if 'choices' in raw_response and raw_response['choices']:
+                choice = raw_response['choices'][0]
+                
+                # 提取 tool_calls
+                if 'message' in choice and 'tool_calls' in choice['message']:
+                    tool_calls = choice['message']['tool_calls']
+                
+                # 提取 finish_reason
+                if 'finish_reason' in choice:
+                    finish_reason = choice['finish_reason']
+            
+            # Google AI 格式适配
+            elif 'candidates' in raw_response and raw_response['candidates']:
+                candidate = raw_response['candidates'][0]
+                
+                # Google 格式的 function calls 映射
+                if 'content' in candidate and 'parts' in candidate['content']:
+                    parts = candidate['content']['parts']
+                    google_tool_calls = []
+                    
+                    for i, part in enumerate(parts):
+                        if 'functionCall' in part:
+                            # 转换为 OpenAI 兼容格式
+                            function_call = part['functionCall']
+                            google_tool_calls.append({
+                                'id': f"call_{i}_{function_call.get('name', 'unknown')}",
+                                'type': 'function',
+                                'function': {
+                                    'name': function_call.get('name', ''),
+                                    'arguments': json.dumps(function_call.get('args', {}))
+                                }
+                            })
+                    
+                    if google_tool_calls:
+                        tool_calls = google_tool_calls
+                
+                # Google 的 finish_reason
+                if 'finishReason' in candidate:
+                    # 映射 Google 格式到标准格式
+                    google_reason = candidate['finishReason']
+                    finish_reason_mapping = {
+                        'STOP': 'stop',
+                        'MAX_TOKENS': 'length',
+                        'SAFETY': 'content_filter',
+                        'RECITATION': 'content_filter'
+                    }
+                    finish_reason = finish_reason_mapping.get(google_reason, google_reason.lower())
+                    
+                    # 如果有工具调用，设置 finish_reason 为 tool_calls
+                    if tool_calls:
+                        finish_reason = 'tool_calls'
+        
         return ModelResponse(
             content=grpc_response.content,
             usage=ResponseHandler._parse_json_field(grpc_response.usage),
             error=grpc_response.error or None,
-            raw_response=ResponseHandler._parse_json_field(grpc_response.raw_response),
+            raw_response=raw_response,
             request_id=grpc_response.request_id if grpc_response.request_id else None,
+            tool_calls=tool_calls,
+            finish_reason=finish_reason
         )
     
     @staticmethod
@@ -117,12 +184,28 @@ class ResponseHandler:
                 "client_type": model_request.user_context.client_type
             })
         
+        # 添加请求中的 tool 信息
+        if hasattr(model_request, 'tools') and model_request.tools:
+            data["tools_count"] = len(model_request.tools) if isinstance(model_request.tools, list) else 1
+            data["has_tools"] = True
+        
+        if hasattr(model_request, 'tool_choice') and model_request.tool_choice:
+            data["tool_choice"] = str(model_request.tool_choice)
+        
         # 添加响应信息
         if response:
             if hasattr(response, 'content') and response.content:
                 data["content_length"] = len(response.content)
             if hasattr(response, 'usage'):
                 data["usage"] = response.usage
+            
+            # 新增：tool_calls 相关日志
+            if hasattr(response, 'tool_calls') and response.tool_calls:
+                data["tool_calls_count"] = len(response.tool_calls)
+                data["has_tool_calls"] = True
+                
+            if hasattr(response, 'finish_reason') and response.finish_reason:
+                data["finish_reason"] = response.finish_reason
         
         # 添加流式响应统计
         if stream_stats:

tamar_model_client/schemas/outputs.py

@@ -15,8 +15,27 @@ class BaseResponse(BaseModel):
 
 
 class ModelResponse(BaseResponse):
+    """增强的模型响应类，对标 OpenAI SDK 的 Tool Call 支持"""
+    
     model_config = ConfigDict(arbitrary_types_allowed=True)
+    
     request_id: Optional[str] = None  # 请求ID，用于跟踪请求
+    
+    # 新增字段 - 对标 OpenAI SDK
+    tool_calls: Optional[List[Dict[str, Any]]] = None
+    """Tool calls 列表，对应 OpenAI SDK 的 message.tool_calls"""
+    
+    finish_reason: Optional[str] = None
+    """完成原因，对应 OpenAI SDK 的 choice.finish_reason"""
+    
+    # 基础便利方法
+    def has_tool_calls(self) -> bool:
+        """检查响应是否包含 tool calls
+        
+        Returns:
+            bool: 如果包含 tool calls 返回 True
+        """
+        return bool(self.tool_calls and len(self.tool_calls) > 0)
 
 
 class BatchModelResponse(BaseModel):

tamar_model_client/sync_client.py

@@ -786,7 +786,7 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
         fetch_thread.daemon = True
         fetch_thread.start()
         
-        chunk_timeout = 30.0  # 单个数据块的超时时间
+        chunk_timeout = self.stream_chunk_timeout  # 单个数据块的超时时间
         
         while True:
             # 检查是否有异常

tamar_model_client/tool_call_helper.py

@@ -0,0 +1,169 @@
+"""
+Tool Call 实用工具类
+
+提供简化 Tool Call 使用的基础工具方法，减少常见错误和样板代码。
+注意：本工具类仅提供数据处理便利，不包含自动执行功能。
+"""
+
+import json
+from typing import List, Dict, Any, Optional
+
+from .schemas.outputs import ModelResponse
+
+
+class ToolCallHelper:
+    """Tool Call 实用工具类
+    
+    提供基础的数据处理方法，对标 OpenAI SDK 的使用体验。
+    """
+    
+    @staticmethod
+    def create_function_tool(
+        name: str, 
+        description: str, 
+        parameters: Dict[str, Any],
+        strict: Optional[bool] = None
+    ) -> Dict[str, Any]:
+        """创建函数工具定义（对标 OpenAI SDK 的工具定义格式）
+        
+        Args:
+            name: 函数名称
+            description: 函数描述
+            parameters: 函数参数的 JSON Schema
+            strict: 是否启用严格模式（OpenAI Structured Outputs）
+            
+        Returns:
+            ChatCompletionToolParam: 工具定义对象
+            
+        Example:
+            >>> weather_tool = ToolCallHelper.create_function_tool(
+            ...     name="get_weather",
+            ...     description="获取指定城市的天气信息",
+            ...     parameters={
+            ...         "type": "object",
+            ...         "properties": {
+            ...             "location": {"type": "string", "description": "城市名称"}
+            ...         },
+            ...         "required": ["location"]
+            ...     }
+            ... )
+        """
+        tool_def = {
+            "type": "function",
+            "function": {
+                "name": name,
+                "description": description,
+                "parameters": parameters
+            }
+        }
+        
+        if strict is not None:
+            tool_def["function"]["strict"] = strict
+            
+        return tool_def
+    
+    @staticmethod
+    def create_tool_response_message(
+        tool_call_id: str, 
+        content: str,
+        name: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """创建工具响应消息（对标 OpenAI SDK 的消息格式）
+        
+        Args:
+            tool_call_id: 工具调用 ID
+            content: 工具执行结果
+            name: 工具名称（可选）
+            
+        Returns:
+            ChatCompletionMessageParam: 工具响应消息
+            
+        Example:
+            >>> tool_message = ToolCallHelper.create_tool_response_message(
+            ...     tool_call_id="call_123",
+            ...     content="北京今天晴天，25°C",
+            ...     name="get_weather"
+            ... )
+        """
+        message = {
+            "role": "tool",
+            "tool_call_id": tool_call_id,
+            "content": content
+        }
+        
+        if name:
+            message["name"] = name
+            
+        return message
+    
+    @staticmethod
+    def parse_function_arguments(tool_call: Dict[str, Any]) -> Dict[str, Any]:
+        """安全解析函数参数（解决 OpenAI SDK 需要手动 json.loads 的痛点）
+        
+        Args:
+            tool_call: 工具调用对象
+            
+        Returns:
+            Dict[str, Any]: 解析后的参数字典
+            
+        Raises:
+            ValueError: 不支持的工具类型或参数解析失败
+            
+        Example:
+            >>> tool_call = response.tool_calls[0]
+            >>> arguments = ToolCallHelper.parse_function_arguments(tool_call)
+            >>> print(arguments["location"])  # "北京"
+        """
+        if tool_call.get("type") != "function":
+            raise ValueError(f"不支持的工具类型: {tool_call.get('type')}")
+        
+        function = tool_call.get("function", {})
+        arguments_str = function.get("arguments", "{}")
+        
+        try:
+            return json.loads(arguments_str)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"解析工具参数失败: {arguments_str}") from e
+    
+    @staticmethod  
+    def build_messages_with_tool_response(
+        original_messages: List[Dict[str, Any]],
+        assistant_message: ModelResponse, 
+        tool_responses: List[Dict[str, Any]]
+    ) -> List[Dict[str, Any]]:
+        """构建包含工具响应的消息列表（简化版工具方法）
+        
+        Args:
+            original_messages: 原始消息列表
+            assistant_message: 包含 tool calls 的助手响应
+            tool_responses: 工具响应列表
+            
+        Returns:
+            List[Dict[str, Any]]: 新的消息列表
+            
+        Example:
+            >>> new_messages = ToolCallHelper.build_messages_with_tool_response(
+            ...     original_messages=request.messages,
+            ...     assistant_message=response,
+            ...     tool_responses=[tool_message]
+            ... )
+            >>> # 然后开发者手动创建新请求发送
+        """
+        new_messages = list(original_messages)
+        
+        # 添加助手的响应消息
+        assistant_msg = {
+            "role": "assistant",
+            "content": assistant_message.content or ""
+        }
+        
+        # 如果有 tool calls，添加到消息中
+        if assistant_message.has_tool_calls():
+            assistant_msg["tool_calls"] = assistant_message.tool_calls
+        
+        new_messages.append(assistant_msg)
+        
+        # 添加工具响应消息
+        new_messages.extend(tool_responses)
+        
+        return new_messages

{tamar_model_client-0.2.6.dist-info → tamar_model_client-0.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tamar-model-client
-Version: 0.2.6
+Version: 0.2.7
 Summary: A Python SDK for interacting with the Model Manager gRPC service
 Home-page: http://gitlab.tamaredge.top/project-tap/AgentOS/model-manager-client
 Author: Oscar Ou

{tamar_model_client-0.2.6.dist-info → tamar_model_client-0.2.7.dist-info}/RECORD

@@ -1,20 +1,21 @@
-tamar_model_client/__init__.py,sha256=4DEIUGlLTeiaECjJQbGYik7C0JO6hHwwfbLYpYpMdzg,444
-tamar_model_client/async_client.py,sha256=047a3Ts6Qe2Wcs4xyxtG71kvYngTuSHFzB3V8D97_ec,46431
+tamar_model_client/__init__.py,sha256=PpU0HWhbgp6jb7cksBcEOUNalHmJ14WfkjhZGVBK1-U,513
+tamar_model_client/async_client.py,sha256=u3fikItsFfzqwSYsvH7GIrHXJGSE1oeJ7ubXnx9G8QE,46452
 tamar_model_client/auth.py,sha256=DrtnFpG0ZKFUnTnV_Y-FuLRiC2kobcgg0W5Gr1ywg1k,1398
 tamar_model_client/circuit_breaker.py,sha256=Y3AVp7WzVYU-ubcmovKsJ8DRJbbO4G7vdZgSjnwcWJQ,5550
 tamar_model_client/error_handler.py,sha256=y7EipcqkXbCecSAOsnoSP3SH7hvZSNF_NUHooTi3hP0,18364
 tamar_model_client/exceptions.py,sha256=EOr4JMYI7hVszRvNYJ1JqsUNpVmd16T2KpJ0MkFTsUE,13073
 tamar_model_client/json_formatter.py,sha256=XT8XPMKKM2M22tuYR2e1rvWHcpz3UD9iLLgGPsGOjCI,2410
 tamar_model_client/logging_icons.py,sha256=MRTZ1Xvkep9ce_jdltj54_XZUXvIpQ95soRNmLdJ4qw,1837
-tamar_model_client/sync_client.py,sha256=FbyjuyDRiXklSS_l5h5fwNxvABI-hpLGiIWAXqhPHoI,53760
+tamar_model_client/sync_client.py,sha256=3BpvW_lexbBapqi4u37LAE00gQlwK3p-aAC7K0ubPTM,53781
+tamar_model_client/tool_call_helper.py,sha256=MbrrKuQ89uP0AojVtxefCbiKI11QKCoOB6GHMr_brjk,5704
 tamar_model_client/utils.py,sha256=9gJm71UuQhyyBCgo6gvMjv74xepOlw6AiwuSzea2CL0,5595
 tamar_model_client/core/__init__.py,sha256=RMiZjV1S4csWPLxB_JfdOea8fYPz97Oj3humQSBw1OI,1054
-tamar_model_client/core/base_client.py,sha256=spb4zjDuPczqnXNlDcIq_bDQ09TOpxeeuX7IxpTS_38,13859
+tamar_model_client/core/base_client.py,sha256=4_QDpXemqTGVO4jPREe0ou9aW-a9_XD3P_E72h8VGDU,14098
 tamar_model_client/core/http_fallback.py,sha256=2N7-N_TZrtffDjuv9s3-CD8Xy7qw9AuI5xeWGUnGQ0w,22217
 tamar_model_client/core/logging_setup.py,sha256=-MXzTR4Ax50H16cbq1jCXbxgayf5fZ0U3o0--fMmxD8,6692
 tamar_model_client/core/request_builder.py,sha256=aplTEXGgeipn-dRCdUptHYWkT9c4zjKmbmI8Ckbv_sM,8516
 tamar_model_client/core/request_id_manager.py,sha256=S-Mliaby9zN_bx-B85FvVnttal-w0skkjy2ZvWoQ5vw,3689
-tamar_model_client/core/response_handler.py,sha256=_q5galAT0_RaUT5C_yZsjg-9VnT9CBjmIASOt28BUmQ,4616
+tamar_model_client/core/response_handler.py,sha256=dmF5GXvBqwtssgVyJDkQc_MxgjBaoY3yOKOk2gJumbE,8613
 tamar_model_client/core/utils.py,sha256=AcbsGfNQEaZLYI4OZJs-BdmJgxAoLUC5LFoiYmji820,5875
 tamar_model_client/enums/__init__.py,sha256=3cYYn8ztNGBa_pI_5JGRVYf2QX8fkBVWdjID1PLvoBQ,182
 tamar_model_client/enums/channel.py,sha256=wCzX579nNpTtwzGeS6S3Ls0UzVAgsOlfy4fXMzQTCAw,199
@@ -25,14 +26,15 @@ tamar_model_client/generated/model_service_pb2.py,sha256=RI6wNSmgmylzWPedFfPxx93
 tamar_model_client/generated/model_service_pb2_grpc.py,sha256=k4tIbp3XBxdyuOVR18Ung_4SUryONB51UYf_uUEl6V4,5145
 tamar_model_client/schemas/__init__.py,sha256=j5XaUGc5Wy669IRNCey56sryCK8QrYbSTl8DSbCqc94,437
 tamar_model_client/schemas/inputs.py,sha256=Hyl3f-oGT3ooUSs4yn7rHWLJHlltXsQwLSwnlNJx1sE,17503
-tamar_model_client/schemas/outputs.py,sha256=M_fcqUtXPJnfiLabHlyA8BorlC5pYkf5KLjXO1ysKIQ,1031
+tamar_model_client/schemas/outputs.py,sha256=Dpd2I-gVr1U154r31OfJ7UrYV5oVh7A5b25cAMKT374,1672
 tests/__init__.py,sha256=kbmImddLDwdqlkkmkyKtl4bQy_ipe-R8eskpaBylU9w,38
 tests/stream_hanging_analysis.py,sha256=W3W48IhQbNAR6-xvMpoWZvnWOnr56CTaH4-aORNBuD4,14807
 tests/test_circuit_breaker.py,sha256=nhEBnyXFjIYjRWlUdu7Z9PnPq48ypbBK6fxN6deHedw,12172
-tests/test_google_azure_final.py,sha256=YnTl5_e-C_lay2e0_0z35rpIxRkLs1tTsvcQ3Qww_RU,67077
+tests/test_google_azure_final.py,sha256=QY_1fPK3qrgvP-3rXWeiLc8lQMgCWtR2U-aTcl-xK3I,67009
 tests/test_logging_issue.py,sha256=JTMbotfHpAEPMBj73pOwxPn-Zn4QVQJX6scMz48FRDQ,2427
 tests/test_simple.py,sha256=Xf0U-J9_xn_LzUsmYu06suK0_7DrPeko8OHoHldsNxE,7169
-tamar_model_client-0.2.6.dist-info/METADATA,sha256=kn5Ehyvj1YG3TDoY5YsJvIDhn3hksTgHUycDdRRJojU,44637
-tamar_model_client-0.2.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tamar_model_client-0.2.6.dist-info/top_level.txt,sha256=f1I-S8iWN-cgv4gB8gxRg9jJOTJMumvm4oGKVPfGg6A,25
-tamar_model_client-0.2.6.dist-info/RECORD,,
+tests/test_tool_call_enhancement.py,sha256=vhhT2_Ni9B0emycT1q7qHn4P9KqDN8UNPzFswTMa4_c,21591
+tamar_model_client-0.2.7.dist-info/METADATA,sha256=7yk65vRlF1VJRkxZzBKoRROvliNE39wlVogxjR9Fo5w,44637
+tamar_model_client-0.2.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tamar_model_client-0.2.7.dist-info/top_level.txt,sha256=f1I-S8iWN-cgv4gB8gxRg9jJOTJMumvm4oGKVPfGg6A,25
+tamar_model_client-0.2.7.dist-info/RECORD,,

tests/test_google_azure_final.py

@@ -1471,36 +1471,36 @@ async def main():
 
     try:
         # 同步测试
-        # test_google_ai_studio()
-        # test_google_vertex_ai()
-        # test_azure_openai()
+        test_google_ai_studio()
+        test_google_vertex_ai()
+        test_azure_openai()
         
         # 新增：图像生成测试
-        # test_google_genai_image_generation()
-        # test_google_vertex_ai_image_generation()
+        test_google_genai_image_generation()
+        test_google_vertex_ai_image_generation()
         
         # 同步批量测试
-        # test_sync_batch_requests()
+        test_sync_batch_requests()
 
         # 异步流式测试
-        # await asyncio.wait_for(test_google_streaming(), timeout=60.0)
-        # await asyncio.wait_for(test_azure_streaming(), timeout=60.0)
+        await asyncio.wait_for(test_google_streaming(), timeout=60.0)
+        await asyncio.wait_for(test_azure_streaming(), timeout=60.0)
         
-        # 新增：异步图像生成测试
-        # await asyncio.wait_for(test_google_genai_image_generation_async(), timeout=120.0)
-        # await asyncio.wait_for(test_google_vertex_ai_image_generation_async(), timeout=120.0)
-        #
-        # # 异步批量测试
-        # await asyncio.wait_for(test_batch_requests(), timeout=120.0)
-        #
-        # # 新增：图像生成批量测试
-        # await asyncio.wait_for(test_image_generation_batch(), timeout=180.0)
+        #：异步图像生成测试
+        await asyncio.wait_for(test_google_genai_image_generation_async(), timeout=120.0)
+        await asyncio.wait_for(test_google_vertex_ai_image_generation_async(), timeout=120.0)
+
+        # 异步批量测试
+        await asyncio.wait_for(test_batch_requests(), timeout=120.0)
+
+        # 新增：图像生成批量测试
+        await asyncio.wait_for(test_image_generation_batch(), timeout=180.0)
 
         # 同步并发测试
-        # test_concurrent_requests(2)  # 测试150个并发请求
-        #
-        # # 异步并发测试
-        # await test_async_concurrent_requests(2)  # 测试50个异步并发请求（复用连接）
+        test_concurrent_requests(2)  # 测试150个并发请求
+
+        # 异步并发测试
+        await test_async_concurrent_requests(2)  # 测试50个异步并发请求（复用连接）
 
         print("\n✅ 测试完成")
 

tests/test_tool_call_enhancement.py

@@ -0,0 +1,571 @@
+#!/usr/bin/env python3
+"""
+Tool Call Enhancement 测试脚本
+
+测试 Tool Call 功能的增强实现，包括：
+1. ModelResponse 的 tool_calls 和 finish_reason 字段
+2. ToolCallHelper 工具类的便利方法
+3. ResponseHandler 的自动提取功能
+"""
+
+import asyncio
+import json
+import logging
+import os
+import sys
+from unittest.mock import Mock
+
+# 配置测试脚本专用的日志
+test_logger = logging.getLogger('test_tool_call_enhancement')
+test_logger.setLevel(logging.INFO)
+test_logger.propagate = False
+
+test_handler = logging.StreamHandler()
+test_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
+test_logger.addHandler(test_handler)
+
+logger = test_logger
+
+# 工具函数实现
+def get_weather(location: str) -> str:
+    """获取指定城市的天气信息
+    
+    Args:
+        location: 城市名称
+        
+    Returns:
+        天气信息字符串
+    """
+    # 模拟天气数据
+    weather_data = {
+        "北京": "北京今天晴天，温度25°C，微风",
+        "上海": "上海今天多云，温度28°C，湿度较高", 
+        "广州": "广州今天阴天，温度32°C，有雷阵雨",
+        "深圳": "深圳今天晴天，温度30°C，空气质量良好",
+        "杭州": "杭州今天小雨，温度22°C，建议带伞",
+        "成都": "成都今天阴天，温度26°C，空气湿润"
+    }
+    
+    # 默认天气信息
+    return weather_data.get(location, f"{location}今天天气晴朗，温度适宜")
+
+# 设置测试环境变量
+os.environ['MODEL_MANAGER_SERVER_GRPC_USE_TLS'] = "false"
+os.environ['MODEL_MANAGER_SERVER_ADDRESS'] = "localhost:50051"
+os.environ['MODEL_MANAGER_SERVER_JWT_SECRET_KEY'] = "model-manager-server-jwt-key"
+
+# 导入客户端模块
+try:
+    from tamar_model_client import TamarModelClient, AsyncTamarModelClient
+    from tamar_model_client.schemas import ModelRequest, UserContext
+    from tamar_model_client.enums import ProviderType, InvokeType, Channel
+    
+    # 为了调试，临时启用 SDK 的日志输出
+    os.environ['TAMAR_MODEL_CLIENT_LOG_LEVEL'] = 'INFO'
+
+except ImportError as e:
+    logger.error(f"导入模块失败: {e}")
+    sys.exit(1)
+
+
+def test_model_response_enhancement():
+    """测试 ModelResponse 增强功能"""
+    print("\n📋 测试 ModelResponse 增强功能...")
+    
+    try:
+        from tamar_model_client.schemas.outputs import ModelResponse
+        
+        # 测试有工具调用的情况
+        response_with_tools = ModelResponse(
+            content="I need to call some tools.",
+            tool_calls=[
+                {
+                    "id": "call_123",
+                    "type": "function",
+                    "function": {"name": "get_weather", "arguments": '{"location": "Beijing"}'}
+                }
+            ],
+            finish_reason="tool_calls"
+        )
+        
+        assert response_with_tools.has_tool_calls() is True
+        assert len(response_with_tools.tool_calls) == 1
+        print("   ✅ 有工具调用的情况测试通过")
+        
+        # 测试无工具调用的情况
+        response_without_tools = ModelResponse(
+            content="Here is the answer.",
+            finish_reason="stop"
+        )
+        
+        assert response_without_tools.has_tool_calls() is False
+        assert response_without_tools.tool_calls is None
+        print("   ✅ 无工具调用的情况测试通过")
+        
+        # 测试空的工具调用列表
+        response_empty_tools = ModelResponse(
+            content="Here is the answer.",
+            tool_calls=[],
+            finish_reason="stop"
+        )
+        
+        assert response_empty_tools.has_tool_calls() is False
+        print("   ✅ 空工具调用列表的情况测试通过")
+        
+        print("✅ ModelResponse 增强功能测试全部通过")
+        
+    except Exception as e:
+        print(f"❌ ModelResponse 增强功能测试失败: {str(e)}")
+
+
+def test_tool_call_helper():
+    """测试 ToolCallHelper 工具类"""
+    print("\n🔧 测试 ToolCallHelper 工具类...")
+    
+    try:
+        from tamar_model_client import ToolCallHelper
+        from tamar_model_client.schemas.outputs import ModelResponse
+        
+        # 测试创建函数工具
+        tool = ToolCallHelper.create_function_tool(
+            name="test_func",
+            description="测试函数",
+            parameters={
+                "type": "object",
+                "properties": {"param1": {"type": "string"}},
+                "required": ["param1"]
+            }
+        )
+        
+        assert tool["type"] == "function"
+        assert tool["function"]["name"] == "test_func"
+        assert tool["function"]["description"] == "测试函数"
+        assert "param1" in tool["function"]["parameters"]["properties"]
+        print("   ✅ 创建函数工具测试通过")
+        
+        # 测试解析函数参数
+        tool_call = {
+            "type": "function",
+            "function": {
+                "name": "test_func",
+                "arguments": '{"location": "Beijing", "unit": "celsius"}'
+            }
+        }
+        
+        args = ToolCallHelper.parse_function_arguments(tool_call)
+        assert args["location"] == "Beijing"
+        assert args["unit"] == "celsius"
+        print("   ✅ 解析函数参数测试通过")
+        
+        # 测试创建工具响应消息
+        response_msg = ToolCallHelper.create_tool_response_message(
+            "call_123",
+            "Tool execution result",
+            "test_tool"
+        )
+        
+        assert response_msg["role"] == "tool"
+        assert response_msg["tool_call_id"] == "call_123"
+        assert response_msg["content"] == "Tool execution result"
+        assert response_msg["name"] == "test_tool"
+        print("   ✅ 创建工具响应消息测试通过")
+        
+        # 测试构建包含工具响应的消息列表
+        original_messages = [
+            {"role": "user", "content": "What's the weather?"}
+        ]
+        
+        assistant_response = ModelResponse(
+            content="I'll check the weather for you.",
+            tool_calls=[
+                {
+                    "id": "call_weather",
+                    "type": "function",
+                    "function": {"name": "get_weather", "arguments": '{"location": "Beijing"}'}
+                }
+            ],
+            finish_reason="tool_calls"
+        )
+        
+        tool_responses = [
+            {
+                "role": "tool",
+                "tool_call_id": "call_weather",
+                "content": "Beijing: Sunny, 25°C"
+            }
+        ]
+        
+        new_messages = ToolCallHelper.build_messages_with_tool_response(
+            original_messages, assistant_response, tool_responses
+        )
+        
+        assert len(new_messages) == 3
+        assert new_messages[0]["role"] == "user"
+        assert new_messages[1]["role"] == "assistant"
+        assert new_messages[1]["tool_calls"] == assistant_response.tool_calls
+        assert new_messages[2]["role"] == "tool"
+        assert new_messages[2]["tool_call_id"] == "call_weather"
+        print("   ✅ 构建消息列表测试通过")
+        
+        print("✅ ToolCallHelper 工具类测试全部通过")
+        
+    except Exception as e:
+        print(f"❌ ToolCallHelper 工具类测试失败: {str(e)}")
+
+
+def test_response_handler_enhancement():
+    """测试 ResponseHandler 增强功能"""
+    print("\n🔄 测试 ResponseHandler 增强功能...")
+    
+    try:
+        from tamar_model_client.core.response_handler import ResponseHandler
+        
+        # 测试 OpenAI 格式的 tool calls 提取
+        mock_grpc_response = Mock()
+        mock_grpc_response.content = ""
+        mock_grpc_response.usage = None
+        mock_grpc_response.error = None
+        mock_grpc_response.request_id = "req_123"
+        mock_grpc_response.raw_response = json.dumps({
+            "choices": [
+                {
+                    "message": {
+                        "tool_calls": [
+                            {
+                                "id": "call_456",
+                                "type": "function",
+                                "function": {
+                                    "name": "get_weather",
+                                    "arguments": '{"location": "Shanghai"}'
+                                }
+                            }
+                        ]
+                    },
+                    "finish_reason": "tool_calls"
+                }
+            ]
+        })
+        
+        response = ResponseHandler.build_model_response(mock_grpc_response)
+        
+        assert response.has_tool_calls() is True
+        assert response.finish_reason == "tool_calls"
+        assert len(response.tool_calls) == 1
+        assert response.tool_calls[0]["function"]["name"] == "get_weather"
+        print("   ✅ OpenAI 格式 tool calls 提取测试通过")
+        
+        # 测试 Google 格式转换
+        mock_google_response = Mock()
+        mock_google_response.content = ""
+        mock_google_response.usage = None
+        mock_google_response.error = None
+        mock_google_response.request_id = "req_456"
+        mock_google_response.raw_response = json.dumps({
+            "candidates": [
+                {
+                    "content": {
+                        "parts": [
+                            {
+                                "functionCall": {
+                                    "name": "get_weather",
+                                    "args": {"location": "Guangzhou"}
+                                }
+                            }
+                        ]
+                    },
+                    "finishReason": "STOP"
+                }
+            ]
+        })
+        
+        google_response = ResponseHandler.build_model_response(mock_google_response)
+        
+        assert google_response.has_tool_calls() is True
+        assert google_response.finish_reason == "tool_calls"  # 自动转换
+        assert len(google_response.tool_calls) == 1
+        
+        tool_call = google_response.tool_calls[0]
+        assert tool_call["type"] == "function"
+        assert tool_call["function"]["name"] == "get_weather"
+        assert "call_0_get_weather" in tool_call["id"]
+        
+        # 验证参数转换
+        args = json.loads(tool_call["function"]["arguments"])
+        assert args["location"] == "Guangzhou"
+        print("   ✅ Google 格式转换测试通过")
+        
+        print("✅ ResponseHandler 增强功能测试全部通过")
+        
+    except Exception as e:
+        print(f"❌ ResponseHandler 增强功能测试失败: {str(e)}")
+
+
+def test_openai_tool_call():
+    """测试 OpenAI Tool Call 场景"""
+    print("\n🔧 测试 OpenAI Tool Call...")
+    
+    try:
+        client = TamarModelClient()
+        
+        request = ModelRequest(
+            provider=ProviderType.AZURE,
+            invoke_type=InvokeType.CHAT_COMPLETIONS,
+            model="gpt-4o-mini",
+            messages=[
+                {"role": "user", "content": "北京今天天气如何？"}
+            ],
+            tools=[
+                {
+                    "type": "function",
+                    "name": "get_weather",
+                    "description": "获取指定城市的天气信息",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "location": {
+                                "type": "string",
+                                "description": "城市名称"
+                            }
+                        },
+                        "required": ["location"]
+                    },
+                    "strict": None
+                }
+            ],
+            tool_choice="auto",
+            user_context=UserContext(
+                user_id="test_user",
+                org_id="test_org",
+                client_type="tool_call_test"
+            )
+        )
+        
+        response = client.invoke(request)
+        
+        print(f"✅ OpenAI Tool Call 测试成功")
+        print(f"   响应类型: {type(response)}")
+        print(f"   是否有 tool calls: {response.has_tool_calls()}")
+        print(f"   finish_reason: {response.finish_reason}")
+        
+        if response.has_tool_calls():
+            print(f"   tool_calls 数量: {len(response.tool_calls)}")
+            for i, tool_call in enumerate(response.tool_calls):
+                function_name = tool_call['function']['name']
+                print(f"   工具 {i+1}: {function_name}")
+                from tamar_model_client import ToolCallHelper
+                args = ToolCallHelper.parse_function_arguments(tool_call)
+                print(f"   参数: {args}")
+                
+                # 演示实际工具函数调用
+                if function_name == "get_weather":
+                    result = get_weather(args['location'])
+                    print(f"   执行结果: {result}")
+        
+        print(f"   响应内容: {str(response.content)[:200]}...")
+        
+    except Exception as e:
+        print(f"❌ OpenAI Tool Call 测试失败: {str(e)}")
+
+
+def test_google_tool_call():
+    """测试 Google Tool Call 场景"""
+    print("\n🔧 测试 Google Tool Call...")
+    
+    try:
+        client = TamarModelClient()
+        
+        request = ModelRequest(
+            provider=ProviderType.GOOGLE,
+            invoke_type=InvokeType.GENERATION,
+            model="tamar-google-gemini-flash-lite",
+            contents=[
+                {"role": "user", "parts": [{"text": "上海今天天气如何？"}]}
+            ],
+            config={
+                "tools": [
+                    {
+                        "functionDeclarations": [
+                            {
+                                "name": "get_weather",
+                                "description": "获取指定城市的天气信息",
+                                "parameters": {
+                                    "type": "object",
+                                    "properties": {
+                                        "location": {
+                                            "type": "string",
+                                            "description": "城市名称"
+                                        }
+                                    },
+                                    "required": ["location"]
+                                }
+                            }
+                        ]
+                    }
+                ]
+            },
+            user_context=UserContext(
+                user_id="test_user",
+                org_id="test_org",
+                client_type="google_tool_test"
+            )
+        )
+        
+        response = client.invoke(request)
+        
+        print(f"✅ Google Tool Call 测试成功")
+        print(f"   响应类型: {type(response)}")
+        print(f"   是否有 tool calls: {response.has_tool_calls()}")
+        print(f"   finish_reason: {response.finish_reason}")
+        
+        if response.has_tool_calls():
+            print(f"   tool_calls 数量: {len(response.tool_calls)}")
+            for i, tool_call in enumerate(response.tool_calls):
+                function_name = tool_call['function']['name']
+                print(f"   工具 {i+1}: {function_name}")
+                from tamar_model_client import ToolCallHelper
+                args = ToolCallHelper.parse_function_arguments(tool_call)
+                print(f"   参数: {args}")
+                
+                # 演示实际工具函数调用
+                if function_name == "get_weather":
+                    result = get_weather(args['location'])
+                    print(f"   执行结果: {result}")
+        
+        print(f"   响应内容: {str(response.content)[:200]}...")
+        
+    except Exception as e:
+        print(f"❌ Google Tool Call 测试失败: {str(e)}")
+
+
+async def test_async_tool_call_workflow():
+    """测试异步工具调用工作流程"""
+    print("\n🔄 测试异步工具调用工作流程...")
+    
+    try:
+        from tamar_model_client import ToolCallHelper
+        
+        async with AsyncTamarModelClient() as client:
+            # 1. 发送带工具的请求
+            initial_messages = [
+                {"role": "user", "content": "深圳今天天气怎么样？"}
+            ]
+            
+            request = ModelRequest(
+                provider=ProviderType.AZURE,
+                invoke_type=InvokeType.CHAT_COMPLETIONS,
+                model="gpt-4o-mini",
+                messages=initial_messages,
+                tools=[
+                    {
+                        "type": "function",
+                        "name": "get_weather",
+                        "description": "获取天气信息",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "location": {"type": "string", "description": "城市名称"}
+                            },
+                            "required": ["location"]
+                        },
+                        "strict": None
+                    }
+                ],
+                tool_choice="auto",
+                user_context=UserContext(
+                    user_id="async_test_user",
+                    org_id="test_org",
+                    client_type="async_tool_test"
+                )
+            )
+            
+            # 发送初始请求
+            response = await client.invoke(request)
+            
+            print(f"   步骤 1: 初始请求完成")
+            print(f"   是否需要工具调用: {response.has_tool_calls()}")
+            
+            if response.has_tool_calls():
+                # 2. 执行工具函数
+                tool_responses = []
+                for tool_call in response.tool_calls:
+                    function_name = tool_call["function"]["name"]
+                    args = ToolCallHelper.parse_function_arguments(tool_call)
+                    
+                    # 根据函数名调用对应的工具函数
+                    if function_name == "get_weather":
+                        weather_result = get_weather(args['location'])
+                    else:
+                        weather_result = f"未知函数: {function_name}"
+                    
+                    tool_response = ToolCallHelper.create_tool_response_message(
+                        tool_call["id"],
+                        weather_result,
+                        function_name
+                    )
+                    tool_responses.append(tool_response)
+                
+                # 3. 构建包含工具响应的新消息列表
+                new_messages = ToolCallHelper.build_messages_with_tool_response(
+                    initial_messages,
+                    response,
+                    tool_responses
+                )
+                
+                # 4. 发送包含工具响应的后续请求
+                follow_up_request = ModelRequest(
+                    provider=ProviderType.AZURE,
+                    invoke_type=InvokeType.CHAT_COMPLETIONS,
+                    model="gpt-4o-mini",
+                    messages=new_messages,
+                    user_context=UserContext(
+                        user_id="async_test_user",
+                        org_id="test_org",
+                        client_type="async_tool_test"
+                    )
+                )
+                
+                final_response = await client.invoke(follow_up_request)
+                
+                print(f"   步骤 2: 工具调用模拟完成")
+                print(f"   步骤 3: 最终回复生成完成")
+                print(f"   最终回复: {final_response.content[:100]}...")
+                
+                print(f"✅ 异步工具调用工作流程测试成功")
+            else:
+                print(f"   模型没有请求工具调用，直接回复: {response.content}")
+                
+    except Exception as e:
+        print(f"❌ 异步工具调用工作流程测试失败: {str(e)}")
+
+
+async def main():
+    """主函数"""
+    print("🚀 Tool Call Enhancement 功能测试")
+    print("=" * 50)
+    
+    try:
+        # 单元测试
+        print("\n📋 运行单元测试...")
+        test_model_response_enhancement()
+        test_tool_call_helper()
+        test_response_handler_enhancement()
+        print("\n✅ 所有单元测试通过")
+        
+        # 真实场景测试
+        print("\n🌐 运行真实场景测试...")
+        test_openai_tool_call()
+        test_google_tool_call()
+        await test_async_tool_call_workflow()
+        
+        print("\n✅ 所有测试完成")
+        
+    except KeyboardInterrupt:
+        print("\n⚠️ 测试被用户中断")
+    except Exception as e:
+        print(f"\n❌ 测试执行出错: {e}")
+    finally:
+        print("🏁 测试程序已退出")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())