Reasoning Models as Agent Backbones

import json
import re
from openai import OpenAI

client = OpenAI()

# Tool registry: name -> (function, description)
def calculator(expression: str) -> str:
 """Evaluate a mathematical expression safely."""
 try:
 # Only allow safe math operations
 allowed = set("0123456789+-*/.() ")
 if not all(c in allowed for c in expression):
 return f"Error: unsafe expression '{expression}'"
 result = eval(expression)
 return str(result)
 except Exception as e:
 return f"Error: {e}"

def weather(city: str) -> str:
 """Look up current weather for a city (simulated)."""
 data = {
 "new york": "72F, partly cloudy",
 "london": "58F, rainy",
 "tokyo": "68F, clear",
 "paris": "63F, overcast",
 }
 return data.get(city.lower(), f"No weather data available for '{city}'")

def search(query: str) -> str:
 """Search the web for information (simulated)."""
 results = {
 "population of france": "Approximately 68.4 million (2025 estimate)",
 "tallest building in the world": "Burj Khalifa in Dubai, 828 meters",
 "speed of light": "299,792,458 meters per second",
 }
 for key, value in results.items():
 if key in query.lower():
 return value
 return f"Search results for '{query}': No relevant results found."

TOOLS = {
 "calculator": (calculator, "Evaluate a math expression. Input: a math expression string."),
 "weather": (weather, "Get current weather for a city. Input: city name."),
 "search": (search, "Search the web for factual information. Input: search query."),
}

def build_system_prompt():
 tool_descriptions = "\n".join(
 f" - {name}: {desc}" for name, (_, desc) in TOOLS.items()
 )
 return f"""You are a helpful assistant that answers questions by reasoning step-by-step and using tools when needed.

Available tools:
{tool_descriptions}

For each step, respond in EXACTLY this format:

Thought: [your reasoning about what to do next]
Action: [tool_name]
Action Input: [input to the tool]

When you have enough information to answer, respond with:

Thought: [your final reasoning]
Final Answer: [your complete answer to the user's question]

Important rules:
- Always start with a Thought before taking an Action.
- Use exactly one tool per step.
- If a tool returns an error, reason about it and try a different approach.
- Do not make up information. Use tools to find facts."""

def parse_agent_output(text):
 """Parse the LLM output to extract action or final answer.

 Returns:
 ("action", tool_name, tool_input) if the model wants to call a tool
 ("final", answer, None) if the model has a final answer
 ("error", message, None) if parsing fails
 """
 # TODO: check if the response contains "Final Answer:"
 # If so, extract and return everything after it
 # Hint: use text.split("Final Answer:", 1)
 if "Final Answer:" in text:
 answer = ???
 return ("final", answer, None)

 # TODO: extract Action and Action Input using string matching or regex
 # Hint: look for "Action:" and "Action Input:" lines
 action_match = re.search(r"Action:\s*(.+)", text)
 input_match = re.search(r"Action Input:\s*(.+)", text)

 if action_match and input_match:
 tool_name = action_match.group(1).strip()
 tool_input = input_match.group(1).strip()
 return ("action", tool_name, tool_input)

 return ("error", "Could not parse response", None)

def run_agent(question, max_steps=6, verbose=True):
 """Run the ReAct agent loop."""
 messages = [
 {"role": "system", "content": build_system_prompt()},
 {"role": "user", "content": question},
 ]

 for step in range(max_steps):
 # Call the LLM
 response = client.chat.completions.create(
 model="gpt-4o-mini",
 messages=messages,
 temperature=0.0,
 max_tokens=500,
 )
 assistant_text = response.choices[0].message.content

 if verbose:
 print(f"\n--- Step {step + 1} ---")
 print(assistant_text)

 # Parse the output
 result_type, value, tool_input = parse_agent_output(assistant_text)

 if result_type == "final":
 if verbose:
 print(f"\n=== FINAL ANSWER ===\n{value}")
 return value

 elif result_type == "action":
 # TODO: look up the tool in TOOLS and execute it
 # Handle the case where the tool name is not recognized
 if value in TOOLS:
 tool_fn, _ = TOOLS[value]
 observation = tool_fn(tool_input)
 else:
 observation = f"Error: unknown tool '{value}'. Available tools: {list(TOOLS.keys())}"

 if verbose:
 print(f"Observation: {observation}")

 # Append the assistant message and observation to the conversation
 messages.append({"role": "assistant", "content": assistant_text})
 messages.append({"role": "user", "content": f"Observation: {observation}"})

 else:
 # Parsing error: ask the model to try again
 messages.append({"role": "assistant", "content": assistant_text})
 messages.append({"role": "user", "content": "Please respond using the exact Thought/Action/Action Input format."})

 return "Agent reached maximum steps without a final answer."

# Single-tool question
run_agent("What is the weather in Tokyo?")

# Multi-step question requiring two tools
run_agent("What is the population of France divided by 2?")

# Question requiring reasoning about which tool to use
run_agent("I'm packing for London. Should I bring an umbrella? Also, what is 72 - 58?")