tamar-model-client 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

tamar_model_client/async_client.py

@@ -4,6 +4,8 @@ import base64
 import json
 import logging
 import os
+import uuid
+from contextvars import ContextVar
 
 import grpc
 from typing import Optional, AsyncIterator, Union, Iterable
@@ -13,21 +15,44 @@ from pydantic import BaseModel
 
 from .auth import JWTAuthHandler
 from .enums import ProviderType, InvokeType
-from .exceptions import ConnectionError, ValidationError
+from .exceptions import ConnectionError
 from .schemas import ModelRequest, ModelResponse, BatchModelRequest, BatchModelResponse
 from .generated import model_service_pb2, model_service_pb2_grpc
 from .schemas.inputs import GoogleGenAiInput, OpenAIResponsesInput, OpenAIChatCompletionsInput, \
     GoogleVertexAIImagesInput, OpenAIImagesInput
 
-if not logging.getLogger().hasHandlers():
-    # 配置日志格式
-    logging.basicConfig(
-        level=logging.INFO,
-        format="%(asctime)s [%(levelname)s] %(message)s",
-    )
-
 logger = logging.getLogger(__name__)
 
+# 使用 contextvars 管理请求ID
+_request_id: ContextVar[str] = ContextVar('request_id', default='-')
+
+
+class RequestIdFilter(logging.Filter):
+    """自定义日志过滤器，向日志中添加 request_id"""
+
+    def filter(self, record):
+        # 从 ContextVar 中获取当前的 request_id
+        record.request_id = _request_id.get()
+        return True
+
+
+if not logger.hasHandlers():
+    # 创建日志处理器，输出到控制台
+    console_handler = logging.StreamHandler()
+
+    # 设置日志格式
+    formatter = logging.Formatter('%(asctime)s [%(levelname)s] [%(request_id)s] %(message)s')
+    console_handler.setFormatter(formatter)
+
+    # 为当前记录器添加处理器
+    logger.addHandler(console_handler)
+
+    # 设置日志级别
+    logger.setLevel(logging.INFO)
+
+    # 将自定义的 RequestIdFilter 添加到 logger 中
+    logger.addFilter(RequestIdFilter())
+
 MAX_MESSAGE_LENGTH = 2 ** 31 - 1  # 对于32位系统
 
 
@@ -97,6 +122,16 @@ def remove_none_from_dict(data: Any) -> Any:
         return data
 
 
+def generate_request_id():
+    """生成一个唯一的request_id"""
+    return str(uuid.uuid4())
+
+
+def set_request_id(request_id: str):
+    """设置当前请求的 request_id"""
+    _request_id.set(request_id)
+
+
 class AsyncTamarModelClient:
     def __init__(
             self,
@@ -105,8 +140,8 @@ class AsyncTamarModelClient:
             jwt_token: Optional[str] = None,
             default_payload: Optional[dict] = None,
             token_expires_in: int = 3600,
-            max_retries: int = 3,  # 最大重试次数
-            retry_delay: float = 1.0,  # 初始重试延迟（秒）
+            max_retries: Optional[int] = None,  # 最大重试次数
+            retry_delay: Optional[float] = None,  # 初始重试延迟（秒）
     ):
         # 服务端地址
         self.server_address = server_address or os.getenv("MODEL_MANAGER_SERVER_ADDRESS")
@@ -137,12 +172,76 @@ class AsyncTamarModelClient:
         self._closed = False
         atexit.register(self._safe_sync_close)  # 注册进程退出自动关闭
 
-    def _build_auth_metadata(self) -> list:
+    async def _retry_request(self, func, *args, **kwargs):
+        retry_count = 0
+        while retry_count < self.max_retries:
+            try:
+                return await func(*args, **kwargs)
+            except (grpc.aio.AioRpcError, grpc.RpcError) as e:
+                # 对于取消的情况进行指数退避重试
+                if isinstance(e, grpc.aio.AioRpcError) and e.code() == grpc.StatusCode.CANCELLED:
+                    retry_count += 1
+                    logger.warning(f"❌ RPC cancelled, retrying {retry_count}/{self.max_retries}...")
+                    if retry_count < self.max_retries:
+                        delay = self.retry_delay * (2 ** (retry_count - 1))
+                        await asyncio.sleep(delay)
+                    else:
+                        logger.error("❌ Max retry reached for CANCELLED")
+                        raise
+                # 针对其他 RPC 错误类型，如暂时的连接问题、服务器超时等
+                elif isinstance(e, grpc.RpcError) and e.code() in {grpc.StatusCode.UNAVAILABLE,
+                                                                   grpc.StatusCode.DEADLINE_EXCEEDED}:
+                    retry_count += 1
+                    logger.warning(f"❌ gRPC error {e.code()}, retrying {retry_count}/{self.max_retries}...")
+                    if retry_count < self.max_retries:
+                        delay = self.retry_delay * (2 ** (retry_count - 1))
+                        await asyncio.sleep(delay)
+                    else:
+                        logger.error(f"❌ Max retry reached for {e.code()}")
+                        raise
+                else:
+                    logger.error(f"❌ Non-retryable gRPC error: {e}", exc_info=True)
+                    raise
+
+    async def _retry_request_stream(self, func, *args, **kwargs):
+        retry_count = 0
+        while retry_count < self.max_retries:
+            try:
+                return func(*args, **kwargs)
+            except (grpc.aio.AioRpcError, grpc.RpcError) as e:
+                # 对于取消的情况进行指数退避重试
+                if isinstance(e, grpc.aio.AioRpcError) and e.code() == grpc.StatusCode.CANCELLED:
+                    retry_count += 1
+                    logger.warning(f"❌ RPC cancelled, retrying {retry_count}/{self.max_retries}...")
+                    if retry_count < self.max_retries:
+                        delay = self.retry_delay * (2 ** (retry_count - 1))
+                        await asyncio.sleep(delay)
+                    else:
+                        logger.error("❌ Max retry reached for CANCELLED")
+                        raise
+                # 针对其他 RPC 错误类型，如暂时的连接问题、服务器超时等
+                elif isinstance(e, grpc.RpcError) and e.code() in {grpc.StatusCode.UNAVAILABLE,
+                                                                   grpc.StatusCode.DEADLINE_EXCEEDED}:
+                    retry_count += 1
+                    logger.warning(f"❌ gRPC error {e.code()}, retrying {retry_count}/{self.max_retries}...")
+                    if retry_count < self.max_retries:
+                        delay = self.retry_delay * (2 ** (retry_count - 1))
+                        await asyncio.sleep(delay)
+                    else:
+                        logger.error(f"❌ Max retry reached for {e.code()}")
+                        raise
+                else:
+                    logger.error(f"❌ Non-retryable gRPC error: {e}", exc_info=True)
+                    raise
+
+    def _build_auth_metadata(self, request_id: str) -> list:
         # if not self.jwt_token and self.jwt_handler:
         # 更改为每次请求都生成一次token
