@livx.cc/agentx 0.99.105 → 0.99.107

package/dist/{Agent-BhOcPaxG.d.ts → secondChannel-BYW5qPAJ.d.ts}

@@ -771,4 +771,293 @@ declare class Agent {
  *  stub made `/compact` chase a target it could never reach and drop-oldest the conversation away. */
 declare function estimateTokens(m: Message[], keepRecentImages?: number, vision?: boolean): number;
 
-export { Agent as A, type ChatFragment as C, DEFAULT_MUTATING as D, type Hooks as H, ModelRouter as M, PermissionOptions as P, type ReasoningEffort as R, type Tier as T, AgentOptions as a, type Classification as b, type Classifier as c, type CompactResult as d, type Decision as e, ModelRouterOptions as f, PermissionPolicy as g, type PermissionRule as h, type PreToolUseDecision as i, RecordingHooks as j, RecordingLifecycle as k, type RouteDecision as l, type RouterState as m, type RunResult as n, type ToolUse as o, type ToolUseMeta as p, claudeCodeDisallowedTools as q, composeHooks as r, estimateTokens as s, jevAvailable as t, jevClassifier as u, pickTier as v, planMode as w, reasoningToChatFragment as x };
+/** 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>;
+        }>;
+    }>;
+}
+/** Duplex v2 second-channel actions (Instinct.channel's Choice). The silence bias lives in the CRITERIA, not prose: a
+ *  greeting or a quick full turn the reflex answers at once scores `silence` (v1's failure: "hmm ok" after a bare "hey"). */
+declare const CHANNEL_ACTIONS: {
+    readonly silence: "the default — nothing to add. ALWAYS for a greeting, thanks, a yes/no, or any short complete turn the real reply will answer instantly (\"hey\", \"how are you?\", \"thanks\"); also mid-word or mid-clause";
+    readonly backchannel: "they are mid-way through a longer story or explanation (several clauses) and just closed a clause: a tiny \"mm-hm\"/\"right\" shows you follow, without taking the turn";
+    readonly filler: "they paused mid-thought, searching for words, and a soft \"hmm\" keeps the line warm";
+    readonly bridge: "they finished a substantial request or hard question and the real answer takes a moment: a short \"let me check—\" lead-in";
+};
+type ChannelKind = keyof typeof CHANNEL_ACTIONS;
+
+declare const TURN_TYPES: readonly ["story", "list", "complaint", "explanation", "short_command", "question", "other"];
+type TurnType = typeof TURN_TYPES[number];
+declare const DENSITIES: readonly ["none", "low", "normal", "high"];
+type Density = typeof DENSITIES[number];
+interface Cue {
+    when: string[];
+    line: string;
+}
+interface BcPlan {
+    turn: TurnType;
+    density: Density;
+    cues: Cue[];
+}
+/** The plan's micro-context — never history. */
+interface PlanContext {
+    /** The agent's last reply (the user's next turn answers it). */
+    agent: string;
+    /** The tail of the user's previous turn. */
+    user: string;
+    /** Recent channel lines — not to be reused. */
+    recent: string[];
+    lang: string;
+    /** Revision only: what the user has said so far in this turn. */
+    heard?: string;
+}
+
+type LineKind$1 = Exclude<ChannelKind, 'silence'>;
+/** `phatic` = greeting/thanks/yes-no openers in this language: a short turn starting with one is answered by the reflex
+ *  instantly, so the channel stays silent (never "hmm" after "hi"). Not a spoken kind. */
+type Bank = Record<LineKind$1 | 'phatic', string[]>;
+declare class ChannelBanksOptions {
+    /** Raw bank for a language (fastBankGenerator). Absent → English fallback only. */
+    generate?: (lang: string, avoid: string[], signal: AbortSignal) => Promise<unknown>;
+    /** Disk cache dir (one `<lang>.json` per language). Absent → in-memory only. */
+    cacheDir?: string;
+    /** A cached bank older than this is still used, and topped up by one background call. */
+    refreshMs: number;
+    /** Lines kept per kind (newest win) — the cap on growth. */
+    maxPerKind: number;
+    timeoutMs: number;
+    /** After a failed cold generation, the next attempt waits this long. */
+    retryMs: number;
+    /** Cold-start/offline banks (English only by default). */
+    fallback: Record<string, Bank>;
+    /** Hand-checked banks: used as-is for their language — never generated, cached or topped up. */
+    curated: Record<string, Bank>;
+    now: () => number;
+}
+declare class ChannelBanks {
+    options?: Partial<ChannelBanksOptions> | undefined;
+    private banks;
+    private pending;
+    constructor(options?: Partial<ChannelBanksOptions> | undefined);
+    private get o();
+    /** The bank to speak from for `lang` now — generated/cached, else the fallback, else null (= stay silent). */
+    get(lang: string): Bank | null;
+    /** Load (cache) and/or generate `lang`'s bank in the background. Never throws, never blocks the caller. */
+    ensure(lang: string): Promise<void>;
+    private file;
+    private load;
+    private generate;
+}
+
+type LineKind = Exclude<ChannelKind, 'silence'>;
+/** The main (channel-1) response lifecycle. `idle` = no turn in flight (the user has the floor). */
+type MainState = 'idle' | 'queued' | 'thinking' | 'streaming_text' | 'first_audio' | 'speaking';
+type Trigger = 'interim' | 'pause' | 'working';
+/** The micro-context a generator gets: a tiny tail, never history. */
+interface ChannelContext {
+    kind: LineKind;
+    /** The last ~microWords words the user said. */
+    heard: string;
+    state: MainState;
+    /** The last few channel lines — do not reuse. */
+    avoid: string[];
+    /** The user's language (BCP-47 primary code) — the line is written in it. */
+    lang: string;
+    /** A content reaction (chatty): "oh no", "wait, really?", a key-word echo — not just an "mm-hm". */
+    react?: boolean;
+}
+interface ChannelEvent {
+    trigger: Trigger;
+    rule: ChannelKind;
+    choice?: string;
+    acted: 'spoken' | 'silence' | 'stale' | 'gated' | 'skipped' | 'no_bank';
+    kind?: LineKind;
+    text?: string;
+    /** The backchannel came from a planned cue (anticipate) — its matched line. */
+    cue?: string;
+    ms: number;
+}
+/** How talkative the second channel is (`--channel-mode`). */
+type ChannelMode = 'turn' | 'normal' | 'chatty';
+declare class SecondChannelOptions {
+    /** Preset (CHANNEL_MODES) under the explicit options. */
+    mode: ChannelMode;
+    /** Line kinds this channel may speak. */
+    kinds: LineKind[];
+    /** A generated (content) backchannel needs this long since the last one; in between, canned light cues. 0 = always. */
+    reactionGapMs: number;
+    /** Refiner (Jev/fast LLM): the choice over CHANNEL_ACTIONS, or null on failure. Absent → the rule alone decides.
+     *  `state.rule` is the kind the rule proposed (fastChannelDecider answers yes/no on it). `signal` aborts a late call. */
+    decide?: (heard: string, state: Record<string, unknown>, signal?: AbortSignal) => Promise<{
+        choice: string;
+    } | null>;
+    /** Fast-model line writer (see fastLineGenerator). Absent or late → the canned bank. */
+    generate?: (ctx: ChannelContext, signal: AbortSignal) => Promise<string>;
+    /** Per-language banks (ChannelBanks). Absent → the hardcoded English bank, and silence in any other language. */
+    banks?: Pick<ChannelBanks, 'get' | 'ensure'>;
+    /** The host's language (BCP-47; pinned — detection never overrides it). Absent → unknown until the user's words
+     *  tell it confidently; the channel is silent until then (never English by default). */
+    lang?: string;
+    /** Kinds worth generating (content-conditioned); the rest are canned sounds. */
+    generateFor: LineKind[];
+    /** Host TTS on the second channel; resolves when the line finished playing. `false` = the host could not play it. */
+    speak: (text: string, kind: LineKind) => Promise<unknown> | boolean | void;
+    /** Host UI (caption / muted line) — never history. */
+    show: (text: string, kind: LineKind) => void;
+    /** Stop the in-flight line's audio now (barge-in only). */
+    cancel: () => void;
+    onEvent: (e: ChannelEvent) => void;
+    /** Echo cancellation on: backchannels may play while the user speaks. Off (half-duplex) → fillers/bridges in silences only. */
+    aec: boolean;
+    decideEveryWords: number;
+    decisionBudgetMs: number;
+    generateBudgetMs: number;
+    minGapMs: number;
+    /** Backchannel after backchannel needs this gap (~4-6 cues in a 30s monologue — Para phone call 2026-10-13: 5s left
+     *  one cue in a long statement). */
+    backchannelGapMs: number;
+    /** Soft cap: at most this many backchannels in any `windowMs` (0 = none). */
+    maxPerWindow: number;
+    windowMs: number;
+    /** The user resumes within this long of their last words after a line of theirs was dispatched: the same statement goes
+     *  on (an STT endpoint mid-monologue) — its words still count toward the backchannel guards, and it is no fresh request. */
+    continueMs: number;
+    /** A decision whose partial grew by this many words while in flight is stale → dropped. */
+    staleWords: number;
+    microWords: number;
+    avoidLines: number;
+    /** Canned picks exclude the last N picks of the same kind. */
+    bankExclude: number;
+    /** A backchannel needs a substantial chunk first: a turn of ≤8 words is a request/answer, not a story (replay: most
+     *  misplaced "mm-hm"s fired at words 6-8 of a short command). */
+    backchannelMinWords: number;
+    /** A turn that opens as a question/command (requestOpener) holds backchannels until it has grown into an explanation. */
+    requestHoldWords: number;
+    /** No new interim for this long mid-utterance (a breath / clause gap, shorter than a pause) → a backchannel moment. */
+    backchannelPauseMs: number;
+    /** A bridge waits this long after the user's turn is dispatched, and plays only if channel-1 has said nothing yet
+     *  (a fast reply/ack needs no bridge — one before it reads as the agent starting a different sentence). 0 = at once. */
+    bridgeDelayMs: number;
+    /** No new interim for this long → a pause (hosts may also call onPause). */
+    fillerPauseMs: number;
+    fillerMinWords: number;
+    bridgeMinWords: number;
+    /** ANTICIPATE (backchannelPlan.ts): plan the user's next turn off the hot path (after the agent's reply / at turn start,
+     *  revised once at `reviseAtWords`); live, a backchannel fires only on a planned cue, at a `cuePauseMs` breath, with the
+     *  cue's line and no decider call. A silent plan (short command / question / density none) vetoes backchannels. No plan
+     *  yet / failed / late → the reactive path. Off by default (AGENTX_CHANNEL_ANTICIPATE=1). */
+    anticipate: boolean;
+    plan?: (ctx: PlanContext, signal: AbortSignal) => Promise<BcPlan | null>;
+    planBudgetMs: number;
+    reviseAtWords: number;
+    /** A predicted moment needs only a short breath (the decision is already made). */
+    cuePauseMs: number;
+    /** A cue counts only within the last N words (older matches were gated or passed). */
+    cueWindow: number;
+    /** true: a plan fires on its cues only. false: a non-silent plan with density normal/high also lets the reactive breath
+     *  backchannel through (the plan then only vetoes short commands / questions / low density). */
+    cueOnly: boolean;
+    onPlan: (p: BcPlan, revised: boolean, ms: number) => void;
+    now: () => number;
+    random: () => number;
+}
+declare class SecondChannel {
+    options?: Partial<SecondChannelOptions> | undefined;
+    private heard;
+    private userSpeaking;
+    private main;
+    private gen;
+    private decidedAt;
+    private busy;
+    private pauseTimer;
+    private bcTimer;
+    private bridgeTimer;
+    private lastAt;
+    private lastKind;
+    private live;
+    private cutLine;
+    private bridged;
+    private recent;
+    private picks;
+    private inflight;
+    private readonly startedAt;
+    private lang;
+    private carried;
+    private floorWords;
+    private lastHeardAt;
+    private pinned;
+    private turnNo;
+    private plan;
+    private planning;
+    private planTries;
+    private revised;
+    private cueFrom;
+    private reply;
+    private lastUser;
+    private lastReactAt;
+    private normalTiming;
+    private degradedLogged;
+    constructor(options?: Partial<SecondChannelOptions> | undefined);
+    /** The language lines are spoken in (detected from the user's words, or set by the host). */
+    get language(): string | null;
+    /** Switch language: its bank starts loading in the background. `host` = the host's STT-reported language — it pins
+     *  the language (later detection never overrides it; only another host call does). Tags normalize to 'he-IL' → 'he'. */
+    setLanguage(tag: string, host?: boolean): void;
+    /** Once a language is known, switching needs strong evidence (detectLanguage's `switching`): an English "Um," read as
+     *  Portuguese flipped a live session to pt (silence until a pt bank was generated — it then spoke Portuguese). */
+    private detect;
+    private get bank();
+    private get o();
+    /** The user's live partial for the current turn (the whole partial, not a delta). */
+    onInterim(text: string): void;
+    /** The user went quiet for `ms` (host VAD/STT pause, or the internal interim timer). */
+    onPause(ms: number): void;
+    /** Channel-1 lifecycle. `queued` = the user's turn was dispatched to the main agent. */
+    onAgentState(s: MainState): void;
+    /** The user's final line was dispatched to the main agent (its words are the bridge's micro-context). */
+    onUserTurn(text: string): void;
+    /** The main answer's streamed text (before its audio): channel-1 is responding — no bridge from here on. */
+    onMainTokens(text: string): void;
+    /** Channel-1's reply text (a delta) — only the plan's context; no state change (hosts without onMainTokens). */
+    noteReply(text: string): void;
+    /** The user barged in: cut the in-flight line now and drop every pending decision. */
+    onBargeIn(): void;
+    /** Is `text` the line the last barge-in cut (ours, still holding the floor)? Hosts strip it from the cut reply — it is
+     *  not the agent's speech. By identity, not by text: a real reply that merely repeats a recent line is kept. Consumed once. */
+    spoke(text: string): boolean;
+    /** Resolves when the in-flight line finished playing (immediately when none) — hosts enqueue channel-1 audio behind it. */
+    drain(): Promise<void>;
+    /** Channel-1's last reply ended on a CLOSED question (yes/no, "X or Y?", a confirm): the user's current turn answers or
+     *  corrects it. An open invitation ("what happened?") is different — a story follows, and reactions fit it. */
+    private get answeringUs();
+    private get audioLocked();
+    private tail;
+    /** Hard gates every line passes, whoever proposed it. */
+    private allowed;
+    private bcTimes;
+    private capped;
+    /** 0ms rule: the candidate line for this trigger, or silence. */
+    private rule;
+    /** Plan (or, with `heard`, revise) the backchannels of the user's turn — async, never on the hot path. */
+    private requestPlan;
+    /** A clause boundary mid-floor: a breath or a comma-like close. Not a question (it wants the answer, not "mm-hm"), and a
+     *  sentence end only deep into a story — a short request's end is the end of their turn (replay: "mm-hm" right after
+     *  "Check hacker news for recent news.", just before the final). */
+    private backchannelMoment;
+    private consider;
+    private state;
+    private line;
+    /** Canned rotation in the user's language: never one of the last `bankExclude` picks of this kind, nor a recent
+     *  line. '' = no bank for this language yet (silence). */
+    private pick;
+    private say;
+}
+
+export { Agent as A, reasoningToChatFragment as B, type ChannelMode as C, DEFAULT_MUTATING as D, type Hooks as H, type LineKind as L, ModelRouter as M, PermissionOptions as P, type ReasoningEffort as R, SecondChannel as S, type Tier as T, AgentOptions as a, type ChatFragment as b, type Classification as c, type Classifier as d, type CompactResult as e, type Decider as f, type Decision as g, ModelRouterOptions as h, PermissionPolicy as i, type PermissionRule as j, type PreToolUseDecision as k, RecordingHooks as l, RecordingLifecycle as m, type RouteDecision as n, type RouterState as o, type RunResult as p, SecondChannelOptions as q, type ToolUse as r, type ToolUseMeta as s, claudeCodeDisallowedTools as t, composeHooks as u, estimateTokens as v, jevAvailable as w, jevClassifier as x, pickTier as y, planMode as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livx.cc/agentx",
-  "version": "0.99.105",
+  "version": "0.99.107",
   "description": "Edge-native AI agent runtime — drives a virtual filesystem via any LLM (ai.libx.js). Same bytes run in node, browser, or edge.",
   "type": "module",
   "main": "./dist/index.js",