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

package/gonext-repl.mjs

@@ -1182,6 +1182,10 @@ let jobIdForApprovalRace = "";
 // Per-session coding-model override chosen via /model (empty = use the account default).
 // Sent to /agent-ask as codingModelOverride; the API validates it against the whitelist.
 let sessionCodingModel = "";
+// The default coding model id (from the startup agent-payload probe) — shown in the
+// per-turn token footer next to the GLOBAL output total so it's clear which model that
+// lifetime count belongs to. The /model override (sessionCodingModel) wins when set.
+let defaultCodingModel = "";
 // Auto-test mode (/test-auto): when on, the agent verifies its work (build/run/curl/…)
 // and fixes → re-tests until it passes before finishing. Default off; remembered per
 // folder in the session file; sent to /agent-ask as autoTest so python drives the loop.
@@ -1937,13 +1941,20 @@ async function runAgentTurn(history) {
           }
         }
         clearStatus();
-        // Task #104: expose this turn's code-model INPUT + OUTPUT token totals so the caller
-        // can print a persistent footer at the bottom of the screen.
+        // Task #104: expose this turn's code-model INPUT + the CUMULATIVE output-token
+        // total (all turns for this user + coding server) so the caller can print a
+        // persistent footer. Output is the running total (globalOutputTokens already holds
+        // every prior turn; latestOutputTokens is THIS turn, not yet folded in because the
+        // addOutputTokens POST above is async) — the same figure the live "↓" showed during
+        // the turn, so it doesn't drop back to just this turn's count at the prompt (#112).
+        // `turnOutputTokens` is kept separately so the caller's footer guard reflects whether
+        // THIS turn used the code model (a plain-reply greeting = 0 → no footer).
         return {
           text: answerFrom(text),
           shown: answerShownLive,
           inputTokens: latestCodeTokens,
-          outputTokens: latestOutputTokens,
+          outputTokens: globalOutputTokens + latestOutputTokens,
+          turnOutputTokens: latestOutputTokens,
         };
       }
       if (text.length > shownChars) {
@@ -2053,6 +2064,8 @@ async function main() {
   try {
     const probe = await fetchAgentPayload([{ role: "user", content: "ping" }]);
     const p = probe?.payload ?? {};
+    // Remember the default coder id for the token footer's global-total label.
+    if (p.codingModelId) defaultCodingModel = p.codingModelId;
     // RAG storage choice (task #97): ask ONCE per folder, and only when RAG is actually
     // enabled in Settings. Default Yes = LOCAL (kept on this machine, no S3 needed).
     if (p.ragEnabled && sessionRagMode === null) {
@@ -2270,7 +2283,7 @@ async function main() {
     }
     history.push({ role: "user", content: taskLine });
     try {
-      const { text: answer, shown, cancelled, inputTokens, outputTokens } =
+      const { text: answer, shown, cancelled, inputTokens, outputTokens, turnOutputTokens } =
         await runAgentTurn(history);
       if (answer) {
         history.push({ role: "assistant", content: answer });
@@ -2281,15 +2294,21 @@ async function main() {
         // A plain-reply answer already streamed live in the loop above — printing it
         // again here would just duplicate it; a blank line is enough for spacing.
         console.log(shown ? "" : `\n\n${answer}\n`);
-        // Task #104: persistent per-turn token footer at the bottom of the screen — the
-        // last turn's code-model INPUT + OUTPUT tokens, kept visible above the next prompt.
-        // Only for turns that actually used the code model (plain-reply greetings = 0/0).
-        if ((inputTokens ?? 0) > 0 || (outputTokens ?? 0) > 0) {
+        // Task #104: persistent token footer at the bottom of the screen — this turn's
+        // code-model INPUT + this turn's OUTPUT (↓ out), then the model's GLOBAL lifetime
+        // output total (all turns for this user + coding server), labelled with the model
+        // name so it's clear which coder that running total belongs to. Guard on THIS turn's
+        // activity so a plain-reply greeting that did no code-model work shows nothing (#112).
+        if ((inputTokens ?? 0) > 0 || (turnOutputTokens ?? 0) > 0) {
+          const coder = sessionCodingModel || defaultCodingModel;
           console.log(
             dim("tokens · ↑ in ") +
               fmtTokens(inputTokens ?? 0) +
               dim(" · ") +
-              cyan(`↓ out ${fmtTokens(outputTokens ?? 0)}`)
+              cyan(`↓ out ${fmtTokens(turnOutputTokens ?? 0)}`) +
+              dim(" · ") +
+              dim(`${coder ? coder + " " : ""}total `) +
+              cyan(`↓ ${fmtTokens(outputTokens ?? 0)}`)
           );
         }
       } else {

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.316",
+  "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",