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

tamar_model_client/__init__.py

@@ -1,6 +1,7 @@
 from .sync_client import TamarModelClient
 from .async_client import AsyncTamarModelClient
 from .exceptions import ModelManagerClientError, ConnectionError, ValidationError
+from .json_formatter import JSONFormatter
 
 __all__ = [
     "TamarModelClient",
@@ -8,4 +9,5 @@ __all__ = [
     "ModelManagerClientError",
     "ConnectionError",
     "ValidationError",
+    "JSONFormatter",
 ]

tamar_model_client/async_client.py

@@ -4,6 +4,7 @@ import base64
 import json
 import logging
 import os
+import time
 import uuid
 from contextvars import ContextVar
 
@@ -19,7 +20,8 @@ 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
+    GoogleVertexAIImagesInput, OpenAIImagesInput, OpenAIImagesEditInput
+from .json_formatter import JSONFormatter
 
 logger = logging.getLogger(__name__)
 
@@ -40,8 +42,8 @@ if not logger.hasHandlers():
     # 创建日志处理器，输出到控制台
     console_handler = logging.StreamHandler()
 
-    # 设置日志格式
-    formatter = logging.Formatter('%(asctime)s [%(levelname)s] [%(request_id)s] %(message)s')
+    # 使用 JSON 格式化器
+    formatter = JSONFormatter()
     console_handler.setFormatter(formatter)
 
     # 为当前记录器添加处理器
@@ -181,26 +183,31 @@ class AsyncTamarModelClient:
                 # 对于取消的情况进行指数退避重试
                 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}...")
+                    logger.info(f"❌ RPC cancelled, retrying {retry_count}/{self.max_retries}...",
+                                 extra={"log_type": "info", "data": {"retry_count": retry_count, "max_retries": self.max_retries, "error_code": "CANCELLED"}})
                     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")
+                        logger.error("❌ Max retry reached for CANCELLED",
+                                   extra={"log_type": "info", "data": {"error_code": "CANCELLED", "max_retries_reached": True}})
                         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}...")
+                    logger.info(f"❌ gRPC error {e.code()}, retrying {retry_count}/{self.max_retries}...",
+                                 extra={"log_type": "info", "data": {"retry_count": retry_count, "max_retries": self.max_retries, "error_code": str(e.code())}})
                     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()}")
+                        logger.error(f"❌ Max retry reached for {e.code()}",
+                                   extra={"log_type": "info", "data": {"error_code": str(e.code()), "max_retries_reached": True}})
                         raise
                 else:
-                    logger.error(f"❌ Non-retryable gRPC error: {e}", exc_info=True)
+                    logger.error(f"❌ Non-retryable gRPC error: {e}", exc_info=True,
+                               extra={"log_type": "info", "data": {"error_code": str(e.code()) if hasattr(e, 'code') else None, "retryable": False}})
                     raise
 
     async def _retry_request_stream(self, func, *args, **kwargs):
@@ -212,26 +219,31 @@ class AsyncTamarModelClient:
                 # 对于取消的情况进行指数退避重试
                 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}...")
+                    logger.info(f"❌ RPC cancelled, retrying {retry_count}/{self.max_retries}...",
+                                 extra={"log_type": "info", "data": {"retry_count": retry_count, "max_retries": self.max_retries, "error_code": "CANCELLED"}})
                     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")
+                        logger.error("❌ Max retry reached for CANCELLED",
+                                   extra={"log_type": "info", "data": {"error_code": "CANCELLED", "max_retries_reached": True}})
                         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}...")
+                    logger.info(f"❌ gRPC error {e.code()}, retrying {retry_count}/{self.max_retries}...",
+                                 extra={"log_type": "info", "data": {"retry_count": retry_count, "max_retries": self.max_retries, "error_code": str(e.code())}})
                     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()}")
+                        logger.error(f"❌ Max retry reached for {e.code()}",
+                                   extra={"log_type": "info", "data": {"error_code": str(e.code()), "max_retries_reached": True}})
                         raise
                 else:
-                    logger.error(f"❌ Non-retryable gRPC error: {e}", exc_info=True)
+                    logger.error(f"❌ Non-retryable gRPC error: {e}", exc_info=True,
+                               extra={"log_type": "info", "data": {"error_code": str(e.code()) if hasattr(e, 'code') else None, "retryable": False}})
                     raise
 
     def _build_auth_metadata(self, request_id: str) -> list:
@@ -266,32 +278,40 @@ class AsyncTamarModelClient:
                         credentials,
                         options=options
                     )
-                    logger.info("🔐 Using secure gRPC channel (TLS enabled)")
+                    logger.info("🔐 Using secure gRPC channel (TLS enabled)",
+                              extra={"log_type": "info", "data": {"tls_enabled": True, "server_address": self.server_address}})
                 else:
                     self.channel = grpc.aio.insecure_channel(
                         self.server_address,
                         options=options
                     )
-                    logger.info("🔓 Using insecure gRPC channel (TLS disabled)")
+                    logger.info("🔓 Using insecure gRPC channel (TLS disabled)",
+                              extra={"log_type": "info", "data": {"tls_enabled": False, "server_address": self.server_address}})
                 await self.channel.channel_ready()
                 self.stub = model_service_pb2_grpc.ModelServiceStub(self.channel)
-                logger.info(f"✅ gRPC channel initialized to {self.server_address}")
+                logger.info(f"✅ gRPC channel initialized to {self.server_address}",
+                          extra={"log_type": "info", "data": {"status": "success", "server_address": self.server_address}})
                 return
             except grpc.FutureTimeoutError as e:
-                logger.error(f"❌ gRPC channel initialization timed out: {str(e)}", exc_info=True)
+                logger.error(f"❌ gRPC channel initialization timed out: {str(e)}", exc_info=True,
+                           extra={"log_type": "info", "data": {"error_type": "timeout", "server_address": self.server_address}})
             except grpc.RpcError as e:
