@tiens.nguyen/gonext-local-worker 1.0.160 → 1.0.162

package/gonext_agent_chat.py

@@ -2325,6 +2325,26 @@ def run_agent_chat(cfg):
             in_tok = out_tok = reasoning_len = 0
             first_token_at = None
 
+            # Runaway guard: a degenerate model (seen live: gemma4:26b spewing
+            # "<channel|><thought>" forever) will stream garbage until the client times
+            # out — a multi-minute hang. Abort early if the output either (a) balloons
+            # past a hard char cap, or (b) collapses into a repeating short line. On abort
+            # we return "" so the empty-turn retry re-prompts with the CODE-NOW directive.
+            _MAX_STREAM_CHARS = 16000  # a single agent step never legitimately needs this
+            _stream_buf = []           # every streamed piece (content + reasoning)
+            _stream_chars = 0
+            _runaway = False
+
+            def _looks_runaway() -> bool:
+                tail = "".join(_stream_buf)[-1600:]
+                lines = [ln.strip() for ln in tail.splitlines() if ln.strip()]
+                # 12+ of the last lines are the same short string → degenerate repetition.
+                if len(lines) >= 12:
+                    last = lines[-12:]
+                    if len(set(last)) <= 2 and all(len(ln) <= 80 for ln in last):
+                        return True
+                return False
+
             def _mark_first():
                 # First streamed byte (content OR reasoning). The gap t0→here is pure
                 # prompt-eval time (server sent nothing before this); everything after is
@@ -2362,13 +2382,33 @@ def run_agent_chat(cfg):
                 if rpiece:
                     _mark_first()
                     reasoning_len += len(rpiece)
+                    _stream_buf.append(rpiece)
+                    _stream_chars += len(rpiece)
                     _emit({"type": "stream", "text": rpiece})
                 piece = getattr(delta, "content", None)
                 if piece:
                     _mark_first()
                     parts.append(piece)
+                    _stream_buf.append(piece)
+                    _stream_chars += len(piece)
                     _emit({"type": "stream", "text": piece})
+                # Check the runaway guard periodically (cheap) once enough has streamed.
+                if _stream_chars > 500 and (_stream_chars > _MAX_STREAM_CHARS or _looks_runaway()):
+                    _runaway = True
+                    reason = "char cap" if _stream_chars > _MAX_STREAM_CHARS else "repeating output"
+                    _log(f"streamed generate: ABORTING ({reason}) after {_stream_chars} chars "
+                         "— model degenerated; closing stream.")
+                    try:
+                        stream.close()
+                    except Exception:  # noqa: BLE001
+                        pass
+                    break
             content = "".join(parts)
+            if _runaway:
+                # Discard the garbage; "" makes _streamed_generate run the CODE-NOW retry.
+                _emit({"type": "step", "text": "Model output ran away — restarting this step…"})
+                _log(f"streamed generate: discarded {len(content)} runaway chars → empty content")
+                return "", role, in_tok, out_tok, reasoning_len
             _log(f"streamed generate assembled {len(content)} chars "
                  f"(in={in_tok} out={out_tok} tokens, reasoning={reasoning_len} chars)")
             return content, role, in_tok, out_tok, reasoning_len

package/package.json

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