@tiens.nguyen/gu-cli 1.0.743 → 1.0.744

package/gonext_agent_chat.py

@@ -3727,46 +3727,6 @@ def _mark_stream_unsupported(base_url, model_id) -> None:
              "of this process — the server refused the streamed request shape itself")
 
 
-def _synthesize_document(gathered: list, task: str, base_url: str, api_key: str,
-                         model_id: str) -> str:
-    """Turn raw gathered research observations into ONE clean, organized document body
-    for create_pdf. This is a pure REFORMAT (organize/deduplicate facts already found —
-    no new research), so the fast local chat model handles it well. Returns "" on any
-    failure so the caller can fall back to the raw concatenation."""
-    notes = "\n\n---\n\n".join(gathered)[:12000]
-    sys_prompt = (
-        "You are a document editor. You are given a user's request and raw research "
-        "notes gathered to answer it. Produce a single, clean, well-organized document "
-        "that fulfills the request using ONLY facts present in the notes.\n"
-        "- Use a clear title, headings, and bullet lists or a markdown table where it "
-        "fits (e.g. schedules → a table of Teams | Date | Time).\n"
-        "- Deduplicate and order the information sensibly (e.g. by date).\n"
-        "- Do NOT invent facts not in the notes, and do NOT mention the research process, "
-        "steps, tools, or that anything is partial. Output ONLY the document body."
-    )
-    user_prompt = f"USER REQUEST:\n{task}\n\nRESEARCH NOTES:\n{notes}"
-    try:
-        from openai import OpenAI
-        client = OpenAI(base_url=base_url, api_key=api_key or "local",
-                        http_client=_proxy_http_client(base_url),
-                        max_retries=0, timeout=120)
-        resp = _chat_create(
-            client,
-            model=model_id,
-            messages=[{"role": "system", "content": sys_prompt},
-                      {"role": "user", "content": user_prompt}],
-            temperature=0.3,
-            max_tokens=2048,
-        )
-        out = (resp.choices[0].message.content or "").strip()
-        # A reasoning model might wrap output in <think>…</think>; strip it.
-        out = _THINK_BLOCK.sub("", out).strip()
-        return out
-    except Exception as e:  # noqa: BLE001
-        _log(f"document synthesis failed ({e}) → will use raw gathered notes")
-        return ""
-
-
 def _strip_tool_tags(text: str) -> str:
     """Remove the internal hint tags we append to tool output (e.g. '[SUCCESS …]',
     '[NOTE: …]', 'Note: This URL failed …') so they never leak into the user reply."""
