from openai import OpenAI
import json

client = OpenAI(base_url="http://127.0.0.1:52625/v1", api_key="flm")

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

resp = client.chat.completions.create(
    model="qwen3:4b",
    messages=[{"role": "user", "content": "What's the weather in Paris?"}],
    tools=tools,
)

choice = resp.choices[0]
msg = choice.message
print("finish_reason:", choice.finish_reason)                  # "tool_calls"
print("reasoning:", getattr(msg, "reasoning_content", None))   # the <think> text, tags removed
print("content:", msg.content)                                 # None: the turn is only a call
for call in msg.tool_calls or []:
    print(call.id, call.function.name, json.loads(call.function.arguments))

def collect_stream(stream):
    """Fold a chat.completion.chunk stream into one assistant message."""
    reasoning, content = [], []
    calls = {}          # index -> {"id", "type", "function": {"name", "arguments"}}
    finish_reason = None
    usage = None

    for chunk in stream:
        if chunk.usage:                 # only with stream_options={"include_usage": True}
            usage = chunk.usage
        if not chunk.choices:           # the usage chunk has no choices
            continue
        choice = chunk.choices[0]
        delta = choice.delta
        if choice.finish_reason:
            finish_reason = choice.finish_reason

        text = getattr(delta, "reasoning_content", None)
        if text:
            reasoning.append(text)
        if delta.content:
            content.append(delta.content)
        for tc in delta.tool_calls or []:
            call = calls.setdefault(tc.index, {
                "id": None, "type": "function",
                "function": {"name": "", "arguments": ""},
            })
            if tc.id:
                call["id"] = tc.id
            if tc.function and tc.function.name:
                call["function"]["name"] = tc.function.name
            if tc.function and tc.function.arguments:
                call["function"]["arguments"] += tc.function.arguments

    message = {"role": "assistant", "content": "".join(content) or None}
    if calls:
        message["tool_calls"] = [calls[i] for i in sorted(calls)]
    return message, "".join(reasoning), finish_reason, usage

stream = client.chat.completions.create(..., stream=True,
                                        stream_options={"include_usage": True})

# Turn thinking off: answers come faster, reasoning_content is absent
client.chat.completions.create(model="qwen3:4b", messages=msgs, extra_body={"think": False})

# Turn it back on
client.chat.completions.create(model="qwen3:4b", messages=msgs, extra_body={"think": True})

# The OpenAI-style knob works too: "none" turns thinking off,
# "low" / "medium" / "high" turn it on (gpt-oss also uses it as its effort level)
client.chat.completions.create(model="gpt-oss:20b", messages=msgs, reasoning_effort="low")

from openai import OpenAI

client = OpenAI(base_url="http://127.0.0.1:52625/v1", api_key="flm")

DIM, RESET = "\033[2m", "\033[0m"
in_thinking = False

stream = client.chat.completions.create(
    model="qwen3:4b",
    messages=[{"role": "user", "content": "A bat and a ball cost $1.10 in total. "
                                          "The bat costs $1.00 more than the ball. "
                                          "How much is the ball?"}],
    stream=True,
    extra_body={"think": True},
)
for chunk in stream:
    if not chunk.choices:
        continue
    delta = chunk.choices[0].delta
    thinking = getattr(delta, "reasoning_content", None)
    if thinking:
        if not in_thinking:
            print(f"{DIM}🤔 ", end="")
            in_thinking = True
        print(thinking, end="", flush=True)
    if delta.content:
        if in_thinking:
            print(f"{RESET}\n\n", end="")
            in_thinking = False
        print(delta.content, end="", flush=True)
print(RESET)

import json
from openai import OpenAI

client = OpenAI(base_url="http://127.0.0.1:52625/v1", api_key="flm")
MODEL = "qwen3:4b"

tools = [
    {"type": "function", "function": {
        "name": "get_weather",
        "description": "Current weather for a city",
        "parameters": {"type": "object",
                       "properties": {"city": {"type": "string"}},
                       "required": ["city"]}}},
    {"type": "function", "function": {
        "name": "convert_currency",
        "description": "Convert an amount between two currencies",
        "parameters": {"type": "object",
                       "properties": {"amount": {"type": "number"},
                                      "from": {"type": "string"},
                                      "to": {"type": "string"}},
                       "required": ["amount", "from", "to"]}}},
]

def get_weather(city):
    return {"city": city, "temperature_c": 18, "sky": "cloudy"}

def convert_currency(amount, **kw):
    return {"amount": round(amount * 1.08, 2), "currency": kw["to"]}

IMPLEMENTATIONS = {"get_weather": get_weather, "convert_currency": convert_currency}

messages = [{"role": "user",
             "content": "I'm flying to Paris with 200 USD. What's the weather there, "
                        "and how many euros is that?"}]

for step in range(5):                       # never loop forever
    stream = client.chat.completions.create(
        model=MODEL, messages=messages, tools=tools, stream=True,
        extra_body={"think": False},
    )
    message, _reasoning, finish_reason, _ = collect_stream(stream)
    messages.append(message)

    if finish_reason != "tool_calls":
        print(message["content"])
        break

    for call in message["tool_calls"]:
        fn = IMPLEMENTATIONS[call["function"]["name"]]
        args = json.loads(call["function"]["arguments"])
        result = fn(**args)
        print(f"🔧 {call['function']['name']}({args}) -> {result}")
        messages.append({
            "role": "tool",
            "tool_call_id": call["id"],
            "content": json.dumps(result),
        })

resp = client.chat.completions.create(
    model="qwen3:4b",
    messages=[{"role": "user", "content": "Weather in Paris and in Tokyo?"}],
    tools=tools,
)
for call in resp.choices[0].message.tool_calls or []:
    print(call.index, call.id, call.function.arguments)
# 0 call_Gce8tV… {"city": "Paris"}
# 1 call_sCOOJo… {"city": "Tokyo"}