tamar-model-client 0.1.0__py3-none-any.whl

model_manager_client/generated/model_service_pb2_grpc.py

@@ -0,0 +1,145 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+import warnings
+
+import model_manager_client.generated.model_service_pb2 as model__service__pb2
+
+GRPC_GENERATED_VERSION = '1.71.0'
+GRPC_VERSION = grpc.__version__
+_version_not_supported = False
+
+try:
+    from grpc._utilities import first_version_is_lower
+    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
+except ImportError:
+    _version_not_supported = True
+
+if _version_not_supported:
+    raise RuntimeError(
+        f'The grpc package installed is at version {GRPC_VERSION},'
+        + f' but the generated code in model_service_pb2_grpc.py depends on'
+        + f' grpcio>={GRPC_GENERATED_VERSION}.'
+        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
+        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
+    )
+
+
+class ModelServiceStub(object):
+    """grpc 服务（接口）定义
+    """
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.Invoke = channel.unary_stream(
+                '/model_service.ModelService/Invoke',
+                request_serializer=model__service__pb2.ModelRequestItem.SerializeToString,
+                response_deserializer=model__service__pb2.ModelResponseItem.FromString,
+                _registered_method=True)
+        self.BatchInvoke = channel.unary_unary(
+                '/model_service.ModelService/BatchInvoke',
+                request_serializer=model__service__pb2.ModelRequest.SerializeToString,
+                response_deserializer=model__service__pb2.ModelResponse.FromString,
+                _registered_method=True)
+
+
+class ModelServiceServicer(object):
+    """grpc 服务（接口）定义
+    """
+
+    def Invoke(self, request, context):
+        """单条请求 + 流式响应
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def BatchInvoke(self, request, context):
+        """批量调用接口，不支持流式
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_ModelServiceServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'Invoke': grpc.unary_stream_rpc_method_handler(
+                    servicer.Invoke,
+                    request_deserializer=model__service__pb2.ModelRequestItem.FromString,
+                    response_serializer=model__service__pb2.ModelResponseItem.SerializeToString,
+            ),
+            'BatchInvoke': grpc.unary_unary_rpc_method_handler(
+                    servicer.BatchInvoke,
+                    request_deserializer=model__service__pb2.ModelRequest.FromString,
+                    response_serializer=model__service__pb2.ModelResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'model_service.ModelService', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('model_service.ModelService', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class ModelService(object):
+    """grpc 服务（接口）定义
+    """
+
+    @staticmethod
+    def Invoke(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_stream(
+            request,
+            target,
+            '/model_service.ModelService/Invoke',
+            model__service__pb2.ModelRequestItem.SerializeToString,
+            model__service__pb2.ModelResponseItem.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def BatchInvoke(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/model_service.ModelService/BatchInvoke',
+            model__service__pb2.ModelRequest.SerializeToString,
+            model__service__pb2.ModelResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)

model_manager_client/schemas/__init__.py

@@ -0,0 +1,17 @@
+"""
+Schema definitions for the API
+"""
+
+from .inputs import UserContext, ModelRequest, BatchModelRequestItem, BatchModelRequest
+from .outputs import ModelResponse, BatchModelResponse
+
+__all__ = [
+    # Model Inputs
+    "UserContext",
+    "ModelRequest",
+    "BatchModelRequestItem",
+    "BatchModelRequest",
+    # Model Outputs
+    "ModelResponse",
+    "BatchModelResponse",
+]

model_manager_client/schemas/inputs.py

@@ -0,0 +1,294 @@
+import httpx
+from google.genai import types
+from openai import NotGiven, NOT_GIVEN
+from openai._types import Headers, Query, Body
+from openai.types import ChatModel, Metadata, ReasoningEffort, ResponsesModel, Reasoning
+from openai.types.chat import ChatCompletionMessageParam, ChatCompletionAudioParam, completion_create_params, \
+    ChatCompletionPredictionContentParam, ChatCompletionStreamOptionsParam, ChatCompletionToolChoiceOptionParam, \
+    ChatCompletionToolParam
+from openai.types.responses import ResponseInputParam, ResponseIncludable, ResponseTextConfigParam, \
+    response_create_params, ToolParam
+from pydantic import BaseModel, model_validator
+from typing import List, Optional, Union, Iterable, Dict, Literal
+
+from model_manager_client.enums import ProviderType, InvokeType
+from model_manager_client.enums.channel import Channel
+
+
+class UserContext(BaseModel):
+    org_id: str  # 组织id
+    user_id: str  # 用户id
+    client_type: str  # 客户端类型，这里记录的是哪个服务请求过来的
+
+
+class GoogleGenAiInput(BaseModel):
+    model: str
+    contents: Union[types.ContentListUnion, types.ContentListUnionDict]
+    config: Optional[types.GenerateContentConfigOrDict] = None
+
+    model_config = {
+        "arbitrary_types_allowed": True
+    }
+
+
+class OpenAIResponsesInput(BaseModel):
+    input: Union[str, ResponseInputParam]
+    model: ResponsesModel
+    include: Optional[List[ResponseIncludable]] | NotGiven = NOT_GIVEN
+    instructions: Optional[str] | NotGiven = NOT_GIVEN
+    max_output_tokens: Optional[int] | NotGiven = NOT_GIVEN
+    metadata: Optional[Metadata] | NotGiven = NOT_GIVEN
+    parallel_tool_calls: Optional[bool] | NotGiven = NOT_GIVEN
+    previous_response_id: Optional[str] | NotGiven = NOT_GIVEN
+    reasoning: Optional[Reasoning] | NotGiven = NOT_GIVEN
+    store: Optional[bool] | NotGiven = NOT_GIVEN
+    stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN
+    temperature: Optional[float] | NotGiven = NOT_GIVEN
+    text: ResponseTextConfigParam | NotGiven = NOT_GIVEN
+    tool_choice: response_create_params.ToolChoice | NotGiven = NOT_GIVEN
+    tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN
+    top_p: Optional[float] | NotGiven = NOT_GIVEN
+    truncation: Optional[Literal["auto", "disabled"]] | NotGiven = NOT_GIVEN
+    user: str | NotGiven = NOT_GIVEN
+    extra_headers: Headers | None = None
+    extra_query: Query | None = None
+    extra_body: Body | None = None
+    timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN
+
+    model_config = {
+        "arbitrary_types_allowed": True
+    }
+
+
+class OpenAIChatCompletionsInput(BaseModel):
+    messages: Iterable[ChatCompletionMessageParam]
+    model: Union[str, ChatModel]
+    audio: Optional[ChatCompletionAudioParam] | NotGiven = NOT_GIVEN
+    frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN
+    function_call: completion_create_params.FunctionCall | NotGiven = NOT_GIVEN
+    functions: Iterable[completion_create_params.Function] | NotGiven = NOT_GIVEN
+    logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN
+    logprobs: Optional[bool] | NotGiven = NOT_GIVEN
+    max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN
+    max_tokens: Optional[int] | NotGiven = NOT_GIVEN
+    metadata: Optional[Metadata] | NotGiven = NOT_GIVEN
+    modalities: Optional[List[Literal["text", "audio"]]] | NotGiven = NOT_GIVEN
+    n: Optional[int] | NotGiven = NOT_GIVEN
+    parallel_tool_calls: bool | NotGiven = NOT_GIVEN
+    prediction: Optional[ChatCompletionPredictionContentParam] | NotGiven = NOT_GIVEN
+    presence_penalty: Optional[float] | NotGiven = NOT_GIVEN
+    reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN
+    response_format: completion_create_params.ResponseFormat | NotGiven = NOT_GIVEN
+    seed: Optional[int] | NotGiven = NOT_GIVEN
+    service_tier: Optional[Literal["auto", "default"]] | NotGiven = NOT_GIVEN
+    stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN
+    store: Optional[bool] | NotGiven = NOT_GIVEN
+    stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN
+    stream_options: Optional[ChatCompletionStreamOptionsParam] | NotGiven = NOT_GIVEN
+    temperature: Optional[float] | NotGiven = NOT_GIVEN
+    tool_choice: ChatCompletionToolChoiceOptionParam | NotGiven = NOT_GIVEN
+    tools: Iterable[ChatCompletionToolParam] | NotGiven = NOT_GIVEN
+    top_logprobs: Optional[int] | NotGiven = NOT_GIVEN
+    top_p: Optional[float] | NotGiven = NOT_GIVEN
+    user: str | NotGiven = NOT_GIVEN
+    web_search_options: completion_create_params.WebSearchOptions | NotGiven = NOT_GIVEN
+    extra_headers: Headers | None = None
+    extra_query: Query | None = None
+    extra_body: Body | None = None
+    timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN
+
+    model_config = {
+        "arbitrary_types_allowed": True
+    }
+
+
+class BaseRequest(BaseModel):
+    provider: ProviderType  # 供应商，如 "openai", "google" 等
+    channel: Channel = Channel.NORMAL  # 渠道：不同服务商之前有不同的调用SDK，这里指定是调用哪个SDK
+    invoke_type: InvokeType = InvokeType.GENERATION  # 模型调用类型：generation-生成模型调用
+
+
+class ModelRequestInput(BaseRequest):
+    # 合并model字段
+    model: Optional[Union[str, ResponsesModel, ChatModel]] = None
+
+    # OpenAI Responses Input
+    input: Optional[Union[str, ResponseInputParam]] = None
+    include: Optional[Union[List[ResponseIncludable], NotGiven]] = NOT_GIVEN
+    instructions: Optional[Union[str, NotGiven]] = NOT_GIVEN
+    max_output_tokens: Optional[Union[int, NotGiven]] = NOT_GIVEN
+    metadata: Optional[Union[Metadata, NotGiven]] = NOT_GIVEN
+    parallel_tool_calls: Optional[Union[bool, NotGiven]] = NOT_GIVEN
+    previous_response_id: Optional[Union[str, NotGiven]] = NOT_GIVEN
+    reasoning: Optional[Union[Reasoning, NotGiven]] = NOT_GIVEN
+    store: Optional[Union[bool, NotGiven]] = NOT_GIVEN
+    stream: Optional[Union[Literal[False], Literal[True], NotGiven]] = NOT_GIVEN
+    temperature: Optional[Union[float, NotGiven]] = NOT_GIVEN
+    text: Optional[Union[ResponseTextConfigParam, NotGiven]] = NOT_GIVEN
+    tool_choice: Optional[
+        Union[response_create_params.ToolChoice, ChatCompletionToolChoiceOptionParam, NotGiven]] = NOT_GIVEN
+    tools: Optional[Union[Iterable[ToolParam], Iterable[ChatCompletionToolParam], NotGiven]] = NOT_GIVEN
+    top_p: Optional[Union[float, NotGiven]] = NOT_GIVEN
+    truncation: Optional[Union[Literal["auto", "disabled"], NotGiven]] = NOT_GIVEN
+    user: Optional[Union[str, NotGiven]] = NOT_GIVEN
+
+    extra_headers: Optional[Union[Headers, None]] = None
+    extra_query: Optional[Union[Query, None]] = None
+    extra_body: Optional[Union[Body, None]] = None
+    timeout: Optional[Union[float, httpx.Timeout, None, NotGiven]] = NOT_GIVEN
+
+    # OpenAI Chat Completions Input
+    messages: Optional[Iterable[ChatCompletionMessageParam]] = None
+    audio: Optional[Union[ChatCompletionAudioParam, NotGiven]] = NOT_GIVEN
+    frequency_penalty: Optional[Union[float, NotGiven]] = NOT_GIVEN
+    function_call: Optional[Union[completion_create_params.FunctionCall, NotGiven]] = NOT_GIVEN
+    functions: Optional[Union[Iterable[completion_create_params.Function], NotGiven]] = NOT_GIVEN
+    logit_bias: Optional[Union[Dict[str, int], NotGiven]] = NOT_GIVEN
+    logprobs: Optional[Union[bool, NotGiven]] = NOT_GIVEN
+    max_completion_tokens: Optional[Union[int, NotGiven]] = NOT_GIVEN
+    modalities: Optional[Union[List[Literal["text", "audio"]], NotGiven]] = NOT_GIVEN
+    n: Optional[Union[int, NotGiven]] = NOT_GIVEN
+    prediction: Optional[Union[ChatCompletionPredictionContentParam, NotGiven]] = NOT_GIVEN
+    presence_penalty: Optional[Union[float, NotGiven]] = NOT_GIVEN
+    reasoning_effort: Optional[Union[ReasoningEffort, NotGiven]] = NOT_GIVEN
+    response_format: Optional[Union[completion_create_params.ResponseFormat, NotGiven]] = NOT_GIVEN
+    seed: Optional[Union[int, NotGiven]] = NOT_GIVEN
+    service_tier: Optional[Union[Literal["auto", "default"], NotGiven]] = NOT_GIVEN
+    stop: Optional[Union[Optional[str], List[str], None, NotGiven]] = NOT_GIVEN
+    top_logprobs: Optional[Union[int, NotGiven]] = NOT_GIVEN
+    web_search_options: Optional[Union[completion_create_params.WebSearchOptions, NotGiven]] = NOT_GIVEN
+    stream_options: Optional[Union[ChatCompletionStreamOptionsParam, NotGiven]] = NOT_GIVEN
+
+    # Google GenAI Input
+    contents: Optional[Union[types.ContentListUnion, types.ContentListUnionDict]] = None
+    config: Optional[types.GenerateContentConfigOrDict] = None
+
+    model_config = {
+        "arbitrary_types_allowed": True
+    }
+
+
+class ModelRequest(ModelRequestInput):
+    user_context: UserContext  # 用户信息
+
+    @model_validator(mode="after")
+    def validate_by_provider_and_invoke_type(self) -> "ModelRequest":
+        """根据 provider 和 invoke_type 动态校验具体输入模型字段。"""
+        # 动态获取 allowed fields
+        base_allowed = ["provider", "channel", "invoke_type", "user_context"]
+        google_allowed = set(base_allowed) | set(GoogleGenAiInput.model_fields.keys())
+        openai_responses_allowed = set(base_allowed) | set(OpenAIResponsesInput.model_fields.keys())
+        openai_chat_allowed = set(base_allowed) | set(OpenAIChatCompletionsInput.model_fields.keys())
+
+        # 导入或定义你的原始输入模型
+        google_required_fields = {"model", "contents"}
+        openai_responses_required_fields = {"input", "model"}
+        openai_chat_required_fields = {"messages", "model"}
+
+        # 选择需要校验的字段集合
+        if self.provider == ProviderType.GOOGLE:
+            expected_fields = google_required_fields
+            allowed_fields = google_allowed
+        elif self.provider == ProviderType.OPENAI or self.provider == ProviderType.AZURE:
+            if self.invoke_type == InvokeType.RESPONSES or self.invoke_type == InvokeType.GENERATION:
+                expected_fields = openai_responses_required_fields
+                allowed_fields = openai_responses_allowed
+            elif self.invoke_type == InvokeType.CHAT_COMPLETIONS:
+                expected_fields = openai_chat_required_fields
+                allowed_fields = openai_chat_allowed
+            else:
+                raise ValueError(f"暂不支持的调用类型: {self.invoke_type}")
+        else:
+            raise ValueError(f"暂不支持的提供商: {self.provider}")
+
+        # 检查是否缺失关键字段
+        missing = []
+        for field in expected_fields:
+            if getattr(self, field, None) is None:
+                missing.append(field)
+
+        if missing:
+            raise ValueError(
+                f"{self.provider}（{self.invoke_type}）请求缺少必填字段: {missing}"
+            )
+
+        # 检查是否有非法字段
+        illegal_fields = []
+        for name, value in self.__dict__.items():
+            if name in {"provider", "channel", "invoke_type", "stream"}:
+                continue
+            if name not in allowed_fields and value is not None and not isinstance(value, NotGiven):
+                illegal_fields.append(name)
+
+        if illegal_fields:
+            raise ValueError(
+                f"{self.provider}（{self.invoke_type}）存在不支持的字段: {illegal_fields}"
+            )
+
+        return self
+
+
+class BatchModelRequestItem(ModelRequestInput):
+    custom_id: Optional[str] = None
+    priority: Optional[int] = None  # （可选、预留字段）批量调用时执行的优先级
+
+    @model_validator(mode="after")
+    def validate_by_provider_and_invoke_type(self) -> "BatchModelRequestItem":
+        """根据 provider 和 invoke_type 动态校验具体输入模型字段。"""
+        # 动态获取 allowed fields
+        base_allowed = ["provider", "channel", "invoke_type", "custom_id", "priority"]
+        google_allowed = set(base_allowed) | set(GoogleGenAiInput.model_fields.keys())
+        openai_responses_allowed = set(base_allowed) | set(OpenAIResponsesInput.model_fields.keys())
+        openai_chat_allowed = set(base_allowed) | set(OpenAIChatCompletionsInput.model_fields.keys())
+
+        # 导入或定义你的原始输入模型
+        google_required_fields = {"model", "contents"}
+        openai_responses_required_fields = {"input", "model"}
+        openai_chat_required_fields = {"messages", "model"}
+
+        # 选择需要校验的字段集合
+        if self.provider == ProviderType.GOOGLE:
+            expected_fields = google_required_fields
+            allowed_fields = google_allowed
+        elif self.provider == ProviderType.OPENAI or self.provider == ProviderType.AZURE:
+            if self.invoke_type == InvokeType.RESPONSES or self.invoke_type == InvokeType.GENERATION:
+                expected_fields = openai_responses_required_fields
+                allowed_fields = openai_responses_allowed
+            elif self.invoke_type == InvokeType.CHAT_COMPLETIONS:
+                expected_fields = openai_chat_required_fields
+                allowed_fields = openai_chat_allowed
+            else:
+                raise ValueError(f"暂不支持的调用类型: {self.invoke_type}")
+        else:
+            raise ValueError(f"暂不支持的提供商: {self.provider}")
+
+        # 检查是否缺失关键字段
+        missing = []
+        for field in expected_fields:
+            if getattr(self, field, None) is None:
+                missing.append(field)
+
+        if missing:
+            raise ValueError(
+                f"{self.provider}（{self.invoke_type}）请求缺少必填字段: {missing}"
+            )
+
+        # 检查是否有非法字段
+        illegal_fields = []
+        for name, value in self.__dict__.items():
+            if name in {"provider", "channel", "invoke_type", "stream"}:
+                continue
+            if name not in allowed_fields and value is not None and not isinstance(value, NotGiven):
+                illegal_fields.append(name)
+
+        if illegal_fields:
+            raise ValueError(
+                f"{self.provider}（{self.invoke_type}）存在不支持的字段: {illegal_fields}"
+            )
+
+        return self
+
+
+class BatchModelRequest(BaseModel):
+    user_context: UserContext  # 用户信息
+    items: List[BatchModelRequestItem]  # 批量请求项列表

model_manager_client/schemas/outputs.py

@@ -0,0 +1,24 @@
+from typing import Any, Iterator, Optional, Union, Dict, List
+
+from pydantic import BaseModel, ConfigDict
+
+
+class BaseResponse(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    content: Optional[str] = None  # 文本输出内容
+    usage: Optional[Dict] = None  # tokens / 请求成本等（JSON）
+    stream_response: Optional[Union[Iterator[str], Any]] = None  # 用于流式响应（同步 or 异步）
+    raw_response: Optional[Union[Dict, List]] = None  # 模型服务商返回的原始结构（JSON）
+    error: Optional[Any] = None  # 错误信息
+    custom_id: Optional[str] = None  # 自定义ID，用于批量请求时结果关联
+
+
+class ModelResponse(BaseResponse):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    request_id: Optional[str] = None  # 请求ID，用于跟踪请求
+
+
+class BatchModelResponse(BaseModel):
+    request_id: Optional[str] = None  # 请求ID，用于跟踪请求
+    responses: Optional[List[BaseResponse]] = None  # 批量请求的响应列表

model_manager_client/sync_client.py

@@ -0,0 +1,111 @@
+import asyncio
+import atexit
+import logging
+from typing import Optional, Union, Iterator
+
+from .async_client import AsyncModelManagerClient
+from .schemas import ModelRequest, BatchModelRequest, ModelResponse, BatchModelResponse
+
+logger = logging.getLogger(__name__)
+
+
+class ModelManagerClient:
+    """
+    同步版本的模型管理客户端，用于非异步环境（如 Flask、Django、脚本）。
+    内部封装 AsyncModelManagerClient 并处理事件循环兼容性。
+    """
+    _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 ModelManagerClient._loop:
+            try:
+                ModelManagerClient._loop = asyncio.get_running_loop()
+            except RuntimeError:
+                ModelManagerClient._loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(ModelManagerClient._loop)
+
+        self._loop = ModelManagerClient._loop
+
+        self._async_client = AsyncModelManagerClient(
+            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()