@@ -4607,130 +4567,6 @@ def _format_text_for_pdf(text: str, title: str, base_url: str, api_key: str,
         return fallback
 
 
-# A clear "make a PDF from this" request. Matched against the raw user message so we
-# can run the PDF pipeline deterministically — a small model cannot reliably echo a
-# long document back into a Python string literal for the create_pdf() tool call.
-_PDF_INTENT = re.compile(
-    r"(create|make|generate|export|build|produce|convert|turn)\b[\s\S]{0,40}\bpdf\b"
-    r"|\bpdf\b[\s\S]{0,40}\b(from|for|of|with|out of)\b",
-    re.IGNORECASE,
-)
-
-# Follow-up phrasings that reference an *existing / target* PDF — e.g. "in the pdf
-# file", "add the teams to the pdf", "put it in the pdf", "update the pdf", "as a pdf".
-# These carry no "create … pdf" verb so _PDF_INTENT misses them, yet they still mean
-# "(re)generate the PDF" — previously they fell through to the CodeAgent and crashed
-# on create_pdf(text="…long literal…"). The document body comes from history (A2).
-_PDF_FOLLOWUP = re.compile(
-    r"\b(in|into|on|to)\s+(the\s+|a\s+|this\s+|that\s+)?pdf\b"
-    r"|\b(add|include|put|fill|insert|append|update|regenerate|remake|redo)\b[\s\S]{0,40}\bpdf\b"
-    r"|\bpdf\b[\s\S]{0,40}\b(add|include|fill|update|insert|append)\b"
-    r"|\bas\s+(a\s+)?pdf\b"
-    r"|\bthe\s+pdf\s+file\b",
-    re.IGNORECASE,
-)
-
-# Interrogatives ABOUT an existing PDF ("what's in the pdf?") must NOT trigger
-# generation — only imperative (re)build requests should.
-_PDF_QUESTION = re.compile(
-    r"^\s*(what|why|how|where|who|which|when|does|do|is|are|can|could|should|would)\b[\s\S]*\?\s*$",
-    re.IGNORECASE,
-)
-
-# READING an existing PDF ("summarize this pdf", "extract text from the pdf") is the job
-# of extract_text_from_pdf, NOT the create fast-path. These read verbs must veto _wants_pdf
-# so a "summarize the pdf file" request doesn't get hijacked into (re)generating a PDF.
-# Deliberately excludes add/put/fill/update (task #6 follow-ups still (re)generate).
-_PDF_READ_INTENT = re.compile(
-    r"\b(read|summari[sz]e|extract|analy[sz]e|parse|review|scan)\b[\s\S]{0,40}\bpdf\b"
-    r"|\bpdf\b[\s\S]{0,40}\b(say|says|contain|contains|about|content)\b",
-    re.IGNORECASE,
-)
-
-
-# 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
-    when asking us to READ/summarize an existing PDF (that's extract_text_from_pdf)."""
-    t = (text or "").strip()
-    if not t:
-        return False
-    if _PDF_QUESTION.match(t):
-        return False
-    if _PDF_READ_INTENT.search(t):
-        return False
-    return bool(_PDF_INTENT.search(t) or _PDF_FOLLOWUP.search(t))
-
-
-def _extract_pdf_doc_text(user_text: str) -> str:
-    """Pull the document body out of a 'create a PDF from this text "…"' message.
-
-    Prefers a quoted span; otherwise strips the leading instruction clause.
-    """
-    t = user_text or ""
-    # 1) Largest quoted span (straight, smart, or single quotes).
-    best = ""
-    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()) > len(best):
-            best = m.group(1).strip()
-    if best:
-        return best
-    # 2) Everything after a 'text:'/'following:'/'content:' lead-in.
-    m = re.search(r"\b(texts?|following|below|content|data)\b\s*[:\-]?\s*\n?", t, re.IGNORECASE)
-    if m and t[m.end():].strip():
-        return t[m.end():].strip()
-    # 3) Drop a leading 'please create a pdf (file) from this text:' verb phrase.
-    stripped = re.sub(
-        r"^\s*(please\s+)?(create|make|generate|export|build|produce|convert|turn)\s+"
-        r"(a\s+|an\s+|this\s+|the\s+)?(pdf|document)\s*(file|doc)?\s*"
-        r"(from|for|of|with|using|out of)?\s*(this|the|following)?\s*"
-        r"(text|texts|data|content)?\s*[:\-]?\s*",
-        "",
-        t,
-        flags=re.IGNORECASE,
-    )
-    return stripped.strip() or t.strip()
-
-
-def _derive_pdf_title(doc_text: str) -> str:
-    """Use the first meaningful line as the document title (strip leading symbols/emoji)."""
-    for line in (doc_text or "").splitlines():
-        s = line.strip().lstrip("#").strip()
-        if not s:
-            continue
-        # Drop leading non-letter symbols/emoji (keep Latin + Vietnamese letters/digits).
-        s2 = re.sub(r"^[^\wÀ-ỹ]+", "", s).strip()
-        return (s2 or s)[:60]
-    return "Document"
-
 
 # ============================ RAG (knowledge base) ============================
 # The agent can download a ZIP-at-URL, unzip it locally, index the text files into a
@@ -7956,106 +7792,6 @@ 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
-    # the tool ever runs. When the user clearly wants a PDF, extract their real text and
-    # run format → render → upload directly. No model string-echoing, and 1 fewer call.
-    # (worker_api_base / worker_api_key are read once near the top of run_agent_chat.)
-    if _wants_pdf(latest_user_text):
-        doc_text = _extract_pdf_doc_text(latest_user_text)
-        # A2: a follow-up like "in the pdf file" / "add the teams to the pdf" carries
-        # no document body — it refers to the last thing the assistant produced. Pull
-        # 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:
-            for m in reversed(messages[:last_user_idx]):
-                if m.get("role") != "assistant":
-                    continue
-                cand = think_re.sub("", (m.get("content") or "")).strip()
-                low = cand.lower()
-                # Skip our own PDF-ready confirmations / bare links — not document bodies.
-                if cand.startswith("✅") or low.startswith("http") or "amazonaws.com" in low:
-                    continue
-                if len(cand) >= 40:
-                    prior_doc = cand
-                    break
-            if prior_doc:
-                edit_instruction = latest_user_text.strip()
-                doc_text = prior_doc
-
-        # 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)")
-            # 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(
-                f"PDF fast-path: title={_c(doc_title, r=True)} doc_chars={len(doc_text)}"
-                + (f" edit={_c(edit_instruction, 60, r=True)}" if edit_instruction else "")
-            )
-
-            _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,
-                agent_base_url or coding_base_url, agent_api_key,
-                agent_model_id or coding_model_id,
-                instruction=edit_instruction,
-            )
-
-            _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
-
-            if not local_artifacts:
-                _emit({"type": "step", "text": "Uploading PDF…"})
-            try:
-                out = _deliver_artifact(
-                    f"{doc_title}.pdf", pdf_bytes, "application/pdf", "PDF",
-                    local=local_artifacts, api_base=worker_api_base, worker_key=worker_api_key,
-                    ask_s3_setup=_ask_s3_setup,
-                )
-            except Exception as e:  # noqa: BLE001
-                _log(f"PDF fast-path delivery error: {type(e).__name__}: {e!r}\n{traceback.format_exc()}")
-                _emit({"type": "final", "text": (
-                    f"PDF was created but could not be delivered: {str(e)[:200]}"
-                )})
-                return
-
-            _log(f"PDF fast-path ok title={_c(doc_title, r=True)} bytes={len(pdf_bytes)}")
-            _emit({"type": "final", "text": out})
-            return
-    # ---------------------------------------------------------------------------------
-
     # Prepend explicit tool instructions so small models pick the right tool, never
     # fabricate URLs/responses, and always terminate with final_answer().
     from datetime import datetime as _dt_now
