@absolutejs/voice 0.0.22-beta.53 → 0.0.22-beta.531

package/dist/vue/useVoiceReconnectProfileEvidence.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceReconnectProfileEvidenceClientOptions } from "../client/reconnectProfileEvidence";
+import type { VoiceReconnectProfileEvidenceSummary } from "../proofTrends";
+export declare function useVoiceReconnectProfileEvidence(path?: string, options?: VoiceReconnectProfileEvidenceClientOptions): {
+    error: import("vue").Ref<string | null, string | null>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    refresh: () => Promise<VoiceReconnectProfileEvidenceSummary | undefined>;
+    report: import("vue").ShallowRef<VoiceReconnectProfileEvidenceSummary | undefined, VoiceReconnectProfileEvidenceSummary | undefined>;
+    updatedAt: import("vue").Ref<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceRoutingStatus.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceRoutingStatusClientOptions } from "../client/routingStatus";
+export declare function useVoiceRoutingStatus(path?: string, options?: VoiceRoutingStatusClientOptions): {
+    decision: import("vue").ShallowRef<import("..").VoiceRoutingEvent | null, import("..").VoiceRoutingEvent | null>;
+    error: import("vue").Ref<string | null, string | null>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    refresh: () => Promise<import("..").VoiceRoutingEvent | null>;
+    updatedAt: import("vue").Ref<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceSessionObservability.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceSessionObservabilityClientOptions } from "../client/sessionObservability";
+import type { VoiceSessionObservabilityReport } from "../sessionObservability";
+export declare function useVoiceSessionObservability(path?: string, options?: VoiceSessionObservabilityClientOptions): {
+    error: import("vue").Ref<string | null, string | null>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    refresh: () => Promise<VoiceSessionObservabilityReport | null>;
+    report: import("vue").ShallowRef<VoiceSessionObservabilityReport | null, VoiceSessionObservabilityReport | null>;
+    updatedAt: import("vue").Ref<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceSessionSnapshot.d.ts

@@ -0,0 +1,10 @@
+import { type VoiceSessionSnapshotClientOptions } from "../client/sessionSnapshot";
+import type { VoiceSessionSnapshot } from "../sessionSnapshot";
+export declare function useVoiceSessionSnapshot(path: string, options?: VoiceSessionSnapshotClientOptions): {
+    download: () => Blob;
+    error: import("vue").ShallowRef<string | null, string | null>;
+    isLoading: import("vue").ShallowRef<boolean, boolean>;
+    refresh: () => Promise<VoiceSessionSnapshot | undefined>;
+    snapshot: import("vue").ShallowRef<VoiceSessionSnapshot | undefined, VoiceSessionSnapshot | undefined>;
+    updatedAt: import("vue").ShallowRef<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceStream.d.ts

@@ -1,5 +1,5 @@
-import type { VoiceConnectionOptions, VoiceTurnRecord } from '../types';
-export declare const useVoiceStream: <TResult = unknown>(path: string, options?: VoiceConnectionOptions) => {
+import type { VoiceConnectionOptions, VoiceTurnRecord } from "../types";
+export declare function useVoiceStream<TResult = unknown>(path: string, options?: VoiceConnectionOptions): {
     assistantAudio: import("vue").ShallowRef<{
         chunk: Uint8Array;
         format: import("..").AudioFormat;
@@ -19,8 +19,11 @@ export declare const useVoiceStream: <TResult = unknown>(path: string, options?:
     error: import("vue").Ref<string | null, string | null>;
     isConnected: import("vue").Ref<boolean, boolean>;
     partial: import("vue").Ref<string, string>;
+    reconnect: import("vue").ShallowRef<import("..").VoiceReconnectClientState, import("..").VoiceReconnectClientState>;
     sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
+    simulateDisconnect: () => void;
     sessionId: import("vue").Ref<string | null, string | null>;
+    sessionMetadata: import("vue").ShallowRef<Record<string, unknown> | null, Record<string, unknown> | null>;
     status: import("vue").Ref<import("..").VoiceSessionStatus | "idle", import("..").VoiceSessionStatus | "idle">;
     turns: import("vue").ShallowRef<VoiceTurnRecord<TResult>[], VoiceTurnRecord<TResult>[]>;
 };

package/dist/vue/useVoiceTraceTimeline.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceTraceTimelineClientOptions } from "../client/traceTimeline";
+import type { VoiceTraceTimelineReport } from "../traceTimeline";
+export declare function useVoiceTraceTimeline(path?: string, options?: VoiceTraceTimelineClientOptions): {
+    error: import("vue").Ref<string | null, string | null>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    refresh: () => Promise<VoiceTraceTimelineReport | null>;
+    report: import("vue").ShallowRef<VoiceTraceTimelineReport | null, VoiceTraceTimelineReport | null>;
+    updatedAt: import("vue").Ref<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceTurnLatency.d.ts

@@ -0,0 +1,10 @@
+import { type VoiceTurnLatencyClientOptions } from "../client/turnLatency";
+import type { VoiceTurnLatencyReport } from "../turnLatency";
+export declare function useVoiceTurnLatency(path?: string, options?: VoiceTurnLatencyClientOptions): {
+    error: import("vue").ShallowRef<string | null, string | null>;
+    isLoading: import("vue").ShallowRef<boolean, boolean>;
+    refresh: () => Promise<VoiceTurnLatencyReport | undefined>;
+    report: import("vue").ShallowRef<VoiceTurnLatencyReport | undefined, VoiceTurnLatencyReport | undefined>;
+    runProof: () => Promise<VoiceTurnLatencyReport | undefined>;
+    updatedAt: import("vue").ShallowRef<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceTurnQuality.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceTurnQualityClientOptions } from "../client/turnQuality";
+import type { VoiceTurnQualityReport } from "../turnQuality";
+export declare function useVoiceTurnQuality(path?: string, options?: VoiceTurnQualityClientOptions): {
+    error: import("vue").ShallowRef<string | null, string | null>;
+    isLoading: import("vue").ShallowRef<boolean, boolean>;
+    refresh: () => Promise<VoiceTurnQualityReport | undefined>;
+    report: import("vue").ShallowRef<VoiceTurnQualityReport | undefined, VoiceTurnQualityReport | undefined>;
+    updatedAt: import("vue").ShallowRef<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceWorkflowStatus.d.ts

@@ -1,6 +1,6 @@
-import { type VoiceWorkflowStatusClientOptions } from '../client/workflowStatus';
-import type { VoiceScenarioEvalReport } from '../evalRoutes';
-export declare const useVoiceWorkflowStatus: (path?: string, options?: VoiceWorkflowStatusClientOptions) => {
+import { type VoiceWorkflowStatusClientOptions } from "../client/workflowStatus";
+import type { VoiceScenarioEvalReport } from "../evalRoutes";
+export declare function useVoiceWorkflowStatus(path?: string, options?: VoiceWorkflowStatusClientOptions): {
     error: import("vue").Ref<string | null, string | null>;
     isLoading: import("vue").Ref<boolean, boolean>;
     refresh: () => Promise<VoiceScenarioEvalReport | undefined>;

package/dist/webhookFanout.d.ts

@@ -0,0 +1,48 @@
+export type VoiceWebhookSinkDeliveryResult = {
+    attempt: number;
+    durationMs: number;
+    error?: string;
+    ok: boolean;
+    sinkId: string;
+    status?: number;
+};
+export type VoiceWebhookSink = {
+    /** Apply only when this filter returns true. Default: accept all. */
+    acceptEvent?: (event: {
+        payload?: unknown;
+        type?: string;
+    }) => boolean;
+    /** Backoff between retries in ms. Default 1_000. */
+    backoffMs?: number;
+    /** Extra headers. */
+    headers?: Record<string, string>;
+    /** Stable id used for retry queues + dead-letter tracking. */
+    id: string;
+    /** Max retry attempts. Default 3. */
+    maxRetries?: number;
+    /** HMAC signing secret. When present, signature headers are emitted. */
+    signingSecret?: string;
+    /** Per-request fetch timeout in ms. Default 10_000. */
+    timeoutMs?: number;
+    /** Target URL. */
+    url: string;
+};
+export type VoiceWebhookFanoutOptions = {
+    /** Custom fetch — used for testing. */
+    fetch?: typeof fetch;
+    /** Sinks to deliver to. */
+    sinks: ReadonlyArray<VoiceWebhookSink>;
+};
+export type VoiceWebhookFanoutEvent = {
+    payload: unknown;
+    type?: string;
+};
+export type VoiceWebhookFanoutReport = {
+    deliveries: VoiceWebhookSinkDeliveryResult[];
+    failed: number;
+    succeeded: number;
+};
+export type VoiceWebhookFanout = {
+    deliver: (event: VoiceWebhookFanoutEvent) => Promise<VoiceWebhookFanoutReport>;
+};
+export declare const createVoiceWebhookFanout: (options: VoiceWebhookFanoutOptions) => VoiceWebhookFanout;

package/dist/webhookVerification.d.ts

@@ -0,0 +1,27 @@
+export type VoiceWebhookVerificationReason = "missing-secret" | "missing-signature" | "missing-timestamp" | "signature-mismatch" | "stale-timestamp" | "unsupported-algorithm";
+export type VoiceWebhookVerificationResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: VoiceWebhookVerificationReason;
+};
+export type VoiceWebhookVerificationInput = {
+    body: string;
+    now?: number;
+    secret?: string;
+    signature?: string | null;
+    timestamp?: string | null;
+    toleranceMs?: number;
+};
+export declare const VOICE_WEBHOOK_SIGNATURE_HEADER = "x-absolutejs-signature";
+export declare const VOICE_WEBHOOK_TIMESTAMP_HEADER = "x-absolutejs-timestamp";
+export declare const signVoiceWebhookBody: (input: {
+    body: string;
+    secret: string;
+    timestamp: string;
+}) => Promise<string>;
+export declare const verifyVoiceWebhookSignature: (input: VoiceWebhookVerificationInput) => Promise<VoiceWebhookVerificationResult>;
+export declare const extractVoiceWebhookSignatureFromHeaders: (headers: Headers | Record<string, string | string[] | undefined>) => {
+    signature: string | null;
+    timestamp: string | null;
+};

package/dist/whisperChannel.d.ts

@@ -0,0 +1,50 @@
+export type VoiceWhisperFrame = {
+    sessionId: string;
+    supervisorId: string;
+    pcm: ArrayBuffer | Uint8Array;
+    sampleRate: number;
+    timestamp: number;
+};
+export type VoiceWhisperRoute = "agent-only" | "agent-and-caller" | "drop";
+export type VoiceWhisperEvent = {
+    type: "started";
+    supervisorId: string;
+    at: number;
+} | {
+    type: "stopped";
+    supervisorId: string;
+    at: number;
+} | {
+    type: "frame";
+    frame: VoiceWhisperFrame;
+} | {
+    type: "ducked";
+    supervisorId: string;
+    level: number;
+    at: number;
+};
+export type CreateVoiceWhisperChannelOptions = {
+    sessionId: string;
+    defaultRoute?: VoiceWhisperRoute;
+    duckCallerToLevel?: number;
+    maxConcurrentWhispers?: number;
+    now?: () => number;
+};
+type ActiveWhisper = {
+    supervisorId: string;
+    route: VoiceWhisperRoute;
+    startedAt: number;
+};
+export declare const createVoiceWhisperChannel: (options: CreateVoiceWhisperChannelOptions) => {
+    activeSupervisors: () => string[];
+    isWhispering: (supervisorId: string) => boolean;
+    pushFrame: (frame: VoiceWhisperFrame) => VoiceWhisperRoute;
+    routeFor: (supervisorId: string) => VoiceWhisperRoute | null;
+    sessionId: string;
+    setRoute(supervisorId: string, route: VoiceWhisperRoute): boolean;
+    start: (supervisorId: string, route?: VoiceWhisperRoute) => ActiveWhisper | undefined;
+    stop: (supervisorId: string) => boolean;
+    subscribe(listener: (event: VoiceWhisperEvent) => void): () => void;
+};
+export type VoiceWhisperChannel = ReturnType<typeof createVoiceWhisperChannel>;
+export {};

package/dist/workflowContract.d.ts

@@ -1,8 +1,8 @@
-import type { VoiceScenarioEvalDefinition } from './evalRoutes';
-import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
-import type { VoiceOnTurnHandler, VoiceRouteResult, VoiceSessionRecord, VoiceTurnRecord } from './types';
-export type VoiceWorkflowOutcome = 'complete' | 'transfer' | 'escalate' | 'voicemail' | 'no-answer';
-export type VoiceWorkflowContractFieldMatch = 'boolean' | 'non-empty' | 'number' | 'string' | 'truthy';
+import type { VoiceScenarioEvalDefinition } from "./evalRoutes";
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from "./trace";
+import type { VoiceOnTurnHandler, VoiceRouteResult, VoiceSessionRecord, VoiceTurnRecord } from "./types";
+export type VoiceWorkflowOutcome = "complete" | "transfer" | "escalate" | "voicemail" | "no-answer";
+export type VoiceWorkflowContractFieldMatch = "boolean" | "non-empty" | "number" | "string" | "truthy";
 export type VoiceWorkflowContractField = {
     aliases?: string[];
     label?: string;
@@ -32,8 +32,8 @@ export type VoiceWorkflowContractDefinition<TResult = unknown> = {
         routeResult: VoiceRouteResult<TResult>;
     }) => VoiceWorkflowContractValidationIssue[];
 };
-export type VoiceWorkflowContractPresetName = 'appointment-booking' | 'lead-qualification' | 'support-triage' | 'transfer-handoff' | 'voicemail-callback';
-export type VoiceWorkflowContractPresetOptions<TResult = unknown> = Partial<Omit<VoiceWorkflowContractDefinition<TResult>, 'fields' | 'id'>> & {
+export type VoiceWorkflowContractPresetName = "appointment-booking" | "lead-qualification" | "support-triage" | "transfer-handoff" | "voicemail-callback";
+export type VoiceWorkflowContractPresetOptions<TResult = unknown> = Partial<Omit<VoiceWorkflowContractDefinition<TResult>, "fields" | "id">> & {
     fields?: VoiceWorkflowContractField[];
     id?: string;
 };
@@ -62,7 +62,7 @@ export type VoiceWorkflowContractTracePayload = {
     missingFields: string[];
     outcome?: VoiceWorkflowOutcome;
     requiredFields: string[];
-    status: 'pass' | 'fail';
+    status: "pass" | "fail";
 };
 export declare const validateVoiceWorkflowRouteResult: <TResult = unknown>(definition: VoiceWorkflowContractDefinition<TResult>, routeResult: VoiceRouteResult<TResult>) => VoiceWorkflowContractValidation;
 export declare const createVoiceWorkflowScenario: <TResult = unknown>(definition: VoiceWorkflowContractDefinition<TResult>, overrides?: Partial<VoiceScenarioEvalDefinition>) => VoiceScenarioEvalDefinition;

package/dist/zeroDataRetention.d.ts

@@ -0,0 +1,41 @@
+import type { VoiceTraceEvent } from "./trace";
+import type { VoiceTurnRecord } from "./types";
+export type VoiceZeroDataRetentionMode = "off" | "strict" | "custom";
+export type VoiceZeroDataRetentionRetainFlags = {
+    /** Persist committed/partial transcript text. */
+    transcriptText: boolean;
+    /** Persist assistant response text. */
+    assistantText: boolean;
+    /** Persist recorded audio artifacts. */
+    recordings: boolean;
+    /** Persist free-text payloads on trace events. */
+    traceText: boolean;
+    /** Persist arbitrary session/turn metadata. */
+    metadata: boolean;
+};
+export type VoiceZeroDataRetentionPolicy = {
+    mode: VoiceZeroDataRetentionMode;
+    retain: VoiceZeroDataRetentionRetainFlags;
+};
+export type CreateVoiceZeroDataRetentionPolicyOptions = {
+    mode?: VoiceZeroDataRetentionMode;
+    /** Per-flag overrides; only meaningful with mode "custom" (or to relax "strict"). */
+    retain?: Partial<VoiceZeroDataRetentionRetainFlags>;
+};
+export declare const createVoiceZeroDataRetentionPolicy: (options?: CreateVoiceZeroDataRetentionPolicyOptions) => VoiceZeroDataRetentionPolicy;
+export declare const isVoiceZeroDataRetentionActive: (policy: VoiceZeroDataRetentionPolicy) => boolean;
+export declare const shouldRetainVoiceRecording: (policy: VoiceZeroDataRetentionPolicy) => boolean;
+export declare const shouldRetainVoiceTranscript: (policy: VoiceZeroDataRetentionPolicy) => boolean;
+/**
+ * Returns a scrubbed copy of a turn record honoring the ZDR policy. Structural
+ * fields (ids, timestamps, transcript count, citation ids) are preserved;
+ * content fields are replaced with a redaction marker or dropped.
+ */
+export declare const scrubVoiceTurnForZeroDataRetention: <TResult = unknown>(turn: VoiceTurnRecord<TResult>, policy: VoiceZeroDataRetentionPolicy) => VoiceTurnRecord<TResult>;
+/**
+ * Returns a scrubbed copy of a trace event honoring the ZDR policy. Drops or
+ * masks free-text payload fields while keeping the event type, ids, and
+ * timestamps so observability/lifecycle accounting still works.
+ */
+export declare const scrubVoiceTraceForZeroDataRetention: (event: VoiceTraceEvent, policy: VoiceZeroDataRetentionPolicy) => VoiceTraceEvent;
+export declare const VOICE_ZERO_DATA_RETENTION_REDACTION_MARKER = "[redacted:zdr]";