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

package/gonext_agent_chat.py

@@ -66,6 +66,22 @@ def _http_request_impl(method, url, headers=None, body=None, timeout=25):
         return f"Error: {e}"
 
 
+def _normalize_openai_base(url: str) -> str:
+    """Normalize a model-server URL to its OpenAI-compatible /v1 root.
+
+    Users paste whatever their server docs show: an MLX root (http://host:8089), an
+    Ollama native endpoint (http://host:11434/api/generate), or a full /v1 URL. Ollama
+    serves the OpenAI-compatible API at /v1 on the same host, so strip any native
+    /api/... path (including a mistakenly appended /v1 after it) and ensure /v1.
+    """
+    u = (url or "").strip().rstrip("/")
+    if not u:
+        return ""
+    u = re.sub(r"/api(/(generate|chat|tags|embeddings|embed))?(/v1)?$", "", u,
+               flags=re.IGNORECASE)
+    return u if u.lower().endswith("/v1") else u + "/v1"
+
+
 def _html_to_text(html_text, limit=3000):
     """Strip HTML to readable plain text (zero-dep). Used by fetch_url so the weak
     model receives prose instead of raw tags it cannot parse."""
@@ -934,7 +950,10 @@ def run_agent_chat(cfg):
     # Optional dedicated coding/reasoning model for the CodeAgent's tool-use loop.
     # Routing, plain replies and summarization stay on the chat model (better at
     # natural language); the code model only drives http_request reasoning.
-    raw_coding_base = (cfg.get("codingBaseURL") or "").strip()
+    # The URL may be a pasted Ollama endpoint (http://host:11434/api/generate) or a
+    # bare host — normalize to the OpenAI-compatible /v1 root either way (defensive:
+    # also fixes an older API layer that appended /v1 after the native /api path).
+    raw_coding_base = _normalize_openai_base(cfg.get("codingBaseURL") or "")
     raw_coding_model = (cfg.get("codingModelId") or "").strip()
     if raw_coding_base:
         same_server = raw_coding_base.rstrip("/") == (agent_base_url or "").rstrip("/")
@@ -1099,6 +1118,10 @@ def run_agent_chat(cfg):
     _log("router: agent (HTTP tool use needed)")
     _emit({"type": "step", "text": "Choosing a tool…"})
 
+    # True when the user wants a PDF but its content must first be researched by the
+    # agent loop (set below); read by the max-steps fallback to force-deliver a PDF.
+    agent_pdf_requested = False
+
     # ---- Deterministic PDF fast-path -------------------------------------------------
     # A small model cannot reliably re-emit a long, emoji/quote-heavy document as a
     # Python string literal for create_pdf(text="…"), so the CodeAgent call fails before
@@ -1137,6 +1160,9 @@ def run_agent_chat(cfg):
                 and _PDF_RESEARCH_INTENT.search(latest_user_text)):
             _log("PDF fast-path SKIPPED: content needs research (no provided body) "
                  "→ agent loop (web_search → create_pdf)")
+            # Remember the user wants a PDF: if the agent loop exhausts its steps without
+            # calling create_pdf, the max-steps fallback renders the gathered facts anyway.
+            agent_pdf_requested = True
         else:
             doc_title = _derive_pdf_title(doc_text)
             _log(
@@ -1280,6 +1306,9 @@ def run_agent_chat(cfg):
         "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"
+        "- RESEARCH BUDGET — you may make at most 3 web_search/fetch_url calls TOTAL per task "
+        "(rewording a query still counts). Reserve your remaining steps for create_pdf / "
+        "final_answer.\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 —
@@ -1306,15 +1335,54 @@ def run_agent_chat(cfg):
     # / final_answer). Keyed to retrieval tools where the loop actually happens.
     _seen_calls: dict = {}
 
+    # Search queries get near-duplicated with filler tweaks ("schedule" → "FULL schedule"
+    # → "2026 FIFA full schedule"), dodging exact-match dedup — seen live. Normalize:
+    # drop filler words, sort tokens, so all variants share one signature.
+    _QUERY_FILLER = {
+        "full", "complete", "comprehensive", "detailed", "entire", "all", "latest",
+        "current", "the", "a", "an", "of", "with", "and", "for", "to", "in", "on",
+        "more", "about", "info", "information",
+    }
+
+    def _norm_query(q: str) -> str:
+        tokens = [t for t in re.findall(r"[a-z0-9]+", (q or "").lower())
+                  if t not in _QUERY_FILLER]
+        return " ".join(sorted(tokens))
+
+    # Hard research budget: at most N retrieval calls (web_search + fetch_url) per run.
+    # Past it, retrieval tools refuse and steer to create_pdf/final_answer. Keeps ≥2 of
+    # the 5 steps free to actually FINISH — the live failure mode was burning ALL steps
+    # on slightly-different searches and never producing the asked-for PDF.
+    _research = {"used": 0, "max": 3}
+
+    def _research_spend(tool_name: str) -> str:
+        """Return '' if under budget (and spend 1), else a refusal steering to finish."""
+        if _research["used"] >= _research["max"]:
+            _log(f"{tool_name} BLOCKED: research budget ({_research['max']}) exhausted")
+            return (
+                f"Research budget exhausted ({_research['max']} web_search/fetch_url calls "
+                "used). Do NOT search or fetch again. FINISH NOW with what you have: if the "
+                "task asked for a PDF call create_pdf(text=<compile the gathered facts>, "
+                "title=...), otherwise call final_answer(<your best answer from the "
+                "observations above>)."
+            )
+        _research["used"] += 1
+        return ""
+
+    # Everything useful the retrieval tools returned this run, so an exhausted loop can
+    # still deterministically deliver (e.g. render a partial PDF) instead of dead-ending.
+    _gathered: list = []
+
     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()}"
