@tiens.nguyen/gonext-local-worker 1.0.48 → 1.0.50

package/gonext-local-worker.mjs

@@ -664,6 +664,73 @@ async function performHttpMeasurement(params) {
   return { response, category, errorMessage };
 }
 
+/**
+ * Spawn a child process, feed it stdin, and call onLine for each NDJSON stdout
+ * line as they arrive. Resolves when the process exits cleanly; rejects on
+ * non-zero exit or timeout. stderr is collected and appended to error messages.
+ */
+function runProcessWithStreamingStdout(cmd, cmdArgs, stdinStr, timeoutMs, onLine) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, cmdArgs, { stdio: ["pipe", "pipe", "pipe"] });
+    let stderr = "";
+    let lineBuffer = "";
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGKILL");
+    }, timeoutMs);
+    child.stdout.on("data", (d) => {
+      lineBuffer += d.toString("utf8");
+      const parts = lineBuffer.split("\n");
+      lineBuffer = parts.pop() ?? "";
+      for (const line of parts) {
+        const trimmed = line.trim();
+        if (trimmed) {
+          try {
+            onLine(JSON.parse(trimmed));
+          } catch {
+            /* ignore non-JSON */
+          }
+        }
+      }
+    });
+    child.stderr.on("data", (d) => {
+      stderr += d;
+    });
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      // Drain any remaining buffered line
+      const remaining = lineBuffer.trim();
+      if (remaining) {
+        try {
+          onLine(JSON.parse(remaining));
+        } catch {
+          /* ignore */
+        }
+      }
+      if (timedOut) {
+        reject(new Error(`agent chat timed out after ${timeoutMs} ms`));
+        return;
+      }
+      if (code !== 0) {
+        reject(
+          new Error(
+            `agent chat exited ${code}${stderr.trim() ? `: ${stderr.trim().slice(0, 500)}` : ""}`
+          )
+        );
+        return;
+      }
+      resolve();
+    });
+    child.stdin.write(stdinStr);
+    child.stdin.end();
+  });
+}
+
 /** Run a child process, feed it stdin, resolve with stdout (rejects on non-zero/timeout). */
 function runProcessWithStdin(cmd, cmdArgs, stdinStr, timeoutMs) {
   return new Promise((resolve, reject) => {
@@ -1091,6 +1158,143 @@ async function runOcrJob(job) {
   }
 }
 
+async function runAgentChatJob(job) {
+  const { jobId, payload } = job;
+  const start = Date.now();
+  const runRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+    method: "PATCH",
+    body: JSON.stringify({ jobStatus: "running" }),
+  });
+  await ensureWorkerOk(runRes, `mark running agent_chat jobId=${jobId}`);
+
+  let buf = "";
+  let flushTimer = null;
+  let fullText = "";
+  let flushTail = Promise.resolve();
+  const CHUNK_DEBOUNCE_MS = 80;
+  const CHUNK_MAX_BUF = 6144;
+
+  const flushChunks = async () => {
+    const t = buf;
+    buf = "";
+    if (!t) return;
+    const res = await workerFetch(CHUNK_PATH, {
+      method: "POST",
+      body: JSON.stringify({ jobId, text: t }),
+    });
+    if (!res.ok && res.status !== 204) {
+      const snippet = (await res.text().catch(() => "")).trim().slice(0, 400);
+      const benign409 =
+        res.status === 409 && snippet.includes('"jobStatus":"completed"');
+      if (!benign409) {
+        console.error(
+          `[gonext-worker] agent_chat job-chunk POST failed status=${res.status} jobId=${jobId}` +
+            (snippet ? ` response=${snippet}` : "")
+        );
+      }
+    }
+  };
+
+  const enqueueText = (s) => {
+    if (!s) return;
+    fullText += s;
+    buf += s;
+    if (buf.length >= CHUNK_MAX_BUF) {
+      if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
+      flushTail = flushTail.then(() => flushChunks()).catch((err) => {
+        console.error("[gonext-worker] agent_chat chunk flush error:", err);
+      });
+      return;
+    }
+    if (!flushTimer) {
+      flushTimer = setTimeout(() => {
+        flushTimer = null;
+        flushTail = flushTail.then(() => flushChunks()).catch((err) => {
+          console.error("[gonext-worker] agent_chat chunk flush error:", err);
+        });
+      }, CHUNK_DEBOUNCE_MS);
+    }
+  };
+
+  try {
+    const python =
+      (process.env.GONEXT_PROBE_PYTHON ?? process.env.GONEXT_MLX_LM_PYTHON ?? "")
+        .trim() || "python3";
+    const scriptPath = join(WORKER_DIR, "gonext_agent_chat.py");
+    const input = JSON.stringify({
+      messages: payload?.messages ?? [],
+      agentBaseURL: payload?.agentBaseURL ?? "",
+      agentApiKey: payload?.agentApiKey ?? "",
+      agentModelId: payload?.agentModelId ?? "",
+      tools: payload?.tools ?? ["http_request"],
+      maxSteps: payload?.maxSteps ?? 10,
+    });
+    const timeoutMs = 300_000; // 5 min max for an agent run
+
+    let inThink = false;
+    let finalText = "";
+
+    await runProcessWithStreamingStdout(python, [scriptPath], input, timeoutMs, (event) => {
+      if (event.type === "step" && typeof event.text === "string") {
+        if (!inThink) {
+          inThink = true;
+          enqueueText("<think>");
+        }
+        enqueueText(event.text + "\n");
+      } else if (event.type === "final" && typeof event.text === "string") {
+        if (inThink) {
+          inThink = false;
+          enqueueText("</think>");
+        }
+        finalText = event.text;
+        enqueueText(event.text);
+      }
+    });
+
+    if (inThink) {
+      enqueueText("</think>");
+    }
+
+    if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
+    await flushTail;
+    await flushChunks();
+
+    const totalTimeSeconds = (Date.now() - start) / 1000;
+    const doneRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        jobStatus: "completed",
+        resultText: finalText || fullText,
+        tokenCount: Math.max(1, Math.ceil((finalText || fullText).length / 4)),
+        totalTimeSeconds,
+      }),
+    });
+    await ensureWorkerOk(doneRes, `complete agent_chat PATCH jobId=${jobId}`);
+    console.log(`[gonext-worker] completed agent_chat ${jobId} (${totalTimeSeconds.toFixed(1)}s)`);
+  } catch (e) {
+    if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
+    await flushTail;
+    await flushChunks().catch(() => {});
+    const message = e instanceof Error ? e.message : String(e);
+    const failRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        jobStatus: "failed",
+        errorMessage: message,
+        totalTimeSeconds: (Date.now() - start) / 1000,
+      }),
+    });
+    if (!failRes.ok) {
+      const snippet = (await failRes.text().catch(() => "")).trim().slice(0, 500);
+      console.error(
+        `[gonext-worker] agent_chat fail PATCH also failed ${failRes.status} jobId=${jobId}` +
+          (snippet ? ` response=${snippet}` : "")
+      );
+    }
+    console.error(`[gonext-worker] failed agent_chat ${jobId}:`, message);
+  }
+}
+
 function normalizeBaseUrl(raw) {
   return typeof raw === "string" ? raw.trim().replace(/\/+$/, "") : "";
 }
