@tiens.nguyen/gonext-local-worker 1.0.94 → 1.0.96

package/gonext_agent_chat.py

@@ -407,6 +407,21 @@ def _render_pdf_bytes(markdown_text: str, title: str = "") -> bytes:
     return out.getvalue()
 
 
+def _ssl_context():
+    """SSL context backed by certifi's CA bundle.
+
+    macOS Python (python.org / Homebrew) doesn't use the system keychain, so urllib's
+    default verification fails with CERTIFICATE_VERIFY_FAILED. certifi ships with the
+    openai/httpx stack the worker already depends on.
+    """
+    import ssl
+    try:
+        import certifi
+        return ssl.create_default_context(cafile=certifi.where())
+    except Exception:  # noqa: BLE001 — fall back to system defaults
+        return ssl.create_default_context()
+
+
 def _pdf_upload_via_api(api_base: str, worker_key: str, file_name: str,
                         pdf_bytes: bytes) -> str:
     """Ask the API to presign an S3 upload, PUT the PDF bytes, return the download URL.
@@ -416,6 +431,7 @@ def _pdf_upload_via_api(api_base: str, worker_key: str, file_name: str,
     import urllib.request as _u
     import urllib.error as _ue
 
+    ctx = _ssl_context()
     base = (api_base or "").rstrip("/")
     if not base or not worker_key:
         raise RuntimeError("PDF upload is not available: worker API base/key missing.")
@@ -431,7 +447,7 @@ def _pdf_upload_via_api(api_base: str, worker_key: str, file_name: str,
         method="POST",
     )
     try:
-        with _u.urlopen(req, timeout=30) as resp:
+        with _u.urlopen(req, timeout=30, context=ctx) as resp:
             ref = json.loads(resp.read().decode("utf-8"))
     except _ue.HTTPError as e:  # noqa: PERF203
         detail = e.read().decode("utf-8", "replace")[:300]
@@ -453,7 +469,7 @@ def _pdf_upload_via_api(api_base: str, worker_key: str, file_name: str,
         method="PUT",
     )
     try:
-        with _u.urlopen(put_req, timeout=60) as up:
+        with _u.urlopen(put_req, timeout=60, context=ctx) as up:
             if up.status not in (200, 201, 204):
                 raise RuntimeError(f"S3 upload failed (HTTP {up.status}).")
     except _ue.HTTPError as e:  # noqa: PERF203
@@ -506,6 +522,59 @@ 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,
+)
+
+
+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"
+
+
 def run_agent_chat(cfg):
     try:
         from smolagents import CodeAgent, OpenAIServerModel, tool
@@ -635,6 +704,58 @@ def run_agent_chat(cfg):
     _log("router: agent (HTTP tool use needed)")
     _emit({"type": "step", "text": "Choosing a tool…"})
 
+    # ---- 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.
+    # (pdf_api_base / pdf_worker_key are read once near the top of run_agent_chat.)
+    if _PDF_INTENT.search(latest_user_text or ""):
+        doc_text = _extract_pdf_doc_text(latest_user_text)
+        doc_title = _derive_pdf_title(doc_text)
+        _log(f"PDF fast-path: title={doc_title!r} doc_chars={len(doc_text)}")
+
+        _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
+        )
+
+        _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}"
+        )
+        _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
     # fabricate URLs/responses, and always terminate with final_answer().
     from datetime import datetime as _dt_now

package/package.json

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