@tiens.nguyen/gonext-local-worker 1.0.126 → 1.0.128

package/gonext_agent_chat.py

@@ -23,6 +23,7 @@ import contextlib
 import json
 import re
 import sys
+import time
 import traceback
 import urllib.request
 import urllib.error
@@ -1270,6 +1271,10 @@ def run_agent_chat(cfg):
         "- If a response starts with 'HTTP 2' it SUCCEEDED — answer with it next step.\n"
         "- NEVER pass an 'Error:' / HTTP 4xx / 5xx result to final_answer. On an error, try a "
         "DIFFERENT approach next step (e.g. web_search); only give up after a few tries.\n"
+        "- CONVERGE — do NOT keep searching for a 'more complete' or 'perfect' source; a single "
+        "clean one often does not exist. After 1-2 searches/fetches, COMPILE what you have and "
+        "finish: if a PDF was asked for, call create_pdf(text=<your compiled text>, title=...); "
+        "otherwise call final_answer. NEVER repeat a web_search/fetch_url you already ran.\n"
         "- Do NOT put final_answer outside the code block.\n\n"
     )
     # Lead with the TASK so the weak model anchors on what's actually being asked —
@@ -1289,6 +1294,26 @@ def run_agent_chat(cfg):
     # tool returned (no extra model call) if the loop ends without final_answer.
     _last_obs: dict = {"text": ""}
 
+    # Deterministic loop-breaker. Weak models often repeat the SAME search/fetch over and
+    # over (hoping for a "more complete" result) and never converge, burning the whole step
+    # budget. We remember each (tool, arg) signature; on a repeat we DON'T re-run it —
+    # instead we return the prior result plus a hard nudge to move on (compile / create_pdf
+    # / final_answer). Keyed to retrieval tools where the loop actually happens.
+    _seen_calls: dict = {}
+
+    def _dedup(tool_name: str, arg: str, next_hint: str):
+        """Return (is_repeat, message). On a repeat, message steers the model forward."""
+        sig = f"{tool_name}::{(arg or '').strip().lower()}"
+        prior = _seen_calls.get(sig)
+        if prior is not None:
+            _log(f"{tool_name} REPEAT suppressed ({arg[:60]!r}) → nudging model forward")
+            return True, (
+                f"You already ran {tool_name}({arg!r}) — its result is unchanged and shown "
+                f"above. Do NOT call it again. {next_hint}"
+            )
+        _seen_calls[sig] = True
+        return False, ""
+
     @tool
     def http_request(method: str, url: str, headers: str = "", body: str = "",
                      username: str = "", password: str = "") -> str:
@@ -1381,6 +1406,13 @@ def run_agent_chat(cfg):
         Args:
             query: What to look up, e.g. 'capital of France' or 'productivity day-to-day method'.
         """
+        dup, nudge = _dedup("web_search", query,
+                            "Use the facts you have ALREADY gathered: if the task asks for a "
+                            "PDF, call create_pdf(text=..., title=...) now; otherwise call "
+                            "final_answer with what you found. Do not keep searching for a "
+                            "'complete' source — one may not exist.")
+        if dup:
+            return nudge
         _emit({"type": "step", "text": f"Searching the web → {query[:80]}"})
         result = _web_search_impl(query)
         _log(f"web_search {query[:60]!r} → {result[:80]}")
@@ -1398,6 +1430,12 @@ def run_agent_chat(cfg):
         Args:
             url: The full URL of the page to read, e.g. 'https://example.com/article'.
         """
+        dup, nudge = _dedup("fetch_url", url,
+                            "You already have this page's text above. Use it: call "
+                            "create_pdf(text=..., title=...) if a PDF was requested, else "
+                            "final_answer with what you found.")
+        if dup:
+            return nudge
         _emit({"type": "step", "text": f"Reading page → {url[:80]}"})
         status, ctype, raw = _fetch_page_impl(url)
         if status is None:
@@ -1627,7 +1665,21 @@ def run_agent_chat(cfg):
             #   2. strip any leftover Qwen3 <think>…</think> trace (belt-and-suspenders;
             #      thinking is disabled via /no_think in _prepare_completion_kwargs, but a
             #      stray trace must never reach the parser or leak to the user).
-            msg = super().generate(*args, **kwargs)
+            # 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.
+            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:
                 content = getattr(msg, "content", None)
                 if content is None:

package/package.json

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