# MCP-Atlas 评测中的典型任务流程
# 任务：查询用户订单状态，如果已发货则获取物流信息，
#       如果未发货则检查库存并预估发货时间

async def mcp_atlas_task(agent, servers):
    # Step 1: 发现可用工具（模型自行完成）
    available_tools = await agent.discover_tools(servers)
    # 36个服务器, 220个工具 — 模型需从中选择正确的3-6个

    # Step 2: 查询订单（模型选择 order_service.get_order_status）
    order = await agent.call_tool(
        "order_service", "get_order_status",
        {"order_id": "ORD-2026-7854"}
    )

    # Step 3: 条件分支 — 模型需要根据返回值决定路径
    if order["status"] == "shipped":
        # 已发货 → 获取物流追踪
        tracking = await agent.call_tool(
            "logistics_service", "get_tracking",
            {"tracking_number": order["tracking_id"]}
        )
    else:
        # 未发货 → 检查库存 + 预估发货
        inventory = await agent.call_tool(
            "inventory_service", "check_stock",
            {"sku": order["items"][0]["sku"]}
        )
        estimate = await agent.call_tool(
            "fulfillment_service", "estimate_ship_date",
            {"warehouse": inventory["nearest_warehouse"],
             "items": order["items"]}
        )

    # 评分：覆盖75%以上的预期事实声明
    return agent.final_answer  # 需包含订单号、状态、物流/预估等

┌─────────────────────────────────────────────────┐
│           生产环境工具调用故障四层模型              │
├─────────────────────────────────────────────────┤
│                                                   │
│  Layer 1: 基础设施故障 (Transient)                │
│  ├─ HTTP 429/503, 网络超时, 服务不可用            │
│  ├─ OAuth Token 过期, API Key 轮换                │
│  └─ 占比: 1–5%  │  可简单重试                     │
│                                                   │
│  Layer 2: Schema/接口故障 (Semi-Transient)        │
│  ├─ Schema Drift (依赖更新改变响应格式)            │
│  ├─ 认证腐化 (会话中途凭证失效)                    │
│  └─ 占比: 3–7%  │  需要提示词调整                 │
│                                                   │
│  Layer 3: 能力差距 (Non-Retryable)                │
│  ├─ 错误工具选择, 上下文溢出                       │
│  ├─ 子任务超出模型能力边界                          │
│  └─ 占比: 4–8%  │  需要模型升级或任务分解           │
│                                                   │
│  Layer 4: 静默错误 (Silent Corruption)            │
│  ├─ 调用成功(200), 但选了错误工具                  │
│  ├─ 参数合法但语义错误                              │
│  └─ 占比: 2–4%  │  需要下游验证                   │
│                                                   │
└─────────────────────────────────────────────────┘

class LLMCircuitBreaker:
    """生产环境三路熔断器"""

    def __init__(self):
        # 协议熔断器: HTTP 429/503 + 网络超时
        self.protocol_circuit = CircuitBreaker(
            failure_threshold=5,      # 5次失败触发
            cooldown_seconds=60,      # 60秒冷却
            retry_backoff="exponential_jitter"  # 1s→2s→4s→8s→16s
        )
        # 质量熔断器: 输出验证失败率
        self.quality_circuit = CircuitBreaker(
            failure_threshold=0.10,   # 5分钟窗口内>10%失败
            cooldown_seconds=120,
            half_open_test="known_good_prompts"  # 半开用已知好提示测试
        )
        # 成本熔断器: 单任务token消耗超预算
        self.cost_circuit = CircuitBreaker(
            failure_threshold="budget_per_task",
            fallback="route_to_cheaper_model"  # 降级到更便宜模型
        )

    async def execute_tool_call(self, tool_call):
        # 最多4次重试, 超过即升级到人工
        max_retries = 4

        for attempt in range(max_retries):
            if self.protocol_circuit.is_open:
                await self.protocol_circuit.wait_for_half_open()

            try:
                result = await self._call_with_validation(tool_call)
                self._validate_output_schema(result, tool_call.schema)
                self.quality_circuit.record_success()
                return result

            except (RateLimitError, TimeoutError) as e:
                self.protocol_circuit.record_failure(e)
                jitter = random.uniform(0.8, 1.2)
                await asyncio.sleep((2 ** attempt) * jitter)

            except SchemaValidationError as e:
                self.quality_circuit.record_failure(e)
                # Schema失败不能简单重试 — 需要调整提示
                tool_call = self._adjust_prompt_for_schema(tool_call, e)

            except TokenBudgetExceeded:
                self.cost_circuit.trip()
                return await self._fallback_to_cheaper_model(tool_call)

        # 超过重试上限 → 升级到决策树上层
        return await self._escalate_to_supervisor(tool_call)

