tamar-model-client 0.1.8__tar.gz → 0.1.15__tar.gz

{tamar_model_client-0.1.8 → tamar_model_client-0.1.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tamar-model-client
-Version: 0.1.8
+Version: 0.1.15
 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
@@ -11,8 +11,8 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Requires-Dist: grpcio
-Requires-Dist: grpcio-tools
+Requires-Dist: grpcio~=1.67.1
+Requires-Dist: grpcio-tools~=1.67.1
 Requires-Dist: pydantic
 Requires-Dist: PyJWT
 Requires-Dist: nest_asyncio
@@ -528,6 +528,13 @@ pip install -e .
 python make_grpc.py
 ```
 
+### 部署到 pip
+```bash
+python setup.py sdist bdist_wheel
+twine check dist/*
+
+```
+
 ## 许可证
 
 MIT License

{tamar_model_client-0.1.8 → tamar_model_client-0.1.15}/README.md

@@ -498,6 +498,13 @@ pip install -e .
 python make_grpc.py
 ```
 
+### 部署到 pip
+```bash
+python setup.py sdist bdist_wheel
+twine check dist/*
+
+```
+
 ## 许可证
 
 MIT License

{tamar_model_client-0.1.8 → tamar_model_client-0.1.15}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="tamar-model-client",
-    version="0.1.8",
+    version="0.1.15",
     description="A Python SDK for interacting with the Model Manager gRPC service",
     author="Oscar Ou",
     author_email="oscar.ou@tamaredge.ai",
@@ -12,8 +12,8 @@ setup(
         "tamar_model_client": ["generated/*.py"],  # 包含 gRPC 生成文件
     },
     install_requires=[
-        "grpcio",
-        "grpcio-tools",
+        "grpcio~=1.67.1",
+        "grpcio-tools~=1.67.1",
         "pydantic",
         "PyJWT",
         "nest_asyncio",

{tamar_model_client-0.1.8 → tamar_model_client-0.1.15}/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,45 @@ 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
+
+    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 与重试机制"""
@@ -153,6 +221,7 @@ class AsyncTamarModelClient:
         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))
@@ -178,14 +247,15 @@ class AsyncTamarModelClient:
                 logger.info(f"✅ gRPC channel initialized to {self.server_address}")
                 return
             except grpc.FutureTimeoutError as e:
-                logger.warning(f"❌ gRPC channel initialization timed out: {str(e)}")
+                logger.error(f"❌ gRPC channel initialization timed out: {str(e)}", exc_info=True)
             except grpc.RpcError as e:
-                logger.warning(f"❌ gRPC channel initialization failed: {str(e)}")
+                logger.error(f"❌ gRPC channel initialization failed: {str(e)}", exc_info=True)
             except Exception as e:
-                logger.warning(f"❌ Unexpected error during channel initialization: {str(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))
@@ -193,28 +263,38 @@ 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_inner(self, model_request, metadata, invoke_timeout) -> AsyncIterator[ModelResponse]:
+        """Inner function to handle the actual streaming gRPC call."""
+        async for response in self.stub.Invoke(model_request, metadata=metadata, timeout=invoke_timeout):
+            yield 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,
+            )
+
     async def _stream(self, model_request, metadata, invoke_timeout) -> AsyncIterator[ModelResponse]:
-        try:
-            async for response in self.stub.Invoke(model_request, metadata=metadata, timeout=invoke_timeout):
-                yield 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,
-                )
-        except grpc.RpcError as e:
-            raise ConnectionError(f"gRPC call failed: {str(e)}")
-        except Exception as e:
-            raise ValidationError(f"Invalid input: {str(e)}")
+        return await self._retry_request(self._stream_inner, model_request, metadata, invoke_timeout)
+
+    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,
+                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: 支持流式或非流式的模型响应
 
@@ -230,6 +310,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:
             # 选择需要校验的字段集合
@@ -281,23 +370,23 @@ class AsyncTamarModelClient:
         except Exception as e:
             raise ValueError(f"构建请求失败: {str(e)}") from e
 
-        metadata = self._build_auth_metadata()
-
-        invoke_timeout = timeout or self.default_invoke_timeout
-        if model_request.stream:
-            return 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,
-                )
-
-    async def invoke_batch(self, batch_request_model: BatchModelRequest, timeout: Optional[float] = None) -> \
+        try:
+            invoke_timeout = timeout or self.default_invoke_timeout
+            if model_request.stream:
+                return await self._stream(request, metadata, invoke_timeout)
+            else:
+                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)
+            raise e
+        except Exception as e:
+            error_message = f"❌ Invoke other error: {str(e)}"
+            logger.error(error_message, exc_info=True)
+            raise e
+
+    async def invoke_batch(self, batch_request_model: BatchModelRequest, timeout: Optional[float] = None,
+                           request_id: Optional[str] = None) -> \
             BatchModelResponse:
         """
         批量模型调用接口
@@ -305,10 +394,11 @@ class AsyncTamarModelClient:
         Args:
             batch_request_model: 多条 BatchModelRequest 输入
             timeout: 调用超时，单位秒
-
+            request_id: 请求id
         Returns:
             BatchModelResponse: 批量请求的结果
         """
+
         await self._ensure_initialized()
 
         if not self.default_payload:
@@ -317,7 +407,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 = []
@@ -378,11 +475,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:
@@ -398,14 +492,19 @@ class AsyncTamarModelClient:
                 responses=result
             )
         except grpc.RpcError as e:
-            raise ConnectionError(f"BatchInvoke failed: {str(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
 
     async def close(self):
         """关闭 gRPC 通道"""
         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-0.1.8 → tamar_model_client-0.1.15}/tamar_model_client/generated/model_service_pb2.py

@@ -2,7 +2,7 @@
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # NO CHECKED-IN PROTOBUF GENCODE
 # source: model_service.proto
-# Protobuf Python Version: 5.29.0
+# Protobuf Python Version: 5.27.2
 """Generated protocol buffer code."""
 from google.protobuf import descriptor as _descriptor
 from google.protobuf import descriptor_pool as _descriptor_pool
@@ -12,8 +12,8 @@ from google.protobuf.internal import builder as _builder
 _runtime_version.ValidateProtobufRuntimeVersion(
     _runtime_version.Domain.PUBLIC,
     5,
-    29,
-    0,
+    27,
+    2,
     '',
     'model_service.proto'
 )

{tamar_model_client-0.1.8 → tamar_model_client-0.1.15}/tamar_model_client/generated/model_service_pb2_grpc.py

@@ -5,7 +5,7 @@ import warnings
 
 import tamar_model_client.generated.model_service_pb2 as model__service__pb2
 
-GRPC_GENERATED_VERSION = '1.71.0'
+GRPC_GENERATED_VERSION = '1.67.1'
 GRPC_VERSION = grpc.__version__
 _version_not_supported = False
 

{tamar_model_client-0.1.8 → tamar_model_client-0.1.15}/tamar_model_client/schemas/inputs.py

@@ -127,11 +127,16 @@ class OpenAIChatCompletionsInput(BaseModel):
 
 class OpenAIImagesInput(BaseModel):
     prompt: str
+    background: Optional[Literal["transparent", "opaque", "auto"]] | NotGiven = NOT_GIVEN
     model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN
+    moderation: Optional[Literal["low", "auto"]] | NotGiven = NOT_GIVEN
     n: Optional[int] | NotGiven = NOT_GIVEN
+    output_compression: Optional[int] | NotGiven = NOT_GIVEN
+    output_format: Optional[Literal["png", "jpeg", "webp"]] | NotGiven = NOT_GIVEN
     quality: Literal["standard", "hd"] | NotGiven = NOT_GIVEN
     response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN
-    size: Optional[Literal["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"]] | NotGiven = NOT_GIVEN
+    size: Optional[Literal[
+        "auto", "1024x1024", "1536x1024", "1024x1536", "256x256", "512x512", "1792x1024", "1024x1792"]] | NotGiven = NOT_GIVEN
     style: Optional[Literal["vivid", "natural"]] | NotGiven = NOT_GIVEN
     user: str | NotGiven = NOT_GIVEN
     extra_headers: Headers | None = None
@@ -301,7 +306,7 @@ class BatchModelRequestItem(ModelRequestInput):
     def validate_by_provider_and_invoke_type(self) -> "BatchModelRequestItem":
         """根据 provider 和 invoke_type 动态校验具体输入模型字段。"""
         # 动态获取 allowed fields
-        base_allowed = {"provider", "channel", "invoke_type", "user_context"}
+        base_allowed = {"provider", "channel", "invoke_type", "user_context", "custom_id"}
         google_allowed = base_allowed | set(GoogleGenAiInput.model_fields.keys())
         openai_responses_allowed = base_allowed | set(OpenAIResponsesInput.model_fields.keys())
         openai_chat_allowed = base_allowed | set(OpenAIChatCompletionsInput.model_fields.keys())

tamar_model_client-0.1.15/tamar_model_client/sync_client.py

@@ -0,0 +1,509 @@
+import base64
+import json
+import logging
+import os
+import time
+import uuid
+import grpc
+from typing import Optional, Union, Iterable, Iterator
+from contextvars import ContextVar
+
+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 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:
+    """
+    递归判断value是否是有意义的有效值
+    """
+    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,
+            jwt_secret_key: Optional[str] = None,
+            jwt_token: Optional[str] = None,
+            default_payload: Optional[dict] = None,
+            token_expires_in: int = 3600,
+            max_retries: Optional[int] = None,  # 最大重试次数
+            retry_delay: Optional[float] = None,  # 初始重试延迟（秒）
+    ):
+        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:
+                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_inner(self, model_request, metadata, invoke_timeout) -> Iterator[ModelResponse]:
+        """Inner function to handle the actual streaming gRPC call."""
+        response = self.stub.Invoke(model_request, metadata=metadata, timeout=invoke_timeout)
+        for res in response:
+            yield ModelResponse(
+                content=res.content,
+                usage=json.loads(res.usage) if res.usage else None,
+                raw_response=json.loads(res.raw_response) if res.raw_response else None,
+                error=res.error or None,
+            )
+
+    def _stream(self, model_request, metadata, invoke_timeout) -> Iterator[ModelResponse]:
+        return self._retry_request(self._stream_inner, model_request, metadata, invoke_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,
+                request_id=response.request_id if response.request_id else None,
+            )
+
+    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: 连接服务端失败。
+        """
+        self._ensure_initialized()
+
+        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 ""
+            }
+
+        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:
+            # 选择需要校验的字段集合
+            # 动态分支逻辑
+            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:
+            raise ValueError(f"构建请求失败: {str(e)}") from e
+
+        try:
+            invoke_timeout = timeout or self.default_invoke_timeout
+            if model_request.stream:
+                return 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:
+        """
+        批量模型调用接口
+
+        Args:
+            batch_request_model: 多条 BatchModelRequest 输入
+            timeout: 调用超时，单位秒
+            request_id: 请求id
+        Returns:
+            BatchModelResponse: 批量请求的结果
+        """
+
+        self._ensure_initialized()
+
+        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 __enter__(self):
+        """同步初始化连接"""
+        self._ensure_initialized()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """同步关闭连接"""
+        self.close()

{tamar_model_client-0.1.8 → tamar_model_client-0.1.15}/tamar_model_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tamar-model-client
-Version: 0.1.8
+Version: 0.1.15
 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
@@ -11,8 +11,8 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Requires-Dist: grpcio
-Requires-Dist: grpcio-tools
+Requires-Dist: grpcio~=1.67.1
+Requires-Dist: grpcio-tools~=1.67.1
 Requires-Dist: pydantic
 Requires-Dist: PyJWT
 Requires-Dist: nest_asyncio
@@ -528,6 +528,13 @@ pip install -e .
 python make_grpc.py
 ```
 
+### 部署到 pip
+```bash
+python setup.py sdist bdist_wheel
+twine check dist/*
+
+```
+
 ## 许可证
 
 MIT License

{tamar_model_client-0.1.8 → tamar_model_client-0.1.15}/tamar_model_client.egg-info/requires.txt

@@ -1,5 +1,5 @@
-grpcio
-grpcio-tools
+grpcio~=1.67.1
+grpcio-tools~=1.67.1
 pydantic
 PyJWT
 nest_asyncio

tamar_model_client-0.1.8/tamar_model_client/sync_client.py

@@ -1,111 +0,0 @@
-import asyncio
-import atexit
-import logging
-from typing import Optional, Union, Iterator
-
-from .async_client import AsyncTamarModelClient
-from .schemas import ModelRequest, BatchModelRequest, ModelResponse, BatchModelResponse
-
-logger = logging.getLogger(__name__)
-
-
-class TamarModelClient:
-    """
-    同步版本的模型管理客户端，用于非异步环境（如 Flask、Django、脚本）。
-    内部封装 AsyncTamarModelClient 并处理事件循环兼容性。
-    """
-    _loop: Optional[asyncio.AbstractEventLoop] = None
-
-    def __init__(
-            self,
-            server_address: Optional[str] = None,
-            jwt_secret_key: Optional[str] = None,
-            jwt_token: Optional[str] = None,
-            default_payload: Optional[dict] = None,
-            token_expires_in: int = 3600,
-            max_retries: int = 3,
-            retry_delay: float = 1.0,
-    ):
-        # 初始化全局事件循环，仅创建一次
-        if not TamarModelClient._loop:
-            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 self._sync_wrap_async_generator(stream())
-        return self._run_async(self._async_client.invoke(model_request, timeout=timeout))
-
-    def invoke_batch(self, batch_model_request: BatchModelRequest,
-                     timeout: Optional[float] = None) -> BatchModelResponse:
-        """
-        同步调用批量模型任务
-        """
-        return self._run_async(self._async_client.invoke_batch(batch_model_request, timeout=timeout))
-
-    def close(self):
-        """手动关闭 gRPC 通道"""
-        self._run_async(self._async_client.close())
-
-    def _safe_sync_close(self):
-        """退出时自动关闭"""
-        try:
-            self._run_async(self._async_client.close())
-            logger.info("✅ gRPC channel closed at exit")
-        except Exception as e:
-            logger.warning(f"❌ gRPC channel close failed at exit: {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):
-        """
-        将 async generator 转换为同步 generator，逐条 yield。
-        """
-        loop = self._loop
-
-        # 创建异步生成器对象
-        agen = async_gen_func
-
-        class SyncGenerator:
-            def __iter__(self_inner):
-                return self_inner
-
-            def __next__(self_inner):
-                try:
-                    return loop.run_until_complete(agen.__anext__())
-                except StopAsyncIteration:
-                    raise StopIteration
-
-        return SyncGenerator()