@livx.cc/agentx 0.99.105 → 0.99.107

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { a as AgentOptions, H as Hooks, n as RunResult, A as Agent, g as PermissionPolicy } from './Agent-BhOcPaxG.js';
-export { C as ChatFragment, b as Classification, c as Classifier, d as CompactResult, D as DEFAULT_MUTATING, e as Decision, M as ModelRouter, f as ModelRouterOptions, P as PermissionOptions, h as PermissionRule, i as PreToolUseDecision, R as ReasoningEffort, j as RecordingHooks, k as RecordingLifecycle, l as RouteDecision, m as RouterState, T as Tier, o as ToolUse, p as ToolUseMeta, q as claudeCodeDisallowedTools, r as composeHooks, s as estimateTokens, t as jevAvailable, u as jevClassifier, v as pickTier, w as planMode, x as reasoningToChatFragment } from './Agent-BhOcPaxG.js';
+import { a as AgentOptions, H as Hooks, p as RunResult, f as Decider, A as Agent, i as PermissionPolicy, L as LineKind, C as ChannelMode, q as SecondChannelOptions, S as SecondChannel } from './secondChannel-BYW5qPAJ.js';
+export { b as ChatFragment, c as Classification, d as Classifier, e as CompactResult, D as DEFAULT_MUTATING, g as Decision, M as ModelRouter, h as ModelRouterOptions, P as PermissionOptions, j as PermissionRule, k as PreToolUseDecision, R as ReasoningEffort, l as RecordingHooks, m as RecordingLifecycle, n as RouteDecision, o as RouterState, T as Tier, r as ToolUse, s as ToolUseMeta, t as claudeCodeDisallowedTools, u as composeHooks, v as estimateTokens, w as jevAvailable, x as jevClassifier, y as pickTier, z as planMode, B as reasoningToChatFragment } from './secondChannel-BYW5qPAJ.js';
 export { MODEL_ALIASES, ModelSwitch, ResolveModelSwitchOpts, latestClaude, modelShortLabel, resolveModelAlias, resolveModelSwitch } from './models.js';
 import { IFilesystem, FileMetadata } from '@livx.cc/wcli/core';
 export { CommandExecutor, FileMetadata, IFilesystem, IndexedDbFilesystem, MemFilesystem, registerHeadlessCommands } from '@livx.cc/wcli/core';
@@ -852,6 +852,8 @@ declare function writeFact(fs: IFilesystem, dir: string, slug: string, body: str
     type?: string;
     description?: string;
 }): Promise<void>;
+/** Delete a fact file and its pointer line in that dir's MEMORY.md. Returns the dirs it was removed from. */
+declare function forgetFact(fs: IFilesystem, dirs: string[], slug: string): Promise<string[]>;
 
 /**
  * Automatic mistake → lesson → steer loop. Closes the within-run learning gap: the agent
@@ -908,17 +910,65 @@ declare function reflectOnRun(o: ReflectOptions): Promise<string | null>;
  */
 declare function loadInstructions(fs: IFilesystem, names?: string[]): Promise<string>;
 
