@tiens.nguyen/gonext-local-worker 1.0.117 → 1.0.123

package/gonext-local-worker.mjs

@@ -1506,11 +1506,25 @@ async function runAgentChatJob(job) {
       codingBaseURL: payload?.codingBaseURL ?? "",
       codingModelId: payload?.codingModelId ?? "",
       tools: payload?.tools ?? ["http_request"],
-      maxSteps: payload?.maxSteps ?? 5,
+      maxSteps: payload?.maxSteps ?? 8,
+      // Tool-invocation mode for the agent: "code" (default, python CodeAgent) or
+      // "toolcall" (structured JSON tool calls). Passed through only; the API/web can
+      // set payload.agentToolMode to A/B — default keeps current behavior.
+      agentToolMode: payload?.agentToolMode ?? "code",
       // For the create_pdf tool: the worker key lets the Python tool ask the API
       // to presign an S3 upload, so no AWS creds ever live on the worker machine.
       apiBaseURL: apiBase,
       workerKey,
+      // send_email tool: the user configures their own email API (e.g. a Lambda) in
+      // web Settings. The tool is only registered when emailEnabled + URL + body
+      // template are set, and always previews before sending (confirm required).
+      emailEnabled: payload?.emailEnabled ?? false,
+      emailApiUrl: payload?.emailApiUrl ?? "",
+      emailApiMethod: payload?.emailApiMethod ?? "POST",
+      emailApiHeaders: payload?.emailApiHeaders ?? "",
+      emailBodyTemplate: payload?.emailBodyTemplate ?? "",
+      emailFrom: payload?.emailFrom ?? "",
+      emailAllowList: payload?.emailAllowList ?? "",
     });
     const timeoutMs = 300_000; // 5 min max for an agent run
 

package/gonext_agent_chat.py

@@ -11,7 +11,7 @@ Reads on stdin:
     "codingBaseURL": str,        # optional: dedicated coding/reasoning model for the
     "codingModelId": str,        #   CodeAgent's tool-use loop; empty = reuse agentModelId
     "tools": ["http_request"],   # v1: only http_request
-    "maxSteps": int              # default 10
+    "maxSteps": int              # multi-step ReAct budget; default 8
   }
 
 Emits NDJSON lines on stdout:
@@ -65,6 +65,213 @@ def _http_request_impl(method, url, headers=None, body=None, timeout=25):
         return f"Error: {e}"
 
 
