@tiens.nguyen/gonext-local-worker 1.0.318 → 1.0.320

package/gonext_agent_chat.py

@@ -1690,6 +1690,146 @@ def _repair_code_block_strings(text: str) -> str:
     return text[:open_end] + sanitized + text[last:]
 
 
+def _looks_like_tool_code(code: str):
+    """Is `code` plausibly a runnable tool call, i.e. worth substituting into the step?
+
+    Returns (ok, why_not). Used ONLY to vet a block recovered from a reasoning channel
+    (task #113) — never to judge code the model put in the visible message, which keeps
+    the normal path (and Ollama) byte-for-byte unchanged.
+
+    Why this gate exists: a reasoning model narrates the FORMAT rules to itself, so the
+    text between a <code>…</code> pair in its reasoning is often English, not python.
+    Seen live with Kimi K3, recovering the 16 chars "and closing with" (it was echoing
+    the system prompt's "OPENS with <code> and CLOSES with </code>") — we wrapped that
+    prose in tags and executed it, turning a clean parse error into a SyntaxError and a
+    poisoned history. Substituting un-vetted prose is strictly worse than not recovering.
+
+    Two checks, both cheap:
+      1. it must COMPILE as python (kills prose, which is the actual failure mode);
+      2. it must CALL something (`name(`) — every legitimate CodeAgent step calls a tool
+         or final_answer, while a bare word like "yes" happens to compile as a Name."""
+    code = (code or "").strip()
+    if not code:
+        return False, "empty"
+    try:
+        compile(code, "<gonext-recovered>", "exec")
+    except SyntaxError as e:
+        return False, f"not python ({(getattr(e, 'msg', '') or 'syntax error')})"
+    except Exception as e:  # noqa: BLE001
+        return False, f"not compilable ({e})"
+    if not re.search(r"[A-Za-z_][A-Za-z0-9_]*\s*\(", code):
+        return False, "no function call"
+    return True, ""
+
+
+def _has_runnable_block(text) -> bool:
+    """True if `text` contains a <code>…</code> block whose python actually compiles —
+    i.e. this step produced something that can run. Used by the #113 no-code loop-breaker
+    (openai backend only) to tell "the step worked" from "the model wrote prose again"."""
+    if not isinstance(text, str) or not text:
+        return False
+    blk = re.search(r"<code[^>]*>([\s\S]*?)</code>", text, re.I)
+    if not blk:
+        return False
+    try:
+        compile(blk.group(1), "<gonext-code>", "exec")
+        return True
+    except Exception:  # noqa: BLE001
+        return False
+
+
+def _code_nudge_reason(content, openai_backend: bool):
+    """Why (if at all) this streamed turn should be re-prompted once with the CODE-NOW
+    directive — or None to accept it as-is. Pure decision so the three triggers can be
+    replayed offline against real traces (task #113).
+
+      1. empty-content   — the whole turn went to the reasoning channel, no message.
+      2. dangling tag    — a stray <code>/</code> with no valid pair.
+      3. prose-only plan — narration of what it is ABOUT to do, no tag at all. This one
+         is openai-only and additionally requires _looks_like_scratchpad, so a FINISHED
+         prose answer is never nudged into inventing another tool call. It exists because
+         the "</code>" visible in a smolagents trace is appended by smolagents AFTER the
+         model returns, so trigger 2 cannot see this shape.
+
+    Triggers 1 and 2 keep their existing backend-agnostic behavior — the Ollama path is
+    unchanged, since trigger 3 is the only new one and it is gated off there."""
+    text = (content or "").strip()
+    if not text:
+        return "empty-content"
+    if re.search(r"<code[^>]*>[\s\S]*?</code>", content, re.I):
+        return None  # a real block — nothing to nudge
+    if re.search(r"</?code[\s>/]", content, re.I):
+        return "dangling code tag, no valid block"
+    if openai_backend and _looks_like_scratchpad(text):
+        return "prose-only plan, no code block"
+    return None
+
+
+def _recover_code_from_reasoning(content, reasoning):
+    """Recover a <code>…</code> tool call that a reasoning model placed in the
+    REASONING channel instead of the visible message (task #111). No-op when the
+    visible content already has a usable code block, or when there is no reasoning
+    text (e.g. Ollama with reasoning_effort='none') — so the Ollama path is unchanged.
+
+    Kimi K3 @ Moonshot splits its output two ways when it fails: (a) the full
+    <code>…</code> block lands in reasoning and only prose leaks to content; or
+    (b) the OPENER + code land in reasoning while the CLOSING </code> leaks into
+    content (seen live: content = 'Thought: …contains.</code>'). Handle both.
+
+    Every candidate is VETTED with _looks_like_tool_code before it is used (task
+    #113): the same reasoning stream also contains the model narrating the format
+    rules to itself, so a <code>…</code> pair found there can hold plain English.
+    Candidates are tried NEWEST-first and the first runnable one wins; if none is
+    runnable we return `content` untouched and let the step fail normally, which
+    is what happened before #111 existed."""
+    _pair = r"<code[^>]*>[\s\S]*?</code>"
+    if re.search(_pair, content or "", re.I):
+        return content  # content already has a usable block — never override it
+    reasoning = reasoning or ""
+    if not reasoning.strip():
+        return content  # nothing to recover from (Ollama / non-reasoning model)
+
+    def _clean(raw):
+        # A leaked 'Thought:' line (or a stray </code>) can ride along after the
+        # code — cut it so only the executable snippet remains.
+        out = re.split(r"\n\s*Thought\s*:\s", raw, maxsplit=1)[0]
+        return re.sub(r"</?code[^>]*>", "", out, flags=re.I).strip()
+
+    # (a) COMPLETE blocks inside reasoning (the model drafts the whole tool call
+    # there), newest first. (b) As a last resort, the opener + code in reasoning
+    # with the closer leaked into content → everything after the LAST opener.
+    candidates = [m.group(1) for m in
+                  re.finditer(r"<code[^>]*>([\s\S]*?)</code>", reasoning, re.I)]
+    candidates.reverse()
+    tail = None
+    for tail in re.finditer(r"<code[^>]*>([\s\S]*)$", reasoning, re.I):
+        pass
+    if tail:
+        candidates.append(tail.group(1))
+    code = None
+    rejected = []
+    for cand in candidates:
+        cleaned = _clean(cand)
+        ok, why = _looks_like_tool_code(cleaned)
+        if ok:
+            code = cleaned
+            break
+        if cleaned:
+            rejected.append((cleaned, why))
+    if code is None:
+        if rejected:
+            _preview, _why = rejected[0]
+            _log(f"#113 rejected recovered block from reasoning — {_why} "
+                 f"({len(_preview)} chars): {_preview[:80]!r}; leaving content as-is")
+        return content
+    # Keep the visible Thought prose (strip any stray/unbalanced code tags), then
+    # append the recovered block so smolagents parses a clean Thought → <code> pair.
+    prose = re.sub(r"</?code[^>]*>", "", content or "", flags=re.I).strip()
+    rebuilt = (prose + "\n" if prose else "") + "<code>\n" + code + "\n</code>"
+    _log(f"#111 recovered <code> block from reasoning channel ({len(code)} chars)")
+    return rebuilt
+
+
 def _strip_think(text: str) -> str:
     """Remove Qwen3-style <think>…</think> reasoning traces from a model reply.
 
@@ -4760,6 +4900,36 @@ def run_agent_chat(cfg):
                 "Do NOT hand an unfinished task back to the user.")
         return True
 
+    _CODE_TRIMMED_MARK = "\n…[code trimmed — already ran; result is in the Observation]"
+
+    def _trim_tool_call_args(step, cap):
+        """Shrink a step's recorded tool-call ARGUMENTS. For a CodeAgent that value IS the
+        full python code action, and smolagents renders it into its OWN 'Calling tools:'
+        message on every later request (memory.py ActionStep.to_messages → ToolCall.dict).
+
+        This is the gap in the #63/#87 trims: they only ever touched model_output and
+        observations, so the <code> they stripped out of the Thought came straight back
+        here, verbatim, forever. On a file-writing step that duplicate is the single
+        largest thing in the prompt (a create_file carries the whole file body twice).
+        Gutting it is safe — the code ALREADY executed and its result is in the
+        Observation; the leading chars we keep still name the tool and its first argument
+        (the path), which is what a later step actually refers back to.
+
+        The ToolCall object, its id and its name are left intact — smolagents formats
+        parse errors as f"Call id: {self.tool_calls[0].id}" — and only `str` arguments are
+        touched, so a ToolCallingAgent's dict arguments are left alone. Returns chars
+        saved; idempotent, since a re-trim recomputes the identical string and no-ops."""
+        saved = 0
+        for _tc in (getattr(step, "tool_calls", None) or []):
+            _a = getattr(_tc, "arguments", None)
+            if not isinstance(_a, str) or len(_a) <= cap:
+                continue
+            _new = _a[:cap].rstrip() + _CODE_TRIMMED_MARK
+            if len(_new) < len(_a):
+                _tc.arguments = _new
+                saved += len(_a) - len(_new)
+        return saved
+
     def _aggressive_compact(steps):
         """User-approved deep compaction: keep only the LAST step in full; for every
         older step shrink the observation to a stub and the model_output to just its
