@tiens.nguyen/gonext-local-worker 1.0.237 → 1.0.238

package/gonext_agent_chat.py

@@ -1392,8 +1392,14 @@ def _format_text_for_pdf(text: str, title: str, base_url: str, api_key: str,
         fallback = f"# {title}\n\n{fallback}"
     try:
         from openai import OpenAI
+        # timeout=20, NOT 60 (task #74): this formatting pass runs INSIDE a create_pdf
+        # tool call, which itself runs under the agent's python-executor wall clock. A
+        # 60s wait here could eat the whole step budget — the PDF then rendered+uploaded
+        # fine but the model was told the step timed out, so it re-created the PDF from
+        # scratch (3 duplicate PDFs, ~10 wasted minutes). Formatting is optional polish:
+        # give it 20s, then fall back to the raw text and leave room for render+upload.
         client = OpenAI(base_url=base_url, api_key=api_key or "local",
-                        max_retries=0, timeout=60)
+                        max_retries=0, timeout=20)
         system_content = (
             "You format raw text/data into clean Markdown for a PDF document. "
             "Add a single top-level '# Title', sensible headings, bullet lists, "
@@ -2961,8 +2967,15 @@ def run_agent_chat(cfg):
             )
 
             _emit({"type": "step", "text": "Formatting document…"})
+            # CHAT model, not the coder (task #74 review): formatting raw text into
+            # Markdown is a language task, and the chat model (local MLX) answers in
+            # seconds where the remote coder can take minutes to first token — inside
+            # the 20s format timeout that difference is "formatted" vs "always falls
+            # back to raw text". Same split as routing/plain replies/summarization.
             markdown_text = _format_text_for_pdf(
-                doc_text, doc_title, coding_base_url, agent_api_key, coding_model_id,
+                doc_text, doc_title,
+                agent_base_url or coding_base_url, agent_api_key,
+                agent_model_id or coding_model_id,
                 instruction=edit_instruction,
             )
 
@@ -3223,6 +3236,8 @@ def run_agent_chat(cfg):
         f"- RESEARCH BUDGET — you may make at most {research_budget} web_search/fetch_url calls "
         "TOTAL per task (rewording a query still counts). Reserve your remaining steps for "
         "create_pdf / final_answer.\n"
+        "- If an earlier Observation already says '✅ Your PDF … is ready', the PDF EXISTS — "
+        "do NOT call create_pdf again. Pass that download link to final_answer.\n"
         "- Do NOT put final_answer outside the code block.\n\n"
     )
     # Recover an interrupted prior turn's step trace, if one survives on disk (crash/
@@ -3595,6 +3610,22 @@ def run_agent_chat(cfg):
         _last_obs["text"] = result
         return result
 
+    # Task #74 retry guard. When a create_pdf call outlives the executor's wall clock,
+    # the tool still finishes (render + S3 upload succeed, "PDF ready" is emitted) but
+    # the model is told the step FAILED — so it calls create_pdf again for the same
+    # document. Remember the last success here; `timeout_pending` is flipped by
+    # step_callback whenever a step's result was an executor-timeout error, meaning
+    # whatever succeeded during that step was never reported to the model.
+    _pdf_state: dict = {"last": None, "timeout_pending": False}
+
+    def _pdf_sig(title: str, text: str) -> str:
+        return (title.strip().lower() + "||"
+                + re.sub(r"\s+", " ", (text or "").strip().lower())[:1500])
+
+    def _pdf_titles_similar(a: str, b: str) -> bool:
+        a, b = a.strip().lower(), b.strip().lower()
+        return bool(a and b) and (a == b or a in b or b in a)
+
     @tool
     def create_pdf(text: str, title: str = "") -> str:
         """Create a PDF document from text/data and return a download link.
@@ -3608,10 +3639,28 @@ def run_agent_chat(cfg):
             title: Optional document title shown at the top and used in the file name.
         """
         doc_title = (title or "").strip() or "Document"