+def _html_to_text(html_text, limit=4000):
+    """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."""
+    import html as _html
+    text = html_text or ""
+    # Drop script/style/head/svg noise wholesale (incl. their content).
+    text = re.sub(r"(?is)<(script|style|head|noscript|svg|template)\b.*?</\1>", " ", text)
+    # Turn block-ending tags into newlines so document structure survives stripping.
+    text = re.sub(r"(?i)<(br|/p|/div|/li|/tr|/h[1-6]|/section|/article)\s*>", "\n", text)
+    # Remove all remaining tags.
+    text = re.sub(r"(?s)<[^>]+>", " ", text)
+    text = _html.unescape(text)
+    # Collapse runs of blank space but keep line breaks for readability.
+    lines = [re.sub(r"[ \t]{2,}", " ", ln).strip() for ln in text.splitlines()]
+    text = "\n".join(ln for ln in lines if ln)
+    if len(text) > limit:
+        text = text[:limit].rstrip() + "\n…[truncated]"
+    return text.strip()
+
+
+def _fetch_page_impl(url, timeout=25, max_bytes=300000):
+    """GET a URL for reading. Returns (status:int|None, content_type:str, raw:bytes).
+
+    status None => transport error (raw holds the message). Reads more than
+    _http_request_impl (which caps at 2000 chars) so a page has enough text to read.
+    """
+    req = urllib.request.Request(url, method="GET", headers={
+        "User-Agent": "gonext-agent/1.0 (local API testing assistant)",
+        "Accept": "text/html,application/xhtml+xml,text/plain,*/*",
+    })
+    try:
+        with urllib.request.urlopen(req, timeout=timeout, context=_ssl_context()) as resp:
+            ctype = (resp.headers.get("Content-Type") or "").lower()
+            return resp.status, ctype, resp.read(max_bytes)
+    except urllib.error.HTTPError as e:
+        return e.code, "", e.read(512)
+    except Exception as e:  # noqa: BLE001
+        return None, "", str(e).encode()
+
+
+def _calc_impl(expression):
+    """Safely evaluate an arithmetic expression via an AST whitelist (no eval()).
+
+    Accepts + - * / // % ** and () plus a small function/const allow-list. Normalizes
+    common natural phrasings ('15% of 80', '2^10', '×', '÷'). Returns a result string
+    or an 'Error: …' string — never raises.
+    """
+    import ast
+    import math
+    import operator
+    expr = (expression or "").strip()
+    if not expr:
+        return "Error: empty expression."
+    # Natural-language normalizations before parsing.
+    expr = re.sub(r"(\d+(?:\.\d+)?)\s*%\s*of\s+", r"(\1/100)*", expr, flags=re.IGNORECASE)
+    expr = re.sub(r"(\d+(?:\.\d+)?)\s*%", r"(\1/100)", expr)
+    expr = expr.replace("^", "**").replace("×", "*").replace("÷", "/").replace(",", "")
+
+    ops = {
+        ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul,
+        ast.Div: operator.truediv, ast.FloorDiv: operator.floordiv,
+        ast.Mod: operator.mod, ast.Pow: operator.pow,
+        ast.USub: operator.neg, ast.UAdd: operator.pos,
+    }
+    funcs = {
+        "sqrt": math.sqrt, "pow": pow, "round": round, "abs": abs,
+        "floor": math.floor, "ceil": math.ceil, "log": math.log,
+        "log10": math.log10, "min": min, "max": max,
+    }
+    consts = {"pi": math.pi, "e": math.e, "tau": math.tau}
+
+    def _ev(node):
+        if isinstance(node, ast.Expression):
+            return _ev(node.body)
+        if isinstance(node, ast.Constant):
+            if isinstance(node.value, (int, float)) and not isinstance(node.value, bool):
+                return node.value
+            raise ValueError("only numbers allowed")
+        if isinstance(node, ast.BinOp) and type(node.op) in ops:
+            return ops[type(node.op)](_ev(node.left), _ev(node.right))
+        if isinstance(node, ast.UnaryOp) and type(node.op) in ops:
+            return ops[type(node.op)](_ev(node.operand))
+        if isinstance(node, ast.Name) and node.id in consts:
+            return consts[node.id]
+        if (isinstance(node, ast.Call) and isinstance(node.func, ast.Name)
+                and node.func.id in funcs and not node.keywords):
+            return funcs[node.func.id](*[_ev(a) for a in node.args])
+        raise ValueError("unsupported expression")
+
+    try:
+        value = _ev(ast.parse(expr, mode="eval"))
+    except ZeroDivisionError:
+        return "Error: division by zero."
+    except Exception as e:  # noqa: BLE001
+        return f"Error: cannot evaluate '{expression}' ({e})."
+    if isinstance(value, float) and value.is_integer():
+        value = int(value)
+    return str(value)
+
+
+def _pdf_reader_available():
+    """True if a PDF text-extraction library is importable on this worker."""
+    for lib in ("pypdf", "pdfminer.high_level", "PyPDF2"):
+        try:
+            __import__(lib)
+            return True
+        except Exception:  # noqa: BLE001
+            continue
+    return False
+
+
+# Probed once at import: gates whether extract_text_from_pdf is offered at all, so the
+# weak model is never advertised a tool that cannot run on this machine.
+_PDF_READ_AVAILABLE = _pdf_reader_available()
+
+
+def _extract_pdf_text_impl(url, max_chars=6000, timeout=30, max_bytes=15_000_000):
+    """Download a PDF at `url` and return its extracted text (truncated), or an
+    'Error:'/'not installed' string. Never raises. Tries pypdf then pdfminer then PyPDF2."""
+    import io
+    try:
+        req = urllib.request.Request(url, method="GET", headers={
+            "User-Agent": "gonext-agent/1.0 (local API testing assistant)",
+            "Accept": "application/pdf,*/*",
+        })
+        with urllib.request.urlopen(req, timeout=timeout, context=_ssl_context()) as resp:
+            raw = resp.read(max_bytes)
+    except Exception as e:  # noqa: BLE001
+        return f"Error: could not download {url}: {e}"
+    if not raw[:5].lstrip().startswith(b"%PDF"):
+        return (f"Error: {url} does not look like a PDF (no %PDF header). "
+                "Use fetch_url for web pages.")
+
+    text = None
+    # 1) pypdf (preferred; also handles the legacy PyPDF2 import name).
+    try:
+        try:
+            from pypdf import PdfReader
+        except ImportError:
+            from PyPDF2 import PdfReader  # type: ignore
+        reader = PdfReader(io.BytesIO(raw))
+        parts = []
+        for page in reader.pages:
+            try:
+                parts.append(page.extract_text() or "")
+            except Exception:  # noqa: BLE001 — skip unreadable pages, keep the rest
+                continue
+        text = "\n".join(p for p in parts if p).strip()
+    except ImportError:
+        text = None
+    except Exception as e:  # noqa: BLE001
+        return f"Error: failed to read PDF ({e})."
+
+    # 2) pdfminer.six fallback.
+    if text is None:
+        try:
+            from pdfminer.high_level import extract_text as _pm_extract
+            text = (_pm_extract(io.BytesIO(raw)) or "").strip()
+        except ImportError:
+            return ("PDF reading is not installed on this worker. Ask the user to run "
+                    "'pip install pypdf' and try again.")
+        except Exception as e:  # noqa: BLE001
+            return f"Error: failed to read PDF ({e})."
+
+    if not text:
+        return f"{url}\n(The PDF has no extractable text — it may be scanned images.)"
+    if len(text) > max_chars:
+        text = text[:max_chars].rstrip() + "\n…[truncated]"
+    return f"{url}\n{text}"
+
+
+# Affirmative confirmation tokens for send_email's two-step (preview → confirm) flow.
+# A send only happens when one of these is in the CURRENT user message AND a prior
+# assistant turn already showed a preview — so the weak model cannot self-confirm.
+_EMAIL_CONFIRM = re.compile(
+    r"\b(confirm(?:ed)?|send it|send the (?:email|mail)|go ahead|approved?|"
+    r"yes\s*,?\s*send|do it|please send)\b",
+    re.IGNORECASE,
+)
+
+
+def _email_allowed(addr, allow):
+    """True if addr matches an allow-list entry — an exact address or a bare domain."""
+    a = (addr or "").lower()
+    dom = a.split("@")[-1]
+    for entry in allow:
+        e = entry.lstrip("@")
+        if a == entry or dom == e:
+            return True
+    return False
+
+
+def _email_fill_template(template, mapping):
+    """Fill {{key}} placeholders in a JSON body template with JSON-escaped values, then
+    parse. Returns a dict/list on success, or an 'Error: …' string. JSON-escaping keeps
+    the body valid even when subject/body contain quotes or newlines."""
+    out = template or ""
+    for key, val in mapping.items():
+        esc = json.dumps("" if val is None else str(val))[1:-1]
+        out = out.replace("{{%s}}" % key, esc).replace("{{ %s }}" % key, esc)
+    try:
+        return json.loads(out)
+    except Exception as e:  # noqa: BLE001
+        return (f"Error: the email body template is not valid JSON after filling in the "
+                f"values ({e}). Fix the template in Settings.")
+
+
 def _get_json(url, timeout=15):
     """GET a URL and parse the JSON body. Returns dict/list, or None on failure.
 
@@ -231,6 +438,9 @@ _AGENT_KEYWORDS = re.compile(
     r"|download|scrape|crawl"
     r"|search|find|look\s*up|lookup|weather|news|latest|current|today|tonight"
     r"|date|time|what\s+day|what\s+time"
+    r"|read\s+(?:this\s+|that\s+|the\s+)?(?:page|article|url|link)|open\s+(?:this\s+|that\s+|the\s+)?(?:url|link|page)|contents?\s+of"
+    r"|calculate|compute|convert|multiply|divide|percentage|percent|average|how\s+much\s+is"
+    r"|email|e-mail|send\s+(?:an?\s+)?(?:email|mail)|mail\s+to"
     r"|pdf|\.pdf|create\s+a\s+pdf|generate\s+a\s+pdf|make\s+a\s+pdf|export.*pdf|make\s+a\s+document"
     r")\b",
     re.IGNORECASE,
@@ -360,6 +570,27 @@ def _strip_tool_tags(text: str) -> str:
     return "\n".join(out).strip()
 
 
+_THINK_BLOCK = re.compile(r"<think>.*?</think>", re.DOTALL | re.IGNORECASE)
+
+
+def _strip_think(text: str) -> str:
+    """Remove Qwen3-style <think>…</think> reasoning traces from a model reply.
+
+    Reasoning models (e.g. Qwen3) emit their chain-of-thought inside <think> tags
+    before the actual answer/code. We keep thinking ON (it improves the output) but
+    strip the trace before smolagents parses the step, so the code/final_answer parser
+    only sees the real content — and the trace never leaks to the user. Handles a
+    dangling </think> too (some chat templates open <think> server-side)."""
+    if not text:
+        return text
+    text = _THINK_BLOCK.sub("", text)
+    low = text.lower()
+    if "</think>" in low and "<think>" not in low:
+        # Template opened the think tag for the model; drop everything up to the close.
+        text = text[low.find("</think>") + len("</think>"):]
+    return text.strip()
+
+
 _PDF_INSTALL_HINT = (
     "PDF engine not installed on the worker. On macOS:\n"
     "    brew install pango libffi\n"
@@ -505,11 +736,12 @@ def _pdf_upload_via_api(api_base: str, worker_key: str, file_name: str,
 
 
 def _format_text_for_pdf(text: str, title: str, base_url: str, api_key: str,
-                         model_id: str) -> str:
+                         model_id: str, instruction: str = "") -> str:
     """Use the model to clean/structure raw text into well-formed Markdown for the PDF.
 
