云端 Agent 架构实战：三大模型 Function Calling 能力横评与生产部署方案

{
  "tools": [
    {
      "name": "search_products",
      "description": "商品搜索接口，支持分类筛选和价格区间",
      "parameters": {
        "type": "object",
        "properties": {
          "query": { "type": "string", "description": "搜索关键词" },
          "category": {
            "type": "string",
            "enum": ["electronics", "clothing", "food"]
          },
          "price_range": {
            "type": "object",
            "properties": {
              "min": { "type": "number", "description": "最低价（元）" },
              "max": { "type": "number", "description": "最高价（元）" }
            }
          },
          "sort_by": { "type": "string", "enum": ["price", "rating", "sales"] }
        },
        "required": ["query"]
      }
    },
    {
      "name": "create_order",
      "description": "创建订单，需要完整的收货地址",
      "parameters": {
        "type": "object",
        "properties": {
          "product_id": { "type": "string" },
          "quantity": { "type": "integer", "minimum": 1 },
          "shipping_address": {
            "type": "object",
            "properties": {
              "city": { "type": "string" },
              "street": { "type": "string" },
              "zip": { "type": "string" }
            },
            "required": ["city", "street"]
          }
        },
        "required": ["product_id", "quantity", "shipping_address"]
      }
    }
  ]
}

[
  { "name": "get_weather", "arguments": { "location": "北京", "date": "2026-03-26" } },
  { "name": "search_products", "arguments": { "query": "户外外套", "category": "clothing" } }
]

// 期望
{ "price_range": { "min": 100, "max": 500 } }
// 实际（偶发）
{ "price_range": "{\"min\": 100, \"max\": 500}" }

import json
import re

def sanitize_tool_arguments(raw_args: str | dict) -> dict:
    """统一处理三家模型的参数格式差异"""
    if isinstance(raw_args, dict):
        # 检查是否有字符串化的嵌套对象（GPT 偶发问题）
        for key, value in raw_args.items():
            if isinstance(value, str) and value.startswith('{'):
                try:
                    raw_args[key] = json.loads(value)
                except json.JSONDecodeError:
                    pass
        return raw_args
    
    if isinstance(raw_args, str):
        # 修复 Gemini 常见的 JSON 格式问题
        cleaned = re.sub(r',\s*}', '}', raw_args)
        cleaned = re.sub(r',\s*]', ']', cleaned)
        return json.loads(cleaned)
    
    raise ValueError(f"Unexpected argument type: {type(raw_args)}")

{
  "price_range": {
    "type": "object",
    "description": "价格筛选区间，JSON 对象格式。示例：{\"min\": 100, \"max\": 500}",
    "properties": {
      "min": { "type": "number", "description": "最低价格，单位人民币元" },
      "max": { "type": "number", "description": "最高价格，单位人民币元" }
    }
  }
}

def select_model(request_context):
    tool_count = len(request_context.available_tools)
    has_nested = any(has_nested_params(t) for t in request_context.available_tools)
    
    if tool_count > 3 and not has_nested:
        return "gpt-5.4"       # 多接口编排强
    elif has_nested:
        return "claude-4.6"    # 嵌套处理稳
    elif request_context.cost_sensitive:
        return "gemini-2.5"    # 简单场景省钱
    else:
        return "claude-4.6"    # 默认选稳定性

async def call_with_fallback(primary_model, messages, tools):
    fallback_chain = {
        "claude-4.6": ["gpt-5.4", "gemini-2.5"],
        "gpt-5.4": ["claude-4.6", "gemini-2.5"],
        "gemini-2.5": ["gpt-5.4", "claude-4.6"],
    }
    
    models = [primary_model] + fallback_chain[primary_model]
    
    for model in models:
        try:
            response = await model_call(model, messages, tools)
            parsed = sanitize_tool_arguments(response.arguments)
            if validate_against_schema(parsed, tools):
                return parsed
        except (JSONDecodeError, ValidationError) as e:
            log_fallback(model, e)
            continue
    
    raise AgentError("所有模型均调用失败，触发人工兜底")

API 调用规则：
- 多个 API 之间无数据依赖时，必须并行调用
- 有依赖关系时串行调用，并注明依赖链
- 每次调用必须包含完整参数，不得省略 required 字段