@tiens.nguyen/gonext-local-worker 1.0.283 → 1.0.284

package/gonext-local-worker.mjs

@@ -1893,6 +1893,10 @@ async function runAgentChatJob(job) {
       agentModelId: payload?.agentModelId ?? "",
       codingBaseURL: payload?.codingBaseURL ?? "",
       codingModelId: payload?.codingModelId ?? "",
+      // Dedicated SEARCH model (#105): when set, web_search synthesizes its results into a
+      // cited answer with this model instead of returning raw read pages. Empty = no synth.
+      searchBaseURL: payload?.searchBaseURL ?? "",
+      searchModelId: payload?.searchModelId ?? "",
       tools: payload?.tools ?? ["http_request"],
       // 0 = "not explicitly set": python defaults to 5, but may auto-raise to 12 when
       // workspaces are registered. Passing a literal 5 here would look user-set and

package/gonext_agent_chat.py

@@ -10,6 +10,8 @@ Reads on stdin:
     "agentModelId": str,
     "codingBaseURL": str,        # optional: dedicated coding/reasoning model for the
     "codingModelId": str,        #   CodeAgent's tool-use loop; empty = reuse agentModelId
+    "searchBaseURL": str,        # optional: dedicated SEARCH model that synthesizes
+    "searchModelId": str,        #   web_search results into a cited answer; empty = none
     "tools": ["http_request"],   # v1: only http_request
     "maxSteps": int              # multi-step ReAct budget; default 5
   }
@@ -606,12 +608,69 @@ def _read_pages(ranked, query, per_page_chars=1500, per_timeout=5, overall=6):
     return out
 
 
-def _web_search_impl(query, max_results=5, searxng_url=""):
+def _synthesize_search(query, context, base_url, model_id, api_key="local",
+                       stall_timeout=20, overall_deadline=45):
+    """Search model (#105): ask a configured OpenAI-compatible model to write a concise,
+    cited answer FROM the already-read search content — so the (slow) coding model doesn't
+    reason over raw pages (the Perplexity pattern).
+
+    STREAMS with a per-READ timeout (httpx `timeout` fires when NO bytes arrive within
+    `stall_timeout`) — that is a genuine FIRST-TOKEN deadline during prompt-eval and an
+    inter-token watchdog after. This is the fix for the old whole-response `timeout=45`
+    that, under MLX contention, let the client hang until it aborted → APITimeoutError +
+    an MLX broken-pipe. Returns "" on ANY failure so the caller falls back to the read
+    content — never worse than #104."""
+    from openai import OpenAI
+    import time as _t
+    client = OpenAI(base_url=base_url, api_key=api_key or "local", max_retries=0,
+                    timeout=stall_timeout)
+    parts = []
+    t0 = _t.time()
+    try:
+        stream = client.chat.completions.create(
+            model=model_id or "default_model",
+            messages=[
+                {"role": "system", "content": (
+                    "You are a research assistant. Using ONLY the search results provided, "
+                    "write a concise, factual answer to the user's query. Cite sources inline "
+                    "as [n] using their numbers. Preserve any table / schedule rows verbatim. "
+                    "If the results do not contain the answer, say so plainly — never invent "
+                    "facts, dates, names, or URLs."
+                )},
+                {"role": "user",
+                 "content": f"Query: {query}\n\nSearch results:\n{context}\n\nAnswer:"},
+            ],
+            max_tokens=700,
+            temperature=0.2,
+            stream=True,
+        )
+        for chunk in stream:
+            choices = getattr(chunk, "choices", None)
+            delta = getattr(choices[0], "delta", None) if choices else None
+            piece = getattr(delta, "content", None) if delta else None
+            if piece:
+                parts.append(piece)
+            if (_t.time() - t0) > overall_deadline:  # generation ran long → keep partial
+                _log(f"search-model synthesis: {overall_deadline}s cap hit → using partial")
+                try:
+                    stream.close()
+                except Exception:  # noqa: BLE001
+                    pass
+                break
+        return "".join(parts).strip()
+    except Exception as e:  # noqa: BLE001
+        _log(f"search-model synthesis failed ({type(e).__name__}: {e}); using read output")
+        return "".join(parts).strip()  # partial (if any) is still useful; else caller falls back
+
+
+def _web_search_impl(query, max_results=5, searxng_url="",
+                     search_base_url="", search_model_id=""):
     """Keyless web search that READS for the model (tasks #103 + #104): run DuckDuckGo-HTML
     + SearXNG (if configured) + Wikipedia CONCURRENTLY, merge/dedupe/rank by cross-engine
     agreement, surface any SERP answer box, then (unless GONEXT_SEARCH_READ=0) READ the top
-    pages in parallel and return answer-ready condensed content — so the model usually does
-    NOT need a slow fetch_url round-trip. Model-free; never fabricates.
+    pages in parallel. If a SEARCH MODEL is configured (search_base_url/search_model_id, #105)
+    it then SYNTHESIZES a cited answer from that read content — so the slow coding model gets
+    a clean answer, not raw pages. Model-free otherwise; never fabricates.
     """
     import os
     import time as _t