-    Falls back to the original text (lightly wrapped) if the model call fails, so a
-    PDF is still produced.
+    When `instruction` is set (a follow-up edit like "fill the teams to the schedule"),
+    the model applies that change to `text` while reformatting. Falls back to the
+    original text (lightly wrapped) if the model call fails, so a PDF is still produced.
     """
     fallback = text or ""
     if title and not fallback.lstrip().startswith("#"):
@@ -518,20 +750,28 @@ def _format_text_for_pdf(text: str, title: str, base_url: str, api_key: str,
         from openai import OpenAI
         client = OpenAI(base_url=base_url, api_key=api_key or "local",
                         max_retries=0, timeout=60)
+        system_content = (
+            "You format raw text/data into clean Markdown for a PDF document. "
+            "Add a single top-level '# Title', sensible headings, bullet lists, "
+            "and tables where appropriate. Do NOT invent facts, do NOT add "
+            "commentary, and preserve all numbers and wording. Output ONLY the "
+            "Markdown — no code fences, no explanations."
+        )
+        if instruction:
+            system_content += (
+                " Apply the user's requested change to the content before formatting; "
+                "keep everything else intact."
+            )
+        user_content = (
+            (f"Title: {title}\n\n" if title else "")
+            + (f"Requested change: {instruction}\n\n" if instruction else "")
+            + f"Content to format:\n{text}"
+        )
         resp = client.chat.completions.create(
             model=model_id,
             messages=[
-                {"role": "system", "content": (
-                    "You format raw text/data into clean Markdown for a PDF document. "
-                    "Add a single top-level '# Title', sensible headings, bullet lists, "
-                    "and tables where appropriate. Do NOT invent facts, do NOT add "
-                    "commentary, and preserve all numbers and wording. Output ONLY the "
-                    "Markdown — no code fences, no explanations."
-                )},
-                {"role": "user", "content": (
-                    (f"Title: {title}\n\n" if title else "")
-                    + f"Content to format:\n{text}"
-                )},
+                {"role": "system", "content": system_content},
+                {"role": "user", "content": user_content},
             ],
             max_tokens=1500,
             temperature=0.2,
@@ -555,6 +795,51 @@ _PDF_INTENT = re.compile(
     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,
+)
+
+
+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.
@@ -636,11 +921,18 @@ def run_agent_chat(cfg):
     else:
         coding_base_url = agent_base_url
         coding_model_id = agent_model_id
-    # Strict single-shot: exactly ONE agent model call per message. The single code
-    # block must call a tool AND final_answer together — no multi-step ReAct loop.
-    # If the model fails to call final_answer, the max-steps fallback below returns
-    # the last tool observation deterministically (no extra model call).
-    max_steps = 1
+    # Multi-step ReAct loop (thinking agent): the agent may take several
+    # Thought → tool → Observation steps and then call final_answer() itself. This
+    # replaced the old strict single-shot (max_steps=1) once a stronger coding model
+    # (Qwen3-14B class) made real multi-step reasoning reliable. Default budget 8,
+    # overridable via cfg.maxSteps. The provide_final_answer override below is now only
+    # the exhaustion fallback (loop ends without final_answer).
+    try:
+        max_steps = int(cfg.get("maxSteps") or 8)
+    except (TypeError, ValueError):
+        max_steps = 8
+    if max_steps < 1:
+        max_steps = 8
 
     _log(
         f"start model={agent_model_id!r} base={agent_base_url!r} "
@@ -713,8 +1005,41 @@ def run_agent_chat(cfg):
         _log(f"  history[{j}]: {ln[:240]}")
     _log(f"current task (latest user message): {task_text.rsplit('Current task: ', 1)[-1][:240]!r}")
 
+    # ---- send_email config (per-user email API, e.g. a Lambda the user set up) ----
+    email_enabled = bool(cfg.get("emailEnabled"))
+    email_api_url = (cfg.get("emailApiUrl") or "").strip()
+    email_api_method = ((cfg.get("emailApiMethod") or "POST").strip().upper()) or "POST"
+    email_api_headers_raw = (cfg.get("emailApiHeaders") or "").strip()
+    email_body_template = (cfg.get("emailBodyTemplate") or "").strip()
+    email_from = (cfg.get("emailFrom") or "").strip()
+    email_allow = [a for a in re.split(r"[,\s]+", (cfg.get("emailAllowList") or "").strip().lower()) if a]
+    # Advertised + registered ONLY when fully configured AND enabled — an outward
+    # action must never be silently available (same gating as the PDF reader).
+    _EMAIL_AVAILABLE = bool(email_enabled and email_api_url and email_body_template)
+
+    def _prior_email_preview() -> bool:
+        """True if an earlier assistant turn showed a send_email preview awaiting confirm."""
+        for m in reversed(messages[:last_user_idx]):
+            if m.get("role") == "assistant":
+                c = m.get("content") or ""
+                if "📧" in c and "About to email" in c:
+                    return True
+        return False
+
+    def _email_confirm_pending() -> bool:
+        """A send is authorized only when the CURRENT message confirms AND a preview
+        was already shown — the weak model cannot self-confirm."""
+        return bool(_EMAIL_AVAILABLE and _EMAIL_CONFIRM.search(latest_user_text or "")
+                    and _prior_email_preview())
+
     # Route: ask the model if this task needs HTTP tool use.
     needs_agent = _route(latest_user_text, agent_base_url, agent_api_key, agent_model_id)
+    # A pending email awaiting 'confirm' must reach the agent even though a bare
+    # 'confirm' / 'send it' is not a network keyword — otherwise the send never fires.
+    if not needs_agent and _email_confirm_pending():
+        _log("router → YES (email confirm pending)")
+        _emit({"type": "step", "text": "→ Agent mode (email confirm)"})
+        needs_agent = True
 
     if not needs_agent:
         _log("router: plain chat (no HTTP needed)")
@@ -734,14 +1059,39 @@ def run_agent_chat(cfg):
     # 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 ""):
+    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 = ""
+        if len(doc_text.strip()) < 40:
+            prior_doc = ""
+            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
         doc_title = _derive_pdf_title(doc_text)
-        _log(f"PDF fast-path: title={doc_title!r} doc_chars={len(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
+            doc_text, doc_title, coding_base_url, agent_api_key, coding_model_id,
+            instruction=edit_instruction,
         )
 
         _emit({"type": "step", "text": "Rendering PDF…"})
@@ -784,19 +1134,56 @@ def run_agent_chat(cfg):
     # fabricate URLs/responses, and always terminate with final_answer().
     from datetime import datetime as _dt_now
     now_str = _dt_now.now().astimezone().strftime("%A, %d %B %Y, %H:%M %Z")
+    # The PDF reader and send_email are only advertised (and registered) when available
+    # here — never offer the model a tool it cannot run. Entry numbers are dynamic so the
+    # list reads cleanly whether 6, 7, or 8 tools are present.
+    _tool_num = 6
+    _pdf_num = 0
+    if _PDF_READ_AVAILABLE:
+        _tool_num += 1
+        _pdf_num = _tool_num
+    _email_num = 0
+    if _EMAIL_AVAILABLE:
+        _tool_num += 1
+        _email_num = _tool_num
+    _tool_count_word = {6: "SIX", 7: "SEVEN", 8: "EIGHT"}.get(_tool_num, str(_tool_num))
+    _pdf_read_tool_line = (
+        f"  {_pdf_num}. extract_text_from_pdf(url) — READ/summarize an EXISTING PDF file "
+        "at a URL. This does NOT create a PDF (use create_pdf for that).\n"
+    ) if _PDF_READ_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_tool_line = (
+        f"  {_email_num}. send_email(to, subject, body) — send an email via the configured "
+        "email API. It PREVIEWS first and only sends after the user replies 'confirm'.\n"
+    ) if _EMAIL_AVAILABLE else ""
+    _email_choose_line = (
+        "- 'email …' / 'send an email to …' -> send_email(to, subject, body) "
+        "(previews first, then sends on confirm).\n"
+    ) if _EMAIL_AVAILABLE else ""
     tool_hint = (
-        "YOU HAVE EXACTLY ONE TURN. Read the TASK above. In a single code block, call "
-        "the ONE tool that fits THAT task, then pass its result to final_answer(). "
-        "Do not plan multiple steps.\n\n"
-        "You have FOUR tools:\n"
+        f"Solve the TASK step by step (up to {max_steps} steps). At EACH step write a "
+        "brief Thought, then ONE code block that calls a SINGLE tool. You will SEE that "
+        "tool's result (Observation) before the next step — use it to decide what to do "
+        "next (e.g. web_search to find a URL, THEN fetch_url to read it). When you have "
+        "enough to answer, call final_answer(<your answer>) in a code block. Prefer "
+        "FEWER steps, and never repeat a tool call that already succeeded.\n\n"
+        f"You have {_tool_count_word} tools:\n"
         "  1. http_request(method, url, headers='', body='', username='', password='') — "
         "call a SPECIFIC known API/URL.\n"
         "  2. web_search(query) — look up facts about a person, place, thing, or topic "
         "when you do NOT already have a real URL. Returns a summary + source.\n"
-        f"  3. get_current_datetime(timezone='') — current date/time ONLY (now: {now_str}). "
+        "  3. fetch_url(url) — READ the full text of a specific web page (e.g. a link the "
+        "user gave, or a source URL from web_search). Returns clean text, not raw HTML.\n"
+        "  4. calculate(expression) — do math: arithmetic, percentages, powers "
+        "(e.g. '15% of 80', '(3+4)*2'). ALWAYS use this instead of computing yourself.\n"
+        f"  5. get_current_datetime(timezone='') — current date/time ONLY (now: {now_str}). "
         "Use this ONLY when the task explicitly asks for the date or time.\n"
-        "  4. create_pdf(text, title='') — make a PDF document from text/data and return a "
+        "  6. create_pdf(text, title='') — make a PDF document from text/data and return a "
         "download link. Use ONLY when the task asks to create/make/generate/export a PDF.\n"
+        + _pdf_read_tool_line + _email_tool_line +
         "\n"
         "http_request RETURN FORMAT: 'HTTP 200\\n{body}' — first line is 'HTTP <code>', body follows.\n"
         "\n"
@@ -814,7 +1201,10 @@ def run_agent_chat(cfg):
         "- ONLY a date/time question (e.g. 'what is the date today') -> get_current_datetime().\n"
         "- 'who is' / 'what is' / 'tell me about' / a person / place / topic / general "
         "knowledge -> web_search(query).\n"
+        "- 'read this page' / 'open this link' / 'what does <URL> say' -> fetch_url(url).\n"
+        "- any arithmetic, percentage, or 'how much is' math -> calculate(expression).\n"
         "- 'create/make/generate/export a PDF' of some text/data -> create_pdf(text, title).\n"
+        + _pdf_read_choose_line + _email_choose_line +
         "- A specific known API/URL was given -> http_request().\n"
         "\n"
         "RULES:\n"
@@ -839,8 +1229,8 @@ def run_agent_chat(cfg):
     # Track URLs that have already failed so we don't retry dead endpoints across steps.
     _failed_urls: set = set()
 
-    # Remember the last tool output so the single-shot fallback + the deterministic
-    # final formatting can report exactly what a tool returned (no extra model call).
+    # Remember the last tool output so the max-steps fallback can report exactly what a
+    # tool returned (no extra model call) if the loop ends without final_answer.
     _last_obs: dict = {"text": ""}
 
     @tool
@@ -941,6 +1331,135 @@ def run_agent_chat(cfg):
         _last_obs["text"] = result
         return result
 
+    @tool
+    def fetch_url(url: str) -> str:
+        """Fetch a specific web page and return its readable text (HTML stripped).
+
+        Use this to READ the actual contents of a specific URL — e.g. a page found by
+        web_search, or a link the user gave — when a summary is not enough. Returns clean
+        plain text, not raw HTML. For JSON APIs use http_request instead.
+
+        Args:
+            url: The full URL of the page to read, e.g. 'https://example.com/article'.
+        """
+        _emit({"type": "step", "text": f"Reading page → {url[:80]}"})
+        status, ctype, raw = _fetch_page_impl(url)
+        if status is None:
+            msg = f"Error: could not fetch {url}: {raw.decode('utf-8', 'replace')[:200]}"
+            _log(f"fetch_url error {url} → {msg[:80]}")
+            _last_obs["text"] = msg
+            return msg
+        if isinstance(status, int) and status >= 400:
+            msg = f"Error: {url} returned HTTP {status}. Try a different URL or use web_search()."
+            _log(f"fetch_url {url} → HTTP {status}")
+            _last_obs["text"] = msg
+            return msg
+        # PDFs / binaries don't strip to useful text.
+        if "application/pdf" in ctype or raw[:5].lstrip().startswith(b"%PDF"):
+            msg = (f"{url} is a PDF, not an HTML page — fetch_url cannot read PDFs. "
+                   "Tell the user this needs a PDF-reading tool.")
+            _log(f"fetch_url {url} → PDF, cannot read")
+            _last_obs["text"] = msg
+            return msg
+        text = _html_to_text(raw.decode("utf-8", errors="replace")) or "(page had no readable text)"
+        out = f"{url}\n{text}"
+        _log(f"fetch_url {url} → {len(text)} chars")
+        _last_obs["text"] = out
+        return out
+
+    @tool
+    def calculate(expression: str) -> str:
+        """Evaluate a math expression and return the numeric result. Do NOT do the math
+        yourself — always call this for arithmetic, percentages, powers, or conversions.
+
+        Supports + - * / // % ** and parentheses, plus sqrt/pow/round/abs/floor/ceil/log
+        and the constants pi and e. Understands '15% of 80' and '2^10'.
+
+        Args:
+            expression: The math to evaluate, e.g. '(3+4)*2', '2**10', '15% of 80'.
+        """
+        _emit({"type": "step", "text": f"Calculating → {expression[:80]}"})
+        result = _calc_impl(expression)
+        _log(f"calculate({expression!r}) → {result[:80]}")
+        _last_obs["text"] = result
+        return result
+
+    @tool
+    def send_email(to: str, subject: str, body: str) -> str:
+        """Send an email through the configured email API. Asks for confirmation FIRST.
+
+        The FIRST time you call this it only PREVIEWS the email and does NOT send — tell
+        the user to reply 'confirm' to actually send it. Use ONLY when the user explicitly
+        asks to email or send a message to someone.
+
+        Args:
+            to: Recipient email address.
+            subject: The email subject line.
+            body: The email body text.
+        """
+        to_addr = (to or "").strip()
+        if "@" not in to_addr or " " in to_addr:
+            msg = f"Error: '{to_addr}' is not a valid recipient email address."
+            _last_obs["text"] = msg
+            return msg
+        if email_allow and not _email_allowed(to_addr, email_allow):
+            msg = (f"Error: {to_addr} is not in the allowed recipients list — refusing to "
+                   "send. Add it to the allow-list in Settings if this is intended.")
+            _log(f"send_email blocked by allow-list: {to_addr}")
+            _last_obs["text"] = msg
+            return msg
+        preview = (
+            f"📧 About to email {to_addr}\n"
+            f"Subject: {subject or '(no subject)'}\n\n"
+            f"{body or '(no body)'}\n\n"
+            "Reply 'confirm' to send this, or tell me what to change."
+        )
+        # Send ONLY when the current user message confirms AND a preview was already
+        # shown — otherwise just preview (never send on the first call).
+        if not _email_confirm_pending():
+            _emit({"type": "step", "text": f"Email preview → {to_addr} (awaiting confirm)"})
+            _log(f"send_email preview (awaiting confirm) → {to_addr}")
+            _last_obs["text"] = preview
+            return preview
+        filled = _email_fill_template(email_body_template, {
+            "to": to_addr, "subject": subject or "", "body": body or "", "from": email_from,
+        })
+        if isinstance(filled, str):  # template error
+            _last_obs["text"] = filled
+            return filled
+        headers = {"Content-Type": "application/json", "Accept": "application/json"}
+        if email_api_headers_raw:
+            try:
+                headers.update(json.loads(email_api_headers_raw))
+            except Exception:  # noqa: BLE001
+                pass
+        _emit({"type": "step", "text": f"Sending email → {to_addr}"})
+        result = _http_request_impl(email_api_method, email_api_url, headers, json.dumps(filled))
+        first = result.split("\n", 1)[0] if result else "no response"
+        if result.startswith("HTTP 2"):
+            out = f"✅ Email sent to {to_addr} (Subject: {subject or '(no subject)'})."
+        else:
+            out = f"Email send failed ({first}). Check the email API settings."
+        _log(f"send_email {to_addr} → {first}")
+        _last_obs["text"] = out
+        return out
+
+    @tool
+    def extract_text_from_pdf(url: str) -> str:
+        """Read an existing PDF at a URL and return its extracted text.
+
+        Use this to READ or SUMMARIZE a PDF the user links to. This does NOT create a
+        PDF — use create_pdf for that. Returns the PDF's text (truncated), not a link.
+
+        Args:
+            url: The full URL of the PDF file, e.g. 'https://example.com/report.pdf'.
+        """
+        _emit({"type": "step", "text": f"Reading PDF → {url[:80]}"})
+        result = _extract_pdf_text_impl(url)
+        _log(f"extract_text_from_pdf {url} → {result[:80]}")
+        _last_obs["text"] = result
+        return result
+
     @tool
     def create_pdf(text: str, title: str = "") -> str:
         """Create a PDF document from text/data and return a download link.