-                logger.error(f"❌ gRPC channel initialization failed: {str(e)}", exc_info=True)
+                logger.error(f"❌ gRPC channel initialization failed: {str(e)}", exc_info=True,
+                           extra={"log_type": "info", "data": {"error_type": "rpc_error", "server_address": self.server_address}})
             except Exception as e:
-                logger.error(f"❌ Unexpected error during channel initialization: {str(e)}", exc_info=True)
+                logger.error(f"❌ Unexpected error during channel initialization: {str(e)}", exc_info=True,
+                           extra={"log_type": "info", "data": {"error_type": "unexpected", "server_address": self.server_address}})
 
             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)
+                logger.error(f"❌ Failed to initialize gRPC channel after {self.max_retries} retries.", exc_info=True,
+                           extra={"log_type": "info", "data": {"max_retries_reached": True, "server_address": self.server_address}})
                 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...")
+            logger.info(f"🚀 Retrying connection (attempt {retry_count}/{self.max_retries}) after {delay:.2f}s delay...",
+                      extra={"log_type": "info", "data": {"retry_count": retry_count, "max_retries": self.max_retries, "delay": delay}})
             await asyncio.sleep(delay)
 
     async def _stream(self, request, metadata, invoke_timeout) -> AsyncIterator[ModelResponse]:
@@ -303,6 +323,66 @@ class AsyncTamarModelClient:
                 raw_response=json.loads(response.raw_response) if response.raw_response else None,
                 request_id=response.request_id if response.request_id else None,
             )
+    
+    async def _stream_with_logging(self, request, metadata, invoke_timeout, start_time, model_request) -> AsyncIterator[ModelResponse]:
+        """流式响应的包装器，用于记录完整的响应日志"""
+        total_content = ""
+        final_usage = None
+        error_occurred = None
+        chunk_count = 0
+        
+        try:
+            async for response in self._stream(request, metadata, invoke_timeout):
+                chunk_count += 1
+                if response.content:
+                    total_content += response.content
+                if response.usage:
+                    final_usage = response.usage
+                if response.error:
+                    error_occurred = response.error
+                yield response
+            
+            # 流式响应完成，记录成功日志
+            duration = time.time() - start_time
+            logger.info(
+                f"✅ Stream completed successfully | chunks: {chunk_count}",
+                extra={
+                    "log_type": "response",
+                    "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                    "duration": duration,
+                    "data": {
+                        "provider": model_request.provider.value,
+                        "invoke_type": model_request.invoke_type.value,
+                        "model": model_request.model,
+                        "stream": True,
+                        "chunks_count": chunk_count,
+                        "total_length": len(total_content),
+                        "usage": final_usage
+                    }
+                }
+            )
+        except Exception as e:
+            # 流式响应出错，记录错误日志
+            duration = time.time() - start_time
+            logger.error(
+                f"❌ Stream failed after {chunk_count} chunks: {str(e)}",
+                exc_info=True,
+                extra={
+                    "log_type": "response",
+                    "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                    "duration": duration,
+                    "data": {
+                        "provider": model_request.provider.value,
+                        "invoke_type": model_request.invoke_type.value,
+                        "model": model_request.model,
+                        "stream": True,
+                        "chunks_count": chunk_count,
+                        "error_type": type(e).__name__,
+                        "partial_content_length": len(total_content)
+                    }
+                }
+            )
+            raise
 
     async def _invoke_request(self, request, metadata, invoke_timeout):
         async for response in self.stub.Invoke(request, metadata=metadata, timeout=invoke_timeout):
@@ -345,8 +425,22 @@ class AsyncTamarModelClient:
         metadata = self._build_auth_metadata(request_id)  # 将 request_id 加入到请求头
 
         # 记录开始日志
+        start_time = time.time()
         logger.info(
-            f"🔵 Request Start | request_id: {request_id} | provider: {model_request.provider} | invoke_type: {model_request.invoke_type} | model_request: {model_request}")
+            f"🔵 Request Start | request_id: {request_id} | provider: {model_request.provider} | invoke_type: {model_request.invoke_type}",
+            extra={
+                "log_type": "request",
+                "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                "data": {
+                    "provider": model_request.provider.value,
+                    "invoke_type": model_request.invoke_type.value,
+                    "model": model_request.model,
+                    "stream": model_request.stream,
+                    "org_id": model_request.user_context.org_id,
+                    "user_id": model_request.user_context.user_id,
+                    "client_type": model_request.user_context.client_type
+                }
+            })
 
         # 动态根据 provider/invoke_type 决定使用哪个 input 字段
         try:
@@ -363,6 +457,8 @@ class AsyncTamarModelClient:
                     allowed_fields = OpenAIChatCompletionsInput.model_fields.keys()
                 case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.IMAGE_GENERATION):
                     allowed_fields = OpenAIImagesInput.model_fields.keys()
+                case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.IMAGE_EDIT_GENERATION):
+                    allowed_fields = OpenAIImagesEditInput.model_fields.keys()
                 case _:
                     raise ValueError(
                         f"Unsupported provider/invoke_type combination: {model_request.provider} + {model_request.invoke_type}")
@@ -402,16 +498,63 @@ class AsyncTamarModelClient:
         try:
             invoke_timeout = timeout or self.default_invoke_timeout
             if model_request.stream:
-                return await self._retry_request_stream(self._stream, request, metadata, invoke_timeout)
+                # 对于流式响应，使用带日志记录的包装器
+                stream_generator = await self._retry_request_stream(self._stream, request, metadata, invoke_timeout)
+                return self._stream_with_logging(request, metadata, invoke_timeout, start_time, model_request)
             else:
