@tiens.nguyen/gonext-local-worker 1.0.312 → 1.0.314

package/gonext-repl.mjs

@@ -948,6 +948,11 @@ let cancelRequested = false; // a cancel POST has been sent for the current turn
 let approvalActive = false;
 let approvalSel = 0; // 0 = Yes (default highlighted), 1 = No
 let approvalResolve = null;
+// The active turn's live-status wiper (its local clearStatus), or null between turns. A
+// picker calls this before drawing so the "Almost done…/thought/token" block is gone
+// first — otherwise the 120ms ticker keeps redrawing that block on top of the picker and
+// its relative-cursor math lands on the wrong rows (duplicated/interleaved options).
+let clearActiveStatus = null;
 function drawApprovalOptions(redraw) {
   // Two option lines, redrawn in place. On redraw the cursor sits one row below "No";
   // step up 2 rows, clear+rewrite both, landing back where we started.
@@ -986,6 +991,10 @@ const MAXSTEP_PREFIX = "__MAXSTEP__::";
 const TIMEOUT_PREFIX = "__TIMEOUT__::";
 const COMPACT_PREFIX = "__COMPACT__::";
 async function approvalPrompt(command) {
+  // Wipe the live "thinking" status block BEFORE any picker draws, and stop the ticker from
+  // redrawing it (the tick early-returns while a picker is active) — otherwise the block
+  // reappears under the options and corrupts the layout.
+  if (clearActiveStatus) clearActiveStatus();
   // Context-compaction prompt (task #87 rec#3): the running context got large. Ask whether
   // to aggressively compact older steps. No answer in 30s = No (keep full detail — the safe
   // default; the always-on auto-trim still bounds things).
@@ -1463,10 +1472,11 @@ async function runAgentTurn(history) {
     process.stdout.write(seq);
     statusShown = false;
   };
+  clearActiveStatus = clearStatus; // let pickers wipe this turn's status block before they draw
 
   const tick = () => {
     if (!following || followAborted || !jobRunning) return;
-    if (approvalActive) return; // a Yes/No picker owns the screen — don't draw over it
+    if (approvalActive || listPickerActive) return; // a picker owns the screen — don't draw over it
     if (Date.now() - lastContentAt < QUIET_MS) return; // tokens still flowing
     // A plain-reply answer streams onto a line with NO trailing newline until it's fully
     // done — overwriting the ticker there corrupts the visible answer mid-word. Stay
@@ -2009,6 +2019,7 @@ async function runAgentTurn(history) {
   } finally {
     clearInterval(ticker);
     clearStatus();
+    clearActiveStatus = null; // no turn owns the status wiper between turns
     // Task #96: stop mouse-reporting the moment the turn ends (also on cancel/error — this
     // finally always runs), and detach the click parser, so the user's shell selection is
     // never captured between turns.

package/gonext_agent_chat.py

@@ -4960,6 +4960,7 @@ def run_agent_chat(cfg):
             _log("streamed generate: request issued (stream=True), awaiting first token…")
             stream = self.client.chat.completions.create(**completion_kwargs)
             parts = []
+            rparts = []  # reasoning-channel text (task #111: may hold the <code> block)
             role = "assistant"
             in_tok = out_tok = reasoning_len = 0
             first_token_at = None
@@ -5028,6 +5029,7 @@ def run_agent_chat(cfg):
                 if rpiece:
                     _mark_first()
                     reasoning_len += len(rpiece)
+                    rparts.append(rpiece)
                     _stream_buf.append(rpiece)
                     _stream_chars += len(rpiece)
                     _emit({"type": "stream", "text": rpiece})
@@ -5055,10 +5057,63 @@ def run_agent_chat(cfg):
                 _emit({"type": "step", "text": "Model output ran away — restarting this step…"})
                 _log(f"streamed generate: discarded {len(content)} runaway chars → empty content")
                 return "", role, in_tok, out_tok, reasoning_len
+            # Task #111: reasoning models on an OpenAI-compatible API (e.g. Kimi K3 @ Moonshot)
+            # can emit the actionable <code>…</code> into the REASONING channel, leaving only
+            # prose + a stray tag in `content` → smolagents' parser can't find the pair. When
+            # content has no usable code block but the reasoning stream does, rebuild content
+            # from it. Inert when reasoning is empty (Ollama with thinking off) → path untouched.
+            content = self._recover_code_from_channels(content, "".join(rparts))
             _log(f"streamed generate assembled {len(content)} chars "
                  f"(in={in_tok} out={out_tok} tokens, reasoning={reasoning_len} chars)")
             return content, role, in_tok, out_tok, reasoning_len
 
+        def _recover_code_from_channels(self, content, reasoning):
+            """Recover a <code>…</code> tool call that a reasoning model placed in the
+            REASONING channel instead of the visible message (task #111). No-op when the
+            visible content already has a usable code block, or when there is no reasoning
+            text (e.g. Ollama with reasoning_effort='none') — so the Ollama path is unchanged.
+
+            Kimi K3 @ Moonshot splits its output two ways when it fails: (a) the full
+            <code>…</code> block lands in reasoning and only prose leaks to content; or
+            (b) the OPENER + code land in reasoning while the CLOSING </code> leaks into
+            content (seen live: content = 'Thought: …contains.</code>'). Handle both."""
+            _pair = r"<code[^>]*>[\s\S]*?</code>"
+            if re.search(_pair, content or "", re.I):
+                return content  # content already has a usable block — never override it
+            reasoning = reasoning or ""
+            if not reasoning.strip():
+                return content  # nothing to recover from (Ollama / non-reasoning model)
+            code = None
+            # (a) Prefer a COMPLETE block already inside reasoning (the model drafts the
+            # whole tool call there) — take the LAST one, ignoring any stray </code> in content.
+            last = None
+            for last in re.finditer(r"<code[^>]*>([\s\S]*?)</code>", reasoning, re.I):
+                pass
+            if last:
+                code = last.group(1)
+            else:
+                # (b) Opener + code in reasoning, closer leaked to content → take everything
+                # after the LAST opener in reasoning (its </code> is the one now in content).
+                m = None
+                for m in re.finditer(r"<code[^>]*>([\s\S]*)$", reasoning, re.I):
+                    pass
+                if m:
+                    code = m.group(1)
+            if code is None:
+                return content
+            # A leaked 'Thought:' line (or a stray </code>) can ride along after the code —
+            # cut it so only the executable snippet remains.
+            code = re.split(r"\n\s*Thought\s*:\s", code, maxsplit=1)[0]
+            code = re.sub(r"</?code[^>]*>", "", code, flags=re.I).strip()
+            if not code:
+                return content
+            # Keep the visible Thought prose (strip any stray/unbalanced code tags), then
+            # append the recovered block so smolagents parses a clean Thought → <code> pair.
+            prose = re.sub(r"</?code[^>]*>", "", content or "", flags=re.I).strip()
+            rebuilt = (prose + "\n" if prose else "") + "<code>\n" + code + "\n</code>"
+            _log(f"#111 recovered <code> block from reasoning channel ({len(code)} chars)")
+            return rebuilt
+
         # Injected when a turn produced ONLY reasoning and no message content — a hard,
         # model-agnostic steer to emit the actionable code block instead of more analysis.
         _CODE_NOW_DIRECTIVE = (

package/package.json

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