@@ -962,7 +1481,7 @@ def run_agent_chat(cfg):
 
         # 2) Render the Markdown to PDF bytes locally (pure-Python xhtml2pdf).
         # Catch EVERYTHING (xhtml2pdf can raise arbitrary errors on exotic glyphs /
-        # emoji), so the tool always returns a string and never breaks the single shot.
+        # emoji), so the tool always returns a string and never breaks the agent loop.
         _emit({"type": "step", "text": "Rendering PDF…"})
         try:
             pdf_bytes = _render_pdf_bytes(markdown_text, doc_title)
@@ -1038,6 +1557,21 @@ def run_agent_chat(cfg):
     # and any step memory it accumulates. completion_kwargs["messages"] here is the
     # 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.
+            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)")
+                    msg.content = cleaned
+            except Exception as e:  # noqa: BLE001
+                _log(f"think-strip error: {e}")
+            return msg
+
         def _prepare_completion_kwargs(self, *args, **kwargs):
             ck = super()._prepare_completion_kwargs(*args, **kwargs)
             try:
@@ -1063,19 +1597,50 @@ def run_agent_chat(cfg):
                 _log(f"MODEL REQUEST log error: {e}")
             return ck
 
-    # Single-shot agent: if the one model call doesn't end in final_answer(),
-    # smolagents would normally make an EXTRA model call (provide_final_answer) to
+    # Tool-invocation mode: "code" (default) makes the model author a Python code
+    # block (CodeAgent); "toolcall" makes it emit a structured JSON tool call
+    # (ToolCallingAgent), which sidesteps the unterminated-string-literal failures weak
+    # models hit when forced to echo long payloads as Python literals. Default is
+    # unchanged ("code"); flip via cfg.agentToolMode to A/B without touching the
+    # working paths (datetime / web_search / http_request).
+    agent_tool_mode = (cfg.get("agentToolMode") or "code").strip().lower()
+    _AgentBase = CodeAgent
+    if agent_tool_mode == "toolcall":
+        try:
+            from smolagents import ToolCallingAgent
+            _AgentBase = ToolCallingAgent
+            _log("agent tool mode: toolcall (structured JSON tool calls)")
+        except Exception as e:  # noqa: BLE001
+            _log(f"ToolCallingAgent unavailable ({e}); falling back to CodeAgent")
+    else:
+        _log("agent tool mode: code (python CodeAgent)")
+
+    # Exhaustion fallback: normally the model calls final_answer() itself within the
+    # multi-step loop and that answer is used. Only if it burns through all max_steps
+    # WITHOUT calling final_answer does smolagents call provide_final_answer to
     # synthesize one. We override that to return the last tool observation