-                return await self._retry_request(self._invoke_request, request, metadata, invoke_timeout)
+                result = await self._retry_request(self._invoke_request, request, metadata, invoke_timeout)
+                
+                # 记录非流式响应的成功日志
+                duration = time.time() - start_time
+                logger.info(
+                    f"✅ Request completed successfully",
+                    extra={
+                        "log_type": "response",
+                        "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                        "duration": duration,
+                        "data": {
+                            "provider": model_request.provider.value,
+                            "invoke_type": model_request.invoke_type.value,
+                            "model": model_request.model,
+                            "stream": False,
+                            "content_length": len(result.content) if result.content else 0,
+                            "usage": result.usage
+                        }
+                    }
+                )
+                return result
         except grpc.RpcError as e:
+            duration = time.time() - start_time
             error_message = f"❌ Invoke gRPC failed: {str(e)}"
-            logger.error(error_message, exc_info=True)
+            logger.error(error_message, exc_info=True,
+                       extra={
+                           "log_type": "response",
+                           "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                           "duration": duration,
+                           "data": {
+                               "error_type": "grpc_error",
+                               "error_code": str(e.code()) if hasattr(e, 'code') else None,
+                               "provider": model_request.provider.value,
+                               "invoke_type": model_request.invoke_type.value,
+                               "model": model_request.model
+                           }
+                       })
             raise e
         except Exception as e:
+            duration = time.time() - start_time
             error_message = f"❌ Invoke other error: {str(e)}"
-            logger.error(error_message, exc_info=True)
+            logger.error(error_message, exc_info=True,
+                       extra={
+                           "log_type": "response",
+                           "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                           "duration": duration,
+                           "data": {
+                               "error_type": "other_error",
+                               "provider": model_request.provider.value,
+                               "invoke_type": model_request.invoke_type.value,
+                               "model": model_request.model
+                           }
+                       })
             raise e
 
     async def invoke_batch(self, batch_request_model: BatchModelRequest, timeout: Optional[float] = None,
@@ -442,8 +585,19 @@ class AsyncTamarModelClient:
         metadata = self._build_auth_metadata(request_id)  # 将 request_id 加入到请求头
 
         # 记录开始日志
+        start_time = time.time()
         logger.info(
-            f"🔵 Batch Request Start | request_id: {request_id} | batch_size: {len(batch_request_model.items)} | batch_request_model: {batch_request_model}")
+            f"🔵 Batch Request Start | request_id: {request_id} | batch_size: {len(batch_request_model.items)}",
+            extra={
+                "log_type": "request",
+                "uri": "/batch_invoke",
+                "data": {
+                    "batch_size": len(batch_request_model.items),
+                    "org_id": batch_request_model.user_context.org_id,
+                    "user_id": batch_request_model.user_context.user_id,
+                    "client_type": batch_request_model.user_context.client_type
+                }
+            })
 
         # 构造批量请求
         items = []
@@ -461,6 +615,8 @@ class AsyncTamarModelClient:
                         allowed_fields = OpenAIChatCompletionsInput.model_fields.keys()
                     case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.IMAGE_GENERATION):
                         allowed_fields = OpenAIImagesInput.model_fields.keys()
+                    case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.IMAGE_EDIT_GENERATION):
+                        allowed_fields = OpenAIImagesEditInput.model_fields.keys()
                     case _:
                         raise ValueError(
                             f"Unsupported provider/invoke_type combination: {model_request_item.provider} + {model_request_item.invoke_type}")
@@ -516,17 +672,54 @@ class AsyncTamarModelClient:
                     error=res_item.error or None,
                     custom_id=res_item.custom_id if res_item.custom_id else None
                 ))
-            return BatchModelResponse(
+            batch_response = BatchModelResponse(
                 request_id=response.request_id if response.request_id else None,
                 responses=result
             )
+            
+            # 记录成功日志
+            duration = time.time() - start_time
+            logger.info(
+                f"✅ Batch request completed successfully",
+                extra={
+                    "log_type": "response",
+                    "uri": "/batch_invoke",
+                    "duration": duration,
+                    "data": {
+                        "batch_size": len(batch_request_model.items),
+                        "responses_count": len(result)
+                    }
+                }
+            )
+            return batch_response
         except grpc.RpcError as e:
+            duration = time.time() - start_time
             error_message = f"❌ BatchInvoke gRPC failed: {str(e)}"
-            logger.error(error_message, exc_info=True)
+            logger.error(error_message, exc_info=True,
+                       extra={
+                           "log_type": "response",
+                           "uri": "/batch_invoke",
+                           "duration": duration,
+                           "data": {
+                               "error_type": "grpc_error",
+                               "error_code": str(e.code()) if hasattr(e, 'code') else None,
+                               "batch_size": len(batch_request_model.items)
+                           }
+                       })
             raise e
         except Exception as e:
+            duration = time.time() - start_time
             error_message = f"❌ BatchInvoke other error: {str(e)}"
-            logger.error(error_message, exc_info=True)
+            logger.error(error_message, exc_info=True,
+                       extra={
+                           "log_type": "response",
+                           "uri": "/batch_invoke",
+                           "duration": duration,
+                           "data": {
+                               "error_type": "other_error",
+                               "batch_size": len(batch_request_model.items)
+                           }
+                       })
             raise e
 
     async def close(self):
@@ -534,7 +727,8 @@ class AsyncTamarModelClient:
         if self.channel and not self._closed:
             await self.channel.close()
             self._closed = True
-            logger.info("✅ gRPC channel closed")
+            logger.info("✅ gRPC channel closed",
+                      extra={"log_type": "info", "data": {"status": "success"}})
 
     def _safe_sync_close(self):
         """进程退出时自动关闭 channel（事件循环处理兼容）"""
@@ -546,7 +740,8 @@ class AsyncTamarModelClient:
                 else:
                     loop.run_until_complete(self.close())
             except Exception as e:
-                logger.warning(f"❌ gRPC channel close failed at exit: {e}")
+                logger.info(f"❌ gRPC channel close failed at exit: {e}",
+                             extra={"log_type": "info", "data": {"status": "failed", "error": str(e)}})
 
     async def __aenter__(self):
         """支持 async with 自动初始化连接"""

tamar_model_client/enums/invoke.py

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

tamar_model_client/json_formatter.py

@@ -0,0 +1,26 @@
+import json
+import logging
+from datetime import datetime
+
+
+class JSONFormatter(logging.Formatter):
+    def format(self, record):
+        # log_type 只能是 request、response 或 info
+        log_type = getattr(record, "log_type", "info")
+        if log_type not in ["request", "response", "info"]:
+            log_type = "info"
+            
+        log_data = {
+            "timestamp": datetime.fromtimestamp(record.created).isoformat(),
+            "level": record.levelname,
+            "type": log_type,
+            "uri": getattr(record, "uri", None),
+            "request_id": getattr(record, "request_id", None),
+            "data": getattr(record, "data", None),
+            "message": record.getMessage(),
+            "duration": getattr(record, "duration", None),
+        }
+        # 增加 trace 支持
+        if hasattr(record, "trace"):
+            log_data["trace"] = getattr(record, "trace")
+        return json.dumps(log_data, ensure_ascii=False)

tamar_model_client/schemas/inputs.py

@@ -1,18 +1,22 @@
+import mimetypes
+import os
+
 import httpx
 from google.genai import types
 from openai import NotGiven, NOT_GIVEN
-from openai._types import Headers, Query, Body
+from openai._types import Headers, Query, Body, FileTypes
 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 pydantic import BaseModel, model_validator, field_validator
+from typing import List, Optional, Union, Iterable, Dict, Literal, IO
 
 from tamar_model_client.enums import ProviderType, InvokeType
 from tamar_model_client.enums.channel import Channel
+from tamar_model_client.utils import convert_file_field, validate_fields_by_provider_and_invoke_type
 
 
 class UserContext(BaseModel):
@@ -149,6 +153,29 @@ class OpenAIImagesInput(BaseModel):
     }
 
 