@@ -4778,6 +4948,10 @@ def run_agent_chat(cfg):
                 _head = re.split(r"<code[\s>]|```", _mo, maxsplit=1)[0].rstrip()
                 _st.model_output = (_head[:200].rstrip() or _mo[:150].rstrip()) + "\n…[compacted]"
                 saved += _b - len(_st.model_output)
+            # The duplicated code action (see _trim_tool_call_args) — tighter than the
+            # always-on pass, since a user-approved compaction is explicitly trading
+            # recall for a smaller prompt.
+            saved += _trim_tool_call_args(_st, 120)
         return saved
 
     def step_callback(step_log):
@@ -4836,6 +5010,15 @@ def run_agent_chat(cfg):
                             _st.model_output = _new
                             _trim_n += 1
                             _trim_saved += _before - len(_new)
+                    # The SAME code, a second time: smolagents keeps the parsed code
+                    # action in step.tool_calls and renders it as its own message on
+                    # every request, so stripping <code> from model_output above saved
+                    # nothing on its own. Trim the duplicate too — see
+                    # _trim_tool_call_args for why this is safe.
+                    _tc_saved = _trim_tool_call_args(_st, 300)
+                    if _tc_saved:
+                        _trim_n += 1
+                        _trim_saved += _tc_saved
                 if _trim_n:
                     _log(f"context trim: shrank {_trim_n} old step field(s), "
                          f"saved ~{_trim_saved} chars (#63/#87)")
