Using OpenAI o-series reasoning models

from openai import OpenAI
import json
import requests

client = OpenAI()


def get_weather(latitude: float, longitude: float) -> float:
    """Fetch current temperature in Celsius for a coordinate pair."""
    url = (
        f"https://api.open-meteo.com/v1/forecast"
        f"?latitude={latitude}&longitude={longitude}"
        f"&current=temperature_2m"
    )
    data = requests.get(url).json()
    return data["current"]["temperature_2m"]


tools = [
    {
        "type": "function",
        "name": "get_weather",
        "description": "Get current temperature for provided coordinates in Celsius.",
        "parameters": {
            "type": "object",
            "properties": {
                "latitude": {"type": "number"},
                "longitude": {"type": "number"},
            },
            "required": ["latitude", "longitude"],
            "additionalProperties": False,
        },
        "strict": True,
    }
]

context = [{"role": "user", "content": "What's the weather like in Paris today?"}]

# First turn: model decides to call the tool
response = client.responses.create(
    model="o3",
    input=context,
    tools=tools,
    store=False,
    include=["reasoning.encrypted_content"],  # persist reasoning across turns
)

# Append the model's output (including encrypted reasoning) to context
context += response.output

tool_call = response.output[1]
args = json.loads(tool_call.arguments)
result = get_weather(args["latitude"], args["longitude"])

context.append(
    {
        "type": "function_call_output",
        "call_id": tool_call.call_id,
        "output": str(result),
    }
)

# Second turn: model synthesizes the tool result into a final answer
response_2 = client.responses.create(
    model="o3",
    input=context,
    tools=tools,
    store=False,
    include=["reasoning.encrypted_content"],
)

print(response_2.output_text)

response = client.responses.create(
    model="o4-mini",
    input=[{"role": "user", "content": "Solve this system of differential equations..."}],
    reasoning={"effort": "high"},
)

You are an AI retail agent.

As a retail agent, you can help users cancel or modify pending orders,
return or exchange delivered orders, modify their default user address,
or provide information about their own profile, orders, and related products.

To process a refund for a delivered order, follow these steps in order:
1. Confirm the order was delivered. Use: order_status_check
2. Check the refund eligibility policy. Use: refund_policy_check
3. Create the refund request. Use: refund_create
4. Notify the user of refund status. Use: user_notify

Check to see if directories exist before creating files.

Use tools when:
- The user wants to cancel or modify an order.
- The user wants to return or exchange a delivered product.
- The user asks for current or personalized order or profile information.

Do not use tools when:
- The user asks a general question like "What's your return policy?"
- The user asks something outside your retail role.

If a task is not possible due to real constraints (for example, trying to
cancel an already-delivered order), explain why clearly and do not call
tools blindly.

# Good — key rules are front and center
Creates a new file with the specified name and contents in a target directory.
- Only call this function if the target directory exists. Check first using directory_check.
- Do not use for temporary content — prefer direct responses for those cases.
- Do not overwrite existing files. Always ensure the file name is unique.

# Worse — important rules are buried after verbose description
Performs a fast regex-based text search that looks for exact pattern matches
within files or entire directories, leveraging the ripgrep tool for high-speed
scanning. Output follows ripgrep formatting and can optionally display line
numbers and matched lines. To manage verbosity, results are limited to 50 hits.
You can fine-tune the search by specifying inclusion or exclusion rules...
[the crucial escape-character rule appears much later]