-    # deterministically — keeping the agent to EXACTLY ONE model call, and never
-    # corrupting exact tool output (dates/numbers) the way a weak model would.
-    class _SingleShotAgent(CodeAgent):
+    # deterministically (or a plain reply) rather than dead-ending — and without a weak
+    # model corrupting exact tool output (dates/numbers).
+    class _ToolAgent(_AgentBase):
         def provide_final_answer(self, task, *args, **kwargs):
             from smolagents.models import ChatMessage, MessageRole
             text = (_last_obs.get("text") or "").strip()
-            if not text:
-                text = ("I couldn't complete that in one step. Please rephrase, or give "
-                        "a specific URL/API to call.")
-            _log(f"single-shot fallback (no model call) → {text[:80]}")
+            if text:
+                _log(f"max-steps fallback (last tool obs) → {text[:80]}")
+            else:
+                # No usable tool output (e.g. every step's code failed to parse).
+                # Don't dead-end on a canned apology — answer from the conversation.
+                _log("max-steps fallback → plain reply over conversation")
+                try:
+                    text = _plain_reply(
+                        messages, agent_base_url, agent_api_key, agent_model_id
+                    ).strip()
+                except Exception as e:  # noqa: BLE001
+                    _log(f"plain-reply fallback error: {e}")
+                    text = ""
+                if not text:
+                    text = ("I couldn't complete that within the step budget. Please "
+                            "rephrase, or give a specific URL/API to call.")
             return ChatMessage(role=MessageRole.ASSISTANT, content=text)
 
     try:
