@tiens.nguyen/gonext-local-worker 1.0.191 → 1.0.193

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
@@ -2267,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"
@@ -2339,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"
@@ -2362,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"
@@ -3134,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) "
@@ -3145,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
@@ -3257,6 +3288,14 @@ def run_agent_chat(cfg):
             text = (_last_obs.get("text") or "").strip()
             if text:
                 _log(f"max-steps fallback (last tool obs) → {text[:80]}")
+                # Without this, `text` (a tool's RAW return value — e.g. a bare grep_repo
+                # dump of file:line hits) becomes the entire chat reply with zero framing,
+                # reading as a bizarre non-answer. A short honest note makes clear this is
+                # a partial result from an interrupted run, not the actual answer/edit.
+                text = (
+                    "I ran out of steps before finishing this. Here's the last thing I "
+                    "found — reply to have me continue from here:\n\n" + text
+                )
             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.
@@ -3313,12 +3352,18 @@ def run_agent_chat(cfg):
                 path, cached = _rag_download(url, (dest_path or "").strip())
                 if cached:
                     _emit({"type": "step", "text": "Already downloaded — reusing cached file"})
-                    return (f"Already downloaded earlier — reusing {path} "
-                            f"({os.path.getsize(path)} bytes). Next: unzip_file(zip_path='{path}').")
+                    out = (f"Already downloaded earlier — reusing {path} "
+                           f"({os.path.getsize(path)} bytes). Next: unzip_file(zip_path='{path}').")
+                    _last_obs["text"] = out
+                    return out
                 _emit({"type": "step", "text": f"Downloading → {url[:80]}"})
-                return f"Downloaded to {path} ({os.path.getsize(path)} bytes). Next: unzip_file(zip_path='{path}') if it is a zip."
+                out = f"Downloaded to {path} ({os.path.getsize(path)} bytes). Next: unzip_file(zip_path='{path}') if it is a zip."
+                _last_obs["text"] = out
+                return out
             except Exception as e:  # noqa: BLE001
-                return f"Error: download failed: {type(e).__name__}: {e}"
+                msg = f"Error: download failed: {type(e).__name__}: {e}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def unzip_file(zip_path: str, dest_dir: str = "") -> str:
@@ -3334,12 +3379,18 @@ def run_agent_chat(cfg):
                 more = f" …(+{len(names) - 15} more)" if len(names) > 15 else ""
                 if cached:
                     _emit({"type": "step", "text": "Already unzipped — reusing extracted files"})
-                    return (f"Already unzipped earlier — {len(names)} files at {d}. "
-                            f"Files: {preview}{more}. Use list_dir/read_text_file or rag_index on it.")
+                    out = (f"Already unzipped earlier — {len(names)} files at {d}. "
+                           f"Files: {preview}{more}. Use list_dir/read_text_file or rag_index on it.")
+                    _last_obs["text"] = out
+                    return out
                 _emit({"type": "step", "text": "Unzipping…"})
-                return f"Unzipped {len(names)} files to {d}. Files: {preview}{more}. Next: rag_index(path='{d}', source_url=<the original url>)."
+                out = f"Unzipped {len(names)} files to {d}. Files: {preview}{more}. Next: rag_index(path='{d}', source_url=<the original url>)."
+                _last_obs["text"] = out
+                return out
             except Exception as e:  # noqa: BLE001
-                return f"Error: unzip failed: {type(e).__name__}: {e}"
+                msg = f"Error: unzip failed: {type(e).__name__}: {e}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def list_dir(path: str) -> str:
@@ -3352,7 +3403,9 @@ def run_agent_chat(cfg):
                 import os
                 root = _rag_read_allowed((path or ".").strip())
                 if os.path.isfile(root):
-                    return f"{root} is a file ({os.path.getsize(root)} bytes)."
+                    out = f"{root} is a file ({os.path.getsize(root)} bytes)."
+                    _last_obs["text"] = out
+                    return out
                 entries = []
                 for dirpath, dirnames, filenames in os.walk(root):
                     dirnames[:] = [d for d in dirnames if d not in _RAG_SKIP_DIRS]