-/** Structural subset of ai.libx.js DecideClient.decide — keeps this module provider-agnostic. */
-interface Decider {
-    decide(o: {
-        state: unknown;
-        questions: Record<string, unknown>;
-    }): Promise<{
-        answers: Record<string, {
-            choice: string;
-            probabilities: Record<string, number>;
-        }>;
-    }>;
+type OverlapVerdict = 'keep' | 'cut';
+
+/** Does the user's line stop mid-phrase (trailing connective / spelled punctuation / comma / slash)? Only the user's own
+ *  words count — host notes appended after a newline ("[the user interrupted you…]") are ignored. */
+declare function endsMidPhrase(text: string): boolean;
+/** A short closing line ("ok bye", "thanks, see you", "ביי", "להתראות"). Long lines that merely contain "bye" are not. */
+declare function isClosing(text: string): boolean;
+interface GateTurn {
+    id: string;
+    /** The user's words, verbatim (several finals joined by a space when merged). */
+    text: string;
+    /** The turn this one replaces (its reply had not started): the host rolls it back. */
+    replaces?: string;
+    /** new = a fresh turn · replace = a fuller re-final of the last · extend = only the words a re-final added after the reply started. */
+    kind: 'new' | 'replace' | 'extend';
+}
+type GateDrop = 'empty' | 'dupe' | 'stale' | 'goodbye';
+declare class TurnGateOptions {
+    holdMs: number;
+    /** An identical final within this window is a duplicate. */
+    dupWindowMs: number;
+    /** A fuller final within this window of the last turn (or with its sttId) is a re-final of it. */
+    refinalWindowMs: number;
+    onTurn: (t: GateTurn) => void;
+    onDrop: (text: string, why: GateDrop) => void;
+    /** A final is being held (ends mid-phrase) — the fill channel may cover it with a filler, never a bridge. */
+    onHold: (text: string) => void;
+    now: () => number;
+}
+declare class TurnGate {
+    options?: Partial<TurnGateOptions> | undefined;
+    private last?;
+    private held?;
+    private seq;
+    private closed;
+    constructor(options?: Partial<TurnGateOptions> | undefined);
+    private get o();
+    /** A closing turn went out — the call is ending. */
+    get ending(): boolean;
+    /** Is a final held right now? */
+    get holding(): boolean;
+    /** The last turn sent (id + text), if any. */
+    get lastTurn(): {
+        id: string;
+        text: string;
+        started: boolean;
+    } | undefined;
+    /** An STT final. */
+    final(text: string, sttId?: string): void;
+    /** The user is speaking again (a partial): a held fragment waits for the rest. */
+    speaking(): void;
+    /** MAIN started replying to turn `id` (its first text/tool/audio): a later re-final only adds its new words. */
+    replyStarted(id: string): void;
+    /** Send a held fragment now (e.g. the call ends). */
+    flush(): void;
+    end(): void;
+    private refinal;
+    private send;
+    private emit;
 }
 
 /**
@@ -1558,6 +1608,144 @@ 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;
 
+type Topic = 'board' | 'search' | 'web' | 'read' | 'write' | 'run' | 'mail' | 'calendar' | 'memory';
+/** Two phrasings per topic and language (never the same line twice in a call). */
+declare const PROGRESS_TEMPLATES: Record<string, Record<Topic, string[]>>;
+declare class ProgressOptions {
+    templates: Record<string, Partial<Record<Topic, string[]>>>;
+    /** Fast-model fallback for a tool with no template (fastProgressGenerator). Absent → silence. */
+    generate?: (tool: string, hint: string, lang: string, signal: AbortSignal) => Promise<string>;
+    generateBudgetMs: number;
+    /** Speak only when nothing has been audible for this long. */
+    silenceMs: number;
+    /** At most one progress line per this long. */
+    gapMs: number;
+    now: () => number;
+}
+declare class Progress {
+    options?: Partial<ProgressOptions> | undefined;
+    private said;
+    private lastAt;
+    private streamed;
+    constructor(options?: Partial<ProgressOptions> | undefined);
+    private get o();
+    /** A new MAIN turn started. */
+    turn(): void;
+    /** MAIN's text streamed this turn: no more progress lines for it. */
+    text(): void;
+    /** May a line play now? (the caller passes when the user last heard anything) */
+    due(lastAudibleAt: number): boolean;
+    /** Mark `line` spoken. */
+    spoke(line: string): void;
+    /** The line for this tool call in `lang`, or '' (no template and no/late/invalid generation, a repeat, a result claim). */
+    line(tool: string, args: unknown, lang: string): Promise<string>;
+}
+
+type FillKind = LineKind | 'progress';
+/** MAIN's stream as the host forwards it. `id` = the turn (sendTurn's id); absent → the current turn. */
+interface MainEvent {
+    type: 'start' | 'text' | 'tool' | 'tool_done' | 'audio' | 'done' | 'error';
+    id?: string;
+    text?: string;
+    name?: string;
+    args?: unknown;
+}
+interface CallMetric {
+    name: 'first_sound' | 'first_word' | 'turn' | 'drop' | 'hold' | 'fill' | 'lang';
+    id?: string;
+    /** ms from the user's final (the first final of a held/merged turn) */
+    ms?: number;
+    by?: 'fill' | 'progress' | 'main';
+    kind?: string;
+    text?: string;
+    lang?: string | null;
+}
+declare class VoiceCallOptions {
+    /** Host runs MAIN with exactly `text` (a replace: roll the `replaces` turn back first). */
+    sendTurn: (text: string, o: {
+        id: string;
+        replaces?: string;
+    }) => void;
+    /** Host aborts a running MAIN turn (barge-in). */
+    abortTurn: (id: string) => void;
+    /** Host TTS (fill lane): resolves when played; `false` = could not play. */
+    speak: (text: string, kind: FillKind) => Promise<unknown> | boolean;
+    /** Stop the in-flight fill line now (barge-in only). */
+    cancel: () => void;
+    /** Host caption — never history. */
+    show: (text: string, kind: FillKind) => void;
+    /** The fast model (lines, banks, progress) — used only with `ai`. */
+    fastModel: string;
+    /** Model client for the fast model + the channel decider / overlap judge. Absent → canned lines and rules only. */
+    ai?: ChatLike;
+    /** Cache dir for per-language banks (ChannelBanks). */
+    bankCacheDir?: string;
+    /** The host STT's language (BCP-47) — the starting language; each turn's own words still decide. */
+    lang?: string;
+    aec: boolean;
+    mode: ChannelMode;
+    gate: Partial<TurnGateOptions>;
+    progress: Partial<ProgressOptions>;
+    /** Extra SecondChannel options (tests, tuning). speak/show/cancel are always VoiceCall's own. */
+    channel: Partial<SecondChannelOptions>;
+    onMetric: (m: CallMetric) => void;
+    now: () => number;
+}
+declare class VoiceCall {
+    options?: Partial<VoiceCallOptions> | undefined;
+    readonly fill: SecondChannel;
+    readonly gate: TurnGate;
+    readonly progress: Progress;
+    private judge;
+    private cur?;
+    private lang;
+    private lastAudibleAt;
+    private firstFinalAt;
+    private progressTimer;
+    private ended;
+    constructor(options?: Partial<VoiceCallOptions> | undefined);
+    private get o();
+    /** The language the fill channel speaks right now (null = unknown → silent). */
+    get language(): string | null;
+    /** The MAIN turn in flight (or the last one). */
+    get turn(): {
+        id: string;
+        text: string;
+        running: boolean;
+    } | undefined;
+    /** The host STT's language (BCP-47): the current language until the user's words say otherwise. */
+    setLanguage(tag: string): void;
+    /** STT partial (the whole partial). */
+    interim(text: string, _atMs?: number, aec?: boolean): void;
+    /** STT final → TurnGate. */
+    final(text: string, sttId?: string): void;
+    /** A v2 host that decides turns itself: the user's line already went to MAIN (no TurnGate, no sendTurn) — the fill
+     *  channel follows its language and covers the wait. */
+    hostTurn(text: string): void;
+    pause(ms: number): void;
+    /** MAIN's stream. */
+    main(ev: MainEvent): void;
+    /** The user barged in (hard): cut fill + MAIN audio (the host cuts its own), abort a running MAIN turn. */
+    barge(): void;
+    /** Soft barge-in: keep (a listener cue — no turn) or cut (→ barge()). */
+    overlap(text: string): Promise<OverlapVerdict>;
+    /** Did the last barge cut OUR fill line `text`? (hosts strip it from the cut reply — it is not MAIN's speech) */
+    spoke(text: string): boolean;
+    /** Resolves when the in-flight fill line finished — hosts queue MAIN audio behind it (stack, don't cut). */
+    drain(): Promise<void>;
+    end(): void;
+    /** Follow the user's language from their own words: a confident detection, else the current language if the words
+     *  fit it, else unknown (silent). Pinned into the channel so its own detection never diverges. */
+    private follow;
+    private onTurn;
+    private onDrop;
+    /** Every fill/progress line passes here: only in the turn's known language, never after the call ended. */
+    private say;
+    private sounded;
+    private onTool;
+    private clearProgress;
+}
+
 declare function validateWorktreeSlug(slug: string): void;
 declare function worktreeBranchName(slug: string): string;
 interface WorktreeInfo {
@@ -1589,4 +1777,4 @@ declare function exitWorktree(): {
     reason?: string;
 } | null;
 
-export { Agent, type AgentDef, AgentOptions, AgentTool, type AskOptions, type Attempt, BodDbFilesystem, ChatLike, ChatOptions, ChatResponse, type CommandInfo, ConsoleHostBridge, DEFAULT_DENY, DEFAULT_MAX_DEPTH, DEFAULT_SKIP_DIRS, DuplexAgent, DuplexAgentOptions, type DuplexTaskStatus, FakeAIClient, type FileScanOptions, Hooks, HostBridge, JailOptions, JailedFilesystem, type LessonOptions, LessonOptionsDefaults, type LoadMemoryOpts, MEMORY_PROMPT, MessageContent, type Mount, MountFilesystem, NodeDiskFilesystem, OverlayFilesystem, PermissionPolicy, type ReflectOptions, RunResult, SCRATCH_DIR, type ScheduledJob, type ScheduledJobSnapshot, Scheduler, type SchedulerOptions, Scratch, type ScratchOptions, ScriptedHostBridge, type SiblingResolver, type SkillInfo, type TaskRecord, type TaskToolOptions, ToolCall, type ToolSpec, type Trigger, type TriggerCron, type TriggerInterval, type TriggerOneOff, UserQuestion, VOICE_MEMORY_PROMPT, VOICE_SYSTEM_PROMPT, type WebFetchOptions, type WebSearchOptions, type WorkerTier, type WorktreeInfo, type WorktreeSession, applyEditsTool, askUserQuestionTool, checkpointTool, checkpointTools, cleanupWorktree, compileSynthesizedTool, cronMatches, decodeDdgUrl, diskAgentOptions, enterWorktree, exitWorktree, expandCommand, expandEntry, expandTemplate, findGitRoot, forComponent, fullAgentOptions, getOrCreateWorktree, getWorktreeSession, globTool, grepTool, htmlToText, idfWeights, lessonCapture, loadAgents, loadCommands, loadInstructions, loadMemory, loadSkills, makeAskTool, makeGlobTool, makeGrepTool, makeScheduleTools, makeTaskBatchTool, makeTaskTool, makeWebFetchTool, makeWebSearchAnthropicTool, makeWebSearchTool, mkdirp, multiEditTool, nextCronAfter, parseCron, parseDdgHtml, raceAttempts, reflectOnRun, relevanceScore, repoIndex, repoMapTool, rollbackTool, sandboxAgentOptions, scanCommands, scanSkills, slugify, tokenize, toolCall, topByRelevance, validateToolCode, validateWorktreeSlug, webFetchTool, webSearchAnthropicTool, webSearchTool, worktreeBranchName, writeFact, writeTool };
+export { Agent, type AgentDef, AgentOptions, AgentTool, type AskOptions, type Attempt, BodDbFilesystem, type CallMetric, ChatLike, ChatOptions, ChatResponse, type CommandInfo, ConsoleHostBridge, DEFAULT_DENY, DEFAULT_MAX_DEPTH, DEFAULT_SKIP_DIRS, DuplexAgent, DuplexAgentOptions, type DuplexTaskStatus, FakeAIClient, type FileScanOptions, type FillKind, type GateDrop, type GateTurn, Hooks, HostBridge, JailOptions, JailedFilesystem, type LessonOptions, LessonOptionsDefaults, type LoadMemoryOpts, MEMORY_PROMPT, type MainEvent, MessageContent, type Mount, MountFilesystem, NodeDiskFilesystem, OverlayFilesystem, PROGRESS_TEMPLATES, PermissionPolicy, Progress, ProgressOptions, type ReflectOptions, RunResult, SCRATCH_DIR, type ScheduledJob, type ScheduledJobSnapshot, Scheduler, type SchedulerOptions, Scratch, type ScratchOptions, ScriptedHostBridge, type SiblingResolver, type SkillInfo, type TaskRecord, type TaskToolOptions, ToolCall, type ToolSpec, type Trigger, type TriggerCron, type TriggerInterval, type TriggerOneOff, TurnGate, TurnGateOptions, UserQuestion, VOICE_MEMORY_PROMPT, VOICE_SYSTEM_PROMPT, VoiceCall, VoiceCallOptions, type WebFetchOptions, type WebSearchOptions, type WorkerTier, type WorktreeInfo, type WorktreeSession, applyEditsTool, askUserQuestionTool, checkpointTool, checkpointTools, cleanupWorktree, compileSynthesizedTool, cronMatches, decodeDdgUrl, diskAgentOptions, endsMidPhrase, enterWorktree, exitWorktree, expandCommand, expandEntry, expandTemplate, findGitRoot, forComponent, forgetFact, fullAgentOptions, getOrCreateWorktree, getWorktreeSession, globTool, grepTool, htmlToText, idfWeights, isClosing, lessonCapture, loadAgents, loadCommands, loadInstructions, loadMemory, loadSkills, makeAskTool, makeGlobTool, makeGrepTool, makeScheduleTools, makeTaskBatchTool, makeTaskTool, makeWebFetchTool, makeWebSearchAnthropicTool, makeWebSearchTool, mkdirp, multiEditTool, nextCronAfter, parseCron, parseDdgHtml, raceAttempts, reflectOnRun, relevanceScore, repoIndex, repoMapTool, rollbackTool, sandboxAgentOptions, scanCommands, scanSkills, slugify, tokenize, toolCall, topByRelevance, validateToolCode, validateWorktreeSlug, webFetchTool, webSearchAnthropicTool, webSearchTool, worktreeBranchName, writeFact, writeTool };