@tiens.nguyen/gonext-local-worker 1.0.181 → 1.0.183

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,34 @@ 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):
+                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}]"
 
 
 def _synthesize_document(gathered: list, task: str, base_url: str, api_key: str,
@@ -1903,8 +2022,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 +2042,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 +3607,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.181",
+  "version": "1.0.183",
   "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",