@@ -622,8 +681,9 @@ def _web_search_impl(query, max_results=5, searxng_url=""):
         return "web_search: empty query."
     searxng = (searxng_url or os.environ.get("GONEXT_SEARXNG_URL") or "").strip()
 
-    # Short TTL cache (identical query within a turn).
-    ckey = (q.lower(), searxng)
+    # Short TTL cache (identical query within a turn). Include the search model so a
+    # synthesized answer isn't served after the search-model config changes.
+    ckey = (q.lower(), searxng, search_base_url, search_model_id)
     hit = _WEB_SEARCH_CACHE.get(ckey)
     if hit and (_t.time() - hit[0]) < _WEB_SEARCH_TTL:
         return hit[1]
@@ -728,6 +788,16 @@ def _web_search_impl(query, max_results=5, searxng_url=""):
             lines.append(head + (f"\n{body}" if body else ""))
         parts.append("\n".join(lines))
     out = "\n\n".join(parts)
+
+    # Search model (#105): if configured, have it write the cited answer FROM the read
+    # content above, so the coding model receives a clean answer instead of raw pages.
+    # Best-effort — any failure keeps the #104 read output (never worse).
+    if search_base_url and search_model_id and (answers or ranked):
+        synth = _synthesize_search(q, out, search_base_url, search_model_id)
+        if synth:
+            srcs = "\n".join(f"[{i}] {e['url']}" for i, e in enumerate(ranked, 1))
+            out = f"Answer:\n{synth}" + (f"\n\nSources:\n{srcs}" if srcs else "")
+
     _WEB_SEARCH_CACHE[ckey] = (_t.time(), out)
     return out
 
@@ -3091,6 +3161,14 @@ def run_agent_chat(cfg):
         f"start model={agent_model_id!r} base={agent_base_url!r} "
         f"codeModel={coding_model_id!r} codeBase={coding_base_url!r} maxSteps={max_steps}"
     )
+    # Search model (#105): diagnostics only — the web_search tool reads it from cfg directly.
+    _search_base = (cfg.get("searchBaseURL") or "").strip()
+    _search_model = (cfg.get("searchModelId") or "").strip()
+    if _search_base and _search_model:
+        _log(f"search model: {_search_model!r} @ {_search_base} "
+             "(web_search synthesizes a cited answer with it)")
+    else:
+        _log("search model: none (web_search returns read page content, not a synthesized answer)")
 
     # Build the task from the conversation history. We include the FULL conversation
     # (both user AND assistant turns) so the agent remembers what it already did —
@@ -4180,7 +4258,13 @@ def run_agent_chat(cfg):
         _emit({"type": "step", "text": f"Searching the web → {query[:80]}"})
         # SearXNG URL (task #103): from Settings (cfg.searxngUrl) if the API sends it, else
         # the GONEXT_SEARXNG_URL env fallback inside _web_search_impl. Keyless either way.
-        result = _web_search_impl(query, searxng_url=(cfg.get("searxngUrl") or "").strip())
+        # Search model (#105): when configured, web_search synthesizes a cited answer with it.
+        result = _web_search_impl(
+            query,
+            searxng_url=(cfg.get("searxngUrl") or "").strip(),
+            search_base_url=(cfg.get("searchBaseURL") or "").strip(),
+            search_model_id=(cfg.get("searchModelId") or "").strip(),
+        )
         _log(f"web_search {query[:60]!r} → {result[:80]}")
         _last_obs["text"] = result
         if result and not result.startswith("Error"):

package/package.json

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