tamar-model-client 0.1.26__py3-none-any.whl → 0.1.28__py3-none-any.whl

tamar_model_client/sync_client.py

@@ -31,8 +31,11 @@ import grpc
 from .core import (
     generate_request_id,
     set_request_id,
+    set_origin_request_id,
     get_protected_logger,
-    MAX_MESSAGE_LENGTH, get_request_id
+    MAX_MESSAGE_LENGTH, 
+    get_request_id,
+    RequestIdManager
 )
 from .core.base_client import BaseClient
 from .core.request_builder import RequestBuilder
@@ -99,6 +102,9 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
         self._channel_error_count = 0
         self._last_channel_error_time = None
         self._channel_lock = threading.Lock()  # 线程安全的channel操作
+        
+        # === Request ID 管理 ===
+        self._request_id_manager = RequestIdManager()
 
     def close(self):
         """
@@ -347,20 +353,15 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
             except grpc.RpcError as e:
                 # 使用新的错误处理逻辑
                 context['retry_count'] = attempt
+                current_duration = time.time() - method_start_time
 
                 # 判断是否可以重试
                 should_retry = self._should_retry(e, attempt)
-                if not should_retry or attempt >= self.max_retries:
-                    # 不可重试或已达到最大重试次数
-                    current_duration = time.time() - method_start_time
-                    context['duration'] = current_duration
-                    last_exception = self.error_handler.handle_error(e, context)
-                    break
-
-                # 计算当前的耗时
-                current_duration = time.time() - method_start_time
                 
-                # 特殊处理 CANCELLED 错误
+                # 记录 channel 错误
+                self._record_channel_error(e)
+                
+                # 特殊处理 CANCELLED 错误的日志
                 if e.code() == grpc.StatusCode.CANCELLED:
                     channel_state = None
                     if self.channel:
@@ -384,7 +385,106 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                         }
                     )
                 
-                # 记录重试日志
+                # 检查是否应该尝试快速降级
+                should_try_fallback = self._should_try_fallback(e.code(), attempt)
+                
+                if should_try_fallback:
+                    # 尝试快速降级到HTTP
+                    logger.warning(
+                        f"🚀 Fast fallback triggered for {e.code().name} after {attempt + 1} attempts",
+                        extra={
+                            "log_type": "fast_fallback",
+                            "request_id": context.get('request_id'),
+                            "data": {
+                                "error_code": e.code().name,
+                                "attempt": attempt,
+                                "fallback_reason": "immediate" if e.code() in self.immediate_fallback_errors else "after_retries"
+                            }
+                        }
+                    )
+                    
+                    try:
+                        # 从 kwargs 中提取降级所需的参数
+                        fallback_kwargs = kwargs.copy()
+                        
+                        # 如果是 _invoke_request，需要提取 model_request
+                        if func.__name__ == '_invoke_request' and len(args) >= 3:
+                            # args 结构: (request, metadata, invoke_timeout)
+                            # 需要从原始参数中恢复 model_request
+                            if hasattr(self, '_current_model_request'):
+                                model_request = self._current_model_request
+                                origin_request_id = getattr(self, '_current_origin_request_id', None)
+                                timeout = args[2] if len(args) > 2 else None
+                                request_id = context.get('request_id')
+                                
+                                # 尝试HTTP降级
+                                result = self._invoke_http_fallback(model_request, timeout, request_id, origin_request_id)
+                        # 如果是 BatchInvoke，需要使用批量降级
+                        elif func.__name__ == 'BatchInvoke' and hasattr(self, '_current_batch_request'):
+                            batch_request = self._current_batch_request
+                            origin_request_id = getattr(self, '_current_origin_request_id', None)
+                            timeout = fallback_kwargs.get('timeout')
+                            request_id = context.get('request_id')
+                            
+                            # 尝试批量HTTP降级
+                            result = self._invoke_batch_http_fallback(batch_request, timeout, request_id, origin_request_id)
+                        else:
+                            # 其他情况，无法处理降级
+                            raise ValueError(f"Unable to perform HTTP fallback for {func.__name__}")
+                                
+                        logger.info(
+                            f"✅ Fast fallback to HTTP succeeded",
+                            extra={
+                                "log_type": "fast_fallback_success",
+                                "request_id": request_id,
+                                "data": {
+                                    "grpc_attempts": attempt + 1,
+                                    "fallback_duration": time.time() - method_start_time
+                                }
+                            }
+                        )
+                        
+                        return result
+                    except Exception as fallback_error:
+                        # 降级失败，记录日志但继续原有重试逻辑
+                        logger.warning(
+                            f"⚠️ Fast fallback to HTTP failed: {str(fallback_error)}",
+                            extra={
+                                "log_type": "fast_fallback_failed",
+                                "request_id": context.get('request_id'),
+                                "data": {
+                                    "fallback_error": str(fallback_error),
+                                    "will_continue_grpc_retry": should_retry and attempt < self.max_retries
+                                }
+                            }
+                        )
+                
+                if not should_retry or attempt >= self.max_retries:
+                    # 不可重试或已达到最大重试次数
+                    context['duration'] = current_duration
+                    
+                    # 记录最终失败日志
+                    log_data = {
+                        "log_type": "info",
+                        "request_id": context.get('request_id'),
+                        "data": {
+                            "error_code": e.code().name if e.code() else 'UNKNOWN',
+                            "retry_count": attempt,
+                            "max_retries": self.max_retries,
+                            "method": context.get('method', 'unknown'),
+                            "final_failure": True
+                        },
+                        "duration": current_duration
+                    }
+                    logger.warning(
+                        f"Final attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()} (no more retries)",
+                        extra=log_data
+                    )
+                    
+                    last_exception = self.error_handler.handle_error(e, context)
+                    break
+                
+                # 可以重试，记录重试日志
                 log_data = {
                     "log_type": "info",
                     "request_id": context.get('request_id'),
@@ -392,12 +492,14 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                         "error_code": e.code().name if e.code() else 'UNKNOWN',
                         "retry_count": attempt,
                         "max_retries": self.max_retries,
-                        "method": context.get('method', 'unknown')
+                        "method": context.get('method', 'unknown'),
+                        "will_retry": True,
+                        "fallback_attempted": should_try_fallback
                     },
                     "duration": current_duration
                 }
                 logger.warning(
-                    f"Attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()}",
+                    f"Attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()} (will retry)",
                     extra=log_data
                 )
 
@@ -405,12 +507,9 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                 if attempt < self.max_retries:
                     delay = self._calculate_backoff(attempt, e.code())
                     time.sleep(delay)
-
-                context['duration'] = current_duration
-                last_exception = self.error_handler.handle_error(e, context)
                 
-                # 记录 channel 错误
-                self._record_channel_error(e)
+                # 保存异常，以备后续使用
+                last_exception = e
 
             except Exception as e:
                 # 非 gRPC 错误，直接包装抛出
@@ -798,7 +897,12 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
         if self.resilient_enabled and self.circuit_breaker and self.circuit_breaker.is_open:
             if self.http_fallback_url:
                 logger.warning("🔻 Circuit breaker is OPEN, using HTTP fallback")
-                return self._invoke_http_fallback(model_request, timeout, request_id)
+                # 在这里还没有计算origin_request_id，所以先计算
+                temp_origin_request_id = None
+                temp_request_id = request_id
+                if request_id:
+                    temp_request_id, temp_origin_request_id = self._request_id_manager.get_composite_id(request_id)
+                return self._invoke_http_fallback(model_request, timeout, temp_request_id, temp_origin_request_id)
                 
         self._ensure_initialized()
 
@@ -808,10 +912,24 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                 "user_id": model_request.user_context.user_id or ""
             }
 
-        if not request_id:
+        # 处理 request_id
+        origin_request_id = None
+        if request_id:
+            # 用户提供了 request_id，生成组合 ID
+            request_id, origin_request_id = self._request_id_manager.get_composite_id(request_id)
+        else:
+            # 没有提供，生成新的
             request_id = generate_request_id()
+            
         set_request_id(request_id)
-        metadata = self._build_auth_metadata(request_id)
+        if origin_request_id:
+            set_origin_request_id(origin_request_id)
+        metadata = self._build_auth_metadata(request_id, origin_request_id)
+
+        # 构建日志数据
+        log_data = ResponseHandler.build_log_data(model_request)
+        if origin_request_id:
+            log_data['origin_request_id'] = origin_request_id
 
         # 记录开始日志
         start_time = time.time()
@@ -820,7 +938,7 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
             extra={
                 "log_type": "request",
                 "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
-                "data": ResponseHandler.build_log_data(model_request)
+                "data": log_data
             })
 
         try:
@@ -857,18 +975,34 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                     request_id=request_id
                 )
             else:
-                result = self._retry_request(self._invoke_request, request, metadata, invoke_timeout, request_id=request_id)
+                # 存储model_request和origin_request_id供重试方法使用
+                self._current_model_request = model_request
+                self._current_origin_request_id = origin_request_id
+                try:
+                    result = self._retry_request(self._invoke_request, request, metadata, invoke_timeout, request_id=request_id)
+                finally:
+                    # 清理临时存储
+                    if hasattr(self, '_current_model_request'):
+                        delattr(self, '_current_model_request')
+                    if hasattr(self, '_current_origin_request_id'):
+                        delattr(self, '_current_origin_request_id')
 
                 # 记录非流式响应的成功日志
                 duration = time.time() - start_time
                 content_length = len(result.content) if result.content else 0
+                
+                # 构建响应日志数据
+                response_log_data = ResponseHandler.build_log_data(model_request, result)
+                if origin_request_id:
+                    response_log_data['origin_request_id'] = origin_request_id
+                    
                 logger.info(
                     f"✅ Request completed | content_length: {content_length}",
                     extra={
                         "log_type": "response",
                         "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
                         "duration": duration,
-                        "data": ResponseHandler.build_log_data(model_request, result)
+                        "data": response_log_data
                     }
                 )
                 
@@ -881,31 +1015,29 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
         except (ConnectionError, grpc.RpcError) as e:
             duration = time.time() - start_time
             error_message = f"❌ Invoke gRPC failed: {str(e)}"
+            
+            # 构建错误日志数据
+            error_log_data = ResponseHandler.build_log_data(model_request, error=e)
+            if origin_request_id:
+                error_log_data['origin_request_id'] = origin_request_id
+                
             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": ResponseHandler.build_log_data(
-                                 model_request,
-                                 error=e
-                             )
+                             "data": error_log_data
                          })
             
             # 记录 channel 错误
             if isinstance(e, grpc.RpcError):
                 self._record_channel_error(e)
             
-            # 记录失败并尝试降级（如果启用了熔断）
+            # 记录失败（如果启用了熔断）
             if self.resilient_enabled and self.circuit_breaker:
                 # 将错误码传递给熔断器，用于智能失败统计
                 error_code = e.code() if hasattr(e, 'code') else None
                 self.circuit_breaker.record_failure(error_code)
-                
-                # 如果可以降级，则降级
-                if self.http_fallback_url and self.circuit_breaker.should_fallback():
-                    logger.warning(f"🔻 gRPC failed, falling back to HTTP: {str(e)}")
-                    return self._invoke_http_fallback(model_request, timeout, request_id)
             
             raise e
         except Exception as e:
@@ -935,6 +1067,17 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
         Returns:
             BatchModelResponse: 批量请求的结果
         """