@@ -8250,10 +7986,6 @@ def run_agent_chat(cfg):
         "AFTER editing, re-read with grep_repo/read_file_lines (an indexed knowledge base may be "
         "stale — do not trust rag_search for freshly edited code).\n"
     ) if _WS_AVAILABLE else ""
-    _pdf_read_choose_line = (
-        "- 'read'/'summarize'/'what does the PDF say' for an existing PDF URL -> "
-        "extract_text_from_pdf(url).\n"
-    ) if _PDF_READ_AVAILABLE else ""
     _email_choose_line = (
         "- 'email …' / 'send an email to …' -> send_email(to, subject, body) "
         "(previews first, then sends on confirm).\n"
@@ -8345,11 +8077,7 @@ def run_agent_chat(cfg):
         "- any arithmetic, percentage, or 'how much is' math -> calculate(expression).\n"
         "- 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 + _rag_choose_line + _ws_choose_line +
+        + _email_choose_line + _rag_choose_line + _ws_choose_line +
         "- A specific known API/URL was given -> http_request().\n"
         "\n"
         "RULES:\n"
@@ -8364,13 +8092,11 @@ def run_agent_chat(cfg):
         "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"
+        "finish with the tool that delivers what was asked, or final_answer. NEVER repeat a "
+        "web_search/fetch_url you already ran.\n"
         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"
+        "finishing.\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/
@@ -8503,10 +8229,6 @@ def run_agent_chat(cfg):
         _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 = []
-
     # --- Loop / no-progress guards (task #79) -------------------------------------------
     # Weak coders thrash on a debug loop: rewrite a file to a previously-tried version,
     # re-hit a broken endpoint, and re-read unchanged files — burning the whole step
@@ -8739,8 +8461,6 @@ def run_agent_chat(cfg):
         )
         _log(f"web_search {_c(query, 60, r=True)} → {_c(result, 80)}")
         _last_obs["text"] = result
-        if result and not result.startswith("Error"):
-            _gathered.append(result)
         return result
 
     @tool
@@ -8791,7 +8511,6 @@ def run_agent_chat(cfg):
         out = f"{url}\n{text}"
         _log(f"fetch_url {_u(url)} → {len(text)} chars")
         _last_obs["text"] = out
-        _gathered.append(out)
         return out
 
     @tool
@@ -8904,17 +8623,46 @@ def run_agent_chat(cfg):
         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.
+    def create_pdf(text: str = "", title: str = "", path: str = "") -> str:
+        """Create a PDF document and return where it is (a download link, or a file on this computer).
 
-        Use this ONLY when the user explicitly asks to make/create/generate/export a PDF.
-        The text is first cleaned into well-formed Markdown, then rendered to a PDF on the
-        worker and uploaded to cloud storage; the returned message contains the download URL.
+        Use this when the user asks for a PDF. Give EITHER the content as text, OR the path of a
+        file in the project to turn into a PDF (a .txt/.md/.csv…) — a file is read as it is, so
+        pass its path rather than copying its contents into text. The content is cleaned into
+        Markdown and rendered.
 
         Args:
-            text: The content to put in the PDF (raw text, notes, or data).
+            text: The content to put in the PDF (raw text, notes, or data). Leave empty when giving path.
             title: Optional document title shown at the top and used in the file name.
+            path: A text file in the project to turn into a PDF, instead of text.
         """