+class OpenAIImagesEditInput(BaseModel):
+    image: Union[FileTypes, List[FileTypes]]
+    prompt: str
+    background: Optional[Literal["transparent", "opaque", "auto"]] | NotGiven = NOT_GIVEN
+    mask: FileTypes | NotGiven = NOT_GIVEN
+    model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN
+    n: Optional[int] | NotGiven = NOT_GIVEN
+    quality: Optional[Literal["standard", "low", "medium", "high", "auto"]] | NotGiven = NOT_GIVEN
+    response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN
+    size: Optional[Literal["256x256", "512x512", "1024x1024", "1536x1024", "1024x1536", "auto"]] | NotGiven = NOT_GIVEN
+    user: str | NotGiven = NOT_GIVEN
+    # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+    # The extra values given here take precedence over values defined on the client or passed to this method.
+    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
@@ -212,8 +239,11 @@ class ModelRequestInput(BaseRequest):
     contents: Optional[Union[types.ContentListUnion, types.ContentListUnionDict]] = None
     config: Optional[types.GenerateContentConfigOrDict] = None
 
-    # OpenAIImagesInput + GoogleVertexAIImagesInput 合并字段
+    # OpenAIImagesInput + OpenAIImagesEditInput + GoogleVertexAIImagesInput 合并字段
+    image: Optional[Union[FileTypes, List[FileTypes]]] = None
     prompt: Optional[str] = None
+    background: Optional[Literal["transparent", "opaque", "auto"]] | NotGiven = NOT_GIVEN
+    mask: FileTypes | NotGiven = NOT_GIVEN
     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
@@ -223,7 +253,8 @@ class ModelRequestInput(BaseRequest):
     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
+    size: Optional[Literal[
+        "auto", "1024x1024", "1536x1024", "1024x1536", "256x256", "512x512", "1792x1024", "1024x1792"]] | NotGiven = NOT_GIVEN
     style: Optional[Literal["vivid", "natural"]] | NotGiven = NOT_GIVEN
     number_of_images: Optional[int] = None  # Google 用法
 
@@ -231,71 +262,26 @@ class ModelRequestInput(BaseRequest):
         "arbitrary_types_allowed": True
     }
 
+    @field_validator("image", mode="before")
+    @classmethod
+    def validate_image(cls, v):
+        return convert_file_field(v)
+
+    @field_validator("mask", mode="before")
+    @classmethod
+    def validate_mask(cls, v):
+        return convert_file_field(v)
+
 
 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
+        return validate_fields_by_provider_and_invoke_type(
+            instance=self,
+            extra_allowed_fields={"provider", "channel", "invoke_type", "user_context"},
+        )
 
 
 class BatchModelRequestItem(ModelRequestInput):
@@ -304,65 +290,10 @@ class BatchModelRequestItem(ModelRequestInput):
 
     @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", "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())
-        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
+        return validate_fields_by_provider_and_invoke_type(
+            instance=self,
+            extra_allowed_fields={"provider", "channel", "invoke_type", "user_context", "custom_id"},
+        )
 
 
 class BatchModelRequest(BaseModel):

tamar_model_client/sync_client.py

@@ -17,7 +17,8 @@ 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
+    OpenAIChatCompletionsInput, OpenAIImagesInput, OpenAIImagesEditInput, BatchModelRequest, ModelRequest
+from .json_formatter import JSONFormatter
 
 logger = logging.getLogger(__name__)
 
@@ -37,8 +38,8 @@ if not logger.hasHandlers():
     # 创建日志处理器，输出到控制台
     console_handler = logging.StreamHandler()
 