+        key = _norm_query(arg) if tool_name == "web_search" else (arg or "").strip().lower()
+        sig = f"{tool_name}::{key}"
         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}"
+                f"You already ran {tool_name}({arg!r}) (or an equivalent query) — the "
+                f"result would be the same as shown above. Do NOT call it again. {next_hint}"
             )
         _seen_calls[sig] = True
         return False, ""
@@ -1418,10 +1486,15 @@ def run_agent_chat(cfg):
                             "'complete' source — one may not exist.")
         if dup:
             return nudge
+        blocked = _research_spend("web_search")
+        if blocked:
+            return blocked
         _emit({"type": "step", "text": f"Searching the web → {query[:80]}"})
         result = _web_search_impl(query)
         _log(f"web_search {query[:60]!r} → {result[:80]}")
         _last_obs["text"] = result
+        if result and not result.startswith("Error"):
+            _gathered.append(result)
         return result
 
     @tool
@@ -1441,6 +1514,9 @@ def run_agent_chat(cfg):
                             "final_answer with what you found.")
         if dup:
             return nudge
+        blocked = _research_spend("fetch_url")
+        if blocked:
+            return blocked
         _emit({"type": "step", "text": f"Reading page → {url[:80]}"})
         status, ctype, raw = _fetch_page_impl(url)
         if status is None:
@@ -1464,6 +1540,7 @@ def run_agent_chat(cfg):
         out = f"{url}\n{text}"
         _log(f"fetch_url {url} → {len(text)} chars")
         _last_obs["text"] = out
+        _gathered.append(out)
         return out
 
     @tool
@@ -1773,6 +1850,28 @@ def run_agent_chat(cfg):
     class _ToolAgent(_AgentBase):
         def provide_final_answer(self, task, *args, **kwargs):
             from smolagents.models import ChatMessage, MessageRole
+            # PDF-on-exhaustion guarantee: the user asked for a PDF and the loop burned
+            # all steps researching without ever calling create_pdf (seen live: 5 steps
+            # of search/fetch, zero deliverable). Render whatever WAS gathered into a
+            # (possibly partial) PDF instead of returning raw page text.
+            if (agent_pdf_requested and _gathered
+                    and not (_last_obs.get("text") or "").startswith("✅")):
+                _log(f"max-steps fallback → forcing create_pdf from {len(_gathered)} "
+                     "gathered observation(s)")
+                try:
+                    compiled = "\n\n---\n\n".join(_gathered)[:12000]
+                    out = create_pdf(
+                        text=compiled, title=_derive_pdf_title(latest_user_text)
+                    )
+                    if isinstance(out, str) and out.startswith("✅"):
+                        out += (
+                            "\n\n(Note: I hit my research step limit, so this PDF contains "
+                            "what I could gather — it may be partial.)"
+                        )
+                        return ChatMessage(role=MessageRole.ASSISTANT, content=out)
+                    _log(f"forced create_pdf did not succeed: {str(out)[:120]}")
+                except Exception as e:  # noqa: BLE001
+                    _log(f"forced create_pdf error: {type(e).__name__}: {e}")
             text = (_last_obs.get("text") or "").strip()
             if text:
                 _log(f"max-steps fallback (last tool obs) → {text[:80]}")

package/package.json

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