@tiens.nguyen/gonext-local-worker 1.0.121 → 1.0.124

package/gonext-local-worker.mjs

@@ -1506,7 +1506,7 @@ async function runAgentChatJob(job) {
       codingBaseURL: payload?.codingBaseURL ?? "",
       codingModelId: payload?.codingModelId ?? "",
       tools: payload?.tools ?? ["http_request"],
-      maxSteps: payload?.maxSteps ?? 5,
+      maxSteps: payload?.maxSteps ?? 8,
       // Tool-invocation mode for the agent: "code" (default, python CodeAgent) or
       // "toolcall" (structured JSON tool calls). Passed through only; the API/web can
       // set payload.agentToolMode to A/B — default keeps current behavior.

package/gonext_agent_chat.py

@@ -11,7 +11,7 @@ Reads on stdin:
     "codingBaseURL": str,        # optional: dedicated coding/reasoning model for the
     "codingModelId": str,        #   CodeAgent's tool-use loop; empty = reuse agentModelId
     "tools": ["http_request"],   # v1: only http_request
-    "maxSteps": int              # default 10
+    "maxSteps": int              # multi-step ReAct budget; default 8
   }
 
 Emits NDJSON lines on stdout:
@@ -570,6 +570,27 @@ def _strip_tool_tags(text: str) -> str:
     return "\n".join(out).strip()
 
 