-    # 设置日志格式
-    formatter = logging.Formatter('%(asctime)s [%(levelname)s] [%(request_id)s] %(message)s')
+    # 使用 JSON 格式化器
+    formatter = JSONFormatter()
     console_handler.setFormatter(formatter)
 
     # 为当前记录器添加处理器
@@ -175,15 +176,18 @@ class TamarModelClient:
             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}...")
+                    logger.info(f"❌ gRPC error {e.code()}, retrying {retry_count}/{self.max_retries}...",
+                                 extra={"log_type": "info", "data": {"retry_count": retry_count, "max_retries": self.max_retries, "error_code": str(e.code())}})
                     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()}")
+                        logger.error(f"❌ Max retry reached for {e.code()}",
+                                   extra={"log_type": "info", "data": {"error_code": str(e.code()), "max_retries_reached": True}})
                         raise
                 else:
-                    logger.error(f"❌ Non-retryable gRPC error: {e}", exc_info=True)
+                    logger.error(f"❌ Non-retryable gRPC error: {e}", exc_info=True,
+                               extra={"log_type": "info", "data": {"error_code": str(e.code()) if hasattr(e, 'code') else None, "retryable": False}})
                     raise
 
     def _build_auth_metadata(self, request_id: str) -> list:
@@ -216,35 +220,43 @@ class TamarModelClient:
                         credentials,
                         options=options
                     )
-                    logger.info("🔐 Using secure gRPC channel (TLS enabled)")
+                    logger.info("🔐 Using secure gRPC channel (TLS enabled)",
+                              extra={"log_type": "info", "data": {"tls_enabled": True, "server_address": self.server_address}})
                 else:
                     self.channel = grpc.insecure_channel(
                         self.server_address,
                         options=options
                     )
-                    logger.info("🔓 Using insecure gRPC channel (TLS disabled)")
+                    logger.info("🔓 Using insecure gRPC channel (TLS disabled)",
+                              extra={"log_type": "info", "data": {"tls_enabled": False, "server_address": self.server_address}})
 
                 # 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}")
+                logger.info(f"✅ gRPC channel initialized to {self.server_address}",
+                          extra={"log_type": "info", "data": {"status": "success", "server_address": self.server_address}})
                 return
             except grpc.FutureTimeoutError as e:
-                logger.error(f"❌ gRPC channel initialization timed out: {str(e)}", exc_info=True)
+                logger.error(f"❌ gRPC channel initialization timed out: {str(e)}", exc_info=True,
+                           extra={"log_type": "info", "data": {"error_type": "timeout", "server_address": self.server_address}})
             except grpc.RpcError as e:
-                logger.error(f"❌ gRPC channel initialization failed: {str(e)}", exc_info=True)
+                logger.error(f"❌ gRPC channel initialization failed: {str(e)}", exc_info=True,
+                           extra={"log_type": "info", "data": {"error_type": "rpc_error", "server_address": self.server_address}})
             except Exception as e:
-                logger.error(f"❌ Unexpected error during channel initialization: {str(e)}", exc_info=True)
+                logger.error(f"❌ Unexpected error during channel initialization: {str(e)}", exc_info=True,
+                           extra={"log_type": "info", "data": {"error_type": "unexpected", "server_address": self.server_address}})
 
             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)
+                logger.error(f"❌ Failed to initialize gRPC channel after {self.max_retries} retries.", exc_info=True,
+                           extra={"log_type": "info", "data": {"max_retries_reached": True, "server_address": self.server_address}})
                 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...")
+            logger.info(f"🚀 Retrying connection (attempt {retry_count}/{self.max_retries}) after {delay:.2f}s delay...",
+                      extra={"log_type": "info", "data": {"retry_count": retry_count, "max_retries": self.max_retries, "delay": delay}})
             time.sleep(delay)  # Blocking sleep in sync version
 
     def _stream(self, request, metadata, invoke_timeout) -> Iterator[ModelResponse]:
@@ -256,6 +268,66 @@ class TamarModelClient:
                 raw_response=json.loads(response.raw_response) if response.raw_response else None,
                 request_id=response.request_id if response.request_id else None,
             )
+    
+    def _stream_with_logging(self, request, metadata, invoke_timeout, start_time, model_request) -> Iterator[ModelResponse]:
+        """流式响应的包装器，用于记录完整的响应日志"""
+        total_content = ""
+        final_usage = None
+        error_occurred = None
+        chunk_count = 0
+        
+        try:
+            for response in self._stream(request, metadata, invoke_timeout):
+                chunk_count += 1
+                if response.content:
+                    total_content += response.content
+                if response.usage:
+                    final_usage = response.usage
+                if response.error:
+                    error_occurred = response.error
+                yield response
+            
+            # 流式响应完成，记录成功日志
+            duration = time.time() - start_time
+            logger.info(
+                f"✅ Stream completed successfully | chunks: {chunk_count}",
+                extra={
+                    "log_type": "response",
+                    "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                    "duration": duration,
+                    "data": {
+                        "provider": model_request.provider.value,
+                        "invoke_type": model_request.invoke_type.value,
+                        "model": model_request.model,
+                        "stream": True,
+                        "chunks_count": chunk_count,
+                        "total_length": len(total_content),
+                        "usage": final_usage
+                    }
+                }
+            )
+        except Exception as e:
+            # 流式响应出错，记录错误日志
+            duration = time.time() - start_time
+            logger.error(
+                f"❌ Stream failed after {chunk_count} chunks: {str(e)}",
+                exc_info=True,
+                extra={
+                    "log_type": "response",
+                    "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                    "duration": duration,
+                    "data": {
+                        "provider": model_request.provider.value,
+                        "invoke_type": model_request.invoke_type.value,
+                        "model": model_request.model,
+                        "stream": True,
+                        "chunks_count": chunk_count,
+                        "error_type": type(e).__name__,
+                        "partial_content_length": len(total_content)
+                    }
+                }
+            )
+            raise
 
     def _invoke_request(self, request, metadata, invoke_timeout):
         response = self.stub.Invoke(request, metadata=metadata, timeout=invoke_timeout)
