@absolutejs/voice 0.0.22-beta.66 → 0.0.22-beta.661

package/dist/client/actions.d.ts

@@ -1,4 +1,4 @@
-import type { VoiceServerMessage } from '../types';
+import type { VoiceServerMessage } from "../core/types";
 export declare const serverMessageToAction: <TResult = unknown>(message: VoiceServerMessage<TResult>) => {
     chunk: Uint8Array<ArrayBuffer>;
     format: import("..").AudioFormat;
@@ -6,26 +6,64 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     turnId: string | undefined;
     type: "audio";
     text?: undefined;
+    delta?: undefined;
     sessionId?: undefined;
+    reconnect?: undefined;
     event?: undefined;
     message?: undefined;
+    recoverable?: undefined;
     transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
     scenarioId?: undefined;
+    sessionMetadata?: undefined;
     status?: undefined;
+    turns?: undefined;
     turn?: undefined;
 } | {
     text: string;
+    turnId: string | undefined;
     type: "assistant";
     chunk?: undefined;
     format?: undefined;
     receivedAt?: undefined;
-    turnId?: undefined;
+    delta?: undefined;
     sessionId?: undefined;
+    reconnect?: undefined;
     event?: undefined;
     message?: undefined;
+    recoverable?: undefined;
     transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
     scenarioId?: undefined;
+    sessionMetadata?: undefined;
     status?: undefined;
+    turns?: undefined;
+    turn?: undefined;
+} | {
+    delta: string;
+    turnId: string | undefined;
+    type: "assistant_delta";
+    chunk?: undefined;
+    format?: undefined;
+    receivedAt?: undefined;
+    text?: undefined;
+    sessionId?: undefined;
+    reconnect?: undefined;
+    event?: undefined;
+    message?: undefined;
+    recoverable?: undefined;
+    transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
+    scenarioId?: undefined;
+    sessionMetadata?: undefined;
+    status?: undefined;
+    turns?: undefined;
     turn?: undefined;
 } | {
     sessionId: string;
@@ -35,11 +73,41 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     receivedAt?: undefined;
     turnId?: undefined;
     text?: undefined;
+    delta?: undefined;
+    reconnect?: undefined;
     event?: undefined;
     message?: undefined;
+    recoverable?: undefined;
     transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
     scenarioId?: undefined;
+    sessionMetadata?: undefined;
     status?: undefined;
+    turns?: undefined;
+    turn?: undefined;
+} | {
+    reconnect: import("..").VoiceReconnectClientState;
+    type: "connection";
+    chunk?: undefined;
+    format?: undefined;
+    receivedAt?: undefined;
+    turnId?: undefined;
+    text?: undefined;
+    delta?: undefined;
+    sessionId?: undefined;
+    event?: undefined;
+    message?: undefined;
+    recoverable?: undefined;
+    transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
+    scenarioId?: undefined;
+    sessionMetadata?: undefined;
+    status?: undefined;
+    turns?: undefined;
     turn?: undefined;
 } | {
     event: import("..").VoiceCallLifecycleEvent;
@@ -50,24 +118,40 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     receivedAt?: undefined;
     turnId?: undefined;
     text?: undefined;
+    delta?: undefined;
+    reconnect?: undefined;
     message?: undefined;
+    recoverable?: undefined;
     transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
     scenarioId?: undefined;
+    sessionMetadata?: undefined;
     status?: undefined;
+    turns?: undefined;
     turn?: undefined;
 } | {
     message: string;
+    recoverable: boolean | undefined;
     type: "error";
     chunk?: undefined;
     format?: undefined;
     receivedAt?: undefined;
     turnId?: undefined;
     text?: undefined;
+    delta?: undefined;
     sessionId?: undefined;
+    reconnect?: undefined;
     event?: undefined;
     transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
     scenarioId?: undefined;
+    sessionMetadata?: undefined;
     status?: undefined;
+    turns?: undefined;
     turn?: undefined;
 } | {
     transcript: import("..").Transcript;
@@ -77,11 +161,19 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     receivedAt?: undefined;
     turnId?: undefined;
     text?: undefined;
+    delta?: undefined;
     sessionId?: undefined;
+    reconnect?: undefined;
     event?: undefined;
     message?: undefined;
+    recoverable?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
     scenarioId?: undefined;
+    sessionMetadata?: undefined;
     status?: undefined;
+    turns?: undefined;
     turn?: undefined;
 } | {
     transcript: import("..").Transcript;
@@ -91,14 +183,45 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     receivedAt?: undefined;
     turnId?: undefined;
     text?: undefined;
+    delta?: undefined;
     sessionId?: undefined;
+    reconnect?: undefined;
     event?: undefined;
     message?: undefined;
+    recoverable?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
     scenarioId?: undefined;
+    sessionMetadata?: undefined;
     status?: undefined;
+    turns?: undefined;
+    turn?: undefined;
+} | {
+    assistantTexts: string[];
+    call: import("..").VoiceCallLifecycleState | undefined;
+    partial: string;
+    scenarioId: string | undefined;
+    sessionId: string;
+    sessionMetadata: Record<string, unknown> | undefined;
+    status: import("..").VoiceSessionStatus;
+    turns: import("..").VoiceTurnRecord<TResult>[];
+    type: "replay";
+    chunk?: undefined;
+    format?: undefined;
+    receivedAt?: undefined;
+    turnId?: undefined;
+    text?: undefined;
+    delta?: undefined;
+    reconnect?: undefined;
+    event?: undefined;
+    message?: undefined;
+    recoverable?: undefined;
+    transcript?: undefined;
     turn?: undefined;
 } | {
     sessionId: string;
+    sessionMetadata: Record<string, unknown> | undefined;
     scenarioId: string | undefined;
     status: import("..").VoiceSessionStatus;
     type: "session";
@@ -107,9 +230,16 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     receivedAt?: undefined;
     turnId?: undefined;
     text?: undefined;
+    delta?: undefined;
+    reconnect?: undefined;
     event?: undefined;
     message?: undefined;
+    recoverable?: undefined;
     transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
+    turns?: undefined;
     turn?: undefined;
 } | {
     turn: import("..").VoiceTurnRecord<TResult>;
@@ -119,10 +249,18 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     receivedAt?: undefined;
     turnId?: undefined;
     text?: undefined;
+    delta?: undefined;
     sessionId?: undefined;
+    reconnect?: undefined;
     event?: undefined;
     message?: undefined;
+    recoverable?: undefined;
     transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
     scenarioId?: undefined;
+    sessionMetadata?: undefined;
     status?: undefined;
+    turns?: undefined;
 } | null;

