agent.libx.js 0.92.1 → 0.92.3

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-import { a as AgentOptions, H as Hooks, h as RunResult, A as Agent } from './Agent-BzwprwHr.js';
-export { C as ChatFragment, D as DEFAULT_MUTATING, b as Decision, P as PermissionOptions, c as PermissionPolicy, d as PermissionRule, e as PreToolUseDecision, R as ReasoningEffort, f as RecordingHooks, g as RecordingLifecycle, T as ToolUse, i as ToolUseMeta, j as composeHooks, p as planMode, r as reasoningToChatFragment } from './Agent-BzwprwHr.js';
+import { a as AgentOptions, H as Hooks, h as RunResult, A as Agent } from './Agent-QwBA0wu6.js';
+export { C as ChatFragment, D as DEFAULT_MUTATING, b as Decision, P as PermissionOptions, c as PermissionPolicy, d as PermissionRule, e as PreToolUseDecision, R as ReasoningEffort, f as RecordingHooks, g as RecordingLifecycle, T as ToolUse, i as ToolUseMeta, j as composeHooks, p as planMode, r as reasoningToChatFragment } from './Agent-QwBA0wu6.js';
 import { IFilesystem, FileMetadata } from '@livx.cc/wcli/core';
 export { CommandExecutor, FileMetadata, IFilesystem, IndexedDbFilesystem, MemFilesystem, registerHeadlessCommands } from '@livx.cc/wcli/core';
 import { BodDB } from '@bod.ee/db';
-import { A as AgentTool, C as ChatLike, a as ChatOptions, b as ChatResponse, h as ToolCall, H as HostBridge, U as UserQuestion, e as MessageContent } from './tools-CeK5AquG.js';
-export { c as ContentPart, d as HostEvent, M as Message, R as Role, S as SandboxJobRegistry, f as StreamChunk, T as TodoItem, g as Tool, i as ToolContext, j as bashTool, k as contentText, l as defaultTools, m as editTool, n as exitSessionTool, o as imagePart, p as makeContext, q as makeJobTools, r as readTool, t as toWireTools, s as todoWriteTool, u as toolRegistry, v as toolsByName } from './tools-CeK5AquG.js';
-export { M as McpCall, a as McpImage, b as McpToolResult, c as McpToolSearchOptions, d as McpToolSpec, m as makeMcpToolSearch, e as mcpToolToAgentTool, f as mcpToolsToAgentTools } from './mcp-Bn5TlRbV.js';
+import { A as AgentTool, C as ChatLike, a as ChatOptions, b as ChatResponse, h as ToolCall, H as HostBridge, U as UserQuestion, e as MessageContent } from './tools-GPWp7oXq.js';
+export { c as ContentPart, d as HostEvent, M as Message, R as Role, S as SandboxJobRegistry, f as StreamChunk, T as TodoItem, g as Tool, i as ToolContext, j as bashTool, k as contentText, l as defaultTools, m as editTool, n as exitSessionTool, o as imagePart, p as makeContext, q as makeJobTools, r as readTool, t as toWireTools, s as todoWriteTool, u as toolRegistry, v as toolsByName } from './tools-GPWp7oXq.js';
+export { M as McpCall, a as McpImage, b as McpToolResult, c as McpToolSearchOptions, d as McpToolSpec, m as makeMcpToolSearch, e as mcpToolToAgentTool, f as mcpToolsToAgentTools } from './mcp-wwgXyhbi.js';
 import * as libx_js_src_modules_log from 'libx.js/src/modules/log';
 export { log } from 'libx.js/src/modules/log';
 