+        # 如果启用了熔断且熔断器打开，直接走 HTTP
+        if self.resilient_enabled and self.circuit_breaker and self.circuit_breaker.is_open:
+            if self.http_fallback_url:
+                logger.warning("🔻 Circuit breaker is OPEN, using HTTP fallback for batch request")
+                # 在这里还没有计算origin_request_id，所以先计算
+                temp_origin_request_id = None
+                temp_request_id = request_id
+                if request_id:
+                    temp_request_id, temp_origin_request_id = self._request_id_manager.get_composite_id(request_id)
+                return self._invoke_batch_http_fallback(batch_request_model, timeout, temp_request_id, temp_origin_request_id)
+                
         self._ensure_initialized()
 
         if not self.default_payload:
@@ -943,10 +1086,29 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                 "user_id": batch_request_model.user_context.user_id or ""
             }
 
-        if not request_id:
+        # 处理 request_id
+        origin_request_id = None
+        if request_id:
+            # 用户提供了 request_id，生成组合 ID
+            request_id, origin_request_id = self._request_id_manager.get_composite_id(request_id)
+        else:
+            # 没有提供，生成新的
             request_id = generate_request_id()
+            
         set_request_id(request_id)
-        metadata = self._build_auth_metadata(request_id)
+        if origin_request_id:
+            set_origin_request_id(origin_request_id)
+        metadata = self._build_auth_metadata(request_id, origin_request_id)
+
+        # 构建日志数据
+        batch_log_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
+        }
+        if origin_request_id:
+            batch_log_data['origin_request_id'] = origin_request_id
 
         # 记录开始日志
         start_time = time.time()