package/dist/client/agentSquadStatus.d.ts

@@ -0,0 +1,37 @@
+import type { VoiceTraceTimelineReport } from "../core/traceTimeline";
+import { type VoiceTraceTimelineClientOptions } from "./traceTimeline";
+export type VoiceAgentSquadSpecialistStatus = "active" | "blocked" | "handoff" | "idle" | "unknown-target";
+export type VoiceAgentSquadSpecialist = {
+    fromAgentId?: string;
+    lastEventAt?: number;
+    reason?: string;
+    sessionId: string;
+    status: VoiceAgentSquadSpecialistStatus;
+    summary?: string;
+    targetAgentId?: string;
+    turnId?: string;
+};
+export type VoiceAgentSquadStatusReport = {
+    active: VoiceAgentSquadSpecialist[];
+    checkedAt?: number;
+    current?: VoiceAgentSquadSpecialist;
+    sessionCount: number;
+    sessions: VoiceAgentSquadSpecialist[];
+};
+export type VoiceAgentSquadStatusSnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report: VoiceAgentSquadStatusReport;
+    updatedAt?: number;
+};
+export type VoiceAgentSquadStatusClientOptions = VoiceTraceTimelineClientOptions & {
+    sessionId?: string;
+};
+export declare const buildVoiceAgentSquadStatusReport: (timeline: VoiceTraceTimelineReport | null | undefined, options?: Pick<VoiceAgentSquadStatusClientOptions, "sessionId">) => VoiceAgentSquadStatusReport;
+export declare const createVoiceAgentSquadStatusStore: (path?: string, options?: VoiceAgentSquadStatusClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceAgentSquadStatusSnapshot;
+    getSnapshot: () => VoiceAgentSquadStatusSnapshot;
+    refresh: () => Promise<VoiceTraceTimelineReport | null>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/agentSquadStatusWidget.d.ts

@@ -0,0 +1,24 @@
+import { type VoiceAgentSquadSpecialist, type VoiceAgentSquadStatusClientOptions, type VoiceAgentSquadStatusSnapshot } from "./agentSquadStatus";
+export type VoiceAgentSquadStatusViewModel = {
+    current?: VoiceAgentSquadSpecialist;
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    sessionCount: number;
+    sessions: VoiceAgentSquadSpecialist[];
+    title: string;
+    updatedAt?: number;
+};
+export type VoiceAgentSquadStatusWidgetOptions = VoiceAgentSquadStatusClientOptions & {
+    description?: string;
+    title?: string;
+};
+export declare const createVoiceAgentSquadStatusViewModel: (snapshot: VoiceAgentSquadStatusSnapshot, options?: VoiceAgentSquadStatusWidgetOptions) => VoiceAgentSquadStatusViewModel;
+export declare const defineVoiceAgentSquadStatusElement: (tagName?: string, options?: VoiceAgentSquadStatusWidgetOptions) => void;
+export declare const getVoiceAgentSquadStatusCSS: () => string;
+export declare const mountVoiceAgentSquadStatus: (element: Element | null, path?: string, options?: VoiceAgentSquadStatusWidgetOptions) => {
+    refresh: () => Promise<import("..").VoiceTraceTimelineReport | null>;
+    close: () => void;
+};
+export declare const renderVoiceAgentSquadStatusHTML: (snapshot: VoiceAgentSquadStatusSnapshot, options?: VoiceAgentSquadStatusWidgetOptions) => string;

package/dist/client/audioPlayer.d.ts

@@ -1,4 +1,4 @@
-import type { AudioFormat, VoiceAudioPlayer, VoiceAudioPlayerOptions, VoiceAudioPlayerSource } from '../types';
+import type { AudioFormat, VoiceAudioPlayer, VoiceAudioPlayerOptions, VoiceAudioPlayerSource } from "../core/types";
 type MinimalAudioBuffer = {
     duration: number;
     getChannelData: (channel: number) => Float32Array;
@@ -8,6 +8,9 @@ type MinimalAudioBufferSourceNode = {
     connect: (destination: unknown) => void;
     disconnect?: () => void;
     onended: (() => void) | null;
+    playbackRate?: {
+        value: number;
+    };
     start: (when?: number) => void;
     stop?: () => void;
 };
@@ -19,9 +22,16 @@ type MinimalGainNode = {
         value: number;
     };
 };
+type MinimalAnalyserNode = {
+    connect?: (destination: unknown) => void;
+    disconnect?: () => void;
+    fftSize: number;
+    getByteTimeDomainData: (array: Uint8Array) => void;
+};
 type MinimalAudioContext = {
     baseLatency?: number;
     close: () => Promise<void>;
+    createAnalyser?: () => MinimalAnalyserNode;
     createBuffer: (numberOfChannels: number, length: number, sampleRate: number) => MinimalAudioBuffer;
     createBufferSource: () => MinimalAudioBufferSourceNode;
     createGain?: () => MinimalGainNode;
@@ -29,7 +39,7 @@ type MinimalAudioContext = {
     destination: unknown;
     outputLatency?: number;
     resume: () => Promise<void>;
-    state: 'closed' | 'running' | 'suspended';
+    state: "closed" | "running" | "suspended";
     suspend: () => Promise<void>;
 };
 export declare const createVoiceAudioPlayer: (source: VoiceAudioPlayerSource, options?: VoiceAudioPlayerOptions) => VoiceAudioPlayer;

package/dist/client/bargeInMonitor.d.ts

@@ -0,0 +1,7 @@
+import type { VoiceBargeInMonitor } from "../core/types";
+export type VoiceBargeInMonitorOptions = {
+    fetch?: typeof fetch;
+    path?: string;
+    thresholdMs?: number;
+};
+export declare const createVoiceBargeInMonitor: (options?: VoiceBargeInMonitorOptions) => VoiceBargeInMonitor;

package/dist/client/browserMedia.d.ts

@@ -0,0 +1,8 @@
+import type { VoiceBrowserMediaReporterOptions, VoiceBrowserMediaReportPayload } from "../core/types";
+export type VoiceBrowserMediaReporter = {
+    close: () => void;
+    reportOnce: () => Promise<VoiceBrowserMediaReportPayload | undefined>;
+    start: () => void;
+    stop: () => void;
+};
+export declare const createVoiceBrowserMediaReporter: (options: VoiceBrowserMediaReporterOptions) => VoiceBrowserMediaReporter;

package/dist/client/browserNoiseSuppression.d.ts

@@ -0,0 +1,42 @@
+export type BrowserNoiseSuppressorOptions = {
+    /** Existing AudioContext to reuse. If omitted, a fresh one is created at 48kHz. */
+    audioContext?: AudioContext;
+    /** Optional message sent to the worklet via port.postMessage on init. */
+    initialPort?: Record<string, unknown>;
+    /** AudioWorkletNode options forwarded to the constructor. */
+    nodeOptions?: AudioWorkletNodeOptions;
+    /** Registered AudioWorkletProcessor name to instantiate. */
+    processorName: string;
+    /** Caller-supplied input stream from getUserMedia or similar. */
+    stream: MediaStream;
+    /** URL of the AudioWorklet script that registers `processorName`. */
+    workletUrl: string;
+};
+export type BrowserNoiseSuppressorHandle = {
+    /** The worklet node — operators can postMessage to tune at runtime. */
+    node: AudioWorkletNode;
+    /** A MediaStream containing the denoised audio track. */
+    stream: MediaStream;
+    /** Tears down the worklet + closes the AudioContext when this helper created it. */
+    stop: () => Promise<void>;
+};
+export declare const applyBrowserNoiseSuppression: (options: BrowserNoiseSuppressorOptions) => Promise<BrowserNoiseSuppressorHandle>;
+export type BrowserNoiseSuppressorPreset = {
+    initialPort?: Record<string, unknown>;
+    /** Display label for UI affordances. */
+    label: string;
+    nodeOptions?: AudioWorkletNodeOptions;
+    processorName: string;
+    workletUrl: string;
+};
+/**
+ * Convenience presets pointing at well-known open-source worklets. Operators
+ * still install the underlying npm package and copy the worklet file to a
+ * URL their site can serve.
+ */
+export declare const BROWSER_NOISE_SUPPRESSOR_PRESETS: {
+    /** DeepFilterNet 2023 model — best quality open-source pick. */
+    readonly deepfilternet: (workletUrl: string) => BrowserNoiseSuppressorPreset;
+    /** Jitsi @jitsi/rnnoise-wasm — ships a `rnnoise-processor` worklet. */
+    readonly rnnoise: (workletUrl: string) => BrowserNoiseSuppressorPreset;
+};

package/dist/client/browserVoiceSupport.d.ts

@@ -0,0 +1,22 @@
+export type BrowserVoiceSupportProbe = {
+    hasAudioContext: boolean;
+    hasAudioWorklet: boolean;
+    hasGetUserMedia: boolean;
+    hasMediaRecorder: boolean;
+    hasOpusEncoding: boolean;
+    hasRTCPeerConnection: boolean;
+    hasWebSocket: boolean;
+    isInsecureContext: boolean;
+    isIos: boolean;
+    isSafari: boolean;
+    requiresUserGestureToResumeAudio: boolean;
+    userAgent: string;
+};
+export type BrowserVoiceSupportReport = {
+    blockers: string[];
+    capabilities: BrowserVoiceSupportProbe;
+    ok: boolean;
+    warnings: string[];
+};
+export declare const checkBrowserVoiceSupport: (globalScope?: typeof globalThis) => BrowserVoiceSupportReport;
+export declare const probeBrowserVoiceSupport: (globalScope?: typeof globalThis) => BrowserVoiceSupportProbe;

package/dist/client/callDebugger.d.ts

@@ -0,0 +1,21 @@
+import type { VoiceCallDebuggerReport } from "../core/callDebugger";
+import { type VoiceReactiveSource } from "./reactiveSource";
+export type VoiceCallDebuggerClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+    reactiveSource?: VoiceReactiveSource;
+};
+export type VoiceCallDebuggerClientState = {
+    error: string | null;
+    isLoading: boolean;
+    report?: VoiceCallDebuggerReport;
+    updatedAt?: number;
+};
+export declare const createVoiceCallDebuggerStore: (path: string, options?: VoiceCallDebuggerClientOptions) => {
+    close: () => void;
+    refresh: () => Promise<VoiceCallDebuggerReport | undefined>;
+    getServerSnapshot: () => VoiceCallDebuggerClientState;
+    getSnapshot: () => VoiceCallDebuggerClientState;
+    subscribe: (listener: () => void) => () => void;
+};
+export declare const fetchVoiceCallDebugger: (path: string, options?: Pick<VoiceCallDebuggerClientOptions, "fetch">) => Promise<VoiceCallDebuggerReport>;

package/dist/client/callDebuggerWidget.d.ts

@@ -0,0 +1,30 @@
+import { type VoiceCallDebuggerClientOptions, type VoiceCallDebuggerClientState } from "./callDebugger";
+export type VoiceCallDebuggerLaunchViewModel = {
+    description: string;
+    error: string | null;
+    href: string;
+    isLoading: boolean;
+    label: string;
+    rows: Array<{
+        label: string;
+        value: string;
+    }>;
+    status: "empty" | "error" | "loading" | "ready" | "warning";
+    title: string;
+    updatedAt?: number;
+};
+export type VoiceCallDebuggerLaunchOptions = VoiceCallDebuggerClientOptions & {
+    description?: string;
+    href?: string | ((input: {
+        report?: VoiceCallDebuggerClientState["report"];
+    }) => string);
+    linkLabel?: string;
+    title?: string;
+};
+export declare const createVoiceCallDebuggerLaunchViewModel: (path: string, state: VoiceCallDebuggerClientState, options?: VoiceCallDebuggerLaunchOptions) => VoiceCallDebuggerLaunchViewModel;
+export declare const defineVoiceCallDebuggerLaunchElement: (tagName?: string) => void;
+export declare const mountVoiceCallDebuggerLaunch: (element: Element, path: string, options?: VoiceCallDebuggerLaunchOptions) => {
+    refresh: () => Promise<import("..").VoiceCallDebuggerReport | undefined>;
+    close: () => void;
+};
+export declare const renderVoiceCallDebuggerLaunchHTML: (path: string, state: VoiceCallDebuggerClientState, options?: VoiceCallDebuggerLaunchOptions) => string;

package/dist/client/callPlayer.d.ts

@@ -0,0 +1,41 @@
+import type { Transcript } from "../core/types";
+export type VoiceCallPlayerState = {
+    activeTranscriptId?: string;
+    activeTranscriptIndex?: number;
+    audioUrl?: string;
+    buffered: number;
+    currentTimeMs: number;
+    durationMs: number;
+    error?: string;
+    isPlaying: boolean;
+    isReady: boolean;
+    playbackRate: number;
+};
+export type VoiceCallPlayerOptions = {
+    audioUrl?: string;
+    initialPlaybackRate?: number;
+    /** Recording start in epoch ms; used to convert transcript epoch timestamps to playback offsets. */
+    recordingStartedAtEpochMs?: number;
+    transcripts?: ReadonlyArray<Transcript>;
+};
+export type VoiceCallPlayer = {
+    getState: () => VoiceCallPlayerState;
+    pause: () => void;
+    play: () => Promise<void>;
+    reset: () => void;
+    seekMs: (positionMs: number) => void;
+    seekToTranscript: (transcriptId: string) => void;
+    setAudioUrl: (url: string | undefined) => void;
+    setBuffered: (seconds: number) => void;
+    setDuration: (durationMs: number) => void;
+    setError: (error: string | undefined) => void;
+    setPlaybackRate: (rate: number) => void;
+    setPlaying: (playing: boolean) => void;
+    setReady: (ready: boolean) => void;
+    setTime: (positionMs: number) => void;
+    setTranscripts: (transcripts: ReadonlyArray<Transcript>) => void;
+    subscribe: (listener: () => void) => () => void;
+    transcripts: () => ReadonlyArray<Transcript>;
+};
+export declare const createVoiceCallPlayer: (options?: VoiceCallPlayerOptions) => VoiceCallPlayer;
+export declare const formatVoiceCallPlayerTimestamp: (ms: number) => string;

package/dist/client/campaignDialerProof.d.ts

@@ -0,0 +1,25 @@
+import type { VoiceCampaignDialerProofReport, VoiceCampaignDialerProofStatus } from "../core/campaignDialers";
+import { type VoiceReactiveSource } from "./reactiveSource";
+export type VoiceCampaignDialerProofClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+    reactiveSource?: VoiceReactiveSource;
+    runPath?: string;
+};
+export type VoiceCampaignDialerProofSnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report?: VoiceCampaignDialerProofReport;
+    status?: VoiceCampaignDialerProofStatus;
+    updatedAt?: number;
+};
+export declare const createVoiceCampaignDialerProofStore: (path?: string, options?: VoiceCampaignDialerProofClientOptions) => {
+    close: () => void;
+    refresh: () => Promise<VoiceCampaignDialerProofStatus | undefined>;
+    runProof: () => Promise<VoiceCampaignDialerProofReport>;
+    getServerSnapshot: () => VoiceCampaignDialerProofSnapshot;
+    getSnapshot: () => VoiceCampaignDialerProofSnapshot;
+    subscribe: (listener: () => void) => () => void;
+};
+export declare const fetchVoiceCampaignDialerProofStatus: (path?: string, options?: Pick<VoiceCampaignDialerProofClientOptions, "fetch">) => Promise<VoiceCampaignDialerProofStatus>;
+export declare const runVoiceCampaignDialerProofAction: (path?: string, options?: Pick<VoiceCampaignDialerProofClientOptions, "fetch">) => Promise<VoiceCampaignDialerProofReport>;

