@livx.cc/agentx 0.99.39 → 0.99.41

package/dist/tools.shell.js

@@ -287,6 +287,8 @@ function makeWebFetchTool(options = {}) {
   return {
     name: "WebFetch",
     description: "Fetch an http/https URL and return its readable text (HTML is stripped to text). Use to read docs or web pages. Returns the status line then up to ~100k chars of content.",
+    // Declared so a transport above the loop sizes its deadline around this one (see AgentTool.maxDurationMs).
+    maxDurationMs: timeoutMs,
     parameters: { type: "object", required: ["url"], properties: { url: { type: "string", description: "absolute http(s) URL" } } },
     async run({ url }) {
       const doFetch = options.fetch ?? globalThis.fetch;
@@ -564,6 +566,11 @@ async function nodeSpawn() {
   if (!_spawn) _spawn = (await import("child_process")).spawn;
   return _spawn;
 }
+function formatJobExit(n) {
+  return `[background job ${n.id} ${n.status}${n.exitCode != null ? ` exit ${n.exitCode}` : ""}] \`${n.command}\`
+` + (n.tail ? `${n.tail}
+` : "(no output)\n") + `Read the full output with ShellOutput({id:"${n.id}"}).`;
+}
 var ShellJobRegistry = class {
   constructor(cfg) {
     this.cfg = cfg;
@@ -592,12 +599,14 @@ var ShellJobRegistry = class {
           job.status = "error";
           append(`
 [error] ${err?.message ?? err}`);
+          this.notifyExit(id, job);
         }
       });
       proc.on("close", (code) => {
         if (job.status === "running") {
           job.status = "exited";
           job.exitCode = code ?? void 0;
+          this.notifyExit(id, job);
         }
       });
     } catch (e) {
@@ -607,6 +616,29 @@ var ShellJobRegistry = class {
     this.jobs.set(id, job);
     return id;
   }
+  /** Fire `onExit` at most once per job, with the tail so the model can act without a second round-trip. */
+  notified = /* @__PURE__ */ new Set();
+  notifyExit(id, job) {
+    if (this.notified.has(id) || !this.cfg.onExit) return;
+    this.notified.add(id);
+    try {
+      this.cfg.onExit({ id, command: job.command, status: job.status, exitCode: job.exitCode, tail: clean(job.buf).slice(-4e3) });
+    } catch {
+    }
+  }
+  /**
+   * Wire (or rewire) the completion callback AFTER construction. A host that only gets its agent handle
+   * once the Agent is constructed (the library's own `fullAgentOptions` preset, any embedder) could not
+   * pass `onExit` up front, so background completions were silently REPL-only. Set it here instead.
+   */
+  setOnExit(fn) {
+    this.cfg.onExit = fn;
+  }
+  /** Whether a finished job will actually be reported to the model. The Shell tool's description reads
+   *  this so it can't promise a completion notice on a host that discards it. */
+  get notifiesOnExit() {
+    return !!this.cfg.onExit;
+  }
   /** Current tail output for a job (null = no such job). */
   output(id) {
     return this.jobs.get(id)?.buf ?? (this.jobs.has(id) ? "" : null);
@@ -639,9 +671,37 @@ var ShellJobRegistry = class {
 function makeRealShellTool(options) {
   const defaultTimeoutMs = options.timeoutMs ?? 12e4;
   const maxTimeoutMs = Math.max(options.maxTimeoutMs ?? 6e5, defaultTimeoutMs);
+  const backgroundDoc = () => {
+    const base = "Set `background:true` for long-running processes (servers, watchers) and for anything that already timed out in the foreground \u2014 returns a job id immediately; poll with ShellOutput/ShellStatus, stop with ShellKill. ";
+    const notify = options.registry?.notifiesOnExit ? "Its completion is reported back to you when it finishes." : "NOTE: nothing will tell you when it finishes \u2014 poll ShellOutput/ShellStatus yourself, or you will never see its result.";
+    const survival = options.jobsSurviveRun === false ? "The job does NOT survive the end of this run, so do not stop while you still need its result." : "It keeps running across turns.";
+    return `${base}${notify} ${survival}`;
+  };
   return {
     name: "Shell",
-    description: `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\`). Set \`background:true\` for long-running processes (servers, watchers) \u2014 returns a job id immediately; poll with ShellOutput, stop with ShellKill.`,
+    // Rebind for an isolated child agent (git worktree): same policy/env/timeouts, new cwd. The
+    // `registry` is deliberately dropped — it is bound to the PARENT's cwd (and, in hosts like
+    // shraga-ee, to the parent's session), so a background job started from the child would run
+    // outside the child's isolation and report into the parent. Background stays a parent capability
+    // (`makeShellJobTools`' companions drop out of an isolated child entirely — see their `withCwd`).
+    // Only `run` is rebuilt: everything else is carried over from THIS instance, because a host may
+    // have mutated the tool AFTER construction (shraga-ee renames `Shell` -> `Bash` and its system
+    // prompt says `Bash` everywhere). Rebuilding from `options` alone silently dropped that rename,
+    // so a worktree child advertised `Shell` while being told to call `Bash` — an unknown-tool error
+    // on its first call, and a hard failure for an agentType def whose allowlist names `Bash`.
+    // `description` is the ONE thing taken from the rebound tool instead: it is derived from the
+    // options and states whether `background:true` works — the rebind drops the registry, so carrying
+    // the parent's text over would advertise a background capability the child does not have. (The
+    // spread also collapses the getter below to a plain value, which is why this override is explicit.)
+    withCwd(cwd) {
+      const rebound = makeRealShellTool({ ...options, cwd, registry: void 0 });
+      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();
+    },
+    // Declared so transports above the agent loop can size their own deadline with headroom (see AgentTool.maxDurationMs).
+    maxDurationMs: maxTimeoutMs,
     parameters: {
       type: "object",
       required: ["command"],
@@ -743,15 +803,18 @@ function makeRealShellTool(options) {
   };
 }
 function reasonFor(timedOut, timeoutMs, body) {
-  const head = timedOut ? `[exit 124] timed out after ${timeoutMs}ms (killed)` : "[exit 130] cancelled (killed)";
+  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}
+Partial output before the kill:
 ${body}` : head;
 }
 var NO_JOB = (id) => `Error: no background job '${id}'. Use ShellStatus with no id to list jobs, or start one with Shell({background:true}).`;
 function makeShellJobTools(registry) {
   const idParam = { type: "object", properties: { id: { type: "string", description: "the job id from Shell({background:true})" } } };
+  const dropOnRebind = { withCwd: () => void 0 };
   return [
     {
+      ...dropOnRebind,
       name: "ShellOutput",
       description: "Read the accumulated output (tail) of a background Shell job by id.",
       parameters: { type: "object", required: ["id"], properties: { id: { type: "string" } } },
@@ -764,6 +827,7 @@ ${clean(out) || "(no output yet)"}`;
       }
     },
     {
+      ...dropOnRebind,
       name: "ShellStatus",
       description: "Status of a background Shell job (running/exited/killed + exit code). Omit `id` to list all jobs.",
       parameters: idParam,
@@ -777,6 +841,7 @@ ${clean(out) || "(no output yet)"}`;
       }
     },
     {
+      ...dropOnRebind,
       name: "ShellKill",
       description: "Stop a running background Shell job by id (SIGTERM).",
       parameters: { type: "object", required: ["id"], properties: { id: { type: "string" } } },
@@ -788,6 +853,7 @@ ${clean(out) || "(no output yet)"}`;
 }
 export {
   ShellJobRegistry,
+  formatJobExit,
   makeRealShellTool,
   makeShellJobTools
 };