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

tests/test_google_azure_final.py

@@ -35,12 +35,13 @@ try:
     from tamar_model_client import TamarModelClient, AsyncTamarModelClient
     from tamar_model_client.schemas import ModelRequest, UserContext
     from tamar_model_client.enums import ProviderType, InvokeType, Channel
-    
+
     # 为了调试，临时启用 SDK 的日志输出
     # 注意：这会输出 JSON 格式的日志
     import os
+
     os.environ['TAMAR_MODEL_CLIENT_LOG_LEVEL'] = 'INFO'
-    
+
 except ImportError as e:
     logger.error(f"导入模块失败: {e}")
     sys.exit(1)
@@ -512,6 +513,7 @@ async def test_async_concurrent_requests(num_requests: int = 150):
     failed_requests = 0
     request_times: List[float] = []
     errors: Dict[str, int] = {}
+    trace_id = "8885588866668888886666888888866666668888"
 
     # 异步锁
     stats_lock = asyncio.Lock()
@@ -623,13 +625,586 @@ async def test_async_concurrent_requests(num_requests: int = 150):
     }
 
 
+async def test_async_batch_with_circuit_breaker_v2(num_requests: int = 10):
+    """
+    测试熔断器功能 - 使用单个请求而不是批量请求
+    
+    通过发送多个单独的请求来触发熔断器，因为批量请求中的单个失败不会触发熔断。
+    
+    Args:
+        num_requests: 要发送的请求数，默认10个
+    """
+    print(f"\n🔥 测试熔断器功能 - 改进版 ({num_requests} 个独立请求)...")
+
+    # 保存原始环境变量
+    import os
+    original_env = {}
+    env_vars = ['MODEL_CLIENT_RESILIENT_ENABLED', 'MODEL_CLIENT_HTTP_FALLBACK_URL',
+                'MODEL_CLIENT_CIRCUIT_BREAKER_THRESHOLD', 'MODEL_CLIENT_CIRCUIT_BREAKER_TIMEOUT']
+    for var in env_vars:
+        original_env[var] = os.environ.get(var)
+
+    # 设置环境变量以启用熔断器和HTTP fallback
+    os.environ['MODEL_CLIENT_RESILIENT_ENABLED'] = 'true'
+    os.environ['MODEL_CLIENT_HTTP_FALLBACK_URL'] = 'http://localhost:8000'
+    os.environ['MODEL_CLIENT_CIRCUIT_BREAKER_THRESHOLD'] = '3'  # 3次失败后触发熔断
+    os.environ['MODEL_CLIENT_CIRCUIT_BREAKER_TIMEOUT'] = '30'  # 熔断器30秒后恢复
+
+    print(f"   环境变量设置:")
+    print(f"   - MODEL_CLIENT_RESILIENT_ENABLED: {os.environ.get('MODEL_CLIENT_RESILIENT_ENABLED')}")
+    print(f"   - MODEL_CLIENT_HTTP_FALLBACK_URL: {os.environ.get('MODEL_CLIENT_HTTP_FALLBACK_URL')}")
+    print(f"   - 熔断阈值: 1 次失败")
+
+    # 统计变量
+    total_requests = 0
+    successful_requests = 0
+    failed_requests = 0
+    circuit_breaker_opened = False
+    http_fallback_used = 0
+    request_times: List[float] = []
+    errors: Dict[str, int] = {}
+
+    try:
+        # 创建一个共享的异步客户端（启用熔断器）
+        async with AsyncTamarModelClient() as client:
+            print(f"\n   熔断器配置:")
+            print(f"   - 启用状态: {getattr(client, 'resilient_enabled', False)}")
+            print(f"   - HTTP Fallback URL: {getattr(client, 'http_fallback_url', 'None')}")
+
+            for i in range(num_requests):
+                start_time = time.time()
+
+                try:
+                    # 前4个请求使用错误的model来触发失败
+                    if i < 6:
+                        request = ModelRequest(
+                            provider=ProviderType.OPENAI,
+                            model="invalid-model-to-trigger-error",  # 无效模型
+                            input=f"测试失败请求 {i + 1}",
+                            user_context=UserContext(
+                                user_id=f"circuit_test_{i}",
+                                org_id="test_org_circuit",
+                                client_type="circuit_test"
+                            )
+                        )
+                    else:
+                        # 后续请求使用正确的model
+                        request = ModelRequest(
+                            provider=ProviderType.GOOGLE,
+                            model="tamar-google-gemini-flash-lite",
+                            contents=f"测试请求 {i + 1}: 计算 {i} + {i}",
+                            user_context=UserContext(
+                                user_id=f"circuit_test_{i}",
+                                org_id="test_org_circuit",
+                                client_type="circuit_test"
+                            ),
+                            config={"temperature": 0.1}
+                        )
+
+                    print(f"\n   📤 发送请求 {i + 1}/{num_requests}...")
+                    response = await client.invoke(request, timeout=10000)
+
+                    duration = time.time() - start_time
+                    request_times.append(duration)
+                    total_requests += 1
+                    successful_requests += 1
+
+                    print(f"   ✅ 请求 {i + 1} 成功 - 耗时: {duration:.2f}秒")
+
+                    # 检查是否通过HTTP fallback
+                    if hasattr(client, 'resilient_enabled') and client.resilient_enabled:
+                        try:
+                            metrics = client.get_resilient_metrics()
+                            if metrics and metrics['circuit_breaker']['state'] == 'open':
+                                http_fallback_used += 1
+                                print(f"      (通过HTTP fallback)")
+                        except:
+                            pass
+
+                except Exception as e:
+                    duration = time.time() - start_time
+                    request_times.append(duration)
+                    total_requests += 1
+                    failed_requests += 1
+
+                    error_type = type(e).__name__
+                    errors[error_type] = errors.get(error_type, 0) + 1
+
+                    print(f"   ❌ 请求 {i + 1} 失败: {error_type} - {str(e)[:100]}")
+                    print(f"      耗时: {duration:.2f}秒")
+
+                # 检查熔断器状态
+                if hasattr(client, 'resilient_enabled') and client.resilient_enabled:
+                    try:
+                        metrics = client.get_resilient_metrics()
+                        if metrics and 'circuit_breaker' in metrics:
+                            state = metrics['circuit_breaker']['state']
+                            failures = metrics['circuit_breaker']['failure_count']
+
+                            if state == 'open' and not circuit_breaker_opened:
+                                circuit_breaker_opened = True
+                                print(f"   🔻 熔断器已打开！失败次数: {failures}")
+
+                            print(f"      熔断器: {state}, 失败计数: {failures}")
+                    except Exception as e:
+                        print(f"      获取熔断器状态失败: {e}")
+
+                # 请求之间短暂等待
+                await asyncio.sleep(0.2)
+
+            # 最终统计
+            print(f"\n📊 熔断器测试结果:")
+            print(f"   总请求数: {total_requests}")
+            print(f"   成功请求: {successful_requests}")
+            print(f"   失败请求: {failed_requests}")
+
+            print(f"\n   🔥 熔断器统计:")
+            print(f"   - 熔断器是否触发: {'是' if circuit_breaker_opened else '否'}")
+            print(f"   - HTTP fallback使用次数: {http_fallback_used}")
+
+            # 获取最终状态
+            if hasattr(client, 'resilient_enabled') and client.resilient_enabled:
+                try:
+                    final_metrics = client.get_resilient_metrics()
+                    if final_metrics and 'circuit_breaker' in final_metrics:
+                        print(f"   - 最终状态: {final_metrics['circuit_breaker']['state']}")
+                        print(f"   - 总失败次数: {final_metrics['circuit_breaker']['failure_count']}")
+                except Exception as e:
+                    print(f"   - 获取最终状态失败: {e}")
+
+            if errors:
+                print(f"\n   错误统计:")
+                for error_type, count in sorted(errors.items(), key=lambda x: x[1], reverse=True):
+                    print(f"   - {error_type}: {count} 次")
+
+    except Exception as e:
+        print(f"❌ 测试失败: {str(e)}")
+        import traceback
+        traceback.print_exc()
+
+    finally:
+        # 恢复原始环境变量
+        for var, value in original_env.items():
+            if value is None:
+                os.environ.pop(var, None)
+            else:
+                os.environ[var] = value
+
+
+async def test_async_batch_with_circuit_breaker(batch_size: int = 10, num_batches: int = 5):
+    """测试异步批量请求 - 触发熔断器使用HTTP fallback
+    
+    这个测试会复用一个AsyncTamarModelClient，通过发送多个批量请求来触发熔断器，
+    使其自动切换到HTTP fallback模式。
+    
+    Args:
+        batch_size: 每个批量请求包含的请求数，默认10个
+        num_batches: 要发送的批量请求数，默认5个
+    """
+    print(f"\n🔥 测试异步批量请求 - 熔断器模式 ({num_batches} 个批量，每批 {batch_size} 个请求)...")
+
+    # 保存原始环境变量
+    import os
+    original_env = {}
+    env_vars = ['MODEL_CLIENT_RESILIENT_ENABLED', 'MODEL_CLIENT_HTTP_FALLBACK_URL',
+                'MODEL_CLIENT_CIRCUIT_BREAKER_THRESHOLD', 'MODEL_CLIENT_CIRCUIT_BREAKER_TIMEOUT']
+    for var in env_vars:
+        original_env[var] = os.environ.get(var)
+
+    # 设置环境变量以启用熔断器和HTTP fallback
+    os.environ['MODEL_CLIENT_RESILIENT_ENABLED'] = 'true'
+    os.environ['MODEL_CLIENT_HTTP_FALLBACK_URL'] = 'http://localhost:8000'
+    os.environ['MODEL_CLIENT_CIRCUIT_BREAKER_THRESHOLD'] = '3'  # 3次失败后触发熔断
+    os.environ['MODEL_CLIENT_CIRCUIT_BREAKER_TIMEOUT'] = '60'  # 熔断器60秒后恢复
+
+    # 调试：打印环境变量确认设置成功
+    print(f"   环境变量设置:")
+    print(f"   - MODEL_CLIENT_RESILIENT_ENABLED: {os.environ.get('MODEL_CLIENT_RESILIENT_ENABLED')}")
+    print(f"   - MODEL_CLIENT_HTTP_FALLBACK_URL: {os.environ.get('MODEL_CLIENT_HTTP_FALLBACK_URL')}")
+
+    # 统计变量
+    total_batches = 0
+    successful_batches = 0
+    failed_batches = 0
+    circuit_breaker_opened = False
+    http_fallback_used = 0
+    batch_times: List[float] = []
+    errors: Dict[str, int] = {}
+
+    try:
+        from tamar_model_client.schemas import BatchModelRequest, BatchModelRequestItem
+
+        # 创建一个共享的异步客户端（启用熔断器）
+        async with AsyncTamarModelClient() as client:
+            print(f"   熔断器配置:")
+            print(f"   - 启用状态: {getattr(client, 'resilient_enabled', False)}")
+            print(f"   - HTTP Fallback URL: {getattr(client, 'http_fallback_url', 'None')}")
+            if hasattr(client, 'resilient_enabled') and client.resilient_enabled:
+                try:
+                    metrics = client.get_resilient_metrics()
+                    if metrics and 'circuit_breaker' in metrics:
+                        print(f"   - 熔断阈值: {metrics['circuit_breaker'].get('failure_threshold', 'Unknown')} 次失败")
+                        print(f"   - 熔断恢复时间: {metrics['circuit_breaker'].get('recovery_timeout', 'Unknown')} 秒")
+                    else:
+                        print(f"   - 熔断阈值: {os.environ.get('MODEL_CLIENT_CIRCUIT_BREAKER_THRESHOLD', '5')} 次失败")
+                        print(f"   - 熔断恢复时间: {os.environ.get('MODEL_CLIENT_CIRCUIT_BREAKER_TIMEOUT', '60')} 秒")
+                except:
+                    print(f"   - 熔断阈值: {os.environ.get('MODEL_CLIENT_CIRCUIT_BREAKER_THRESHOLD', '5')} 次失败")
+                    print(f"   - 熔断恢复时间: {os.environ.get('MODEL_CLIENT_CIRCUIT_BREAKER_TIMEOUT', '60')} 秒")
+            else:
+                print(f"   - 熔断器未启用")
+
+            for batch_num in range(num_batches):
+                start_time = time.time()
+
+                try:
+                    # 构建批量请求
+                    items = []
+                    for i in range(batch_size):
+                        request_idx = batch_num * batch_size + i
+
+                        # 混合使用不同的provider和model
+                        if request_idx % 4 == 0:
+                            # Google Vertex AI
+                            item = BatchModelRequestItem(
+                                provider=ProviderType.GOOGLE,
+                                channel=Channel.VERTEXAI,
+                                invoke_type=InvokeType.GENERATION,
+                                model="tamar-google-gemini-flash-lite",
+                                contents=f"计算 {request_idx} * 2 的结果",
+                                custom_id=f"batch-{batch_num}-google-vertex-{i}",
+                                config={"temperature": 0.1}
+                            )
+                        elif request_idx % 4 == 1:
+                            # Google AI Studio
+                            item = BatchModelRequestItem(
+                                provider=ProviderType.GOOGLE,
+                                channel=Channel.AI_STUDIO,
+                                invoke_type=InvokeType.GENERATION,
+                                model="tamar-google-gemini-flash-lite",
+                                contents=f"解释数字 {request_idx} 的含义",
+                                custom_id=f"batch-{batch_num}-google-studio-{i}",
+                                config={"temperature": 0.2, "maxOutputTokens": 50}
+                            )
+                        elif request_idx % 4 == 2:
+                            # Azure OpenAI
+                            item = BatchModelRequestItem(
+                                provider=ProviderType.AZURE,
+                                invoke_type=InvokeType.CHAT_COMPLETIONS,
+                                model="gpt-4o-mini",
+                                messages=[{"role": "user", "content": f"数字 {request_idx} 是奇数还是偶数？"}],
+                                custom_id=f"batch-{batch_num}-azure-{i}",
+                                config={"temperature": 0.1, "max_tokens": 30}
+                            )
+                        else:
+                            # 故意使用错误的model来触发失败（帮助触发熔断）
+                            if batch_num < 2:  # 前两个批次使用错误model
+                                item = BatchModelRequestItem(
+                                    provider=ProviderType.GOOGLE,
+                                    invoke_type=InvokeType.GENERATION,
+                                    model="invalid-model-to-trigger-error",
+                                    contents=f"测试错误 {request_idx}",
+                                    custom_id=f"batch-{batch_num}-error-{i}",
+                                )
+                            else:
+                                # 后续批次使用正确的model
+                                item = BatchModelRequestItem(
+                                    provider=ProviderType.GOOGLE,
+                                    invoke_type=InvokeType.GENERATION,
+                                    model="tamar-google-gemini-flash-lite",
+                                    contents=f"Hello from batch {batch_num}, item {i}",
+                                    custom_id=f"batch-{batch_num}-recovery-{i}",
+                                )
+
+                        items.append(item)
+
+                    batch_request = BatchModelRequest(
+                        user_context=UserContext(
+                            user_id=f"circuit_breaker_test_batch_{batch_num}",
+                            org_id="test_org_circuit_breaker",
+                            client_type="async_batch_circuit_test"
+                        ),
+                        items=items
+                    )
+
+                    # 执行批量请求
+                    print(f"\n   📦 发送批量请求 {batch_num + 1}/{num_batches}...")
+                    batch_response = await client.invoke_batch(
+                        batch_request,
+                        timeout=300000.0,
+                        request_id=f"circuit_breaker_test_{batch_num}"
+                    )
+
+                    duration = time.time() - start_time
+                    batch_times.append(duration)
+                    total_batches += 1
+                    successful_batches += 1
+
+                    # 统计结果
+                    success_count = sum(1 for r in batch_response.responses if not r.error)
+                    error_count = sum(1 for r in batch_response.responses if r.error)
+
+                    print(f"   ✅ 批量请求 {batch_num + 1} 完成")
+                    print(f"      - 耗时: {duration:.2f} 秒")
+                    print(f"      - 成功: {success_count}/{batch_size}")
+                    print(f"      - 失败: {error_count}/{batch_size}")
+
+                    # 检查熔断器状态
+                    if hasattr(client, 'resilient_enabled') and client.resilient_enabled:
+                        try:
+                            breaker_status = client.get_resilient_metrics()
+                            if breaker_status and 'circuit_breaker' in breaker_status:
+                                if breaker_status['circuit_breaker']['state'] == 'OPEN':
+                                    if not circuit_breaker_opened:
+                                        circuit_breaker_opened = True
+                                        print(f"   🔻 熔断器已打开！将使用HTTP fallback")
+                                    http_fallback_used += 1
+
+                                print(f"      - 熔断器状态: {breaker_status['circuit_breaker']['state']}")
+                                print(f"      - 失败计数: {breaker_status['circuit_breaker']['failure_count']}")
+                        except Exception as e:
+                            print(f"      - 获取熔断器状态失败: {e}")
+
+                except Exception as e:
+                    duration = time.time() - start_time
+                    batch_times.append(duration)
+                    total_batches += 1
+                    failed_batches += 1
+
+                    error_type = str(e).split(':')[0] if ':' in str(e) else str(e)[:50]
+                    errors[error_type] = errors.get(error_type, 0) + 1
+
+                    print(f"   ❌ 批量请求 {batch_num + 1} 失败: {error_type}")
+                    print(f"      - 耗时: {duration:.2f} 秒")
+
+                # 批次之间短暂等待
+                if batch_num < num_batches - 1:
+                    await asyncio.sleep(0.5)
+
+            # 最终统计
+            print(f"\n📊 批量请求测试结果 (熔断器模式):")
+            print(f"   总批次数: {total_batches}")
+            print(f"   成功批次: {successful_batches} ({successful_batches / total_batches * 100:.1f}%)")
+            print(f"   失败批次: {failed_batches} ({failed_batches / total_batches * 100:.1f}%)")
+
+            if batch_times:
+                avg_batch_time = sum(batch_times) / len(batch_times)
+                print(f"\n   批次耗时统计:")
+                print(f"   - 平均: {avg_batch_time:.3f} 秒")
+                print(f"   - 最小: {min(batch_times):.3f} 秒")
+                print(f"   - 最大: {max(batch_times):.3f} 秒")
+
+            print(f"\n   🔥 熔断器统计:")
+            print(f"   - 熔断器是否触发: {'是' if circuit_breaker_opened else '否'}")
+            print(f"   - HTTP fallback使用次数: {http_fallback_used}")
+
+            # 获取最终的熔断器状态
+            if hasattr(client, 'resilient_enabled') and client.resilient_enabled:
+                try:
+                    final_metrics = client.get_resilient_metrics()
+                    if final_metrics and 'circuit_breaker' in final_metrics:
+                        print(f"   - 最终状态: {final_metrics['circuit_breaker']['state']}")
+                        print(f"   - 总失败次数: {final_metrics['circuit_breaker']['failure_count']}")
+                        print(f"   - 失败阈值: {final_metrics['circuit_breaker']['failure_threshold']}")
+                        print(f"   - 恢复超时: {final_metrics['circuit_breaker']['recovery_timeout']}秒")
+                    else:
+                        print(f"   - 无法获取熔断器指标")
+                except Exception as e:
+                    print(f"   - 获取熔断器指标失败: {e}")
+
+            if errors:
+                print(f"\n   错误统计:")
+                for error_type, count in sorted(errors.items(), key=lambda x: x[1], reverse=True):
+                    print(f"   - {error_type}: {count} 次")
+
+    except Exception as e:
+        print(f"❌ 批量测试失败: {str(e)}")
+        import traceback
+        traceback.print_exc()
+
+    finally:
+        # 恢复原始环境变量
+        for var, value in original_env.items():
+            if value is None:
+                os.environ.pop(var, None)
+            else:
+                os.environ[var] = value
+
+
+async def test_async_concurrent_requests_independent_clients(num_requests: int = 150):
+    """测试异步并发请求 - 每个请求使用独立的AsyncTamarModelClient
+    
+    每个请求都会创建一个新的AsyncTamarModelClient实例，不复用连接，
+    这种方式可以测试客户端的连接管理和资源清理能力。
+    
+    Args:
+        num_requests: 要发送的总请求数，默认150个
+    """
+    print(f"\n🚀 测试异步并发请求 - 独立客户端模式 ({num_requests} 个请求)...")
+
+    # 统计变量
+    total_requests = 0
+    successful_requests = 0
+    failed_requests = 0
+    request_times: List[float] = []
+    errors: Dict[str, int] = {}
+    trace_id = "9999999999999999933333999999993333399999"
+
+    # 异步锁
+    stats_lock = asyncio.Lock()
+
+    async def make_single_async_request_with_independent_client(request_id: int) -> Tuple[bool, float, str]:
+        """使用独立的AsyncTamarModelClient执行单个异步请求
+        
+        Returns:
+            (success, duration, error_msg)
+        """
+        start_time = time.time()
+        try:
+            # 每个请求创建独立的客户端实例
+            async with AsyncTamarModelClient() as client:
+                # 根据请求ID选择不同的provider和model，增加测试多样性
+                if request_id % 3 == 0:
+                    # Google Vertex AI
+                    request = ModelRequest(
+                        provider=ProviderType.GOOGLE,
+                        channel=Channel.VERTEXAI,
+                        invoke_type=InvokeType.GENERATION,
+                        model="tamar-google-gemini-flash-lite",
+                        contents=f"请计算 {request_id % 10} + {(request_id + 1) % 10} 等于多少？",
+                        user_context=UserContext(
+                            user_id=f"{os.environ.get('INSTANCE_ID', '0')}_independent_{request_id:03d}",
+                            org_id="test_org_independent",
+                            client_type="async_independent_test"
+                        ),
+                        config={"temperature": 0.1}
+                    )
+                elif request_id % 3 == 1:
+                    # Google AI Studio
+                    request = ModelRequest(
+                        provider=ProviderType.GOOGLE,
+                        channel=Channel.AI_STUDIO,
+                        invoke_type=InvokeType.GENERATION,
+                        model="tamar-google-gemini-flash-lite",
+                        contents=f"什么是人工智能？请简要回答。(请求ID: {request_id})",
+                        user_context=UserContext(
+                            user_id=f"{os.environ.get('INSTANCE_ID', '0')}_independent_{request_id:03d}",
+                            org_id="test_org_independent",
+                            client_type="async_independent_test"
+                        ),
+                        config={"temperature": 0.3, "maxOutputTokens": 100}
+                    )
+                else:
+                    # Azure OpenAI
+                    request = ModelRequest(
+                        provider=ProviderType.AZURE,
+                        invoke_type=InvokeType.CHAT_COMPLETIONS,
+                        model="gpt-4o-mini",
+                        messages=[
+                            {"role": "user", "content": f"请简单解释什么是云计算？(请求{request_id})"}
+                        ],
+                        user_context=UserContext(
+                            user_id=f"{os.environ.get('INSTANCE_ID', '0')}_independent_{request_id:03d}",
+                            org_id="test_org_independent",
+                            client_type="async_independent_test"
+                        ),
+                        config={"temperature": 0.2, "max_tokens": 100}
+                    )
+
+                response = await client.invoke(request, timeout=300000.0, request_id=f"{trace_id}_{request_id}")
+                duration = time.time() - start_time
+                return (True, duration, "")
+
+        except Exception as e:
+            duration = time.time() - start_time
+            error_msg = str(e)
+            return (False, duration, error_msg)
+
+    async def async_independent_worker(request_id: int):
+        """独立异步工作协程 - 每个请求使用独立的客户端"""
+        nonlocal total_requests, successful_requests, failed_requests
+
+        success, duration, error_msg = await make_single_async_request_with_independent_client(request_id)
+
+        async with stats_lock:
+            total_requests += 1
+            request_times.append(duration)
+
+            if success:
+                successful_requests += 1
+            else:
+                failed_requests += 1
+                # 统计错误类型
+                error_type = error_msg.split(':')[0] if ':' in error_msg else error_msg[:50]
+                errors[error_type] = errors.get(error_type, 0) + 1
+
+            # 每20个请求输出一次进度
+            if total_requests % 20 == 0:
+                print(
+                    f"   进度: {total_requests}/{num_requests} (成功: {successful_requests}, 失败: {failed_requests})")
+
+    # 使用独立客户端执行并发请求
+    start_time = time.time()
+
+    # 限制并发数，避免创建过多连接
+    semaphore = asyncio.Semaphore(30)  # 降低并发数，因为每个请求都要创建新连接
+
+    async def limited_independent_worker(request_id: int):
+        async with semaphore:
+            await async_independent_worker(request_id)
+
+    # 创建所有任务
+    tasks = [limited_independent_worker(i) for i in range(num_requests)]
+
+    # 等待所有任务完成
+    await asyncio.gather(*tasks)
+
+    total_duration = time.time() - start_time
+
+    # 计算统计信息
+    avg_request_time = sum(request_times) / len(request_times) if request_times else 0
+    min_request_time = min(request_times) if request_times else 0
+    max_request_time = max(request_times) if request_times else 0
+
+    # 输出结果
+    print(f"\n📊 异步并发测试结果 (独立客户端模式):")
+    print(f"   总请求数: {total_requests}")
+    print(f"   成功请求: {successful_requests} ({successful_requests / total_requests * 100:.1f}%)")
+    print(f"   失败请求: {failed_requests} ({failed_requests / total_requests * 100:.1f}%)")
+    print(f"   总耗时: {total_duration:.2f} 秒")
+    print(f"   平均QPS: {total_requests / total_duration:.2f}")
+    print(f"\n   请求耗时统计:")
+    print(f"   - 平均: {avg_request_time:.3f} 秒")
+    print(f"   - 最小: {min_request_time:.3f} 秒")
+    print(f"   - 最大: {max_request_time:.3f} 秒")
+
+    print(f"\n   🔍 测试特点:")
+    print(f"   - 每个请求使用独立的AsyncTamarModelClient实例")
+    print(f"   - 不复用连接，测试连接管理能力")
+    print(f"   - 限制并发数为30个，避免过多连接")
+    print(f"   - 使用多种Provider (Google Vertex AI, AI Studio, Azure OpenAI)")
+
+    if errors:
+        print(f"\n   错误统计:")
+        for error_type, count in sorted(errors.items(), key=lambda x: x[1], reverse=True):
+            print(f"   - {error_type}: {count} 次")
+
+    return {
+        "total": total_requests,
+        "successful": successful_requests,
+        "failed": failed_requests,
+        "duration": total_duration,
+        "qps": total_requests / total_duration
+    }
+
+
 async def main():
     """主函数"""
     print("🚀 简化版 Google/Azure 测试")
     print("=" * 50)
 
     try:
-        # # 同步测试
+        # 同步测试
         test_google_ai_studio()
         test_google_vertex_ai()
         test_azure_openai()
@@ -647,8 +1222,17 @@ async def main():
         # 同步并发测试
         test_concurrent_requests(2)  # 测试150个并发请求
 
-        # 异步并发测试
-        await test_async_concurrent_requests(2)  # 测试150个异步并发请求
+        # # 异步并发测试
+        await test_async_concurrent_requests(2)  # 测试50个异步并发请求（复用连接）
+
+        # 异步并发测试 - 独立客户端模式
+        # await test_async_concurrent_requests_independent_clients(30)  # 测试30个独立客户端并发请求
+
+        # 异步批量测试 - 熔断器模式（原版）
+        # await test_async_batch_with_circuit_breaker(10, 5)  # 测试5个批量请求，每批10个请求
+
+        # 熔断器测试 - 改进版（使用单个请求）
+        # await test_async_batch_with_circuit_breaker_v2(10)  # 测试10个独立请求触发熔断
 
         print("\n✅ 测试完成")