agent.libx.js 0.93.8 → 0.93.10

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { a as AgentOptions, H as Hooks, h as RunResult, A as Agent } from './Agent-B_xvSHlG.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-B_xvSHlG.js';
+import { a as AgentOptions, H as Hooks, h as RunResult, A as Agent } from './Agent-Di1u5nH0.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-Di1u5nH0.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';
@@ -572,12 +572,16 @@ 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`.
+ * DuplexAgent — voice-optimized three-tier 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`).
+ * Three cognitive tiers (like a human brain):
+ *   REFLEX — fast voice agent (streams instant replies, owns THE transcript, the only voice the
+ *            user hears). Handles simple questions, routes complex work to Act or Think.
+ *   ACT    — standard worker (Sonnet-class). Full tools, file access, shell. The hands.
+ *   THINK  — premium reasoning (Opus-class). Deep analysis, architecture, hard problems. The brain.
+ *
+ * Workers are spawned per escalation via `Act`/`Think` tools. Results are pushed back as
+ * `[task <id> completed] …` events and re-voiced by the reflex — push, not poll.
  *
  * Host events (via the open HostEvent union): the voice agent's standard `text_delta` stream,
  * plus `task_started` / `task_progress` / `task_done` / `task_error` / `task_cancelled`.
@@ -592,16 +596,20 @@ interface TaskRecord {
     /** Settles when the worker finished AND its completion was processed. Never rejects. */
     promise: Promise<void>;
 }