@@ -3367,9 +3420,13 @@ def run_agent_chat(cfg):
                         break
                 entries.sort()
                 more = " …(truncated)" if len(entries) >= 300 else ""
-                return f"{len(entries)} files under {root}:\n" + "\n".join(entries) + more
+                out = f"{len(entries)} files under {root}:\n" + "\n".join(entries) + more
+                _last_obs["text"] = out
+                return out
             except Exception as e:  # noqa: BLE001
-                return f"Error: list_dir failed: {type(e).__name__}: {e}"
+                msg = f"Error: list_dir failed: {type(e).__name__}: {e}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def read_text_file(path: str, max_chars: int = 20000) -> str:
@@ -3383,14 +3440,22 @@ def run_agent_chat(cfg):
                 import os
                 rp = _rag_read_allowed((path or "").strip())
                 if not os.path.isfile(rp):
-                    return f"Error: not a file: {path}"
+                    msg = f"Error: not a file: {path}"
+                    _last_obs["text"] = msg
+                    return msg
                 if os.path.getsize(rp) > 5 * 1024 * 1024:
-                    return "Error: file too large to read (> 5 MB)."
+                    msg = "Error: file too large to read (> 5 MB)."
+                    _last_obs["text"] = msg
+                    return msg
                 with open(rp, "r", encoding="utf-8", errors="replace") as fh:
                     data = fh.read(max(500, min(int(max_chars or 20000), 100000)))
-                return data or "(empty file)"
+                out = data or "(empty file)"
+                _last_obs["text"] = out
+                return out
             except Exception as e:  # noqa: BLE001
-                return f"Error: read_text_file failed: {type(e).__name__}: {e}"
+                msg = f"Error: read_text_file failed: {type(e).__name__}: {e}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def rag_index(path: str, source_url: str) -> str:
@@ -3401,7 +3466,9 @@ def run_agent_chat(cfg):
                 source_url: the original URL the user gave — used as the knowledge-base key.
             """
             if not _RAG_AVAILABLE:
-                return "Error: RAG is not configured (enable it + add AWS credentials in Settings)."
+                msg = "Error: RAG is not configured (enable it + add AWS credentials in Settings)."
+                _last_obs["text"] = msg
+                return msg
             _emit({"type": "step", "text": f"RAG source → {source_url}"})
             _emit({"type": "step", "text": "Indexing files for RAG…"})
             try:
@@ -3417,7 +3484,9 @@ def run_agent_chat(cfg):
                     files += 1
                     records.extend(_rag_chunk_text(text, rel, ext))
                 if not records:
-                    return "No indexable text files found at that path."
+                    msg = "No indexable text files found at that path."
+                    _last_obs["text"] = msg
+                    return msg
                 for i in range(0, len(records), 64):
                     batch = records[i:i + 64]
                     vecs = _embed(rag_embed_base, rag_embed_model, [r["text"] for r in batch])
@@ -3438,10 +3507,14 @@ def run_agent_chat(cfg):
                 client.put_object(Bucket=bucket, Key=f"{base}/manifest.json",
                                   Body=json.dumps(manifest).encode("utf-8"),
                                   ContentType="application/json")
-                return (f"Indexed {files} files into {len(records)} chunks for {source_url}. "
-                        f"Use rag_search(source_url='{source_url}', query=...) to retrieve, then answer the user.")
+                out = (f"Indexed {files} files into {len(records)} chunks for {source_url}. "
+                       f"Use rag_search(source_url='{source_url}', query=...) to retrieve, then answer the user.")
+                _last_obs["text"] = out
+                return out
             except Exception as e:  # noqa: BLE001
-                return f"Error: indexing failed: {type(e).__name__}: {e}"
+                msg = f"Error: indexing failed: {type(e).__name__}: {e}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def rag_add(source_url: str, text: str) -> str:
@@ -3452,9 +3525,13 @@ def run_agent_chat(cfg):
                 text: the new information to embed and store.
             """
             if not _RAG_AVAILABLE:
-                return "Error: RAG is not configured."
+                msg = "Error: RAG is not configured."
+                _last_obs["text"] = msg
+                return msg
             if not (text or "").strip():
