@tiens.nguyen/gonext-local-worker 1.0.89 → 1.0.91

package/gonext_agent_chat.py

@@ -215,8 +215,8 @@ def _summarise_step(step_log):
         else:
             parts.append(f"→ Error: {err[:120]}")
 
-    label = f"Step {step_num}: " if step_num is not None else ""
-    return label + (" | ".join(parts) if parts else "thinking…")
+    # No numeric "Step N:" prefix — show only the semantic action.
+    return (" | ".join(parts) if parts else "thinking…")
 
 
 # Keywords that strongly indicate the user wants to make an HTTP/network request,
@@ -241,9 +241,13 @@ def _route(task_text: str, base_url: str, api_key: str, model_id: str) -> bool:
     Fast-path: if the user explicitly mentions network/request keywords → agent.
     Otherwise: ask the model to classify.
     """
+    # Show the routing stage in the web Thinking panel.
+    _emit({"type": "step", "text": "Routing your request…"})
+
     # Fast-path: explicit HTTP/network intent overrides the model classifier.
     if _AGENT_KEYWORDS.search(task_text):
         _log(f"router → YES (keyword match)")
+        _emit({"type": "step", "text": "→ Agent mode (needs tools)"})
         return True
 
     try:
@@ -271,9 +275,12 @@ def _route(task_text: str, base_url: str, api_key: str, model_id: str) -> bool:
         )
         answer = (resp.choices[0].message.content or "").strip().upper()
         _log(f"router → {answer!r} (model)")
-        return answer.startswith("Y")
+        is_agent = answer.startswith("Y")
+        _emit({"type": "step", "text": "→ Agent mode (needs tools)" if is_agent else "→ Chat reply"})
+        return is_agent
     except Exception as e:  # noqa: BLE001
         _log(f"router error: {e} — defaulting to agent")
+        _emit({"type": "step", "text": "→ Agent mode (needs tools)"})
         return True
 
 
@@ -339,6 +346,18 @@ def _plain_reply(messages: list, base_url: str, api_key: str, model_id: str) ->
         return f"[Error: {e}]"
 
 
+def _strip_tool_tags(text: str) -> str:
+    """Remove the internal hint tags we append to tool output (e.g. '[SUCCESS …]',
+    '[NOTE: …]', 'Note: This URL failed …') so they never leak into the user reply."""
+    out = []
+    for ln in (text or "").splitlines():
+        s = ln.strip()
+        if s.startswith("[SUCCESS") or s.startswith("[NOTE:") or s.startswith("Note: This URL failed"):
+            continue
+        out.append(ln)
+    return "\n".join(out).strip()
+
+
 def run_agent_chat(cfg):
     try:
         from smolagents import CodeAgent, OpenAIServerModel, tool
@@ -373,7 +392,11 @@ def run_agent_chat(cfg):
     else:
         coding_base_url = agent_base_url
         coding_model_id = agent_model_id
-    max_steps = int(cfg.get("maxSteps") or 5)
+    # 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
 
     _log(
         f"start model={agent_model_id!r} base={agent_base_url!r} "
@@ -451,6 +474,7 @@ 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)
         _log(f"plain reply: {len(answer)} chars")
         _emit({"type": "final", "text": answer})
@@ -466,6 +490,8 @@ def run_agent_chat(cfg):
     now_str = _dt_now.now().astimezone().strftime("%A, %d %B %Y, %H:%M %Z")
     tool_hint = (
         f"Current date/time: {now_str}.\n\n"
+        "YOU HAVE EXACTLY ONE TURN. In a single code block, call the ONE right tool "
+        "and then pass its result to final_answer(). Do not plan multiple steps.\n\n"
         "You have THREE tools:\n"
         "  1. http_request(method, url, headers='', body='', username='', password='') — "
         "call a SPECIFIC known API/URL.\n"
@@ -504,6 +530,10 @@ 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).
+    _last_obs: dict = {"text": ""}
+
     @tool
     def http_request(method: str, url: str, headers: str = "", body: str = "",
                      username: str = "", password: str = "") -> str:
@@ -561,6 +591,7 @@ def run_agent_chat(cfg):
             result = result + "\n[SUCCESS — call final_answer(response) now, do not parse or retry]"
         _emit({"type": "step", "text": f"HTTP {method.upper()} {url} → {status_line}"})
         _log(f"http_request {method.upper()} {url} → {result[:80]}")
+        _last_obs["text"] = result
         return result
 
     @tool
@@ -582,6 +613,7 @@ def run_agent_chat(cfg):
         out = now.strftime("%A, %d %B %Y, %H:%M:%S %Z")
         _emit({"type": "step", "text": f"Current date/time → {out}"})
         _log(f"get_current_datetime({timezone!r}) → {out}")
+        _last_obs["text"] = out
         return out
 
     @tool
@@ -597,6 +629,7 @@ def run_agent_chat(cfg):
         _emit({"type": "step", "text": f"Searching the web → {query[:80]}"})
         result = _web_search_impl(query)
         _log(f"web_search {query[:60]!r} → {result[:80]}")
+        _last_obs["text"] = result
         return result
 
     def step_callback(step_log):
@@ -658,13 +691,28 @@ 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
+    # 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):
+        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]}")
+            return ChatMessage(role=MessageRole.ASSISTANT, content=text)
+
     try:
         model = _LoggingModel(
             model_id=coding_model_id,
             api_base=coding_base_url,
             api_key=agent_api_key,
         )
-        agent = CodeAgent(
+        agent = _SingleShotAgent(
             tools=[http_request, web_search, get_current_datetime],
             model=model,
             max_steps=max_steps,
@@ -674,11 +722,14 @@ def run_agent_chat(cfg):
         )
         with contextlib.redirect_stdout(sys.stderr):
             result = agent.run(task_with_hint)
-        final_text = _summarize_result(
-            task_text, str(result).strip(),
-            agent_base_url, agent_api_key, agent_model_id
-        )
-        _log(f"done: {len(final_text)} chars")
+        # 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.
+        _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}")

package/package.json

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