@@ -1523,6 +1727,10 @@ async function pollOnce() {
       await runHttpProbeJob(job);
       return;
     }
+    if (job.jobType === "agent_chat") {
+      await runAgentChatJob(job);
+      return;
+    }
     const isOcrByType = job.jobType === "ocr";
     const isOcrByPayload =
       job.payload &&

package/gonext_agent_chat.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""
+gonext_agent_chat.py — streaming agent chat for the gonext local worker.
+
+Reads on stdin:
+  {
+    "messages": [{"role": "system"|"user"|"assistant", "content": str}, ...],
+    "agentBaseURL": str,
+    "agentApiKey": str,
+    "agentModelId": str,
+    "tools": ["http_request"],   # v1: only http_request
+    "maxSteps": int              # default 10
+  }
+
+Emits NDJSON lines on stdout per step/final:
+  {"type": "step",  "text": "<tool call summary>"}
+  {"type": "final", "text": "<agent final answer>"}
+
+All smolagents/rich console output goes to stderr so stdout stays clean.
+
+TLS: uses certifi CA bundle when available (macOS may lack system certs for
+Python urllib), with fallback to the default bundle.
+"""
+import contextlib
+import json
+import sys
+import urllib.request
+import urllib.error
+
+# Capture stdout before anything can redirect it.  _emit() must always write
+# to the real fd-1 so the Node worker's readline loop sees NDJSON even while
+# contextlib.redirect_stdout(sys.stderr) is active inside agent.run().
+_REAL_STDOUT = sys.stdout
+
+
+def _ssl_context():
+    import ssl
+    try:
+        import certifi
+        return ssl.create_default_context(cafile=certifi.where())
+    except ImportError:
+        return ssl.create_default_context()
+
+
+def _http_request_impl(method, url, headers=None, body=None, timeout=15):
+    req = urllib.request.Request(url, method=method.upper())
+    if headers:
+        for k, v in headers.items():
+            req.add_header(k, v)
+    data = body.encode() if isinstance(body, str) and body else (body or None)
+    try:
+        ctx = _ssl_context()
+        with urllib.request.urlopen(req, data=data, timeout=timeout, context=ctx) as resp:
+            status = resp.status
+            raw = resp.read(4096)
+            snippet = raw.decode("utf-8", errors="replace")[:2000]
+            return f"HTTP {status}\n{snippet}"
+    except urllib.error.HTTPError as e:
+        raw = e.read(512)
+        snippet = raw.decode("utf-8", errors="replace")
+        return f"HTTP {e.code} {e.reason}\n{snippet}"
+    except Exception as e:  # noqa: BLE001
+        return f"Error: {e}"
+
+
+def run_agent_chat(cfg):
+    try:
+        from smolagents import CodeAgent, OpenAIServerModel, tool
+    except Exception as e:  # noqa: BLE001
+        _emit({"type": "final", "text": f"[smolagents not installed: {e}]"})
+        return
+
+    messages = cfg.get("messages") or []
+    agent_base_url = cfg.get("agentBaseURL") or ""
+    agent_api_key = cfg.get("agentApiKey") or "local"
+    agent_model_id = cfg.get("agentModelId") or ""
+    max_steps = int(cfg.get("maxSteps") or 10)
+
+    # Build the task from the last user message; use prior turns as context.
+    task_text = ""
+    context_lines = []
+    for m in messages:
+        role = m.get("role", "")
+        content = m.get("content", "")
+        if role == "user":
+            task_text = content
+        elif role == "assistant":
+            context_lines.append(f"Assistant previously said: {content[:500]}")
+
+    if not task_text:
+        _emit({"type": "final", "text": "[No user message found in history]"})
+        return
+
+    if context_lines:
+        task_text = "\n".join(context_lines) + "\n\nNow answer: " + task_text
+
+    @tool
+    def http_request(method: str, url: str, headers: str = "", body: str = "") -> str:
+        """Perform an HTTP request and return the status code and a body preview.
+
+        Args:
+            method: HTTP method (GET, POST, PUT, DELETE, etc.)
+            url: Full URL to request
+            headers: Optional JSON object string of request headers
+            body: Optional request body string
+        """
+        parsed_headers = {}
+        if headers:
+            try:
+                parsed_headers = json.loads(headers)
+            except Exception:  # noqa: BLE001
+                pass
+        return _http_request_impl(method, url, parsed_headers, body or None)
+
+    def step_callback(step_log):
+        try:
+            parts = []
+            # tool_calls is a list of ToolCall(name, arguments, id)
+            tool_calls = getattr(step_log, "tool_calls", None) or []
+            for tc in tool_calls:
+                name = getattr(tc, "name", str(tc))
+                args = getattr(tc, "arguments", None)
+                arg_str = json.dumps(args) if args is not None else ""
+                parts.append(f"Tool: {name}({arg_str})")
+            observations = getattr(step_log, "observations", None)
+            if observations:
+                parts.append(f"→ {str(observations)[:400]}")
+            error = getattr(step_log, "error", None)
+            if error:
+                parts.append(f"Error: {error}")
+            if not parts:
+                parts.append(str(step_log)[:300])
+            text = " ".join(parts)
+        except Exception as e:  # noqa: BLE001
+            text = f"Step: {e}"
+
+        _emit({"type": "step", "text": text})
+
+    try:
+        model = OpenAIServerModel(
+            model_id=agent_model_id,
+            api_base=agent_base_url,
+            api_key=agent_api_key,
+        )
+        agent = CodeAgent(
+            tools=[http_request],
+            model=model,
+            max_steps=max_steps,
+            step_callbacks=[step_callback],
+        )
+        with contextlib.redirect_stdout(sys.stderr):
+            result = agent.run(task_text)
+        final_text = str(result).strip()
+        _emit({"type": "final", "text": final_text})
+    except Exception as e:  # noqa: BLE001
+        _emit({"type": "final", "text": f"[Agent error: {e}]"})
+
+
+def _emit(obj):
+    """Write one NDJSON line to the real stdout and flush immediately.
+    Uses _REAL_STDOUT (captured at import time) so redirect_stdout blocks
+    inside agent.run() don't accidentally route events to stderr."""
+    _REAL_STDOUT.write(json.dumps(obj) + "\n")
+    _REAL_STDOUT.flush()
+
+
+def main():
+    try:
+        cfg = json.load(sys.stdin)
+    except Exception as e:  # noqa: BLE001
+        _emit({"type": "final", "text": f"[Invalid input: {e}]"})
+        return
+    run_agent_chat(cfg)
+
+
+if __name__ == "__main__":
+    main()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gonext-local-worker",
-  "version": "1.0.48",
+  "version": "1.0.50",
   "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",
@@ -23,6 +23,7 @@
   "files": [
     "gonext-local-worker.mjs",
     "gonext_probe_agent.py",
+    "gonext_agent_chat.py",
     "README.md",
     "launchd/"
   ],