npm - @tiens.nguyen/gonext-local-worker - Versions diffs - 1.0.260 → 1.0.261 - Mend

@tiens.nguyen/gonext-local-worker 1.0.260 → 1.0.261

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 (3) hide show

package/gonext-repl.mjs CHANGED Viewed

@@ -1025,13 +1025,20 @@ const normalizeThought = (buf) => {
   const t = String(buf || "");
   const ci = t.search(/<code[\s>]/i);
   const head = ci >= 0 ? t.slice(0, ci) : t;
-  // 1) a genuine Thought prose line (before the code) — only if it isn't itself code.
+  // 1) a genuine Thought prose line (before the code) — only if it isn't itself code AND
+  //    reads like an actual clause. A streaming token boundary can leave the first
+  //    non-empty line as a single bare word (e.g. "string", when the model is rambling
+  //    about "multi-line strings"); shown alone on the blinking line it's meaningless and,
+  //    because liveThought only updates on a truthy value, it can FREEZE there through a
+  //    long silent prompt-eval ("string… (777s)"). Require ≥2 words and a little length so
+  //    a lone fragment falls through to the tool label / "Thinking…" instead.
   const prose = head
     .replace(/^\s*Thought:\s*/i, "")
     .split(/\n/)
     .map((x) => x.trim())
     .find(Boolean);
-  if (prose && !_thoughtLooksCodey(prose)) return prose.slice(0, 100);
+  const proseIsClause = !!prose && prose.length >= 6 && prose.trim().split(/\s+/).length >= 2;
+  if (proseIsClause && !_thoughtLooksCodey(prose)) return prose.slice(0, 100);
   // 2) otherwise name the tool being called (from the code part).
   const codePart = ci >= 0 ? t.slice(ci) : t;
   const m = /(?:<code>\s*)?\b([a-z_]\w*)\s*\(\s*(?:path\s*=\s*)?["']?([^"'\n,)]*)/i.exec(codePart);
@@ -1117,6 +1124,7 @@ async function runAgentTurn(history) {
   // "◐ working… (7s)" — instead of dumping the model's rambling reasoning and stamping a
   // "✔ completed thought" on every token-stream micro-pause (the reported clutter).
   const QUIET_MS = 700; // stream idle this long ⇒ we're waiting on the model
+  const STALE_THOUGHT_MS = 25000; // no new tokens this long ⇒ the current Thought clause is stale (#95 A)
   let lastContentAt = Date.now();
   let thinking = false;
   let thinkingSince = 0;
@@ -1154,6 +1162,11 @@ async function runAgentTurn(history) {
       thinking = true; thinkingSince = lastContentAt; thinkWord = pickWord(); lastWordBucket = 0;
     }
     const now = Date.now();
+    // Age out a stale Thought clause: if the model has produced NO new stream content for a
+    // while (e.g. a 150s+ silent prompt-eval on a huge context), the last clause is no longer
+    // "what it's doing now" — drop it so the line falls back to the playful word / "Thinking…"
+    // instead of freezing on an old thought while the timer climbs ("string… (777s)", #95 A).
+    if (liveThought && now - lastContentAt > STALE_THOUGHT_MS) liveThought = "";
     const secs = thinkSecs();
     // Rotate the playful word once per 12s window (guarded so the fast ticker doesn't
     // re-roll it many times within the same second).

package/gonext_agent_chat.py CHANGED Viewed

@@ -1077,6 +1077,35 @@ def _plain_reply(messages: list, base_url: str, api_key: str, model_id: str,
     raise RuntimeError(f"couldn't get a response ({_clip(str(last_err), 160)})")
+# A model-server call can fail for two very different reasons, and they deserve
+# different handling:
+#   • the BACKEND is unavailable — an nginx 502/503/504 (the upstream Ollama/MLX box is
+#     down, restarting, still loading the weights, or overloaded past the proxy's read
+#     timeout), or the socket refused/timed out. These are INFRA outages: retrying a bit
+#     harder can ride out a blip, and if it persists the honest thing is to SAY the
+#     coding backend is down — never to hallucinate a generic answer as if we succeeded.
+#   • 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_unavailable(err) -> bool:
+    s = str(err or "").lower()
+    return (
+        "502 bad gateway" in s
+        or "503 service" in s
+        or "504 gateway" in s
+        or "bad gateway" in s
+        or "gateway time-out" in s
+        or "gateway timeout" in s
+        or "connection refused" in s
+        or "connection reset" in s
+        or "connection aborted" in s
+        or "failed to establish a new connection" in s
+        or "max retries exceeded" in s
+        or "read timed out" in s
+        or "timed out" in s
+    )
 def _synthesize_document(gathered: list, task: str, base_url: str, api_key: str,
                          model_id: str) -> str:
     """Turn raw gathered research observations into ONE clean, organized document body
@@ -1179,11 +1208,19 @@ def _normalize_code_tags(text: str) -> str:
     return fixed
-def _escape_raw_newlines_in_strings(code: str) -> str:
+def _escape_raw_newlines_in_strings(code: str, defuse_tags: bool = False) -> str:
     """Turn RAW newlines/tabs that sit INSIDE a single/double-quoted string literal into
     \\n/\\t escapes. Triple-quoted strings, comments, and everything outside a string are
     copied verbatim. A tiny hand-rolled scanner (the code doesn't parse, so ast/tokenize
-    can't help). Used only by _repair_unterminated_string below."""
+    can't help). Used by _repair_unterminated_string below.
+    defuse_tags: also rewrite a literal <code>/</code> that appears INSIDE a string literal
+    (e.g. the file content the model is writing legitimately contains React's default
+    "Edit <code>src/App.js</code>") to <co\\x64e>/</co\\x64e>. The `\\x64` is Python's hex
+    escape for 'd', so at RUNTIME the string is still exactly "<code>"/"</code>" — but the
+    literal source no longer contains the token smolagents uses as its code-block delimiter,
+    so its parser can't mis-close the block on content. Only touches tags inside strings;
+    the real closing </code> lives OUTSIDE any string and is left intact."""
     out = []
     i, n = 0, len(code)
     quote = None      # the delimiter of the string we're inside, or None
@@ -1196,7 +1233,10 @@ def _escape_raw_newlines_in_strings(code: str) -> str:
                 end = code.find(three, i + 3)
                 if end == -1:
                     out.append(code[i:]); break
-                out.append(code[i:end + 3]); i = end + 3; continue
+                seg = code[i:end + 3]
+                if defuse_tags:
+                    seg = seg.replace("</code>", "</co\\x64e>").replace("<code>", "<co\\x64e>")
+                out.append(seg); i = end + 3; continue
             if ch == "#":                          # comment — copy to end of line
                 j = code.find("\n", i)
                 if j == -1:
@@ -1212,6 +1252,11 @@ def _escape_raw_newlines_in_strings(code: str) -> str:
                 out.append(ch); escaped = True; i += 1; continue
             if ch == quote:
                 out.append(ch); quote = None; i += 1; continue
+            # Defuse a delimiter-colliding tag INSIDE the string (see docstring).
+            if defuse_tags and code.startswith("</code>", i):
+                out.append("</co\\x64e>"); i += 7; continue
+            if defuse_tags and code.startswith("<code>", i):
+                out.append("<co\\x64e>"); i += 6; continue
             out.append({"\n": "\\n", "\r": "\\r", "\t": "\\t"}.get(ch, ch)); i += 1
     return "".join(out)
@@ -1242,15 +1287,42 @@ def _repair_unterminated_string(code: str) -> str:
 def _repair_code_block_strings(text: str) -> str:
     """Apply _repair_unterminated_string to the python inside a <code>…</code> block
     (leaving the surrounding Thought prose untouched). No-op when there's no block or the
-    block already parses."""
-    m = re.search(r"<code>([\s\S]*?)</code>", text)
-    if not m:
+    block already parses.
+    Two-stage rescue:
+      1. NON-GREEDY span (first <code> → first </code>) + raw-newline escaping — the common
+         case (multi-line file content with unescaped newlines).
+      2. If that still won't compile AND the content itself contains extra </code> tags
+         (the model is writing a file whose CONTENT legitimately has <code>/</code> — e.g.
+         React's default App.js "Edit <code>src/App.js</code>"), the non-greedy match closed
+         the block early on that inner tag → a truncated, unterminatable fragment. Retry with
+         the GREEDY span (first <code> → LAST </code>) and defuse the in-string tags so the
+         only real </code> left is the true closer. This is the fix for the create_file loop
+         where the coder burned minutes/100k+ tokens on 'unterminated string literal'."""
+    om = re.search(r"<code>", text)
+    if not om:
         return text
-    inner = m.group(1)
-    fixed = _repair_unterminated_string(inner)
-    if fixed == inner:
+    open_end = om.end()
+    cm = re.search(r"</code>", text[open_end:])
+    if not cm:
         return text
-    return text[:m.start(1)] + fixed + text[m.end(1):]
+    close_start = open_end + cm.start()
+    inner = text[open_end:close_start]
+    fixed = _repair_unterminated_string(inner)
+    if fixed != inner:
+        return text[:open_end] + fixed + text[close_start:]
+    # Stage 2 — only worth trying when there's MORE than one </code> (extra tags in content).
+    last = text.rfind("</code>")
+    if last <= close_start:
+        return text  # single </code>; nothing a greedy re-read would change
+    greedy = text[open_end:last]
+    sanitized = _escape_raw_newlines_in_strings(greedy, defuse_tags=True)
+    try:
+        compile(sanitized, "<gonext-code>", "exec")
+    except Exception:  # noqa: BLE001
+        return text  # still not parseable — leave it for the loop-breaker / model retry
+    # Rebuild so the FIRST literal </code> is now the true closer (inner ones are defused).
+    return text[:open_end] + sanitized + text[last:]
 def _strip_think(text: str) -> str:
@@ -4173,6 +4245,12 @@ def run_agent_chat(cfg):
             # Largest SINGLE-request prompt-token count seen this turn (task #84) — the
             # peak context size, not the sum. The REPL keeps a per-workspace max of this.
             self._code_tokens_max = 0
+            # Loop-breaker (#95 B1): how many CONSECUTIVE generations have produced a code
+            # block that STILL won't compile after our repair. A weak coder can get stuck
+            # re-emitting the same unparseable tool call (seen live: create_file with a
+            # multi-line string, ~10 identical retries, 863s/133k tokens). After a few in a
+            # row we stop feeding smolagents an un-runnable block and finish honestly.
+            self._parse_fail_streak = 0
             # stream_agent: request the completion with stream=True and reassemble the
             # deltas into one message. Enabled for Ollama, where a long single-shot
             # (non-stream) generation sends nothing until the very end — a reverse proxy
@@ -4445,9 +4523,16 @@ def run_agent_chat(cfg):
             hb.start()
             last_err = None
             try:
-                for attempt in range(3):
+                # A gateway outage (502/503/504, refused/reset/timeout) is transient infra —
+                # the remote box may just be cold or the proxy briefly down — so give it MORE
+                # attempts and a longer backoff to ride out a blip, instead of the 3 quick
+                # tries a normal error gets. The attempt count is decided per-error: we start
+                # with the generic budget and extend it the moment we see a gateway error.
+                attempt, max_attempts = 0, 3
+                while attempt < max_attempts:
                     try:
                         msg = self._generate_once(*args, **kwargs)
+                        last_err = None
                         break
                     except Exception as e:  # noqa: BLE001
                         emsg = str(e)
@@ -4465,10 +4550,19 @@ def run_agent_chat(cfg):
                                 "names (for Ollama use the tag, e.g. qwen3:14b)."
                             ) from e
                         last_err = e
-                        if attempt < 2:
-                            _log(f"generate transient error (attempt {attempt + 1}/3): {e} — retrying")
-                            time.sleep(1.5 * (attempt + 1))
-                else:
+                        gateway = _is_backend_unavailable(e)
+                        if 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
+                            kind = "gateway/backend unavailable" if gateway else "transient"
+                            _log(f"generate {kind} error (attempt {attempt}/{max_attempts}): "
+                                 f"{_clip(emsg, 160)} — retrying in {delay:.0f}s")
+                            time.sleep(delay)
+                if last_err is not None:
                     raise last_err
             finally:
                 hb_stop.set()
@@ -4532,7 +4626,42 @@ def run_agent_chat(cfg):
                             _log("repaired unterminated string literal in tool-call code")
                         if repaired != content:
                             msg.content = repaired
+                        # Loop-breaker (#95 B1): if the block STILL won't compile after the
+                        # repair, the model is stuck emitting an unparseable tool call. Count
+                        # consecutive failures; after a few, finish honestly rather than burn
+                        # the whole step budget — each retry is a full (often 150s+) model
+                        # call on an ever-growing context. B2's greedy/defuse fix means the
+                        # <code>-in-content collision now compiles here, so this only trips on
+                        # genuinely un-fixable code (e.g. a truncated generation).
+                        _cb = re.search(r"<code>([\s\S]*?)</code>", msg.content or "")
+                        _still_bad = False
+                        if _cb:
+                            try:
+                                compile(_cb.group(1), "<gonext-code>", "exec")
+                            except Exception:  # noqa: BLE001
+                                _still_bad = True
+                        if _still_bad:
+                            self._parse_fail_streak += 1
+                            _log("tool-call code still unparseable after repair "
+                                 f"(streak {self._parse_fail_streak}/3)")
+                            if self._parse_fail_streak >= 3:
+                                _log("parse-fail streak hit limit → ending the turn honestly "
+                                     "instead of looping on an unparseable tool call")
+                                _stuck_msg = (
+                                    "I got stuck on a code-formatting error: my edit to the "
+                                    "file kept failing to parse (a string/escaping issue in the "
+                                    "tool call), so I stopped instead of retrying in a loop. "
+                                    "Any dev server I started is still running. Please try "
+                                    "again, or tell me the specific change to make and I'll "
+                                    "keep it to a small, single-line edit."
+                                )
+                                msg.content = ("<code>\nfinal_answer("
+                                               + repr(_stuck_msg) + ")\n</code>")
+                                self._parse_fail_streak = 0
+                        else:
+                            self._parse_fail_streak = 0
                     else:
+                        self._parse_fail_streak = 0  # a prose turn isn't a parse failure
                         stripped = content.strip()
                         looks_final = (
                             len(stripped) >= 400 or re.search(
@@ -5778,6 +5907,26 @@ def run_agent_chat(cfg):
             _log(f"agent config error (not degrading): {cfg_err}")
             _emit({"type": "final", "text": f"⚠️ {cfg_err}"})
             return
+        # Coding-model BACKEND outage (502/503/504, refused/timeout): the tool-capable
+        # loop never got to run because its code model was unreachable. Do NOT fall through
+        # to _plain_reply — a bare chat model would stream a confident GENERIC how-to (e.g.
+        # "to create a React app, run npx create-react-app…") that looks like a real answer
+        # but did NOTHING the user asked (seen live: "create a reactjs and start it" → the
+        # coder 502'd 3× → generic instructions, no warning). That's worse than an honest
+        # 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.
+        if _is_backend_unavailable(e):
+            _log(f"agent error (coding-model backend unavailable, NOT degrading): {_clip(str(e), 160)}")
+            _emit({"type": "final", "text": (
+                "⚠️ The coding model backend is currently unavailable (the server returned "
+                "a gateway error / timed out), so I couldn't run the tools to do this. It's "
+                "usually starting up, reloading the model, or briefly overloaded — not a "
+                "problem with your request. Please try again in a moment; if it keeps "
+                "happening, check that the coding model server is up. (I didn't make any "
+                "changes.)"
+            )})
+            return
         # An unexpected failure inside the agent loop should still return a useful
         # answer from the conversation rather than surfacing a raw error to the user —
         # but only when the fallback ACTUALLY has something useful to say.

package/package.json CHANGED Viewed

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