@tiens.nguyen/gonext-local-worker 1.0.190 → 1.0.192

package/gonext_agent_chat.py

@@ -476,6 +476,28 @@ def _clip(text: str, limit: int = 280) -> str:
     return f"{cut}…"
 
 
+def _render_numbered_tool_list(tools) -> str:
+    """Render '  N. name(args) — description' lines from the REAL registered smolagents
+    tool objects — their actual name/inputs/docstring — instead of a hand-maintained
+    duplicate of the same information. This is the single source of truth for what's
+    ACTUALLY callable, so the list can never drift out of sync with the tool set (e.g.
+    when RAG or a workspace is enabled/disabled) and the numbering is always exactly
+    correct, unlike the old manually-incremented counter it replaces. Kept intentionally
+    terse — first docstring line only, bare arg names — since the system prompt's own
+    `tool.to_code_prompt()` rendering (see _COMPACT_CODE_SYSTEM_PROMPT) already shows the
+    full typed signature on every model call; this is just a quick-reference index."""
+    lines = []
+    for i, t in enumerate(tools, 1):
+        args = []
+        for pname, pinfo in (getattr(t, "inputs", None) or {}).items():
+            optional = isinstance(pinfo, dict) and pinfo.get("nullable")
+            args.append(f"{pname}=''" if optional and pinfo.get("type") == "string" else pname)
+        desc_full = (getattr(t, "description", "") or "").strip()
+        desc = desc_full.splitlines()[0] if desc_full else ""
+        lines.append(f"  {i}. {t.name}({', '.join(args)}) — {desc}")
+    return ("\n".join(lines) + "\n") if lines else ""
+
+
 def _summarise_step(step_log):
     """Return a short human-readable description of an agent step."""
     tool_calls = getattr(step_log, "tool_calls", None) or []
@@ -598,6 +620,31 @@ def _is_trivial_chat(text: str) -> bool:
     return bool(_TRIVIAL_CHAT.match(t))
 
 
+# A weak/confused coding model sometimes "thinks out loud" in plain prose instead of
+# emitting the next tool call — e.g. a rambling, self-correcting scratchpad ("Wait,
+# actually... Let's try... Actually, let's just...") that can run thousands of chars.
+# The prose-final-answer heuristic below (long text with list-like structure) can't tell
+# this apart from a genuine, complete answer on structure alone — both use headings/
+# numbered lists. These two signals catch the scratchpad case specifically: it either
+# self-labels as "Thought"/"Thinking Process" up front (a real answer doesn't open by
+# naming itself as the model's own reasoning), or it's dense with self-correction
+# language a finished answer wouldn't contain.
+_SCRATCHPAD_START_RE = re.compile(r"^\s*thought\b\s*[:\n]", re.I)
+_DELIBERATION_RE = re.compile(
+    r"\b(wait,|actually,|let'?s (try|just|use|list|see|go)|"
+    r"i (?:need to|should) (?:check|verify|confirm))\b",
+    re.I,
+)
+
+
+def _looks_like_scratchpad(stripped: str) -> bool:
+    """True if `stripped` reads like unresolved internal deliberation rather than a
+    finished, user-facing answer — see module comment above for the two signals used."""
+    if _SCRATCHPAD_START_RE.match(stripped):
+        return True
+    return len(_DELIBERATION_RE.findall(stripped)) >= 3
+
+
 # Compact replacement for smolagents' default CodeAgent system prompt. The stock template
 # is ~9.9k chars, dominated by ~6k chars of GENERIC few-shot examples (image captions,
 # Wikipedia, etc.) that are irrelevant to our HTTP/file tools and cost real prompt-eval
@@ -829,7 +876,13 @@ def _plain_reply(messages: list, base_url: str, api_key: str, model_id: str,
     and delivering it in one burst) — the worker renders these as the live-updating MAIN
     answer, not the collapsible Thinking panel. If the primary model is unreachable (e.g.
     the local MLX server is down) and a distinct fallback model is given (the coding
-    model), retry there so a greeting still gets answered instead of erroring."""
+    model), retry there so a greeting still gets answered instead of erroring.
+
+    RAISES (does not return a sentinel string) if every target fails or returns no
+    content — callers that want a soft degrade should catch this locally and substitute
+    their own clean message; letting it propagate uncaught turns into a genuine job
+    failure (red error, never persisted to conversation history) instead of a fabricated
+    "answer" that would poison every future turn's prompt with raw exception text."""
     _THINK_RE_LOCAL = re.compile(r"<think>.*?</think>", re.DOTALL | re.IGNORECASE)
     chat_messages = [{"role": "system", "content": "You are a helpful assistant."}]
     for m in messages:
