Fall back to the reasoning block when a stall strips empty

A reasoning-only stall keeps its whole promise inside the think block, so
stripping tool markup empties it and the nudge never fired, while the local
loops still nudge via _reprompt_intent_text. The fallback runs after stripping,
so a turn that is only an unpromotable call block still has no think span and
is still not nudged, and the replayed turn is the text that was classified.

Author: danielhanchen

studio/backend/core/inference/studio_tool_loop.py

@@ -64,6 +64,7 @@
     reprompt_to_act_message,
     strip_tool_markup,
 )
+from core.tool_healing import _think_spans_outside_tool_markup
 from core.inference.tool_loop_controller import (
     ToolLoopController,
     awaiting_approval_status,
@@ -1055,6 +1056,17 @@ async def stream_with_studio_tools(
                 final = True,
                 enabled_tool_names = allowed_tool_names,
             )
+            if not replayable_answer.strip():
+                # A reasoning-only stall announces the plan inside the think block
+                # and nowhere else. _reprompt_intent_text falls back to that block
+                # rather than dropping the turn, so match it, and replay what was
+                # classified. Ordering matters: the fallback runs on the stripped
+                # text, so a turn that is only an unpromotable call block has no
+                # think span, stays empty, and still does not get nudged.
+                replayable_answer = "\n".join(
+                    visible_answer[start:end]
+                    for start, end in _think_spans_outside_tool_markup(visible_answer)
+                ).strip()
             if (
                 tools_available
                 and nudge_enabled(policy.nudge_tool_calls)

studio/backend/tests/test_studio_tool_loop.py

@@ -780,6 +780,62 @@ def test_a_stalled_model_is_nudged_to_act(executed):
     assert second[-2]["content"] == "I'll search for that now."
 
 
+def test_a_reasoning_only_stall_is_nudged_and_replayed(executed):
+    """Magistral-style stalls put the whole promise inside the think block.
+
+    Stripping tool markup empties such a turn, so classifying the stripped text
+    alone would drop the nudge the local loops still give. The replayed turn must
+    be the text that was classified, or the retry is user -> user again.
+    """
+    stall = "[THINK]I will search now.[/THINK]"
+    transport = FakeTransport(
+        [
+            [_sse({"content": stall}), _sse(finish = "stop"), _DONE],
+            [
+                _sse(
+                    {
+                        "tool_calls": [
+                            {
+                                "index": 0,
+                                "id": "c1",
+                                "function": {"name": "web_search", "arguments": "{}"},
+                            }
+                        ]
+                    }
+                ),
+                _sse(finish = "tool_calls"),
+                _DONE,
+            ],
+            [_sse({"content": "answer"}), _sse(finish = "stop"), _DONE],
+        ]
+    )
+    _run(transport, nudge_tool_calls = True)
+
+    assert [c["name"] for c in executed] == ["web_search"]
+    second = transport.requests[1]["messages"]
+    assert [message["role"] for message in second] == ["user", "assistant", "user"]
+    assert second[-2]["content"] == stall
+
+
+def test_a_markup_only_stall_is_still_not_nudged(executed):
+    """The reasoning fallback runs on the stripped text, so it must not revive Case G."""
+    transport = FakeTransport(
+        [
+            [
+                _sse({"content": '<tool_call>{"name": "not_enabled"}</tool_call>'}),
+                _sse(finish = "stop"),
+                _DONE,
+            ],
+            [_sse({"content": "SHOULD NOT APPEAR"}), _sse(finish = "stop"), _DONE],
+        ],
+        heals = False,
+    )
+    _run(transport, auto_heal = False, nudge_tool_calls = True)
+
+    assert executed == []
+    assert len(transport.requests) == 1
+
+
 def test_a_stalled_model_is_not_nudged_by_default(executed, monkeypatch):
     """An API caller that omits the opt-in must not get a hidden retry."""
     from core.inference import passthrough_healing