+        metadata = [("x-request-id", request_id)]  # 将 request_id 添加到 headers
         if self.jwt_handler:
             self.jwt_token = self.jwt_handler.encode_token(self.default_payload, expires_in=self.token_expires_in)
-        return [("authorization", f"Bearer {self.jwt_token}")] if self.jwt_token else []
+            metadata.append(("authorization", f"Bearer {self.jwt_token}"))
+        return metadata
 
     async def _ensure_initialized(self):
         """初始化 gRPC 通道，支持 TLS 与重试机制"""
@@ -195,23 +294,36 @@ class AsyncTamarModelClient:
             logger.info(f"🚀 Retrying connection (attempt {retry_count}/{self.max_retries}) after {delay:.2f}s delay...")
             await asyncio.sleep(delay)
 
-    async def _stream(self, model_request, metadata, invoke_timeout) -> AsyncIterator[ModelResponse]:
-        async for response in self.stub.Invoke(model_request, metadata=metadata, timeout=invoke_timeout):
+    async def _stream(self, request, metadata, invoke_timeout) -> AsyncIterator[ModelResponse]:
+        async for response in self.stub.Invoke(request, metadata=metadata, timeout=invoke_timeout):
             yield ModelResponse(
                 content=response.content,
                 usage=json.loads(response.usage) if response.usage else None,
+                error=response.error or None,
                 raw_response=json.loads(response.raw_response) if response.raw_response else None,
+                request_id=response.request_id if response.request_id else None,
+            )
+
+    async def _invoke_request(self, request, metadata, invoke_timeout):
+        async for response in self.stub.Invoke(request, metadata=metadata, timeout=invoke_timeout):
+            return ModelResponse(
+                content=response.content,
+                usage=json.loads(response.usage) if response.usage else None,
                 error=response.error or None,
+                raw_response=json.loads(response.raw_response) if response.raw_response else None,
+                request_id=response.request_id if response.request_id else None,
             )
 
