fix(agent): render OpenAI tool-call arguments as a mapping for chat templates

[EazyReal]

Problem

In the OpenAI HTTP adapter (slime/agent/adapters/openai.py), _normalize_tool_call builds the assistant message that _translate_chat_messages collects into chain.chat_messages, which render_token_ids then feeds to tokenizer.apply_chat_template. That message is the render boundary. It serialized tool_calls[].function.arguments to a JSON string via json_arguments. Qwen-family chat templates iterate tool_call.arguments.items(), which expects a mapping — given a string they either iterate it character-by-character or raise a template error, so the rendered prompt diverges from the tokens the policy actually generated. In a token-capturing rollout that is a rollout/train token desync: the policy is trained on tokens it never sampled.

Before vs After

Same input — an assistant turn whose tool call carries arguments as the JSON string echoed on the OpenAI wire:

openai._normalize_tool_call(
    {"function": {"name": "lookup", "arguments": '{"q": "slime"}'}}
)

Before — arguments stays a JSON string, so the rendered assistant message is:

{"type": "function",
 "function": {"name": "lookup", "arguments": '{"q": "slime"}'}}   # str

The Qwen template's arguments.items() then runs on a string → AttributeError: 'str' object has no attribute 'items' (or, on templates that tolerate it, per-character iteration that emits a garbled tool block). Either way the rendered prompt no longer matches the sampled tokens.

After — the wire string is decoded back to the mapping the template expects:

{"type": "function",
 "function": {"name": "lookup", "arguments": {"q": "slime"}}}     # dict

arguments.items() now yields [("q", "slime")] and the tool call renders correctly.

Hostile inputs that are valid JSON but not a mapping are wrapped so .items() can never crash:

openai._normalize_tool_call(
    {"function": {"name": "lookup", "arguments": "[1, 2]"}}
)
# arguments -> {"_raw_arguments": [1, 2]}

Falsy non-dict values are real argument payloads, not "no arguments", and are preserved the same way — only None (or an empty wire string) maps to {}:

dict_arguments(0)     # -> {"_raw_arguments": 0}
dict_arguments([])    # -> {"_raw_arguments": []}
dict_arguments(None)  # -> {}

Fix

Add a small pure helper dict_arguments(value) -> dict in slime/agent/adapters/common.py that decodes echoed wire strings to a mapping at the render boundary:

• dict passes through unchanged;
• str is json.loads-decoded (an empty wire string → {}: the OpenAI wire encodes "no arguments" as an empty / "{}" string);
• None → {} (no arguments); every other non-dict outcome — including falsy values like 0, False, and [] — funnels through a {"_raw_arguments": ...} sentinel (already a convention in slime/agent/parsing.py), so the -> dict contract holds for all inputs, .items() can never crash, and no argument payload is ever silently dropped.

Switch the single render-boundary call site in _normalize_tool_call from json_arguments to dict_arguments.

Why this is the right fix

• Default-path safe. The dict-passthrough and empty/None → {} branches mean callers already passing a mapping (or no arguments) get bit-identical output; only echoed JSON-string arguments change, and they now match what the chat template expects.
• Lossless. Truthiness is the wrong gate for "no arguments": 0, False, and [] are payloads the model emitted. Gating the sentinel on is None instead of truthiness means the normalization never rewrites a real payload to an empty call.
• Outbound wire contract preserved. _openai_tool_calls (the response path) is untouched and still emits function.arguments as a JSON string, exactly as the OpenAI spec requires. Only the internal render boundary changed.
• No new abstraction. It is one pure function reusing the existing {"_raw_arguments": ...} sentinel from parsing.py; the -> dict return type guarantees .items() is always safe.
• CI-verifiable. tests/test_agent_adapters.py::test_openai_render_tool_call_arguments_are_dicts (marked unit) asserts the rendered arguments are the decoded mapping {"q": "slime"}, that "[1, 2]" wraps to {"_raw_arguments": [1, 2]}, and that falsy non-dict values are preserved losslessly (0 → {"_raw_arguments": 0}, [] → {"_raw_arguments": []}, None → {}). The file already runs in the CPU agent-adapter-test job (num_gpus: 0), so the test executes with no workflow change.

[jingshenghang]

Hi, our refactoring of the agent framework has been merged into the main branch. The Codex/OpenAI testing and validation were insufficient; we welcome pull requests based on our latest refactor.

#2005