tamar-model-client 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

model_manager_client/schemas/inputs.py

@@ -105,7 +105,7 @@ class OpenAIChatCompletionsInput(BaseModel):
 class BaseRequest(BaseModel):
     provider: ProviderType  # 供应商，如 "openai", "google" 等
     channel: Channel = Channel.NORMAL  # 渠道：不同服务商之前有不同的调用SDK，这里指定是调用哪个SDK
-    invoke_type: InvokeType = InvokeType.GENERATION  # 模型调用类型：generation-生成模型调用
+    invoke_type: InvokeType = InvokeType.TEXT_GENERATION  # 模型调用类型：generation-生成模型调用
 
 
 class ModelRequestInput(BaseRequest):
@@ -190,7 +190,7 @@ class ModelRequest(ModelRequestInput):
             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:
+            if self.invoke_type == InvokeType.RESPONSES or self.invoke_type == InvokeType.TEXT_GENERATION:
                 expected_fields = openai_responses_required_fields
                 allowed_fields = openai_responses_allowed
             elif self.invoke_type == InvokeType.CHAT_COMPLETIONS:
@@ -251,7 +251,7 @@ class BatchModelRequestItem(ModelRequestInput):
             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:
+            if self.invoke_type == InvokeType.RESPONSES or self.invoke_type == InvokeType.TEXT_GENERATION:
                 expected_fields = openai_responses_required_fields
                 allowed_fields = openai_responses_allowed
             elif self.invoke_type == InvokeType.CHAT_COMPLETIONS:

tamar_model_client/async_client.py

@@ -1,5 +1,6 @@
 import asyncio
 import atexit
+import base64
 import json
 import logging
 import os
@@ -15,7 +16,8 @@ from .enums import ProviderType, InvokeType
 from .exceptions import ConnectionError, ValidationError
 from .schemas import ModelRequest, ModelResponse, BatchModelRequest, BatchModelResponse
 from .generated import model_service_pb2, model_service_pb2_grpc
-from .schemas.inputs import GoogleGenAiInput, OpenAIResponsesInput, OpenAIChatCompletionsInput
+from .schemas.inputs import GoogleGenAiInput, OpenAIResponsesInput, OpenAIChatCompletionsInput, \
+    GoogleVertexAIImagesInput, OpenAIImagesInput
 
 if not logging.getLogger().hasHandlers():
     # 配置日志格式
@@ -27,6 +29,72 @@ if not logging.getLogger().hasHandlers():
 logger = logging.getLogger(__name__)
 
 
+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
+
+
 class AsyncTamarModelClient:
     def __init__(
             self,
@@ -157,17 +225,22 @@ class AsyncTamarModelClient:
 
         # 动态根据 provider/invoke_type 决定使用哪个 input 字段
         try:
-            if model_request.provider == ProviderType.GOOGLE:
-                allowed_fields = GoogleGenAiInput.model_fields.keys()
-            elif model_request.provider in {ProviderType.OPENAI, ProviderType.AZURE}:
-                if model_request.invoke_type in {InvokeType.RESPONSES, InvokeType.GENERATION}:
+            # 选择需要校验的字段集合
+            # 动态分支逻辑
+            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()
-                elif model_request.invoke_type == InvokeType.CHAT_COMPLETIONS:
+                case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.CHAT_COMPLETIONS):
                     allowed_fields = OpenAIChatCompletionsInput.model_fields.keys()
-                else:
-                    raise ValueError(f"暂不支持的调用类型: {model_request.invoke_type}")
-            else:
-                raise ValueError(f"暂不支持的提供商: {model_request.provider}")
+                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)
@@ -177,51 +250,15 @@ class AsyncTamarModelClient:
                 if field in model_request_dict:
                     value = model_request_dict[field]
 
-                    # Skip fields with NotGiven or None (unless explicitly allowed)
-                    if value is NOT_GIVEN or value is None:
+                    # 跳过无效的值
+                    if not is_effective_value(value):
                         continue
 
