agent.libx.js 0.89.6 → 0.89.7

package/dist/index.d.ts

@@ -1,10 +1,10 @@
-import { a as AgentOptions, H as Hooks, h as RunResult } from './Agent-B0l9qT_j.js';
-export { A as Agent, 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-B0l9qT_j.js';
+import { a as AgentOptions, H as Hooks, h as RunResult, A as Agent } from './Agent-B0l9qT_j.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-B0l9qT_j.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 } from './tools-Ch-OzOU8.js';
-export { c as ContentPart, d as HostEvent, M as Message, e as MessageContent, 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 imagePart, o as makeContext, p as makeJobTools, r as readTool, t as toWireTools, q as todoWriteTool, s as toolRegistry, u as toolsByName } from './tools-Ch-OzOU8.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-Ch-OzOU8.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 imagePart, o as makeContext, p as makeJobTools, r as readTool, t as toWireTools, q as todoWriteTool, s as toolRegistry, u as toolsByName } from './tools-Ch-OzOU8.js';
 export { M as McpCall, a as McpToolSearchOptions, b as McpToolSpec, m as makeMcpToolSearch, c as mcpToolToAgentTool, d as mcpToolsToAgentTools } from './mcp-Dg3vA1Uj.js';
 import * as libx_js_src_modules_log from 'libx.js/src/modules/log';
 export { log } from 'libx.js/src/modules/log';
@@ -556,6 +556,85 @@ declare function reflectOnRun(o: ReflectOptions): Promise<string | null>;
  */
 declare function loadInstructions(fs: IFilesystem, names?: string[]): Promise<string>;
 
+/**
+ * DuplexAgent — voice-optimized dual-model conversational engine, composed on top of `Agent`.
+ *
+ * One FAST voice agent (streams instant replies, owns THE transcript, the only voice the user
+ * hears) + detached SLOW worker agents (full tools, deep reasoning) spawned per escalation via a
+ * `Delegate` tool. Worker results are pushed back as `[task <id> completed] …` events and
+ * 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`.
+ */
+
+type DuplexTaskStatus = 'running' | 'done' | 'error' | 'cancelled';
+interface TaskRecord {
+    id: string;
+    label: string;
+    status: DuplexTaskStatus;
+    controller: AbortController;
+    /** Settles when the worker finished AND its completion was processed. Never rejects. */
+    promise: Promise<void>;
+}
+declare class DuplexAgentOptions {
+    /** Any ai.libx.js AIClient — shared by the voice and worker agents (routed by model). */
+    ai: ChatLike;
+    /** The WORKER's filesystem. If omitted the worker keeps Agent's jailed-disk-at-cwd default. */
+    fs?: IFilesystem;
+    voiceModel: string;
+    workerModel: string;
+    /** Escape hatches merged over the derived per-agent options. */
+    voiceOptions?: Partial<AgentOptions>;
+    workerOptions?: Partial<AgentOptions>;
+    /** Receives the voice text_delta stream + task lifecycle events. */
+    host?: HostBridge;
+    /** How many recent transcript messages are rendered into a worker's brief. */
+    excerptTurns: number;
+    /** Voice register: 'neutral' = clean spoken style; 'conversational' = human-like — fillers,
+     *  backchannels, impulsive first reactions before content (mimics real duplex conversation). */
+    voiceStyle: 'neutral' | 'conversational';
+    /** 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>;
+}
+declare const VOICE_SYSTEM_PROMPT: string;
+/**
+ * The duplex orchestrator. `send()` enqueues a user turn on the voice agent; `Delegate`
+ * spawns a detached worker whose completion enqueues a re-voice turn. A promise-chain
+ * mutex serializes all voice turns so streams never interleave, and completions that
+ * pile up while the voice is busy are coalesced into a single re-voice turn.
+ */
+declare class DuplexAgent {
+    options: DuplexAgentOptions;
+    readonly voice: Agent;
+    readonly tasks: Map<string, TaskRecord>;
+    private queue;
+    private seq;
+    private pendingEvents;
+    private flushQueued;
+    constructor(options?: Partial<DuplexAgentOptions>);
+    /** One user turn: the voice agent streams the reply (and may Delegate). Serialized with re-voice turns. */
+    send(content: MessageContent): Promise<RunResult>;
+    /** Resolve when all queued voice turns AND all in-flight worker tasks have settled (tests, graceful shutdown). */
+    idle(): Promise<void>;
+    /** Promise-chain mutex: turns run strictly one at a time; a failed turn doesn't poison the chain. */
+    private enqueue;
+    private notify;
+    /** Queue a `[task …]` event for re-voicing. Events arriving while the voice is busy coalesce into ONE turn. */
+    private queueRevoice;
+    /** The worker's brief: the Delegate args + a STATIC text snapshot of the recent conversation. */
+    private buildBrief;
+    /** Spawn a detached worker for task `id`; its settlement notifies + enqueues the re-voice turn. */
+    private spawnWorker;
+    private onWorkerSettled;
+    private onWorkerFailed;
+    private failTask;
+    private delegateTool;
+    private taskStatusTool;
+    private cancelTaskTool;
+}
+
 /**
  * Typed subagents — named child-agent definitions from `<dir>/<name>.md`, each with a
  * description, an optional model + tool allowlist (frontmatter), and a system prompt (the
@@ -618,4 +697,4 @@ declare function makeTaskBatchTool(opts: TaskToolOptions): AgentTool;
 /** Component-scoped logger (libx.js). debug/verbose gated via DEBUG env/localStorage. */
 declare const forComponent: (name: string) => libx_js_src_modules_log.ComponentLogger;
 
-export { type AgentDef, AgentOptions, AgentTool, type Attempt, BodDbFilesystem, ChatLike, ChatOptions, ChatResponse, type CommandInfo, ConsoleHostBridge, DEFAULT_DENY, FakeAIClient, Hooks, HostBridge, JailOptions, JailedFilesystem, type LessonOptions, LessonOptionsDefaults, type Mount, MountFilesystem, NodeDiskFilesystem, OverlayFilesystem, type ReflectOptions, RunResult, ScriptedHostBridge, type SkillInfo, type TaskToolOptions, ToolCall, type ToolSpec, UserQuestion, type WebFetchOptions, type WebSearchOptions, applyEditsTool, askUserQuestionTool, checkpointTool, checkpointTools, compileSynthesizedTool, diskAgentOptions, expandCommand, expandTemplate, forComponent, fullAgentOptions, globTool, grepTool, htmlToText, idfWeights, lessonCapture, loadAgents, loadCommands, loadInstructions, loadMemory, loadSkills, makeTaskBatchTool, makeTaskTool, makeWebFetchTool, makeWebSearchTool, mkdirp, multiEditTool, raceAttempts, reflectOnRun, relevanceScore, repoIndex, repoMapTool, rollbackTool, sandboxAgentOptions, slugify, tokenize, toolCall, topByRelevance, validateToolCode, webFetchTool, webSearchTool, writeFact, writeTool };
+export { Agent, type AgentDef, AgentOptions, AgentTool, type Attempt, BodDbFilesystem, ChatLike, ChatOptions, ChatResponse, type CommandInfo, ConsoleHostBridge, DEFAULT_DENY, DuplexAgent, DuplexAgentOptions, type DuplexTaskStatus, FakeAIClient, Hooks, HostBridge, JailOptions, JailedFilesystem, type LessonOptions, LessonOptionsDefaults, MessageContent, type Mount, MountFilesystem, NodeDiskFilesystem, OverlayFilesystem, type ReflectOptions, RunResult, ScriptedHostBridge, type SkillInfo, type TaskRecord, type TaskToolOptions, ToolCall, type ToolSpec, UserQuestion, VOICE_SYSTEM_PROMPT, type WebFetchOptions, type WebSearchOptions, applyEditsTool, askUserQuestionTool, checkpointTool, checkpointTools, compileSynthesizedTool, diskAgentOptions, expandCommand, expandTemplate, forComponent, fullAgentOptions, globTool, grepTool, htmlToText, idfWeights, lessonCapture, loadAgents, loadCommands, loadInstructions, loadMemory, loadSkills, makeTaskBatchTool, makeTaskTool, makeWebFetchTool, makeWebSearchTool, mkdirp, multiEditTool, raceAttempts, reflectOnRun, relevanceScore, repoIndex, repoMapTool, rollbackTool, sandboxAgentOptions, slugify, tokenize, toolCall, topByRelevance, validateToolCode, webFetchTool, webSearchTool, writeFact, writeTool };

package/dist/index.js

@@ -3448,6 +3448,202 @@ function digestRun(messages, maxChars) {
   return out.length > maxChars ? out.slice(0, maxChars) + "\n\u2026 (truncated)" : out;
 }
 
+// src/duplex.ts
+import { MemFilesystem as MemFilesystem2 } from "@livx.cc/wcli/core";
+init_logging();
+var log7 = forComponent("DuplexAgent");
+var DuplexAgentOptions = class {
+  /** Any ai.libx.js AIClient — shared by the voice and worker agents (routed by model). */
+  ai;
+  /** The WORKER's filesystem. If omitted the worker keeps Agent's jailed-disk-at-cwd default. */
+  fs;
+  voiceModel = "anthropic/claude-haiku-4-5";
+  workerModel = "anthropic/claude-sonnet-4-6";
+  /** Escape hatches merged over the derived per-agent options. */
+  voiceOptions;
+  workerOptions;
+  /** Receives the voice text_delta stream + task lifecycle events. */
+  host;
+  /** How many recent transcript messages are rendered into a worker's brief. */
+  excerptTurns = 6;
+  /** Voice register: 'neutral' = clean spoken style; 'conversational' = human-like — fillers,
+   *  backchannels, impulsive first reactions before content (mimics real duplex conversation). */
+  voiceStyle = "neutral";
+  /** Awaited BEFORE a delegated worker spawns — open a per-task checkpoint frame, audit, etc.
+   *  (post-spawn would race the worker's first edits). */
+  onTaskStart;
+};
+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.';
+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;
+  voice;
+  tasks = /* @__PURE__ */ new Map();
+  queue = Promise.resolve();
+  seq = 0;
+  pendingEvents = [];
+  flushQueued = false;
+  constructor(options) {
+    this.options = { ...new DuplexAgentOptions(), ...options };
+    const o = this.options;
+    this.voice = new Agent({
+      ai: o.ai,
+      fs: new MemFilesystem2(),
+      // scratch — NOT Agent's jailed-disk default (voice has no fs tools; edge-safe)
+      model: o.voiceModel,
+      stream: true,
+      host: o.host,
+      systemPrompt: VOICE_SYSTEM_PROMPT + (o.voiceStyle === "conversational" ? "\n" + VOICE_STYLE_CONVERSATIONAL : ""),
+      instructionFiles: false,
+      maxSteps: 8,
+      // a voice turn should never loop
+      timeoutMs: 3e4,
+      ...o.voiceOptions,
+      // no defaultTools() — the voice can only Delegate, never touch files itself. Set AFTER the
+      // voiceOptions spread (addTools() would be clobbered by the first prepare()); extra voice
+      // tools come in via voiceOptions.tools and are merged here.
+      tools: [...o.voiceOptions?.tools ?? [], this.delegateTool(), this.taskStatusTool(), this.cancelTaskTool()]
+    });
+  }
+  /** One user turn: the voice agent streams the reply (and may Delegate). Serialized with re-voice turns. */
+  send(content) {
+    return this.enqueue(() => this.voice.send(content));
+  }
+  /** Resolve when all queued voice turns AND all in-flight worker tasks have settled (tests, graceful shutdown). */
+  async idle() {
+    while (true) {
+      const q = this.queue;
+      await q.catch(() => {
+      });
+      await Promise.all([...this.tasks.values()].map((t) => t.promise));
+      if (this.queue === q && ![...this.tasks.values()].some((t) => t.status === "running")) return;
+    }
+  }
+  /** Promise-chain mutex: turns run strictly one at a time; a failed turn doesn't poison the chain. */
+  enqueue(fn) {
+    const run = this.queue.then(fn, fn);
+    this.queue = run.then(() => {
+    }, () => {
+    });
+    return run;
+  }
+  notify(kind, message, data) {
+    this.options.host?.notify?.({ kind, message, data });
+  }
+  /** Queue a `[task …]` event for re-voicing. Events arriving while the voice is busy coalesce into ONE turn. */
+  queueRevoice(event) {
+    this.pendingEvents.push(event);
+    if (this.flushQueued) return;
+    this.flushQueued = true;
+    void this.enqueue(async () => {
+      this.flushQueued = false;
+      const events = this.pendingEvents.splice(0);
+      if (!events.length) return;
+      await this.voice.send(events.join("\n"));
+      this.notify("revoice_done", "");
+    });
+  }
+  /** The worker's brief: the Delegate args + a STATIC text snapshot of the recent conversation. */
+  buildBrief(brief) {
+    const recent = this.voice.transcript.filter((m) => (m.role === "user" || m.role === "assistant") && contentText(m.content).trim()).slice(-this.options.excerptTurns).map((m) => `${m.role}: ${contentText(m.content)}`).join("\n");
+    return recent ? `${brief}
+
+## Recent conversation (for context)
+${recent}` : brief;
+  }
+  /** Spawn a detached worker for task `id`; its settlement notifies + enqueues the re-voice turn. */
+  spawnWorker(id, label, briefText) {
+    const o = this.options;
+    const controller = new AbortController();
+    const worker = new Agent({
+      ai: o.ai,
+      fs: o.fs,
+      model: o.workerModel,
+      ...o.workerOptions,
+      // may override ai/fs/model/tools/… —
+      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 });
+  }
+  onWorkerSettled(id, res) {
+    const rec = this.tasks.get(id);
+    if (res.finishReason === "aborted" || rec.status === "cancelled") {
+      rec.status = "cancelled";
+      this.notify("task_cancelled", `task ${id} (${rec.label}) cancelled`);
+      return;
+    }
+    if (res.finishReason === "error") {
+      const msg = res.error instanceof Error ? res.error.message : String(res.error ?? "unknown error");
+      return this.failTask(rec, msg);
+    }
+    rec.status = "done";
+    log7.verbose(`task ${id} done (${res.steps} steps)`);
+    this.notify("task_done", `task ${id} (${rec.label}) completed`, { id, text: res.text, usage: res.usage, usageEstimated: res.usageEstimated });
+    this.queueRevoice(`[task ${id} completed] ${res.text}`);
+  }
+  onWorkerFailed(id, err) {
+    this.failTask(this.tasks.get(id), err instanceof Error ? err.message : String(err));
+  }
+  failTask(rec, msg) {
+    rec.status = "error";
+    log7.warn(`task ${rec.id} failed: ${msg}`);
+    this.notify("task_error", `task ${rec.id} (${rec.label}) failed: ${msg}`);
+    this.queueRevoice(`[task ${rec.id} failed] ${msg}`);
+  }
+  // --- the three voice tools (closures over this instance) ---
+  delegateTool() {
+    return {
+      name: "Delegate",
+      description: 'Escalate real work (reading/editing files, searching, running tasks, deep analysis) to a background worker agent. Returns immediately with a task id; the result arrives later as a "[task <id> completed]" event. Provide a clear, self-contained `brief` (the worker does not hear the live conversation).',
+      parameters: {
+        type: "object",
+        required: ["brief"],
+        properties: {
+          brief: { type: "string", description: "full, self-contained instructions for the worker" },
+          label: { type: "string", description: "a short (2-4 word) label for the task" }
+        }
+      },
+      run: async ({ brief, label }) => {
+        const id = `t${++this.seq}`;
+        const lbl = String(label ?? "task");
+        await this.options.onTaskStart?.(id, lbl);
+        this.spawnWorker(id, lbl, this.buildBrief(String(brief ?? "")));
+        this.notify("task_started", `task ${id} (${lbl}) started`, { id, brief });
+        return `Delegated as task ${id}. Acknowledge briefly; the result will arrive as a [task ${id} completed] event.`;
+      }
+    };
+  }
+  taskStatusTool() {
+    return {
+      name: "TaskStatus",
+      description: "Status of background tasks. Pass `id` for one task, or omit it to list all.",
+      parameters: { type: "object", properties: { id: { type: "string" } } },
+      run: async ({ id }) => {
+        const list = id ? [this.tasks.get(String(id))].filter(Boolean) : [...this.tasks.values()];
+        if (!list.length) return id ? `No task '${id}'.` : "No background tasks.";
+        return list.map((t) => `${t.id} (${t.label}): ${t.status}`).join("\n");
+      }
+    };
+  }
+  cancelTaskTool() {
+    return {
+      name: "CancelTask",
+      description: "Cancel a running background task by id.",
+      parameters: { type: "object", required: ["id"], properties: { id: { type: "string" } } },
+      run: async ({ id }) => {
+        const rec = this.tasks.get(String(id));
+        if (!rec) return `No task '${id}'.`;
+        if (rec.status !== "running") return `Task ${rec.id} is already ${rec.status}.`;
+        rec.status = "cancelled";
+        rec.controller.abort();
+        return `Task ${rec.id} (${rec.label}) cancelled.`;
+      }
+    };
+  }
+};
+
 // src/mcp.ts
 function toText(result) {
   if (result == null) return "";
@@ -3565,7 +3761,7 @@ var RecordingLifecycle = class {
 
 // src/index.ts
 init_logging();
-import { MemFilesystem as MemFilesystem2, IndexedDbFilesystem, CommandExecutor as CommandExecutor2, registerHeadlessCommands as registerHeadlessCommands2 } from "@livx.cc/wcli/core";
+import { MemFilesystem as MemFilesystem3, IndexedDbFilesystem, CommandExecutor as CommandExecutor2, registerHeadlessCommands as registerHeadlessCommands2 } from "@livx.cc/wcli/core";
 export {
   Agent,
   AgentOptions,
@@ -3574,12 +3770,14 @@ export {
   ConsoleHostBridge,
   DEFAULT_DENY,
   DEFAULT_MUTATING,
+  DuplexAgent,
+  DuplexAgentOptions,
   FakeAIClient,
   IndexedDbFilesystem,
   JailOptions,
   JailedFilesystem,
   LessonOptionsDefaults,
-  MemFilesystem2 as MemFilesystem,
+  MemFilesystem3 as MemFilesystem,
   MountFilesystem,
   NodeDiskFilesystem,
   OverlayFilesystem,
@@ -3589,6 +3787,7 @@ export {
   RecordingLifecycle,
   SandboxJobRegistry,
   ScriptedHostBridge,
+  VOICE_SYSTEM_PROMPT,
   applyEditsTool,
   askUserQuestionTool,
   bashTool,