@@ -4852,9 +5035,20 @@ def run_agent_chat(cfg):
                     _tu = getattr(step_log, "token_usage", None)
                     _in_tok = int(getattr(_tu, "input_tokens", 0) or 0) if _tu else 0
                     if _in_tok <= 0:
-                        _chars = sum(len(getattr(_s, "model_output", "") or "")
-                                     + len(getattr(_s, "observations", "") or "")
-                                     for _s in _steps)
+                        # Count every field that ActionStep.to_messages actually renders —
+                        # model_output, the tool-call arguments, and observations. The
+                        # tool_calls term used to be missing, which under-counted exactly
+                        # the part that grows fastest (the duplicated code action), so a
+                        # server that reports no usage would reach the ask late or never.
+                        _chars = 0
+                        for _s in _steps:
+                            _chars += len(getattr(_s, "model_output", "") or "")
+                            _chars += len(getattr(_s, "observations", "") or "")
+                            for _tc in (getattr(_s, "tool_calls", None) or []):
+                                _a = getattr(_tc, "arguments", None)
+                                # str = the code action; anything else renders as JSON,
+                                # so charge it a small flat cost rather than guessing.
+                                _chars += len(_a) if isinstance(_a, str) else 80
                         _in_tok = _chars // 4 + 7000  # + fixed system/reference baseline
                     if _in_tok >= _COMPACT_ASK_TOKENS and len(_steps) > 2:
                         if _compact_state["decision"] != "always":