package/dist/client/connection.d.ts

@@ -1,20 +1,29 @@
-import type { VoiceClientMessage, VoiceConnectionOptions, VoiceServerMessage } from '../types';
+import type { VoiceClientMessage, VoiceConnectionOptions, VoiceServerMessage } from "../core/types";
+/** Exponential reconnect backoff for attempt N (1-based): baseMs doubles each
+ *  attempt, capped at maxDelayMs. Exported so the backoff window is unit-tested
+ *  without a DOM/WebSocket harness. */
+export declare const computeVoiceReconnectDelayMs: (attempt: number, baseMs: number, maxDelayMs: number) => number;
 type VoiceConnectionHandle = {
     callControl: (message: Omit<VoiceClientMessage & {
-        type: 'call_control';
-    }, 'type'>) => void;
+        type: "call_control";
+    }, "requestId" | "type">) => Promise<void>;
     start: (input?: {
         sessionId?: string;
         scenarioId?: string;
     }) => void;
-    close: () => void;
+    close: (reason?: string) => void;
+    disconnect: () => void;
     endTurn: () => void;
     getReadyState: () => number;
     getScenarioId: () => string;
     getSessionId: () => string;
     send: (message: VoiceClientMessage) => void;
     sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
+    simulateDisconnect: () => void;
     subscribe: (callback: (message: VoiceServerMessage) => void) => () => void;
 };