@@ -298,8 +370,22 @@ class TamarModelClient:
         metadata = self._build_auth_metadata(request_id)  # 将 request_id 加入到请求头
 
         # 记录开始日志
+        start_time = time.time()
         logger.info(
-            f"🔵 Request Start | request_id: {request_id} | provider: {model_request.provider} | invoke_type: {model_request.invoke_type} | model_request: {model_request}")
+            f"🔵 Request Start | request_id: {request_id} | provider: {model_request.provider} | invoke_type: {model_request.invoke_type}",
+            extra={
+                "log_type": "request",
+                "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                "data": {
+                    "provider": model_request.provider.value,
+                    "invoke_type": model_request.invoke_type.value,
+                    "model": model_request.model,
+                    "stream": model_request.stream,
+                    "org_id": model_request.user_context.org_id,
+                    "user_id": model_request.user_context.user_id,
+                    "client_type": model_request.user_context.client_type
+                }
+            })
 
         # 动态根据 provider/invoke_type 决定使用哪个 input 字段
         try:
@@ -316,6 +402,8 @@ class TamarModelClient:
                     allowed_fields = OpenAIChatCompletionsInput.model_fields.keys()
                 case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.IMAGE_GENERATION):
                     allowed_fields = OpenAIImagesInput.model_fields.keys()
+                case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.IMAGE_EDIT_GENERATION):
+                    allowed_fields = OpenAIImagesEditInput.model_fields.keys()
                 case _:
                     raise ValueError(
                         f"Unsupported provider/invoke_type combination: {model_request.provider} + {model_request.invoke_type}")
@@ -355,16 +443,62 @@ class TamarModelClient:
         try:
             invoke_timeout = timeout or self.default_invoke_timeout
             if model_request.stream:
-                return self._retry_request(self._stream, request, metadata, invoke_timeout)
+                # 对于流式响应，使用带日志记录的包装器
+                return self._stream_with_logging(request, metadata, invoke_timeout, start_time, model_request)
             else:
-                return self._retry_request(self._invoke_request, request, metadata, invoke_timeout)
+                result = self._retry_request(self._invoke_request, request, metadata, invoke_timeout)
+                
+                # 记录非流式响应的成功日志
+                duration = time.time() - start_time
+                logger.info(
+                    f"✅ Request completed successfully",
+                    extra={
+                        "log_type": "response",
+                        "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                        "duration": duration,
+                        "data": {
+                            "provider": model_request.provider.value,
+                            "invoke_type": model_request.invoke_type.value,
+                            "model": model_request.model,
+                            "stream": False,
+                            "content_length": len(result.content) if result.content else 0,
+                            "usage": result.usage
+                        }
+                    }
+                )
+                return result
         except grpc.RpcError as e:
+            duration = time.time() - start_time
             error_message = f"❌ Invoke gRPC failed: {str(e)}"
-            logger.error(error_message, exc_info=True)
+            logger.error(error_message, exc_info=True,
+                       extra={
+                           "log_type": "response",
+                           "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                           "duration": duration,
+                           "data": {
+                               "error_type": "grpc_error",
+                               "error_code": str(e.code()) if hasattr(e, 'code') else None,
+                               "provider": model_request.provider.value,
+                               "invoke_type": model_request.invoke_type.value,
+                               "model": model_request.model
+                           }
+                       })
             raise e
         except Exception as e:
+            duration = time.time() - start_time
             error_message = f"❌ Invoke other error: {str(e)}"
-            logger.error(error_message, exc_info=True)
+            logger.error(error_message, exc_info=True,
+                       extra={
+                           "log_type": "response",
+                           "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                           "duration": duration,
+                           "data": {
+                               "error_type": "other_error",
+                               "provider": model_request.provider.value,
+                               "invoke_type": model_request.invoke_type.value,
+                               "model": model_request.model
+                           }
+                       })
             raise e
 
     def invoke_batch(self, batch_request_model: BatchModelRequest, timeout: Optional[float] = None,
@@ -394,8 +528,19 @@ class TamarModelClient:
         metadata = self._build_auth_metadata(request_id)  # 将 request_id 加入到请求头
 
         # 记录开始日志
+        start_time = time.time()
         logger.info(
-            f"🔵 Batch Request Start | request_id: {request_id} | batch_size: {len(batch_request_model.items)} | batch_request_model: {batch_request_model}")
+            f"🔵 Batch Request Start | request_id: {request_id} | batch_size: {len(batch_request_model.items)}",
+            extra={
+                "log_type": "request",
+                "uri": "/batch_invoke",
+                "data": {
+                    "batch_size": len(batch_request_model.items),
+                    "org_id": batch_request_model.user_context.org_id,
+                    "user_id": batch_request_model.user_context.user_id,
+                    "client_type": batch_request_model.user_context.client_type
+                }
+            })
 
         # 构造批量请求
         items = []
@@ -413,6 +558,8 @@ class TamarModelClient:
                         allowed_fields = OpenAIChatCompletionsInput.model_fields.keys()
                     case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.IMAGE_GENERATION):
                         allowed_fields = OpenAIImagesInput.model_fields.keys()
+                    case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.IMAGE_EDIT_GENERATION):
+                        allowed_fields = OpenAIImagesEditInput.model_fields.keys()
                     case _:
                         raise ValueError(
                             f"Unsupported provider/invoke_type combination: {model_request_item.provider} + {model_request_item.invoke_type}")
@@ -468,17 +615,54 @@ class TamarModelClient:
                     error=res_item.error or None,
                     custom_id=res_item.custom_id if res_item.custom_id else None
                 ))
