A model's tool call is JSON all the way down — including its arguments, which arrive as text your code must parse before trusting them.
1arguments Is a String, Not Yet an Object
Most chat completion APIs encode a tool call's arguments as a JSON string inside the response, rather than a nested object, because the overall response itself is JSON text — nesting an object that might contain arbitrary or malformed data as a raw sub-object would break the outer JSON structure. Your code must call something like json.loads on it before use.
2You're One Parse Away From Your Existing Dispatch Logic
Once arguments is a real dict, handling a live model's tool call is identical to the dispatch function you already built in Module 2 — look up the handler by name, call it with the parsed arguments unpacked as keyword arguments. The model-facing plumbing is new; the execution logic underneath it isn't.
3Step-by-Step Breakdown
From Tool Call to Real Result. A model's tool call arrives as JSON over the wire — and critically, its arguments arrive as a JSON-encoded string, not an already-parsed object, because that's how the underlying API transmits structured data. Your server has to parse that string before it can hand the arguments to a real handler.
Parse and Execute a Real Tool Call. This is a real tool_call payload shaped exactly like one a model would return. Finish handle_tool_call so it parses the JSON-encoded arguments string into a real dict before dispatching to the handler.
Why do a model's tool call arguments arrive as a JSON string rather than an already-parsed Python dict?
- →Because the API response itself is transmitted as JSON text over HTTP — any nested structured data inside it, including tool arguments, is encoded as a string until your code explicitly parses it.
- →Because parsing dicts directly would be a security vulnerability in every programming language.
A Real Result, Ready to Send Back. You just took a real tool call all the way from raw JSON to an executed result. But the model that requested this call still doesn't know what happened — it's waiting. Next lesson: sending that result back and getting the model's actual final answer.
Level Up 🚀
Advanced cheat sheets, SEO tricks, and interview prep for this topic.
Browser Support
Fully supported.
Fully supported.
Fully supported.
Fully supported.
Accessibility (A11y)
1Fail Clearly on Malformed Tool Call Arguments
If json.loads fails on a model's arguments string, catch it and return a descriptive tool error rather than letting a raw parsing exception surface to the end user.
except json.JSONDecodeError: return "error: malformed arguments"SEO Implications
- 1
Target 'parse OpenAI tool call arguments Python' and 'MCP execute tool call example' separately
Developers debugging this exact step search for the API-specific parsing detail and the MCP execution pattern independently.
Best Practices
Never Trust That Parsed Arguments Match Your Schema
json.loads only guarantees valid JSON, not that the resulting dict has the keys and types your handler expects — validate before calling the handler, which a later lesson covers explicitly.
Frequent Bugs
Passing the raw arguments string straight to the handler without parsing it.
`handler(**"{\"path\": \"x\"}")` fails immediately — a string can't be unpacked as keyword arguments; it must be parsed into a dict with json.loads first.
Real-World Examples
Real MCP Client Libraries
Official MCP and function-calling client libraries perform this exact parse-then-dispatch sequence internally — understanding it by hand here is what makes debugging a real library's behavior possible later.
args = json.loads(tool_call.function.arguments)