@@ -4922,7 +5116,8 @@ def run_agent_chat(cfg):
     # and any step memory it accumulates. completion_kwargs["messages"] here is the
     # literal messages array sent to /v1/chat/completions.
     class _LoggingModel(OpenAIServerModel):
-        def __init__(self, *a, stream_agent=False, save_full_response=False, **kw):
+        def __init__(self, *a, stream_agent=False, save_full_response=False,
+                     openai_backend=False, **kw):
             # Running total of PROMPT (input) tokens sent to the CODE model across the
             # turn (task #83). Only this wrapper counts — the chat/brain helper calls
             # (_chat_completion) don't route through here, so this is "code model only".
@@ -4952,6 +5147,19 @@ def run_agent_chat(cfg):
             # per-turn call counter used as the stored `step`.
             self._save_full_response = bool(save_full_response)
             self._call_index = 0
+            # Task #113: the coding backend is an explicit OpenAI-compatible endpoint
+            # (Settings → kind=openai), which in practice means a cloud REASONING model.
+            # Everything gated on this flag is OFF for Ollama and for Auto/MLX, so those
+            # paths keep behaving exactly as they do today (the user switches back and
+            # forth between Kimi and Ollama and the Ollama path must not move).
+            self._openai_backend = bool(openai_backend)
+            # Consecutive steps (openai backend only) that ended with NO runnable code
+            # block at all — prose, empty output, a dangling tag, or a recovery we had to
+            # reject. Distinct from _parse_fail_streak, which counts blocks that EXIST but
+            # won't compile. Without this, a coder that never emits a parseable block just
+            # loops to the step budget: the live trace burned 25k prompt tokens over three
+            # steps and still had to be Ctrl+C'd by the user.
+            self._no_code_streak = 0
             super().__init__(*a, **kw)
 
         def _generate_once(self, *args, **kwargs):
@@ -5105,51 +5313,10 @@ def run_agent_chat(cfg):
             return content, role, in_tok, out_tok, reasoning_len
 
         def _recover_code_from_channels(self, content, reasoning):
-            """Recover a <code>…</code> tool call that a reasoning model placed in the
-            REASONING channel instead of the visible message (task #111). No-op when the
-            visible content already has a usable code block, or when there is no reasoning
-            text (e.g. Ollama with reasoning_effort='none') — so the Ollama path is unchanged.
-
-            Kimi K3 @ Moonshot splits its output two ways when it fails: (a) the full
-            <code>…</code> block lands in reasoning and only prose leaks to content; or
-            (b) the OPENER + code land in reasoning while the CLOSING </code> leaks into
-            content (seen live: content = 'Thought: …contains.</code>'). Handle both."""
-            _pair = r"<code[^>]*>[\s\S]*?</code>"
-            if re.search(_pair, content or "", re.I):
-                return content  # content already has a usable block — never override it
-            reasoning = reasoning or ""
-            if not reasoning.strip():
-                return content  # nothing to recover from (Ollama / non-reasoning model)
-            code = None
-            # (a) Prefer a COMPLETE block already inside reasoning (the model drafts the
-            # whole tool call there) — take the LAST one, ignoring any stray </code> in content.
-            last = None
-            for last in re.finditer(r"<code[^>]*>([\s\S]*?)</code>", reasoning, re.I):
-                pass
-            if last:
-                code = last.group(1)
-            else:
-                # (b) Opener + code in reasoning, closer leaked to content → take everything
-                # after the LAST opener in reasoning (its </code> is the one now in content).
-                m = None
-                for m in re.finditer(r"<code[^>]*>([\s\S]*)$", reasoning, re.I):
-                    pass
-                if m:
-                    code = m.group(1)
-            if code is None:
-                return content
-            # A leaked 'Thought:' line (or a stray </code>) can ride along after the code —
-            # cut it so only the executable snippet remains.
-            code = re.split(r"\n\s*Thought\s*:\s", code, maxsplit=1)[0]
-            code = re.sub(r"</?code[^>]*>", "", code, flags=re.I).strip()
-            if not code:
-                return content
-            # Keep the visible Thought prose (strip any stray/unbalanced code tags), then
-            # append the recovered block so smolagents parses a clean Thought → <code> pair.
-            prose = re.sub(r"</?code[^>]*>", "", content or "", flags=re.I).strip()
-            rebuilt = (prose + "\n" if prose else "") + "<code>\n" + code + "\n</code>"
-            _log(f"#111 recovered <code> block from reasoning channel ({len(code)} chars)")
-            return rebuilt
+            """Thin wrapper over the module-level _recover_code_from_reasoning (kept as a
+            method so the streaming path reads the same). The logic lives at module scope
+            so it can be exercised directly by the offline replay checks."""
+            return _recover_code_from_reasoning(content, reasoning)
 
         # Injected when a turn produced ONLY reasoning and no message content — a hard,
         # model-agnostic steer to emit the actionable code block instead of more analysis.