+        # Retry guard (task #74): identical content is ALWAYS a retry; a merely similar
+        # title counts only when the previous success was swallowed by an executor
+        # timeout (the model rewords/shortens on retry, so the text rarely matches).
+        prev = _pdf_state.get("last")
+        if prev and (
+            prev["sig"] == _pdf_sig(doc_title, text)
+            or (_pdf_state.get("timeout_pending")
+                and _pdf_titles_similar(prev["title"], doc_title))
+        ):
+            _log(f"create_pdf retry detected (prev title={prev['title']!r}) "
+                 "→ returning the existing PDF instead of re-rendering")
+            _emit({"type": "step",
+                   "text": f"PDF already created → {prev['title']}.pdf (reusing link)"})
+            _last_obs["text"] = prev["msg"]
+            return prev["msg"]
         # 1) Format the raw text into clean Markdown (extra model call, intentional).
+        # CHAT model, not the coder — see the fast-path call site for why (task #74).
         _emit({"type": "step", "text": "Formatting document…"})
         markdown_text = _format_text_for_pdf(
-            text or "", doc_title, coding_base_url, agent_api_key, coding_model_id
+            text or "", doc_title,
+            agent_base_url or coding_base_url, agent_api_key,
+            agent_model_id or coding_model_id,
         )
 
         # 2) Render the Markdown to PDF bytes locally (pure-Python xhtml2pdf).
@@ -3655,6 +3704,9 @@ def run_agent_chat(cfg):
         )
         _emit({"type": "step", "text": f"PDF ready → {doc_title}.pdf"})
         _log(f"create_pdf ok title={doc_title!r} bytes={len(pdf_bytes)}")
+        _pdf_state["last"] = {
+            "sig": _pdf_sig(doc_title, text), "title": doc_title, "msg": out,
+        }
         _last_obs["text"] = out
         return out
 
@@ -3670,6 +3722,19 @@ def run_agent_chat(cfg):
     def step_callback(step_log):
         step_num = getattr(step_log, "step_number", "?")
 
+        # Task #74: an executor-timeout error means whatever the step's tool call
+        # achieved was NEVER reported to the model (a create_pdf may have finished —
+        # or may still be finishing — in the background). Flag it so a repeat
+        # create_pdf with a similar title is treated as the retry it is; any step
+        # that ends with a real (non-timeout) result clears the flag.
+        try:
+            _err = getattr(step_log, "error", None)
+            _pdf_state["timeout_pending"] = bool(
+                _err and "maximum execution time" in str(_err)
+            )
+        except Exception:  # noqa: BLE001
+            pass
+
         # (B) Trim OLD, LARGE tool observations out of the CodeAgent's step memory so
         # they aren't re-sent to the model on every subsequent step (the #63 O(n²) token
         # blow-up: an uncapped read_file_lines dump cost ~5-6k tokens PER remaining step).
@@ -5122,7 +5187,15 @@ def run_agent_chat(cfg):
         )
         if _AgentBase is CodeAgent:
             # Only the CodeAgent runs a Python executor; ToolCallingAgent takes neither.
-            agent_kwargs["executor_kwargs"] = {"timeout_seconds": 60}
+            # 660s, NOT 60 (task #74): the wall clock must exceed the LARGEST tool-internal
+            # timeout (run_command caps at 600s; create_pdf's format+render+upload can pass
+            # 60s), otherwise a tool that eventually SUCCEEDS gets reported to the model as
+            # 'Code execution exceeded the maximum execution time' — the model then retries
+            # work that already finished (the duplicate-PDF bug). Every tool enforces its
+            # own tighter timeout and returns a clean message; runaway pure-python is still
+            # caught by smolagents' op-count caps (MAX_OPERATIONS/MAX_WHILE_ITERATIONS),
+            # so this wall clock is a last-resort backstop, not the primary guard.
+            agent_kwargs["executor_kwargs"] = {"timeout_seconds": 660}
             agent_kwargs["additional_authorized_imports"] = [
                 "json", "base64", "urllib", "urllib.request", "urllib.error"
             ]

package/package.json

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