fix(agent): execute valid tool calls in mixed batches with invalid names

agent/conversation_loop.py

@@ -483,6 +483,34 @@ def _get_continuation_prompt(is_partial_stub: bool, dropped_tools: Optional[List
 )
 
 
+def _invalid_tool_name_error_content(name: str, valid_tool_names) -> str:
+    """Error-result content for a tool call whose name isn't a real tool.
+
+    A blank/whitespace-only name is not a typo the model can fuzzy-correct
+    toward a real tool — it is almost always a weak open model echoing
+    tool-call XML/JSON it saw in file or tool output (#47967:
+    <tool_call>/<invoke name=...> payloads in a file prime
+    mimo/nemotron-class models to emit empty structured calls), or a model
+    degrading at very large context (observed with gpt-5.6 past ~350K input).
+    Dumping the full tool catalog in that case feeds the priming loop more
+    names to mimic and inflates context 3-4x across retries, so send a terse
+    error that tells the model in-context tool-call syntax is DATA, not a
+    call to make. A genuinely-wrong-but-nonempty name (an actual typo) still
+    gets the catalog so the model can self-correct.
+    """
+    if not (name or "").strip():
+        return (
+            "Tool call rejected: the tool name was empty. "
+            "If tool-call XML or JSON appeared in file "
+            "contents or tool output, that is data — do "
+            "not re-emit it as a tool call. To call a "
+            "tool, use a valid name from your tool list; "
+            "otherwise reply in plain text."
+        )
+    available = ", ".join(sorted(valid_tool_names))
+    return f"Tool '{name}' does not exist. Available tools: {available}"
+
+
 def _content_policy_blocked_result(
     messages: List[Dict],
     api_call_count: int,
@@ -4629,12 +4657,38 @@ def _perform_api_call(next_api_kwargs):
                     tc.function.name for tc in assistant_message.tool_calls
                     if tc.function.name not in agent.valid_tool_names
                 ]
-                if invalid_tool_calls:
+                # Mixed batch: at least one valid call alongside the invalid
+                # one(s). Degrading models (observed with gpt-5.6 at very
+                # large context) emit batches like 6 named calls + 1
+                # blank-name call; voiding the whole turn throws away real
+                # work and, across the 3-strike budget, halts sessions that
+                # were still making progress. Instead: error-result ONLY the
+                # invalid calls (below, after dedup/cap guardrails) and let
+                # the valid ones execute. The strike counter only advances
+                # when a turn contains NO valid call, so a fully-degenerate
+                # model still halts at 3 while a mostly-coherent one keeps
+                # working.
+                _mixed_invalid_batch = bool(invalid_tool_calls) and any(
+                    tc.function.name in agent.valid_tool_names
+                    for tc in assistant_message.tool_calls
+                )
+                if _mixed_invalid_batch:
+                    agent._invalid_tool_retries = 0
+                    invalid_name = invalid_tool_calls[0]
+                    invalid_preview = invalid_name[:80] + "..." if len(invalid_name) > 80 else invalid_name
+                    _n_valid = sum(
+                        1 for tc in assistant_message.tool_calls
+                        if tc.function.name in agent.valid_tool_names
+                    )
+                    agent._buffer_vprint(
+                        f"⚠️  Unknown tool '{invalid_preview}' in batch — erroring that call, "
+                        f"executing {_n_valid} valid call(s)"
+                    )
+                elif invalid_tool_calls:
                     # Track retries for invalid tool calls
                     agent._invalid_tool_retries += 1
 
                     # Return helpful error to model — model can agent-correct next turn
-                    available = ", ".join(sorted(agent.valid_tool_names))
                     invalid_name = invalid_tool_calls[0]
                     invalid_preview = invalid_name[:80] + "..." if len(invalid_name) > 80 else invalid_name
                     agent._buffer_vprint(f"⚠️  Unknown tool '{invalid_preview}' — sending error to model for agent-correction ({agent._invalid_tool_retries}/3)")
@@ -4659,28 +4713,11 @@ def _perform_api_call(next_api_kwargs):
                     for tc in assistant_message.tool_calls:
                         _tc_name = tc.function.name
                         if _tc_name not in agent.valid_tool_names:
-                            # A blank/whitespace-only name is not a typo the
-                            # model can fuzzy-correct toward a real tool — it is
-                            # almost always a weak open model echoing tool-call
-                            # XML/JSON it saw in file or tool output (#47967:
-                            # <tool_call>/<invoke name=...> payloads in a file
-                            # prime mimo/nemotron-class models to emit empty
-                            # structured calls). Dumping the full tool catalog
-                            # in that case feeds the priming loop more names to
-                            # mimic and inflates context 3-4x across retries, so
-                            # send a terse error that tells the model in-context
-                            # tool-call syntax is DATA, not a call to make.
-                            if not (_tc_name or "").strip():
-                                content = (
-                                    "Tool call rejected: the tool name was empty. "
-                                    "If tool-call XML or JSON appeared in file "
-                                    "contents or tool output, that is data — do "
-                                    "not re-emit it as a tool call. To call a "
-                                    "tool, use a valid name from your tool list; "
-                                    "otherwise reply in plain text."
-                                )
-                            else:
-                                content = f"Tool '{_tc_name}' does not exist. Available tools: {available}"
+                            # See _invalid_tool_name_error_content for the
+                            # blank-name anti-priming rationale (#47967).
+                            content = _invalid_tool_name_error_content(
+                                _tc_name, agent.valid_tool_names
+                            )
                         else:
                             content = "Skipped: another tool call in this turn used an invalid name. Please retry this tool call."
                         messages.append({
@@ -4711,6 +4748,14 @@ def _perform_api_call(next_api_kwargs):
                     try:
                         json.loads(args)
                     except json.JSONDecodeError as e:
+                        if (
+                            _mixed_invalid_batch
+                            and tc.function.name not in agent.valid_tool_names
+                        ):
+                            # This call never executes — it gets an
+                            # invalid-name error result below. Don't let its
+                            # broken args trigger the whole-turn JSON retry.
+                            continue
                         invalid_json_args.append((tc.function.name, str(e)))
 
                 if invalid_json_args:
@@ -4794,6 +4839,18 @@ def _perform_api_call(next_api_kwargs):
                     assistant_message.tool_calls
                 )
 
+                # Mixed-batch invalid-name handling: collect the invalid
+                # calls now so the assistant message (built below) keeps
+                # EVERY call the model emitted — providers require each
+                # tool_call to have a matching tool result and vice versa —
+                # while only the valid subset is dispatched for execution.
+                _invalid_batch_calls = []
+                if _mixed_invalid_batch:
+                    _invalid_batch_calls = [
+                        tc for tc in assistant_message.tool_calls
+                        if tc.function.name not in agent.valid_tool_names
+                    ]
+
                 assistant_msg = agent._build_assistant_message(assistant_message, finish_reason)
 
                 turn_content = assistant_message.content or ""
@@ -4885,6 +4942,27 @@ def _perform_api_call(next_api_kwargs):
                 messages.append(assistant_msg)
                 if not duplicate_previous_interim:
                     agent._emit_interim_assistant_message(assistant_msg)
+
+                # Mixed batch: error-result the invalid calls and strip them
+                # from the execution set. The assistant message above keeps
+                # all calls (each gets a matching tool result — the invalid
+                # ones get theirs here, the valid ones during execution), so
+                # provider-side tool_call/result pairing stays intact.
+                if _invalid_batch_calls:
+                    for tc in _invalid_batch_calls:
+                        messages.append({
+                            "role": "tool",
+                            "name": tc.function.name,
+                            "tool_call_id": tc.id,
+                            "content": _invalid_tool_name_error_content(
+                                tc.function.name, agent.valid_tool_names
+                            ),
+                        })
+                    assistant_message.tool_calls = [
+                        tc for tc in assistant_message.tool_calls
+                        if tc.function.name in agent.valid_tool_names
+                    ]
+
                 try:
                     # Persist the assistant tool-call turn before any tool
                     # side effects run. If a destructive tool restarts or

tests/agent/test_empty_tool_name_loop_dampening.py

@@ -95,6 +95,22 @@ def _tc_resp(name: str, args: str = "{}") -> dict:
     }
 
 
+def _batch_tc_resp(calls: list[tuple[str, str]]) -> dict:
+    """Multi-call batch response: calls = [(name, arguments), ...]."""
+    return {
+        "id": "m",
+        "choices": [{"index": 0, "message": {
+            "role": "assistant", "content": "",
+            "tool_calls": [
+                {"id": f"call_{i}", "type": "function",
+                 "function": {"name": name, "arguments": args}}
+                for i, (name, args) in enumerate(calls)
+            ]},
+            "finish_reason": "tool_calls"}],
+        "usage": {"prompt_tokens": 10, "completion_tokens": 0, "total_tokens": 10},
+    }
+
+
 def _text_resp(text: str) -> dict:
     return {
         "id": "m",
@@ -181,3 +197,97 @@ def test_unknown_nonempty_name_keeps_catalog(agent_env):
     assert "frobnicate_xyz" in joined
     assert "Available tools:" in joined
     assert "tool name was empty" not in joined
+
+
+# ── Mixed batches: valid calls execute, invalid calls get error results ──
+#
+# Degrading models (observed with gpt-5.6 past ~350K input; jonny's July 2026
+# report) emit batches like 6 named calls + 1 blank-name call. Before the fix,
+# the whole turn was voided ("Skipped: another tool call in this turn used an
+# invalid name") and three such batches halted the session as partial even
+# though most of the model's work was coherent.
+
+
+def test_mixed_batch_executes_valid_and_errors_blank(agent_env):
+    """Valid siblings of a blank-name call must execute, not be skipped."""
+    agent, handler = agent_env
+    agent.valid_tool_names = agent.valid_tool_names | {"todo"}
+    handler.response_queue.append(_batch_tc_resp([("todo", "{}"), ("", "{}")]))
+    handler.response_queue.append(_text_resp("done"))
+
+    result = agent.run_conversation("track work", conversation_history=[], task_id="t")
+
+    joined = " ".join(_tool_results(handler))
+    # The blank call got the terse anti-priming error...
+    assert "tool name was empty" in joined
+    # ...the valid sibling was NOT punished...
+    assert "Skipped: another tool call" not in joined
+    # ...and actually executed (todo returns its list, not an error result).
+    assert result.get("completed", False)
+
+
+def test_mixed_batch_preserves_tool_call_result_pairing(agent_env):
+    """Every emitted tool_call keeps a matching tool result (provider invariant)."""
+    agent, handler = agent_env
+    agent.valid_tool_names = agent.valid_tool_names | {"todo"}
+    handler.response_queue.append(_batch_tc_resp([("todo", "{}"), ("", "{}")]))
+    handler.response_queue.append(_text_resp("done"))
+
+    result = agent.run_conversation("track work", conversation_history=[], task_id="t")
+
+    msgs = result["messages"]
+    tc_ids = []
+    for m in msgs:
+        if isinstance(m, dict) and m.get("role") == "assistant" and m.get("tool_calls"):
+            tc_ids.extend(tc["id"] for tc in m["tool_calls"])
+    result_ids = [
+        m.get("tool_call_id") or "" for m in msgs
+        if isinstance(m, dict) and m.get("role") == "tool"
+    ]
+    # Both the valid and blank call must appear in the assistant message,
+    # and each must have exactly one matching tool result.
+    assert set(tc_ids) == {"call_0", "call_1"}
+    assert sorted(result_ids) == sorted(tc_ids)
+
+
+def test_mixed_batches_do_not_strike_out_session(agent_env):
+    """4 consecutive mixed batches must not trip the 3-strike halt."""
+    agent, handler = agent_env
+    agent.valid_tool_names = agent.valid_tool_names | {"todo"}
+    for _ in range(4):
+        handler.response_queue.append(_batch_tc_resp([("todo", "{}"), ("", "{}")]))
+    handler.response_queue.append(_text_resp("survived"))
+
+    result = agent.run_conversation("keep going", conversation_history=[], task_id="t")
+
+    assert result.get("completed", False)
+    assert not result.get("partial", False)
+    assert "survived" in (result.get("final_response") or "")
+
+
+def test_all_invalid_batch_still_strikes_out(agent_env):
+    """A turn with NO valid call must still advance the 3-strike halt."""
+    agent, handler = agent_env
+    for _ in range(3):
+        handler.response_queue.append(_batch_tc_resp([("", "{}"), ("  ", "{}")]))
+
+    result = agent.run_conversation("degenerate", conversation_history=[], task_id="t")
+
+    assert result.get("partial", False)
+    assert "invalid tool call" in (result.get("error") or "")
+
+
+def test_mixed_batch_invalid_call_with_broken_json_does_not_retry_turn(agent_env):
+    """Broken args on a never-executing invalid call must not trigger the JSON retry loop."""
+    agent, handler = agent_env
+    agent.valid_tool_names = agent.valid_tool_names | {"todo"}
+    handler.response_queue.append(_batch_tc_resp([("todo", "{}"), ("", '{"unclosed')]))
+    handler.response_queue.append(_text_resp("done"))
+
+    result = agent.run_conversation("track work", conversation_history=[], task_id="t")
+
+    assert result.get("completed", False)
+    # Exactly 2 chat API calls: the batch turn + the final answer. A JSON
+    # retry would add a third identical request.
+    chat_calls = [r for r in handler.captured_requests if "messages" in r]
+    assert len(chat_calls) == 2