-                    # 特别处理：如果是自定义的 BaseModel 或特定类型
-                    if isinstance(value, BaseModel):
-                        grpc_request_kwargs[field] = value.model_dump()
-                    # 如果是 OpenAI / Google 里的自定义对象，通常有 dict() 方法
-                    elif hasattr(value, "dict") and callable(value.dict):
-                        grpc_request_kwargs[field] = value.dict()
-                    # 如果是 list，需要处理里面元素也是自定义对象的情况
-                    elif isinstance(value, Iterable) and not isinstance(value, (str, bytes, dict)):
-                        new_list = []
-                        for item in value:
-                            if isinstance(item, BaseModel):
-                                new_list.append(item.model_dump())
-                            elif hasattr(item, "dict") and callable(item.dict):
-                                new_list.append(item.dict())
-                            elif isinstance(item, dict):
-                                # Handle nested dictionaries
-                                nested_dict = {}
-                                for k, v in item.items():
-                                    if isinstance(v, BaseModel):
-                                        nested_dict[k] = v.model_dump()
-                                    elif hasattr(v, "dict") and callable(v.dict):
-                                        nested_dict[k] = v.dict()
-                                    else:
-                                        nested_dict[k] = v
-                                new_list.append(nested_dict)
-                            else:
-                                new_list.append(item)
-                        grpc_request_kwargs[field] = new_list
-                        # 如果是 dict，同理处理内部元素
-                    elif isinstance(value, dict):
-                        new_dict = {}
-                        for k, v in value.items():
-                            if isinstance(v, BaseModel):
-                                new_dict[k] = v.model_dump()
-                            elif hasattr(v, "dict") and callable(v.dict):
-                                new_dict[k] = v.dict()
-                            else:
-                                new_dict[k] = v
-                        grpc_request_kwargs[field] = new_dict
-                    else:
-                        grpc_request_kwargs[field] = value
+                    # 序列化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,
@@ -280,17 +317,20 @@ class AsyncTamarModelClient:
         for model_request_item in batch_request_model.items:
             # 动态根据 provider/invoke_type 决定使用哪个 input 字段
             try:
-                if model_request_item.provider == ProviderType.GOOGLE:
-                    allowed_fields = GoogleGenAiInput.model_fields.keys()
-                elif model_request_item.provider in {ProviderType.OPENAI, ProviderType.AZURE}:
-                    if model_request_item.invoke_type in {InvokeType.RESPONSES, InvokeType.GENERATION}:
+                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()
-                    elif model_request_item.invoke_type == InvokeType.CHAT_COMPLETIONS:
+                    case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.CHAT_COMPLETIONS):
                         allowed_fields = OpenAIChatCompletionsInput.model_fields.keys()
-                    else:
-                        raise ValueError(f"暂不支持的调用类型: {model_request_item.invoke_type}")
-                else:
-                    raise ValueError(f"暂不支持的提供商: {model_request_item.provider}")
+                    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)
@@ -300,51 +340,15 @@ class AsyncTamarModelClient:
                     if field in model_request_dict:
                         value = model_request_dict[field]
 
-                        # Skip fields with NotGiven or None (unless explicitly allowed)
-                        if value is NOT_GIVEN or value is None:
+                        # 跳过无效的值
+                        if not is_effective_value(value):
                             continue
 
-                        # 特别处理：如果是自定义的 BaseModel 或特定类型
-                        if isinstance(value, BaseModel):
-                            grpc_request_kwargs[field] = value.model_dump()
-                        # 如果是 OpenAI / Google 里的自定义对象，通常有 dict() 方法
-                        elif hasattr(value, "dict") and callable(value.dict):
-                            grpc_request_kwargs[field] = value.dict()
-                        # 如果是 list，需要处理里面元素也是自定义对象的情况
-                        elif isinstance(value, Iterable) and not isinstance(value, (str, bytes, dict)):
-                            new_list = []
-                            for item in value:
-                                if isinstance(item, BaseModel):
-                                    new_list.append(item.model_dump())
-                                elif hasattr(item, "dict") and callable(item.dict):
-                                    new_list.append(item.dict())
-                                elif isinstance(item, dict):
-                                    # Handle nested dictionaries
-                                    nested_dict = {}
-                                    for k, v in item.items():
-                                        if isinstance(v, BaseModel):
-                                            nested_dict[k] = v.model_dump()
-                                        elif hasattr(v, "dict") and callable(v.dict):
-                                            nested_dict[k] = v.dict()
-                                        else:
-                                            nested_dict[k] = v
-                                    new_list.append(nested_dict)
-                                else:
-                                    new_list.append(item)
-                            grpc_request_kwargs[field] = new_list
-                            # 如果是 dict，同理处理内部元素
-                        elif isinstance(value, dict):
-                            new_dict = {}
-                            for k, v in value.items():
-                                if isinstance(v, BaseModel):
-                                    new_dict[k] = v.model_dump()
-                                elif hasattr(v, "dict") and callable(v.dict):
-                                    new_dict[k] = v.dict()
-                                else:
-                                    new_dict[k] = v
-                            grpc_request_kwargs[field] = new_dict
-                        else:
-                            grpc_request_kwargs[field] = value
+                        # 序列化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,