@@ -1084,28 +1649,47 @@ def run_agent_chat(cfg):
             api_base=coding_base_url,
             api_key=agent_api_key,
         )
-        agent = _SingleShotAgent(
-            tools=[http_request, web_search, get_current_datetime, create_pdf],
+        agent_tools = [http_request, web_search, fetch_url, calculate,
+                       get_current_datetime, create_pdf]
+        # Only register the PDF reader / email tools when available (kept in sync with
+        # the gated hint entries above so the model never sees a tool it can't run).
+        if _PDF_READ_AVAILABLE:
+            agent_tools.append(extract_text_from_pdf)
+        if _EMAIL_AVAILABLE:
+            agent_tools.append(send_email)
+        agent_kwargs = dict(
+            tools=agent_tools,
             model=model,
             max_steps=max_steps,
             step_callbacks=[step_callback],
-            executor_kwargs={"timeout_seconds": 60},
-            additional_authorized_imports=["json", "base64", "urllib", "urllib.request", "urllib.error"],
         )
+        if _AgentBase is CodeAgent:
+            # Only the CodeAgent runs a Python executor; ToolCallingAgent takes neither.
+            agent_kwargs["executor_kwargs"] = {"timeout_seconds": 60}
+            agent_kwargs["additional_authorized_imports"] = [
+                "json", "base64", "urllib", "urllib.request", "urllib.error"
+            ]
+        agent = _ToolAgent(**agent_kwargs)
         with contextlib.redirect_stdout(sys.stderr):
             result = agent.run(task_with_hint)
-        # Deterministic final formatting — NO summarizer model call. The agent's
-        # final_answer (or the single-shot fallback above) already holds exact tool
-        # output; we just strip the internal hint tags we appended to tool results so
-        # they don't leak to the user. This permanently fixes the date-corruption a
-        # weak summarizer model used to introduce.
+        # Final formatting — NO extra summarizer model call. In multi-step mode the
+        # agent's own final_answer() (or the max-steps fallback above) already holds the
+        # synthesized answer; we just strip the internal hint tags we appended to tool
+        # results so they don't leak to the user.
         _emit({"type": "step", "text": "Composing answer…"})
         final_text = _strip_tool_tags(str(result).strip()) or "[No result]"
         _log(f"done (deterministic, no summarizer call): {len(final_text)} chars")
         _emit({"type": "final", "text": final_text})
     except Exception as e:  # noqa: BLE001
-        _log(f"agent error: {e}")
-        _emit({"type": "final", "text": f"[Agent error: {e}]"})
+        # An unexpected failure inside the agent loop should still return a useful
+        # answer from the conversation rather than surfacing a raw error to the user.
+        _log(f"agent error: {e} — degrading to plain reply")
+        try:
+            fallback = _plain_reply(messages, agent_base_url, agent_api_key, agent_model_id).strip()
+        except Exception as e2:  # noqa: BLE001
+            _log(f"plain-reply degrade error: {e2}")
+            fallback = ""
+        _emit({"type": "final", "text": fallback or f"[Agent error: {e}]"})
 
 
 def _log(text: str):

package/package.json

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