@tiens.nguyen/gonext-local-worker 1.0.134 → 1.0.136

package/gonext-local-worker.mjs

@@ -1526,12 +1526,14 @@ async function runAgentChatJob(job) {
       emailFrom: payload?.emailFrom ?? "",
       emailAllowList: payload?.emailAllowList ?? "",
     });
-    // 7 min max for an agent run: up to 5 ReAct steps on a local 14B with a cold
-    // prompt cache can legitimately exceed the old 5-min cap. Must stay BELOW the web
-    // client's hard WS deadline (480s) so our clean timeout error reaches the user
-    // instead of a generic WS timeout. On expiry the python child is SIGKILLed, which
-    // also shows up as a BrokenPipeError in the mlx_lm.server log (expected).
-    const timeoutMs = 420_000;
+    // 10 min max for an agent run: 5 ReAct steps on a 14B with a cold prompt cache —
+    // or a remote Ollama box cold-loading a big model — can exceed the old caps. Must
+    // stay BELOW the web client's hard WS deadline (660s) so our clean timeout error
+    // reaches the user instead of a generic WS timeout. On expiry the python child is
+    // SIGKILLed, which also shows up as a BrokenPipeError in the model server log
+    // (expected). Liveness during long model calls comes from the python heartbeat
+    // (a keepalive step chunk every 45s), not from this cap.
+    const timeoutMs = 600_000;
 
     let inThink = false;
     let finalText = "";

package/gonext_agent_chat.py

@@ -23,6 +23,7 @@ import contextlib
 import json
 import re
 import sys
+import threading
 import time
 import traceback
 import urllib.request
@@ -388,9 +389,16 @@ def _detect_model_id(base_url, api_key=""):
         return ""
     data = payload.get("data") if isinstance(payload, dict) else None
     if isinstance(data, list) and data:
-        first = data[0]
-        if isinstance(first, dict) and isinstance(first.get("id"), str):
-            return first["id"].strip()
+        ids = [d["id"].strip() for d in data
+               if isinstance(d, dict) and isinstance(d.get("id"), str) and d["id"].strip()]
+        if ids:
+            if len(ids) > 1:
+                # Ollama servers list every pulled model; "first" is arbitrary and may
+                # be a huge/slow one (seen live: picked gemma4:31b over qwen3:14b).
+                _log(f"model detect: server hosts {len(ids)} models {ids} — using "
+                     f"{ids[0]!r}. Set the coding model NAME in Settings to choose "
+                     "a specific one.")
+            return ids[0]
     return ""
 
 
@@ -1750,18 +1758,38 @@ def run_agent_chat(cfg):
             # A transient "Connection error" to the local MLX server (seen mid-loop when the
             # context grows large) otherwise aborts the whole run — retry a couple of times
             # with a short backoff before giving up.
+            # Heartbeat: while a model call is in flight the agent emits NOTHING, and
+            # the web's no-progress watchdog kills the chat. A big/cold model (e.g. a
+            # 31B on a remote Ollama box) can take minutes on prompt-eval before the
+            # first byte — emit a keepalive step every 45s until the call returns.
+            hb_stop = threading.Event()
+
+            def _heartbeat():
+                waited = 0
+                while not hb_stop.wait(45):
+                    waited += 45
+                    _emit({"type": "step",
+                           "text": f"Model is still working… ({waited}s — a large or "
+                                   "cold-loading model can take a few minutes)"})
+                    _log(f"heartbeat: model call in flight {waited}s")
+
+            hb = threading.Thread(target=_heartbeat, daemon=True)
+            hb.start()
             last_err = None
-            for attempt in range(3):
-                try:
-                    msg = super().generate(*args, **kwargs)
-                    break
-                except Exception as e:  # noqa: BLE001
-                    last_err = e
-                    if attempt < 2:
-                        _log(f"generate transient error (attempt {attempt + 1}/3): {e} — retrying")
-                        time.sleep(1.5 * (attempt + 1))
-            else:
-                raise last_err
+            try:
+                for attempt in range(3):
+                    try:
+                        msg = super().generate(*args, **kwargs)
+                        break
+                    except Exception as e:  # noqa: BLE001
+                        last_err = e
+                        if attempt < 2:
+                            _log(f"generate transient error (attempt {attempt + 1}/3): {e} — retrying")
+                            time.sleep(1.5 * (attempt + 1))
+                else:
+                    raise last_err
+            finally:
+                hb_stop.set()
             try:
                 content = getattr(msg, "content", None)
                 if content is None:
@@ -1896,6 +1924,12 @@ def run_agent_chat(cfg):
             model_id=coding_model_id,
             api_base=coding_base_url,
             api_key=agent_api_key,
+            # Cap each HTTP attempt at 240s so one hung request (remote server
+            # cold-loading a big model) fails into OUR retry loop instead of eating
+            # the whole worker budget; by the retry the model is usually loaded.
+            # max_retries=0: the openai client's own silent retries would otherwise
+            # stack multiplicatively with ours (3 × 3 attempts).
+            client_kwargs={"timeout": 240.0, "max_retries": 0},
         )
         agent_tools = [http_request, web_search, fetch_url, calculate,
                        get_current_datetime, create_pdf]
@@ -1945,10 +1979,18 @@ def _log(text: str):
     _emit({"type": "log", "text": text})
 
 
+_EMIT_LOCK = threading.Lock()
+
+
 def _emit(obj):
-    """Write one NDJSON line to the real stdout and flush immediately."""
-    _REAL_STDOUT.write(json.dumps(obj) + "\n")
-    _REAL_STDOUT.flush()
+    """Write one NDJSON line to the real stdout and flush immediately.
+
+    Lock-guarded: the model-call heartbeat thread emits concurrently with the
+    main loop, and interleaved writes would corrupt the NDJSON stream.
+    """
+    with _EMIT_LOCK:
+        _REAL_STDOUT.write(json.dumps(obj) + "\n")
+        _REAL_STDOUT.flush()
 
 
 def main():

package/package.json

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