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

package/gonext-local-worker.mjs

@@ -1526,14 +1526,15 @@ async function runAgentChatJob(job) {
       emailFrom: payload?.emailFrom ?? "",
       emailAllowList: payload?.emailAllowList ?? "",
     });
-    // 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;
+    // 30 min max for an agent run: multi-step ReAct on a 14B/31B with a cold prompt
+    // cache — or a remote Ollama box on slow GPU cold-loading a big model — can run
+    // for many minutes per step. Must stay BELOW the web client's hard WS deadline
+    // (1_860_000 ms) 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 = 1_800_000;
 
     let inThink = false;
     let finalText = "";

package/gonext_agent_chat.py

@@ -369,12 +369,16 @@ def _web_search_impl(query):
     )
 
 
-def _detect_model_id(base_url, api_key=""):
-    """Ask an OpenAI-compatible server which model it serves.
+class _AgentConfigError(RuntimeError):
+    """Deterministic setup error (e.g. wrong model name/URL). Not retryable and not
+    worth a plain-reply degrade — the user needs the message itself to fix Settings."""
+
+
+def _list_model_ids(base_url, api_key=""):
+    """Return the model ids an OpenAI-compatible server reports at {base_url}/models.
 
-    Queries GET {base_url}/models and returns the first reported model id.
-    `base_url` already ends with /v1. Returns "" on any failure so callers can
-    fall back. Used when the user supplies a coding-model URL but no model name.
+    `base_url` already ends with /v1. Returns [] on any failure so callers can
+    fall back.
     """
     url = base_url.rstrip("/") + "/models"
     headers = {"Accept": "application/json"}
@@ -385,21 +389,49 @@ def _detect_model_id(base_url, api_key=""):
         with urllib.request.urlopen(req, timeout=10, context=_ssl_context()) as resp:
             payload = json.loads(resp.read().decode("utf-8", errors="replace"))
     except Exception as e:  # noqa: BLE001
-        _log(f"model detect failed {url}: {e}")
-        return ""
+        _log(f"model list failed {url}: {e}")
+        return []
     data = payload.get("data") if isinstance(payload, dict) else None
-    if isinstance(data, list) and data:
-        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 ""
+    if not isinstance(data, list):
+        return []
+    return [d["id"].strip() for d in data
+            if isinstance(d, dict) and isinstance(d.get("id"), str) and d["id"].strip()]
+
+
+def _is_ollama_server(base_url):
+    """True if the OpenAI-compatible base URL is an Ollama server.
+
+    Ollama's root path answers GET / with the plain-text banner "Ollama is
+    running". Used to gate Ollama-only request params (reasoning_effort) that an
+    MLX server might reject.
+    """
+    root = re.sub(r"/v1/?$", "", (base_url or "").rstrip("/"))
+    if not root:
+        return False
+    req = urllib.request.Request(root, headers={"User-Agent": "gonext-agent/1.0"})
+    try:
+        with urllib.request.urlopen(req, timeout=6, context=_ssl_context()) as resp:
+            return b"ollama" in resp.read(200).lower()
+    except Exception:  # noqa: BLE001
+        return False
+
+
+def _detect_model_id(base_url, api_key=""):
+    """Ask an OpenAI-compatible server which model it serves (first reported id).
+
+    Returns "" on any failure so callers can fall back. Used when the user supplies
+    a coding-model URL but no model name.
+    """
+    ids = _list_model_ids(base_url, api_key)
+    if not ids:
+        return ""
+    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]
 
 
 def _summarise_step(step_log):
@@ -1782,6 +1814,20 @@ def run_agent_chat(cfg):
                         msg = super().generate(*args, **kwargs)
                         break
                     except Exception as e:  # noqa: BLE001
+                        emsg = str(e)
+                        # A 404 "model not found" is a config error (wrong model NAME
+                        # for this server, e.g. an MLX-style name against Ollama) —
+                        # deterministic, so retrying is pointless. Fail fast with the
+                        # server's actual model list so the user can fix Settings.
+                        if "404" in emsg and "not found" in emsg.lower():
+                            ids = _list_model_ids(coding_base_url, agent_api_key)
+                            have = f" This server has: {', '.join(ids)}." if ids else ""
+                            raise _AgentConfigError(
+                                f"The agent coding model {coding_model_id!r} does not "
+                                f"exist on {coding_base_url}.{have} Set 'Agent coding "
+                                "model name' in Settings → Agent to one of these exact "
+                                "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")
@@ -1920,16 +1966,27 @@ def run_agent_chat(cfg):
             return ChatMessage(role=MessageRole.ASSISTANT, content=text)
 
     try:
+        # Ollama's OpenAI-compat endpoint ignores Qwen3's /no_think soft-switch (its
+        # template forces thinking mode; "think": false is also ignored there) but DOES
+        # honor reasoning_effort="none". Thinking burned ~430 of 487 output tokens in
+        # the live test — minutes per step on a slow GPU — so disable it explicitly.
+        # Sniffed per-server because MLX might reject the unknown param.
+        extra_model_kwargs = {}
+        if _is_ollama_server(coding_base_url):
+            _log("coding server is Ollama → sending reasoning_effort='none' to disable thinking")
+            extra_model_kwargs["reasoning_effort"] = "none"
         model = _LoggingModel(
             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.
+            # 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
+            # retry loop rather than eating the whole 30min worker budget.
             # 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},
+            client_kwargs={"timeout": 600.0, "max_retries": 0},
+            **extra_model_kwargs,
         )
         agent_tools = [http_request, web_search, fetch_url, calculate,
                        get_current_datetime, create_pdf]
@@ -1963,6 +2020,23 @@ def run_agent_chat(cfg):
         _log(f"done (deterministic, no summarizer call): {len(final_text)} chars")
         _emit({"type": "final", "text": final_text})
     except Exception as e:  # noqa: BLE001
+        # Config errors (wrong coding-model name/URL) must reach the user VERBATIM —
+        # they contain the fix (the server's real model list). smolagents wraps model
+        # exceptions in AgentGenerationError, so walk the cause chain to find ours.
+        cfg_err = None
+        cur, depth = e, 0
+        while cur is not None and depth < 6:
+            if isinstance(cur, _AgentConfigError):
+                cfg_err = cur
+                break
+            cur, depth = (getattr(cur, "__cause__", None)
+                          or getattr(cur, "__context__", None)), depth + 1
+        if cfg_err is None and "Settings → Agent" in str(e):
+            cfg_err = e  # wrapped without a cause chain; message survived
+        if cfg_err is not None:
+            _log(f"agent config error (not degrading): {cfg_err}")
+            _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.
         _log(f"agent error: {e} — degrading to plain reply")

package/package.json

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