在 Claude 與 Gemini 之間共用工具呼叫：一份程式碼，一個 base_url

# 用標準的 OpenAI「function」schema 定義一個工具，再讀回
# 模型回傳的 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 回應可以一次要求好幾個函式。
# 你把它們執行掉（想的話可以併行），再為每一個 call 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)

# 注意：如果某個模型是一次一個、而非批次地回傳呼叫，上一段
# 程式碼裡的迴圈不必改就能處理 — 它只是會多跑幾輪而已。