-            return BatchModelResponse(
+            batch_response = BatchModelResponse(
                 request_id=response.request_id if response.request_id else None,
                 responses=result
             )
+            
+            # 记录成功日志
+            duration = time.time() - start_time
+            logger.info(
+                f"✅ Batch request completed successfully",
+                extra={
+                    "log_type": "response",
+                    "uri": "/batch_invoke",
+                    "duration": duration,
+                    "data": {
+                        "batch_size": len(batch_request_model.items),
+                        "responses_count": len(result)
+                    }
+                }
+            )
+            return batch_response
         except grpc.RpcError as e:
+            duration = time.time() - start_time
             error_message = f"❌ BatchInvoke gRPC failed: {str(e)}"
-            logger.error(error_message, exc_info=True)
+            logger.error(error_message, exc_info=True,
+                       extra={
+                           "log_type": "response",
+                           "uri": "/batch_invoke",
+                           "duration": duration,
+                           "data": {
+                               "error_type": "grpc_error",
+                               "error_code": str(e.code()) if hasattr(e, 'code') else None,
+                               "batch_size": len(batch_request_model.items)
+                           }
+                       })
             raise e
         except Exception as e:
+            duration = time.time() - start_time
             error_message = f"❌ BatchInvoke other error: {str(e)}"
-            logger.error(error_message, exc_info=True)
+            logger.error(error_message, exc_info=True,
+                       extra={
+                           "log_type": "response",
+                           "uri": "/batch_invoke",
+                           "duration": duration,
+                           "data": {
+                               "error_type": "other_error",
+                               "batch_size": len(batch_request_model.items)
+                           }
+                       })
             raise e
 
     def close(self):
@@ -486,7 +670,8 @@ class TamarModelClient:
         if self.channel and not self._closed:
             self.channel.close()
             self._closed = True
-            logger.info("✅ gRPC channel closed")
+            logger.info("✅ gRPC channel closed",
+                      extra={"log_type": "info", "data": {"status": "success"}})
 
     def _safe_sync_close(self):
         """进程退出时自动关闭 channel（事件循环处理兼容）"""
@@ -494,7 +679,8 @@ class TamarModelClient:
             try:
                 self.close()  # 直接调用关闭方法
             except Exception as e:
-                logger.error(f"❌ gRPC channel close failed at exit: {e}")
+                logger.error(f"❌ gRPC channel close failed at exit: {e}",
+                           extra={"log_type": "info", "data": {"status": "failed", "error": str(e)}})
 
     def __enter__(self):
         """同步初始化连接"""

tamar_model_client/utils.py

@@ -0,0 +1,118 @@
+from openai import NotGiven
+from pydantic import BaseModel
+from typing import Any
+import os, mimetypes
+
+def convert_file_field(value: Any) -> Any:
+    def is_file_like(obj):
+        return hasattr(obj, "read") and callable(obj.read)
+
+    def infer_mimetype(filename: str) -> str:
+        mime, _ = mimetypes.guess_type(filename)
+        return mime or "application/octet-stream"
+
+    def convert_item(item):
+        if is_file_like(item):
+            filename = os.path.basename(getattr(item, "name", "file.png"))
+            content_type = infer_mimetype(filename)
+            content = item.read()
+            if hasattr(item, "seek"):
+                item.seek(0)
+            return (filename, content, content_type)
+        elif isinstance(item, tuple):
+            parts = list(item)
+            if len(parts) > 1:
+                maybe_file = parts[1]
+                if is_file_like(maybe_file):
+                    content = maybe_file.read()
+                    if hasattr(maybe_file, "seek"):
+                        maybe_file.seek(0)
+                    parts[1] = content
+                elif not isinstance(maybe_file, (bytes, bytearray)):
+                    raise ValueError(f"Unsupported second element in tuple: {type(maybe_file)}")
+            if len(parts) == 2:
+                parts.append(infer_mimetype(os.path.basename(parts[0] or "file.png")))
+            return tuple(parts)
+        else:
+            return item
+
+    if value is None:
+        return value
+    elif isinstance(value, list):
+        return [convert_item(v) for v in value]
+    else:
+        return convert_item(value)
+
+
+def validate_fields_by_provider_and_invoke_type(
+        instance: BaseModel,
+        extra_allowed_fields: set[str],
+        extra_required_fields: set[str] = set()
+) -> BaseModel:
+    """
+    通用的字段校验逻辑，根据 provider 和 invoke_type 动态检查字段合法性和必填字段。
+    适用于 ModelRequest 和 BatchModelRequestItem。
+    """
+    from tamar_model_client.enums import ProviderType, InvokeType
+    from tamar_model_client.schemas.inputs import GoogleGenAiInput, OpenAIResponsesInput, OpenAIChatCompletionsInput, \
+        OpenAIImagesInput, OpenAIImagesEditInput, GoogleVertexAIImagesInput
+
+    google_allowed = extra_allowed_fields | set(GoogleGenAiInput.model_fields)
+    openai_responses_allowed = extra_allowed_fields | set(OpenAIResponsesInput.model_fields)
+    openai_chat_allowed = extra_allowed_fields | set(OpenAIChatCompletionsInput.model_fields)
+    openai_images_allowed = extra_allowed_fields | set(OpenAIImagesInput.model_fields)
+    openai_images_edit_allowed = extra_allowed_fields | set(OpenAIImagesEditInput.model_fields)
+    google_vertexai_images_allowed = extra_allowed_fields | set(GoogleVertexAIImagesInput.model_fields)
+
+    google_required = {"model", "contents"}
+    google_vertex_required = {"model", "prompt"}
+    openai_resp_required = {"input", "model"}
+    openai_chat_required = {"messages", "model"}
+    openai_img_required = {"prompt"}
+    openai_edit_required = {"image", "prompt"}
+
+    match (instance.provider, instance.invoke_type):
+        case (ProviderType.GOOGLE, InvokeType.GENERATION):
+            allowed = google_allowed
+            required = google_required
+        case (ProviderType.GOOGLE, InvokeType.IMAGE_GENERATION):
+            allowed = google_vertexai_images_allowed
+            required = google_vertex_required
+        case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.RESPONSES | InvokeType.GENERATION):
+            allowed = openai_responses_allowed
+            required = openai_resp_required
+        case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.CHAT_COMPLETIONS):
+            allowed = openai_chat_allowed
+            required = openai_chat_required
+        case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.IMAGE_GENERATION):
+            allowed = openai_images_allowed
+            required = openai_img_required
+        case ((ProviderType.OPENAI | ProviderType.AZURE), InvokeType.IMAGE_EDIT_GENERATION):
+            allowed = openai_images_edit_allowed
+            required = openai_edit_required
+        case _:
+            raise ValueError(f"Unsupported provider/invoke_type: {instance.provider} + {instance.invoke_type}")
+
+    required = required | extra_required_fields
+
+    missing = [f for f in required if getattr(instance, f, None) is None]
+    if missing:
+        raise ValueError(
+            f"Missing required fields for provider={instance.provider} and invoke_type={instance.invoke_type}: {missing}")
+
+    illegal = []
+    valid_fields = {"provider", "channel", "invoke_type"}
+    if getattr(instance, "stream", None) is not None:
+        valid_fields.add("stream")
+
+    for k, v in instance.__dict__.items():
+        if k in valid_fields:
+            continue
+        if k not in allowed and v is not None and not isinstance(v, NotGiven):
+            illegal.append(k)
+
+    if illegal:
+        raise ValueError(
+            f"Unsupported fields for provider={instance.provider} and invoke_type={instance.invoke_type}: {illegal}")
+
+    return instance

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tamar-model-client
-Version: 0.1.16
+Version: 0.1.18
 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.16.dist-info → tamar_model_client-0.1.18.dist-info}/RECORD