+export declare class VoiceReconnectRejectedError extends Error {
+    constructor(message?: string);
+}
 export declare const createVoiceConnection: (path: string, options?: VoiceConnectionOptions) => VoiceConnectionHandle;
 export {};

package/dist/client/controller.d.ts

@@ -1,2 +1,2 @@
-import type { VoiceController, VoiceControllerOptions } from '../types';
+import type { VoiceController, VoiceControllerOptions } from "../core/types";
 export declare const createVoiceController: <TResult = unknown>(path: string, options?: VoiceControllerOptions) => VoiceController<TResult>;

package/dist/client/conversationAnalytics.d.ts

@@ -0,0 +1,30 @@
+import type { StoredVoiceTraceEvent } from "../core/trace";
+type VoiceTrafficBucket = {
+    bucketKey: string;
+    callsCompleted: number;
+    callsFailed: number;
+    callsTransferred: number;
+    callsVoicemail: number;
+    callsTotal: number;
+    totalDurationMs: number;
+};
+export type VoiceTrafficSummary = {
+    buckets: VoiceTrafficBucket[];
+    callsByDisposition: Record<string, number>;
+    transferReasons: Record<string, number>;
+    topTransferTargets: Array<{
+        count: number;
+        target: string;
+    }>;
+    totals: VoiceTrafficBucket;
+    windowEndMs: number;
+    windowStartMs: number;
+};
+export type SummarizeVoiceCallTrafficOptions = {
+    bucketBy?: "day" | "hour" | "month";
+    events: ReadonlyArray<StoredVoiceTraceEvent>;
+    fromMs?: number;
+    toMs?: number;
+};
+export declare const summarizeVoiceCallTraffic: (options: SummarizeVoiceCallTrafficOptions) => VoiceTrafficSummary;
+export {};