-                return "Error: no text to add."
+                msg = "Error: no text to add."
+                _last_obs["text"] = msg
+                return msg
             _emit({"type": "step", "text": f"RAG source → {source_url}"})
             _emit({"type": "step", "text": "Adding info to RAG…"})
             try:
@@ -3468,9 +3545,13 @@ def run_agent_chat(cfg):
                 shard = f"{base}/chunks-add-{int(_t.time())}.jsonl"
                 body = "\n".join(json.dumps(r, ensure_ascii=False) for r in records).encode("utf-8")
                 client.put_object(Bucket=bucket, Key=shard, Body=body, ContentType="application/x-ndjson")
-                return f"Added {len(records)} chunk(s) to the knowledge base for {source_url}."
+                out = f"Added {len(records)} chunk(s) to the knowledge base for {source_url}."
+                _last_obs["text"] = out
+                return out
             except Exception as e:  # noqa: BLE001
-                return f"Error: rag_add failed: {type(e).__name__}: {e}"
+                msg = f"Error: rag_add failed: {type(e).__name__}: {e}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def rag_search(source_url: str, query: str, k: int = 0) -> str:
@@ -3482,7 +3563,9 @@ def run_agent_chat(cfg):
                 k: number of chunks to return (0 = configured default).
             """
             if not _RAG_AVAILABLE:
-                return "Error: RAG is not configured."
+                msg = "Error: RAG is not configured."
+                _last_obs["text"] = msg
+                return msg
             _emit({"type": "step", "text": f"RAG source → {source_url}"})
             _emit({"type": "step", "text": f"Searching RAG → {query[:60]}"})
             try:
@@ -3490,7 +3573,9 @@ def run_agent_chat(cfg):
                 base = _rag_prefix_for(source_url, prefix)
                 chunks = _rag_load_chunks(client, bucket, base)
                 if not chunks:
-                    return f"No knowledge base found for {source_url}. Run rag_index first."
+                    msg = f"No knowledge base found for {source_url}. Run rag_index first."
+                    _last_obs["text"] = msg
+                    return msg
                 qvec = _embed(rag_embed_base, rag_embed_model, [query])[0]
                 scored = sorted(
                     ((_cosine(qvec, c.get("embedding") or []), c) for c in chunks),
@@ -3499,9 +3584,13 @@ def run_agent_chat(cfg):
                 topk = scored[: (k if k and k > 0 else rag_top_k)]
                 parts = [f"[{c.get('file', '?')}] (score {score:.2f})\n{c.get('text', '')}"
                          for score, c in topk]
-                return "\n\n---\n\n".join(parts) if parts else "No matches."
+                out = "\n\n---\n\n".join(parts) if parts else "No matches."
+                _last_obs["text"] = out
+                return out
             except Exception as e:  # noqa: BLE001
-                return f"Error: rag_search failed: {type(e).__name__}: {e}"
+                msg = f"Error: rag_search failed: {type(e).__name__}: {e}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def grep_repo(pattern: str, path: str = "", glob: str = "") -> str:
@@ -3542,11 +3631,17 @@ def run_agent_chat(cfg):
                         break
                 _emit({"type": "step", "text": f"Searching code → {pattern[:60]} ({len(hits)} hits)"})
                 if not hits:
-                    return f"No matches for {pattern!r} under {root}."
+                    msg = f"No matches for {pattern!r} under {root}."
+                    _last_obs["text"] = msg
+                    return msg
                 more = "\n…(capped at 100 hits)" if len(hits) >= 100 else ""
-                return f"Matches under {root}:\n" + "\n".join(hits) + more
+                out = f"Matches under {root}:\n" + "\n".join(hits) + more
+                _last_obs["text"] = out
+                return out
             except Exception as e:  # noqa: BLE001
-                return f"Error: grep_repo failed: {type(e).__name__}: {e}"
+                msg = f"Error: grep_repo failed: {type(e).__name__}: {e}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def read_file_lines(path: str, start_line: int = 1, end_line: int = 0) -> str:
@@ -3565,9 +3660,13 @@ def run_agent_chat(cfg):
                 e = int(end_line or 0) or len(lines)
                 e = min(e, len(lines), s + 399)
                 body = "".join(f"{i}: {lines[i - 1]}" for i in range(s, e + 1))
-                return f"{rp} (lines {s}-{e} of {len(lines)}):\n{body}"
+                out = f"{rp} (lines {s}-{e} of {len(lines)}):\n{body}"
+                _last_obs["text"] = out
+                return out
             except Exception as ex:  # noqa: BLE001
-                return f"Error: read_file_lines failed: {type(ex).__name__}: {ex}"
+                msg = f"Error: read_file_lines failed: {type(ex).__name__}: {ex}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def edit_lines(path: str, start_line: int, end_line: int, new_content: str) -> str:
@@ -3583,14 +3682,18 @@ def run_agent_chat(cfg):
                 rp = _ws_write_allowed((path or "").strip())
                 import os
                 if not os.path.isfile(rp):
-                    return f"Error: not a file: {path}"
+                    msg = f"Error: not a file: {path}"
+                    _last_obs["text"] = msg
+                    return msg
                 backup = _ws_snapshot(rp)
                 with open(rp, "r", encoding="utf-8", errors="replace") as fh:
                     lines = fh.readlines()
                 s, e = int(start_line), int(end_line)
                 if not (1 <= s <= e <= len(lines)):
-                    return (f"Error: line range {s}-{e} is out of bounds "
-                            f"(file has {len(lines)} lines). Re-check with read_file_lines.")
+                    msg = (f"Error: line range {s}-{e} is out of bounds "
+                           f"(file has {len(lines)} lines). Re-check with read_file_lines.")
+                    _last_obs["text"] = msg
+                    return msg
                 new_lines = new_content.splitlines(keepends=True)
                 if new_lines and not new_lines[-1].endswith("\n"):
                     new_lines[-1] += "\n"
@@ -3601,10 +3704,14 @@ def run_agent_chat(cfg):
                 _emit({"type": "step", "text": f"Edited {os.path.basename(rp)} lines {s}-{e}"})
                 shown = "".join(f"{i}: {lines[i - 1]}" for i in
                                 range(max(1, s - 2), min(len(lines), s + len(new_lines) + 1) + 1))
-                return (f"Replaced lines {s}-{e} of {rp} with {len(new_lines)} line(s). "
-                        f"Backup saved. Updated region:\n{shown}")
+                out = (f"Replaced lines {s}-{e} of {rp} with {len(new_lines)} line(s). "
+                       f"Backup saved. Updated region:\n{shown}")
+                _last_obs["text"] = out
+                return out
             except Exception as ex:  # noqa: BLE001
-                return f"Error: edit_lines failed: {type(ex).__name__}: {ex}"
+                msg = f"Error: edit_lines failed: {type(ex).__name__}: {ex}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def edit_file(path: str, old_string: str, new_string: str) -> str:
@@ -3619,23 +3726,33 @@ def run_agent_chat(cfg):
                 rp = _ws_write_allowed((path or "").strip())
                 import os
                 if not os.path.isfile(rp):
-                    return f"Error: not a file: {path}"
+                    msg = f"Error: not a file: {path}"
+                    _last_obs["text"] = msg
+                    return msg
                 with open(rp, "r", encoding="utf-8", errors="replace") as fh:
                     text = fh.read()
                 n = text.count(old_string)
                 if n == 0:
-                    return ("Error: old_string not found — it must match EXACTLY "
-                            "(check whitespace with read_file_lines, or use edit_lines).")
+                    msg = ("Error: old_string not found — it must match EXACTLY "
+                           "(check whitespace with read_file_lines, or use edit_lines).")
+                    _last_obs["text"] = msg
+                    return msg
                 if n > 1:
-                    return f"Error: old_string occurs {n} times — add surrounding context to make it unique, or use edit_lines."
+                    msg = f"Error: old_string occurs {n} times — add surrounding context to make it unique, or use edit_lines."
+                    _last_obs["text"] = msg
+                    return msg
                 backup = _ws_snapshot(rp)
                 with open(rp, "w", encoding="utf-8") as fh:
                     fh.write(text.replace(old_string, new_string, 1))
                 _ws_record_change("edit", rp, backup)
                 _emit({"type": "step", "text": f"Edited {os.path.basename(rp)}"})
-                return f"Replaced 1 occurrence in {rp}. Backup saved."
+                out = f"Replaced 1 occurrence in {rp}. Backup saved."
+                _last_obs["text"] = out
+                return out
             except Exception as ex:  # noqa: BLE001
-                return f"Error: edit_file failed: {type(ex).__name__}: {ex}"
+                msg = f"Error: edit_file failed: {type(ex).__name__}: {ex}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def create_file(path: str, content: str) -> str:
@@ -3649,15 +3766,21 @@ def run_agent_chat(cfg):
                 rp = _ws_write_allowed((path or "").strip())
                 import os
                 if os.path.exists(rp):
-                    return f"Error: {path} already exists — use edit_lines/edit_file to change it."
+                    msg = f"Error: {path} already exists — use edit_lines/edit_file to change it."
+                    _last_obs["text"] = msg
+                    return msg
                 os.makedirs(os.path.dirname(rp) or ".", exist_ok=True)
                 with open(rp, "w", encoding="utf-8") as fh:
                     fh.write(content)
                 _ws_record_change("create", rp, None)
                 _emit({"type": "step", "text": f"Created {os.path.basename(rp)}"})
-                return f"Created {rp} ({len(content)} chars)."
+                out = f"Created {rp} ({len(content)} chars)."
+                _last_obs["text"] = out
+                return out
             except Exception as ex:  # noqa: BLE001
-                return f"Error: create_file failed: {type(ex).__name__}: {ex}"
+                msg = f"Error: create_file failed: {type(ex).__name__}: {ex}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def run_command(command: str, workdir: str = "", timeout_seconds: int = 180) -> str:
@@ -3675,14 +3798,20 @@ def run_agent_chat(cfg):
                 wd = _rag_read_allowed((workdir or "").strip() or (_WS_ROOTS[0]["path"] if _WS_ROOTS else "."))
                 w = _ws_for_path(wd)
                 if w is None or not w.get("allowRun"):
-                    return ("Error: running commands is not enabled for this workspace. "
-                            "Re-register it with: gonext-local-worker workspace add <path> --allow-run")
+                    msg = ("Error: running commands is not enabled for this workspace. "
+                           "Re-register it with: gonext-local-worker workspace add <path> --allow-run")
+                    _last_obs["text"] = msg
+                    return msg
                 argv = shlex.split(command or "")
                 if not argv:
-                    return "Error: empty command."
+                    msg = "Error: empty command."
+                    _last_obs["text"] = msg
+                    return msg
                 if argv[0] not in _WS_RUN_ALLOWED:
-                    return (f"Error: '{argv[0]}' is not an allowed runner. Allowed: "
-                            + ", ".join(sorted(_WS_RUN_ALLOWED)))
+                    msg = (f"Error: '{argv[0]}' is not an allowed runner. Allowed: "
+                           + ", ".join(sorted(_WS_RUN_ALLOWED)))
+                    _last_obs["text"] = msg
+                    return msg
                 _emit({"type": "step", "text": f"Running → {command[:70]}"})
                 t = max(5, min(int(timeout_seconds or 180), 600))
                 # Scrubbed env: repo test scripts must never see worker secrets.
@@ -3693,16 +3822,23 @@ def run_agent_chat(cfg):
                 out = _ws_distill_output(proc.stdout or "")
                 status = "PASSED (exit 0)" if proc.returncode == 0 else f"FAILED (exit {proc.returncode})"
                 _emit({"type": "step", "text": f"Command {status.split()[0].lower()} → {command[:50]}"})
-                return f"{status}\n{out}" if out.strip() else status
+                result = f"{status}\n{out}" if out.strip() else status
+                _last_obs["text"] = result
+                return result
             except subprocess.TimeoutExpired:
-                return f"Error: command timed out after {timeout_seconds}s."
+                msg = f"Error: command timed out after {timeout_seconds}s."
+                _last_obs["text"] = msg
+                return msg
             except Exception as ex:  # noqa: BLE001
-                return f"Error: run_command failed: {type(ex).__name__}: {ex}"
+                msg = f"Error: run_command failed: {type(ex).__name__}: {ex}"
+                _last_obs["text"] = msg
+                return msg
 
         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:
@@ -3717,6 +3853,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,

package/package.json

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