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

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,43 @@ 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."""
+            _pair = r"<code[^>]*>[\s\S]*?</code>"
+            if re.search(_pair, content or "", re.I):
+                return content  # already parseable
+            if not (reasoning or "").strip():
+                return content  # nothing to recover from (Ollama / non-reasoning model)
+            # Take the LAST code block in the combined stream (reasoning usually holds it).
+            combined = (reasoning or "") + "\n" + (content or "")
+            last = None
+            for last in re.finditer(r"<code[^>]*>([\s\S]*?)</code>", combined, re.I):
+                pass
+            if not last:
+                return content
+            code = (last.group(1) or "").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.313",
   "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",