@@ -565,7 +565,7 @@ declare function loadInstructions(fs: IFilesystem, names?: string[]): Promise<st
  * re-voiced by the fast persona — push, not poll (unlike subagent.ts's background `Task`).
  *
  * Host events (via the open HostEvent union): the voice agent's standard `text_delta` stream,
- * plus `task_started` / `task_done` / `task_error` / `task_cancelled`.
+ * plus `task_started` / `task_progress` / `task_done` / `task_error` / `task_cancelled`.
  */
 
 type DuplexTaskStatus = 'running' | 'done' | 'error' | 'cancelled';
@@ -597,6 +597,11 @@ declare class DuplexAgentOptions {
     /** Awaited BEFORE a delegated worker spawns — open a per-task checkpoint frame, audit, etc.
      *  (post-spawn would race the worker's first edits). */
     onTaskStart?: (id: string, label: string) => void | Promise<void>;
+    /** Re-voice throttled worker progress asides ('[task t1 progress] …') so long tasks aren't dead
+     *  air. Off by default — each update costs a voice turn (LLM call + speech). */
+    progressUpdates: boolean;
+    /** Min ms between progress re-voices per task. */
+    progressIntervalMs: number;
     /** Host overrides for QuickLook lookups (keyed by `what`). The engine's defaults go through the
      *  (possibly jailed) fs — e.g. `.git/**` is deny-listed, so the CLI supplies 'branch' itself. */
     quickLook?: Record<string, (path?: string) => string | Promise<string>>;
@@ -630,6 +635,11 @@ declare class DuplexAgent {
     private buildBrief;
     /** Spawn a detached worker for task `id`; its settlement notifies + enqueues the re-voice turn. */
     private spawnWorker;
+    /** Throttled per-task progress: worker tool calls → at most one progress re-voice per interval.
+     *  Two sources, one throttle: completed steps (post) and a heartbeat for a SINGLE long tool call
+     *  (pre records the in-flight call; a self-cleaning timer narrates "still inside Bash — 70s").
+     *  Completion supersedes: nothing is emitted once the task has settled. */
+    private progressReporter;
     private onWorkerSettled;
     private onWorkerFailed;
     private failTask;

package/dist/index.js

@@ -1391,6 +1391,18 @@ function makeRealShellTool(options) {
         timedOut = true;
         ctl.abort();
       }, timeoutMs);
+      let pend = "";
+      let flushTimer = null;
+      const flushEmit = (ctx2) => {
+        if (flushTimer) {
+          clearTimeout(flushTimer);
+          flushTimer = null;
+        }
+        if (pend) {
+          ctx2.emit?.(redactSecrets(pend));
+          pend = "";
+        }
+      };
       try {
         return await new Promise((resolve) => {
           let out = "";
@@ -1407,7 +1419,13 @@ function makeRealShellTool(options) {
             return finish(`[exit 1] failed to spawn shell: ${e?.message ?? e}`);
           }
           const collect = (chunk) => {
-            out += typeof chunk === "string" ? chunk : chunk?.toString?.("utf8") ?? "";
+            const s = typeof chunk === "string" ? chunk : chunk?.toString?.("utf8") ?? "";
+            out += s;
+            if (ctx.emit && !settled) {
+              pend += s;
+              if (pend.length >= 1024) flushEmit(ctx);
+              else flushTimer ??= setTimeout(() => flushEmit(ctx), 250);
+            }
           };
           proc.stdout?.on("data", collect);
           proc.stderr?.on("data", collect);
@@ -1417,6 +1435,7 @@ function makeRealShellTool(options) {
             finish(`[exit 1] ${err?.message ?? err}${out ? "\n" + clean(out) : ""}`);
           });
           proc.on("close", (code) => {
+            flushEmit(ctx);
             if (ctl.signal.aborted) return finish(reasonFor(timedOut, timeoutMs, clean(out)));
             const body = clean(out);
             if (code && code !== 0) return finish(`[exit ${code}]${body ? "\n" + body : ""}`);
@@ -1425,6 +1444,7 @@ function makeRealShellTool(options) {
         });
       } finally {
         clearTimeout(timer);
+        if (flushTimer) clearTimeout(flushTimer);
         ctx.signal?.removeEventListener("abort", onAbort);
       }
     }
@@ -2405,6 +2425,9 @@ function composeHooks(...list) {
     async postToolUse(call, result, meta) {
       for (const h of hooks) await h.postToolUse?.(call, result, meta);
     },
+    onToolOutput(call, chunk, meta) {
+      for (const h of hooks) h.onToolOutput?.(call, chunk, meta);
+    },
     onStop(text) {
       for (const h of hooks) h.onStop?.(text);
     },
@@ -2915,6 +2938,13 @@ var Agent = class _Agent {
     let threw = false;
     try {
       log3.debug(`${tc.function.name}(${tc.function.arguments})`);
+      this.ctx.emit = hooks?.onToolOutput ? (chunk) => {
+        try {
+          hooks.onToolOutput(call, chunk, meta);
+        } catch (e) {
+          log3.debug(`onToolOutput hook error: ${e}`);
+        }
+      } : void 0;
       const raw = await tool.run(args, this.ctx);
       if (typeof raw === "string") {
         result = raw;
@@ -2927,6 +2957,8 @@ var Agent = class _Agent {
       log3.debug(`${tc.function.name} -> error: ${msg}`);
       result = `Error: ${msg}`;
       threw = true;
+    } finally {
+      this.ctx.emit = void 0;
     }
     if (!threw) result = await this.maybeAutoTest(tc.function.name, result);
     await hooks?.postToolUse?.(call, result, meta);
@@ -3483,6 +3515,11 @@ function digestRun(messages, maxChars) {
 import { MemFilesystem as MemFilesystem2 } from "@livx.cc/wcli/core";
 init_logging();
 var log7 = forComponent("DuplexAgent");
+function describeCall(call) {
+  const v = call.args && Object.values(call.args).find((x) => typeof x === "string" && x.trim());
+  const hint = v ? ` (${String(v).replace(/\s+/g, " ").trim().slice(0, 48)})` : "";
+  return `${call.name}${hint}`;
+}
 var DuplexAgentOptions = class {
   /** Any ai.libx.js AIClient — shared by the voice and worker agents (routed by model). */
   ai;
@@ -3503,11 +3540,16 @@ var DuplexAgentOptions = class {
   /** Awaited BEFORE a delegated worker spawns — open a per-task checkpoint frame, audit, etc.
    *  (post-spawn would race the worker's first edits). */
   onTaskStart;
+  /** Re-voice throttled worker progress asides ('[task t1 progress] …') so long tasks aren't dead
+   *  air. Off by default — each update costs a voice turn (LLM call + speech). */
+  progressUpdates = false;
+  /** Min ms between progress re-voices per task. */
+  progressIntervalMs = 25e3;
   /** Host overrides for QuickLook lookups (keyed by `what`). The engine's defaults go through the
    *  (possibly jailed) fs — e.g. `.git/**` is deny-listed, so the CLI supplies 'branch' itself. */
   quickLook;
 };
-var VOICE_SYSTEM_PROMPT = 'You are a spoken voice assistant \u2014 the user HEARS everything you say. Use short sentences. One idea per sentence. No markdown, no bullet lists, no code blocks, no headings, no emoji.\nKeep turns SHORT \u2014 one to three sentences, then stop. Never lecture, enumerate cases, or add caveats unprompted. Conversation is a fast exchange: give the one thing asked, and let the user pull more if they want it.\nYou work in a pair: you talk, and a background worker with FULL access to the user\'s environment (files, shell, web) does the hands-on work. You can find out or do ANYTHING by calling `Delegate` with a clear, self-contained brief \u2014 so NEVER tell the user you can\'t see, access, or do something. Delegate and find out. When the user mentions their project, folder, files, or environment ("this project", "the current folder", "my code"), delegate IMMEDIATELY \u2014 do not ask for paths or details the worker can discover itself. Never pretend to have done the work or invent results \u2014 the worker\'s report is your only source.\nAfter calling Delegate, tell the user you are on it in one short sentence, then end your turn. Do not wait for the result.\nResults arrive later as events like "[task t1 completed] \u2026" or "[task t1 failed] \u2026". When one arrives, summarize it for the ear in one or two short sentences. Never read raw file paths, diffs, or code aloud verbatim.\nDo not fire a second Delegate for work already in flight \u2014 check `TaskStatus` first. Use `CancelTask` when the user asks to stop something.\nPRIORITY: when the user says goodbye or wants to end/finish/wrap up the session ("ok bye", "that\'s all", "let\'s finish", "let\'s end", "goodnight", "exit", "wrap up"), call `ExitSession` IMMEDIATELY \u2014 do not delegate, do not check status, just exit.\nFor TRIVIAL instant lookups only \u2014 current time, git branch, listing a folder, peeking at a small file \u2014 use `QuickLook` (instant, no task). Anything requiring searching, reasoning, running commands, or editing still goes through `Delegate`.\nNEVER claim to have stored, saved, or remembered something durably \u2014 you cannot. Anything the user wants persisted (their name, preferences, notes) must be Delegated so a worker writes it to memory.\nUser messages may arrive via speech-to-text and can carry transcription artifacts \u2014 odd words, cut-offs, homophones ("for you" vs "folder"). Read for INTENT, not surface text. If a message seems garbled or surprising, briefly confirm what they meant ("did you mean\u2026?") instead of answering the literal words.';
+var VOICE_SYSTEM_PROMPT = 'You are a spoken voice assistant \u2014 the user HEARS everything you say. Use short sentences. One idea per sentence. No markdown, no bullet lists, no code blocks, no headings, no emoji.\nKeep turns SHORT \u2014 one to three sentences, then stop. Never lecture, enumerate cases, or add caveats unprompted. Conversation is a fast exchange: give the one thing asked, and let the user pull more if they want it.\nYou work in a pair: you talk, and a background worker with FULL access to the user\'s environment (files, shell, web) does the hands-on work. You can find out or do ANYTHING by calling `Delegate` with a clear, self-contained brief \u2014 so NEVER tell the user you can\'t see, access, or do something. Delegate and find out. When the user mentions their project, folder, files, or environment ("this project", "the current folder", "my code"), delegate IMMEDIATELY \u2014 do not ask for paths or details the worker can discover itself. Never pretend to have done the work or invent results \u2014 the worker\'s report is your only source.\nAfter calling Delegate, tell the user you are on it in one short sentence, then end your turn. Do not wait for the result.\nResults arrive later as events like "[task t1 completed] \u2026" or "[task t1 failed] \u2026". When one arrives, summarize it for the ear in one or two short sentences. "[task t1 progress] \u2026" events are interim status, NOT results \u2014 give at most a half-sentence aside ("still on it \u2014 running tests now") and end your turn. Never present progress as a finished result.\nNever read raw file paths, diffs, or code aloud verbatim.\nDo not fire a second Delegate for work already in flight \u2014 check `TaskStatus` first. Use `CancelTask` when the user asks to stop something.\nPRIORITY: when the user says goodbye or wants to end/finish/wrap up the session ("ok bye", "that\'s all", "let\'s finish", "let\'s end", "goodnight", "exit", "wrap up"), call `ExitSession` IMMEDIATELY \u2014 do not delegate, do not check status, just exit.\nFor TRIVIAL instant lookups only \u2014 current time, git branch, listing a folder, peeking at a small file \u2014 use `QuickLook` (instant, no task). Anything requiring searching, reasoning, running commands, or editing still goes through `Delegate`.\nNEVER claim to have stored, saved, or remembered something durably \u2014 you cannot. Anything the user wants persisted (their name, preferences, notes) must be Delegated so a worker writes it to memory.\nUser messages may arrive via speech-to-text and can carry transcription artifacts \u2014 odd words, cut-offs, homophones ("for you" vs "folder"). Read for INTENT, not surface text. If a message seems garbled or surprising, briefly confirm what they meant ("did you mean\u2026?") instead of answering the literal words.';
 var VOICE_STYLE_CONVERSATIONAL = `Speak like a person in a live conversation, not an assistant reading a script. React first, then deliver: a quick impulsive beat ("oh nice", "hmm, hold on", "ah, got it") before the substance. Use contractions always. Vary sentence length \u2014 some very short. Light fillers and backchannels are fine ("mm-hm", "right", "let's see") but at most one per reply \u2014 never stack them. When you delegate, say it like a human would ("hang on, let me actually dig into that \u2014 gimme a minute") instead of announcing a task. When a result comes back, react to it like you just found out ("okay so \u2014 turns out\u2026"). Match the user's energy: a quick question gets a quick answer \u2014 a few words is a perfectly good turn. Prefer a short answer plus an offer ("want the details?") over covering everything. Never narrate your own mechanics (no "I will now delegate", no task ids out loud).`;
 var DuplexAgent = class {
   options;
@@ -3592,18 +3634,78 @@ ${recent}` : brief;
   spawnWorker(id, label, briefText) {
     const o = this.options;
     const controller = new AbortController();
+    const base = o.workerOptions?.hooks;
+    const report = o.progressUpdates ? this.progressReporter(id) : void 0;
+    const hooks = report ? {
+      ...base,
+      preToolUse: async (call, meta) => {
+        const d = await base?.preToolUse?.(call, meta);
+        report.pre(call);
+        return d;
+      },
+      postToolUse: async (call, result, meta) => {
+        await base?.postToolUse?.(call, result, meta);
+        report.post(call);
+      },
+      onToolOutput: (call, chunk, meta) => {
+        base?.onToolOutput?.(call, chunk, meta);
+        report.output(chunk);
+      }
+    } : base;
     const worker = new Agent({
       ai: o.ai,
       fs: o.fs,
       model: o.workerModel,
       ...o.workerOptions,
       // may override ai/fs/model/tools/… —
+      ...hooks ? { hooks } : {},
       signal: controller.signal
       // …but never the per-task cancellation signal
     });
     const promise = worker.run(briefText).then((res) => this.onWorkerSettled(id, res)).catch((err) => this.onWorkerFailed(id, err));
     this.tasks.set(id, { id, label, status: "running", controller, promise });
   }
+  /** Throttled per-task progress: worker tool calls → at most one progress re-voice per interval.
+   *  Two sources, one throttle: completed steps (post) and a heartbeat for a SINGLE long tool call
+   *  (pre records the in-flight call; a self-cleaning timer narrates "still inside Bash — 70s").
+   *  Completion supersedes: nothing is emitted once the task has settled. */
+  progressReporter(id) {
+    let lastAt = Date.now();
+    let steps = 0;
+    let inflight = null;
+    const due = () => {
+      const rec = this.tasks.get(id);
+      return rec && rec.status === "running" && Date.now() - lastAt >= this.options.progressIntervalMs ? rec : void 0;
+    };
+    const emit = (rec, line, call) => {
+      lastAt = Date.now();
+      this.notify("task_progress", `task ${id} (${rec.label}): ${line}`, { id, steps, call: call.name });
+      this.queueRevoice(`[task ${id} progress] ${line}`);
+    };
+    const timer = setInterval(() => {
+      const rec = this.tasks.get(id);
+      if (!rec || rec.status !== "running") return clearInterval(timer);
+      if (!inflight || !due()) return;
+      const last = inflight.tail.trim().split("\n").filter(Boolean).pop()?.slice(-80);
+      emit(rec, `still inside ${describeCall(inflight.call)} \u2014 ${Math.round((Date.now() - inflight.at) / 1e3)}s on this step${last ? `, last output: ${last}` : ""}`, inflight.call);
+    }, Math.max(this.options.progressIntervalMs, 250));
+    timer.unref?.();
+    return {
+      pre: (call) => {
+        inflight = { call, at: Date.now(), tail: "" };
+      },
+      output: (chunk) => {
+        if (inflight) inflight.tail = (inflight.tail + chunk).slice(-500);
+      },
+      // digest only — NEVER re-voices directly
+      post: (call) => {
+        steps++;
+        inflight = null;
+        const rec = due();
+        if (rec) emit(rec, `still running \u2014 ${steps} steps so far, now: ${describeCall(call)}`, call);
+      }
+    };
+  }
   onWorkerSettled(id, res) {
     const rec = this.tasks.get(id);
     if (res.finishReason === "aborted" || rec.status === "cancelled") {
@@ -3820,6 +3922,7 @@ var RecordingHooks = class {
   blocks;
   pre = [];
   post = [];
+  outputs = [];
   stops = [];
   preToolUse(call, meta) {
     this.pre.push({ call, meta });
@@ -3829,6 +3932,9 @@ var RecordingHooks = class {
   postToolUse(call, result, meta) {
     this.post.push({ call, result, meta });
   }
+  onToolOutput(call, chunk, meta) {
+    this.outputs.push({ call, chunk, meta });
+  }
   onStop(finalText) {
     this.stops.push(finalText);
   }