+        # A FILE, read here (task #269 follow-up): "a PDF of this .txt file" used to be caught by
+        # a keyword fast-path that rendered the REQUEST's own words. The same reach as
+        # read_text_file — registered workspaces, the terminal folder, ~/.gonext, the temp dir.
+        if (path or "").strip():
+            import os as _os_pdf
+            try:
+                _rp = _rag_read_allowed(path.strip())
+            except Exception as _e:  # noqa: BLE001
+                msg = f"Error: create_pdf cannot read {path}: {_e}"
+                _last_obs["text"] = msg
+                return msg
+            if not _os_pdf.path.isfile(_rp):
+                msg = f"Error: not a file: {path}"
+                _last_obs["text"] = msg
+                return msg
+            if _os_pdf.path.getsize(_rp) > 2 * 1024 * 1024:
+                msg = f"Error: {path} is larger than 2 MB — too big for one PDF."
+                _last_obs["text"] = msg
+                return msg
+            with open(_rp, "r", encoding="utf-8", errors="replace") as _fh:
+                text = _fh.read()
+            if not (title or "").strip():
+                title = _os_pdf.path.splitext(_os_pdf.path.basename(_rp))[0]
+        if not (text or "").strip():
+            msg = "Error: create_pdf needs the content — text=… or path=<a file in the project>."
+            _last_obs["text"] = msg
+            return msg
         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
@@ -8950,7 +8698,8 @@ def run_agent_chat(cfg):
             _last_obs["text"] = msg
             return 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).
+        # CHAT model, not the coder: formatting is a plain rewrite, and the coder is the slow,
+        # expensive one (task #74).
         _emit({"type": "step", "text": "Formatting document…"})
         markdown_text = _format_text_for_pdf(
             text or "", doc_title,
@@ -8981,8 +8730,8 @@ def run_agent_chat(cfg):
             return msg
 
         # 3) Hand it over: a link via the API-presigned PUT (no AWS creds on the worker), or — in
-        #    private mode without the user's own S3 — on this computer (task #252, same path as the
-        #    PDF fast-path and create_download).
+        #    private mode without the user's own S3 — on this computer (task #252, same path as
+        #    create_download).
         _emit({"type": "step", "text": "Uploading PDF…"})
         file_name = f"{doc_title}.pdf"
         try:
@@ -10720,36 +10469,6 @@ def run_agent_chat(cfg):
     class _ToolAgent(_AgentBase):
         def provide_final_answer(self, task, *args, **kwargs):
             from smolagents.models import ChatMessage, MessageRole
-            # Deterministic PDF delivery: the user asked for a PDF and the model did the
-            # research but never emitted the create_pdf call itself (weak/slow coders often
-            # keep researching and never converge). Rendering the gathered facts here is the
-            # INTENDED deliverable, not an error — so deliver it cleanly, with NO apologetic
-            # "may be partial / hit my step limit" note (that made a normal, successful PDF
-            # look like a failure to the user).
-            if (agent_pdf_requested and _gathered
-                    and not (_last_obs.get("text") or "").startswith("✅")):
-                _log(f"delivering PDF deterministically from {len(_gathered)} "
-                     "gathered result(s) (model didn't call create_pdf itself)")
-                try:
-                    # Reformat the raw observations into a clean document (headings/tables)
-                    # via the fast local chat model; fall back to the raw concatenation if
-                    # synthesis fails or returns nothing.
-                    compiled = _synthesize_document(
-                        _gathered, latest_user_text,
-                        agent_base_url, agent_api_key, agent_model_id,
-                    )
-                    if compiled:
-                        _log(f"synthesized document ({len(compiled)} chars) for PDF")
-                    else:
-                        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("✅"):
-                        return ChatMessage(role=MessageRole.ASSISTANT, content=out)
-                    _log(f"deterministic create_pdf did not succeed: {_c(out, 120)}")
-                except Exception as e:  # noqa: BLE001
-                    _log(f"deterministic create_pdf error: {type(e).__name__}: {e}")
             _maxsteps_partial["hit"] = True
             text = (_last_obs.get("text") or "").strip()
             if text:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.743",
+  "version": "1.0.744",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",