tamar-model-client 0.1.1__tar.gz → 0.1.3__tar.gz

{tamar_model_client-0.1.1 → tamar_model_client-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tamar-model-client
-Version: 0.1.1
+Version: 0.1.3
 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
@@ -31,9 +31,9 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-# Model Manager Client
+# Tamar Model Client
 
-**Model Manager Client** 是一款高性能的 Python SDK，用于连接 Model Manager gRPC 服务，统一调用多家第三方 AI
+**Tamar Model Client** 是一款高性能的 Python SDK，用于连接 Model Manager gRPC 服务，统一调用多家第三方 AI
 模型服务商（如OpenAI、Google、Azure OpenAI）。
 
 ## ✨ 特性亮点
@@ -58,7 +58,7 @@ pip install tamar-model-client
 ## 🏗️ 项目结构概览
 
 ```
-model_manager_client/
+tamar_model_client/
 ├── generated/                      # gRPC 生成的代码
 │   ├── model_service.proto         # 协议定义文件
 │   ├── model_service_pb2.py        # 生成的 protobuf 代码
@@ -82,16 +82,16 @@ model_manager_client/
 ### 客户端初始化
 
 ```python
-from model_manager_client import ModelManagerClient, AsyncModelManagerClient
+from tamar_model_client import TamarModelClient, AsyncTamarModelClient
 
 # 同步客户端
-client = ModelManagerClient(
+client = TamarModelClient(
     server_address="localhost:50051",
     jwt_token="your-jwt-token"
 )
 
 # 异步客户端
-async_client = AsyncModelManagerClient(
+async_client = AsyncTamarModelClient(
     server_address="localhost:50051",
     jwt_secret_key="your-jwt-secret-key"  # 使用固定密钥自动生成 JWT
 )
@@ -105,12 +105,12 @@ async_client = AsyncModelManagerClient(
 #### OpenAI 调用示例
 
 ```python
-from model_manager_client import ModelManagerClient
-from model_manager_client.schemas import ModelRequest, UserContext
-from model_manager_client.enums import ProviderType, InvokeType, Channel
+from tamar_model_client import TamarModelClient
+from tamar_model_client.schemas import ModelRequest, UserContext
+from tamar_model_client.enums import ProviderType, InvokeType, Channel
 
 # 创建同步客户端
-client = ModelManagerClient()
+client = TamarModelClient()
 
 # OpenAI 调用示例
 request_data = ModelRequest(
@@ -144,12 +144,12 @@ else:
 #### Google 调用示例 （AI Studio / Vertex AI）
 
 ```python
-from model_manager_client import ModelManagerClient
-from model_manager_client.schemas import ModelRequest, UserContext
-from model_manager_client.enums import ProviderType, InvokeType, Channel
+from tamar_model_client import TamarModelClient
+from tamar_model_client.schemas import ModelRequest, UserContext
+from tamar_model_client.enums import ProviderType, InvokeType, Channel
 
 # 创建同步客户端
-client = ModelManagerClient()
+client = TamarModelClient()
 
 # Google AI Studio 调用示例
 request_data = ModelRequest(
@@ -207,12 +207,12 @@ else:
 #### Azure OpenAI 调用示例
 
 ```python
-from model_manager_client import ModelManagerClient
-from model_manager_client.schemas import ModelRequest, UserContext
-from model_manager_client.enums import ProviderType, InvokeType, Channel
+from tamar_model_client import TamarModelClient
+from tamar_model_client.schemas import ModelRequest, UserContext
+from tamar_model_client.enums import ProviderType, InvokeType, Channel
 
 # 创建同步客户端
-client = ModelManagerClient()
+client = TamarModelClient()
 
 # Azure OpenAI 调用示例
 request_data = ModelRequest(
@@ -247,14 +247,14 @@ else:
 
 ```python
 import asyncio
-from model_manager_client import AsyncModelManagerClient
-from model_manager_client.schemas import ModelRequest, UserContext
-from model_manager_client.enums import ProviderType, InvokeType, Channel
+from tamar_model_client import AsyncTamarModelClient
+from tamar_model_client.schemas import ModelRequest, UserContext
+from tamar_model_client.enums import ProviderType, InvokeType, Channel
 
 
 async def main():
     # 创建异步客户端
-    client = AsyncModelManagerClient()
+    client = AsyncTamarModelClient()
 
     # 组装请求参数
     request_data = ModelRequest(
@@ -293,14 +293,14 @@ asyncio.run(main())
 
 ```python
 import asyncio
-from model_manager_client import AsyncModelManagerClient
-from model_manager_client.schemas import ModelRequest, UserContext
-from model_manager_client.enums import ProviderType, InvokeType, Channel
+from tamar_model_client import AsyncTamarModelClient
+from tamar_model_client.schemas import ModelRequest, UserContext
+from tamar_model_client.enums import ProviderType, InvokeType, Channel
 
 
 async def stream_example():
     # 创建异步客户端
-    client = AsyncModelManagerClient()
+    client = AsyncTamarModelClient()
 
     # 组装请求参数
     request_data = ModelRequest(
@@ -340,17 +340,17 @@ asyncio.run(stream_example())
 
 ```python
 import asyncio
-from model_manager_client import AsyncModelManagerClient
-from model_manager_client.schemas import (
+from tamar_model_client import AsyncTamarModelClient
+from tamar_model_client.schemas import (
     BatchModelRequest, BatchModelRequestItem,
     UserContext
 )
-from model_manager_client.enums import ProviderType, InvokeType, Channel
+from tamar_model_client.enums import ProviderType, InvokeType, Channel
 
 
 async def batch_example():
     # 创建异步客户端
-    client = AsyncModelManagerClient()
+    client = AsyncTamarModelClient()
 
     # 组装批量请求参数
     batch_request = BatchModelRequest(
@@ -404,77 +404,48 @@ asyncio.run(batch_example())
 
 ### 文件输入示例
 
-支持处理图像等文件输入（需使用支持多模态的模型，如 gpt-4-vision-preview）：
+支持处理图像等文件输入（需使用支持多模态的模型，如 gemini-2.0-flash）：
 
 ```python
-import asyncio
-from model_manager_client import AsyncModelManagerClient
-from model_manager_client.schemas import ModelRequest, UserContext
-from model_manager_client.enums import ProviderType, InvokeType, Channel
-
-
-async def file_input_example():
-    # 创建异步客户端
-    client = AsyncModelManagerClient()
-
-    # 组装请求参数（包含文件输入）
-    request_data = ModelRequest(
-        provider=ProviderType.OPENAI,
-        channel=Channel.OPENAI,
-        invoke_type=InvokeType.CHAT_COMPLETIONS,
-        model="gpt-4-vision-preview",  # 使用支持图像的模型
-        messages=[
-            {
-                "role": "user",
-                "content": [
-                    {
-                        "type": "image_url",
-                        "image_url": {
-                            "url": "https://example.com/image.jpg"
-                        }
-                    },
-                    {
-                        "type": "text",
-                        "text": "请描述这张图片。"
-                    }
-                ]
-            }
-        ],
-        user_context=UserContext(
-            user_id="test_user",
-            org_id="test_org",
-            client_type="python-sdk"
+from tamar_model_client import TamarModelClient
+from tamar_model_client.schemas import ModelRequest, UserContext
+from tamar_model_client.enums import ProviderType
+from google.genai.types import Part
+model_request = ModelRequest(
+    provider=ProviderType.GOOGLE,  # 选择 Google作为提供商
+    model="gemini-2.0-flash",
+    contents=[
+        "What is shown in this image?",
+        Part.from_uri( # 这个是Google那边的参数支持
+            file_uri="https://images.pexels.com/photos/248797/pexels-photo-248797.jpeg",
+            mime_type="image/jpeg",
         ),
-        stream=False
-    )
-
-    # 发送请求并获取响应
-    response = await client.invoke(request_data)
-    if response.error:
-        print(f"错误: {response.error}")
-    else:
-        print(f"响应: {response.content}")
-        if response.usage:
-            print(f"Token 使用情况: {response.usage}")
-
-
-# 运行文件输入示例
-asyncio.run(file_input_example())
+    ],
+    user_context=UserContext(
+        org_id="testllm",
+        user_id="testllm",
+        client_type="conversation-service"
+    ),
+)
+client = TamarModelClient("localhost:50051")
+response = client.invoke(
+    model_request=model_request
+)
 ```
 
 ### ⚠️ 注意事项
 
-以下是使用 Model Manager Client 时的重要提示：
+以下是使用 Tamar Model Client 时的重要提示：
 
 - **参数处理**
-  - 公共参数包括：**服务商 (provider)**、**渠道 (channel)** 和 **调用方法 (invoke_type)**
+  - 公共参数包括：**服务商 (provider)**、**渠道 (channel)** 、 **调用方法 (invoke_type)** 以及 **用户信息（user_context）**
   - 其中 **channel** 和 **invoke_type** 为可选参数，**建议默认使用系统自动推断**，除非有特殊需求再显式指定
   - 是否流式输出由公共参数 **stream** 控制，其他参数遵循对应服务商官方 SDK 的标准定义
 - **客户端连接管理**
   - gRPC 使用 HTTP/2 长连接，**建议将客户端实例作为单例使用**
-  - 若需创建多个实例，**请务必调用** `client.close()` **方法手动关闭连接**，以防止连接堆积或资源泄露。
+  - 若需创建多个实例，**请务必调用** `client.close()` **方法手动关闭连接**，以防止连接堆积或资源泄露
 - **异常处理**：
-  - 所有接口均提供详细的**错误信息** 以及 **请求ID（request_id）**，业务调用时建议纳入对应日志便于后期排错。
+  - 所有接口均提供详细的**错误信息** 以及 **请求ID（request_id）**，业务调用时建议纳入对应日志便于后期排错
 
 ## ⚙️ 环境变量配置（推荐）
 
@@ -528,9 +499,9 @@ MODEL_MANAGER_SERVER_GRPC_RETRY_DELAY=1.0
 加载后，初始化时无需传参：
 
 ```python
-from model_manager_client import ModelManagerClient
+from tamar_model_client import TamarModelClient
 
-client = ModelManagerClient()  # 将使用环境变量中的配置
+client = TamarModelClient()  # 将使用环境变量中的配置
 ```
 
 ## 开发

{tamar_model_client-0.1.1 → tamar_model_client-0.1.3}/README.md

@@ -1,6 +1,6 @@
-# Model Manager Client
+# Tamar Model Client
 
-**Model Manager Client** 是一款高性能的 Python SDK，用于连接 Model Manager gRPC 服务，统一调用多家第三方 AI
+**Tamar Model Client** 是一款高性能的 Python SDK，用于连接 Model Manager gRPC 服务，统一调用多家第三方 AI
 模型服务商（如OpenAI、Google、Azure OpenAI）。
 
 ## ✨ 特性亮点
@@ -25,7 +25,7 @@ pip install tamar-model-client
 ## 🏗️ 项目结构概览
 
 ```
-model_manager_client/
+tamar_model_client/
 ├── generated/                      # gRPC 生成的代码
 │   ├── model_service.proto         # 协议定义文件
 │   ├── model_service_pb2.py        # 生成的 protobuf 代码
@@ -49,16 +49,16 @@ model_manager_client/
 ### 客户端初始化
 
 ```python
-from model_manager_client import ModelManagerClient, AsyncModelManagerClient
+from tamar_model_client import TamarModelClient, AsyncTamarModelClient
 
 # 同步客户端
-client = ModelManagerClient(
+client = TamarModelClient(
     server_address="localhost:50051",
     jwt_token="your-jwt-token"
 )
 
 # 异步客户端
-async_client = AsyncModelManagerClient(
+async_client = AsyncTamarModelClient(
     server_address="localhost:50051",
     jwt_secret_key="your-jwt-secret-key"  # 使用固定密钥自动生成 JWT
 )
@@ -72,12 +72,12 @@ async_client = AsyncModelManagerClient(
 #### OpenAI 调用示例
 
 ```python
-from model_manager_client import ModelManagerClient
-from model_manager_client.schemas import ModelRequest, UserContext
-from model_manager_client.enums import ProviderType, InvokeType, Channel
+from tamar_model_client import TamarModelClient
+from tamar_model_client.schemas import ModelRequest, UserContext
+from tamar_model_client.enums import ProviderType, InvokeType, Channel
 
 # 创建同步客户端
-client = ModelManagerClient()
+client = TamarModelClient()
 
 # OpenAI 调用示例
 request_data = ModelRequest(
@@ -111,12 +111,12 @@ else:
 #### Google 调用示例 （AI Studio / Vertex AI）
 
 ```python
-from model_manager_client import ModelManagerClient
-from model_manager_client.schemas import ModelRequest, UserContext
-from model_manager_client.enums import ProviderType, InvokeType, Channel
+from tamar_model_client import TamarModelClient
+from tamar_model_client.schemas import ModelRequest, UserContext
+from tamar_model_client.enums import ProviderType, InvokeType, Channel
 
 # 创建同步客户端
-client = ModelManagerClient()
+client = TamarModelClient()
 
 # Google AI Studio 调用示例
 request_data = ModelRequest(
@@ -174,12 +174,12 @@ else:
 #### Azure OpenAI 调用示例
 
 ```python
-from model_manager_client import ModelManagerClient
-from model_manager_client.schemas import ModelRequest, UserContext
-from model_manager_client.enums import ProviderType, InvokeType, Channel
+from tamar_model_client import TamarModelClient
+from tamar_model_client.schemas import ModelRequest, UserContext
+from tamar_model_client.enums import ProviderType, InvokeType, Channel
 
 # 创建同步客户端
-client = ModelManagerClient()
+client = TamarModelClient()
 
 # Azure OpenAI 调用示例
 request_data = ModelRequest(
@@ -214,14 +214,14 @@ else:
 
 ```python
 import asyncio
-from model_manager_client import AsyncModelManagerClient
-from model_manager_client.schemas import ModelRequest, UserContext
-from model_manager_client.enums import ProviderType, InvokeType, Channel
+from tamar_model_client import AsyncTamarModelClient
+from tamar_model_client.schemas import ModelRequest, UserContext
+from tamar_model_client.enums import ProviderType, InvokeType, Channel
 
 
 async def main():
     # 创建异步客户端
-    client = AsyncModelManagerClient()
+    client = AsyncTamarModelClient()
 
     # 组装请求参数
     request_data = ModelRequest(
@@ -260,14 +260,14 @@ asyncio.run(main())
 
 ```python
 import asyncio
-from model_manager_client import AsyncModelManagerClient
-from model_manager_client.schemas import ModelRequest, UserContext
-from model_manager_client.enums import ProviderType, InvokeType, Channel
+from tamar_model_client import AsyncTamarModelClient
+from tamar_model_client.schemas import ModelRequest, UserContext
+from tamar_model_client.enums import ProviderType, InvokeType, Channel
 
 
 async def stream_example():
     # 创建异步客户端
-    client = AsyncModelManagerClient()
+    client = AsyncTamarModelClient()
 
     # 组装请求参数
     request_data = ModelRequest(
@@ -307,17 +307,17 @@ asyncio.run(stream_example())
 
 ```python
 import asyncio
-from model_manager_client import AsyncModelManagerClient
-from model_manager_client.schemas import (
+from tamar_model_client import AsyncTamarModelClient
+from tamar_model_client.schemas import (
     BatchModelRequest, BatchModelRequestItem,
     UserContext
 )
-from model_manager_client.enums import ProviderType, InvokeType, Channel
+from tamar_model_client.enums import ProviderType, InvokeType, Channel
 
 
 async def batch_example():
     # 创建异步客户端
-    client = AsyncModelManagerClient()
+    client = AsyncTamarModelClient()
 
     # 组装批量请求参数
     batch_request = BatchModelRequest(
@@ -371,77 +371,48 @@ asyncio.run(batch_example())
 
 ### 文件输入示例
 
-支持处理图像等文件输入（需使用支持多模态的模型，如 gpt-4-vision-preview）：
+支持处理图像等文件输入（需使用支持多模态的模型，如 gemini-2.0-flash）：
 
 ```python
-import asyncio
-from model_manager_client import AsyncModelManagerClient
-from model_manager_client.schemas import ModelRequest, UserContext
-from model_manager_client.enums import ProviderType, InvokeType, Channel
-
-
-async def file_input_example():
-    # 创建异步客户端
-    client = AsyncModelManagerClient()
-
-    # 组装请求参数（包含文件输入）
-    request_data = ModelRequest(
-        provider=ProviderType.OPENAI,
-        channel=Channel.OPENAI,
-        invoke_type=InvokeType.CHAT_COMPLETIONS,
-        model="gpt-4-vision-preview",  # 使用支持图像的模型
-        messages=[
-            {
-                "role": "user",
-                "content": [
-                    {
-                        "type": "image_url",
-                        "image_url": {
-                            "url": "https://example.com/image.jpg"
-                        }
-                    },
-                    {
-                        "type": "text",
-                        "text": "请描述这张图片。"
-                    }
-                ]
-            }
-        ],
-        user_context=UserContext(
-            user_id="test_user",
-            org_id="test_org",
-            client_type="python-sdk"
+from tamar_model_client import TamarModelClient
+from tamar_model_client.schemas import ModelRequest, UserContext
+from tamar_model_client.enums import ProviderType
+from google.genai.types import Part
+model_request = ModelRequest(
+    provider=ProviderType.GOOGLE,  # 选择 Google作为提供商
+    model="gemini-2.0-flash",
+    contents=[
+        "What is shown in this image?",
+        Part.from_uri( # 这个是Google那边的参数支持
+            file_uri="https://images.pexels.com/photos/248797/pexels-photo-248797.jpeg",
+            mime_type="image/jpeg",
         ),
-        stream=False
-    )
-
-    # 发送请求并获取响应
-    response = await client.invoke(request_data)
-    if response.error:
-        print(f"错误: {response.error}")
-    else:
-        print(f"响应: {response.content}")
-        if response.usage:
-            print(f"Token 使用情况: {response.usage}")
-
-
-# 运行文件输入示例
-asyncio.run(file_input_example())
+    ],
+    user_context=UserContext(
+        org_id="testllm",
+        user_id="testllm",
+        client_type="conversation-service"
+    ),
+)
+client = TamarModelClient("localhost:50051")
+response = client.invoke(
+    model_request=model_request
+)
 ```
 
 ### ⚠️ 注意事项
 
-以下是使用 Model Manager Client 时的重要提示：
+以下是使用 Tamar Model Client 时的重要提示：
 
 - **参数处理**
-  - 公共参数包括：**服务商 (provider)**、**渠道 (channel)** 和 **调用方法 (invoke_type)**
+  - 公共参数包括：**服务商 (provider)**、**渠道 (channel)** 、 **调用方法 (invoke_type)** 以及 **用户信息（user_context）**
   - 其中 **channel** 和 **invoke_type** 为可选参数，**建议默认使用系统自动推断**，除非有特殊需求再显式指定
   - 是否流式输出由公共参数 **stream** 控制，其他参数遵循对应服务商官方 SDK 的标准定义
 - **客户端连接管理**
   - gRPC 使用 HTTP/2 长连接，**建议将客户端实例作为单例使用**
-  - 若需创建多个实例，**请务必调用** `client.close()` **方法手动关闭连接**，以防止连接堆积或资源泄露。
+  - 若需创建多个实例，**请务必调用** `client.close()` **方法手动关闭连接**，以防止连接堆积或资源泄露
 - **异常处理**：
-  - 所有接口均提供详细的**错误信息** 以及 **请求ID（request_id）**，业务调用时建议纳入对应日志便于后期排错。
+  - 所有接口均提供详细的**错误信息** 以及 **请求ID（request_id）**，业务调用时建议纳入对应日志便于后期排错
 
 ## ⚙️ 环境变量配置（推荐）
 
@@ -495,9 +466,9 @@ MODEL_MANAGER_SERVER_GRPC_RETRY_DELAY=1.0
 加载后，初始化时无需传参：
 
 ```python
-from model_manager_client import ModelManagerClient
+from tamar_model_client import TamarModelClient
 
-client = ModelManagerClient()  # 将使用环境变量中的配置
+client = TamarModelClient()  # 将使用环境变量中的配置
 ```
 
 ## 开发

{tamar_model_client-0.1.1 → tamar_model_client-0.1.3}/setup.py

@@ -2,14 +2,14 @@ from setuptools import setup, find_packages
 
 setup(
     name="tamar-model-client",
-    version="0.1.1",
+    version="0.1.3",
     description="A Python SDK for interacting with the Model Manager gRPC service",
     author="Oscar Ou",
     author_email="oscar.ou@tamaredge.ai",
     packages=find_packages(),
     include_package_data=True,  # 包含非 .py 文件
     package_data={
-        "model_manager_client": ["generated/*.py"],  # 包含 gRPC 生成文件
+        "tamar_model_client": ["generated/*.py"],  # 包含 gRPC 生成文件
     },
     install_requires=[
         "grpcio",

{tamar_model_client-0.1.1/model_manager_client → tamar_model_client-0.1.3/tamar_model_client}/__init__.py

@@ -1,10 +1,10 @@
-from .sync_client import ModelManagerClient
-from .async_client import AsyncModelManagerClient
+from .sync_client import TamarModelClient
+from .async_client import AsyncTamarModelClient
 from .exceptions import ModelManagerClientError, ConnectionError, ValidationError
 
 __all__ = [
-    "ModelManagerClient",
-    "AsyncModelManagerClient",
+    "TamarModelClient",
+    "AsyncTamarModelClient",
     "ModelManagerClientError",
     "ConnectionError",
     "ValidationError",

{tamar_model_client-0.1.1/model_manager_client → tamar_model_client-0.1.3/tamar_model_client}/async_client.py

@@ -1,5 +1,6 @@
 import asyncio
 import atexit
+import base64
 import json
 import logging
 import os
@@ -27,7 +28,73 @@ if not logging.getLogger().hasHandlers():
 logger = logging.getLogger(__name__)
 
 
-class AsyncModelManagerClient:
+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,
             server_address: Optional[str] = None,
@@ -177,51 +244,15 @@ class AsyncModelManagerClient:
                 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,
@@ -300,51 +331,15 @@ class AsyncModelManagerClient:
                     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-0.1.1/model_manager_client → tamar_model_client-0.1.3/tamar_model_client}/generated/model_service_pb2_grpc.py

@@ -3,7 +3,7 @@
 import grpc
 import warnings
 
-import model_manager_client.generated.model_service_pb2 as model__service__pb2
+import tamar_model_client.generated.model_service_pb2 as model__service__pb2
 
 GRPC_GENERATED_VERSION = '1.71.0'
 GRPC_VERSION = grpc.__version__

{tamar_model_client-0.1.1/model_manager_client → tamar_model_client-0.1.3/tamar_model_client}/schemas/inputs.py

@@ -11,8 +11,8 @@ from openai.types.responses import ResponseInputParam, ResponseIncludable, Respo
 from pydantic import BaseModel, model_validator
 from typing import List, Optional, Union, Iterable, Dict, Literal
 
-from model_manager_client.enums import ProviderType, InvokeType
-from model_manager_client.enums.channel import Channel
+from tamar_model_client.enums import ProviderType, InvokeType
+from tamar_model_client.enums.channel import Channel
 
 
 class UserContext(BaseModel):

{tamar_model_client-0.1.1/model_manager_client → tamar_model_client-0.1.3/tamar_model_client}/sync_client.py

@@ -3,16 +3,16 @@ import atexit
 import logging
 from typing import Optional, Union, Iterator
 
-from .async_client import AsyncModelManagerClient
+from .async_client import AsyncTamarModelClient
 from .schemas import ModelRequest, BatchModelRequest, ModelResponse, BatchModelResponse
 
 logger = logging.getLogger(__name__)
 
 
-class ModelManagerClient:
+class TamarModelClient:
     """
     同步版本的模型管理客户端，用于非异步环境（如 Flask、Django、脚本）。
-    内部封装 AsyncModelManagerClient 并处理事件循环兼容性。
+    内部封装 AsyncTamarModelClient 并处理事件循环兼容性。
     """
     _loop: Optional[asyncio.AbstractEventLoop] = None
 
@@ -27,16 +27,16 @@ class ModelManagerClient:
             retry_delay: float = 1.0,
     ):
         # 初始化全局事件循环，仅创建一次
-        if not ModelManagerClient._loop:
+        if not TamarModelClient._loop:
             try:
-                ModelManagerClient._loop = asyncio.get_running_loop()
+                TamarModelClient._loop = asyncio.get_running_loop()
             except RuntimeError:
-                ModelManagerClient._loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(ModelManagerClient._loop)
+                TamarModelClient._loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(TamarModelClient._loop)
 
-        self._loop = ModelManagerClient._loop
+        self._loop = TamarModelClient._loop
 
-        self._async_client = AsyncModelManagerClient(
+        self._async_client = AsyncTamarModelClient(
             server_address=server_address,
             jwt_secret_key=jwt_secret_key,
             jwt_token=jwt_token,

{tamar_model_client-0.1.1 → tamar_model_client-0.1.3}/tamar_model_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tamar-model-client
-Version: 0.1.1
+Version: 0.1.3
 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
@@ -31,9 +31,9 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-# Model Manager Client
+# Tamar Model Client
 
-**Model Manager Client** 是一款高性能的 Python SDK，用于连接 Model Manager gRPC 服务，统一调用多家第三方 AI
+**Tamar Model Client** 是一款高性能的 Python SDK，用于连接 Model Manager gRPC 服务，统一调用多家第三方 AI
 模型服务商（如OpenAI、Google、Azure OpenAI）。
 
 ## ✨ 特性亮点
@@ -58,7 +58,7 @@ pip install tamar-model-client
 ## 🏗️ 项目结构概览
 
 ```
-model_manager_client/
+tamar_model_client/
 ├── generated/                      # gRPC 生成的代码
 │   ├── model_service.proto         # 协议定义文件
 │   ├── model_service_pb2.py        # 生成的 protobuf 代码
@@ -82,16 +82,16 @@ model_manager_client/
 ### 客户端初始化
 
 ```python
-from model_manager_client import ModelManagerClient, AsyncModelManagerClient
+from tamar_model_client import TamarModelClient, AsyncTamarModelClient
 
 # 同步客户端
-client = ModelManagerClient(
+client = TamarModelClient(
     server_address="localhost:50051",
     jwt_token="your-jwt-token"
 )
 
 # 异步客户端
-async_client = AsyncModelManagerClient(
+async_client = AsyncTamarModelClient(
     server_address="localhost:50051",
     jwt_secret_key="your-jwt-secret-key"  # 使用固定密钥自动生成 JWT
 )
@@ -105,12 +105,12 @@ async_client = AsyncModelManagerClient(
 #### OpenAI 调用示例
 
 ```python
-from model_manager_client import ModelManagerClient
-from model_manager_client.schemas import ModelRequest, UserContext
-from model_manager_client.enums import ProviderType, InvokeType, Channel
+from tamar_model_client import TamarModelClient
+from tamar_model_client.schemas import ModelRequest, UserContext
+from tamar_model_client.enums import ProviderType, InvokeType, Channel
 
 # 创建同步客户端
-client = ModelManagerClient()
+client = TamarModelClient()
 
 # OpenAI 调用示例
 request_data = ModelRequest(
@@ -144,12 +144,12 @@ else:
 #### Google 调用示例 （AI Studio / Vertex AI）
 
 ```python
-from model_manager_client import ModelManagerClient
-from model_manager_client.schemas import ModelRequest, UserContext
-from model_manager_client.enums import ProviderType, InvokeType, Channel
+from tamar_model_client import TamarModelClient
+from tamar_model_client.schemas import ModelRequest, UserContext
+from tamar_model_client.enums import ProviderType, InvokeType, Channel
 
 # 创建同步客户端
-client = ModelManagerClient()
+client = TamarModelClient()
 
 # Google AI Studio 调用示例
 request_data = ModelRequest(
@@ -207,12 +207,12 @@ else:
 #### Azure OpenAI 调用示例
 
 ```python
-from model_manager_client import ModelManagerClient
-from model_manager_client.schemas import ModelRequest, UserContext
-from model_manager_client.enums import ProviderType, InvokeType, Channel
+from tamar_model_client import TamarModelClient
+from tamar_model_client.schemas import ModelRequest, UserContext
+from tamar_model_client.enums import ProviderType, InvokeType, Channel
 
 # 创建同步客户端
-client = ModelManagerClient()
+client = TamarModelClient()
 
 # Azure OpenAI 调用示例
 request_data = ModelRequest(
@@ -247,14 +247,14 @@ else:
 
 ```python
 import asyncio
-from model_manager_client import AsyncModelManagerClient
-from model_manager_client.schemas import ModelRequest, UserContext
-from model_manager_client.enums import ProviderType, InvokeType, Channel
+from tamar_model_client import AsyncTamarModelClient
+from tamar_model_client.schemas import ModelRequest, UserContext
+from tamar_model_client.enums import ProviderType, InvokeType, Channel
 
 
 async def main():
     # 创建异步客户端
-    client = AsyncModelManagerClient()
+    client = AsyncTamarModelClient()
 
     # 组装请求参数
     request_data = ModelRequest(
@@ -293,14 +293,14 @@ asyncio.run(main())
 
 ```python
 import asyncio
-from model_manager_client import AsyncModelManagerClient
-from model_manager_client.schemas import ModelRequest, UserContext
-from model_manager_client.enums import ProviderType, InvokeType, Channel
+from tamar_model_client import AsyncTamarModelClient
+from tamar_model_client.schemas import ModelRequest, UserContext
+from tamar_model_client.enums import ProviderType, InvokeType, Channel
 
 
 async def stream_example():
     # 创建异步客户端
-    client = AsyncModelManagerClient()
+    client = AsyncTamarModelClient()
 
     # 组装请求参数
     request_data = ModelRequest(
@@ -340,17 +340,17 @@ asyncio.run(stream_example())
 
 ```python
 import asyncio
-from model_manager_client import AsyncModelManagerClient
-from model_manager_client.schemas import (
+from tamar_model_client import AsyncTamarModelClient
+from tamar_model_client.schemas import (
     BatchModelRequest, BatchModelRequestItem,
     UserContext
 )
-from model_manager_client.enums import ProviderType, InvokeType, Channel
+from tamar_model_client.enums import ProviderType, InvokeType, Channel
 
 
 async def batch_example():
     # 创建异步客户端
-    client = AsyncModelManagerClient()
+    client = AsyncTamarModelClient()
 
     # 组装批量请求参数
     batch_request = BatchModelRequest(
@@ -404,77 +404,48 @@ asyncio.run(batch_example())
 
 ### 文件输入示例
 
-支持处理图像等文件输入（需使用支持多模态的模型，如 gpt-4-vision-preview）：
+支持处理图像等文件输入（需使用支持多模态的模型，如 gemini-2.0-flash）：
 
 ```python
-import asyncio
-from model_manager_client import AsyncModelManagerClient
-from model_manager_client.schemas import ModelRequest, UserContext
-from model_manager_client.enums import ProviderType, InvokeType, Channel
-
-
-async def file_input_example():
-    # 创建异步客户端
-    client = AsyncModelManagerClient()
-
-    # 组装请求参数（包含文件输入）
-    request_data = ModelRequest(
-        provider=ProviderType.OPENAI,
-        channel=Channel.OPENAI,
-        invoke_type=InvokeType.CHAT_COMPLETIONS,
-        model="gpt-4-vision-preview",  # 使用支持图像的模型
-        messages=[
-            {
-                "role": "user",
-                "content": [
-                    {
-                        "type": "image_url",
-                        "image_url": {
-                            "url": "https://example.com/image.jpg"
-                        }
-                    },
-                    {
-                        "type": "text",
-                        "text": "请描述这张图片。"
-                    }
-                ]
-            }
-        ],
-        user_context=UserContext(
-            user_id="test_user",
-            org_id="test_org",
-            client_type="python-sdk"
+from tamar_model_client import TamarModelClient
+from tamar_model_client.schemas import ModelRequest, UserContext
+from tamar_model_client.enums import ProviderType
+from google.genai.types import Part
+model_request = ModelRequest(
+    provider=ProviderType.GOOGLE,  # 选择 Google作为提供商
+    model="gemini-2.0-flash",
+    contents=[
+        "What is shown in this image?",
+        Part.from_uri( # 这个是Google那边的参数支持
+            file_uri="https://images.pexels.com/photos/248797/pexels-photo-248797.jpeg",
+            mime_type="image/jpeg",
         ),
-        stream=False
-    )
-
-    # 发送请求并获取响应
-    response = await client.invoke(request_data)
-    if response.error:
-        print(f"错误: {response.error}")
-    else:
-        print(f"响应: {response.content}")
-        if response.usage:
-            print(f"Token 使用情况: {response.usage}")
-
-
-# 运行文件输入示例
-asyncio.run(file_input_example())
+    ],
+    user_context=UserContext(
+        org_id="testllm",
+        user_id="testllm",
+        client_type="conversation-service"
+    ),
+)
+client = TamarModelClient("localhost:50051")
+response = client.invoke(
+    model_request=model_request
+)
 ```
 
 ### ⚠️ 注意事项
 
-以下是使用 Model Manager Client 时的重要提示：
+以下是使用 Tamar Model Client 时的重要提示：
 
 - **参数处理**
-  - 公共参数包括：**服务商 (provider)**、**渠道 (channel)** 和 **调用方法 (invoke_type)**
+  - 公共参数包括：**服务商 (provider)**、**渠道 (channel)** 、 **调用方法 (invoke_type)** 以及 **用户信息（user_context）**
   - 其中 **channel** 和 **invoke_type** 为可选参数，**建议默认使用系统自动推断**，除非有特殊需求再显式指定
   - 是否流式输出由公共参数 **stream** 控制，其他参数遵循对应服务商官方 SDK 的标准定义
 - **客户端连接管理**
   - gRPC 使用 HTTP/2 长连接，**建议将客户端实例作为单例使用**
-  - 若需创建多个实例，**请务必调用** `client.close()` **方法手动关闭连接**，以防止连接堆积或资源泄露。
+  - 若需创建多个实例，**请务必调用** `client.close()` **方法手动关闭连接**，以防止连接堆积或资源泄露
 - **异常处理**：
-  - 所有接口均提供详细的**错误信息** 以及 **请求ID（request_id）**，业务调用时建议纳入对应日志便于后期排错。
+  - 所有接口均提供详细的**错误信息** 以及 **请求ID（request_id）**，业务调用时建议纳入对应日志便于后期排错
 
 ## ⚙️ 环境变量配置（推荐）
 
@@ -528,9 +499,9 @@ MODEL_MANAGER_SERVER_GRPC_RETRY_DELAY=1.0
 加载后，初始化时无需传参：
 
 ```python
-from model_manager_client import ModelManagerClient
+from tamar_model_client import TamarModelClient
 
-client = ModelManagerClient()  # 将使用环境变量中的配置
+client = TamarModelClient()  # 将使用环境变量中的配置
 ```
 
 ## 开发

tamar_model_client-0.1.3/tamar_model_client.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+README.md
+setup.py
+tamar_model_client/__init__.py
+tamar_model_client/async_client.py
+tamar_model_client/auth.py
+tamar_model_client/exceptions.py
+tamar_model_client/sync_client.py
+tamar_model_client.egg-info/PKG-INFO
+tamar_model_client.egg-info/SOURCES.txt
+tamar_model_client.egg-info/dependency_links.txt
+tamar_model_client.egg-info/requires.txt
+tamar_model_client.egg-info/top_level.txt
+tamar_model_client/enums/__init__.py
+tamar_model_client/enums/channel.py
+tamar_model_client/enums/invoke.py
+tamar_model_client/enums/providers.py
+tamar_model_client/generated/__init__.py
+tamar_model_client/generated/model_service_pb2.py
+tamar_model_client/generated/model_service_pb2_grpc.py
+tamar_model_client/schemas/__init__.py
+tamar_model_client/schemas/inputs.py
+tamar_model_client/schemas/outputs.py

tamar_model_client-0.1.3/tamar_model_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+tamar_model_client

tamar_model_client-0.1.1/tamar_model_client.egg-info/SOURCES.txt

@@ -1,22 +0,0 @@
-README.md
-setup.py
-model_manager_client/__init__.py
-model_manager_client/async_client.py
-model_manager_client/auth.py
-model_manager_client/exceptions.py
-model_manager_client/sync_client.py
-model_manager_client/enums/__init__.py
-model_manager_client/enums/channel.py
-model_manager_client/enums/invoke.py
-model_manager_client/enums/providers.py
-model_manager_client/generated/__init__.py
-model_manager_client/generated/model_service_pb2.py
-model_manager_client/generated/model_service_pb2_grpc.py
-model_manager_client/schemas/__init__.py
-model_manager_client/schemas/inputs.py
-model_manager_client/schemas/outputs.py
-tamar_model_client.egg-info/PKG-INFO
-tamar_model_client.egg-info/SOURCES.txt
-tamar_model_client.egg-info/dependency_links.txt
-tamar_model_client.egg-info/requires.txt
-tamar_model_client.egg-info/top_level.txt

tamar_model_client-0.1.1/tamar_model_client.egg-info/top_level.txt

@@ -1 +0,0 @@
-model_manager_client