tamar_model_client/enums/invoke.py

@@ -6,5 +6,5 @@ class InvokeType(str, Enum):
     RESPONSES = "responses"
     CHAT_COMPLETIONS = "chat-completions"
 
-    # 默认的
-    GENERATION = "generation"
+    GENERATION = "generation"  # 生成类，默认的值
+    IMAGE_GENERATION = "image-generation"

tamar_model_client/schemas/inputs.py

@@ -1,294 +1,365 @@
-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 tamar_model_client.enums import ProviderType, InvokeType
-from tamar_model_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]  # 批量请求项列表
+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, ImageModel
+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 tamar_model_client.enums import ProviderType, InvokeType
+from tamar_model_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 GoogleVertexAIImagesInput(BaseModel):
+    model: str
+    prompt: str
+    negative_prompt: Optional[str] = None
+    number_of_images: int = 1
+    aspect_ratio: Optional[Literal["1:1", "9:16", "16:9", "4:3", "3:4"]] = None
+    guidance_scale: Optional[float] = None
+    language: Optional[str] = None
+    seed: Optional[int] = None
+    output_gcs_uri: Optional[str] = None
+    add_watermark: Optional[bool] = True
+    safety_filter_level: Optional[
+        Literal["block_most", "block_some", "block_few", "block_fewest"]
+    ] = None
+    person_generation: Optional[
+        Literal["dont_allow", "allow_adult", "allow_all"]
+    ] = 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 OpenAIImagesInput(BaseModel):
+    prompt: str
+    model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN
+    n: Optional[int] | 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
+    style: Optional[Literal["vivid", "natural"]] | 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 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, ImageModel]] = 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[Literal["url", "b64_json"], 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
+
+    # OpenAIImagesInput + GoogleVertexAIImagesInput 合并字段
+    prompt: Optional[str] = None
+    negative_prompt: Optional[str] = None
+    aspect_ratio: Optional[Literal["1:1", "9:16", "16:9", "4:3", "3:4"]] = None
+    guidance_scale: Optional[float] = None
+    language: Optional[str] = None
+    output_gcs_uri: Optional[str] = None
+    add_watermark: Optional[bool] = None
+    safety_filter_level: Optional[Literal["block_most", "block_some", "block_few", "block_fewest"]] = None
+    person_generation: Optional[Literal["dont_allow", "allow_adult", "allow_all"]] = None
+    quality: Optional[Literal["standard", "hd"]] | NotGiven = NOT_GIVEN
+    size: Optional[Literal["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"]] | NotGiven = NOT_GIVEN
+    style: Optional[Literal["vivid", "natural"]] | NotGiven = NOT_GIVEN
+    number_of_images: Optional[int] = None  # Google 用法
+
+    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 = 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())
+        openai_images_allowed = base_allowed | set(OpenAIImagesInput.model_fields.keys())
+        google_vertexai_images_allowed = base_allowed | set(GoogleVertexAIImagesInput.model_fields.keys())
+
+        # 各模型类型必填字段
+        google_required_fields = {"model", "contents"}
+        google_vertexai_image_required_fields = {"model", "prompt"}
+
+        openai_responses_required_fields = {"input", "model"}
+        openai_chat_required_fields = {"messages", "model"}
+        openai_image_required_fields = {"prompt"}
+
+        # 选择需要校验的字段集合
+        # 动态分支逻辑
+        match (self.provider, self.invoke_type):
+            case (ProviderType.GOOGLE, InvokeType.GENERATION):
+                allowed_fields = google_allowed
+                expected_fields = google_required_fields
+            case (ProviderType.GOOGLE, InvokeType.IMAGE_GENERATION):
+                allowed_fields = google_vertexai_images_allowed
+                expected_fields = google_vertexai_image_required_fields
+            case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.RESPONSES | InvokeType.GENERATION):
+                allowed_fields = openai_responses_allowed
+                expected_fields = openai_responses_required_fields
+            case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.CHAT_COMPLETIONS):
+                allowed_fields = openai_chat_allowed
+                expected_fields = openai_chat_required_fields
+            case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.IMAGE_GENERATION):
+                allowed_fields = openai_images_allowed
+                expected_fields = openai_image_required_fields
+            case _:
+                raise ValueError(f"Unsupported provider/invoke_type combination: {self.provider} + {self.invoke_type}")
+
+        # 校验必填字段是否缺失
+        missing = [field for field in expected_fields if getattr(self, field, None) is None]
+        if missing:
+            raise ValueError(
+                f"Missing required fields for provider={self.provider} and invoke_type={self.invoke_type}: {missing}")
+
+        # 检查是否有非法字段
+        illegal_fields = []
+        valid_fields = {"provider", "channel", "invoke_type"} if self.invoke_type == InvokeType.IMAGE_GENERATION else {
+            "provider", "channel", "invoke_type", "stream"}
+        for name, value in self.__dict__.items():
+            if name in valid_fields:
+                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"Unsupported fields for provider={self.provider} and invoke_type={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", "user_context"}
+        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())
+        openai_images_allowed = base_allowed | set(OpenAIImagesInput.model_fields.keys())
+        google_vertexai_images_allowed = base_allowed | set(GoogleVertexAIImagesInput.model_fields.keys())
+
+        # 各模型类型必填字段
+        google_required_fields = {"model", "contents"}
+        google_vertexai_image_required_fields = {"model", "prompt"}
+
+        openai_responses_required_fields = {"input", "model"}
+        openai_chat_required_fields = {"messages", "model"}
+        openai_image_required_fields = {"prompt"}
+
+        # 选择需要校验的字段集合
+        # 动态分支逻辑
+        match (self.provider, self.invoke_type):
+            case (ProviderType.GOOGLE, InvokeType.GENERATION):
+                allowed_fields = google_allowed
+                expected_fields = google_required_fields
+            case (ProviderType.GOOGLE, InvokeType.IMAGE_GENERATION):
+                allowed_fields = google_vertexai_images_allowed
+                expected_fields = google_vertexai_image_required_fields
+            case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.RESPONSES | InvokeType.GENERATION):
+                allowed_fields = openai_responses_allowed
+                expected_fields = openai_responses_required_fields
+            case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.CHAT_COMPLETIONS):
+                allowed_fields = openai_chat_allowed
+                expected_fields = openai_chat_required_fields
+            case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.IMAGE_GENERATION):
+                allowed_fields = openai_images_allowed
+                expected_fields = openai_image_required_fields
+            case _:
+                raise ValueError(f"Unsupported provider/invoke_type combination: {self.provider} + {self.invoke_type}")
+
+        # 校验必填字段是否缺失
+        missing = [field for field in expected_fields if getattr(self, field, None) is None]
+        if missing:
+            raise ValueError(
+                f"Missing required fields for provider={self.provider} and invoke_type={self.invoke_type}: {missing}")
+
+        # 检查是否有非法字段
+        illegal_fields = []
+        valid_fields = {"provider", "channel", "invoke_type"} if self.invoke_type == InvokeType.IMAGE_GENERATION else {
+            "provider", "channel", "invoke_type", "stream"}
+        for name, value in self.__dict__.items():
+            if name in valid_fields:
+                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"Unsupported fields for provider={self.provider} and invoke_type={self.invoke_type}: {illegal_fields}")
+
+        return self
+
+
+class BatchModelRequest(BaseModel):
+    user_context: UserContext  # 用户信息
+    items: List[BatchModelRequestItem]  # 批量请求项列表