+_THINK_BLOCK = re.compile(r"<think>.*?</think>", re.DOTALL | re.IGNORECASE)
+
+
+def _strip_think(text: str) -> str:
+    """Remove Qwen3-style <think>…</think> reasoning traces from a model reply.
+
+    Reasoning models (e.g. Qwen3) emit their chain-of-thought inside <think> tags
+    before the actual answer/code. We keep thinking ON (it improves the output) but
+    strip the trace before smolagents parses the step, so the code/final_answer parser
+    only sees the real content — and the trace never leaks to the user. Handles a
+    dangling </think> too (some chat templates open <think> server-side)."""
+    if not text:
+        return text
+    text = _THINK_BLOCK.sub("", text)
+    low = text.lower()
+    if "</think>" in low and "<think>" not in low:
+        # Template opened the think tag for the model; drop everything up to the close.
+        text = text[low.find("</think>") + len("</think>"):]
+    return text.strip()
+
+
 _PDF_INSTALL_HINT = (
     "PDF engine not installed on the worker. On macOS:\n"
     "    brew install pango libffi\n"
@@ -883,28 +904,48 @@ def run_agent_chat(cfg):
     raw_coding_base = (cfg.get("codingBaseURL") or "").strip()
     raw_coding_model = (cfg.get("codingModelId") or "").strip()
     if raw_coding_base:
-        # A dedicated coding server is configured. If no model name was given,
-        # ask the server which model it serves (mlx_lm.server otherwise tries to
-        # download a mismatched name from HF and 404s).
-        detected = raw_coding_model or _detect_model_id(raw_coding_base, agent_api_key)
-        if detected:
-            coding_base_url = raw_coding_base
-            coding_model_id = detected
-        else:
+        same_server = raw_coding_base.rstrip("/") == (agent_base_url or "").rstrip("/")
+        if same_server and not raw_coding_model:
+            # The coding URL points at the SAME server as the chat model. Do NOT
+            # auto-detect: /v1/models can list several cached models and return a
+            # SMALLER one first (e.g. a 3B), silently downgrading the agent's reasoning.
+            # Reuse the chat model id directly — it's the model actually loaded here.
             _log(
-                f"coding model id unresolved for {raw_coding_base!r}; "
-                "falling back to chat model"
+                f"coding base == chat base ({raw_coding_base}); "
+                f"reusing chat model {agent_model_id!r} (skipping auto-detect)"
             )
             coding_base_url = agent_base_url
             coding_model_id = agent_model_id
+        else:
+            # A DIFFERENT dedicated coding server. If no model name was given, ask the
+            # server which model it serves (mlx_lm.server otherwise tries to download a
+            # mismatched name from HF and 404s).
+            detected = raw_coding_model or _detect_model_id(raw_coding_base, agent_api_key)
+            if detected:
+                coding_base_url = raw_coding_base
+                coding_model_id = detected
+            else:
+                _log(
+                    f"coding model id unresolved for {raw_coding_base!r}; "
+                    "falling back to chat model"
+                )
+                coding_base_url = agent_base_url
+                coding_model_id = agent_model_id
     else:
         coding_base_url = agent_base_url
         coding_model_id = agent_model_id
-    # 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
+    # Multi-step ReAct loop (thinking agent): the agent may take several
+    # Thought → tool → Observation steps and then call final_answer() itself. This
+    # replaced the old strict single-shot (max_steps=1) once a stronger coding model
+    # (Qwen3-14B class) made real multi-step reasoning reliable. Default budget 8,
+    # overridable via cfg.maxSteps. The provide_final_answer override below is now only
+    # the exhaustion fallback (loop ends without final_answer).
+    try:
+        max_steps = int(cfg.get("maxSteps") or 8)
+    except (TypeError, ValueError):
+        max_steps = 8
+    if max_steps < 1:
+        max_steps = 8
 
     _log(
         f"start model={agent_model_id!r} base={agent_base_url!r} "
@@ -1136,9 +1177,12 @@ def run_agent_chat(cfg):
         "(previews first, then sends on confirm).\n"
     ) if _EMAIL_AVAILABLE else ""
     tool_hint = (
-        "YOU HAVE EXACTLY ONE TURN. Read the TASK above. In a single code block, call "
-        "the ONE tool that fits THAT task, then pass its result to final_answer(). "
-        "Do not plan multiple steps.\n\n"
+        f"Solve the TASK step by step (up to {max_steps} steps). At EACH step write a "
+        "brief Thought, then ONE code block that calls a SINGLE tool. You will SEE that "
+        "tool's result (Observation) before the next step — use it to decide what to do "
+        "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"
@@ -1156,15 +1200,13 @@ def run_agent_chat(cfg):
         "\n"
         "http_request RETURN FORMAT: 'HTTP 200\\n{body}' — first line is 'HTTP <code>', body follows.\n"
         "\n"
-        "BASIC AUTH — ALWAYS use username= and password=, NEVER construct headers manually:\n"
-        "  response = http_request('GET', 'https://api.example.com/data',\n"
-        "                          username='alice@example.com', password='secret123')\n"
-        "  final_answer(response)\n"
-        "The function handles base64 encoding automatically. NEVER write 'Basic ' + anything.\n"
-        "\n"
-        "BEARER TOKEN — use headers:\n"
-        "  response = http_request('GET', url, headers='{\"Authorization\": \"Bearer TOKEN\"}')\n"
-        "  final_answer(response)\n"
+        "AUTH — ONLY when the TASK itself provides credentials or a token. If it does "
+        "NOT, call http_request with NO username/password/headers. NEVER invent or copy "
+        "the placeholder values below.\n"
+        "  BASIC AUTH — pass username= and password= (auto base64; never build a 'Basic ' header):\n"
+        "      http_request('GET', url, username=<username from the task>, password=<password from the task>)\n"
+        "  BEARER TOKEN — pass it in headers:\n"
+        "      http_request('GET', url, headers='{\"Authorization\": \"Bearer <token from the task>\"}')\n"
         "\n"
         "CHOOSING A TOOL (match the TASK, not these examples):\n"
         "- ONLY a date/time question (e.g. 'what is the date today') -> get_current_datetime().\n"
@@ -1172,6 +1214,8 @@ def run_agent_chat(cfg):
         "knowledge -> web_search(query).\n"
         "- 'read this page' / 'open this link' / 'what does <URL> say' -> fetch_url(url).\n"
         "- any arithmetic, percentage, or 'how much is' math -> calculate(expression).\n"
+        "- a live/current NUMBER with no URL given (price, exchange rate, weather, score, "
+        "stock/crypto) -> web_search(query). Do NOT guess an API URL for these.\n"
         "- 'create/make/generate/export a PDF' of some text/data -> create_pdf(text, title).\n"
         + _pdf_read_choose_line + _email_choose_line +
         "- A specific known API/URL was given -> http_request().\n"
@@ -1181,8 +1225,11 @@ def run_agent_chat(cfg):
         "If nothing works, call final_answer explaining what you need — do NOT make up an answer.\n"
         "- Only report what a tool ACTUALLY returned. Never fabricate a response, body, or status code.\n"
         "- Pass an http_request response DIRECTLY to final_answer — do NOT split, parse, or index it.\n"
-        "- If a response starts with 'HTTP 2' it SUCCEEDED — call final_answer immediately.\n"
-        "- If a tool returns 'Error:' or HTTP 4xx/5xx, try a DIFFERENT approach, not the same URL.\n"
+        "- When a call's result is UNCERTAIN (any network call), do NOT call final_answer "
+        "in the SAME block. Call the tool alone, READ the Observation, THEN answer next step.\n"
+        "- If a response starts with 'HTTP 2' it SUCCEEDED — answer with it next step.\n"
+        "- NEVER pass an 'Error:' / HTTP 4xx / 5xx result to final_answer. On an error, try a "
+        "DIFFERENT approach next step (e.g. web_search); only give up after a few tries.\n"
         "- Do NOT put final_answer outside the code block.\n\n"
     )
     # Lead with the TASK so the weak model anchors on what's actually being asked —
@@ -1198,8 +1245,8 @@ 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).
+    # Remember the last tool output so the max-steps fallback can report exactly what a
+    # tool returned (no extra model call) if the loop ends without final_answer.
     _last_obs: dict = {"text": ""}
 
     @tool
