tamar-model-client 0.1.27__py3-none-any.whl → 0.1.30__py3-none-any.whl

tamar_model_client/core/http_fallback.py

@@ -7,7 +7,7 @@ connections fail, supporting both synchronous and asynchronous clients.
 
 import json
 import logging
-from typing import Optional, Iterator, AsyncIterator, Dict, Any
+from typing import Optional, Iterator, AsyncIterator, Dict, Any, List
 
 from . import generate_request_id, get_protected_logger
 from ..schemas import ModelRequest, ModelResponse
@@ -15,8 +15,70 @@ 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"""
+    """HTTP fallback functionality for synchronous clients
+    
+    This mixin requires the following attributes from the host class:
+    - http_fallback_url: str - The HTTP fallback URL (from BaseClient._init_resilient_features)
+    - jwt_token: Optional[str] - JWT token for authentication (from BaseClient)
+    
+    Usage:
+        This mixin should be used with BaseClient or its subclasses that have
+        initialized the resilient features with _init_resilient_features().
+    """
     
     def _ensure_http_client(self) -> None:
         """Ensure HTTP client is initialized"""
@@ -29,36 +91,42 @@ class HttpFallbackMixin:
             
             # Set default headers
             self._http_client.headers.update({
-                'Content-Type': 'application/json',
                 'User-Agent': 'TamarModelClient/1.0'
             })
     
     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
     
@@ -88,12 +156,17 @@ 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,
-                             request_id: Optional[str] = None) -> Any:
+                             request_id: Optional[str] = None,
+                             origin_request_id: Optional[str] = None) -> Any:
         """HTTP fallback implementation"""
+        # Check if http_fallback_url is available
+        if not hasattr(self, 'http_fallback_url') or not self.http_fallback_url:
+            raise RuntimeError("HTTP fallback URL not configured. Please set MODEL_CLIENT_HTTP_FALLBACK_URL environment variable.")
+        
         self._ensure_http_client()
         
         # Generate request ID if not provided
@@ -104,10 +177,14 @@ class HttpFallbackMixin:
         logger.warning(
             f"🔻 Using HTTP fallback for request",
             extra={
+                "log_type": "info",
                 "request_id": request_id,
-                "provider": model_request.provider.value,
-                "model": model_request.model,
-                "fallback_url": self.http_fallback_url
+                "data": {
+                    "origin_request_id": origin_request_id,
+                    "provider": model_request.provider.value,
+                    "model": model_request.model,
+                    "fallback_url": self.http_fallback_url
+                }
             }
         )
         
@@ -117,8 +194,18 @@ class HttpFallbackMixin:
         # Construct URL
         url = f"{self.http_fallback_url}/v1/invoke"
         
-        # Build headers with authentication
-        headers = {'X-Request-ID': request_id}
+        # Build headers with authentication and request tracking
+        headers = {
+            'X-Request-ID': request_id,
+            'Content-Type': 'application/json',
+            'User-Agent': 'TamarModelClient/1.0'
+        }
+        
+        # Add origin request ID if provided
+        if origin_request_id:
+            headers['X-Origin-Request-ID'] = origin_request_id
+        
+        # Add JWT authentication if available
         if hasattr(self, 'jwt_token') and self.jwt_token:
             headers['Authorization'] = f'Bearer {self.jwt_token}'
         
@@ -138,10 +225,101 @@ class HttpFallbackMixin:
             # Parse response
             data = response.json()
             return ModelResponse(**data)
+    
+    def _invoke_batch_http_fallback(self, batch_request: 'BatchModelRequest',
+                                   timeout: Optional[float] = None,
+                                   request_id: Optional[str] = None,
+                                   origin_request_id: Optional[str] = None) -> List['BatchModelResponse']:
+        """HTTP batch fallback implementation"""
+        # Import here to avoid circular import
+        from ..schemas import BatchModelRequest, BatchModelResponse
+        
+        # Check if http_fallback_url is available
+        if not hasattr(self, 'http_fallback_url') or not self.http_fallback_url:
+            raise RuntimeError("HTTP fallback URL not configured. Please set MODEL_CLIENT_HTTP_FALLBACK_URL environment variable.")
+        
+        self._ensure_http_client()
+        
+        # Generate request ID if not provided
+        if not request_id:
+            request_id = generate_request_id()
+        
+        # Log fallback usage
+        logger.warning(
+            f"🔻 Using HTTP fallback for batch request",
+            extra={
+                "log_type": "info",
+                "request_id": request_id,
+                "data": {
+                    "origin_request_id": origin_request_id,
+                    "batch_size": len(batch_request.items),
+                    "fallback_url": self.http_fallback_url
+                }
+            }
+        )
+        
+        # Convert to HTTP format
+        http_payload = {
+            "user_context": batch_request.user_context.model_dump(),
+            "items": []
+        }
+        
+        # Convert each item
+        for item in batch_request.items:
+            item_payload = self._convert_to_http_format(item)
+            if hasattr(item, 'custom_id') and item.custom_id:
+                item_payload['custom_id'] = item.custom_id
+            if hasattr(item, 'priority') and item.priority is not None:
+                item_payload['priority'] = item.priority
+            http_payload['items'].append(item_payload)
+        
+        # Construct URL
+        url = f"{self.http_fallback_url}/v1/batch-invoke"
+        
+        # Build headers with authentication and request tracking
+        headers = {
+            'X-Request-ID': request_id,
+            'Content-Type': 'application/json',
+            'User-Agent': 'TamarModelClient/1.0'
+        }
+        
+        # Add origin request ID if provided
+        if origin_request_id:
+            headers['X-Origin-Request-ID'] = origin_request_id
+        
+        # Add JWT authentication if available
+        if hasattr(self, 'jwt_token') and self.jwt_token:
+            headers['Authorization'] = f'Bearer {self.jwt_token}'
+        
+        # Send batch request
+        response = self._http_client.post(
+            url,
+            json=http_payload,
+            timeout=timeout or 120,  # Longer timeout for batch requests
+            headers=headers
+        )
+        response.raise_for_status()
+        
+        # Parse response
+        data = response.json()
+        results = []
+        for item_data in data.get('results', []):
+            results.append(BatchModelResponse(**item_data))
+        
+        return results
 
 
 class AsyncHttpFallbackMixin:
-    """HTTP fallback functionality for asynchronous clients"""
+    """HTTP fallback functionality for asynchronous clients
+    
+    This mixin requires the following attributes from the host class:
+    - http_fallback_url: str - The HTTP fallback URL (from BaseClient._init_resilient_features)
+    - jwt_token: Optional[str] - JWT token for authentication (from BaseClient)
+    
+    Usage:
+        This mixin should be used with BaseClient or its subclasses that have
+        initialized the resilient features with _init_resilient_features().
+    """
     
     async def _ensure_http_client(self) -> None:
         """Ensure async HTTP client is initialized"""
@@ -149,7 +327,6 @@ class AsyncHttpFallbackMixin:
             import aiohttp
             self._http_session = aiohttp.ClientSession(
                 headers={
-                    'Content-Type': 'application/json',
                     'User-Agent': 'AsyncTamarModelClient/1.0'
                 }
             )
@@ -188,12 +365,17 @@ 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,
-                                   request_id: Optional[str] = None) -> Any:
+                                   request_id: Optional[str] = None,
+                                   origin_request_id: Optional[str] = None) -> Any:
         """Async HTTP fallback implementation"""
+        # Check if http_fallback_url is available
+        if not hasattr(self, 'http_fallback_url') or not self.http_fallback_url:
+            raise RuntimeError("HTTP fallback URL not configured. Please set MODEL_CLIENT_HTTP_FALLBACK_URL environment variable.")
+        
         await self._ensure_http_client()
         
         # Generate request ID if not provided
@@ -204,21 +386,36 @@ class AsyncHttpFallbackMixin:
         logger.warning(
             f"🔻 Using HTTP fallback for request",
             extra={
+                "log_type": "info",
                 "request_id": request_id,
-                "provider": model_request.provider.value,
-                "model": model_request.model,
-                "fallback_url": self.http_fallback_url
+                "data": {
+                    "origin_request_id": origin_request_id,
+                    "provider": model_request.provider.value,
+                    "model": model_request.model,
+                    "fallback_url": self.http_fallback_url
+                }
             }
         )
         
         # 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"
         
-        # Build headers with authentication
-        headers = {'X-Request-ID': request_id}
+        # Build headers with authentication and request tracking
+        headers = {
+            'X-Request-ID': request_id,
+            'Content-Type': 'application/json',
+            'User-Agent': 'AsyncTamarModelClient/1.0'
+        }
+        
+        # Add origin request ID if provided
+        if origin_request_id:
+            headers['X-Origin-Request-ID'] = origin_request_id
+        
+        # Add JWT authentication if available
         if hasattr(self, 'jwt_token') and self.jwt_token:
             headers['Authorization'] = f'Bearer {self.jwt_token}'
         
@@ -242,6 +439,91 @@ class AsyncHttpFallbackMixin:
                 data = await response.json()
                 return ModelResponse(**data)
     
+    async def _invoke_batch_http_fallback(self, batch_request: 'BatchModelRequest',
+                                         timeout: Optional[float] = None,
+                                         request_id: Optional[str] = None,
+                                         origin_request_id: Optional[str] = None) -> List['BatchModelResponse']:
+        """Async HTTP batch fallback implementation"""
+        # Import here to avoid circular import
+        from ..schemas import BatchModelRequest, BatchModelResponse
+        
+        # Check if http_fallback_url is available
+        if not hasattr(self, 'http_fallback_url') or not self.http_fallback_url:
+            raise RuntimeError("HTTP fallback URL not configured. Please set MODEL_CLIENT_HTTP_FALLBACK_URL environment variable.")
+        
+        await self._ensure_http_client()
+        
+        # Generate request ID if not provided
+        if not request_id:
+            request_id = generate_request_id()
+        
+        # Log fallback usage
+        logger.warning(
+            f"🔻 Using HTTP fallback for batch request",
+            extra={
+                "log_type": "info",
+                "request_id": request_id,
+                "data": {
+                    "origin_request_id": origin_request_id,
+                    "batch_size": len(batch_request.items),
+                    "fallback_url": self.http_fallback_url
+                }
+            }
+        )
+        
+        # Convert to HTTP format
+        http_payload = {
+            "user_context": batch_request.user_context.model_dump(),
+            "items": []
+        }
+        
+        # Convert each item
+        for item in batch_request.items:
+            item_payload = self._convert_to_http_format(item)
+            if hasattr(item, 'custom_id') and item.custom_id:
+                item_payload['custom_id'] = item.custom_id
+            if hasattr(item, 'priority') and item.priority is not None:
+                item_payload['priority'] = item.priority
+            http_payload['items'].append(item_payload)
+        
+        # Construct URL
+        url = f"{self.http_fallback_url}/v1/batch-invoke"
+        
+        # Build headers with authentication and request tracking
+        headers = {
+            'X-Request-ID': request_id,
+            'Content-Type': 'application/json',
+            'User-Agent': 'AsyncTamarModelClient/1.0'
+        }
+        
+        # Add origin request ID if provided
+        if origin_request_id:
+            headers['X-Origin-Request-ID'] = origin_request_id
+        
+        # Add JWT authentication if available
+        if hasattr(self, 'jwt_token') and self.jwt_token:
+            headers['Authorization'] = f'Bearer {self.jwt_token}'
+        
+        # Send batch request
+        import aiohttp
+        timeout_obj = aiohttp.ClientTimeout(total=timeout or 120) if timeout else None
+        
+        async with self._http_session.post(
+            url,
+            json=http_payload,
+            timeout=timeout_obj,
+            headers=headers
+        ) as response:
+            response.raise_for_status()
+            
+            # Parse response
+            data = await response.json()
+            results = []
+            for item_data in data.get('results', []):
+                results.append(BatchModelResponse(**item_data))
+            
+            return results
+    
     async def _cleanup_http_session(self) -> None:
         """Clean up HTTP session"""
         if hasattr(self, '_http_session') and self._http_session:

tamar_model_client/core/logging_setup.py

@@ -10,7 +10,7 @@ import threading
 from typing import Optional, Dict
 
 from ..json_formatter import JSONFormatter
-from .utils import get_request_id
+from .utils import get_request_id, get_origin_request_id
 
 # gRPC 消息长度限制（32位系统兼容）
 MAX_MESSAGE_LENGTH = 2 ** 31 - 1
@@ -45,6 +45,20 @@ class RequestIdFilter(logging.Filter):
         """
         # 从 ContextVar 中获取当前的 request_id
         record.request_id = get_request_id()
