@tiens.nguyen/gonext-local-worker 1.0.317 → 1.0.318

package/gonext_agent_chat.py

@@ -3177,15 +3177,32 @@ def run_agent_chat(cfg):
     # 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).
+    # (Qwen3-14B class) made real multi-step reasoning reliable. The default budget is
+    # BACKEND-AWARE (a cloud OpenAI-compatible coder is stronger and cheaper-per-step than
+    # a small local model, so it gets more room; a local Ollama coder gets a middle budget;
+    # local MLX keeps the original tight default). Overridable via cfg.maxSteps.
+    # The provide_final_answer override below is only the exhaustion fallback.
+    #
+    # Resolve the effective backend the SAME way as the model setup further down
+    # (explicit kind wins; Auto sniffs the URL) so the budgets match the coder that runs.
+    if coding_kind == "openai":
+        _budget_is_ollama = False
+    elif coding_kind == "ollama":
+        _budget_is_ollama = True
+    else:
+        _budget_is_ollama = _is_ollama_server(coding_base_url)
+    if coding_kind == "openai":
+        _default_budget, _ws_budget = 20, 40   # OpenAI-compatible coder
+    elif _budget_is_ollama:
+        _default_budget, _ws_budget = 10, 20    # Ollama coder
+    else:
+        _default_budget, _ws_budget = 5, 12     # local MLX / Auto — original defaults
     try:
-        max_steps = int(cfg.get("maxSteps") or 5)
+        max_steps = int(cfg.get("maxSteps") or _default_budget)
     except (TypeError, ValueError):
-        max_steps = 8
+        max_steps = _default_budget
     if max_steps < 1:
-        max_steps = 8
+        max_steps = _default_budget
 
     # Max web_search + fetch_url calls per task (user-configurable in web Settings →
     # Agent). Default 10; past it the retrieval tools refuse and steer to finish.
@@ -3392,11 +3409,12 @@ def run_agent_chat(cfg):
             _log(f"active workspace ignored (error resolving '{_aw_raw}'): {_e}")
     if _WS_AVAILABLE:
         _log(f"workspaces: {[(w['name'], w['path'], w['allowRun']) for w in _WS_ROOTS]}")
-        # Coding tasks are edit→test→fix loops — 5 steps is too tight. Bump the default
-        # budget when workspaces are registered, unless the payload set one explicitly.
-        if not cfg.get("maxSteps") and max_steps < 12:
-            max_steps = 12
-            _log("workspace registered → step budget raised to 12 (no explicit maxSteps)")
+        # Coding tasks are edit→test→fix loops — the normal budget is too tight. Bump to
+        # the backend-aware workspace budget (openai 40 / ollama 20 / MLX 12) when
+        # workspaces are registered, unless the payload set one explicitly.
+        if not cfg.get("maxSteps") and max_steps < _ws_budget:
+            max_steps = _ws_budget
+            _log(f"workspace registered → step budget raised to {_ws_budget} (no explicit maxSteps)")
         # Auto-test adds a verify → fix → re-test cycle on top of the work itself, so give
         # it more room (unless the user pinned a budget). Kept modest so a stuck test loop
         # still terminates rather than burning a huge budget.
@@ -5163,14 +5181,27 @@ def run_agent_chat(cfg):
             # Ollama honors it). Harmless if the server ignores it — usage stays 0.
             completion_kwargs["stream_options"] = {"include_usage": True}
             content, role, in_tok, out_tok, reasoning_len = self._run_stream(completion_kwargs)
-            # Empty-turn retry: reasoning models (gemma4 on Ollama) sometimes spend the
-            # WHOLE turn in the reasoning channel and emit no content → smolagents parses an
-            # empty tool call and WASTES the step (seen live: 2 of 5 steps burned this way).
             # Retry ONCE with a hard "emit the code block now" directive appended to the
             # already-prepared API messages (plain dicts — no smolagents format guessing).
-            if not content.strip():
-                _log(f"empty-content turn (reasoning={reasoning_len} chars, no message) "
-                     "→ retrying once with a 'code now' directive")
+            # Two triggers:
+            #   (1) EMPTY content — reasoning models (gemma4 on Ollama) sometimes spend the
+            #       WHOLE turn in the reasoning channel and emit no message.
+            #   (2) BROKEN code attempt — content has a dangling <code>/</code> tag but NO
+            #       valid pair, and #111 recovery found nothing in reasoning either (seen
+            #       live with Kimi K3: content = "Thought: …</code>", reasoning is plain
+            #       planning prose with no code). Without this, smolagents shows the ugly
+            #       "regex pattern <code> was not found" error and burns the step before its
+            #       own retry recovers. A finished PROSE answer has NO code tags, so it never
+            #       trips this — it flows to the auto-wrap path in generate() untouched.
+            _pair_re = r"<code[^>]*>[\s\S]*?</code>"
+            _has_pair = re.search(_pair_re, content or "", re.I) is not None
+            _broken_code = (not _has_pair) and (
+                re.search(r"</?code[\s>/]", content or "", re.I) is not None
+            )
+            if not content.strip() or _broken_code:
+                why = "empty-content" if not content.strip() else "dangling code tag, no valid block"
+                _log(f"{why} turn (reasoning={reasoning_len} chars) → retrying once with a "
+                     "'code now' directive")
                 _emit({"type": "step",
                        "text": "Model produced only analysis — nudging it to write the action…"})
                 retry_kwargs = dict(completion_kwargs)
@@ -5178,10 +5209,15 @@ def run_agent_chat(cfg):
                     {"role": "user", "content": self._CODE_NOW_DIRECTIVE}
                 ]
                 r_content, r_role, r_in, r_out, _ = self._run_stream(retry_kwargs)
-                if r_content.strip():
+                r_has_pair = re.search(_pair_re, r_content or "", re.I) is not None
+                # Use the retry when it yields a real code block, or (empty original) any
+                # content. If the retry is still broken and we HAD a Thought, keep the
+                # original and let smolagents' own retry take it from here — no regression.
+                if r_has_pair or (not content.strip() and r_content.strip()):
                     content, role = r_content, r_role
-                    # Count both calls' output so token accounting isn't understated.
-                    in_tok, out_tok = (r_in or in_tok), out_tok + r_out
+                    in_tok = r_in or in_tok
+                # Count the retry call's output either way — it was generated/billed (#112).
+                out_tok += r_out
             if stop_sequences and not self.supports_stop_parameter:
                 from smolagents.models import remove_content_after_stop_sequences
                 content = remove_content_after_stop_sequences(content, stop_sequences)

package/package.json

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