@@ -5193,13 +5360,16 @@ def run_agent_chat(cfg):
             #       "regex pattern <code> was not found" error and burns the step before its
             #       own retry recovers. A finished PROSE answer has NO code tags, so it never
             #       trips this — it flows to the auto-wrap path in generate() untouched.
+            #   (3) PROSE-ONLY plan — the model spent the turn narrating what it is ABOUT
+            #       to do and emitted no code tag whatsoever (seen live with Kimi K3 step 1:
+            #       221 chars of "I'll scaffold a NestJS project…", 3246 chars of reasoning,
+            #       nothing runnable). Trigger (2) missed this: the "</code>" that shows up
+            #       in the trace is appended by SMOLAGENTS after we return (its stop-sequence
+            #       handling), so the content WE see here carries no tag at all. Openai-only.
+            # See _code_nudge_reason for the full decision (kept pure so it can be replayed).
             _pair_re = r"<code[^>]*>[\s\S]*?</code>"
-            _has_pair = re.search(_pair_re, content or "", re.I) is not None
-            _broken_code = (not _has_pair) and (
-                re.search(r"</?code[\s>/]", content or "", re.I) is not None
-            )
-            if not content.strip() or _broken_code:
-                why = "empty-content" if not content.strip() else "dangling code tag, no valid block"
+            why = _code_nudge_reason(content, self._openai_backend)
+            if why:
                 _log(f"{why} turn (reasoning={reasoning_len} chars) → retrying once with a "
                      "'code now' directive")
                 _emit({"type": "step",
@@ -5509,12 +5679,92 @@ def run_agent_chat(cfg):
                                 f"scratchpad-like prose ({len(stripped)} chars, no tool call) "
                                 "→ NOT auto-wrapping; letting the step fail normally"
                             )
+                # Loop-breaker for reasoning coders (#113). _parse_fail_streak above only
+                # counts blocks that EXIST but won't compile, so a coder that never emits a
+                # usable block at all — prose plans, empty turns, a dangling tag, or a
+                # recovery we rejected — never trips it and just burns the step budget
+                # (live: 3 steps, ~25k prompt tokens, zero progress, user had to Ctrl+C).
+                # Count consecutive no-block steps here and finish honestly instead. The
+                # check is on the FINAL msg.content, so anything the repairs above rescued
+                # (including the _parse_fail_streak fallback, which injects a compilable
+                # final_answer) resets the streak. openai backend only — an Ollama coder
+                # keeps looping exactly as long as it does today.
+                if self._openai_backend:
+                    if _has_runnable_block(msg.content):
+                        self._no_code_streak = 0
+                    else:
+                        self._no_code_streak += 1
+                        _log("no runnable code block this step "
+                             f"(no-code streak {self._no_code_streak}/3, #113)")
+                        if self._no_code_streak >= 3:
+                            _log("no-code streak hit limit → ending the turn honestly "
+                                 "instead of looping on a coder that won't emit code")
+                            _nocode_msg = (
+                                "I had to stop: the coding model kept replying with "
+                                "explanations instead of a runnable code block, so none of "
+                                "my steps could actually execute. This is usually a "
+                                "reasoning model putting its answer in the thinking channel. "
+                                "Try a non-reasoning coding model, or switch the coding "
+                                "backend back to Ollama in Settings, then run this again."
+                            )
+                            msg.content = ("<code>\nfinal_answer("
+                                           + repr(_nocode_msg) + ")\n</code>")
+                            self._no_code_streak = 0
+                            self._parse_fail_streak = 0
             except Exception as e:  # noqa: BLE001
                 _log(f"content-normalize error: {e}")
             return msg
 
+        # Replaces smolagents' stock code-parsing error for reasoning backends (#113).
+        # The stock text spells out the delimiters twice ("the regex pattern <code>(.*?)
+        # </code> was not found", "for instance: … <code> # Your python code here </code>")
+        # and quotes the model's own broken output back at it. A reasoning model MIRRORS
+        # those tokens: the live trace shows Kimi K3 answering the error with the literal
+        # words "and closing with" wrapped in code tags — it was completing the sentence
+        # from the prompt, not writing code. Deliberately carries NO literal delimiter (the
+        # system prompt already shows the format with a worked example), so there is nothing
+        # to echo. Applied only when kind=openai; Ollama keeps the stock message.
+        _PARSE_ERROR_REPLACEMENT = (
+            "Error: your last reply contained no runnable code block, so nothing executed "
+            "and no observation was produced.\n"
+            "Reply with ONE 'Thought:' line, then the code block using the exact opening and "
+            "closing delimiters shown in the system prompt, with ONLY Python between them — "
+            "no prose inside the block, and do not repeat these instructions back to me. "
+            "Call exactly one tool, or call final_answer(...) if you are done."
+        )
+
+        def _sanitize_parse_errors(self, msgs):
+            """Swap smolagents' code-parsing error text for a delimiter-free directive
+            (see _PARSE_ERROR_REPLACEMENT). No-op unless the backend is kind=openai, and
+            no-op on every other kind of message — genuine SyntaxError feedback from a
+            block that DID run is left intact, since that is real information."""
+            if not self._openai_backend:
+                return
+            n = 0
+            for m in msgs or []:
+                if not isinstance(m, dict):
+                    continue  # _prepare_completion_kwargs already returns plain dicts
+                c = m.get("content")
+                if isinstance(c, str):
+                    if "Error in code parsing" in c:
+                        m["content"] = self._PARSE_ERROR_REPLACEMENT
+                        n += 1
+                elif isinstance(c, list):
+                    for part in c:
+                        if (isinstance(part, dict) and isinstance(part.get("text"), str)
+                                and "Error in code parsing" in part["text"]):
+                            part["text"] = self._PARSE_ERROR_REPLACEMENT
+                            n += 1
+            if n:
+                _log(f"#113 replaced {n} code-parsing error message(s) with a "
+                     "delimiter-free directive (openai backend)")
+
         def _prepare_completion_kwargs(self, *args, **kwargs):
             ck = super()._prepare_completion_kwargs(*args, **kwargs)
+            try:
+                self._sanitize_parse_errors(ck.get("messages", []) or [])
+            except Exception as e:  # noqa: BLE001
+                _log(f"#113 parse-error sanitize skipped: {e}")
             # Disable Qwen3 "thinking" for the agent loop. Live runs showed thinking-on
             # spends the whole completion budget on a <think> trace and returns
             # content=None (no code block) → parse-error spiral → WS timeout. The
@@ -5692,6 +5942,10 @@ def run_agent_chat(cfg):
             stream_agent=_stream_coder,
             # Task #107: persist each code-model response to Mongo when the user opted in.
             save_full_response=save_full_response,
+            # Task #113: enables the reasoning-model repairs (prose-only nudge, parse-error
+            # sanitizing, no-code breaker). Explicit kind=openai ONLY — Ollama and Auto/MLX
+            # never take those branches.
+            openai_backend=(coding_kind == "openai"),
             # Cap each HTTP attempt at 600s so a genuinely slow single call (a
             # remote M6000/Vulkan box doing a cold ~4-5min prompt-eval) can finish
             # on the first try, while a truly hung request still fails into OUR

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gonext-local-worker",
-  "version": "1.0.318",
+  "version": "1.0.320",
   "description": "Polls GoNext cloud API for async local LLM jobs and runs them against Ollama/OpenAI-compatible servers on this Mac",
   "type": "module",
   "license": "MIT",