npm - @tiens.nguyen/gonext-local-worker - Versions diffs - 1.0.318 → 1.0.322 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/gonext_agent_chat.py +482 -62
package/package.json +1 -1

package/gonext_agent_chat.py CHANGED Viewed

@@ -25,6 +25,7 @@ Emits NDJSON lines on stdout:
 """
 import contextlib
 import json
+import random
 import re
 import sys
 import threading
@@ -820,6 +821,22 @@ class _AgentConfigError(RuntimeError):
     worth a plain-reply degrade — the user needs the message itself to fix Settings."""
+class _AgentBackendOverloaded(RuntimeError):
+    """The coding backend refused every attempt with 429/rate-limit (task #114). Carries
+    the user-facing explanation; like a gateway outage it must NOT degrade to a plain
+    reply, which would answer from the chat model as if the work had been done."""
+def _host_of(url) -> str:
+    """Just the hostname of a base URL ('https://api.moonshot.ai/v1' → 'api.moonshot.ai'),
+    for user-facing messages. Falls back to the raw string."""
+    try:
+        from urllib.parse import urlparse
+        return urlparse(str(url or "")).netloc or str(url or "")
+    except Exception:  # noqa: BLE001
+        return str(url or "")
 def _list_model_ids(base_url, api_key=""):
     """Return the model ids an OpenAI-compatible server reports at {base_url}/models.
@@ -1452,8 +1469,92 @@ def _plain_reply(messages: list, base_url: str, api_key: str, model_id: str,
 #   • a genuine model/agent error — worth the plain-reply degrade.
 # `str(e)` for a proxy error is the raw nginx HTML ("<html>…502 Bad Gateway…"), so match
 # on the status text/codes and the common connection-failure phrases.
+def _is_backend_overloaded(err) -> bool:
+    """True when the model server ACCEPTED the connection but REFUSED the work because it
+    is saturated or we are over a quota — 429 / engine_overloaded / rate limit (task #114).
+    Deliberately separate from _is_backend_unavailable: that one means "the box or proxy
+    is not answering" (retry the same request, it will probably land), while this means
+    "the server is telling us to slow down" (re-sending immediately makes it worse and can
+    deepen the limit). The two get different retry budgets and different user-facing copy.
+    Live trigger: Moonshot returned
+      Error code: 429 - {'error': {'message': 'The engine is currently overloaded, please
+      try again later', 'type': 'engine_overloaded_error'}}
+    A local Ollama/MLX box does not produce these, so nothing keyed off this fires there."""
+    s = str(err or "").lower()
+    if "429" in s or "too many requests" in s:
+        return True
+    return (
+        "engine_overloaded" in s
+        or "overloaded" in s
+        or "rate limit" in s
+        or "rate_limit" in s
+        # OpenAI's billing/quota code. NOT a bare "quota" — a tool hitting "Disk quota
+        # exceeded" would otherwise be reported to the user as a model overload.
+        or "insufficient_quota" in s
+        or "over capacity" in s
+        or "at capacity" in s
+    )
+def _retry_after_seconds(err):
+    """The provider's Retry-After hint in seconds, or None. Reads the header off an
+    openai-python APIStatusError (`err.response.headers`) and falls back to a
+    'retry after 12 seconds' phrase in the message. Values are clamped to a sane range so
+    a bogus header can't park the turn for an hour."""
+    val = None
+    resp = getattr(err, "response", None)
+    headers = getattr(resp, "headers", None)
+    if headers is not None:
+        try:
+            val = headers.get("retry-after") or headers.get("Retry-After")
+        except Exception:  # noqa: BLE001
+            val = None
+    if val is None:
+        m = re.search(r"retry[\s-]?after[\s:]+(\d+(?:\.\d+)?)", str(err or ""), re.I)
+        val = m.group(1) if m else None
+    if val is None:
+        return None
+    try:
+        secs = float(str(val).strip())
+    except (TypeError, ValueError):
+        return None  # HTTP-date form — not worth parsing; fall back to our own backoff
+    if secs <= 0:
+        return None
+    return max(1.0, min(60.0, secs))
+def _retry_delay(attempt: int, overloaded: bool, gateway: bool, err=None) -> float:
+    """Seconds to wait before retry #attempt (1-based). Pure, so the policy can be
+    replayed offline (task #114).
+      overloaded (429) — PATIENT and jittered: ~5s → 10s → 20s → 30s (capped), plus up to
+                         25% jitter so parallel workers don't retry in lock-step. The
+                         provider's own Retry-After wins outright when it sends one.
+      gateway (502…)   — unchanged from #94: prompt re-send, 2s/4s/6s/8s capped at 8.
+      otherwise        — unchanged: 1.5s per attempt.
+    Only the `overloaded` branch is new; the other two must stay byte-for-byte, since they
+    are the path an Ollama/MLX coder takes."""
+    if overloaded:
+        hinted = _retry_after_seconds(err)
+        if hinted:
+            return hinted
+        delay = min(30.0, 5.0 * (2 ** (attempt - 1)))
+        return delay + random.uniform(0, min(3.0, delay * 0.25))
+    if gateway:
+        return min(8.0, 2.0 * attempt)
+    return 1.5 * attempt
 def _is_backend_unavailable(err) -> bool:
     s = str(err or "").lower()
+    # An overload (429) is its own class — never let it fall into the gateway bucket, whose
+    # policy (re-send promptly, up to 6 times) is exactly wrong for a server saying "slow
+    # down". Checked FIRST because a 429 body can also contain the word "timeout".
+    if _is_backend_overloaded(err):
+        return False
     return (
         "502 bad gateway" in s
         or "503 service" in s
@@ -1690,6 +1791,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 +5001,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 +5049,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 +5111,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 +5136,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 +5217,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,20 +5248,48 @@ 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):
             """One model call. Streams + reassembles when _stream_agent, else the normal
-            non-streaming path. Streaming is a pure transport optimization: on ANY failure
-            it falls back to the non-streaming call, and it's skipped for tool-calling
-            mode (tools_to_call_from), whose tool_call deltas we don't reassemble."""
+            non-streaming path. Streaming is a pure transport optimization: on a TRANSPORT
+            failure it falls back to the non-streaming call, and it's skipped for
+            tool-calling mode (tools_to_call_from), whose tool_call deltas we don't
+            reassemble.
+            Exception (task #114): an OVERLOAD (429 / engine_overloaded / rate limit) is
+            NOT a transport failure — the server refused the work. Re-sending the identical
+            request unstreamed, instantly and with no backoff, is the worst possible answer:
+            it can deepen the limit, and because a non-streamed call emits no first token it
+            then sits silent behind the 600s client timeout (live: 167s of "Thinking…" until
+            the user pressed Ctrl+C). Re-raise instead, so generate()'s retry loop applies a
+            real backoff and tells the user what is going on."""
             tools_to_call_from = kwargs.get("tools_to_call_from")
             if not self._stream_agent or tools_to_call_from:
                 return super().generate(*args, **kwargs)
             try:
                 return self._streamed_generate(*args, **kwargs)
             except Exception as e:  # noqa: BLE001
+                if _is_backend_overloaded(e):
+                    _log(f"streamed generate refused ({_clip(str(e), 200)}) → NOT falling "
+                         "back to non-streaming; letting the retry loop back off (#114)")
+                    raise
                 _log(f"streamed generate failed ({e}) → falling back to non-streaming")
+                _emit({"type": "step",
+                       "text": "Streaming unavailable — retrying without streaming…"})
                 return super().generate(*args, **kwargs)
         def _run_stream(self, completion_kwargs):
@@ -5105,51 +5429,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 +5476,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",
@@ -5335,18 +5621,45 @@ def run_agent_chat(cfg):
                                 "names (for Ollama use the tag, e.g. qwen3:14b)."
                             ) from e
                         last_err = e
-                        gateway = _is_backend_unavailable(e)
-                        if gateway and max_attempts < 6:
+                        # An OVERLOAD (429/rate limit, task #114) is its own class: the
+                        # server answered and told us to slow down, so it needs a PATIENT,
+                        # jittered backoff rather than the gateway policy's prompt re-send.
+                        # Checked first — _is_backend_unavailable already excludes it, but
+                        # the ordering keeps the intent obvious.
+                        overloaded = _is_backend_overloaded(e)
+                        gateway = (not overloaded) and _is_backend_unavailable(e)
+                        if (overloaded or gateway) and max_attempts < 6:
                             max_attempts = 6  # stretch the budget for a flaky backend
                         attempt += 1
                         if attempt < max_attempts:
                             # Longer, capped backoff for gateway errors (up to ~8s) so a
-                            # cold/loading model has time to come back; short for the rest.
-                            delay = min(8.0, 2.0 * attempt) if gateway else 1.5 * attempt
+                            # cold/loading model has time to come back; short for the rest;
+                            # patient + jittered for an overload. See _retry_delay.
+                            delay = _retry_delay(attempt, overloaded, gateway, e)
                             kind = "gateway/backend unavailable" if gateway else "transient"
+                            if overloaded:
+                                kind = "backend overloaded (429/rate limit)"
+                                # SURFACE IT: without this the REPL keeps showing a playful
+                                # heartbeat word and the user has no idea the provider is
+                                # refusing work (live: 167s of "Thinking…" → Ctrl+C).
+                                _emit({"type": "step",
+                                       "text": "Coding model is overloaded (429) — waiting "
+                                               f"{delay:.0f}s, then retrying "
+                                               f"(attempt {attempt + 1}/{max_attempts})…"})
                             _log(f"generate {kind} error (attempt {attempt}/{max_attempts}): "
                                  f"{_clip(emsg, 160)} — retrying in {delay:.0f}s")
                             time.sleep(delay)
+                        elif overloaded:
+                            # Out of attempts: end the turn with a cause the user can act on
+                            # instead of a bare stack trace (same spirit as #94's 502 copy).
+                            _log("backend overloaded after all attempts → failing honestly")
+                            raise _AgentBackendOverloaded(
+                                "The agent coding model backend "
+                                f"({_host_of(coding_base_url)}) is overloaded right now and "
+                                f"refused {max_attempts} attempts (HTTP 429). Nothing ran. "
+                                "Please try again in a minute, or switch the coding backend "
+                                "in Settings → Agent."
+                            ) from e
                 if last_err is not None:
                     raise last_err
             finally:
@@ -5509,12 +5822,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 +6085,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
@@ -6756,6 +7153,29 @@ def run_agent_chat(cfg):
         # failure: it hides the outage and, being persisted to history, misleads the next
         # turn. Emit a clear, standalone "backend is down, retry" and stop — the checkpoint
         # is kept (not cleared) so a later "continue" resumes once the box is back.
+        # Coding-model OVERLOAD (429/rate limit, task #114): same reasoning as the outage
+        # branch below — the tools never ran, so degrading to _plain_reply would invent a
+        # confident how-to for work that didn't happen. Reported separately because the
+        # cause and the advice differ: the server is UP, it's just saturated or we're over
+        # quota, so "try again shortly" is the honest fix. Checked BEFORE the outage branch
+        # (_is_backend_unavailable deliberately excludes overloads).
+        if _is_backend_overloaded(e):
+            _log(f"agent error (coding-model backend OVERLOADED, NOT degrading): {_clip(str(e), 160)}")
+            _ov = None
+            _cur, _depth = e, 0
+            while _cur is not None and _depth < 6:
+                if isinstance(_cur, _AgentBackendOverloaded):
+                    _ov = _cur
+                    break
+                _cur, _depth = (getattr(_cur, "__cause__", None)
+                                or getattr(_cur, "__context__", None)), _depth + 1
+            _emit({"type": "final", "text": "⚠️ " + (str(_ov) if _ov else (
+                "The coding model backend is overloaded right now (HTTP 429 — it asked me "
+                "to slow down), so I couldn't run the tools to do this. The server is up, "
+                "it's just saturated or over quota. Please try again in a minute, or switch "
+                "the coding backend in Settings → Agent. (I didn't make any changes.)"
+            ))})
+            return
         if _is_backend_unavailable(e):
             _log(f"agent error (coding-model backend unavailable, NOT degrading): {_clip(str(e), 160)}")
             _emit({"type": "final", "text": (

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gonext-local-worker",
-  "version": "1.0.318",
+  "version": "1.0.322",
   "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",