@tiens.nguyen/gonext-local-worker 1.0.138 → 1.0.141

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

@@ -398,6 +398,24 @@ def _list_model_ids(base_url, api_key=""):
             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).
 
@@ -616,6 +634,38 @@ def _strip_tool_tags(text: str) -> str:
 
 _THINK_BLOCK = re.compile(r"<think>.*?</think>", re.DOTALL | re.IGNORECASE)
 
+# Whitespace/attr variants of smolagents' code-block tags. Weak models routinely
+# emit "<code >" (trailing space), "< code >", "</ code>", or an uppercase form —
+# none of which match smolagents' exact "<code>(.*?)</code>" parser, so EVERY step
+# fails with "regex pattern <code>(.*?)</code> was not found" and the run burns all
+# its steps. Normalizing the tags to the canonical form before the parser sees them
+# turns that spiral into a normal, parseable step.
+_CODE_OPEN_TAG = re.compile(r"<\s*code(?:\s[^>]*)?\s*>", re.IGNORECASE)
+_CODE_CLOSE_TAG = re.compile(r"<\s*/\s*code\s*>", re.IGNORECASE)
+# Fallback: a markdown code fence (```py / ```python / ```) when the model ignored
+# the tag convention entirely. Captures the fenced body so we can re-wrap it.
+_MD_FENCE_BLOCK = re.compile(
+    r"```(?:py|python)?[ \t]*\r?\n(.*?)```", re.DOTALL | re.IGNORECASE
+)
+
+
+def _normalize_code_tags(text: str) -> str:
+    """Coerce a model reply's code-block delimiters to smolagents' exact <code>…</code>.
+
+    Handles the two failure modes seen live with weak coding models:
+      1. tag whitespace/case: "<code >", "< code >", "</ code>", "<CODE>" → "<code>".
+      2. markdown fences instead of tags: ```py … ``` → <code> … </code> (only when
+         no <code> tag is present after step 1, so we don't touch code that legitimately
+         contains backticks inside a real <code> block).
+    Returns text unchanged when it already parses cleanly."""
+    if not text:
+        return text
+    fixed = _CODE_OPEN_TAG.sub("<code>", text)
+    fixed = _CODE_CLOSE_TAG.sub("</code>", fixed)
+    if "<code>" not in fixed:
+        fixed = _MD_FENCE_BLOCK.sub(lambda m: f"<code>\n{m.group(1)}</code>", fixed, count=1)
+    return fixed
+
 
 def _strip_think(text: str) -> str:
     """Remove Qwen3-style <think>…</think> reasoning traces from a model reply.
@@ -1823,10 +1873,20 @@ def run_agent_chat(cfg):
                 if content is None:
                     _log("model returned content=None (empty/thinking-only turn) → coercing to ''")
                     msg.content = ""
+                    content = ""
                 elif isinstance(content, str) and "</think>" in content.lower():
                     cleaned = _strip_think(content)
                     _log(f"stripped <think> trace ({len(content) - len(cleaned)} chars)")
                     msg.content = cleaned
+                    content = cleaned
+                # Normalize code-block delimiters so smolagents' <code>…</code> parser
+                # matches even when the model wrote "<code >" / a markdown fence. Without
+                # this, tag-whitespace variants fail EVERY step → "Reached max steps".
+                if isinstance(content, str) and content:
+                    normalized = _normalize_code_tags(content)
+                    if normalized != content:
+                        _log("normalized code-block tags (<code >/fence → <code>)")
+                        msg.content = normalized
             except Exception as e:  # noqa: BLE001
                 _log(f"content-normalize error: {e}")
             return msg
@@ -1948,16 +2008,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]

package/package.json

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