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

package/gonext_agent_chat.py

@@ -827,6 +827,33 @@ _PDF_READ_INTENT = re.compile(
 )
 
 
+# A PDF request whose CONTENT must be gathered/researched first (e.g. "get me the world
+# cup 2026 schedule … then create a pdf"). The deterministic fast-path can only render text
+# the user already GAVE (or a prior assistant turn) — it cannot web_search, and the model
+# would just hallucinate live facts. When these retrieval/currency signals appear AND no
+# document body was provided, we skip the fast-path and let the multi-step agent gather the
+# data (web_search / fetch_url) and THEN call create_pdf with it.
+_PDF_RESEARCH_INTENT = re.compile(
+    r"\b(get me|get the|find|research|look ?up|search|fetch|gather|collect|compile|"
+    r"latest|current|today'?s|upcoming|recent|schedules?|fixtures?|standings?|"
+    r"news|weather|prices?|scores?|results?|rankings?|statistics|stats)\b",
+    re.IGNORECASE,
+)
+
+
+def _pdf_has_explicit_body(user_text: str) -> bool:
+    """True when the message itself supplies the document body — a quoted span, or text
+    after a 'text:/content:/following:/data:' lead-in. Distinguishes 'make a PDF of THIS
+    text …' (fast-path OK) from 'get me X then make a PDF' (needs the agent to fetch X)."""
+    t = user_text or ""
+    for pat in (r'"([\s\S]+)"', r"“([\s\S]+)”", r"'([\s\S]+)'"):
+        m = re.search(pat, t)
+        if m and len(m.group(1).strip()) >= 40:
+            return True
+    m = re.search(r"\b(texts?|following|below|content|data)\b\s*[:\-]\s*\S", t, re.IGNORECASE)
+    return bool(m)
+
+
 def _wants_pdf(text: str) -> bool:
     """True when the user is asking us to (re)generate a PDF — fresh request or a
     follow-up referencing a target PDF — but NOT when merely asking about one, and NOT
@@ -1079,8 +1106,8 @@ def run_agent_chat(cfg):
         # the most recent substantial assistant turn as the base document and treat the
         # current user message as an edit instruction the formatter should apply.
         edit_instruction = ""
+        prior_doc = ""
         if len(doc_text.strip()) < 40:
-            prior_doc = ""
             for m in reversed(messages[:last_user_idx]):
                 if m.get("role") != "assistant":
                     continue
@@ -1095,52 +1122,62 @@ def run_agent_chat(cfg):
             if prior_doc:
                 edit_instruction = latest_user_text.strip()
                 doc_text = prior_doc
-        doc_title = _derive_pdf_title(doc_text)
-        _log(
-            f"PDF fast-path: title={doc_title!r} doc_chars={len(doc_text)}"
-            + (f" edit={edit_instruction[:60]!r}" if edit_instruction else "")
-        )
 
-        _emit({"type": "step", "text": "Formatting document…"})
-        markdown_text = _format_text_for_pdf(
-            doc_text, doc_title, coding_base_url, agent_api_key, coding_model_id,
-            instruction=edit_instruction,
-        )
+        # Guard: if the PDF's content must be RESEARCHED (not provided in the message, not
+        # from a prior turn), don't render the instruction text into a PDF — fall through to
+        # the agent loop so it can web_search/fetch_url the facts and THEN create_pdf them.
+        if (not prior_doc
+                and not _pdf_has_explicit_body(latest_user_text)
+                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)")
+        else:
+            doc_title = _derive_pdf_title(doc_text)
+            _log(
+                f"PDF fast-path: title={doc_title!r} doc_chars={len(doc_text)}"
+                + (f" edit={edit_instruction[:60]!r}" if edit_instruction else "")
+            )
 
-        _emit({"type": "step", "text": "Rendering PDF…"})
-        try:
-            pdf_bytes = _render_pdf_bytes(markdown_text, doc_title)
-        except RuntimeError as e:
-            msg = str(e)
-            _log(f"PDF fast-path render error: {msg[:200]}")
-            _emit({"type": "final", "text": msg})
-            return
-        except Exception as e:  # noqa: BLE001
-            _log(f"PDF fast-path render crash: {type(e).__name__}: {e!r}\n{traceback.format_exc()}")
-            _emit({"type": "final", "text": (
-                f"Sorry — I couldn't render that into a PDF ({type(e).__name__}: {str(e)[:160]})."
-            )})
-            return
+            _emit({"type": "step", "text": "Formatting document…"})
+            markdown_text = _format_text_for_pdf(
+                doc_text, doc_title, coding_base_url, agent_api_key, coding_model_id,
+                instruction=edit_instruction,
+            )
 
-        _emit({"type": "step", "text": "Uploading PDF…"})
-        try:
-            download_url = _pdf_upload_via_api(
-                pdf_api_base, pdf_worker_key, f"{doc_title}.pdf", pdf_bytes
+            _emit({"type": "step", "text": "Rendering PDF…"})
+            try:
+                pdf_bytes = _render_pdf_bytes(markdown_text, doc_title)
+            except RuntimeError as e:
+                msg = str(e)
+                _log(f"PDF fast-path render error: {msg[:200]}")
+                _emit({"type": "final", "text": msg})
+                return
+            except Exception as e:  # noqa: BLE001
+                _log(f"PDF fast-path render crash: {type(e).__name__}: {e!r}\n{traceback.format_exc()}")
+                _emit({"type": "final", "text": (
+                    f"Sorry — I couldn't render that into a PDF ({type(e).__name__}: {str(e)[:160]})."
+                )})
+                return
+
+            _emit({"type": "step", "text": "Uploading PDF…"})
+            try:
+                download_url = _pdf_upload_via_api(
+                    pdf_api_base, pdf_worker_key, f"{doc_title}.pdf", pdf_bytes
+                )
+            except Exception as e:  # noqa: BLE001
+                _log(f"PDF fast-path upload error: {type(e).__name__}: {e!r}\n{traceback.format_exc()}")
+                _emit({"type": "final", "text": (
+                    f"PDF was created but could not be uploaded: {str(e)[:200]}"
+                )})
+                return
+
+            out = (
+                f"✅ Your PDF \"{doc_title}\" is ready.\n"
+                f"Download it here (link valid for a limited time):\n{download_url}"
             )
-        except Exception as e:  # noqa: BLE001
-            _log(f"PDF fast-path upload error: {type(e).__name__}: {e!r}\n{traceback.format_exc()}")
-            _emit({"type": "final", "text": (
-                f"PDF was created but could not be uploaded: {str(e)[:200]}"
-            )})
+            _log(f"PDF fast-path ok title={doc_title!r} bytes={len(pdf_bytes)}")
+            _emit({"type": "final", "text": out})
             return
-
-        out = (
-            f"✅ Your PDF \"{doc_title}\" is ready.\n"
-            f"Download it here (link valid for a limited time):\n{download_url}"
-        )
-        _log(f"PDF fast-path ok title={doc_title!r} bytes={len(pdf_bytes)}")
-        _emit({"type": "final", "text": out})
-        return
     # ---------------------------------------------------------------------------------
 
     # Prepend explicit tool instructions so small models pick the right tool, never
@@ -1217,6 +1254,9 @@ def run_agent_chat(cfg):
         "- a live/current NUMBER with no URL given (price, exchange rate, weather, score, "
         "stock/crypto) -> web_search(query). Do NOT guess an API URL for these.\n"
         "- 'create/make/generate/export a PDF' of some text/data -> create_pdf(text, title).\n"
+        "- a PDF of info you must LOOK UP first (e.g. 'get the world cup schedule then make a "
+        "pdf') -> FIRST web_search/fetch_url to gather the real facts, THEN in a later step "
+        "create_pdf(text=<the gathered facts>, title=...). Never PDF the request wording itself.\n"
         + _pdf_read_choose_line + _email_choose_line +
         "- A specific known API/URL was given -> http_request().\n"
         "\n"
@@ -1574,22 +1614,58 @@ def run_agent_chat(cfg):
     # literal messages array sent to /v1/chat/completions.
     class _LoggingModel(OpenAIServerModel):
         def generate(self, *args, **kwargs):
-            # Strip Qwen3 <think>…</think> reasoning traces from each step's reply
-            # BEFORE smolagents parses it for the code block / final_answer. Thinking
-            # stays on (better reasoning), but the trace never confuses the parser or
-            # leaks to the user.
+            # Two safeguards on each step's reply BEFORE smolagents parses it for the
+            # code block / final_answer:
+            #   1. content=None guard — Qwen3 (and reasoning models generally) can return
+            #      message.content=None on a turn (e.g. it spent the whole completion on a
+            #      <think> trace and never emitted a code block). smolagents has NO null
+            #      guard (models.py: `content = response.choices[0].message.content`) and
+            #      feeds it straight into parse_code_blobs → `re` gets None →
+            #      "expected string or bytes-like object, got 'NoneType'" → the whole
+            #      loop spirals on parse errors and trips the WebSocket timeout. Coercing
+            #      None→"" turns that fatal crash into a normal "no code block" retry.
+            #   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)
             try:
-                if isinstance(getattr(msg, "content", None), str) and "</think>" in msg.content.lower():
-                    cleaned = _strip_think(msg.content)
-                    _log(f"stripped <think> trace ({len(msg.content) - len(cleaned)} chars)")
+                content = getattr(msg, "content", None)
+                if content is None:
+                    _log("model returned content=None (empty/thinking-only turn) → coercing to ''")
+                    msg.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
             except Exception as e:  # noqa: BLE001
-                _log(f"think-strip error: {e}")
+                _log(f"content-normalize error: {e}")
             return msg
 
         def _prepare_completion_kwargs(self, *args, **kwargs):
             ck = super()._prepare_completion_kwargs(*args, **kwargs)
+            # Disable Qwen3 "thinking" for the agent loop. Live runs showed thinking-on
+            # spends the whole completion budget on a <think> trace and returns
+            # content=None (no code block) → parse-error spiral → WS timeout. The
+            # `/no_think` soft switch (recognized by the Qwen3 chat template) forces a
+            # direct Thought+code reply every step. Injected into the SYSTEM message so it
+            # applies to EVERY step's request, not just the first user turn.
+            try:
+                msgs = ck.get("messages", []) or []
+                for m in msgs:
+                    role = m.get("role") if isinstance(m, dict) else getattr(m, "role", None)
+                    if str(role).endswith("system") or role == "system":
+                        c = m.get("content") if isinstance(m, dict) else getattr(m, "content", None)
+                        if isinstance(c, str) and "/no_think" not in c:
+                            m["content"] = c + "\n\n/no_think"
+                        elif isinstance(c, list):
+                            for part in c:
+                                if isinstance(part, dict) and isinstance(part.get("text"), str) \
+                                        and "/no_think" not in part["text"]:
+                                    part["text"] += "\n\n/no_think"
+                                    break
+                        break
+            except Exception as e:  # noqa: BLE001
+                _log(f"/no_think inject error: {e}")
             try:
                 msgs = ck.get("messages", []) or []
                 _log(f"=== MODEL REQUEST: {len(msgs)} message(s) sent to the model ===")

package/package.json

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