工具调用全攻略：同一套代码同时驱动 Claude 和 Gemini

# 用标准的 OpenAI "function" 模式定义一个工具，再把
# 模型返回的 tool_calls 读出来。Claude 和 Gemini 的结构完全一致。
from openai import OpenAI
import json

client = OpenAI(
    api_key="sk-brievio-...",
    base_url="https://api.brievio.com/v1",
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a city.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "e.g. 'Tokyo'"},
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Temperature unit.",
                    },
                },
                "required": ["city"],
            },
        },
    }
]

messages = [{"role": "user", "content": "What's the weather in Tokyo?"}]

resp = client.chat.completions.create(
    model="claude-sonnet-4-6",   # 换成 "gemini-2.5-pro" —— 下面的代码原封不动
    messages=messages,
    tools=tools,
    tool_choice="auto",          # 让模型自己决定要不要调用
)

msg = resp.choices[0].message

# 模型没有用文字回答 —— 它要你去运行一个函数。
if msg.tool_calls:
    for call in msg.tool_calls:
        print(call.function.name)             # "get_weather"
        print(call.function.arguments)         # '{"city": "Tokyo", "unit": "celsius"}'
        args = json.loads(call.function.arguments)  # 永远是一个 JSON 字符串 —— 要解析它
else:
    print(msg.content)           # 普通回答，不需要工具

# 多轮循环：模型发起请求 -> 你运行函数 ->
# 你把结果喂回去 -> 模型写出最终答案。
def run_get_weather(city: str, unit: str = "celsius") -> dict:
    # 你真实的实现：一次 HTTP 调用、一次数据库查询，随便什么都行。
    return {"city": city, "temp": 18, "unit": unit, "sky": "clear"}

TOOL_IMPLS = {"get_weather": run_get_weather}

def answer(question: str, model: str) -> str:
    messages = [{"role": "user", "content": question}]

    while True:
        resp = client.chat.completions.create(
            model=model,
            messages=messages,
            tools=tools,
            tool_choice="auto",
        )
        msg = resp.choices[0].message

        # 没有请求工具 -> 这就是最终答案。结束。
        if not msg.tool_calls:
            return msg.content

        # 1. 把 assistant 这一轮原封不动地追加进去（它携带着
        #    后续消息必须引用的 tool_call id）。
        messages.append(msg)

        # 2. 运行每一个被请求的函数，每次调用追加一条 tool 消息，
        #    并回带对应的 tool_call_id。
        for call in msg.tool_calls:
            fn = TOOL_IMPLS[call.function.name]
            args = json.loads(call.function.arguments)
            result = fn(**args)
            messages.append({
                "role": "tool",
                "tool_call_id": call.id,          # 必须与该次调用的 id 匹配
                "content": json.dumps(result),    # 把结果序列化成字符串
            })
        # 3. 继续循环：模型现在看到工具输出，接着往下进行。

# 同一个函数在这一个 base_url 后面对两家供应商都管用：
print(answer("What's the weather in Tokyo?", "claude-sonnet-4-6"))
print(answer("What's the weather in Tokyo?", "gemini-2.5-pro"))

# 并行工具调用：assistant 的一轮可以一次请求好几个函数。
# 你把它们运行掉（愿意的话可以并发），并为每个调用 id 返回
# 一条 tool 消息。模型会不会把调用批量打包各不相同 —— 所以
# 永远遍历这个列表，而不是假定只有一个。
messages = [{"role": "user",
             "content": "Compare the weather in Tokyo, Paris and Cairo."}]

resp = client.chat.completions.create(
    model="claude-sonnet-4-6",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)
msg = resp.choices[0].message
messages.append(msg)

# msg.tool_calls 此时可能装着三个 id 各不相同的 get_weather 调用。
from concurrent.futures import ThreadPoolExecutor

def handle(call):
    args = json.loads(call.function.arguments)
    result = TOOL_IMPLS[call.function.name](**args)
    return {
        "role": "tool",
        "tool_call_id": call.id,
        "content": json.dumps(result),
    }

with ThreadPoolExecutor() as pool:
    tool_msgs = list(pool.map(handle, msg.tool_calls or []))

messages.extend(tool_msgs)   # 在发出下一个请求前，先追加全部结果

final = client.chat.completions.create(
    model="claude-sonnet-4-6", messages=messages, tools=tools,
)
print(final.choices[0].message.content)

# 注意：如果某个模型一次只返回一个调用、而不是批量打包，上一段
# 代码里的循环会自动处理 —— 它只是多跑几轮而已。