# OpenAI: strict mode — 约束解码
response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[{"role": "user", "content": "查询订单状态"}],
    tools=[{
        "type": "function",
        "function": {
            "name": "get_order_status",
            "parameters": {
                "type": "object",
                "properties": {
                    "order_id": {"type": "string"},
                    "include_history": {"type": "boolean"}
                },
                "required": ["order_id"]
            },
            "strict": True  # 启用约束解码，合规率>99%
        }
    }]
)

# Anthropic: tool_use — 结构化输出
response = client.messages.create(
    model="claude-sonnet-4-6-20250514",
    messages=[{"role": "user", "content": "查询订单状态"}],
    tools=[{
        "name": "get_order_status",
        "input_schema": {  # 注意：用 input_schema 而非 parameters
            "type": "object",
            "properties": {
                "order_id": {"type": "string"},
                "include_history": {"type": "boolean"}
            },
            "required": ["order_id"]
        }
    }]
)

# Google Gemini: function_declarations
response = client.models.generate_content(
    model="gemini-3.1-pro",
    contents="查询订单状态",
    config=GenerateContentConfig(
        tools=[{
            "function_declarations": [{
                "name": "get_order_status",
                "parameters": {
                    "type_": "OBJECT",
                    "properties": {
                        "order_id": {"type_": "STRING"},
                        "include_history": {"type_": "BOOLEAN"}
                    },
                    "required": ["order_id"]
                }
            }]
        }]
    )
)

flowchart TD
    A[工具调用请求到达] --> B{依赖分析}
    B -->|无依赖| C[并行发射层]
    B -->|有依赖| D[串行编排层]

    C --> E[工具1]
    C --> F[工具2]
    C --> G[工具3]
    E --> H[结果聚合]
    F --> H
    G --> H

    D --> I[工具A]
    I --> J[结果解析]
    J --> K{条件分支}
    K -->|路径1| L[工具B]
    K -->|路径2| M[工具C]
    L --> H
    M --> H

    H --> N{Schema验证}
    N -->|通过| O[返回结果]
    N -->|失败| P[质量熔断器]
    P -->|重试| D
    P -->|超限| Q[降级/人工升级]

    style C fill:#4CAF50,color:#fff
    style D fill:#FF9800,color:#fff
    style P fill:#F44336,color:#fff

flowchart LR
    subgraph 入口层
        A[工具调用请求]
    end

    subgraph 复杂度路由
        B{调用复杂度分析}
    end

    subgraph 快路径
        C[Gemini 3.5 Flash]
        C1[单步调用]
        C2[并行调用]
    end

    subgraph 慢路径
        D[Claude Opus 4.6]
        D1[多步编排]
        D2[策略合规]
    end

    subgraph 验证层
        E[Schema 验证]
        F{合规?}
    end

    subgraph 熔断层
        G[质量熔断器]
        H[成本熔断器]
    end

    A --> B
    B -->|简单/并行| C
    B -->|复杂/多步| D
    C --> C1
    C --> C2
    D --> D1
    D --> D2
    C1 --> E
    C2 --> E
    D1 --> E
    D2 --> E
    E --> F
    F -->|通过| I[返回结果]
    F -->|失败| G
    G -->|重试<4次| B
    G -->|超限| H
    H --> J[降级/人工升级]