@tiens.nguyen/gonext-local-worker 1.0.246 → 1.0.249

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
@@ -1879,6 +1909,9 @@ async function runAgentChatJob(job) {
       // REPL's "I can show a picker" signal (else python keeps hard-blocking, as on web).
       jobId,
       interactiveApproval: payload?.interactiveApproval === true,
+      // Session opt-in (task #80): auto-extend past the step budget without re-prompting
+      // (the REPL sets this once the user picks "yes, don't ask again").
+      alwaysExtendOnMaxStep: payload?.alwaysExtendOnMaxStep === true,
       // Auto-test mode (/test-auto): the agent verifies its work and fixes until it passes.
       autoTest: payload?.autoTest === true,
       // Deploy target chosen via the terminal /server picker (task #69). Host/user only.
@@ -1922,15 +1955,27 @@ 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 = "";
@@ -1982,6 +2027,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") {
@@ -2036,7 +2120,7 @@ async function runAgentChatJob(job) {
           enqueueText(event.text);
         }
       }
-    }, pdfEnv, cancelAc.signal);
+    }, pdfEnv, cancelAc.signal, isInteractiveTimeout ? onAgentTimeout : undefined);
     } finally {
       clearInterval(cancelPoll);
     }

package/gonext-repl.mjs

@@ -778,8 +778,39 @@ function onApprovalKey(key) {
 // Show the picker and resolve to the user's choice. Non-TTY (piped) can't pick → deny
 // (safe). Auto-denies after ~170s so an absent user never hangs the turn (and stays
 // under the python side's 180s wait); Enter is instant since Yes is preselected.
-function approvalPrompt(command) {
-  return new Promise((resolve) => {
+// The command carries a "__MAXSTEP__::<message>" sentinel when it's the step-budget
+// continue prompt (task #80) rather than a risky-command approval. That case shows a
+// 3-option picker (Yes / Yes-don't-ask-again / No); a normal command shows Yes/No.
+// 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);
+    if (!process.stdin.isTTY) return { allow: false, dontAsk: false };
+    process.stdout.write("\n" + yellow("⏭ " + label) + "\n");
+    const idx = await pickFromList(
+      ["Yes, keep going", "Yes, and don't ask again this session", "No, stop here"],
+      0
+    );
+    return { allow: idx === 0 || idx === 1, dontAsk: idx === 1 };
+  }
+  const allow = await new Promise((resolve) => {
     if (!process.stdin.isTTY) {
       process.stdout.write(dim(`\n(approval needed for: ${command} — no interactive terminal, skipping)\n`));
       resolve(false);
@@ -799,6 +830,7 @@ function approvalPrompt(command) {
       orig(v);
     };
   });
+  return { allow, dontAsk: false };
 }
 // Generic arrow-key list picker (↑/↓ + Enter) — used by /server so you navigate instead
 // of typing a number. Same mechanism as the Yes/No approval picker above, generalized to
@@ -839,7 +871,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);
@@ -850,6 +882,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);
+      };
+    }
   });
 }
 
@@ -860,6 +906,10 @@ let sessionCodingModel = "";
 // and fixes → re-tests until it passes before finishing. Default off; remembered per
 // folder in the session file; sent to /agent-ask as autoTest so python drives the loop.
 let sessionTestAuto = false;
+// Step-budget opt-out (task #80): set once the user picks "yes, don't ask again" at a
+// max-step prompt. Session-scoped (not persisted per folder); sent to /agent-ask each turn
+// so the agent auto-extends past the step budget without prompting again.
+let alwaysExtendOnMaxStep = false;
 // Deploy target chosen via /server (task #69): {name, host, user} or null. Session-scoped;
 // sent to /agent-ask as deployServer so the agent deploys to this host with KEY auth.
 let selectedServer = null;