@@ -955,12 +1117,7 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
             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
-                }
+                "data": batch_log_data
             })
 
         try:
@@ -987,6 +1144,11 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
 
         try:
             invoke_timeout = timeout or self.default_invoke_timeout
+            
+            # 保存批量请求信息用于降级
+            self._current_batch_request = batch_request_model
+            self._current_origin_request_id = origin_request_id
+            
             batch_response = self._retry_request(
                 self.stub.BatchInvoke,
                 batch_request,

{tamar_model_client-0.1.26.dist-info → tamar_model_client-0.1.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tamar-model-client
-Version: 0.1.26
+Version: 0.1.28
 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
@@ -18,6 +18,8 @@ Requires-Dist: PyJWT
 Requires-Dist: nest_asyncio
 Requires-Dist: openai
 Requires-Dist: google-genai
+Requires-Dist: requests>=2.25.0
+Requires-Dist: aiohttp>=3.7.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -65,6 +67,8 @@ Dynamic: summary
 - 🔄 **自动重试** 指数退避策略
 
 ### 🛡️ 生产级特性
+- 🛡️ **熔断降级** 服务故障时自动切换到 HTTP
+- 🚀 **快速降级** 失败立即降级，最大化成功率
 - 🔐 **JWT 认证** 安全可靠
 - 📊 **使用量追踪** Token 统计与成本计算
 - 🆔 **请求追踪** 唯一 request_id
@@ -87,7 +91,14 @@ pip install tamar-model-client
 
 - Python ≥ 3.8
 - 支持 Windows / Linux / macOS
-- 依赖项会自动安装（grpcio, pydantic, python-dotenv 等）
+- 依赖项会自动安装（包括以下核心库）：
+  - `grpcio>=1.67.1` - gRPC 通信协议
+  - `pydantic` - 数据验证和序列化
+  - `PyJWT` - JWT 认证
+  - `requests>=2.25.0` - HTTP 降级功能（同步）
+  - `aiohttp>=3.7.0` - HTTP 降级功能（异步）
+  - `openai` - OpenAI 服务商支持
+  - `google-genai` - Google AI 服务商支持
 
 ## 🏗️ 项目架构
 
@@ -339,7 +350,7 @@ async def main():
     )
 
     # 发送请求并获取响应
-    async for r in await client.invoke(model_request):
+    async for r in await client.invoke(request_data):
         if r.error:
             print(f"错误: {r.error}")
         else:
@@ -587,6 +598,62 @@ metrics = client.get_resilient_metrics()
 # }
 ```
 
+### 🚀 快速降级功能（用户体验优化）
+
+在传统的熔断降级基础上，SDK 新增了快速降级功能，进一步提升用户体验：
+
+#### 传统降级 vs 快速降级
+
+**传统模式**：
+```
+gRPC请求 → 失败 → 重试1 → 失败 → 重试2 → 失败 → ... → 重试N → 失败 → HTTP降级
+耗时：(重试次数 × 退避时间) + 降级时间  // 可能需要十几秒
+```
+
+**快速降级模式**：
+```
+gRPC请求 → 失败 → 立即HTTP降级 (或重试1次后降级)
+耗时：降级时间  // 通常1-2秒内完成
+```
+
+#### 降级策略配置
+
+- **立即降级错误**：`UNAVAILABLE`, `DEADLINE_EXCEEDED`, `CANCELLED` (网络问题)
+- **延迟降级错误**：其他错误重试指定次数后降级
+- **永不降级错误**：`UNAUTHENTICATED`, `PERMISSION_DENIED` (客户端问题)
+
+#### 使用示例
+
+```python
+from tamar_model_client import TamarModelClient
+
+# 启用快速降级（通过环境变量）
+# MODEL_CLIENT_FAST_FALLBACK_ENABLED=true
+# MODEL_CLIENT_FALLBACK_AFTER_RETRIES=1
+
+client = TamarModelClient()
+
+# 正常使用，快速降级对用户透明
+response = client.invoke(request)
+# 如果gRPC不可用，会在1-2秒内自动切换到HTTP并返回结果
+```
+
+#### 配置选项详解
+
+```bash
+# 启用快速降级（默认开启）
+MODEL_CLIENT_FAST_FALLBACK_ENABLED=true
+
+# 非立即降级的错误，重试多少次后降级（默认1次）
+MODEL_CLIENT_FALLBACK_AFTER_RETRIES=1
+
+# 网络错误立即降级（默认配置）
+MODEL_CLIENT_IMMEDIATE_FALLBACK_ERRORS=UNAVAILABLE,DEADLINE_EXCEEDED,CANCELLED
+
+# 认证错误永不降级（避免无效降级）
+MODEL_CLIENT_NEVER_FALLBACK_ERRORS=UNAUTHENTICATED,PERMISSION_DENIED,INVALID_ARGUMENT
+```
+
 ### ⚠️ 注意事项
 
 1. **参数说明**
@@ -614,6 +681,11 @@ export MODEL_MANAGER_SERVER_GRPC_USE_TLS="false"
 export MODEL_MANAGER_SERVER_GRPC_DEFAULT_AUTHORITY="localhost"
 export MODEL_MANAGER_SERVER_GRPC_MAX_RETRIES="5"
 export MODEL_MANAGER_SERVER_GRPC_RETRY_DELAY="1.5"
+
+# 快速降级配置（可选，优化用户体验）
+export MODEL_CLIENT_FAST_FALLBACK_ENABLED="true"
+export MODEL_CLIENT_HTTP_FALLBACK_URL="http://localhost:8080"
+export MODEL_CLIENT_FALLBACK_AFTER_RETRIES="1"
 ```
 
 或者本地 `.env` 文件
@@ -667,6 +739,27 @@ MODEL_CLIENT_CIRCUIT_BREAKER_THRESHOLD=5
 
 # 熔断器恢复超时（秒，熔断后多久尝试恢复，默认 60）
 MODEL_CLIENT_CIRCUIT_BREAKER_TIMEOUT=60
+
+
+# ========================
+# 🚀 快速降级配置（可选，优化体验）
+# ========================
+
+# 是否启用快速降级功能（默认 true）
+# 启用后，gRPC 请求失败时会立即尝试 HTTP 降级，而不是等待所有重试完成
+MODEL_CLIENT_FAST_FALLBACK_ENABLED=true
+
+# 降级前的最大 gRPC 重试次数（默认 1）
+# 对于非立即降级的错误，重试指定次数后才尝试降级
+MODEL_CLIENT_FALLBACK_AFTER_RETRIES=1
+
+# 立即降级的错误类型（逗号分隔，默认网络相关错误）
+# 这些错误类型会在第一次失败后立即尝试降级
+MODEL_CLIENT_IMMEDIATE_FALLBACK_ERRORS=UNAVAILABLE,DEADLINE_EXCEEDED,CANCELLED
+
+# 永不降级的错误类型（逗号分隔，默认认证相关错误）
+# 这些错误类型不会触发降级，通常是客户端问题而非服务不可用
+MODEL_CLIENT_NEVER_FALLBACK_ERRORS=UNAUTHENTICATED,PERMISSION_DENIED,INVALID_ARGUMENT
 ```
 
 加载后，初始化时无需传参：

{tamar_model_client-0.1.26.dist-info → tamar_model_client-0.1.28.dist-info}/RECORD

@@ -1,20 +1,21 @@
 tamar_model_client/__init__.py,sha256=4DEIUGlLTeiaECjJQbGYik7C0JO6hHwwfbLYpYpMdzg,444
-tamar_model_client/async_client.py,sha256=2m3-oMkIjhJRdhuJpXSV3HZxqJXjQEshD677yXBsZzo,41368
+tamar_model_client/async_client.py,sha256=x1hFOpwrRS2bhLKDct-wO4bdrkfovwvCMYyJ_6XlDvU,44655
 tamar_model_client/auth.py,sha256=gbwW5Aakeb49PMbmYvrYlVx1mfyn1LEDJ4qQVs-9DA4,438
-tamar_model_client/circuit_breaker.py,sha256=0XHJXBYA4O8vwsDGwqNrae9zxNJphY5Rfucc9ytVFGA,5419
-tamar_model_client/error_handler.py,sha256=oI_jUTjnq4OXu8fwJoGXNmQpddEgOFF9ZUhbytq7H6c,12384
+tamar_model_client/circuit_breaker.py,sha256=Y3AVp7WzVYU-ubcmovKsJ8DRJbbO4G7vdZgSjnwcWJQ,5550
+tamar_model_client/error_handler.py,sha256=iEgaJOCoQJ4riVSi9ehLl7514jjbfBI9QDd-OTTXpnc,18091
 tamar_model_client/exceptions.py,sha256=EOr4JMYI7hVszRvNYJ1JqsUNpVmd16T2KpJ0MkFTsUE,13073
 tamar_model_client/json_formatter.py,sha256=IyBv_pEEzjF-KaMF-7rxRpNc_fxRYK2A-pu_2n4Liow,1990
 tamar_model_client/logging_icons.py,sha256=MRTZ1Xvkep9ce_jdltj54_XZUXvIpQ95soRNmLdJ4qw,1837
-tamar_model_client/sync_client.py,sha256=mAe-yVCXyLVQCCTkHczA3289pbIL5Fw7zeGOoY8gqP8,42976
+tamar_model_client/sync_client.py,sha256=NcruPoLVmrIiyOy8hExqt3uZRE5UvBWDqmaCgl2J3jc,51497
 tamar_model_client/utils.py,sha256=Kn6pFz9GEC96H4eejEax66AkzvsrXI3WCSDtgDjnVTI,5238
-tamar_model_client/core/__init__.py,sha256=bJRJllrp4Xc0g_qu1pW9G-lsXNB7c1r0NBIfb2Ypxe0,832
-tamar_model_client/core/base_client.py,sha256=3dQLhv8-Lnh2VxKBut_TW-lPS5LBuj7pbJkIwUGq0QI,8995
-tamar_model_client/core/http_fallback.py,sha256=1OuSMxzhDyxy07JZa5artMTNdPNMyAhI7By3RUCSPDw,9872
-tamar_model_client/core/logging_setup.py,sha256=h1aky1uslIQnx4NxMqjoDMxwlc4Vg46KYTjW9yPu2xQ,6032
+tamar_model_client/core/__init__.py,sha256=RMiZjV1S4csWPLxB_JfdOea8fYPz97Oj3humQSBw1OI,1054
+tamar_model_client/core/base_client.py,sha256=0oEhmxz_Y60c04XFziLv70PLDijLWYAeRVSg1oldYjI,12992
+tamar_model_client/core/http_fallback.py,sha256=_3Cd0ziv-w2BeWhZPlrtzVRD90WaggB0Fg_Jaup1F9E,19058
+tamar_model_client/core/logging_setup.py,sha256=-MXzTR4Ax50H16cbq1jCXbxgayf5fZ0U3o0--fMmxD8,6692
 tamar_model_client/core/request_builder.py,sha256=yi8iy2Ps2m4d1YwIFiQLRxTvxQxgEGV576aXnNYRl7E,8507
+tamar_model_client/core/request_id_manager.py,sha256=S-Mliaby9zN_bx-B85FvVnttal-w0skkjy2ZvWoQ5vw,3689
 tamar_model_client/core/response_handler.py,sha256=_q5galAT0_RaUT5C_yZsjg-9VnT9CBjmIASOt28BUmQ,4616
-tamar_model_client/core/utils.py,sha256=8jSx8UOE6ukbiIgruCX7SXN8J5FyuGbqENOmJDsxaSM,5084
+tamar_model_client/core/utils.py,sha256=AcbsGfNQEaZLYI4OZJs-BdmJgxAoLUC5LFoiYmji820,5875
 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=Up87myAg4-0SDJV5a82ggPDpYHSLEtIco8BF_5Ph1nY,322
@@ -27,10 +28,10 @@ tamar_model_client/schemas/inputs.py,sha256=dz1m8NbUIxA99JXZc8WlyzbKpDuz1lEzx3Vg
 tamar_model_client/schemas/outputs.py,sha256=M_fcqUtXPJnfiLabHlyA8BorlC5pYkf5KLjXO1ysKIQ,1031
 tests/__init__.py,sha256=kbmImddLDwdqlkkmkyKtl4bQy_ipe-R8eskpaBylU9w,38
 tests/stream_hanging_analysis.py,sha256=W3W48IhQbNAR6-xvMpoWZvnWOnr56CTaH4-aORNBuD4,14807
-tests/test_google_azure_final.py,sha256=BRKUpaCfL5Gd3ApxpLkOwSFfuFI5ibSm_oh6LxXgGNY,26427
+tests/test_google_azure_final.py,sha256=YRBn1JH1fMJMOQHk6a04NYR9fybboOhqR4urU7vnShI,26330
 tests/test_logging_issue.py,sha256=JTMbotfHpAEPMBj73pOwxPn-Zn4QVQJX6scMz48FRDQ,2427
 tests/test_simple.py,sha256=Xf0U-J9_xn_LzUsmYu06suK0_7DrPeko8OHoHldsNxE,7169
-tamar_model_client-0.1.26.dist-info/METADATA,sha256=fNpG1edeXqkPy8svo2-ZSo7g2S6YTEzfyW8QC-SvgAU,23453
-tamar_model_client-0.1.26.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tamar_model_client-0.1.26.dist-info/top_level.txt,sha256=f1I-S8iWN-cgv4gB8gxRg9jJOTJMumvm4oGKVPfGg6A,25
-tamar_model_client-0.1.26.dist-info/RECORD,,
+tamar_model_client-0.1.28.dist-info/METADATA,sha256=wGQvtURWcFMoreHt52qQhjgCPjIgUruUuWaMZd4-B6A,26880
+tamar_model_client-0.1.28.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tamar_model_client-0.1.28.dist-info/top_level.txt,sha256=f1I-S8iWN-cgv4gB8gxRg9jJOTJMumvm4oGKVPfGg6A,25
+tamar_model_client-0.1.28.dist-info/RECORD,,

tests/test_google_azure_final.py

@@ -26,8 +26,8 @@ test_logger.addHandler(test_handler)
 
 logger = test_logger
 
-os.environ['MODEL_MANAGER_SERVER_GRPC_USE_TLS'] = "true"
-os.environ['MODEL_MANAGER_SERVER_ADDRESS'] = "model-manager-server-grpc-131786869360.asia-northeast1.run.app"
+os.environ['MODEL_MANAGER_SERVER_GRPC_USE_TLS'] = "false"
+os.environ['MODEL_MANAGER_SERVER_ADDRESS'] = "localhost:50051"
 os.environ['MODEL_MANAGER_SERVER_JWT_SECRET_KEY'] = "model-manager-server-jwt-key"
 
 # 导入客户端模块
@@ -630,25 +630,25 @@ async def main():
 
     try:
         # # 同步测试
-        # test_google_ai_studio()
-        # test_google_vertex_ai()
-        # test_azure_openai()
-        #
-        # # 同步批量测试
-        # test_sync_batch_requests()
-        #
-        # # 异步流式测试
-        # await asyncio.wait_for(test_google_streaming(), timeout=60.0)
-        # await asyncio.wait_for(test_azure_streaming(), timeout=60.0)
-        #
-        # # 异步批量测试
-        # await asyncio.wait_for(test_batch_requests(), timeout=120.0)
+        test_google_ai_studio()
+        test_google_vertex_ai()
+        test_azure_openai()
+
+        # 同步批量测试
+        test_sync_batch_requests()
+
+        # 异步流式测试
+        await asyncio.wait_for(test_google_streaming(), timeout=60.0)
+        await asyncio.wait_for(test_azure_streaming(), timeout=60.0)
+
+        # 异步批量测试
+        await asyncio.wait_for(test_batch_requests(), timeout=120.0)
 
         # 同步并发测试
-        test_concurrent_requests(150)  # 测试150个并发请求
+        test_concurrent_requests(2)  # 测试150个并发请求
 
         # 异步并发测试
-        await test_async_concurrent_requests(150)  # 测试150个异步并发请求
+        await test_async_concurrent_requests(2)  # 测试150个异步并发请求
 
         print("\n✅ 测试完成")