Multiple Tool Calls in One Turn

Extend the basic agent loop to handle a model turn that asks for several tools at once. Modern models batch independent tool calls into a single turn (fetch three pages, run two queries) so the agent can run them together instead of one round-trip each. Your loop must execute the whole batch before calling the model again.

How the loop works

You keep a running list of messages. Each turn you call model(messages) and it returns one of two things:

• a final answer — {"type": "final", "content": "..."} — stop and return the content.
• a batch of tool calls — {"type": "tools", "calls": [{"name": ..., "args": ...}, ...]} — run every call in the list, in order, appending one tool-result message per call, then loop again.

A turn that fans out into five tools is still one step. Cap the loop at max_steps model calls so a model that never finishes cannot run forever.

Task

Complete run_agent(model, tools, user_msg, max_steps=10):

1. Start messages with {"role": "user", "content": user_msg}.
2. Loop up to max_steps times, calling model(messages) once per iteration.
3. On a "final" turn, return content.
4. On a "tools" turn, append the assistant message, then for each call in calls look up the tool, run it with args, and append a tool-result message {"role": "tool", "name": ..., "content": <output>} for that call. Then continue the loop.
5. If the loop runs out of steps, return a clear message like "Stopped: reached max steps.".

Example

def model(messages):
    # (mock) first turn asks for two tools at once, second turn answers
    if not any(m["role"] == "tool" for m in messages):
        return {"type": "tools", "calls": [
            {"name": "add", "args": {"a": 2, "b": 3}},
            {"name": "add", "args": {"a": 10, "b": 20}},
        ]}
    return {"type": "final", "content": "Sums are 5 and 30."}

tools = {"add": lambda args: str(args["a"] + args["b"])}

run_agent(model, tools, "add these pairs")   # -> "Sums are 5 and 30."

Constraints

• Preserve call order: the tool-result messages must be appended in the same order as calls.
• Handle an unknown tool name or a tool that raises gracefully — append an error result for that call rather than crashing the whole batch.
• Do not call any real LLM or network — model and the tools are provided.

Approach

The loop is the same bounded while over a message list, but a "tools" turn now carries a list of calls instead of one. On such a turn we append the assistant message, iterate over calls running each tool and appending its result in order, then continue. Each model call counts as one step, so a fan-out of many tools does not drain the step budget faster than a single tool call.

Solution

def run_agent(model, tools, user_msg, max_steps=10):
    messages = [{"role": "user", "content": user_msg}]

    for _ in range(max_steps):
        action = model(messages)

        if action["type"] == "final":
            return action["content"]

        # otherwise it's a batch of tool calls
        messages.append(action)                       # record what the model asked for

        for call in action["calls"]:
            name, args = call["name"], call.get("args", {})
            tool = tools.get(name)
            if tool is None:
                result = f"error: unknown tool '{name}'"
            else:
                try:
                    result = tool(args)
                except Exception as e:                # one broken tool shouldn't sink the batch
                    result = f"error: {e}"
            messages.append({"role": "tool", "name": name, "content": result})

    return "Stopped: reached max steps."

Walkthrough

On the example:

1. messages = [user: "add these pairs"]. model sees no tool result yet and returns a "tools" turn with two add calls.
2. We append the assistant message, then run the batch in order: add(2, 3) -> "5" and add(10, 20) -> "30", appending {"role": "tool", "name": "add", "content": "5"} then {"role": "tool", "name": "add", "content": "30"}.
3. Next iteration (step 2 of the budget): model now sees tool messages and returns {"type": "final", "content": "Sums are 5 and 30."}, which we return.

Complexity & notes

• Time is O(steps × (model cost + total tool cost)); the batch adds one tool per call but does not add model round-trips. Space is O(total messages), which grows by 1 + len(calls) per tools turn.
• Counting a whole batch as one step is the key design choice: it keeps max_steps a bound on model calls (the expensive, unbounded thing) rather than tool executions. If you instead counted each tool, a single turn could exhaust the budget.
• Per-call error handling appends an error string for the failing call while the rest of the batch still runs, so the model sees exactly which call failed and can retry only that one next turn.
• Real frameworks run independent calls concurrently (thread pool or async) since they have no data dependency; the sequential version here is the correctness baseline, and parallelism is a drop-in optimization once ordering of appended results is preserved.