+type WorkerTier = 'act' | 'think';
 declare class DuplexAgentOptions {
-    /** Any ai.libx.js AIClient — shared by the voice and worker agents (routed by model). */
+    /** Any ai.libx.js AIClient — shared by all tiers (routed by model). */
     ai: ChatLike;
-    /** The WORKER's filesystem. If omitted the worker keeps Agent's jailed-disk-at-cwd default. */
+    /** The WORKER's filesystem (act + think). If omitted the worker keeps Agent's jailed-disk-at-cwd default. */
     fs?: IFilesystem;
-    voiceModel: string;
-    workerModel: string;
+    reflexModel: string;
+    actModel: string;
+    /** Premium reasoning model. Set to `false` to disable the Think tier entirely. */
+    thinkModel: string | false;
     /** Escape hatches merged over the derived per-agent options. */
-    voiceOptions?: Partial<AgentOptions>;
-    workerOptions?: Partial<AgentOptions>;
+    reflexOptions?: Partial<AgentOptions>;
+    actOptions?: Partial<AgentOptions>;
+    thinkOptions?: 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. */
@@ -609,7 +617,7 @@ declare class DuplexAgentOptions {
     /** 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.
+    /** Awaited BEFORE a 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
@@ -634,8 +642,8 @@ declare class DuplexAgentOptions {
 }
 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
+ * The duplex orchestrator. `send()` enqueues a user turn on the reflex agent; `Act`/`Think`
+ * spawn detached workers whose completions enqueue re-voice turns. 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.
  */
@@ -657,7 +665,7 @@ declare class DuplexAgent {
     constructor(options?: Partial<DuplexAgentOptions>);
     /** Resolve memory tools + inject index into voice system prompt (once). */
     private initMemory;
-    /** One user turn: the voice agent streams the reply (and may Delegate). Serialized with re-voice turns. */
+    /** One user turn: the voice agent streams the reply (and may Act/Think). 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>;
@@ -666,7 +674,10 @@ declare class DuplexAgent {
     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. */
+    /** The worker's brief: the Act/Think args + a STATIC text snapshot of the recent conversation.
+     *  Act briefs get a self-verify footer — the worker's report is trusted without review, so it
+     *  must check its own work before reporting (nearly free under prompt caching; measured honest:
+     *  it does NOT fix one-shot logic bugs — see mind/10). Think tasks are pure reasoning — no footer. */
     private buildBrief;
     /** Spawn a detached worker for task `id`; its settlement notifies + enqueues the re-voice turn. */
     private spawnWorker;
@@ -684,13 +695,22 @@ declare class DuplexAgent {
     private onWorkerSettled;
     private onWorkerFailed;
     private failTask;
-    private delegateTool;
+    /** Live-switch the think tier: `false` disables (removes the Think tool from the voice agent),
+     *  a model id enables (adds the tool if missing). The system-prompt THINK_SLOT text is frozen at
+     *  construction — the tool's own description carries the routing guidance, so a live enable works;
+     *  dispatch()'s think→act fallback covers any straggler calls after a live disable. */
+    setThinkModel(model: string | false): void;
+    /** User/programmatic spawn: the CLI's /act and /think commands. Returns the task id. */
+    dispatch(brief: string, tier?: WorkerTier, label?: string): Promise<string>;
+    private actTool;
+    private thinkTool;
     private taskStatusTool;
-    /** Sub-100ms read-only lookups the voice may do itself — everything else stays Delegate-only.
+    /** Sub-100ms read-only lookups the voice may do itself — everything else stays Act-only.
      *  fs-only (no shell; the engine is VFS-abstracted): time, git branch (.git/HEAD read), ls, file
      *  head. Output is hard-capped so a lookup can never bloat the skinny voice context. */
     private quickLookTool;
     private answerTaskTool;
+    private holdTool;
     private cancelTaskTool;
 }
 
@@ -838,6 +858,13 @@ declare class VoiceEngineOptions {
      *  letters, mid-thought pauses), the next utterance MERGES instead of dispatching a truncated one
      *  ("E-L-Y." / "A."). Costs this much latency per turn; 0 disables. */
     utteranceMergeMs: number;
+    /** Extended merge window (ms) for utterances that look incomplete (trailing conjunction/filler).
+     *  Gives the user time to finish their thought without triggering a model call. */
+    incompleteMergeMs: number;
+    /** Filler phrase spoken when holding for an incomplete utterance ('' disables). */
+    holdFiller: string;
+    /** Called when the engine holds an incomplete utterance (host can render a visual cue). */
+    onHold: () => void;
     /** heuristic (non-AEC) energy barge-in tuning */
     bargeRmsMult: number;
     bargeRmsFloor: number;
@@ -897,6 +924,8 @@ declare class VoiceEngine {
         full: string;
         heard: string;
     } | null;
+    /** Speak a short filler phrase without starting a model turn (stays in listening mode after). */
+    speakFiller(text: string): void;
     /** barge-in: stop audio NOW, cancel generation, reset for the user's utterance */
     interrupt(): void;
     stop(): void;
@@ -910,6 +939,9 @@ declare class VoiceEngine {
      *  longer ones on count. */
     private genuine;
     private handlePartial;
+    private static readonly TRAIL_RE;
+    /** The utterance sounds like the user paused mid-thought (trailing conjunction/filler/comma). */
+    private looksIncomplete;
     private handleUtterance;
     private flushUtterance;
     private get overlapCapable();
@@ -968,6 +1000,12 @@ declare class CartesiaTTS {
     onAudio: (chunk: Uint8Array) => void;
     onDone: () => void;
     firstAudioAt: number;
+    /** Circuit breaker: consecutive error count + down flag. */
+    private consecutiveErrors;
+    private down;
+    private probeTimer;
+    private static readonly CB_THRESHOLD;
+    private static readonly CB_PROBE_MS;
     constructor(options?: Partial<CartesiaTTSOptions>);
     private closed;
     private connecting;
@@ -980,7 +1018,9 @@ declare class CartesiaTTS {
     speak(text: string, cont: boolean): void;
     end(): void;
     cancel(): void;
+    private startProbe;
+    private stopProbe;
     close(): void;
 }
 
-export { Agent, type AgentDef, AgentOptions, AgentTool, type Attempt, type AudioSink, type AudioSource, type AuthProvider, BodDbFilesystem, CartesiaTTS, CartesiaTTSOptions, ChatLike, ChatOptions, ChatResponse, type CommandInfo, ConsoleHostBridge, DEFAULT_DENY, DuplexAgent, DuplexAgentOptions, type DuplexTaskStatus, FakeAIClient, Hooks, HostBridge, JailOptions, JailedFilesystem, type LessonOptions, LessonOptionsDefaults, type LoadMemoryOpts, MEMORY_PROMPT, MessageContent, type Mount, MountFilesystem, NodeDiskFilesystem, OverlayFilesystem, type ReflectOptions, RunResult, STT_SAMPLE_RATE, ScriptedHostBridge, type SkillInfo, SonioxSTT, SonioxSTTOptions, type SttLike, TTS_SAMPLE_RATE, type TaskRecord, type TaskToolOptions, ToolCall, type ToolSpec, type TtsLike, UserQuestion, VOICE_MEMORY_PROMPT, VOICE_SYSTEM_PROMPT, VoiceEngine, VoiceEngineOptions, type VoiceState, 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, resolveAuth, rollbackTool, sandboxAgentOptions, slugify, tokenize, toolCall, topByRelevance, validateToolCode, webFetchTool, webSearchTool, writeFact, writeTool };
+export { Agent, type AgentDef, AgentOptions, AgentTool, type Attempt, type AudioSink, type AudioSource, type AuthProvider, BodDbFilesystem, CartesiaTTS, CartesiaTTSOptions, ChatLike, ChatOptions, ChatResponse, type CommandInfo, ConsoleHostBridge, DEFAULT_DENY, DuplexAgent, DuplexAgentOptions, type DuplexTaskStatus, FakeAIClient, Hooks, HostBridge, JailOptions, JailedFilesystem, type LessonOptions, LessonOptionsDefaults, type LoadMemoryOpts, MEMORY_PROMPT, MessageContent, type Mount, MountFilesystem, NodeDiskFilesystem, OverlayFilesystem, type ReflectOptions, RunResult, STT_SAMPLE_RATE, ScriptedHostBridge, type SkillInfo, SonioxSTT, SonioxSTTOptions, type SttLike, TTS_SAMPLE_RATE, type TaskRecord, type TaskToolOptions, ToolCall, type ToolSpec, type TtsLike, UserQuestion, VOICE_MEMORY_PROMPT, VOICE_SYSTEM_PROMPT, VoiceEngine, VoiceEngineOptions, type VoiceState, type WebFetchOptions, type WebSearchOptions, type WorkerTier, 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, resolveAuth, rollbackTool, sandboxAgentOptions, slugify, tokenize, toolCall, topByRelevance, validateToolCode, webFetchTool, webSearchTool, writeFact, writeTool };