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

package/gonext_agent_chat.py

@@ -626,6 +626,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 +1482,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."""
@@ -1872,10 +1912,13 @@ def run_agent_chat(cfg):
             # Ollama honors it). Harmless if the server ignores it — usage stays 0.
             completion_kwargs["stream_options"] = {"include_usage": True}
             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
+            first_token_at = None
             for chunk in stream:
                 usage = getattr(chunk, "usage", None)
                 if usage is not None:
@@ -1891,6 +1934,17 @@ def run_agent_chat(cfg):
                     role = delta.role
                 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…"})
                     parts.append(piece)
             content = "".join(parts)
             if stop_sequences and not self.supports_stop_parameter:
@@ -2067,28 +2121,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.143",
+  "version": "1.0.145",
   "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",