@tiens.nguyen/gonext-local-worker 1.0.247 → 1.0.250

package/gonext-local-worker.mjs

@@ -867,7 +867,7 @@ async function performHttpMeasurement(params) {
  * 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, extraEnv, abortSignal) {
+function runProcessWithStreamingStdout(cmd, cmdArgs, stdinStr, timeoutMs, onLine, extraEnv, abortSignal, onTimeout) {
   return new Promise((resolve, reject) => {
     const spawnOpts = { stdio: ["pipe", "pipe", "pipe"] };
     if (extraEnv && Object.keys(extraEnv).length > 0) {
@@ -878,10 +878,36 @@ function runProcessWithStreamingStdout(cmd, cmdArgs, stdinStr, timeoutMs, onLine
     let lineBuffer = "";
     let timedOut = false;
     let aborted = false;
-    const timer = setTimeout(() => {
+    let closed = false;
+    let timerLive = true;
+    // On the time budget: with no onTimeout handler (probe/legacy) this is a hard cap —
+    // kill immediately. With a handler (task #81, interactive terminal) ask the user
+    // whether to keep waiting; the child keeps running/streaming during the ~60s prompt.
+    // "Keep waiting" disables the cap for the rest of the run; No / no-answer kills it.
+    const fireTimeout = async () => {
+      if (!timerLive || closed || aborted) return;
+      if (typeof onTimeout !== "function") {
+        timedOut = true;
+        timerLive = false;
+        child.kill("SIGKILL");
+        return;
+      }
+      let extend = false;
+      try {
+        extend = await onTimeout();
+      } catch {
+        extend = false;
+      }
+      if (closed || aborted || !timerLive) return; // finished/cancelled during the prompt
+      if (extend) {
+        timerLive = false; // ignore the time budget for the rest of this run
+        return;
+      }
       timedOut = true;
+      timerLive = false;
       child.kill("SIGKILL");
-    }, timeoutMs);
+    };
+    const timer = setTimeout(fireTimeout, timeoutMs);
     // User-requested cancel (gonext Ctrl+C): kill the Python agent so it stops burning
     // steps/tokens. On close we resolve cleanly (not reject) — the caller checks the
     // cancel flag and leaves the job in its already-"cancelled" state.
@@ -913,10 +939,14 @@ function runProcessWithStreamingStdout(cmd, cmdArgs, stdinStr, timeoutMs, onLine
       stderr += d;
     });
     child.on("error", (e) => {
+      closed = true;
+      timerLive = false;
       clearTimeout(timer);
       reject(e);
     });
     child.on("close", (code) => {
+      closed = true;
+      timerLive = false;
       clearTimeout(timer);
       if (abortSignal) abortSignal.removeEventListener?.("abort", onAbort);
       // Drain any remaining buffered line
@@ -1925,19 +1955,35 @@ async function runAgentChatJob(job) {
       // re-validates). Terminal = its launch cwd; web = the temp scratch folder.
       activeWorkspace: jobActiveWorkspace,
     });
-    // 30 min max for an agent run: multi-step ReAct on a 14B/31B with a cold prompt
-    // cache — or a remote Ollama box on slow GPU cold-loading a big model — can run
-    // for many minutes per step. Must stay BELOW the web client's hard WS deadline
-    // (1_860_000 ms) so our clean timeout error reaches the user instead of a generic
-    // WS timeout. On expiry the python child is SIGKILLed, which also shows up as a
-    // BrokenPipeError in the model server log (expected). Liveness during long model
-    // calls comes from the python heartbeat (a keepalive step chunk every 45s), not
-    // from this cap.
-    const timeoutMs = 1_800_000;
+    // Agent run time budget (task #81). Default 60 min; user-configurable in web Settings
+    // (agentTimeoutMinutes → payload.agentTimeoutMs). Multi-step ReAct on a 14B/31B with a
+    // cold prompt cache — or a remote Ollama box slow-cold-loading a big model — can run
+    // for many minutes per step, so a generous budget is normal. On expiry the TERMINAL
+    // (interactive) asks the user whether to keep waiting (onAgentTimeout below); "yes"
+    // ignores the budget for the rest of the run. WEB has no picker AND a hard WS deadline
+    // (1_860_000 ms), so it's capped at 30 min and just aborts — our clean timeout error
+    // then reaches the user instead of a generic WS timeout. On a hard stop the python
+    // child is SIGKILLed (shows as a BrokenPipeError in the model server log — expected).
+    // Liveness during long model calls comes from the python heartbeat (a keepalive step
+    // chunk every 45s), not from this cap.
+    const DEFAULT_AGENT_TIMEOUT_MS = 3_600_000; // 1 hour
+    const WEB_AGENT_TIMEOUT_CAP_MS = 1_800_000; // stay under the web WS deadline
+    const isInteractiveTimeout = payload?.interactiveApproval === true;
+    const requestedTimeoutMs =
+      Number.isFinite(payload?.agentTimeoutMs) && payload.agentTimeoutMs > 0
+        ? payload.agentTimeoutMs
+        : DEFAULT_AGENT_TIMEOUT_MS;
+    const timeoutMs = isInteractiveTimeout
+      ? requestedTimeoutMs
+      : Math.min(requestedTimeoutMs, WEB_AGENT_TIMEOUT_CAP_MS);
 
     let inThink = false;
     let finalText = "";
     let answerStreamed = false; // an answer_stream delta already delivered the visible text
+    // Task #83: running total of prompt tokens sent to the agent CODE model. Updated on
+    // each python "tokens" event, persisted to the job doc (Mongo) so the REPL can show
+    // it live and it survives on the completed job.
+    let latestCodeTokens = 0;
     // 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
@@ -1985,6 +2031,45 @@ async function runAgentChatJob(job) {
     }, 1500);
     cancelAc.signal.addEventListener("abort", () => { cancelled = true; }, { once: true });
 
+    // Task #81: when the time budget is reached in the TERMINAL, ask the user whether to
+    // keep waiting instead of just aborting. Reuses the #67 approval plumbing
+    // (approval-request → poll approvalDecision) with a __TIMEOUT__:: sentinel the REPL
+    // recognizes and renders as a Yes/No picker (auto-No at 60s). Returns true = keep
+    // waiting (disable the cap), false = stop. Only wired for interactive jobs (web never
+    // reaches here — it isn't passed as onTimeout).
+    const onAgentTimeout = async () => {
+      if (!isInteractiveTimeout || !jobId) return false;
+      const approvalId = `timeout-${Date.now()}`;
+      const mins = Math.round(timeoutMs / 60000);
+      const command = `__TIMEOUT__::The agent has run for ${mins} min (the time budget). Keep waiting?`;
+      try {
+        const r = await workerFetch(`/api/worker/jobs/${jobId}/approval-request`, {
+          method: "POST",
+          body: JSON.stringify({ id: approvalId, command }),
+        });
+        if (!r.ok) return false;
+      } catch {
+        return false;
+      }
+      // Poll for the user's Yes/No up to ~65s (the REPL auto-answers No at 60s).
+      const deadline = Date.now() + 65_000;
+      while (Date.now() < deadline) {
+        if (cancelAc.signal.aborted) return false;
+        await new Promise((r) => setTimeout(r, 1500));
+        try {
+          const r = await workerFetch(`/api/worker/jobs/${jobId}`);
+          if (r.ok) {
+            const j = await r.json().catch(() => ({}));
+            const dec = j?.approvalDecision;
+            if (dec && dec.id === approvalId) return dec.allow === true;
+          }
+        } catch {
+          /* transient poll error — keep trying */
+        }
+      }
+      return false; // no answer in time → treat as No (stop)
+    };
+
     try {
     await runProcessWithStreamingStdout(python, [scriptPath], input, timeoutMs, (event) => {
       if (event.type === "log" && typeof event.text === "string") {
@@ -2025,6 +2110,19 @@ async function runAgentChatJob(job) {
         }
         enqueueText(event.text);
         answerStreamed = true;
+      } else if (event.type === "tokens" && Number.isFinite(event.codeInput)) {
+        // Prompt tokens sent to the agent CODE model (task #83). Persist the running
+        // total to the job doc so it's in Mongo and the REPL can render it live. Steps
+        // are seconds apart, so a fire-and-forget PATCH per event is cheap; it only
+        // touches agentCodeTokens (never resultText/jobStatus), so it can't race the
+        // chunk/completed writes.
+        if (event.codeInput > latestCodeTokens) {
+          latestCodeTokens = event.codeInput;
+          workerFetch(`/api/worker/jobs/${jobId}`, {
+            method: "PATCH",
+            body: JSON.stringify({ agentCodeTokens: latestCodeTokens }),
+          }).catch(() => {});
+        }
       } else if (event.type === "final" && typeof event.text === "string") {
         closeStreamFence();
         if (inThink) {
@@ -2039,7 +2137,7 @@ async function runAgentChatJob(job) {
           enqueueText(event.text);
         }
       }
-    }, pdfEnv, cancelAc.signal);
+    }, pdfEnv, cancelAc.signal, isInteractiveTimeout ? onAgentTimeout : undefined);
     } finally {
       clearInterval(cancelPoll);
     }
@@ -2075,6 +2173,7 @@ async function runAgentChatJob(job) {
         // the whole story.
         resultText: answerStreamed ? fullText : finalText || fullText,
         tokenCount: Math.max(1, Math.ceil((finalText || fullText).length / 4)),
+        ...(latestCodeTokens > 0 ? { agentCodeTokens: latestCodeTokens } : {}),
         totalTimeSeconds,
       }),
     });

package/gonext-repl.mjs

@@ -122,6 +122,12 @@ const SPINNERS = [
 // green, cyan, blue, indigo, pink, amber).
 const WAIT_COLORS_256 = [120, 87, 111, 147, 218, 221];
 const color256 = (n, s) => `\x1b[38;5;${n}m${s}\x1b[0m`;
+// Compact token count: 950 → "950", 12300 → "12.3k", 1500000 → "1.5M" (task #83).
+const fmtTokens = (n) => {
+  if (n < 1000) return String(n);
+  if (n < 1_000_000) return `${(n / 1000).toFixed(n < 100_000 ? 1 : 0)}k`;
+  return `${(n / 1_000_000).toFixed(1)}M`;
+};
 const BULLET = "●"; // a completed action
 
 // ---------- flags ----------
@@ -784,7 +790,21 @@ function onApprovalKey(key) {
 // Returns { allow, dontAsk } — dontAsk is only ever true for the max-step "don't ask
 // again this session" choice (the caller then stops sending the prompt).
 const MAXSTEP_PREFIX = "__MAXSTEP__::";
+const TIMEOUT_PREFIX = "__TIMEOUT__::";
 async function approvalPrompt(command) {
+  // Time-budget prompt (task #81): the agent hit its wall-clock budget. Ask whether to
+  // keep waiting; auto-answer No after 60s of no input so the run can't hang forever.
+  if (command.startsWith(TIMEOUT_PREFIX)) {
+    const label = command.slice(TIMEOUT_PREFIX.length);
+    if (!process.stdin.isTTY) return { allow: false, dontAsk: false };
+    process.stdout.write("\n" + yellow("⏳ " + label) + dim("  (no answer in 60s = stop)") + "\n");
+    const idx = await pickFromList(
+      ["Yes, keep waiting", "No, stop now"],
+      0,
+      { timeoutMs: 60000, timeoutIndex: 1 }
+    );
+    return { allow: idx === 0, dontAsk: false };
+  }
   const isMax = command.startsWith(MAXSTEP_PREFIX);
   if (isMax) {
     const label = command.slice(MAXSTEP_PREFIX.length);
@@ -857,7 +877,7 @@ function onListKey(key) {
     finishList(-1);
   }
 }
-function pickFromList(items, initialSel = 0) {
+function pickFromList(items, initialSel = 0, opts = {}) {
   return new Promise((resolve) => {
     if (!process.stdin.isTTY || items.length === 0) {
       resolve(-1);
@@ -868,6 +888,20 @@ function pickFromList(items, initialSel = 0) {
     listResolve = resolve;
     listPickerActive = true;
     drawList(false);
+    // Optional auto-resolve after opts.timeoutMs (task #81 time-budget prompt): if the
+    // user doesn't choose in time, finish with opts.timeoutIndex (default -1). Wrap
+    // listResolve so any real selection clears the timer.
+    if (opts && opts.timeoutMs > 0) {
+      const to = setTimeout(
+        () => finishList(opts.timeoutIndex ?? -1),
+        opts.timeoutMs
+      );
+      const orig = listResolve;
+      listResolve = (v) => {
+        clearTimeout(to);
+        orig(v);
+      };
+    }
   });
 }
 
@@ -1037,6 +1071,9 @@ async function runAgentTurn(history) {
   // poll figure out how much of the FINAL answer is still unshown even when resultText
   // was replaced (not extended) on completion. See the completed-branch recovery below.
   let liveAnswer = "";
+  // Running total of prompt tokens sent to the agent CODE model this turn (task #83),
+  // read from the job doc each poll. Rendered on the thinking line after the playful word.
+  let latestCodeTokens = 0;
   // First few KB of the raw stream as consumed — a cheap fingerprint to verify the
   // completed resultText really EXTENDS what we streamed (an old worker replaces it
   // with the shorter bare answer, which must not be sliced by shownChars).
@@ -1111,9 +1148,12 @@ async function runAgentTurn(history) {
     // Line 2 (indented): the SPINNER + the playful word together, both in the cycling
     // color — the spinner belongs with the word (dot on the label line, spinner leading
     // the flavor line).
+    // Task #83: after the playful word, show the running agent-code-model token count
+    // (dim), e.g. "  ⠙ Caffeinating… · 12.3k tok". Only once we've seen some tokens.
+    const tokLabel = latestCodeTokens > 0 ? dim(` · ${fmtTokens(latestCodeTokens)} tok`) : "";
     process.stdout.write(
       `${green(BULLET)} ${green(`${fit(primary)}… (${secs}s)`)}` +
-        "\n" + `  ${color256(wc, `${glyph} ${thinkWord}…`)}`
+        "\n" + `  ${color256(wc, `${glyph} ${thinkWord}…`)}${tokLabel}`
     );
     statusShown = true;
   };
@@ -1379,6 +1419,10 @@ async function runAgentTurn(history) {
         continue;
       }
       jobRunning = job.jobStatus === "running";
+      // Live agent-code-model token total (task #83) — monotonic, shown on the thinking line.
+      if (Number.isFinite(job.agentCodeTokens) && job.agentCodeTokens > latestCodeTokens) {
+        latestCodeTokens = job.agentCodeTokens;
+      }
       const text = typeof job.resultText === "string" ? job.resultText : "";
       if (job.jobStatus === "completed") {
         // The job can flip to "completed" between polls with authoritative resultText that

package/gonext_agent_chat.py

@@ -3936,6 +3936,10 @@ def run_agent_chat(cfg):
     # literal messages array sent to /v1/chat/completions.
     class _LoggingModel(OpenAIServerModel):
         def __init__(self, *a, stream_agent=False, **kw):
+            # Running total of PROMPT (input) tokens sent to the CODE model across the
+            # turn (task #83). Only this wrapper counts — the chat/brain helper calls
+            # (_chat_completion) don't route through here, so this is "code model only".
+            self._code_tokens_total = 0
             # stream_agent: request the completion with stream=True and reassemble the
             # deltas into one message. Enabled for Ollama, where a long single-shot
             # (non-stream) generation sends nothing until the very end — a reverse proxy
@@ -4129,6 +4133,29 @@ def run_agent_chat(cfg):
                 token_usage=TokenUsage(input_tokens=in_tok, output_tokens=out_tok),
             )
 
+        def _estimate_prompt_tokens(self, args, kwargs):
+            """Fallback token estimate (~4 chars/token) from the outgoing messages, used
+            only when the model server doesn't report prompt usage (task #83)."""
+            msgs = kwargs.get("messages")
+            if msgs is None and args:
+                msgs = args[0]
+            if not msgs:
+                return 0
+            chars = 0
+            try:
+                for m in msgs:
+                    c = m.get("content") if isinstance(m, dict) else getattr(m, "content", None)
+                    if isinstance(c, list):  # multimodal content parts
+                        for part in c:
+                            t = part.get("text") if isinstance(part, dict) else None
+                            if isinstance(t, str):
+                                chars += len(t)
+                    elif isinstance(c, str):
+                        chars += len(c)
+            except Exception:  # noqa: BLE001
+                return 0
+            return max(1, chars // 4)
+
         def generate(self, *args, **kwargs):
             # Two safeguards on each step's reply BEFORE smolagents parses it for the
             # code block / final_answer:
@@ -4199,6 +4226,23 @@ def run_agent_chat(cfg):
                     raise last_err
             finally:
                 hb_stop.set()
+            # Task #83: tally PROMPT tokens sent to the code model this step, then emit
+            # the running total so the worker can persist it (Mongo) and the REPL can
+            # show it live. Best-effort — never let accounting break the run.
+            try:
+                tu = getattr(msg, "token_usage", None)
+                step_in = int(getattr(tu, "input_tokens", 0) or 0) if tu else 0
+                if step_in <= 0:
+                    step_in = self._estimate_prompt_tokens(args, kwargs)
+                if step_in > 0:
+                    self._code_tokens_total += step_in
+                    _emit({
+                        "type": "tokens",
+                        "codeInput": self._code_tokens_total,
+                        "stepInput": step_in,
+                    })
+            except Exception:  # noqa: BLE001
+                pass
             try:
                 content = getattr(msg, "content", None)
                 if content is None:

package/package.json

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