@tiens.nguyen/gonext-local-worker 1.0.180 → 1.0.182

package/gonext-repl.mjs

@@ -19,7 +19,7 @@
  * Commands: /exit  /revert [runId]  /help      Ctrl-C stops following the current run.
  */
 import { readFile, mkdir, writeFile } from "node:fs/promises";
-import { existsSync, statSync } from "node:fs";
+import { existsSync, statSync, readFileSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { dirname, join, resolve, basename } from "node:path";
@@ -38,11 +38,26 @@ const red = (s) => `\x1b[31m${s}\x1b[0m`;
 const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
 const CLEAR_LINE = "\r\x1b[K"; // carriage-return + erase-to-end-of-line
 
-// The worker's playful "still thinking" heartbeat lines look like "Caffeinating… (90s)"
-// (a word/phrase, an ellipsis, then the elapsed seconds). They're ephemeral progress —
-// we render them on a single in-place status line (yellow) that the next one overwrites
-// and that gets erased once real output arrives, so they never pile up in the scrollback.
+// The worker's "still thinking" heartbeat lines look like "Caffeinating… (90s)" — we
+// SWALLOW them from the terminal (the local ticker below drives progress instead), and
+// also drop the worker's ~~~ stream fences (they only matter to the web renderer).
 const isHeartbeatLine = (line) => /…\s?\(\d+s\)\s*$/.test(line);
+const isFenceLine = (line) => line.trim() === "~~~";
+
+// Playful words for the local "thinking…" ticker, reused verbatim from the worker's
+// thinking_words.txt sibling (falls back to a tiny built-in list if it's missing).
+const THINKING_WORDS = (() => {
+  try {
+    return readFileSync(join(DIR, "thinking_words.txt"), "utf8")
+      .split("\n")
+      .map((l) => l.trim())
+      .filter((l) => l && !l.startsWith("#"));
+  } catch {
+    return ["Thinking", "Percolating", "Cogitating", "Noodling", "Ruminating"];
+  }
+})();
+const pickWord = () =>
+  THINKING_WORDS[Math.floor(Math.random() * THINKING_WORDS.length)] || "Thinking";
 
 // ---------- flags ----------
 const argv = process.argv.slice(2);
@@ -227,38 +242,74 @@ async function runAgentTurn(history) {
   followAborted = false;
   const startedAt = Date.now();
   let shownChars = 0;
-  let carry = ""; // trailing partial line held until its newline arrives
-  let statusShown = false; // a transient heartbeat status line is on screen
+  let carry = ""; // trailing partial content line held until its newline arrives
+  let statusShown = false; // a transient status line is currently on screen
   let warnedPending = false;
+  let jobRunning = false; // only tick "thinking…" once the worker has claimed the job
+
+  // --- Live "thinking…" ticker ---------------------------------------------------
+  // Between visible tokens (prompt-eval / awaiting the first token) we show ONE in-place
+  // status line that counts UP every second — "Percolating thinking… (7s)" — so the wait
+  // feels alive. When output resumes we stamp a dim "✔ completed thought (Ns)" and let the
+  // tokens stream. The worker's own 45s heartbeat lines (and ~~~ fences) are swallowed;
+  // this local 1-second ticker owns the progress display.
+  const QUIET_MS = 700; // stream idle this long ⇒ we're waiting on the model
+  let lastContentAt = Date.now();
+  let thinking = false;
+  let thinkingSince = 0;
+  let thinkWord = pickWord();
+  const thinkSecs = () => Math.max(1, Math.round((Date.now() - thinkingSince) / 1000));
 
-  // Erase the transient heartbeat status line (if any) before printing real output.
   const clearStatus = () => {
-    if (statusShown) {
-      process.stdout.write(CLEAR_LINE);
+    if (statusShown) { process.stdout.write(CLEAR_LINE); statusShown = false; }
+  };
+
+  const tick = () => {
+    if (!following || followAborted || !jobRunning) return;
+    if (Date.now() - lastContentAt < QUIET_MS) return; // tokens still flowing
+    // Count from when the stream actually went quiet, so the seconds reflect the true
+    // wait for the first token (1s, 2s, 3s…) rather than from the first tick.
+    if (!thinking) { thinking = true; thinkingSince = lastContentAt; thinkWord = pickWord(); }
+    const secs = thinkSecs();
+    if (secs % 12 === 0) thinkWord = pickWord(); // rotate the word on long waits
+    process.stdout.write(CLEAR_LINE + yellow(`${thinkWord} thinking… (${secs}s)`));
+    statusShown = true;
+  };
+  const ticker = setInterval(tick, 1000);
+
+  // Close out a "thinking…" phase right before real output prints.
+  const onContent = () => {
+    if (thinking) {
+      process.stdout.write(CLEAR_LINE + dim(`✔ completed thought (${thinkSecs()}s)`) + "\n");
+      thinking = false;
       statusShown = false;
+    } else {
+      clearStatus();
     }
+    lastContentAt = Date.now();
   };
-  // Feed newly-arrived stream text through the line splitter: heartbeat lines become an
-  // in-place status line (never committed to scrollback); everything else commits dim.
+
+  // Split newly-arrived text into lines: heartbeats + ~~~ fences are swallowed (the ticker
+  // shows progress); blank lines keep spacing; everything else commits dim to scrollback.
   const consume = (chunk) => {
     carry += stripThinkTags(chunk);
     let nl;
     while ((nl = carry.indexOf("\n")) >= 0) {
       const line = carry.slice(0, nl);
       carry = carry.slice(nl + 1);
-      if (isHeartbeatLine(line)) {
-        // Overwrite the previous heartbeat in place — no newline, so it stays transient.
-        process.stdout.write(CLEAR_LINE + yellow(line));
-        statusShown = true;
-      } else if (line.trim() === "") {
-        // Swallow the blank line the worker appends after a heartbeat; keep real spacing.
-        if (!statusShown) process.stdout.write("\n");
-      } else {
-        clearStatus();
-        process.stdout.write(dim(line) + "\n");
+      if (isHeartbeatLine(line) || isFenceLine(line)) continue; // swallow
+      if (line.trim() === "") {
+        if (!thinking && !statusShown) process.stdout.write("\n");
+        continue;
       }
+      onContent();
+      process.stdout.write(dim(line) + "\n");
     }
+    // A non-empty remainder is a partial CONTENT line (heartbeats always arrive whole with
+    // a newline), so tokens are actively flowing — keep the ticker asleep.
+    if (carry.trim() !== "") lastContentAt = Date.now();
   };
+
   try {
     for (;;) {
       if (followAborted) {
@@ -273,10 +324,11 @@ async function runAgentTurn(history) {
       });
       const job = await jr.json().catch(() => ({}));
       if (!jr.ok) throw new Error(job?.error || `job poll failed (HTTP ${jr.status})`);
+      jobRunning = job.jobStatus === "running";
       const text = typeof job.resultText === "string" ? job.resultText : "";
       if (job.jobStatus === "completed") {
-        // Drop the transient heartbeat line and any partial reasoning tail; the bright
-        // answer prints right after via the caller.
+        // Drop the transient status line and any partial reasoning tail; the bright answer
+        // prints right after via the caller.
         clearStatus();
         return answerFrom(text);
       }
@@ -302,6 +354,7 @@ async function runAgentTurn(history) {
       await sleep(700);
     }
   } finally {
+    clearInterval(ticker);
     clearStatus();
     following = false;
   }

package/gonext_agent_chat.py

@@ -558,6 +558,96 @@ _AGENT_KEYWORDS = re.compile(
     re.IGNORECASE,
 )
 
+# Pure conversational openers/closers that never need a tool — a greeting, a thank-you, a
+# "who are you". Matching the WHOLE message (anchored) means "hi, fetch https://…" won't
+# match. These skip BOTH the model router call AND the heavy tool preamble → an instant
+# small-prompt plain reply, instead of a multi-minute prompt-eval on the coding model.
+_TRIVIAL_CHAT = re.compile(
+    r"^\s*(?:"
+    r"h(?:i+|ello+|ey+|iya|owdy)|yo|sup|wass?up|"
+    r"good\s*(?:morning|afternoon|evening|night|day)|greetings|"
+    r"thanks?(?:\s*you)?|thank\s*you|thx|ty|cheers|much\s*appreciated|"
+    r"bye+|goodbye|see\s*(?:ya|you)|cya|later|good\s*night|"
+    r"ok(?:ay)?|k|cool|nice|great|awesome|perfect|sounds\s*good|got\s*it|"
+    r"how\s*(?:are|r)\s*(?:you|u|ya)(?:\s*doing)?|how'?s\s*it\s*going|what'?s\s*up|"
+    r"who\s*(?:are|r)\s*(?:you|u)|what\s*(?:can|do)\s*you\s*do|what\s*are\s*you|"
+    r"test(?:ing)?|ping"
+    r")"
+    r"(?:\s+(?:there|everyone|all|bot|assistant|gonext|man|dude|buddy))?"
+    r"[\s!.?,'\"]*$",
+    re.IGNORECASE,
+)
+
+
+def _is_trivial_chat(text: str) -> bool:
+    """True for a short, pure-conversational message (greeting, thanks, 'who are you')
+    that clearly needs no tools — so we can answer directly and fast."""
+    t = (text or "").strip()
+    if not t or len(t) > 60:
+        return False
+    return bool(_TRIVIAL_CHAT.match(t))
+
+
+# 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
+# time every step on a slow coding model. This keeps everything FUNCTIONALLY required —
+# the Thought→Code→Observation loop, the code-blob format + closing tag, the {{tools}}
+# rendering (so exact signatures survive), authorized imports, custom_instructions — plus
+# ONE short worked example, and trims the rest. Jinja vars must match the stock template.
+_COMPACT_CODE_SYSTEM_PROMPT = (
+    "You are an expert assistant who solves the task by writing Python code that calls "
+    "tools. You work in a loop of Thought → Code → Observation.\n\n"
+    "At EACH step:\n"
+    "- Write one 'Thought:' line: what you'll do and which tool.\n"
+    "- Then a code block that OPENS with {{code_block_opening_tag}} and CLOSES with "
+    "{{code_block_closing_tag}}, containing simple Python that calls ONE tool and print()s "
+    "anything you need next.\n"
+    "- You then receive that tool's 'Observation:'. Use it to decide the next step. When "
+    "you have the answer, call final_answer(answer) inside a code block.\n\n"
+    "Example:\n"
+    "Thought: I'll read the page the user gave.\n"
+    "{{code_block_opening_tag}}\n"
+    'text = fetch_url("https://example.com")\n'
+    "print(text)\n"
+    "{{code_block_closing_tag}}\n"
+    "Observation: \"Example Domain … \"\n"
+    "Thought: I have the content, so I'll answer.\n"
+    "{{code_block_opening_tag}}\n"
+    'final_answer("The page is Example Domain, a placeholder site.")\n'
+    "{{code_block_closing_tag}}\n\n"
+    "You have access to these tools — call them as plain Python functions with the exact "
+    "signatures shown:\n"
+    "{{code_block_opening_tag}}\n"
+    "{%- for tool in tools.values() %}\n"
+    "{{ tool.to_code_prompt() }}\n"
+    "{% endfor %}\n"
+    "{{code_block_closing_tag}}\n"
+    "{%- if managed_agents and managed_agents.values() | list %}\n"
+    "You can also delegate to team members by calling them like a tool with a 'task' "
+    "string argument:\n"
+    "{{code_block_opening_tag}}\n"
+    "{%- for agent in managed_agents.values() %}\n"
+    "def {{ agent.name }}(task: str) -> str:\n"
+    '    """{{ agent.description }}"""\n'
+    "{% endfor %}\n"
+    "{{code_block_closing_tag}}\n"
+    "{%- endif %}\n\n"
+    "Rules:\n"
+    "1. ALWAYS write a 'Thought:' line, then a code block opening with "
+    "{{code_block_opening_tag}} and closing with {{code_block_closing_tag}} — or you fail.\n"
+    "2. Pass tool arguments directly: calculate(expression=\"2+2\"), NOT as a dict.\n"
+    "3. Use only variables you have defined; state persists between steps.\n"
+    "4. Never re-run a tool call with the exact same parameters.\n"
+    "5. Don't name a variable after a tool (e.g. 'final_answer').\n"
+    "6. Imports are allowed ONLY from: {{authorized_imports}}\n"
+    "7. Don't give up — you are in charge of solving the task.\n"
+    "{%- if custom_instructions %}\n"
+    "{{custom_instructions}}\n"
+    "{%- endif %}\n\n"
+    "Now Begin!"
+)
+
 
 def _route(task_text: str, base_url: str, api_key: str, model_id: str) -> bool:
     """Decide if the task needs the HTTP agent (True) or a plain chat reply (False).
@@ -603,6 +693,16 @@ def _route(task_text: str, base_url: str, api_key: str, model_id: str) -> bool:
         _emit({"type": "step", "text": "→ Agent mode (needs tools)" if is_agent else "→ Chat reply"})
         return is_agent
     except Exception as e:  # noqa: BLE001
+        # Classifier unreachable (e.g. the local chat server is down). No agent keyword
+        # matched above, so a SHORT message is almost certainly plain conversation — send
+        # it to a fast small-prompt reply instead of the heavy tool loop (which would
+        # prompt-eval a huge preamble for minutes). Only longer/ambiguous tasks fall back
+        # to the agent.
+        short = len((task_text or "").split()) <= 12
+        if short:
+            _log(f"router error: {e} — short message, defaulting to plain chat reply")
+            _emit({"type": "step", "text": "→ Chat reply"})
+            return False
         _log(f"router error: {e} — defaulting to agent")
         _emit({"type": "step", "text": "→ Agent mode (needs tools)"})
         return True
@@ -641,8 +741,12 @@ def _summarize_result(task_text: str, agent_output: str,
         return agent_output
 
 
-def _plain_reply(messages: list, base_url: str, api_key: str, model_id: str) -> str:
-    """Plain chat completion using the full conversation history."""
+def _plain_reply(messages: list, base_url: str, api_key: str, model_id: str,
+                 fallback_base_url: str = "", fallback_model_id: str = "") -> str:
+    """Plain chat completion using the full conversation history — a SMALL prompt (no tool
+    preamble), so it returns fast. 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."""
     _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:
@@ -655,19 +759,33 @@ def _plain_reply(messages: list, base_url: str, api_key: str, model_id: str) ->
             if not content:
                 continue
         chat_messages.append({"role": role, "content": content})
-    try:
-        from openai import OpenAI
-        client = OpenAI(base_url=base_url, api_key=api_key or "local",
-                        max_retries=0, timeout=60)
-        resp = client.chat.completions.create(
-            model=model_id,
-            messages=chat_messages,
-            temperature=0.7,
-            max_tokens=512,
-        )
-        return (resp.choices[0].message.content or "").strip()
-    except Exception as e:  # noqa: BLE001
-        return f"[Error: {e}]"
+
+    targets = [(base_url, model_id)]
+    if fallback_base_url and fallback_model_id and (
+        fallback_base_url.rstrip("/") != (base_url or "").rstrip("/")
+        or fallback_model_id != model_id
+    ):
+        targets.append((fallback_base_url, fallback_model_id))
+
+    last_err = None
+    for i, (b, mid) in enumerate(targets):
+        try:
+            from openai import OpenAI
+            client = OpenAI(base_url=b, api_key=api_key or "local",
+                            max_retries=0, timeout=60)
+            resp = client.chat.completions.create(
+                model=mid,
+                messages=chat_messages,
+                temperature=0.7,
+                max_tokens=512,
+            )
+            return (resp.choices[0].message.content or "").strip()
+        except Exception as e:  # noqa: BLE001
+            last_err = e
+            if i + 1 < len(targets):
+                _log(f"plain reply: primary model failed ({e}); retrying on fallback "
+                     f"{mid} @ {b}")
+    return f"[Error: {last_err}]"
 
 
 def _synthesize_document(gathered: list, task: str, base_url: str, api_key: str,
@@ -1903,8 +2021,16 @@ def run_agent_chat(cfg):
         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)
+    # Route: does this task need HTTP tool use? A trivial greeting/thank-you/"who are you"
+    # is caught LOCALLY (no model classifier call, no tool preamble) → straight to a fast
+    # small-prompt reply. Otherwise ask the model classifier.
+    if _is_trivial_chat(latest_user_text) and not _AGENT_KEYWORDS.search(latest_user_text or ""):
+        _log("router → NO (trivial greeting/smalltalk — local fast-path, no tool preamble)")
+        _emit({"type": "step", "text": "Routing your request…"})
+        _emit({"type": "step", "text": "→ Chat reply"})
+        needs_agent = False
+    else:
+        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():
@@ -1915,7 +2041,9 @@ def run_agent_chat(cfg):
     if not needs_agent:
         _log("router: plain chat (no HTTP needed)")
         _emit({"type": "step", "text": "Composing a reply…"})
-        answer = _plain_reply(messages, agent_base_url, agent_api_key, agent_model_id)
+        # Small prompt → fast. Fall back to the coding model if the chat model is down.
+        answer = _plain_reply(messages, agent_base_url, agent_api_key, agent_model_id,
+                              coding_base_url, coding_model_id)
         _log(f"plain reply: {len(answer)} chars")
         _emit({"type": "final", "text": answer})
         return
@@ -3478,6 +3606,21 @@ def run_agent_chat(cfg):
             agent_kwargs["additional_authorized_imports"] = [
                 "json", "base64", "urllib", "urllib.request", "urllib.error"
             ]
+            # Trim smolagents' ~6k-char generic few-shot examples from the system prompt
+            # (they dominate prompt-eval on a slow coding model) while keeping the tool
+            # rendering + format rules intact. Load the stock templates and swap only the
+            # system_prompt; fall back to the default on any error.
+            try:
+                import yaml as _yaml
+                import os as _os
+                import smolagents as _sm
+                _tpl = _yaml.safe_load(open(_os.path.join(
+                    _os.path.dirname(_sm.__file__), "prompts", "code_agent.yaml")))
+                _tpl["system_prompt"] = _COMPACT_CODE_SYSTEM_PROMPT
+                agent_kwargs["prompt_templates"] = _tpl
+                _log("using compact CodeAgent system prompt (trimmed few-shot examples)")
+            except Exception as _e:  # noqa: BLE001
+                _log(f"compact system prompt unavailable ({_e}); using smolagents default")
         agent = _ToolAgent(**agent_kwargs)
         with contextlib.redirect_stdout(sys.stderr):
             result = agent.run(task_with_hint)

package/package.json

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