package/dist/client/costDashboard.d.ts

@@ -0,0 +1,27 @@
+import type { StoredVoiceTraceEvent } from "../core/trace";
+export type VoiceCostDashboardBucket = {
+    bucketKey: string;
+    callCount: number;
+    llmUsd: number;
+    sttUsd: number;
+    telephonyMinutes: number;
+    telephonyUsd: number;
+    totalUsd: number;
+    ttsUsd: number;
+};
+export type VoiceCostDashboardReport = {
+    buckets: VoiceCostDashboardBucket[];
+    generatedAt: number;
+    grandTotal: VoiceCostDashboardBucket;
+    windowEndMs: number;
+    windowStartMs: number;
+};
+export type VoiceCostDashboardOptions = {
+    bucketBy?: "day" | "hour" | "month";
+    events: ReadonlyArray<StoredVoiceTraceEvent>;
+    /** Inclusive bucket start filter, epoch ms. */
+    fromMs?: number;
+    /** Inclusive bucket end filter, epoch ms. */
+    toMs?: number;
+};
+export declare const buildVoiceCostDashboardReport: (options: VoiceCostDashboardOptions) => VoiceCostDashboardReport;

package/dist/client/createVoiceStream.d.ts

@@ -1,2 +1,2 @@
-import type { VoiceConnectionOptions, VoiceStream } from '../types';
+import type { VoiceConnectionOptions, VoiceStream } from "../core/types";
 export declare const createVoiceStream: <TResult = unknown>(path: string, options?: VoiceConnectionOptions) => VoiceStream<TResult>;