Arena · AGL-01 · Dispatch a tool call

[akash-coded]

Submissions for AGL-01 · Dispatch a tool call go here. A bot grades each one and replies in the thread.

Brief: labs/catalog/agent-loop/AGL-01 · easy · ~20 min · track agent-loop

tool dispatch · toolUse / toolResult · unknown-tool handling

Submit

/lab AGL-01

```python
def dispatch(...):
    ...
```

The public checks and the Break phase run. Hidden checks do not — publishing their output would spoil this thread for everyone reading it. For those, lab submit AGL-01 in a Codespace or locally.

Before you post

The Learn phase of this lab asks you to make a decision before writing code. Say what you chose and why — that is the part worth discussing, and it is what turns a thread of code blocks into something people read.

Wrap a full working solution in <details><summary> so others can still attempt it.

Stuck?

Post the attempt and the check you cannot pass. That gets better replies than silence, and the failing check's 💡 line usually names the reason.

_{Format and sandbox details: ARENA.md}

[akash-coded]

A worked example of what this thread is for — a deliberately wrong submission, so you can see what the reply looks like before you post your own.

The Learn phase of AGL-01 asks you to decide what happens when the model requests a tool you do not have. Three options: raise, return an error result, or skip silently. I chose skip silently below, because it sounds harmless.

The bot's reply shows why it is not. Note the 💡 lines — that is the point of each failing check, not just a diff.

/lab AGL-01

def dispatch(tool_use, registry):
    tid = tool_use.get("toolUseId")
    fn = registry.get(tool_use.get("name"))
    if fn is None:
        return None
    return {"toolResult": {"toolUseId": tid, "status": "success",
            "content": [{"json": fn(**(tool_use.get("input") or {}))}]}}

[github-actions[bot]]

❌ AGL-01 · Dispatch a tool call

Public checks — 3/6

• ✅ carries the toolUseId through unchanged
• ✅ calls the tool and returns its value as a success result
• ✅ passes input as keyword arguments
• ❌ an unknown tool becomes an error result, not an exception
  _{error while running your code — TypeError: 'NoneType' object is not subscriptable
  💡 Raising here turns a recoverable turn into an outage.}
• ❌ the unknown-tool message names the tools that do exist
  _{error while running your code — TypeError: 'NoneType' object is not subscriptable
  💡 Without the list, the model guesses again — usually the same wrong name.}
• ❌ a tool that raises becomes an error result
  _{error in your code — TimeoutError: upstream took too long
  💡 An escaping exception ends the run; an error result lets the agent abstain honestly.}

Break phase — 0/4

• ❌ survives a tool that raises BaseException
  _{error in your code — SystemExit: a library called sys.exit()
  💡 except Exception misses these. A library that calls sys.exit() takes your agent with it.}
• ❌ survives a registry entry that is not callable
  _{error in your code — TypeError: 'str' object is not callable
  💡 registry.get(name) returning a non-callable passes a None check and fails at call time.}
• ❌ survives arguments the tool does not accept
  _{error in your code — TypeError: t_bad_kwargs..() got an unexpected keyword argument 'wrong_name'
  💡 A TypeError from **kwargs is the single most common dispatch crash in production.}
• ❌ never returns None
  _{dispatch returned None for 'missing'
  💡 A None return means the model asked a question and got no reply. It will answer anyway.}

---

Read the 💡 lines — they are the point of the failing check, not just a diff. The brief and SOLUTION.md are there when you want them, but try once more first.

_{Graded automatically · public and Break phases only · how this works}

[akash-coded]

Trying the drill version — I fixed the None but left the except clause alone, curious what the bot says.

/drill AGL-102

def dispatch(tool_use, registry):
    tid = tool_use.get("toolUseId"); name = tool_use.get("name"); args = tool_use.get("input") or {}
    fn = registry.get(name)
    if fn is None:
        return {"toolResult": {"toolUseId": tid, "status": "error",
                "content": [{"text": f"No tool named {name!r}. Available: {', '.join(sorted(registry))}."}]}}
    try:
        result = fn(**args)
    except Exception as exc:
        return {"toolResult": {"toolUseId": tid, "status": "error", "content": [{"text": str(exc)}]}}
    return {"toolResult": {"toolUseId": tid, "status": "success", "content": [{"json": result}]}}

[github-actions[bot]]

🔁 AGL-102 · Two bugs in a working dispatcher

_{fix · medium}

Checks — 4/5

• ✅ the working paths still work
• ✅ bug 1 — an unknown tool no longer returns None
• ✅ …and the message names the tools that exist
• ❌ bug 2 — SystemExit from a tool no longer kills the loop
  _{error in your code — SystemExit: a library quit
  💡 except Exception misses SystemExit and KeyboardInterrupt. A library calling sys.exit() takes the agent with it.}
• ✅ a hallucinated argument name becomes an error result, not a crash

Break phase — could not run.

---

One of the two bugs is still open. If the SystemExit check fails, you are catching Exception and not BaseException — the classic miss. If the unknown-tool check fails, something on that path still returns None, and None is a reply the model never receives.

Nudge: Ask of every return path: could the loop append this to history and call the model again?

4 of 5 passing. Post the next attempt in this thread — retries are tracked, and a pass after a retry counts more than a first-time pass on the scoreboard.

_{Graded in a network-isolated sandbox · public and Break checks only · how this works · scoreboard}

[akash-coded]

Predict drill. My reasoning: c2 fails at 400+900, the loop continues, c3 and c4 fit (950), c5 does not. So the packer dropped the second-best chunk and kept two lower-ranked ones — fuller, but not rank-faithful.

/drill RET-101

answer = ["c1", "c3", "c4"]

[github-actions[bot]]

✅ RET-101 · Predict what fits in the budget

_{predict · medium}

Checks — 5/5

• ✅ answer is a list of chunk ids
• ✅ c2 is skipped — it would blow the budget on its own
• ✅ the packer keeps going after a skip — c3 and c4 get in
• ✅ c5 does not fit once c4 is in
• ✅ order is rank order, exactly

Break phase — could not run.

---

Traced correctly. Now the harder question you were asked to answer in prose: c2 was the second-best chunk by rank and it was dropped entirely, while c4 — ranked below it — got in. A packer that skips-and-continues optimises for fullness, not for rank fidelity. Whether that is right depends on whether your reranker's ordering is trustworthy. Most teams never decide.

Skill demonstrated: Reasoning about token budgets before running code

Go deeper:

• Context Budget Ledger
• RAG pipeline cheat sheet · packing to a budget

Next: /drill MEM-101 — The summariser that runs every turn

_{Graded in a network-isolated sandbox · public and Break checks only · how this works · scoreboard}