-    async def invoke(self, model_request: ModelRequest, timeout: Optional[float] = None) -> Union[
+    async def invoke(self, model_request: ModelRequest, timeout: Optional[float] = None,
+                     request_id: Optional[str] = None) -> Union[
         ModelResponse, AsyncIterator[ModelResponse]]:
         """
        通用调用模型方法。
 
         Args:
             model_request: ModelRequest 对象，包含请求参数。
-
+            timeout: Optional[float]
+            request_id: Optional[str]
         Yields:
             ModelResponse: 支持流式或非流式的模型响应
 
@@ -227,6 +339,15 @@ class AsyncTamarModelClient:
                 "user_id": model_request.user_context.user_id or ""
             }
 
+        if not request_id:
+            request_id = generate_request_id()  # 生成一个新的 request_id
+        set_request_id(request_id)  # 设置当前请求的 request_id
+        metadata = self._build_auth_metadata(request_id)  # 将 request_id 加入到请求头
+
+        # 记录开始日志
+        logger.info(
+            f"🔵 Request Start | request_id: {request_id} | provider: {model_request.provider} | invoke_type: {model_request.invoke_type} | model_request: {model_request}")
+
         # 动态根据 provider/invoke_type 决定使用哪个 input 字段
         try:
             # 选择需要校验的字段集合
@@ -278,22 +399,12 @@ class AsyncTamarModelClient:
         except Exception as e:
             raise ValueError(f"构建请求失败: {str(e)}") from e
 
-        metadata = self._build_auth_metadata()
-
         try:
             invoke_timeout = timeout or self.default_invoke_timeout
             if model_request.stream:
-                return self._stream(request, metadata, invoke_timeout)
+                return await self._retry_request_stream(self._stream, request, metadata, invoke_timeout)
             else:
-                async for response in self.stub.Invoke(request, metadata=metadata, timeout=invoke_timeout):
-                    return ModelResponse(
-                        content=response.content,
-                        usage=json.loads(response.usage) if response.usage else None,
-                        raw_response=json.loads(response.raw_response) if response.raw_response else None,
-                        error=response.error or None,
-                        custom_id=None,
-                        request_id=response.request_id if response.request_id else None,
-                    )
+                return await self._retry_request(self._invoke_request, request, metadata, invoke_timeout)
         except grpc.RpcError as e:
             error_message = f"❌ Invoke gRPC failed: {str(e)}"
             logger.error(error_message, exc_info=True)
@@ -303,7 +414,8 @@ class AsyncTamarModelClient:
             logger.error(error_message, exc_info=True)
             raise e
 
-    async def invoke_batch(self, batch_request_model: BatchModelRequest, timeout: Optional[float] = None) -> \
+    async def invoke_batch(self, batch_request_model: BatchModelRequest, timeout: Optional[float] = None,
+                           request_id: Optional[str] = None) -> \
             BatchModelResponse:
         """
         批量模型调用接口
@@ -311,10 +423,11 @@ class AsyncTamarModelClient:
         Args:
             batch_request_model: 多条 BatchModelRequest 输入
             timeout: 调用超时，单位秒
-
+            request_id: 请求id
         Returns:
             BatchModelResponse: 批量请求的结果
         """
+
         await self._ensure_initialized()
 
         if not self.default_payload:
@@ -323,7 +436,14 @@ class AsyncTamarModelClient:
                 "user_id": batch_request_model.user_context.user_id or ""
             }
 
-        metadata = self._build_auth_metadata()
+        if not request_id:
+            request_id = generate_request_id()  # 生成一个新的 request_id
+        set_request_id(request_id)  # 设置当前请求的 request_id
+        metadata = self._build_auth_metadata(request_id)  # 将 request_id 加入到请求头
+
+        # 记录开始日志
+        logger.info(
+            f"🔵 Batch Request Start | request_id: {request_id} | batch_size: {len(batch_request_model.items)} | batch_request_model: {batch_request_model}")
 
         # 构造批量请求
         items = []
@@ -384,11 +504,8 @@ class AsyncTamarModelClient:
             invoke_timeout = timeout or self.default_invoke_timeout
 
             # 调用 gRPC 接口
-            response = await self.stub.BatchInvoke(
-                model_service_pb2.ModelRequest(items=items),
-                timeout=invoke_timeout,
-                metadata=metadata
-            )
+            response = await self._retry_request(self.stub.BatchInvoke, model_service_pb2.ModelRequest(items=items),
+                                                 timeout=invoke_timeout, metadata=metadata)
 
             result = []
             for res_item in response.items:
@@ -417,7 +534,6 @@ class AsyncTamarModelClient:
         if self.channel and not self._closed:
             await self.channel.close()
             self._closed = True
-            await self.channel.close()
             logger.info("✅ gRPC channel closed")
 
     def _safe_sync_close(self):

tamar_model_client/sync_client.py

@@ -1,21 +1,135 @@
-import asyncio
-import atexit
+import base64
+import json
 import logging
-from typing import Optional, Union, Iterator
+import os
+import time
+import uuid
+import grpc
+from typing import Optional, Union, Iterable, Iterator
+from contextvars import ContextVar
 
-from .async_client import AsyncTamarModelClient
-from .schemas import ModelRequest, BatchModelRequest, ModelResponse, BatchModelResponse
+from openai import NOT_GIVEN
+from pydantic import BaseModel
+
+from .auth import JWTAuthHandler
+from .enums import ProviderType, InvokeType
+from .exceptions import ConnectionError
+from .generated import model_service_pb2, model_service_pb2_grpc
+from .schemas import BatchModelResponse, ModelResponse
+from .schemas.inputs import GoogleGenAiInput, GoogleVertexAIImagesInput, OpenAIResponsesInput, \
+    OpenAIChatCompletionsInput, OpenAIImagesInput, BatchModelRequest, ModelRequest
 
 logger = logging.getLogger(__name__)
 
+_request_id: ContextVar[str] = ContextVar('request_id', default='-')
 
-class TamarModelClient:
+
+class RequestIdFilter(logging.Filter):
+    """自定义日志过滤器，向日志中添加 request_id"""
+
+    def filter(self, record):
+        # 从 ContextVar 中获取当前的 request_id
+        record.request_id = _request_id.get()
+        return True
+
+
+if not logger.hasHandlers():
+    # 创建日志处理器，输出到控制台
+    console_handler = logging.StreamHandler()
+
+    # 设置日志格式
+    formatter = logging.Formatter('%(asctime)s [%(levelname)s] [%(request_id)s] %(message)s')
+    console_handler.setFormatter(formatter)
+
+    # 为当前记录器添加处理器
+    logger.addHandler(console_handler)
+
+    # 设置日志级别
+    logger.setLevel(logging.INFO)
+
+    # 将自定义的 RequestIdFilter 添加到 logger 中
+    logger.addFilter(RequestIdFilter())
+
+MAX_MESSAGE_LENGTH = 2 ** 31 - 1  # 对于32位系统
+
+
+def is_effective_value(value) -> bool:
     """
-    同步版本的模型管理客户端，用于非异步环境（如 Flask、Django、脚本）。
-    内部封装 AsyncTamarModelClient 并处理事件循环兼容性。
+    递归判断value是否是有意义的有效值
     """
-    _loop: Optional[asyncio.AbstractEventLoop] = None
+    if value is None or value is NOT_GIVEN:
+        return False
+
+    if isinstance(value, str):
+        return value.strip() != ""
+
+    if isinstance(value, bytes):
+        return len(value) > 0
+
+    if isinstance(value, dict):
+        for v in value.values():
+            if is_effective_value(v):
+                return True
+        return False
+
+    if isinstance(value, list):
+        for item in value:
+            if is_effective_value(item):
+                return True
+        return False
+
+    return True  # 其他类型（int/float/bool）只要不是None就算有效
+
+
+def serialize_value(value):
+    """递归处理单个值，处理BaseModel, dict, list, bytes"""
+    if not is_effective_value(value):
+        return None
+    if isinstance(value, BaseModel):
+        return serialize_value(value.model_dump())
+    if hasattr(value, "dict") and callable(value.dict):
+        return serialize_value(value.dict())
+    if isinstance(value, dict):
+        return {k: serialize_value(v) for k, v in value.items()}
+    if isinstance(value, list) or (isinstance(value, Iterable) and not isinstance(value, (str, bytes))):
+        return [serialize_value(v) for v in value]
+    if isinstance(value, bytes):
+        return f"bytes:{base64.b64encode(value).decode('utf-8')}"
+    return value
+
+
+from typing import Any
 
+
+def remove_none_from_dict(data: Any) -> Any:
+    """
+    遍历 dict/list，递归删除 value 为 None 的字段
+    """
+    if isinstance(data, dict):
+        new_dict = {}
+        for key, value in data.items():
+            if value is None:
+                continue
+            cleaned_value = remove_none_from_dict(value)
+            new_dict[key] = cleaned_value
+        return new_dict
+    elif isinstance(data, list):
+        return [remove_none_from_dict(item) for item in data]
+    else:
+        return data
+
+
+def generate_request_id():
+    """生成一个唯一的request_id"""
+    return str(uuid.uuid4())
+
+
+def set_request_id(request_id: str):
+    """设置当前请求的 request_id"""
+    _request_id.set(request_id)
+
+
+class TamarModelClient:
     def __init__(
             self,
             server_address: Optional[str] = None,
@@ -23,89 +137,370 @@ class TamarModelClient:
             jwt_token: Optional[str] = None,
             default_payload: Optional[dict] = None,
             token_expires_in: int = 3600,
-            max_retries: int = 3,
-            retry_delay: float = 1.0,
+            max_retries: Optional[int] = None,  # 最大重试次数
+            retry_delay: Optional[float] = None,  # 初始重试延迟（秒）
     ):
-        # 初始化全局事件循环，仅创建一次
-        if not TamarModelClient._loop:
+        self.server_address = server_address or os.getenv("MODEL_MANAGER_SERVER_ADDRESS")
+        if not self.server_address:
+            raise ValueError("Server address must be provided via argument or environment variable.")
+        self.default_invoke_timeout = float(os.getenv("MODEL_MANAGER_SERVER_INVOKE_TIMEOUT", 30.0))
+
+        # JWT 配置
+        self.jwt_secret_key = jwt_secret_key or os.getenv("MODEL_MANAGER_SERVER_JWT_SECRET_KEY")
+        self.jwt_handler = JWTAuthHandler(self.jwt_secret_key)
+        self.jwt_token = jwt_token  # 用户传入的 Token（可选）
+        self.default_payload = default_payload
+        self.token_expires_in = token_expires_in
+
+        # === TLS/Authority 配置 ===
+        self.use_tls = os.getenv("MODEL_MANAGER_SERVER_GRPC_USE_TLS", "true").lower() == "true"
+        self.default_authority = os.getenv("MODEL_MANAGER_SERVER_GRPC_DEFAULT_AUTHORITY")
+
+        # === 重试配置 ===
+        self.max_retries = max_retries if max_retries is not None else int(
+            os.getenv("MODEL_MANAGER_SERVER_GRPC_MAX_RETRIES", 3))
+        self.retry_delay = retry_delay if retry_delay is not None else float(
+            os.getenv("MODEL_MANAGER_SERVER_GRPC_RETRY_DELAY", 1.0))
+
+        # === gRPC 通道相关 ===
+        self.channel: Optional[grpc.Channel] = None
+        self.stub: Optional[model_service_pb2_grpc.ModelServiceStub] = None
+        self._closed = False
+
+    def _retry_request(self, func, *args, **kwargs):
+        retry_count = 0
+        while retry_count < self.max_retries:
             try:
-                TamarModelClient._loop = asyncio.get_running_loop()
-            except RuntimeError:
-                TamarModelClient._loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(TamarModelClient._loop)
-
-        self._loop = TamarModelClient._loop
-
-        self._async_client = AsyncTamarModelClient(
-            server_address=server_address,
-            jwt_secret_key=jwt_secret_key,
-            jwt_token=jwt_token,
-            default_payload=default_payload,
-            token_expires_in=token_expires_in,
-            max_retries=max_retries,
-            retry_delay=retry_delay,
-        )
-        atexit.register(self._safe_sync_close)
-
-    def invoke(self, model_request: ModelRequest, timeout: Optional[float] = None) -> Union[
-        ModelResponse, Iterator[ModelResponse]]:
-        """
-        同步调用单个模型任务
-        """
-        if model_request.stream:
-            async def stream():
-                async for r in await self._async_client.invoke(model_request, timeout=timeout):
-                    yield r
+                return func(*args, **kwargs)
+            except (grpc.RpcError) as e:
+                if e.code() in {grpc.StatusCode.UNAVAILABLE, grpc.StatusCode.DEADLINE_EXCEEDED}:
+                    retry_count += 1
+                    logger.error(f"❌ gRPC error {e.code()}, retrying {retry_count}/{self.max_retries}...")
+                    if retry_count < self.max_retries:
+                        delay = self.retry_delay * (2 ** (retry_count - 1))
+                        time.sleep(delay)
+                    else:
+                        logger.error(f"❌ Max retry reached for {e.code()}")
+                        raise
+                else:
+                    logger.error(f"❌ Non-retryable gRPC error: {e}", exc_info=True)
+                    raise
+
+    def _build_auth_metadata(self, request_id: str) -> list:
+        metadata = [("x-request-id", request_id)]  # 将 request_id 添加到 headers
+        if self.jwt_handler:
+            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}"))
+        return metadata
+
+    def _ensure_initialized(self):
+        """初始化 gRPC 通道，支持 TLS 与重试机制"""
+        if self.channel and self.stub:
+            return
+
+        retry_count = 0
+        options = [
+            ('grpc.max_send_message_length', MAX_MESSAGE_LENGTH),
+            ('grpc.max_receive_message_length', MAX_MESSAGE_LENGTH),
+            ('grpc.keepalive_permit_without_calls', True)  # 即使没有活跃请求也保持连接
+        ]
+        if self.default_authority:
+            options.append(("grpc.default_authority", self.default_authority))
+
+        while retry_count <= self.max_retries:
+            try:
+                if self.use_tls:
+                    credentials = grpc.ssl_channel_credentials()
+                    self.channel = grpc.secure_channel(
+                        self.server_address,
+                        credentials,
+                        options=options
+                    )
+                    logger.info("🔐 Using secure gRPC channel (TLS enabled)")
+                else:
+                    self.channel = grpc.insecure_channel(
+                        self.server_address,
+                        options=options
+                    )
+                    logger.info("🔓 Using insecure gRPC channel (TLS disabled)")
+
+                # Wait for the channel to be ready (synchronously)
+                grpc.channel_ready_future(self.channel).result()  # This is blocking in sync mode
+
+                self.stub = model_service_pb2_grpc.ModelServiceStub(self.channel)
+                logger.info(f"✅ gRPC channel initialized to {self.server_address}")
+                return
+            except grpc.FutureTimeoutError as e:
+                logger.error(f"❌ gRPC channel initialization timed out: {str(e)}", exc_info=True)
+            except grpc.RpcError as e:
+                logger.error(f"❌ gRPC channel initialization failed: {str(e)}", exc_info=True)
+            except Exception as e:
+                logger.error(f"❌ Unexpected error during channel initialization: {str(e)}", exc_info=True)
+
+            retry_count += 1
+            if retry_count > self.max_retries:
+                logger.error(f"❌ Failed to initialize gRPC channel after {self.max_retries} retries.", exc_info=True)
+                raise ConnectionError(f"❌ Failed to initialize gRPC channel after {self.max_retries} retries.")
+
+            # 指数退避：延迟时间 = retry_delay * (2 ^ (retry_count - 1))
+            delay = self.retry_delay * (2 ** (retry_count - 1))
+            logger.info(f"🚀 Retrying connection (attempt {retry_count}/{self.max_retries}) after {delay:.2f}s delay...")
+            time.sleep(delay)  # Blocking sleep in sync version
+
+    def _stream(self, request, metadata, invoke_timeout) -> Iterator[ModelResponse]:
+        for response in self.stub.Invoke(request, metadata=metadata, timeout=invoke_timeout):
+            yield ModelResponse(
+                content=response.content,
+                usage=json.loads(response.usage) if response.usage else None,
+                error=response.error or None,
+                raw_response=json.loads(response.raw_response) if response.raw_response else None,
+                request_id=response.request_id if response.request_id else None,
+            )
 
-            return self._sync_wrap_async_generator(stream())
-        return self._run_async(self._async_client.invoke(model_request, timeout=timeout))
+    def _invoke_request(self, request, metadata, invoke_timeout):
+        response = self.stub.Invoke(request, metadata=metadata, timeout=invoke_timeout)
+        for response in response:
+            return ModelResponse(
+                content=response.content,
+                usage=json.loads(response.usage) if response.usage else None,
+                error=response.error or None,
+                raw_response=json.loads(response.raw_response) if response.raw_response else None,
+                request_id=response.request_id if response.request_id else None,
+            )
 
-    def invoke_batch(self, batch_model_request: BatchModelRequest,
-                     timeout: Optional[float] = None) -> BatchModelResponse:
+    def invoke(self, model_request: ModelRequest, timeout: Optional[float] = None, request_id: Optional[str] = None) -> \
+            Union[ModelResponse, Iterator[ModelResponse]]:
         """
-        同步调用批量模型任务
+       通用调用模型方法。
+
+        Args:
+            model_request: ModelRequest 对象，包含请求参数。
+            timeout: Optional[float]
+            request_id: Optional[str]
+        Yields:
+            ModelResponse: 支持流式或非流式的模型响应
+
+        Raises:
+            ValidationError: 输入验证失败。
+            ConnectionError: 连接服务端失败。
         """
-        return self._run_async(self._async_client.invoke_batch(batch_model_request, timeout=timeout))
+        self._ensure_initialized()
 
-    def close(self):
-        """手动关闭 gRPC 通道"""
-        self._run_async(self._async_client.close())
+        if not self.default_payload:
+            self.default_payload = {
+                "org_id": model_request.user_context.org_id or "",
+                "user_id": model_request.user_context.user_id or ""
+            }
 
-    def _safe_sync_close(self):
-        """退出时自动关闭"""
+        if not request_id:
+            request_id = generate_request_id()  # 生成一个新的 request_id
+        set_request_id(request_id)  # 设置当前请求的 request_id
+        metadata = self._build_auth_metadata(request_id)  # 将 request_id 加入到请求头
+
+        # 记录开始日志
+        logger.info(
+            f"🔵 Request Start | request_id: {request_id} | provider: {model_request.provider} | invoke_type: {model_request.invoke_type} | model_request: {model_request}")
+
+        # 动态根据 provider/invoke_type 决定使用哪个 input 字段
         try:
-            self._run_async(self._async_client.close())
-            logger.info("✅ gRPC channel closed at exit")
+            # 选择需要校验的字段集合
+            # 动态分支逻辑
+            match (model_request.provider, model_request.invoke_type):
+                case (ProviderType.GOOGLE, InvokeType.GENERATION):
+                    allowed_fields = GoogleGenAiInput.model_fields.keys()
+                case (ProviderType.GOOGLE, InvokeType.IMAGE_GENERATION):
+                    allowed_fields = GoogleVertexAIImagesInput.model_fields.keys()
+                case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.RESPONSES | InvokeType.GENERATION):
+                    allowed_fields = OpenAIResponsesInput.model_fields.keys()
+                case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.CHAT_COMPLETIONS):
+                    allowed_fields = OpenAIChatCompletionsInput.model_fields.keys()
+                case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.IMAGE_GENERATION):
+                    allowed_fields = OpenAIImagesInput.model_fields.keys()
+                case _:
+                    raise ValueError(
+                        f"Unsupported provider/invoke_type combination: {model_request.provider} + {model_request.invoke_type}")
+
+            # 将 ModelRequest 转 dict，过滤只保留 base + allowed 的字段
+            model_request_dict = model_request.model_dump(exclude_unset=True)
+
+            grpc_request_kwargs = {}
+            for field in allowed_fields:
+                if field in model_request_dict:
+                    value = model_request_dict[field]
+
+                    # 跳过无效的值
+                    if not is_effective_value(value):
+                        continue
+
+                    # 序列化grpc不支持的类型
+                    grpc_request_kwargs[field] = serialize_value(value)
+
+                    # 清理 serialize后的 grpc_request_kwargs
+                    grpc_request_kwargs = remove_none_from_dict(grpc_request_kwargs)
+
+            request = model_service_pb2.ModelRequestItem(
+                provider=model_request.provider.value,
+                channel=model_request.channel.value,
+                invoke_type=model_request.invoke_type.value,
+                stream=model_request.stream or False,
+                org_id=model_request.user_context.org_id or "",
+                user_id=model_request.user_context.user_id or "",
+                client_type=model_request.user_context.client_type or "",
+                extra=grpc_request_kwargs
+            )
+
         except Exception as e:
-            logger.warning(f"❌ gRPC channel close failed at exit: {e}")
+            raise ValueError(f"构建请求失败: {str(e)}") from e
 
-    def _run_async(self, coro):
-        """统一运行协程，兼容已存在的事件循环"""
         try:
-            loop = asyncio.get_running_loop()
-            import nest_asyncio
-            nest_asyncio.apply()
-            return loop.run_until_complete(coro)
-        except RuntimeError:
-            return self._loop.run_until_complete(coro)
-
-    def _sync_wrap_async_generator(self, async_gen_func):
+            invoke_timeout = timeout or self.default_invoke_timeout
+            if model_request.stream:
+                return self._retry_request(self._stream, request, metadata, invoke_timeout)
+            else:
+                return self._retry_request(self._invoke_request, request, metadata, invoke_timeout)
+        except grpc.RpcError as e:
+            error_message = f"❌ Invoke gRPC failed: {str(e)}"
+            logger.error(error_message, exc_info=True)
+            raise e
+        except Exception as e:
+            error_message = f"❌ Invoke other error: {str(e)}"
+            logger.error(error_message, exc_info=True)
+            raise e
+
+    def invoke_batch(self, batch_request_model: BatchModelRequest, timeout: Optional[float] = None,
+                     request_id: Optional[str] = None) -> BatchModelResponse:
         """
-        将 async generator 转换为同步 generator，逐条 yield。
+        批量模型调用接口
+
+        Args:
+            batch_request_model: 多条 BatchModelRequest 输入
+            timeout: 调用超时，单位秒
+            request_id: 请求id
+        Returns:
+            BatchModelResponse: 批量请求的结果
         """
-        loop = self._loop
 
-        # 创建异步生成器对象
-        agen = async_gen_func
+        self._ensure_initialized()
 
-        class SyncGenerator:
-            def __iter__(self_inner):
-                return self_inner
+        if not self.default_payload:
+            self.default_payload = {
+                "org_id": batch_request_model.user_context.org_id or "",
+                "user_id": batch_request_model.user_context.user_id or ""
+            }
+
+        if not request_id:
+            request_id = generate_request_id()  # 生成一个新的 request_id
+        set_request_id(request_id)  # 设置当前请求的 request_id
+        metadata = self._build_auth_metadata(request_id)  # 将 request_id 加入到请求头
+
+        # 记录开始日志
+        logger.info(
+            f"🔵 Batch Request Start | request_id: {request_id} | batch_size: {len(batch_request_model.items)} | batch_request_model: {batch_request_model}")
+
+        # 构造批量请求
+        items = []
+        for model_request_item in batch_request_model.items:
+            # 动态根据 provider/invoke_type 决定使用哪个 input 字段
+            try:
+                match (model_request_item.provider, model_request_item.invoke_type):
+                    case (ProviderType.GOOGLE, InvokeType.GENERATION):
+                        allowed_fields = GoogleGenAiInput.model_fields.keys()
+                    case (ProviderType.GOOGLE, InvokeType.IMAGE_GENERATION):
+                        allowed_fields = GoogleVertexAIImagesInput.model_fields.keys()
+                    case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.RESPONSES | InvokeType.GENERATION):
+                        allowed_fields = OpenAIResponsesInput.model_fields.keys()
+                    case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.CHAT_COMPLETIONS):
+                        allowed_fields = OpenAIChatCompletionsInput.model_fields.keys()
+                    case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.IMAGE_GENERATION):
+                        allowed_fields = OpenAIImagesInput.model_fields.keys()
+                    case _:
+                        raise ValueError(
+                            f"Unsupported provider/invoke_type combination: {model_request_item.provider} + {model_request_item.invoke_type}")
+
+                # 将 ModelRequest 转 dict，过滤只保留 base + allowed 的字段
+                model_request_dict = model_request_item.model_dump(exclude_unset=True)
+
+                grpc_request_kwargs = {}
+                for field in allowed_fields:
+                    if field in model_request_dict:
+                        value = model_request_dict[field]
+
+                        # 跳过无效的值
+                        if not is_effective_value(value):
+                            continue
+
+                        # 序列化grpc不支持的类型
+                        grpc_request_kwargs[field] = serialize_value(value)
+
+                        # 清理 serialize后的 grpc_request_kwargs
+                        grpc_request_kwargs = remove_none_from_dict(grpc_request_kwargs)
+
+                items.append(model_service_pb2.ModelRequestItem(
+                    provider=model_request_item.provider.value,
+                    channel=model_request_item.channel.value,
+                    invoke_type=model_request_item.invoke_type.value,
+                    stream=model_request_item.stream or False,
+                    custom_id=model_request_item.custom_id or "",
+                    priority=model_request_item.priority or 1,
+                    org_id=batch_request_model.user_context.org_id or "",
+                    user_id=batch_request_model.user_context.user_id or "",
+                    client_type=batch_request_model.user_context.client_type or "",
+                    extra=grpc_request_kwargs,
+                ))
+
+            except Exception as e:
+                raise ValueError(f"构建请求失败: {str(e)}，item={model_request_item.custom_id}") from e
+
+        try:
+            # 超时处理逻辑
+            invoke_timeout = timeout or self.default_invoke_timeout
+
+            # 调用 gRPC 接口
+            response = self._retry_request(self.stub.BatchInvoke, model_service_pb2.ModelRequest(items=items),
+                                           timeout=invoke_timeout, metadata=metadata)
+
+            result = []
+            for res_item in response.items:
+                result.append(ModelResponse(
+                    content=res_item.content,
+                    usage=json.loads(res_item.usage) if res_item.usage else None,
+                    raw_response=json.loads(res_item.raw_response) if res_item.raw_response else None,
+                    error=res_item.error or None,
+                    custom_id=res_item.custom_id if res_item.custom_id else None
+                ))
+            return BatchModelResponse(
+                request_id=response.request_id if response.request_id else None,
+                responses=result
+            )
+        except grpc.RpcError as e:
+            error_message = f"❌ BatchInvoke gRPC failed: {str(e)}"
+            logger.error(error_message, exc_info=True)
+            raise e
+        except Exception as e:
+            error_message = f"❌ BatchInvoke other error: {str(e)}"
+            logger.error(error_message, exc_info=True)
+            raise e
+
+    def close(self):
+        """关闭 gRPC 通道"""
+        if self.channel and not self._closed:
+            self.channel.close()
+            self._closed = True
+            logger.info("✅ gRPC channel closed")
+
+    def _safe_sync_close(self):
+        """进程退出时自动关闭 channel（事件循环处理兼容）"""
+        if self.channel and not self._closed:
+            try:
+                self.close()  # 直接调用关闭方法
+            except Exception as e:
+                logger.error(f"❌ gRPC channel close failed at exit: {e}")
 
-            def __next__(self_inner):
-                try:
-                    return loop.run_until_complete(agen.__anext__())
-                except StopAsyncIteration:
-                    raise StopIteration
+    def __enter__(self):
+        """同步初始化连接"""
+        self._ensure_initialized()
+        return self
 
-        return SyncGenerator()
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """同步关闭连接"""
+        self.close()

{tamar_model_client-0.1.14.dist-info → tamar_model_client-0.1.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tamar-model-client
-Version: 0.1.14
+Version: 0.1.16
 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
@@ -273,13 +273,13 @@ async def main():
     )
 
     # 发送请求并获取响应
-    response = await client.invoke(request_data)
-    if response.error:
-        print(f"错误: {response.error}")
-    else:
-        print(f"响应: {response.content}")
-        if response.usage:
-            print(f"Token 使用情况: {response.usage}")
+    async for r in await client.invoke(model_request):
+        if r.error:
+            print(f"错误: {r.error}")
+        else:
+            print(f"响应: {r.content}")
+            if r.usage:
+                print(f"Token 使用情况: {r.usage}")
 
 
 # 运行异步示例
@@ -531,7 +531,7 @@ python make_grpc.py
 ### 部署到 pip
 ```bash
 python setup.py sdist bdist_wheel
-twine check dist/*
+twine upload dist/*
 
 ```
 

{tamar_model_client-0.1.14.dist-info → tamar_model_client-0.1.16.dist-info}/RECORD

@@ -1,8 +1,8 @@
 tamar_model_client/__init__.py,sha256=LMECAuDARWHV1XzH3msoDXcyurS2eihRQmBy26_PUE0,328
-tamar_model_client/async_client.py,sha256=gmZ2xMHO_F-Vtg3OK7B_yf-gtI-WH2NU2LzC6YO_t7k,19649
+tamar_model_client/async_client.py,sha256=K14GigYdcsHQg83PP1YH3wxxZEUwvFlIFMWdFfegnhc,25655
 tamar_model_client/auth.py,sha256=gbwW5Aakeb49PMbmYvrYlVx1mfyn1LEDJ4qQVs-9DA4,438
 tamar_model_client/exceptions.py,sha256=jYU494OU_NeIa4X393V-Y73mTNm0JZ9yZApnlOM9CJQ,332
-tamar_model_client/sync_client.py,sha256=o8b20fQUvtMq1gWax3_dfOpputYT4l9pRTz6cHdB0lg,4006
+tamar_model_client/sync_client.py,sha256=B4itGuFy1T6g2pnC-95RbaaOqtRIYLeW9eah-CRFRM0,22486
 tamar_model_client/enums/__init__.py,sha256=3cYYn8ztNGBa_pI_5JGRVYf2QX8fkBVWdjID1PLvoBQ,182
 tamar_model_client/enums/channel.py,sha256=wCzX579nNpTtwzGeS6S3Ls0UzVAgsOlfy4fXMzQTCAw,199
 tamar_model_client/enums/invoke.py,sha256=WufImoN_87ZjGyzYitZkhNNFefWJehKfLtyP-DTBYlA,267
@@ -13,7 +13,7 @@ tamar_model_client/generated/model_service_pb2_grpc.py,sha256=k4tIbp3XBxdyuOVR18
 tamar_model_client/schemas/__init__.py,sha256=AxuI-TcvA4OMTj2FtK4wAItvz9LrK_293pu3cmMLE7k,394
 tamar_model_client/schemas/inputs.py,sha256=AlvjTRp_UGnbmqzv4OJ3RjH4UGErzSNfKS8Puj6oEXQ,19088
 tamar_model_client/schemas/outputs.py,sha256=M_fcqUtXPJnfiLabHlyA8BorlC5pYkf5KLjXO1ysKIQ,1031
-tamar_model_client-0.1.14.dist-info/METADATA,sha256=XB9fzmRzMJM2UL8udezQf6PHy103GgtwICGmlFUnn4U,16566
-tamar_model_client-0.1.14.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
-tamar_model_client-0.1.14.dist-info/top_level.txt,sha256=_LfDhPv_fvON0PoZgQuo4M7EjoWtxPRoQOBJziJmip8,19
-tamar_model_client-0.1.14.dist-info/RECORD,,
+tamar_model_client-0.1.16.dist-info/METADATA,sha256=YaPEPgdIVcJVSZ55rzx-G5TtjHTT0teXJspOz5O3vyE,16562
+tamar_model_client-0.1.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tamar_model_client-0.1.16.dist-info/top_level.txt,sha256=_LfDhPv_fvON0PoZgQuo4M7EjoWtxPRoQOBJziJmip8,19
+tamar_model_client-0.1.16.dist-info/RECORD,,

{tamar_model_client-0.1.14.dist-info → tamar_model_client-0.1.16.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.0.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any