+        
+        # 添加 origin_request_id 到 data 字段
+        origin_request_id = get_origin_request_id()
+        if origin_request_id:
+            # 确保 data 字段存在且是字典类型
+            if not hasattr(record, 'data'):
+                record.data = {}
+            elif record.data is None:
+                record.data = {}
+            elif isinstance(record.data, dict):
+                # 只有在 data 是字典且没有 origin_request_id 时才添加
+                if 'origin_request_id' not in record.data:
+                    record.data['origin_request_id'] = origin_request_id
+            
         return True
 
 

tamar_model_client/core/utils.py

@@ -15,6 +15,7 @@ from pydantic import BaseModel
 
 # 使用 contextvars 管理请求ID，支持异步和同步上下文中的请求追踪
 _request_id: ContextVar[str] = ContextVar('request_id', default='-')
+_origin_request_id: ContextVar[str] = ContextVar('origin_request_id', default=None)
 
 
 def is_effective_value(value) -> bool:
@@ -168,4 +169,29 @@ def get_request_id() -> str:
     Returns:
         str: 当前的请求ID或默认值
     """
-    return _request_id.get()
+    return _request_id.get()
+
+
+def set_origin_request_id(origin_request_id: str):
+    """
+    设置当前上下文的原始请求ID
+    
+    在 ContextVar 中设置原始请求ID，使得在整个异步调用链中
+    都能访问到同一个原始请求ID，便于追踪请求来源。
+    
+    Args:
+        origin_request_id: 要设置的原始请求ID字符串
+    """
+    _origin_request_id.set(origin_request_id)
+
+
+def get_origin_request_id() -> str:
+    """
+    获取当前上下文的原始请求ID
+    
+    从 ContextVar 中获取当前的原始请求ID，如果没有设置则返回 None
+    
+    Returns:
+        str: 当前的原始请求ID或 None
+    """
+    return _origin_request_id.get()