@tiens.nguyen/gonext-local-worker 1.0.145 → 1.0.148

package/gonext-local-worker.mjs

@@ -1538,6 +1538,19 @@ async function runAgentChatJob(job) {
 
     let inThink = false;
     let finalText = "";
+    // Raw model-stream tokens (event.type === "stream") are Python code + `Thought:`
+    // prose + <code>/<|"|> fragments. The web Thought panel renders reasoning as
+    // markdown, which turns `#`-prefixed code comments into <h1> headings and
+    // swallows the tag fragments. Wrap only the raw stream in a fenced code block so
+    // it renders verbatim; `step` labels stay outside the fence as normal prose.
+    // Tilde fences (~~~) avoid colliding with any ``` the model itself emits.
+    let inStreamFence = false;
+    const closeStreamFence = () => {
+      if (inStreamFence) {
+        inStreamFence = false;
+        enqueueText("\n~~~\n\n");
+      }
+    };
 
     // The create_pdf tool uses WeasyPrint, whose Homebrew libs (pango/cairo/gobject)
     // live in /opt/homebrew/lib (Apple Silicon) or /usr/local/lib (Intel). macOS doesn't
@@ -1554,13 +1567,30 @@ async function runAgentChatJob(job) {
     await runProcessWithStreamingStdout(python, [scriptPath], input, timeoutMs, (event) => {
       if (event.type === "log" && typeof event.text === "string") {
         console.log(`[gonext-agent] ${event.text}`);
+      } else if (event.type === "stream" && typeof event.text === "string") {
+        // Live model token stream (the agent's Thought / reasoning as it generates).
+        // Goes inside the same <think> block as the step summaries, but RAW — no
+        // "\n\n" separator, so the tokens concatenate into flowing text. Wrapped in
+        // a code fence (opened lazily on the first stream token) so the web viewer
+        // renders it verbatim instead of as markdown.
+        if (!inThink) {
+          inThink = true;
+          enqueueText("<think>");
+        }
+        if (!inStreamFence) {
+          inStreamFence = true;
+          enqueueText("~~~\n");
+        }
+        enqueueText(event.text);
       } else if (event.type === "step" && typeof event.text === "string") {
+        closeStreamFence();
         if (!inThink) {
           inThink = true;
           enqueueText("<think>");
         }
         enqueueText(event.text + "\n\n");
       } else if (event.type === "final" && typeof event.text === "string") {
+        closeStreamFence();
         if (inThink) {
           inThink = false;
           enqueueText("</think>");
@@ -1570,6 +1600,7 @@ async function runAgentChatJob(job) {
       }
     }, pdfEnv);
 
+    closeStreamFence();
     if (inThink) {
       enqueueText("</think>");
     }

package/gonext_agent_chat.py

@@ -15,9 +15,11 @@ Reads on stdin:
   }
 
 Emits NDJSON lines on stdout:
-  {"type": "log",   "text": "..."}   — worker logs to console, not shown in chat
-  {"type": "step",  "text": "..."}   — shown in <think> area
-  {"type": "final", "text": "..."}   — assistant answer
+  {"type": "log",    "text": "..."}  — worker logs to console, not shown in chat
+  {"type": "step",   "text": "..."}  — a summary line shown in the <think> area
+  {"type": "stream", "text": "..."}  — RAW model token(s) streamed live into <think>
+                                       (the agent's Thought/reasoning as it generates)
+  {"type": "final",  "text": "..."}  — assistant answer
 """
 import contextlib
 import json
@@ -1892,33 +1894,34 @@ def run_agent_chat(cfg):
                 _log(f"streamed generate failed ({e}) → falling back to non-streaming")
                 return super().generate(*args, **kwargs)
 
-        def _streamed_generate(
-            self, messages, stop_sequences=None, response_format=None,
-            tools_to_call_from=None, **kwargs,
-        ):
-            from smolagents.models import ChatMessage, TokenUsage  # local: version-safe
-            completion_kwargs = self._prepare_completion_kwargs(
-                messages=messages,
-                stop_sequences=stop_sequences,
-                response_format=response_format,
-                tools_to_call_from=tools_to_call_from,
-                model=self.model_id,
-                custom_role_conversions=self.custom_role_conversions,
-                convert_images_to_image_urls=True,
-                **kwargs,
-            )
-            completion_kwargs["stream"] = True
-            # Ask for a usage summary in the final chunk (OpenAI streaming convention;
-            # Ollama honors it). Harmless if the server ignores it — usage stays 0.
-            completion_kwargs["stream_options"] = {"include_usage": True}
+        def _run_stream(self, completion_kwargs):
+            """Issue ONE streaming completion, stream tokens live to the UI, and return
+            (content, role, in_tok, out_tok, reasoning_len). `content` is ONLY the visible
+            message text (for smolagents' parser); reasoning-channel tokens are streamed to
+            the Thinking panel but never accumulated into content."""
             self._apply_rate_limit()
             t0 = time.monotonic()
             _log("streamed generate: request issued (stream=True), awaiting first token…")
             stream = self.client.chat.completions.create(**completion_kwargs)
             parts = []
             role = "assistant"
-            in_tok = out_tok = 0
+            in_tok = out_tok = reasoning_len = 0
             first_token_at = None
+
+            def _mark_first():
+                # First streamed byte (content OR reasoning). The gap t0→here is pure
+                # prompt-eval time (server sent nothing before this); everything after is
+                # token generation with bytes flowing, so the proxy idle timer resets. If
+                # this never logs, the request died in prompt-eval BEFORE any token —
+                # streaming can't help there (shrink the model / warm the prompt cache).
+                nonlocal first_token_at
+                if first_token_at is None:
+                    first_token_at = time.monotonic()
+                    _log(f"streamed generate: FIRST token after {first_token_at - t0:.1f}s "
+                         "(prompt-eval done; tokens now flowing)")
+                    # Separate this step's live thinking from the previous step summary.
+                    _emit({"type": "stream", "text": "\n"})
+
             for chunk in stream:
                 usage = getattr(chunk, "usage", None)
                 if usage is not None:
@@ -1932,26 +1935,79 @@ def run_agent_chat(cfg):
                     continue
                 if getattr(delta, "role", None):
                     role = delta.role
+                # Live "thinking": stream BOTH the visible content AND any reasoning-channel
+                # tokens (gemma4/deepseek-class models emit their chain-of-thought there,
+                # leaving `content` empty) to the web Thinking panel as they arrive. Only
+                # `content` is accumulated into the message smolagents parses — reasoning is
+                # display-only and must NEVER reach the <code> parser.
+                rpiece = (getattr(delta, "reasoning", None)
+                          or getattr(delta, "reasoning_content", None))
+                if rpiece:
+                    _mark_first()
+                    reasoning_len += len(rpiece)
+                    _emit({"type": "stream", "text": rpiece})
                 piece = getattr(delta, "content", None)
                 if piece:
-                    if first_token_at is None:
-                        # First streamed byte. The gap t0→here is pure prompt-eval time
-                        # (server sent nothing before this); everything after is token
-                        # generation with bytes flowing, so the proxy idle timer resets.
-                        # If this line never appears in the log, the request died in
-                        # prompt-eval BEFORE any token — streaming can't help there
-                        # (shrink the model / warm the prompt cache instead).
-                        first_token_at = time.monotonic()
-                        _log(f"streamed generate: FIRST token after {first_token_at - t0:.1f}s "
-                             "(prompt-eval done; tokens now flowing)")
-                        _emit({"type": "step", "text": "Model is responding…"})
+                    _mark_first()
                     parts.append(piece)
+                    _emit({"type": "stream", "text": piece})
             content = "".join(parts)
+            _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
+
+        # 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 = (
+            "You wrote analysis but produced NO code block, so nothing ran. Output ONLY a "
+            "single code block NOW that calls exactly one tool and nothing else, e.g.:\n"
+            "<code>\nweb_search(query=\"...\")\n</code>\n"
+            "No explanation, no <thought>, no <think> — just the <code>…</code> block. "
+            "If you already have enough information, call final_answer(...) or create_pdf(...)."
+        )
+
+        def _streamed_generate(
+            self, messages, stop_sequences=None, response_format=None,
+            tools_to_call_from=None, **kwargs,
+        ):
+            from smolagents.models import ChatMessage, TokenUsage  # local: version-safe
+            completion_kwargs = self._prepare_completion_kwargs(
+                messages=messages,
+                stop_sequences=stop_sequences,
+                response_format=response_format,
+                tools_to_call_from=tools_to_call_from,
+                model=self.model_id,
+                custom_role_conversions=self.custom_role_conversions,
+                convert_images_to_image_urls=True,
+                **kwargs,
+            )
+            completion_kwargs["stream"] = True
+            # Ask for a usage summary in the final chunk (OpenAI streaming convention;
+            # 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")
+                _emit({"type": "step",
+                       "text": "Model produced only analysis — nudging it to write the action…"})
+                retry_kwargs = dict(completion_kwargs)
+                retry_kwargs["messages"] = list(completion_kwargs.get("messages") or []) + [
+                    {"role": "user", "content": self._CODE_NOW_DIRECTIVE}
+                ]
+                r_content, r_role, r_in, r_out, _ = self._run_stream(retry_kwargs)
+                if 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
             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)
-            _log(f"streamed generate assembled {len(content)} chars "
-                 f"(in={in_tok} out={out_tok} tokens)")
             return ChatMessage(
                 role=role,
                 content=content,

package/package.json

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