@@ -1450,7 +1497,7 @@ def run_agent_chat(cfg):
 
         # 2) Render the Markdown to PDF bytes locally (pure-Python xhtml2pdf).
         # Catch EVERYTHING (xhtml2pdf can raise arbitrary errors on exotic glyphs /
-        # emoji), so the tool always returns a string and never breaks the single shot.
+        # emoji), so the tool always returns a string and never breaks the agent loop.
         _emit({"type": "step", "text": "Rendering PDF…"})
         try:
             pdf_bytes = _render_pdf_bytes(markdown_text, doc_title)
@@ -1526,6 +1573,21 @@ def run_agent_chat(cfg):
     # and any step memory it accumulates. completion_kwargs["messages"] here is the
     # literal messages array sent to /v1/chat/completions.
     class _LoggingModel(OpenAIServerModel):
+        def generate(self, *args, **kwargs):
+            # Strip Qwen3 <think>…</think> reasoning traces from each step's reply
+            # BEFORE smolagents parses it for the code block / final_answer. Thinking
+            # stays on (better reasoning), but the trace never confuses the parser or
+            # leaks to the user.
+            msg = super().generate(*args, **kwargs)
+            try:
+                if isinstance(getattr(msg, "content", None), str) and "</think>" in msg.content.lower():
+                    cleaned = _strip_think(msg.content)
+                    _log(f"stripped <think> trace ({len(msg.content) - len(cleaned)} chars)")
+                    msg.content = cleaned
+            except Exception as e:  # noqa: BLE001
+                _log(f"think-strip error: {e}")
+            return msg
+
         def _prepare_completion_kwargs(self, *args, **kwargs):
             ck = super()._prepare_completion_kwargs(*args, **kwargs)
             try:
@@ -1569,21 +1631,22 @@ def run_agent_chat(cfg):
     else:
         _log("agent tool mode: code (python CodeAgent)")
 
-    # 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
+    # Exhaustion fallback: normally the model calls final_answer() itself within the
+    # multi-step loop and that answer is used. Only if it burns through all max_steps
+    # WITHOUT calling final_answer does smolagents 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(_AgentBase):
+    # deterministically (or a plain reply) rather than dead-ending — and without a weak
+    # model corrupting exact tool output (dates/numbers).
+    class _ToolAgent(_AgentBase):
         def provide_final_answer(self, task, *args, **kwargs):
             from smolagents.models import ChatMessage, MessageRole
             text = (_last_obs.get("text") or "").strip()
             if text:
-                _log(f"single-shot fallback (last tool obs) → {text[:80]}")
+                _log(f"max-steps fallback (last tool obs) → {text[:80]}")
             else:
-                # No usable tool output (e.g. the single code block failed to parse).
+                # 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.
-                _log("single-shot fallback → plain reply over conversation")
+                _log("max-steps fallback → plain reply over conversation")
                 try:
                     text = _plain_reply(
                         messages, agent_base_url, agent_api_key, agent_model_id
@@ -1592,8 +1655,8 @@ def run_agent_chat(cfg):
                     _log(f"plain-reply fallback error: {e}")
                     text = ""
                 if not text:
-                    text = ("I couldn't complete that in one step. Please rephrase, or "
-                            "give a specific URL/API to call.")
+                    text = ("I couldn't complete that within the step budget. Please "
+                            "rephrase, or give a specific URL/API to call.")
             return ChatMessage(role=MessageRole.ASSISTANT, content=text)
 
     try:
@@ -1622,14 +1685,13 @@ def run_agent_chat(cfg):
             agent_kwargs["additional_authorized_imports"] = [
                 "json", "base64", "urllib", "urllib.request", "urllib.error"
             ]
-        agent = _SingleShotAgent(**agent_kwargs)
+        agent = _ToolAgent(**agent_kwargs)
         with contextlib.redirect_stdout(sys.stderr):
             result = agent.run(task_with_hint)
-        # 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.
+        # Final formatting — NO extra summarizer model call. In multi-step mode the
+        # agent's own final_answer() (or the max-steps fallback above) already holds the
+        # synthesized answer; we just strip the internal hint tags we appended to tool
+        # results so they don't leak to the user.
         _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")

package/package.json

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