tamar-model-client 0.1.28__py3-none-any.whl → 0.2.0__py3-none-any.whl

tamar_model_client/async_client.py

@@ -103,7 +103,6 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
         self.stub: Optional[model_service_pb2_grpc.ModelServiceStub] = None
         self._channel_error_count = 0
         self._last_channel_error_time = None
-        self._channel_lock = asyncio.Lock()  # 异步锁
         
         # === Request ID 管理 ===
         self._request_id_manager = RequestIdManager()
@@ -194,7 +193,7 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
         # 如果 channel 存在但不健康，记录日志
         if self.channel and self.stub:
             logger.warning(
-                "Channel exists but unhealthy, will recreate",
+                "⚠️ Channel exists but unhealthy, will recreate",
                 extra={
                     "log_type": "channel_recreate", 
                     "data": {
@@ -222,7 +221,7 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
                                        "data": {"tls_enabled": True, "server_address": self.server_address}})
                 else:
                     self.channel = grpc.aio.insecure_channel(
-                        self.server_address,
+                        f"dns:///{self.server_address}",
                         options=options
                     )
                     logger.info("🔓 Using insecure gRPC channel (TLS disabled)",
@@ -272,7 +271,7 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
             # 如果处于关闭或失败状态，需要重建
             if state in [grpc.ChannelConnectivity.SHUTDOWN, 
                         grpc.ChannelConnectivity.TRANSIENT_FAILURE]:
-                logger.warning(f"Channel in unhealthy state: {state}",
+                logger.warning(f"⚠️ Channel in unhealthy state: {state}",
                              extra={"log_type": "info", 
                                    "data": {"channel_state": str(state)}})
                 return False
@@ -280,7 +279,7 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
             # 如果最近有多次错误，也需要重建
             if self._channel_error_count > 3 and self._last_channel_error_time:
                 if time.time() - self._last_channel_error_time < 60:  # 60秒内
-                    logger.warning("Too many channel errors recently, marking as unhealthy",
+                    logger.warning("⚠️ Too many channel errors recently, marking as unhealthy",
                                  extra={"log_type": "info",
                                        "data": {"error_count": self._channel_error_count}})
                     return False
@@ -288,7 +287,7 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
             return True
             
         except Exception as e:
-            logger.error(f"Error checking channel health: {e}",
+            logger.error(f"❌ Error checking channel health: {e}",
                         extra={"log_type": "info", 
                               "data": {"error": str(e)}})
             return False
@@ -299,27 +298,26 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
         
         关闭旧的 channel 并创建新的连接
         """
-        async with self._channel_lock:
-            # 关闭旧 channel
-            if self.channel:
-                try:
-                    await self.channel.close()
-                    logger.info("Closed unhealthy channel",
-                              extra={"log_type": "info"})
-                except Exception as e:
-                    logger.warning(f"Error closing channel: {e}",
-                                 extra={"log_type": "info"})
-                    
-            # 清空引用
-            self.channel = None
-            self.stub = None
-            
-            # 重置错误计数
-            self._channel_error_count = 0
-            self._last_channel_error_time = None
-            
-            logger.info("Recreating gRPC channel...",
-                       extra={"log_type": "info"})
+        # 关闭旧 channel
+        if self.channel:
+            try:
+                await self.channel.close()
+                logger.info("🔚 Closed unhealthy channel",
+                          extra={"log_type": "info"})
+            except Exception as e:
+                logger.warning(f"⚠️ Error closing channel: {e}",
+                             extra={"log_type": "info"})
+                
+        # 清空引用
+        self.channel = None
+        self.stub = None
+        
+        # 重置错误计数
+        self._channel_error_count = 0
+        self._last_channel_error_time = None
+        
+        logger.info("🔄 Recreating gRPC channel...",
+                   extra={"log_type": "info"})
     
     def _record_channel_error(self, error: grpc.RpcError):
         """
@@ -346,7 +344,7 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
             
         # 记录详细的错误信息
         logger.warning(
-            f"Channel error recorded: {error.code().name}",
+            f"⚠️ Channel error recorded: {error.code().name}",
             extra={
                 "log_type": "channel_error",
                 "data": {
@@ -457,7 +455,7 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
                             is_network_cancelled = error_context.is_network_cancelled()
                             
                             logger.warning(
-                                f"CANCELLED error in stream, channel state: {channel_state}",
+                                f"⚠️ CANCELLED error in stream, channel state: {channel_state}",
                                 extra={
                                     "log_type": "cancelled_debug",
                                     "request_id": context.get('request_id'),
@@ -485,14 +483,16 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
                         "request_id": context.get('request_id'),
                         "data": {
                             "error_code": e.code().name if e.code() else 'UNKNOWN',
+                            "error_details": e.details() if hasattr(e, 'details') else '',
                             "retry_count": attempt,
                             "max_retries": self.max_retries,
                             "method": "stream"
                         },
                         "duration": current_duration
                     }
+                    error_detail = f" - {e.details()}" if e.details() else ""
                     logger.warning(
-                        f"Stream attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()} (will retry)",
+                        f"🔄 Attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()}{error_detail} (will retry)",
                         extra=log_data
                     )
                     
@@ -507,6 +507,7 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
                         "request_id": context.get('request_id'),
                         "data": {
                             "error_code": e.code().name if e.code() else 'UNKNOWN',
+                            "error_details": e.details() if hasattr(e, 'details') else '',
                             "retry_count": attempt,
                             "max_retries": self.max_retries,
                             "method": "stream",
@@ -514,8 +515,9 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
                         },
                         "duration": current_duration
                     }
-                    logger.error(
-                        f"Stream failed: {e.code()} (no retry)",
+                    error_detail = f" - {e.details()}" if e.details() else ""
+                    logger.warning(
+                        f"⚠️ Attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()}{error_detail} (no more retries)",
                         extra=log_data
                     )
                     context['duration'] = current_duration
@@ -596,7 +598,7 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
             
         return delay
 
-    async def _stream(self, request, metadata, invoke_timeout) -> AsyncIterator[ModelResponse]:
+    async def _stream(self, request, metadata, invoke_timeout, request_id=None, origin_request_id=None) -> AsyncIterator[ModelResponse]:
         """
         处理流式响应
         
@@ -604,8 +606,10 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
         
         Args:
             request: gRPC 请求对象
-            metadata: 请求元数据
+            metadata: 请求元数据（为了兼容性保留，但会被忽略）
             invoke_timeout: 总体超时时间
+            request_id: 请求ID
+            origin_request_id: 原始请求ID
             
         Yields:
             ModelResponse: 流式响应的每个数据块
@@ -613,7 +617,12 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
         Raises:
             TimeoutError: 当等待下一个数据块超时时
         """
-        stream_iter = self.stub.Invoke(request, metadata=metadata, timeout=invoke_timeout).__aiter__()
+        # 每次调用时重新生成metadata，确保JWT token是最新的
+        fresh_metadata = self._build_auth_metadata(
+            request_id or get_request_id(), 
+            origin_request_id
+        )
+        stream_iter = self.stub.Invoke(request, metadata=fresh_metadata, timeout=invoke_timeout).__aiter__()
         chunk_timeout = 30.0  # 单个数据块的超时时间
         
         try:
@@ -634,7 +643,7 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
         except Exception as e:
             raise
 
-    async def _stream_with_logging(self, request, metadata, invoke_timeout, start_time, model_request) -> AsyncIterator[
+    async def _stream_with_logging(self, request, metadata, invoke_timeout, start_time, model_request, request_id=None, origin_request_id=None) -> AsyncIterator[
         ModelResponse]:
         """流式响应的包装器，用于记录完整的响应日志并处理重试"""
         total_content = ""
@@ -643,7 +652,7 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
         chunk_count = 0
 
         # 使用重试逻辑获取流生成器
-        stream_generator = self._retry_request_stream(self._stream, request, metadata, invoke_timeout, request_id=get_request_id())
+        stream_generator = self._retry_request_stream(self._stream, request, metadata, invoke_timeout, request_id=request_id or get_request_id(), origin_request_id=origin_request_id)
 
         try:
             async for response in stream_generator:
@@ -717,9 +726,22 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
             )
             raise
 
-    async def _invoke_request(self, request, metadata, invoke_timeout):
-        """执行单个非流式请求"""
-        async for response in self.stub.Invoke(request, metadata=metadata, timeout=invoke_timeout):
+    async def _invoke_request(self, request, metadata, invoke_timeout, request_id=None, origin_request_id=None):
+        """执行单个非流式请求
+        
+        Args:
+            request: gRPC请求对象
+            metadata: 请求元数据（为了兼容性保留，但会被忽略）
+            invoke_timeout: 请求超时时间
+            request_id: 请求ID
+            origin_request_id: 原始请求ID
+        """
+        # 每次调用时重新生成metadata，确保JWT token是最新的
+        fresh_metadata = self._build_auth_metadata(
+            request_id or get_request_id(), 
+            origin_request_id
+        )
+        async for response in self.stub.Invoke(request, metadata=fresh_metadata, timeout=invoke_timeout):
             return ResponseHandler.build_model_response(response)
 
     async def invoke(self, model_request: ModelRequest, timeout: Optional[float] = None,
@@ -815,13 +837,13 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
             invoke_timeout = timeout or self.default_invoke_timeout
             if model_request.stream:
                 # 对于流式响应，直接返回带日志记录的包装器
-                return self._stream_with_logging(request, metadata, invoke_timeout, start_time, model_request)
+                return self._stream_with_logging(request, metadata, invoke_timeout, start_time, model_request, request_id, origin_request_id)
             else:
                 # 存储model_request和origin_request_id供重试方法使用
                 self._current_model_request = model_request
                 self._current_origin_request_id = origin_request_id
                 try:
-                    result = await self._retry_request(self._invoke_request, request, metadata, invoke_timeout, request_id=request_id)
+                    result = await self._retry_request(self._invoke_request, request, metadata, invoke_timeout, request_id=request_id, origin_request_id=origin_request_id)
                 finally:
                     # 清理临时存储
                     if hasattr(self, '_current_model_request'):
@@ -1033,6 +1055,13 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
                                  "batch_size": len(batch_request_model.items)
                              }
                          })
+            
+            # 记录失败（如果启用了熔断）
+            if self.resilient_enabled and self.circuit_breaker:
+                # 将错误码传递给熔断器，用于智能失败统计
+                error_code = e.code() if hasattr(e, 'code') else None
+                self.circuit_breaker.record_failure(error_code)
+            
             raise e
         except Exception as e:
             duration = time.time() - start_time

tamar_model_client/auth.py

@@ -1,14 +1,43 @@
 import time
 import jwt
+from typing import Optional
 
 
 # JWT 处理类
 class JWTAuthHandler:
     def __init__(self, secret_key: str):
         self.secret_key = secret_key
+        self._token_cache: Optional[str] = None
+        self._token_exp_time: Optional[int] = None
 
     def encode_token(self, payload: dict, expires_in: int = 3600) -> str:
         """生成带过期时间的 JWT Token"""
         payload = payload.copy()
-        payload["exp"] = int(time.time()) + expires_in
-        return jwt.encode(payload, self.secret_key, algorithm="HS256")
+        exp_time = int(time.time()) + expires_in
+        payload["exp"] = exp_time
+        token = jwt.encode(payload, self.secret_key, algorithm="HS256")
+        
+        # 缓存token和过期时间
+        self._token_cache = token
+        self._token_exp_time = exp_time
+        
+        return token
+    
+    def is_token_expiring_soon(self, buffer_seconds: int = 60) -> bool:
+        """检查token是否即将过期
+        
+        Args:
+            buffer_seconds: 提前多少秒认为token即将过期，默认60秒
+            
+        Returns:
+            bool: True表示token即将过期或已过期
+        """
+        if not self._token_exp_time:
+            return True
+        
+        current_time = int(time.time())
+        return current_time >= (self._token_exp_time - buffer_seconds)
+    
+    def get_cached_token(self) -> Optional[str]:
+        """获取缓存的token"""
+        return self._token_cache

tamar_model_client/core/base_client.py

@@ -136,10 +136,7 @@ class BaseClient(ABC):
             ('grpc.resource_quota_size', 1048576000),  # 设置资源配额为1GB
 
             # 启用负载均衡配置
-            ('grpc.lb_policy', 'round_robin'),  # 设置负载均衡策略为 round_robin（轮询）
-
-            # 启用详细的日志记录
-            ('grpc.debug', 1),  # 启用 gRPC 的调试日志，记录更多的连接和请求信息
+            ('grpc.lb_policy_name', 'round_robin'), # 设置负载均衡策略为 round_robin（轮询）
         ]
 
         if self.default_authority:
@@ -168,10 +165,27 @@ class BaseClient(ABC):
             metadata.append(("x-origin-request-id", origin_request_id))
 
         if self.jwt_handler:
-            self.jwt_token = self.jwt_handler.encode_token(
-                self.default_payload,
-                expires_in=self.token_expires_in
-            )
+            # 检查token是否即将过期，如果是则刷新
+            if self.jwt_handler.is_token_expiring_soon():
+                self.jwt_token = self.jwt_handler.encode_token(
+                    self.default_payload,
+                    expires_in=self.token_expires_in
+                )
+            else:
+                # 使用缓存的token
+                cached_token = self.jwt_handler.get_cached_token()
+                if cached_token:
+                    self.jwt_token = cached_token
+                else:
+                    # 如果没有缓存，生成新token
+                    self.jwt_token = self.jwt_handler.encode_token(
+                        self.default_payload,
+                        expires_in=self.token_expires_in
+                    )
+            
+            metadata.append(("authorization", f"Bearer {self.jwt_token}"))
+        elif self.jwt_token:
+            # 使用用户提供的预生成token
             metadata.append(("authorization", f"Bearer {self.jwt_token}"))
 
         return metadata
@@ -240,9 +254,13 @@ class BaseClient(ABC):
 
         return {
             "enabled": self.resilient_enabled,
-            "circuit_state": self.circuit_breaker.get_state(),
-            "failure_count": self.circuit_breaker.failure_count,
-            "last_failure_time": self.circuit_breaker.last_failure_time,
+            "circuit_breaker": {
+                "state": self.circuit_breaker.get_state(),
+                "failure_count": self.circuit_breaker.failure_count,
+                "last_failure_time": self.circuit_breaker.last_failure_time,
+                "failure_threshold": self.circuit_breaker.failure_threshold,
+                "recovery_timeout": self.circuit_breaker.recovery_timeout
+            },
             "http_fallback_url": self.http_fallback_url
         }
 

tamar_model_client/core/http_fallback.py

@@ -15,6 +15,59 @@ from ..schemas import ModelRequest, ModelResponse
 logger = get_protected_logger(__name__)
 
 
+def safe_serialize(obj: Any) -> Any:
+    """
+    安全地序列化对象，避免 Pydantic ValidatorIterator 序列化问题
+    """
+    if obj is None:
+        return None
+    
+    # 处理基本类型
+    if isinstance(obj, (str, int, float, bool)):
+        return obj
+    
+    # 处理列表
+    if isinstance(obj, (list, tuple)):
+        return [safe_serialize(item) for item in obj]
+    
+    # 处理字典
+    if isinstance(obj, dict):
+        return {key: safe_serialize(value) for key, value in obj.items()}
+    
+    # 处理 Pydantic 模型
+    if hasattr(obj, 'model_dump'):
+        try:
+            return obj.model_dump(exclude_unset=True)
+        except Exception:
+            # 如果 model_dump 失败，尝试手动提取字段
+            try:
+                if hasattr(obj, '__dict__'):
+                    return {k: safe_serialize(v) for k, v in obj.__dict__.items() 
+                           if not k.startswith('_') and not callable(v)}
+                elif hasattr(obj, '__slots__'):
+                    return {slot: safe_serialize(getattr(obj, slot, None)) 
+                           for slot in obj.__slots__ if hasattr(obj, slot)}
+            except Exception:
+                pass
+    
+    # 处理 Pydantic v1 模型
+    if hasattr(obj, 'dict'):
+        try:
+            return obj.dict(exclude_unset=True)
+        except Exception:
+            pass
+    
+    # 处理枚举
+    if hasattr(obj, 'value'):
+        return obj.value
+    
+    # 最后的尝试：转换为字符串
+    try:
+        return str(obj)
+    except Exception:
+        return None
+
+
 class HttpFallbackMixin:
     """HTTP fallback functionality for synchronous clients
     
@@ -43,30 +96,37 @@ class HttpFallbackMixin:
     
     def _convert_to_http_format(self, model_request: ModelRequest) -> Dict[str, Any]:
         """Convert ModelRequest to HTTP payload format"""
+        # Use safe serialization to avoid Pydantic ValidatorIterator issues
         payload = {
-            "provider": model_request.provider.value,
-            "model": model_request.model,
-            "user_context": model_request.user_context.model_dump(),
-            "stream": model_request.stream
+            "provider": safe_serialize(model_request.provider),
+            "model": safe_serialize(model_request.model),
+            "user_context": safe_serialize(model_request.user_context),
+            "stream": safe_serialize(model_request.stream)
         }
         
         # Add provider-specific fields
         if hasattr(model_request, 'messages') and model_request.messages:
-            payload['messages'] = model_request.messages
+            payload['messages'] = safe_serialize(model_request.messages)
         if hasattr(model_request, 'contents') and model_request.contents:
-            payload['contents'] = model_request.contents
+            payload['contents'] = safe_serialize(model_request.contents)
         
         # Add optional fields
         if model_request.channel:
-            payload['channel'] = model_request.channel.value
+            payload['channel'] = safe_serialize(model_request.channel)
         if model_request.invoke_type:
-            payload['invoke_type'] = model_request.invoke_type.value
+            payload['invoke_type'] = safe_serialize(model_request.invoke_type)
             
-        # Add extra parameters
+        # Add config parameters safely
+        if hasattr(model_request, 'config') and model_request.config:
+            payload['config'] = safe_serialize(model_request.config)
+        
+        # Add extra parameters safely
         if hasattr(model_request, 'model_extra') and model_request.model_extra:
-            for key, value in model_request.model_extra.items():
-                if key not in payload:
-                    payload[key] = value
+            serialized_extra = safe_serialize(model_request.model_extra)
+            if isinstance(serialized_extra, dict):
+                for key, value in serialized_extra.items():
+                    if key not in payload:
+                        payload[key] = value
                 
         return payload
     
@@ -96,7 +156,7 @@ class HttpFallbackMixin:
                         data = json.loads(data_str)
                         yield ModelResponse(**data)
                     except json.JSONDecodeError:
-                        logger.warning(f"Failed to parse streaming response: {data_str}")
+                        logger.warning(f"⚠️ Failed to parse streaming response: {data_str}")
     
     def _invoke_http_fallback(self, model_request: ModelRequest, 
                              timeout: Optional[float] = None,
@@ -262,14 +322,35 @@ class AsyncHttpFallbackMixin:
     """
     
     async def _ensure_http_client(self) -> None:
-        """Ensure async HTTP client is initialized"""
+        """Ensure async HTTP client is initialized in the correct event loop"""
+        import asyncio
+        import aiohttp
+        
+        # Get current event loop
+        current_loop = asyncio.get_running_loop()
+        
+        # Check if we need to recreate the session
+        need_new_session = False
+        
         if not hasattr(self, '_http_session') or not self._http_session:
-            import aiohttp
+            need_new_session = True
+        elif hasattr(self, '_http_session_loop') and self._http_session_loop != current_loop:
+            # Session was created in a different event loop
+            logger.warning("🔄 HTTP session bound to different event loop, recreating...")
+            # Close old session if possible
+            try:
+                await self._http_session.close()
+            except Exception as e:
+                logger.debug(f"Error closing old session: {e}")
+            need_new_session = True
+            
+        if need_new_session:
             self._http_session = aiohttp.ClientSession(
                 headers={
                     'User-Agent': 'AsyncTamarModelClient/1.0'
                 }
             )
+            self._http_session_loop = current_loop
             
             # Note: JWT token will be set per request in headers
     
@@ -305,7 +386,7 @@ class AsyncHttpFallbackMixin:
                             data = json.loads(data_str)
                             yield ModelResponse(**data)
                         except json.JSONDecodeError:
-                            logger.warning(f"Failed to parse streaming response: {data_str}")
+                            logger.warning(f"⚠️ Failed to parse streaming response: {data_str}")
     
     async def _invoke_http_fallback(self, model_request: ModelRequest,
                                    timeout: Optional[float] = None,
@@ -339,6 +420,7 @@ class AsyncHttpFallbackMixin:
         
         # Convert to HTTP format
         http_payload = self._convert_to_http_format(model_request)
+        print(http_payload)
         
         # Construct URL
         url = f"{self.http_fallback_url}/v1/invoke"
@@ -467,4 +549,6 @@ class AsyncHttpFallbackMixin:
         """Clean up HTTP session"""
         if hasattr(self, '_http_session') and self._http_session:
             await self._http_session.close()
-            self._http_session = None
+            self._http_session = None
+        if hasattr(self, '_http_session_loop'):
+            self._http_session_loop = None

tamar_model_client/error_handler.py

@@ -67,7 +67,7 @@ class GrpcErrorHandler:
             log_data['duration'] = context['duration']
 
         self.logger.error(
-            f"gRPC Error occurred: {error_context.error_code.name if error_context.error_code else 'UNKNOWN'}",
+            f"❌ gRPC Error occurred: {error_context.error_code.name if error_context.error_code else 'UNKNOWN'}",
             extra=log_data
         )
 
@@ -151,14 +151,14 @@ class ErrorRecoveryStrategy:
 
     async def handle_token_refresh(self, error_context: ErrorContext):
         """处理 Token 刷新"""
-        self.client.logger.info("Attempting to refresh JWT token")
+        self.client.logger.info("🔄 Attempting to refresh JWT token")
         # 这里需要客户端实现 _refresh_jwt_token 方法
         if hasattr(self.client, '_refresh_jwt_token'):
             await self.client._refresh_jwt_token()
 
     async def handle_reconnect(self, error_context: ErrorContext):
         """处理重连"""
-        self.client.logger.info("Attempting to reconnect channel")
+        self.client.logger.info("🔄 Attempting to reconnect channel")
         # 这里需要客户端实现 _reconnect_channel 方法
         if hasattr(self.client, '_reconnect_channel'):
             await self.client._reconnect_channel()
@@ -170,7 +170,7 @@ class ErrorRecoveryStrategy:
 
     async def handle_circuit_break(self, error_context: ErrorContext):
         """处理熔断"""
-        self.client.logger.warning("Circuit breaker activated")
+        self.client.logger.warning("⚠️ Circuit breaker activated")
         # 这里可以实现熔断逻辑
         pass
 
@@ -322,8 +322,9 @@ class EnhancedRetryHandler:
                         },
                         "duration": current_duration
                     }
+                    error_detail = f" - {error_context.error_message}" if error_context.error_message else ""
                     logger.warning(
-                        f"Final attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()} (no more retries)",
+                        f"⚠️ Attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()}{error_detail} (no more retries)",
                         extra=log_data
                     )
                     last_exception = self.error_handler.handle_error(e, context)
@@ -346,8 +347,9 @@ class EnhancedRetryHandler:
                     },
                     "duration": current_duration
                 }
+                error_detail = f" - {error_context.error_message}" if error_context.error_message else ""
                 logger.warning(
-                    f"Attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()} (will retry)",
+                    f"🔄 Attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()}{error_detail} (will retry)",
                     extra=log_data
                 )
 

tamar_model_client/json_formatter.py

@@ -57,5 +57,14 @@ class JSONFormatter(logging.Formatter):
         if hasattr(record, "trace"):
             log_data["trace"] = getattr(record, "trace")
         
+        # 添加异常信息（如果有的话）
+        if record.exc_info:
+            import traceback
+            log_data["exception"] = {
+                "type": record.exc_info[0].__name__ if record.exc_info[0] else None,
+                "message": str(record.exc_info[1]) if record.exc_info[1] else None,
+                "traceback": traceback.format_exception(*record.exc_info)
+            }
+        
         # 使用安全的 JSON 编码器
         return json.dumps(log_data, ensure_ascii=False, cls=SafeJSONEncoder)