@@ -863,24 +916,38 @@ def _plain_reply(messages: list, base_url: str, api_key: str, model_id: str,
             from openai import OpenAI
             client = OpenAI(base_url=b, api_key=api_key or "local",
                             max_retries=0, timeout=60)
-            return _chat_create_stream(
+            text = _chat_create_stream(
                 client, _track,
                 model=mid,
                 messages=chat_messages,
                 temperature=0.7,
                 max_tokens=512,
             ).strip()
+            if text:
+                return text
+            # The call SUCCEEDED (no exception) but the model produced NO content at all —
+            # seen with a reasoning model given a confusing/degenerate prompt (e.g. a prior
+            # turn's history polluted with raw error text). Treat this the same as a
+            # failure: fall back to the next target, or surface a clean message, rather
+            # than silently returning "" (which the caller can't tell apart from a real,
+            # deliberately empty answer).
+            last_err = RuntimeError(f"{mid} returned an empty response")
         except Exception as e:  # noqa: BLE001
             last_err = e
-            if emitted_here:
-                # Part of THIS attempt's answer already streamed to the user — don't
-                # silently splice a DIFFERENT model's output after a partial one.
-                break
-            if i + 1 < len(targets):
-                nb, nmid = targets[i + 1]  # the model we're about to try next
-                _log(f"plain reply: {mid} @ {b} failed ({e}); "
-                     f"falling back to {nmid} @ {nb}")
-    return f"[Error: {last_err}]"
+        if emitted_here:
+            # Part of THIS attempt's answer already streamed to the user — don't
+            # silently splice a DIFFERENT model's output after a partial one.
+            break
+        if i + 1 < len(targets):
+            nb, nmid = targets[i + 1]  # the model we're about to try next
+            _log(f"plain reply: {mid} @ {b} failed ({last_err}); "
+                 f"falling back to {nmid} @ {nb}")
+    # Every target failed or returned nothing — raise rather than return a sentinel
+    # string. A returned string always looks like a legitimate answer to callers (and
+    # gets persisted to conversation history); raising lets it become a genuine job
+    # failure instead (see docstring). Kept short/clean (no embedded newlines/HTML — a
+    # raw nginx 502 page can be a whole document) for whichever caller logs/surfaces it.
+    raise RuntimeError(f"couldn't get a response ({_clip(str(last_err), 160)})")
 
 
 def _synthesize_document(gathered: list, task: str, base_url: str, api_key: str,
@@ -2247,25 +2314,12 @@ 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
-    if _RAG_AVAILABLE:
-        _tool_num += 7  # download_file, unzip_file, list_dir, read_text_file, rag_index/add/search
-    if _WS_AVAILABLE:
-        _tool_num += 6  # grep_repo, read_file_lines, edit_lines, edit_file, create_file, run_command
-        if not _RAG_AVAILABLE:
-            _tool_num += 2  # list_dir + read_text_file registered for workspace browsing
-    _tool_count_word = {6: "SIX", 7: "SEVEN", 8: "EIGHT"}.get(_tool_num, str(_tool_num))
+    # The numbered tool list itself is generated LATER from the real registered tool
+    # objects (see _render_numbered_tool_list, spliced into task_with_hint below via the
+    # {{TOOL_LIST}} placeholder) — it can never drift or miscount, unlike a hand-written
+    # list with a manually-incremented number. The PDF reader / send_email / RAG /
+    # workspace tools are only ever REGISTERED (further below) when available, so an
+    # unavailable tool is never advertised.
     _rag_tool_block = (
         "  FILES & KNOWLEDGE BASE — to SUMMARIZE or ANSWER questions about a ZIP of files at a URL:\n"
         "    - download_file(url) — download a file (e.g. a .zip) to this machine.\n"
@@ -2319,18 +2373,10 @@ def run_agent_chat(cfg):
         "AFTER editing, re-read with grep_repo/read_file_lines (an S3 knowledge base may be "
         "stale — do not trust rag_search for freshly edited code).\n"
     ) if _WS_AVAILABLE else ""
-    _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"
@@ -2342,20 +2388,10 @@ def run_agent_chat(cfg):
         "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"
-        "  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"
-        "  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 + _rag_tool_block + _ws_tool_block +
+        "{{TOOL_LIST}}\n"  # filled in below, once from the REAL registered tool objects
+        f"(Current date/time: {now_str} — pass a timezone to get_current_datetime() only "
+        "if the task needs a DIFFERENT one.)\n"
+        + _rag_tool_block + _ws_tool_block +
         "\n"
         "http_request RETURN FORMAT: 'HTTP 200\\n{body}' — first line is 'HTTP <code>', body follows.\n"
         "\n"
@@ -3114,9 +3150,11 @@ def run_agent_chat(cfg):
                             msg.content = normalized
                     else:
                         stripped = content.strip()
-                        looks_final = len(stripped) >= 400 or re.search(
-                            r"(^|\n)#{1,4}\s|\n\d+\.\s|\n[-*]\s|\|.+\|", stripped
-                        ) is not None
+                        looks_final = (
+                            len(stripped) >= 400 or re.search(
+                                r"(^|\n)#{1,4}\s|\n\d+\.\s|\n[-*]\s|\|.+\|", stripped
+                            ) is not None
+                        ) and not _looks_like_scratchpad(stripped)
                         if stripped and looks_final:
                             _log(
                                 f"prose-only turn ({len(stripped)} chars, no tool call) "
@@ -3125,6 +3163,19 @@ def run_agent_chat(cfg):
                             msg.content = (
                                 stripped + "\n<code>\nfinal_answer(" + repr(stripped) + ")\n</code>"
                             )
+                        elif stripped and _looks_like_scratchpad(stripped):
+                            # Looks like unresolved deliberation, not a finished answer — do
+                            # NOT wrap it as final_answer (that would dump this rambling
+                            # scratchpad into the user-facing reply AND permanently pollute
+                            # every future turn's conversation history with it, seen live:
+                            # a 6000+ char "Thinking Process:" dump derailed the next two
+                            # unrelated questions). Leave content as-is: smolagents' own
+                            # code-block parser will fail to find one and burn this step as
+                            # a normal parse-error retry, giving the model another attempt.
+                            _log(
+                                f"scratchpad-like prose ({len(stripped)} chars, no tool call) "
+                                "→ NOT auto-wrapping; letting the step fail normally"
+                            )
             except Exception as e:  # noqa: BLE001
                 _log(f"content-normalize error: {e}")
             return msg
@@ -3681,8 +3732,9 @@ def run_agent_chat(cfg):
 
         agent_tools = [http_request, web_search, fetch_url, calculate,
                        get_current_datetime, create_pdf]
-        # Only register the PDF reader / email / RAG tools when available (kept in sync
-        # with the gated hint entries above so the model never sees a tool it can't run).
+        # Only register the PDF reader / email / RAG tools when available — the model
+        # never sees a tool it can't run, since the task-hint's tool list (filled in just
+        # below) is generated FROM this exact list, so it's always in sync by construction.
         if _PDF_READ_AVAILABLE:
             agent_tools.append(extract_text_from_pdf)
         if _EMAIL_AVAILABLE:
@@ -3697,6 +3749,12 @@ def run_agent_chat(cfg):
             # (S3 indexing) isn't configured.
             if not _RAG_AVAILABLE:
                 agent_tools += [list_dir, read_text_file]
+        # Fill in the numbered tool list now that the REAL tool objects exist — see
+        # _render_numbered_tool_list and the {{TOOL_LIST}} placeholder left in tool_hint.
+        task_with_hint = task_with_hint.replace(
+            "{{TOOL_LIST}}",
+            f"You have {len(agent_tools)} tools:\n" + _render_numbered_tool_list(agent_tools),
+        )
         agent_kwargs = dict(
             tools=agent_tools,
             model=model,
@@ -3754,14 +3812,20 @@ def run_agent_chat(cfg):
             _emit({"type": "final", "text": f"⚠️ {cfg_err}"})
             return
         # 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.
+        # answer from the conversation rather than surfacing a raw error to the user —
+        # but only when the fallback ACTUALLY has something useful to say.
         _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}]"})
+            # Nothing useful to say — re-raise the ORIGINAL (more relevant) agent
+            # failure so this becomes a genuine job failure: a red error the REPL/web
+            # already handle correctly, NOT persisted to conversation history. Emitting
+            # a fabricated "final" answer here instead would poison every future turn's
+            # prompt with raw exception text (this is exactly what caused task #35).
+            raise e
+        _emit({"type": "final", "text": fallback})
 
 
 def _log(text: str):

package/package.json

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