@tiens.nguyen/gonext-local-worker 1.0.144 → 1.0.146

package/gonext-local-worker.mjs

@@ -1554,6 +1554,15 @@ 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.
+        if (!inThink) {
+          inThink = true;
+          enqueueText("<think>");
+        }
+        enqueueText(event.text);
       } else if (event.type === "step" && typeof event.text === "string") {
         if (!inThink) {
           inThink = true;

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
@@ -626,6 +628,44 @@ def _plain_reply(messages: list, base_url: str, api_key: str, model_id: str) ->
         return f"[Error: {e}]"
 
 
+def _synthesize_document(gathered: list, task: str, base_url: str, api_key: str,
+                         model_id: str) -> str:
+    """Turn raw gathered research observations into ONE clean, organized document body
+    for create_pdf. This is a pure REFORMAT (organize/deduplicate facts already found —
+    no new research), so the fast local chat model handles it well. Returns "" on any
+    failure so the caller can fall back to the raw concatenation."""
+    notes = "\n\n---\n\n".join(gathered)[:12000]
+    sys_prompt = (
+        "You are a document editor. You are given a user's request and raw research "
+        "notes gathered to answer it. Produce a single, clean, well-organized document "
+        "that fulfills the request using ONLY facts present in the notes.\n"
+        "- Use a clear title, headings, and bullet lists or a markdown table where it "
+        "fits (e.g. schedules → a table of Teams | Date | Time).\n"
+        "- Deduplicate and order the information sensibly (e.g. by date).\n"
+        "- Do NOT invent facts not in the notes, and do NOT mention the research process, "
+        "steps, tools, or that anything is partial. Output ONLY the document body."
+    )
+    user_prompt = f"USER REQUEST:\n{task}\n\nRESEARCH NOTES:\n{notes}"
+    try:
+        from openai import OpenAI
+        client = OpenAI(base_url=base_url, api_key=api_key or "local",
+                        max_retries=0, timeout=120)
+        resp = client.chat.completions.create(
+            model=model_id,
+            messages=[{"role": "system", "content": sys_prompt},
+                      {"role": "user", "content": user_prompt}],
+            temperature=0.3,
+            max_tokens=2048,
+        )
+        out = (resp.choices[0].message.content or "").strip()
+        # A reasoning model might wrap output in <think>…</think>; strip it.
+        out = _THINK_BLOCK.sub("", out).strip()
+        return out
+    except Exception as e:  # noqa: BLE001
+        _log(f"document synthesis failed ({e}) → will use raw gathered notes")
+        return ""
+
+
 def _strip_tool_tags(text: str) -> str:
     """Remove the internal hint tags we append to tool output (e.g. '[SUCCESS …]',
     '[NOTE: …]', 'Note: This URL failed …') so they never leak into the user reply."""
@@ -1444,10 +1484,12 @@ def run_agent_chat(cfg):
         return " ".join(sorted(tokens))
 
     # Hard research budget: at most N retrieval calls (web_search + fetch_url) per run.
-    # Past it, retrieval tools refuse and steer to create_pdf/final_answer. Keeps ≥2 of
-    # the 5 steps free to actually FINISH — the live failure mode was burning ALL steps
-    # on slightly-different searches and never producing the asked-for PDF.
-    _research = {"used": 0, "max": 3}
+    # Past it, retrieval tools refuse and steer to create_pdf/final_answer. Keeps steps
+    # free to actually FINISH — the live failure mode was burning ALL steps on
+    # slightly-different searches and never producing the asked-for PDF. PDF tasks get a
+    # TIGHTER budget (2) so the model is steered to create_pdf a step sooner and has more
+    # steps left to actually emit that call itself (avoids leaning on the fallback).
+    _research = {"used": 0, "max": 2 if agent_pdf_requested else 3}
 
     def _research_spend(tool_name: str) -> str:
         """Return '' if under budget (and spend 1), else a refusal steering to finish."""
@@ -1852,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:
@@ -1892,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,
@@ -2081,28 +2177,36 @@ def run_agent_chat(cfg):
     class _ToolAgent(_AgentBase):
         def provide_final_answer(self, task, *args, **kwargs):
             from smolagents.models import ChatMessage, MessageRole
-            # PDF-on-exhaustion guarantee: the user asked for a PDF and the loop burned
-            # all steps researching without ever calling create_pdf (seen live: 5 steps
-            # of search/fetch, zero deliverable). Render whatever WAS gathered into a
-            # (possibly partial) PDF instead of returning raw page text.
+            # Deterministic PDF delivery: the user asked for a PDF and the model did the
+            # research but never emitted the create_pdf call itself (weak/slow coders often
+            # keep researching and never converge). Rendering the gathered facts here is the
+            # INTENDED deliverable, not an error — so deliver it cleanly, with NO apologetic
+            # "may be partial / hit my step limit" note (that made a normal, successful PDF
+            # look like a failure to the user).
             if (agent_pdf_requested and _gathered
                     and not (_last_obs.get("text") or "").startswith("✅")):
-                _log(f"max-steps fallback → forcing create_pdf from {len(_gathered)} "
-                     "gathered observation(s)")
+                _log(f"delivering PDF deterministically from {len(_gathered)} "
+                     "gathered result(s) (model didn't call create_pdf itself)")
                 try:
-                    compiled = "\n\n---\n\n".join(_gathered)[:12000]
+                    # Reformat the raw observations into a clean document (headings/tables)
+                    # via the fast local chat model; fall back to the raw concatenation if
+                    # synthesis fails or returns nothing.
+                    compiled = _synthesize_document(
+                        _gathered, latest_user_text,
+                        agent_base_url, agent_api_key, agent_model_id,
+                    )
+                    if compiled:
+                        _log(f"synthesized document ({len(compiled)} chars) for PDF")
+                    else:
+                        compiled = "\n\n---\n\n".join(_gathered)[:12000]
                     out = create_pdf(
                         text=compiled, title=_derive_pdf_title(latest_user_text)
                     )
                     if isinstance(out, str) and out.startswith("✅"):
-                        out += (
-                            "\n\n(Note: I hit my research step limit, so this PDF contains "
-                            "what I could gather — it may be partial.)"
-                        )
                         return ChatMessage(role=MessageRole.ASSISTANT, content=out)
-                    _log(f"forced create_pdf did not succeed: {str(out)[:120]}")
+                    _log(f"deterministic create_pdf did not succeed: {str(out)[:120]}")
                 except Exception as e:  # noqa: BLE001
-                    _log(f"forced create_pdf error: {type(e).__name__}: {e}")
+                    _log(f"deterministic create_pdf error: {type(e).__name__}: {e}")
             text = (_last_obs.get("text") or "").strip()
             if text:
                 _log(f"max-steps fallback (last tool obs) → {text[:80]}")

package/package.json

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