@livx.cc/agentx 0.99.41 → 0.99.43

package/dist/{Agent-DydgLoT-.d.ts → Agent-f4um2q8E.d.ts}

@@ -251,7 +251,9 @@ declare class AgentOptions {
     /** Retry budget for an EMPTY/silent-turn (a delegated-runtime wedge: cursor's warm helper spins then
      *  returns a content-less end, surfaced as `code:'empty'`/`code:'cursor_silent'`). Tuned WIDER than the
      *  network-drop budget (fixed 2) because clearing a wedge needs several reap+respawn cycles — each retry
-     *  hits a FRESH cursor session (the adapter evicts the wedged warm helper on the silent-end). Still bounded:
+     *  hits a FRESH cursor session (the adapter evicts the wedged warm helper on the silent-end; a stall-watchdog
+     *  cancel is NOT this class — it is classified `stall`, and the watchdog's coded abort reason is what tells
+     *  the adapter to evict on that path too). Still bounded:
      *  after exhaustion the turn surfaces `finishReason:'empty'` (non-zero exit), never infinite, never silent.
      *  Env: AGENTX_EMPTY_RETRIES. */
     emptyRetries: number;

package/dist/cli.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { H as Hooks, i as RunResult, R as ReasoningEffort, A as Agent } from './Agent-DydgLoT-.js';
+import { H as Hooks, i as RunResult, R as ReasoningEffort, A as Agent } from './Agent-f4um2q8E.js';
 import { IFilesystem } from '@livx.cc/wcli/core';
 import { M as Message, U as UserQuestion, H as HostBridge, c as ContentPart, g as MessageContent } from './tools-S-ArIR3o.js';
 

package/dist/cli.js

@@ -2179,7 +2179,7 @@ function makeRealShellTool(options) {
       return { ...this, description: rebound.description, run: rebound.run, withCwd: rebound.withCwd };
     },
     get description() {
-      return `Run a shell command via /bin/sh in the working directory. Executes any installed binary \u2014 ls, cat, grep, git, bun, node, curl, scripts, etc. Returns combined stdout+stderr; non-zero exits are prefixed \`[exit N]\`. Runs non-interactively with no terminal (stdin is /dev/null): commands that prompt for input fail fast rather than hang \u2014 for privileged actions use a non-interactive flag (e.g. \`sudo -n\`), or ask the user to run the command themselves. Each command is killed after ${defaultTimeoutMs}ms (result \`[exit 124]\` with whatever output it produced) \u2014 pass \`timeoutMs\` (max ${maxTimeoutMs}) for a legitimately slower command, and always bound network commands yourself (e.g. \`curl -m 10\`). ` + backgroundDoc();
+      return "Run a shell command via /bin/sh in the working directory. Executes any installed binary \u2014 ls, cat, grep, git, bun, node, curl, scripts, etc. Returns combined stdout+stderr; non-zero exits are prefixed `[exit N]`. Runs non-interactively with no terminal (stdin is /dev/null): commands that prompt for input fail fast rather than hang \u2014 for privileged actions use a non-interactive flag (e.g. `sudo -n`), or ask the user to run the command themselves. " + (options.registry?.adopt ? `A command still running after ${defaultTimeoutMs}ms is NOT killed \u2014 it is handed to a background job and you get its id, so you can keep checking on it (\`[still running]\`). Pass \`timeoutMs\` (max ${maxTimeoutMs}) to wait longer in the foreground, and always bound network commands yourself (e.g. \`curl -m 10\`). ` : `Each command is killed after ${defaultTimeoutMs}ms (result \`[exit 124]\` with whatever output it produced) \u2014 pass \`timeoutMs\` (max ${maxTimeoutMs}) for a legitimately slower command, and always bound network commands yourself (e.g. \`curl -m 10\`). `) + backgroundDoc();
     },
     // Declared so transports above the agent loop can size their own deadline with headroom (see AgentTool.maxDurationMs).
     maxDurationMs: maxTimeoutMs,
@@ -2218,9 +2218,12 @@ function makeRealShellTool(options) {
         else ctx.signal.addEventListener("abort", onAbort, { once: true });
       }
       let timedOut = false;
-      const timer = setTimeout(() => {
+      let onDeadline = () => {
         timedOut = true;
         ctl.abort();
+      };
+      const timer = setTimeout(() => {
+        onDeadline();
       }, timeoutMs);
       let pend = "";
       let flushTimer = null;
@@ -2251,6 +2254,18 @@ function makeRealShellTool(options) {
           }
           if (ctl.signal.aborted) killGroup(proc, "SIGKILL");
           else ctl.signal.addEventListener("abort", () => killGroup(proc, "SIGKILL"), { once: true });
+          const registry = options.registry;
+          if (registry?.adopt) {
+            onDeadline = () => {
+              timedOut = true;
+              if (settled) return;
+              flushEmit(ctx);
+              proc.stdout?.off?.("data", collect);
+              proc.stderr?.off?.("data", collect);
+              const id = registry.adopt(cmd, proc, out);
+              finish(handoffFor(timeoutMs, id, clean(out), !!registry.notifiesOnExit));
+            };
+          }
           const collect = (chunk) => {
             const s = typeof chunk === "string" ? chunk : chunk?.toString?.("utf8") ?? "";
             out += s;
@@ -2283,6 +2298,12 @@ function makeRealShellTool(options) {
     }
   };
 }
+function handoffFor(timeoutMs, id, body, notifies) {
+  const head = `[still running] exceeded ${timeoutMs}ms, so it was handed to background job ${id} \u2014 NOT killed, it is still going. Check on it with ShellOutput({id:"${id}"}) / ShellStatus({id:"${id}"}), stop it with ShellKill({id:"${id}"}). ` + (notifies ? "Its completion will be reported to you, so you may continue with other work meanwhile." : "Nothing will tell you when it finishes \u2014 poll it yourself before you rely on its result.");
+  return body ? `${head}
+Output so far:
+${body}` : head;
+}
 function reasonFor(timedOut, timeoutMs, body) {
   const head = timedOut ? `[exit 124] timed out after ${timeoutMs}ms (killed). Re-running this command unchanged will time out again. Either re-run it with background:true (returns a job id immediately; poll with ShellOutput/ShellStatus, stop with ShellKill) or narrow it so it can finish \u2014 bound it, scope it, or ask for less.` : "[exit 130] cancelled (killed)";
   return body ? `${head}
@@ -2422,6 +2443,41 @@ var init_tools_shell = __esm({
       list() {
         return [...this.jobs].map(([id, j]) => ({ id, command: j.command, status: j.status }));
       }
+      /**
+       * Take over an ALREADY-RUNNING child as a background job. A foreground command that outruns its
+       * timeout is not necessarily a hung command — killing it throws away work that was nearly done and,
+       * worse, a launcher that spawned its own detached worker leaves that worker running with nothing
+       * tracking it. Adopting hands the model a handle instead: the command keeps going, its completion
+       * is reported like any other job, and `seed` carries the output produced before the handoff.
+       */
+      adopt(command, proc, seed = "") {
+        const id = `job-${++this.seq}`;
+        const max = this.cfg.maxBuffer ?? 256 * 1024;
+        const job = { command, buf: seed.slice(-max), status: "running", proc };
+        const append = (chunk) => {
+          const s = typeof chunk === "string" ? chunk : chunk?.toString?.("utf8") ?? "";
+          job.buf = (job.buf + s).slice(-max);
+        };
+        proc.stdout?.on("data", append);
+        proc.stderr?.on("data", append);
+        proc.on("error", (err2) => {
+          if (job.status === "running") {
+            job.status = "error";
+            append(`
+[error] ${err2?.message ?? err2}`);
+            this.notifyExit(id, job);
+          }
+        });
+        proc.on("close", (code) => {
+          if (job.status === "running") {
+            job.status = "exited";
+            job.exitCode = code ?? void 0;
+            this.notifyExit(id, job);
+          }
+        });
+        this.jobs.set(id, job);
+        return id;
+      }
       kill(id) {
         const j = this.jobs.get(id);
         if (!j) return false;
@@ -3807,7 +3863,9 @@ var AgentOptions = class {
   /** Retry budget for an EMPTY/silent-turn (a delegated-runtime wedge: cursor's warm helper spins then
    *  returns a content-less end, surfaced as `code:'empty'`/`code:'cursor_silent'`). Tuned WIDER than the
    *  network-drop budget (fixed 2) because clearing a wedge needs several reap+respawn cycles — each retry
-   *  hits a FRESH cursor session (the adapter evicts the wedged warm helper on the silent-end). Still bounded:
+   *  hits a FRESH cursor session (the adapter evicts the wedged warm helper on the silent-end; a stall-watchdog
+   *  cancel is NOT this class — it is classified `stall`, and the watchdog's coded abort reason is what tells
+   *  the adapter to evict on that path too). Still bounded:
    *  after exhaustion the turn surfaces `finishReason:'empty'` (non-zero exit), never infinite, never silent.
    *  Env: AGENTX_EMPTY_RETRIES. */
   emptyRetries = envInt("AGENTX_EMPTY_RETRIES", 4);
@@ -4326,6 +4384,7 @@ var Agent = class _Agent {
               try {
                 const r = await o.ai.chat({ model: o.model, messages: sent, tools: sentTools, stream: true, signal: stall.signal, ...o.toolChoice ? { toolChoice: o.toolChoice } : {}, ...reasonOpts });
                 res = await this.consumeStream(r, stall.poke);
+                if (stall.stalled()) throw stall.reclassify(void 0);
               } catch (err2) {
                 throw stall.reclassify(err2);
               } finally {
@@ -4360,7 +4419,7 @@ var Agent = class _Agent {
         if (err2?.code === "budget") return kill("budget");
         if (err2?.code === "stall") {
           log6.warn(`model stalled out after retries: ${err2?.message ?? err2}`);
-          return kill("timeout");
+          return { ...kill("timeout"), error: err2 };
         }
         if (o.signal?.aborted || isAbortError(err2)) return kill("aborted");
         if (err2?.code === "empty" || err2?.code === "cursor_silent") {
@@ -4508,31 +4567,30 @@ var Agent = class _Agent {
     if (parent?.aborted) ac.abort();
     else parent?.addEventListener("abort", onParentAbort, { once: true });
     let timer;
+    const stallError = () => {
+      const e = new Error(`model stalled: no stream output for ${stallMs >= 1e3 ? `${Math.round(stallMs / 1e3)}s` : `${stallMs}ms`}`);
+      e.code = "stall";
+      return e;
+    };
     const poke = () => {
       if (!stallMs) return;
       if (timer) clearTimeout(timer);
       timer = setTimeout(() => {
         fired = true;
-        ac.abort();
+        ac.abort(stallError());
       }, stallMs);
     };
     poke();
+    const stalled = () => fired && !parent?.aborted;
     return {
       signal: ac.signal,
       poke,
+      stalled,
       clear: () => {
         if (timer) clearTimeout(timer);
         parent?.removeEventListener("abort", onParentAbort);
       },
-      // Distinguish OUR abort (silent provider) from a parent/user cancel, which must stay an abort.
-      reclassify: (err2) => {
-        if (fired && !parent?.aborted) {
-          const e = new Error(`model stalled: no stream output for ${stallMs >= 1e3 ? `${Math.round(stallMs / 1e3)}s` : `${stallMs}ms`}`);
-          e.code = "stall";
-          return e;
-        }
-        return err2;
-      }
+      reclassify: (err2) => stalled() ? stallError() : err2
     };
   }
   /** A clean-stop turn that carries no assistant text AND no tool calls (native or delegated) — a