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

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"
@@ -900,11 +921,18 @@ def run_agent_chat(cfg):
     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 +1164,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"
@@ -1198,8 +1229,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 +1481,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 +1557,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 +1615,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 +1639,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 +1669,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.123",
   "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",