@tiens.nguyen/gonext-local-worker 1.0.189 → 1.0.191

package/gonext-repl.mjs

@@ -306,6 +306,13 @@ async function runAgentTurn(history) {
   const tick = () => {
     if (!following || followAborted || !jobRunning) return;
     if (Date.now() - lastContentAt < QUIET_MS) return; // tokens still flowing
+    // A plain-reply answer streams onto a line with NO trailing newline until it's fully
+    // done — if the model pauses mid-sentence (normal token-generation jitter) and we're
+    // already partway through that open line, CLEAR_LINE can only erase the terminal's
+    // CURRENT visual row, not the whole logical line once it's wrapped — overwriting the
+    // ticker there corrupts the visible answer text mid-word. Stay silent once any of
+    // THIS line has already been shown; the next completed line (fresh, empty) is safe.
+    if (plainReplyFlow && carryFlushedLen > 0) return;
     // Count from when the stream actually went quiet, so the seconds reflect the true
     // wait for the first token (1s, 2s, 3s…) rather than from the first tick.
     if (!thinking) { thinking = true; thinkingSince = lastContentAt; thinkWord = pickWord(); }

package/gonext_agent_chat.py

@@ -829,7 +829,13 @@ def _plain_reply(messages: list, base_url: str, api_key: str, model_id: str,
     and delivering it in one burst) — the worker renders these as the live-updating MAIN
     answer, not the collapsible Thinking panel. If the primary model is unreachable (e.g.
     the local MLX server is down) and a distinct fallback model is given (the coding
-    model), retry there so a greeting still gets answered instead of erroring."""
+    model), retry there so a greeting still gets answered instead of erroring.
+
+    RAISES (does not return a sentinel string) if every target fails or returns no
+    content — callers that want a soft degrade should catch this locally and substitute
+    their own clean message; letting it propagate uncaught turns into a genuine job
+    failure (red error, never persisted to conversation history) instead of a fabricated
+    "answer" that would poison every future turn's prompt with raw exception text."""
     _THINK_RE_LOCAL = re.compile(r"<think>.*?</think>", re.DOTALL | re.IGNORECASE)
     chat_messages = [{"role": "system", "content": "You are a helpful assistant."}]
     for m in messages:
@@ -863,24 +869,38 @@ def _plain_reply(messages: list, base_url: str, api_key: str, model_id: str,
             from openai import OpenAI
             client = OpenAI(base_url=b, api_key=api_key or "local",
                             max_retries=0, timeout=60)
-            return _chat_create_stream(
+            text = _chat_create_stream(
                 client, _track,
                 model=mid,
                 messages=chat_messages,
                 temperature=0.7,
                 max_tokens=512,
             ).strip()
+            if text:
+                return text
+            # The call SUCCEEDED (no exception) but the model produced NO content at all —
+            # seen with a reasoning model given a confusing/degenerate prompt (e.g. a prior
+            # turn's history polluted with raw error text). Treat this the same as a
+            # failure: fall back to the next target, or surface a clean message, rather
+            # than silently returning "" (which the caller can't tell apart from a real,
+            # deliberately empty answer).
+            last_err = RuntimeError(f"{mid} returned an empty response")
         except Exception as e:  # noqa: BLE001
             last_err = e
-            if emitted_here:
-                # Part of THIS attempt's answer already streamed to the user — don't
-                # silently splice a DIFFERENT model's output after a partial one.
-                break
-            if i + 1 < len(targets):
-                nb, nmid = targets[i + 1]  # the model we're about to try next
-                _log(f"plain reply: {mid} @ {b} failed ({e}); "
-                     f"falling back to {nmid} @ {nb}")
-    return f"[Error: {last_err}]"
+        if emitted_here:
+            # Part of THIS attempt's answer already streamed to the user — don't
+            # silently splice a DIFFERENT model's output after a partial one.
+            break
+        if i + 1 < len(targets):
+            nb, nmid = targets[i + 1]  # the model we're about to try next
+            _log(f"plain reply: {mid} @ {b} failed ({last_err}); "
+                 f"falling back to {nmid} @ {nb}")
+    # Every target failed or returned nothing — raise rather than return a sentinel
+    # string. A returned string always looks like a legitimate answer to callers (and
+    # gets persisted to conversation history); raising lets it become a genuine job
+    # failure instead (see docstring). Kept short/clean (no embedded newlines/HTML — a
+    # raw nginx 502 page can be a whole document) for whichever caller logs/surfaces it.
+    raise RuntimeError(f"couldn't get a response ({_clip(str(last_err), 160)})")
 
 
 def _synthesize_document(gathered: list, task: str, base_url: str, api_key: str,
@@ -3754,14 +3774,20 @@ def run_agent_chat(cfg):
             _emit({"type": "final", "text": f"⚠️ {cfg_err}"})
             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.
+        # answer from the conversation rather than surfacing a raw error to the user —
+        # but only when the fallback ACTUALLY has something useful to say.
         _log(f"agent error: {e} — degrading to plain reply")
         try:
             fallback = _plain_reply(messages, agent_base_url, agent_api_key, agent_model_id).strip()
         except Exception as e2:  # noqa: BLE001
             _log(f"plain-reply degrade error: {e2}")
-            fallback = ""
-        _emit({"type": "final", "text": fallback or f"[Agent error: {e}]"})
+            # Nothing useful to say — re-raise the ORIGINAL (more relevant) agent
+            # failure so this becomes a genuine job failure: a red error the REPL/web
+            # already handle correctly, NOT persisted to conversation history. Emitting
+            # a fabricated "final" answer here instead would poison every future turn's
+            # prompt with raw exception text (this is exactly what caused task #35).
+            raise e
+        _emit({"type": "final", "text": fallback})
 
 
 def _log(text: str):

package/package.json

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