@@ -965,6 +1015,9 @@ async function runAgentTurn(history) {
       // The terminal can show a Yes/No picker → the agent PAUSES on a risky command and
       // asks instead of hard-blocking it (interactive command-approval gate).
       interactiveApproval: true,
+      // Step-budget opt-out (task #80): once the user chose "don't ask again", auto-extend
+      // past the step budget without prompting.
+      ...(alwaysExtendOnMaxStep ? { alwaysExtendOnMaxStep: true } : {}),
       // Auto-test mode (/test-auto): the agent verifies its work and fixes until it passes.
       ...(sessionTestAuto ? { autoTest: true } : {}),
       // Deploy target chosen via /server — host/user only (no secret), for key-auth deploys.
@@ -1409,7 +1462,13 @@ async function runAgentTurn(history) {
       ) {
         lastApprovalId = job.pendingApproval.id;
         clearStatus();
-        const allow = await approvalPrompt(job.pendingApproval.command || "");
+        const { allow, dontAsk } = await approvalPrompt(job.pendingApproval.command || "");
+        // "Yes, don't ask again this session" (max-step prompt only): remember it so every
+        // later turn sends alwaysExtendOnMaxStep and the agent auto-extends silently (#80).
+        if (dontAsk) {
+          alwaysExtendOnMaxStep = true;
+          process.stdout.write(dim("  (won't ask again about the step budget this session)\n"));
+        }
         try {
           await fetch(`${apiBase}/api/worker/jobs/${jobId}/approval`, {
             method: "POST",

package/gonext_agent_chat.py

@@ -2340,7 +2340,10 @@ def _ws_request_approval(api_base, worker_key, job_id, command, reason):
     except Exception as e:  # noqa: BLE001
         _log(f"approval-request failed: {e} — treating as deny")
         return False
-    _emit({"type": "step", "text": f"Awaiting your approval to run: {command[:70]}"})
+    if command.startswith("__MAXSTEP__::"):
+        _emit({"type": "step", "text": "Awaiting your choice: continue past the step budget?"})
+    else:
+        _emit({"type": "step", "text": f"Awaiting your approval to run: {command[:70]}"})
     deadline = _t.time() + 180  # 3 min; absent user → deny (never auto-run something risky)
     while _t.time() < deadline:
         _t.sleep(1.2)
@@ -5396,8 +5399,38 @@ def run_agent_chat(cfg):
                 _log(f"compact system prompt unavailable ({_e}); using smolagents default")
         agent = _ToolAgent(**agent_kwargs)
         _agent_ref["a"] = agent  # let step_callback trim this agent's step memory (#63)
+        # At the step budget the run ends WITHOUT final_answer (_maxsteps_partial hit). Offer
+        # to keep going instead of dead-ending (task #80): a terminal user says Yes → extend
+        # the budget to a large ceiling and CONTINUE with the existing memory (reset=False,
+        # so the model keeps all prior observations). smolagents captures max_steps as a
+        # LOCAL at run() time, so we can't bump it mid-loop — we re-enter run() with a raised
+        # agent.max_steps instead. The real bound is the 30-min worker job cap, so 1000 just
+        # means "run to completion". 'Yes, don't ask again' is handled REPL-side: it flips a
+        # session flag so the NEXT turn arrives with alwaysExtendOnMaxStep and we auto-extend
+        # without prompting.
+        _MAXSTEP_CEILING = 1000
+        _always_extend = bool(cfg.get("alwaysExtendOnMaxStep"))
         with contextlib.redirect_stdout(sys.stderr):
             result = agent.run(task_with_hint)
+            while _maxsteps_partial.get("hit"):
+                if _always_extend:
+                    _log(f"max-steps reached → auto-extending to {_MAXSTEP_CEILING} "
+                         "(don't-ask-again session flag)")
+                    _do_extend = True
+                elif _interactive_approval and _job_id and pdf_api_base and pdf_worker_key:
+                    _do_extend = _ws_request_approval(
+                        pdf_api_base, pdf_worker_key, _job_id,
+                        f"__MAXSTEP__::Reached the step budget ({agent.max_steps}). "
+                        "Keep going?", "max-steps")
+                else:
+                    _do_extend = False  # web / no interactive channel → current wrap-up
+                if not _do_extend:
+                    break
+                _maxsteps_partial["hit"] = False
+                agent.max_steps = _MAXSTEP_CEILING
+                _emit({"type": "step", "text": "Continuing — step budget extended…"})
+                _log(f"continuing run with raised budget {agent.max_steps}")
+                result = agent.run(task_with_hint, reset=False)
         # Final formatting — NO extra summarizer model call. In multi-step mode the
         # agent's own final_answer() (or the max-steps fallback above) already holds the
         # synthesized answer; we just strip the internal hint tags we appended to tool

package/package.json

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