{tamar_model_client-0.1.2.dist-info → tamar_model_client-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tamar-model-client
-Version: 0.1.2
+Version: 0.1.4
 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

{tamar_model_client-0.1.2.dist-info → tamar_model_client-0.1.4.dist-info}/RECORD

@@ -11,24 +11,24 @@ model_manager_client/generated/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5
 model_manager_client/generated/model_service_pb2.py,sha256=ST84YYQk8x6UtQKIx6HprUxH5uGU4i3LhC8b-lHUQtA,3066
 model_manager_client/generated/model_service_pb2_grpc.py,sha256=BzsINWQeACVnVzLVV0PgieZA25C2-EklMKlA-W50c6Y,5147
 model_manager_client/schemas/__init__.py,sha256=AxuI-TcvA4OMTj2FtK4wAItvz9LrK_293pu3cmMLE7k,394
-model_manager_client/schemas/inputs.py,sha256=gXaifquIhSgUdbteRXsW9jxiJn0aOGDJ4UGCsrYdhPI,14323
+model_manager_client/schemas/inputs.py,sha256=3HUxnbuyQbuvMz1C46zydFYz-iEvLAUWVzOx7-eKS_I,14338
 model_manager_client/schemas/outputs.py,sha256=M_fcqUtXPJnfiLabHlyA8BorlC5pYkf5KLjXO1ysKIQ,1031
 tamar_model_client/__init__.py,sha256=LMECAuDARWHV1XzH3msoDXcyurS2eihRQmBy26_PUE0,328
-tamar_model_client/async_client.py,sha256=EMu1x2BHI11ssoxfTMD3MBq5VAqyT758sBG7vop-cj8,20597
+tamar_model_client/async_client.py,sha256=UQCvHlijt5VvseQJkXq0CyjKv-oOyzLk2oWLgq85P84,18661
 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/enums/__init__.py,sha256=3cYYn8ztNGBa_pI_5JGRVYf2QX8fkBVWdjID1PLvoBQ,182
 tamar_model_client/enums/channel.py,sha256=wCzX579nNpTtwzGeS6S3Ls0UzVAgsOlfy4fXMzQTCAw,199
-tamar_model_client/enums/invoke.py,sha256=9C5BxyAd4En-PSscOMynhfDa5WavGaSSOVFSYQGerK4,215
+tamar_model_client/enums/invoke.py,sha256=WufImoN_87ZjGyzYitZkhNNFefWJehKfLtyP-DTBYlA,267
 tamar_model_client/enums/providers.py,sha256=L_bX75K6KnWURoFizoitZ1Ybza7bmYDqXecNzNpgIrI,165
 tamar_model_client/generated/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tamar_model_client/generated/model_service_pb2.py,sha256=ST84YYQk8x6UtQKIx6HprUxH5uGU4i3LhC8b-lHUQtA,3066
 tamar_model_client/generated/model_service_pb2_grpc.py,sha256=KW1UEGUim_kmSi_fCIjeLNVOp8nAPE08DgJOn6PY7PM,5145
 tamar_model_client/schemas/__init__.py,sha256=AxuI-TcvA4OMTj2FtK4wAItvz9LrK_293pu3cmMLE7k,394
-tamar_model_client/schemas/inputs.py,sha256=tXkBy19gm-ms8YE8GKn374uYY85hT7iT3BgivJGOJ4A,14319
+tamar_model_client/schemas/inputs.py,sha256=Y9zzt-RoRklkxxe_3VJbZvPghJ00KUjHtFUmD0pCdHs,18721
 tamar_model_client/schemas/outputs.py,sha256=M_fcqUtXPJnfiLabHlyA8BorlC5pYkf5KLjXO1ysKIQ,1031
-tamar_model_client-0.1.2.dist-info/METADATA,sha256=wxhQ6527g9U4DC80ZAbLpeQUujbbHJ4RUtyPbDAw_Y8,16608
-tamar_model_client-0.1.2.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-tamar_model_client-0.1.2.dist-info/top_level.txt,sha256=_LfDhPv_fvON0PoZgQuo4M7EjoWtxPRoQOBJziJmip8,19
-tamar_model_client-0.1.2.dist-info/RECORD,,
+tamar_model_client-0.1.4.dist-info/METADATA,sha256=xW11Mj_6s0Qm4fLg3gKRHoXCW4lcCnhexv-qxigqUTQ,16608
+tamar_model_client-0.1.4.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
+tamar_model_client-0.1.4.dist-info/top_level.txt,sha256=_LfDhPv_fvON0PoZgQuo4M7EjoWtxPRoQOBJziJmip8,19
+tamar_model_client-0.1.4.dist-info/RECORD,,

{tamar_model_client-0.1.2.dist-info → tamar_model_client-0.1.4.dist-info}/WHEEL

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