@@ -1,19 +1,21 @@
-tamar_model_client/__init__.py,sha256=LMECAuDARWHV1XzH3msoDXcyurS2eihRQmBy26_PUE0,328
-tamar_model_client/async_client.py,sha256=K14GigYdcsHQg83PP1YH3wxxZEUwvFlIFMWdFfegnhc,25655
+tamar_model_client/__init__.py,sha256=gT2OwD5e4nXAZXIXG9QRn3DwwyDZb-LlICU2vBJX7FU,393
+tamar_model_client/async_client.py,sha256=SVRxIRAgVa7Mfm2krxFDUdjcs1W7uwdjlRa-9msIIDg,36810
 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=B4itGuFy1T6g2pnC-95RbaaOqtRIYLeW9eah-CRFRM0,22486
+tamar_model_client/json_formatter.py,sha256=9iO4Qn7FiyPTjcn07uHuP4q80upVlmqI_P1UV12YPxI,991
+tamar_model_client/sync_client.py,sha256=bWPkGMcWE73Qtif0thT1lAtF_Kmtvd6j8KV3Jb-N_T4,32493
+tamar_model_client/utils.py,sha256=Kn6pFz9GEC96H4eejEax66AkzvsrXI3WCSDtgDjnVTI,5238
 tamar_model_client/enums/__init__.py,sha256=3cYYn8ztNGBa_pI_5JGRVYf2QX8fkBVWdjID1PLvoBQ,182
 tamar_model_client/enums/channel.py,sha256=wCzX579nNpTtwzGeS6S3Ls0UzVAgsOlfy4fXMzQTCAw,199
-tamar_model_client/enums/invoke.py,sha256=WufImoN_87ZjGyzYitZkhNNFefWJehKfLtyP-DTBYlA,267
+tamar_model_client/enums/invoke.py,sha256=Up87myAg4-0SDJV5a82ggPDpYHSLEtIco8BF_5Ph1nY,322
 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=RI6wNSmgmylzWPedFfPxx938UzS7kcPR58YTzYshcL8,3066
 tamar_model_client/generated/model_service_pb2_grpc.py,sha256=k4tIbp3XBxdyuOVR18Ung_4SUryONB51UYf_uUEl6V4,5145
 tamar_model_client/schemas/__init__.py,sha256=AxuI-TcvA4OMTj2FtK4wAItvz9LrK_293pu3cmMLE7k,394
-tamar_model_client/schemas/inputs.py,sha256=AlvjTRp_UGnbmqzv4OJ3RjH4UGErzSNfKS8Puj6oEXQ,19088
+tamar_model_client/schemas/inputs.py,sha256=dz1m8NbUIxA99JXZc8WlyzbKpDuz1lEzx3VghC33zYI,14625
 tamar_model_client/schemas/outputs.py,sha256=M_fcqUtXPJnfiLabHlyA8BorlC5pYkf5KLjXO1ysKIQ,1031
-tamar_model_client-0.1.16.dist-info/METADATA,sha256=YaPEPgdIVcJVSZ55rzx-G5TtjHTT0teXJspOz5O3vyE,16562
-tamar_model_client-0.1.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tamar_model_client-0.1.16.dist-info/top_level.txt,sha256=_LfDhPv_fvON0PoZgQuo4M7EjoWtxPRoQOBJziJmip8,19
-tamar_model_client-0.1.16.dist-info/RECORD,,
+tamar_model_client-0.1.18.dist-info/METADATA,sha256=od6DIz8FluOEDUwfst42_pNvwBO1nZUTjWzTDqZJLwo,16562
+tamar_model_client-0.1.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tamar_model_client-0.1.18.dist-info/top_level.txt,sha256=_LfDhPv_fvON0PoZgQuo4M7EjoWtxPRoQOBJziJmip8,19
+tamar_model_client-0.1.18.dist-info/RECORD,,