Studio: Don't re-prompt finished answers in the tool loop

studio/backend/core/inference/llama_cpp.py

@@ -92,6 +92,8 @@
 from core.inference.tool_call_parser import (
     MAX_ACT_REPROMPTS as _MAX_REPROMPTS,
     REPROMPT_MAX_CHARS as _REPROMPT_MAX_CHARS,
+    is_reprompt_repeat as _is_reprompt_repeat,
+    is_reprompt_restatement as _is_reprompt_restatement,
     is_short_intent_without_action as _is_short_intent_without_action,
     reprompt_to_act_message as _reprompt_to_act_message,
 )
@@ -339,8 +341,15 @@ def _finalize_reasoning_only_cumulative(
 # loop). Structured delta.tool_calls are grammar-bounded by llama-server; text
 # parsed from content is not, so one runaway turn could fan out unbounded.
 _MAX_TOOL_CALLS_PER_TURN = 8
-_FORCED_REPEAT_PLAN_SIGNAL = re.compile(
-    r"\b(?:i\s+will|i'll|let\s+me|going\s+to|need\s+to|call|use|run|search|fetch|render)\b",
+# Obligation phrasing INTENT_SIGNAL leaves alone ("I need to call ...", "I must
+# call ..."), paired with an action verb: the bare topic words this replaced ate
+# real answers. Two shapes, not one list: the semi-modals take a "to"
+# ("I need to call"), the plain modals take a bare infinitive ("I must call") --
+# folding "should"/"must" into the need|have|ought group would demand
+# "I should to call".
+_FORCED_PLAN_INTENT = re.compile(
+    r"(?:\bi\s+(?:(?:need|have|ought)\s+to|should|must)|^need\s+to|^going\s+to)"
+    r"\s+(?:\w+\s+){0,2}?(?:call|use|run|search|fetch|render|invoke|query)\b",
     re.I,
 )
 _FINAL_ANSWER_SIGNAL = re.compile(
@@ -436,14 +445,27 @@ def _held_rehearsal_tail_len(text: str, active_tools: list[dict]) -> int:
     return len(tail) if tail and _is_rehearsal_prefix(tail, active_tools) else 0
 
 
-def _should_suppress_forced_no_tool_output(text: str) -> bool:
-    """Suppress only repeated forced-turn planning text, not final answers."""
+def _should_suppress_forced_no_tool_output(text: str, previous: str = "") -> bool:
+    """Suppress only repeated forced-turn planning text, not final answers.
+
+    ``previous`` is the stall text that triggered the nudge, so a retry that
+    moved on can be told from one that just said the same thing again.
+    """
     stripped = text.strip()
     if not stripped or len(stripped) >= _REPROMPT_MAX_CHARS:
         return False
     if _FINAL_ANSWER_SIGNAL.search(stripped):
         return False
-    return _FORCED_REPEAT_PLAN_SIGNAL.search(stripped) is not None
+    if _FORCED_PLAN_INTENT.search(stripped) is not None:
+        return True
+    if not _is_short_intent_without_action(stripped):
+        return False
+    # INTENT_SIGNAL also fires on lead-ins that introduce a real answer ("Now I
+    # have the results. The capital is Tokyo."), which _FORCED_REPEAT_PLAN_SIGNAL
+    # used to let through. Dropping those loses the answer outright, so a bare
+    # intent match only counts as a stall once the retry adds nothing to what we
+    # nudged; no ``previous`` keeps the standalone "is this a stall?" contract.
+    return not previous or _is_reprompt_restatement(stripped, previous)
 
 
 # ── Pre-compiled patterns for GGUF shard detection ───────────
@@ -11241,14 +11263,18 @@ def _tool_succeeded(tool_name: str) -> bool:
         # direct answer ("4", "Hello!") won't match. Pattern shared with the
         # safetensors loop (tool_call_parser.INTENT_SIGNAL).
         _reprompt_count = 0
+        # Budgeted apart from _reprompt_count so a pre-tool nudge can't spend it.
+        _post_tool_reprompts = 0
+        # Text that triggered the last nudge; if the retry restates it, stop.
+        _last_reprompt_text = ""
         # Gates ``max_tool_iterations`` on real tool turns (not the enlarged range) so reserved
         # re-prompt slots don't extend the budget. Mirrors the safetensors guard.
         _tool_iters_done = 0
         _forced_tool_call_pending = False
 
         # Reserve extra iterations for re-prompts so they don't consume the
         # caller's tool-call budget; only when tool iterations are allowed.
-        _extra = _MAX_REPROMPTS if max_tool_iterations > 0 else 0
+        _extra = _MAX_REPROMPTS + 1 if max_tool_iterations > 0 else 0
         for iteration in range(max_tool_iterations + _extra):
             if cancel_event is not None and cancel_event.is_set():
                 return
@@ -11876,7 +11902,7 @@ def _tool_succeeded(tool_name: str) -> bool:
                         # ── Re-prompt on plan-without-action ──
                         # If the model described its intent (forward-looking
                         # language) without calling a tool, nudge it to act.
-                        # Fires at most once per request, only on short
+                        # Fires up to _MAX_REPROMPTS times, only on short
                         # responses with intent signals -- "4" or "Hello!"
                         # won't trigger it. Use content if available, else
                         # fall back to reasoning text (reasoning-only stalls).
@@ -11889,18 +11915,35 @@ def _tool_succeeded(tool_name: str) -> bool:
                             r"(?i)\brender[_\s-]?html\b",
                             _stripped,
                         )
+                        # A stall after a tool ran still deserves a nudge, but
+                        # each retry re-runs tools, so allow only one.
+                        # RAG autoinject retrieves before the controller exists, so it
+                        # never lands in history; without _auto a doc-grounded turn
+                        # would still be read as pre-tool and get the full budget.
+                        # Mirrors the safetensors loop's rag_autoinjected.
+                        _already_acted = bool(_auto) or any(
+                            record.executed for record in tool_controller.history
+                        )
+                        if _already_acted:
+                            _reprompt_used, _reprompt_cap = _post_tool_reprompts, 1
+                        else:
+                            _reprompt_used, _reprompt_cap = _reprompt_count, _MAX_REPROMPTS
                         # None keeps the default-on re-prompt; False disables it.
                         if (
                             auto_heal_tool_calls
                             and (nudge_tool_calls is None or nudge_tool_calls)
                             and active_tools
                             and not _render_html_already_done_intent
-                            and _reprompt_count < _MAX_REPROMPTS
+                            and _reprompt_used < _reprompt_cap
+                            and not _is_reprompt_repeat(_stripped, _last_reprompt_text)
                             and _is_short_intent_without_action(_stripped)
                         ):
                             _reprompt_count += 1
+                            if _already_acted:
+                                _post_tool_reprompts += 1
+                            _last_reprompt_text = _stripped
                             logger.info(
-                                f"Re-prompt {_reprompt_count}/{_MAX_REPROMPTS}: "
+                                f"Re-prompt {_reprompt_used + 1}/{_reprompt_cap}: "
                                 f"model responded without calling tools "
                                 f"({len(_stripped)} chars)"
                             )
@@ -11935,7 +11978,10 @@ def _tool_succeeded(tool_name: str) -> bool:
 
                         if _forced_tool_call_pending:
                             _forced_tool_call_pending = False
-                            if not _should_suppress_forced_no_tool_output(_stripped):
+                            if not _should_suppress_forced_no_tool_output(
+                                _stripped,
+                                _last_reprompt_text,
+                            ):
                                 if cumulative_display:
                                     forced_visible_text = _strip_tool_markup(
                                         cumulative_display,
@@ -12252,6 +12298,11 @@ def _invoke_tool(_output_callback, _decision = decision):
                             _kb_search_count += 1
                     completion = tool_controller.record_result(decision, result)
                     resolved_provisional_tool_call_ids.add(decision.tool_call_id)
+                    # A real execution opens the post-tool phase. The pre-tool stall
+                    # text must not carry over, or "I will search the web now." said
+                    # before and after the search reads as a repeat and swallows the
+                    # one post-tool nudge.
+                    _last_reprompt_text = ""
                     # A tool ran this turn, so it counts against the caller's budget.
                     _turn_executed_real_tool = True
                     yield completion.tool_end_event()

studio/backend/core/inference/tool_call_parser.py

@@ -169,12 +169,15 @@
 # Forward-looking intent: the model says what it *will* do, not a final answer.
 INTENT_SIGNAL = re.compile(
     r"(?i)("
-    # Direct intent ("I'll", "Let me"); lookahead drops negated forms
-    # ("I will not") so a refusal does not re-prompt.
-    r"\b(i['\u2019](ll|m going to|m gonna)|i am (going to|gonna)|i will|i shall|let me|allow me)\b(?!\s+(?:not|never)\b)"
+    # Direct intent ("I'll"); lookahead drops negated forms ("I will not").
+    r"\b(i['\u2019](ll|m going to|m gonna)|i am (going to|gonna)|i will|i shall)\b(?!\s+(?:not|never)\b)"
     r"|"
-    # Step/plan framing: "First ...", "Step 1:", "Here's my plan"
-    r"\b(?:first\b|step \d+:?|here['\u2019]?s (?:my |the |a )?(?:plan|approach))"
+    # "let me know" hands control back rather than announcing an action.
+    r"\b(?:let me|allow me)\b(?!\s+(?:not|never|know)\b)"
+    r"|"
+    # Step/plan framing: "First, I ...", "Step 1:", "Here's my plan". "first"
+    # needs first person so "First, the answer is 42" isn't read as a stall.
+    r"\b(?:first,?\s+(?:i|we|let['\u2019]?s|let us)\b|step \d+:?|here['\u2019]?s (?:my |the |a )?(?:plan|approach))"
     r"|"
     r"\b(?:now i|next i)\b"
     r")"
@@ -190,6 +193,42 @@ def is_short_intent_without_action(text: str) -> bool:
     return 0 < len(stripped) < REPROMPT_MAX_CHARS and INTENT_SIGNAL.search(stripped) is not None
 
 
+_REPEAT_WORD_RE = re.compile(r"[^\w\s]+")
+REPROMPT_REPEAT_SIMILARITY = 0.85
+
+
+def _normalize_for_repeat(text: str) -> str:
+    return " ".join(_REPEAT_WORD_RE.sub(" ", text.lower()).split())
+
+
+# A nudge that just gets the same answer back has not worked, so stop there.
+def is_reprompt_repeat(text: str, previous: str) -> bool:
+    if not previous:
+        return False
+    a, b = _normalize_for_repeat(text), _normalize_for_repeat(previous)
+    if not a or not b:
+        return False
+    if a == b:
+        return True
+    wa, wb = set(a.split()), set(b.split())
+    if len(wa) < 4 or len(wb) < 4:
+        return False  # too short for overlap to mean anything
+    return len(wa & wb) / len(wa | wb) >= REPROMPT_REPEAT_SIMILARITY
+
+
+# Stricter sibling of ``is_reprompt_repeat``: nothing at all was added. Near-repeat
+# is the right test for "stop nudging, it isn't working", but not for "throw the
+# turn away" -- a retry that restates the plan and appends the answer ("... for
+# you: Tokyo.") clears the similarity bar, and dropping it loses the answer.
+def is_reprompt_restatement(text: str, previous: str) -> bool:
+    if not previous:
+        return False
+    a, b = _normalize_for_repeat(text), _normalize_for_repeat(previous)
+    if not a or not b:
+        return False
+    return set(a.split()) <= set(b.split())
+
+
 def reprompt_to_act_message(tool_hint: str) -> str:
     """The user message appended when re-prompting a plan-without-action turn."""
     return (