@absolutejs/voice 0.0.22-beta.497 → 0.0.22-beta.499

package/dist/assistant.d.ts

@@ -59,7 +59,7 @@ export type VoiceAssistantExperimentOptions<TContext = unknown, TSession extends
     }) => VoiceAssistantVariant<TContext, TSession, TResult> | string | void;
     variants: Array<VoiceAssistantVariant<TContext, TSession, TResult>>;
 };
-type VoiceAssistantAgentSource<TContext, TSession extends VoiceSessionRecord, TResult> = {
+export type VoiceAssistantAgentSource<TContext, TSession extends VoiceSessionRecord, TResult> = {
     agent: VoiceAgent<TContext, TSession, TResult>;
     agents?: never;
     defaultAgentId?: never;
@@ -140,4 +140,3 @@ export declare const summarizeVoiceAssistantRuns: (input: StoredVoiceTraceEvent[
     events?: StoredVoiceTraceEvent[];
     store?: VoiceTraceEventStore;
 }) => Promise<VoiceAssistantRunsSummary>;
-export {};

package/dist/callQuota.d.ts

@@ -0,0 +1,54 @@
+export type VoiceCallQuotaTier = {
+    burstAllowance?: number;
+    customerId: string;
+    monthlyMinutes?: number;
+    reservedConcurrent: number;
+};
+export type VoiceCallReservation = {
+    callId: string;
+    customerId: string;
+    release: () => Promise<void> | void;
+    reservedAt: number;
+};
+export type VoiceCallQuotaRejection = {
+    customerId: string;
+    reason: "concurrency-exceeded" | "customer-not-found" | "monthly-minutes-exceeded";
+    retryAfterMs?: number;
+};
+export type VoiceCallQuotaResult = {
+    ok: false;
+    rejection: VoiceCallQuotaRejection;
+} | {
+    ok: true;
+    reservation: VoiceCallReservation;
+};
+export type VoiceCallQuota = {
+    describe: (customerId: string) => Promise<undefined | {
+        activeCalls: number;
+        burstAllowance: number;
+        monthlyMinutesUsed: number;
+        reservedConcurrent: number;
+        tier: VoiceCallQuotaTier;
+    }> | (undefined | {
+        activeCalls: number;
+        burstAllowance: number;
+        monthlyMinutesUsed: number;
+        reservedConcurrent: number;
+        tier: VoiceCallQuotaTier;
+    });
+    recordMinutes: (input: {
+        callId?: string;
+        customerId: string;
+        minutes: number;
+    }) => Promise<void> | void;
+    reserve: (input: {
+        callId: string;
+        customerId: string;
+    }) => Promise<VoiceCallQuotaResult> | VoiceCallQuotaResult;
+};
+export type CreateInMemoryVoiceCallQuotaOptions = {
+    /** When provided, treat any customer not in the map as denied with 'customer-not-found'. */
+    strict?: boolean;
+    tiers: VoiceCallQuotaTier[];
+};
+export declare const createInMemoryVoiceCallQuota: (options: CreateInMemoryVoiceCallQuotaOptions) => VoiceCallQuota;

package/dist/client/costDashboard.d.ts

@@ -0,0 +1,27 @@
+import type { StoredVoiceTraceEvent } from "../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/liveCallViewer.d.ts

@@ -0,0 +1,42 @@
+import type { VoiceAgentUIState } from "../agentState";
+export type LiveCallEventKind = "agent_audio" | "agent_text" | "lifecycle" | "transcript" | "tool";
+export type LiveCallTimelineEvent = {
+    at: number;
+    detail?: string;
+    kind: LiveCallEventKind;
+    title: string;
+};
+export type LiveCallViewState = {
+    agentState: VoiceAgentUIState;
+    callDurationMs: number;
+    events: LiveCallTimelineEvent[];
+    isConnected: boolean;
+    isLiveListening: boolean;
+    lastAssistantAt?: number;
+    lastTranscriptAt?: number;
+    partialTranscript: string;
+    sessionId: string;
+};
+export type CreateLiveCallViewerOptions = {
+    bufferLimit?: number;
+    sessionId: string;
+    startedAt?: number;
+};
+export type LiveCallViewer = {
+    applyControl: (control: {
+        reason?: string;
+        type: string;
+    }) => void;
+    applyEvent: (event: LiveCallTimelineEvent) => void;
+    applyMonitorEvent: (event: {
+        payload: Record<string, unknown>;
+        type: string;
+    }) => void;
+    getState: () => LiveCallViewState;
+    noteAgentAudio: (at?: number) => void;
+    notePartial: (text: string, at?: number) => void;
+    noteTranscript: (text: string, at?: number) => void;
+    reset: (sessionId: string, startedAt?: number) => void;
+    subscribe: (subscriber: () => void) => () => void;
+};
+export declare const createLiveCallViewer: (options: CreateLiveCallViewerOptions) => LiveCallViewer;

package/dist/client/replayTimeline.d.ts

@@ -0,0 +1,26 @@
+import type { VoiceCallReviewArtifact } from "../testing/review";
+export type ReplayTimelineEvent = {
+    at: number;
+    category: "agent" | "lifecycle" | "tool" | "user";
+    detail?: string;
+    durationMs?: number;
+    label: string;
+};
+export type ReplayTimelineReport = {
+    duration: number;
+    events: ReplayTimelineEvent[];
+    metadata: {
+        artifactId: string;
+        title: string;
+    };
+    startedAt: number;
+    summary: {
+        agentTurns: number;
+        toolCalls: number;
+        userTurns: number;
+    };
+};
+export type ReplayTimelineInput = {
+    artifact: VoiceCallReviewArtifact;
+};
+export declare const buildReplayTimelineReport: (input: ReplayTimelineInput) => ReplayTimelineReport;

package/dist/defineVoiceAssistant.d.ts

@@ -0,0 +1,68 @@
+import { type VoiceAssistant, type VoiceAssistantAgentSource, type VoiceAssistantGuardrails, type VoiceAssistantMemoryLifecycle } from "./assistant";
+import type { AudioFormat, CreateVoiceSessionOptions, RealtimeAdapter, STTAdapter, TTSAdapter, VoiceLanguageStrategy, VoiceLexiconEntry, VoicePhraseHint, VoiceReconnectConfig, VoiceResolvedSTTFallbackConfig, VoiceResolvedAudioConditioningConfig, VoiceRouteConfig, VoiceSessionRecord, VoiceSessionRecordingConfig, VoiceSessionStore, VoiceSocket, VoiceSTTLifecycle, VoiceTTSProsody, VoiceTurnDetectionConfig } from "./types";
+import type { VoiceAssistantMemoryOptions } from "./assistantMemory";
+import type { VoiceAgentTool } from "./agent";
+import type { VoiceAMDDetector } from "./amdDetector";
+import type { VoiceCostAccountant } from "./costAccounting";
+import type { VoiceTraceEventStore } from "./trace";
+import type { VoiceTranscriptRedactor } from "./redaction";
+import type { VoiceSemanticTurnDetector } from "./semanticTurn";
+import type { VoiceAssistantMode } from "./assistantMode";
+import type { VoiceRuntimeOpsConfig } from "./types";
+export type VoiceAssistantVoiceConfig = {
+    prosody?: VoiceTTSProsody;
+    realtime?: RealtimeAdapter;
+    realtimeInputFormat?: AudioFormat;
+    stt?: STTAdapter;
+    sttFallback?: VoiceResolvedSTTFallbackConfig;
+    tts?: TTSAdapter;
+};
+export type VoiceAssistantObservabilityConfig = {
+    costAccountant?: VoiceCostAccountant;
+    costTelephony?: {
+        provider?: string;
+    };
+    recording?: VoiceSessionRecordingConfig;
+    trace?: VoiceTraceEventStore;
+};
+export type VoiceAssistantDefinition<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    agent: VoiceAssistantAgentSource<TContext, TSession, TResult>;
+    amd?: VoiceAMDDetector<TContext, TSession, TResult>;
+    assistantMode?: VoiceAssistantMode;
+    audioConditioning?: VoiceResolvedAudioConditioningConfig;
+    callSilenceTimeoutMs?: number;
+    guardrails?: VoiceAssistantGuardrails<TContext, TSession, TResult>;
+    id: string;
+    languageStrategy?: VoiceLanguageStrategy;
+    lexicon?: VoiceLexiconEntry[];
+    memory?: VoiceAssistantMemoryOptions<TContext, TSession>;
+    memoryLifecycle?: VoiceAssistantMemoryLifecycle<TContext, TSession, TResult>;
+    metadata?: Record<string, unknown>;
+    modalities?: ReadonlyArray<"audio" | "text">;
+    ops?: VoiceRuntimeOpsConfig<TContext, TSession, TResult>;
+    observability?: VoiceAssistantObservabilityConfig;
+    phraseHints?: VoicePhraseHint[];
+    redact?: VoiceTranscriptRedactor;
+    route?: Partial<VoiceRouteConfig<TContext, TSession, TResult>>;
+    semanticTurnDetector?: VoiceSemanticTurnDetector;
+    tools?: ReadonlyArray<VoiceAgentTool<TContext, TSession, Record<string, unknown>, unknown, TResult>>;
+    turnDetection?: VoiceTurnDetectionConfig;
+    voice: VoiceAssistantVoiceConfig;
+};
+export type VoiceAssistantSessionInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
+    context: TContext;
+    id: string;
+    reconnect?: Partial<VoiceReconnectConfig>;
+    scenarioId?: string;
+    sessionMetadata?: Record<string, unknown>;
+    socket: VoiceSocket;
+    sttLifecycle?: VoiceSTTLifecycle;
+    store: VoiceSessionStore<TSession>;
+};
+export type DefinedVoiceAssistant<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    assistant: VoiceAssistant<TContext, TSession, TResult>;
+    definition: VoiceAssistantDefinition<TContext, TSession, TResult>;
+    id: string;
+    toSessionOptions: (input: VoiceAssistantSessionInput<TContext, TSession>) => CreateVoiceSessionOptions<TContext, TSession, TResult>;
+};
+export declare const defineVoiceAssistant: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(definition: VoiceAssistantDefinition<TContext, TSession, TResult>) => DefinedVoiceAssistant<TContext, TSession, TResult>;

package/dist/index.d.ts

@@ -75,6 +75,8 @@ export { createVoiceAIJudgeCompletion, createVoiceLLMJudge, } from "./llmJudge";
 export type { CreateVoiceAIJudgeCompletionOptions, CreateVoiceLLMJudgeOptions, VoiceLLMJudge, VoiceLLMJudgeCompletion, VoiceLLMJudgeCriterionVerdict, VoiceLLMJudgeInput, VoiceLLMJudgeRubric, VoiceLLMJudgeRubricCriterion, VoiceLLMJudgeVerdict, } from "./llmJudge";
 export { DEFAULT_VOICE_REDACTION_PATTERNS, createVoiceTranscriptRedactor, redactVoiceTranscript, } from "./redaction";
 export type { CreateVoiceTranscriptRedactorOptions, VoiceRedactionPattern, VoiceTranscriptRedactor, } from "./redaction";
+export { deriveVoiceRecordingRedactionRanges } from "./recordingRedaction";
+export type { DeriveVoiceRecordingRedactionRangesInput, VoiceRecordingRedactionRange, } from "./recordingRedaction";
 export { DEFAULT_VOICE_PRICE_BOOK, createVoiceCostAccountant, } from "./costAccounting";
 export type { CreateVoiceCostAccountantOptions, VoiceCostAccountant, VoiceCostBreakdown, VoiceCostLLMRecord, VoiceCostSTTRecord, VoiceCostTTSRecord, VoiceCostTelephonyRecord, VoicePriceBook, VoiceProviderRates, } from "./costAccounting";
 export { describeVoiceAssistantMode, resolveVoiceAssistantMode, } from "./assistantMode";
@@ -102,6 +104,20 @@ export type { MonologueAMDDetectorOptions, VoiceAMDDetector, VoiceAMDDetectorInp
 export { createVoiceRAGTool, extractVoiceRAGCitations } from "./ragTool";
 export type { VoiceRAGCitationSummary, VoiceRAGCollectionLike, VoiceRAGQueryResult, VoiceRAGSearchInput, VoiceRAGToolArgs, VoiceRAGToolOptions, VoiceRAGToolResult, } from "./ragTool";
 export { createVoiceApiRequestTool, createVoiceDTMFTool, createVoiceEndCallTool, createVoiceTransferCallTool, createVoiceVoicemailDetectionTool, } from "./agentTools";
+export { defineVoiceAssistant } from "./defineVoiceAssistant";
+export type { DefinedVoiceAssistant, VoiceAssistantDefinition, VoiceAssistantObservabilityConfig, VoiceAssistantSessionInput, VoiceAssistantVoiceConfig, } from "./defineVoiceAssistant";
+export { createInMemoryVoiceCallQuota } from "./callQuota";
+export type { CreateInMemoryVoiceCallQuotaOptions, VoiceCallQuota, VoiceCallQuotaRejection, VoiceCallQuotaResult, VoiceCallQuotaTier, VoiceCallReservation, } from "./callQuota";
+export { createVoiceBearerAuthVerifier, createVoiceHMACAuthVerifier, createVoiceRouteAuth, } from "./routeAuth";
+export type { VoiceRouteAuthDecision, VoiceRouteAuthInput, VoiceRouteAuthOptions, VoiceRouteAuthVerifier, } from "./routeAuth";
+export { buildVoiceCostDashboardReport } from "./client/costDashboard";
+export type { VoiceCostDashboardBucket, VoiceCostDashboardOptions, VoiceCostDashboardReport, } from "./client/costDashboard";
+export { createLiveCallViewer } from "./client/liveCallViewer";
+export type { CreateLiveCallViewerOptions, LiveCallEventKind, LiveCallTimelineEvent, LiveCallViewState, LiveCallViewer, } from "./client/liveCallViewer";
+export { buildReplayTimelineReport } from "./client/replayTimeline";
+export type { ReplayTimelineEvent, ReplayTimelineInput, ReplayTimelineReport, } from "./client/replayTimeline";
+export { createVoiceRetentionScheduler, purgeVoiceRetentionStore, } from "./retention";
+export type { CreateVoiceRetentionSchedulerOptions, VoicePurgeReport, VoiceRetentionPolicyOptions, VoiceRetentionScheduler, VoiceRetentionStore, } from "./retention";
 export { fromVapiAssistantConfig } from "./vapiAdapter";
 export type { VapiAssistantConfig, VapiAssistantConfigModel, VapiAssistantConfigTool, VapiAssistantConfigTranscriber, VapiAssistantConfigTransferDestination, VapiAssistantConfigVoice, VapiAssistantMessage, VoiceFromVapiAssistantOptions, VoiceFromVapiAssistantResult, VoiceFromVapiCustomToolFactory, VoiceFromVapiCustomToolInput, VoiceFromVapiDTMFFactory, VoiceFromVapiKnowledgeBase, VoiceFromVapiModelFactory, VoiceFromVapiModelFactoryInput, VoiceFromVapiRouteHints, VoiceFromVapiUnsupportedReason, } from "./vapiAdapter";
 export type { VoiceApiRequestToolArgs, VoiceApiRequestToolFetch, VoiceApiRequestToolHttpMethod, VoiceApiRequestToolOptions, VoiceApiRequestToolResult, VoiceDTMFToolArgs, VoiceDTMFToolOptions, VoiceDTMFToolResult, VoiceEndCallToolArgs, VoiceEndCallToolOptions, VoiceEndCallToolResult, VoiceTransferCallToolArgs, VoiceTransferCallToolDestination, VoiceTransferCallToolOptions, VoiceTransferCallToolResult, VoiceVoicemailDetectionToolArgs, VoiceVoicemailDetectionToolOptions, VoiceVoicemailDetectionToolResult, } from "./agentTools";
@@ -116,8 +132,8 @@ export { assertVoiceOutcomeContractEvidence, createVoiceOutcomeContractHTMLHandl
 export { applyVoiceTelephonyOutcome, assertVoiceTelephonyWebhookNormalizationEvidence, createMemoryVoiceTelephonyWebhookIdempotencyStore, createVoiceTelephonyOutcomePolicy, createVoiceTelephonyWebhookHandler, createVoiceTelephonyWebhookRoutes, evaluateVoiceTelephonyWebhookNormalizationEvidence, parseVoiceTelephonyWebhookEvent, resolveVoiceTelephonyOutcome, signVoiceTwilioWebhook, verifyVoiceTwilioWebhookSignature, voiceTelephonyOutcomeToRouteResult, } from "./telephonyOutcome";
 export { assertVoicePhoneCallControlEvidence, assertVoicePhoneAssistantEvidence, createVoicePhoneAgent, evaluateVoicePhoneCallControlEvidence, evaluateVoicePhoneAssistantEvidence, } from "./phoneAgent";
 export { createStoredVoiceCallReviewArtifact, createStoredVoiceExternalObjectMap, createStoredVoiceIntegrationEvent, createStoredVoiceOpsTask, createVoiceFileIncidentBundleStore, createVoiceFileExternalObjectMapStore, createVoiceFileAssistantMemoryStore, createVoiceFileAuditEventStore, createVoiceFileAuditSinkDeliveryStore, createVoiceFileCampaignStore, createVoiceFileIntegrationEventStore, createVoiceFileRecordingStore, createVoiceFileReviewStore, createVoiceFileRuntimeStorage, createVoiceFileSessionStore, createVoiceFileTaskStore, createVoiceFileTraceSinkDeliveryStore, createVoiceFileTraceEventStore, } from "./fileStore";
-export { computePcmDurationMs, createVoiceMemoryRecordingStore, encodePcmAsWav, } from "./recordingStore";
-export type { StoredVoiceRecordingArtifact, VoiceRecordingArtifact, VoiceRecordingChannel, VoiceRecordingStore, } from "./recordingStore";
+export { computePcmDurationMs, createVoiceMemoryRecordingStore, createVoiceWavRecordingEncoder, encodePcmAsWav, encodeStereoWav, interleaveStereoPcm, } from "./recordingStore";
+export type { EncodeStereoWavInput, InterleavePcmInput, StoredVoiceRecordingArtifact, VoiceRecordingArtifact, VoiceRecordingChannel, VoiceRecordingEncoder, VoiceRecordingEncoderInput, VoiceRecordingEncoderResult, VoiceRecordingStore, } from "./recordingStore";
 export { createVoiceAssistantMemoryHandle, createVoiceAssistantMemoryRecord, createVoiceMemoryAssistantMemoryStore, resolveVoiceAssistantMemoryNamespace, } from "./assistantMemory";
 export { createAnthropicVoiceAssistantModel, createGeminiVoiceAssistantModel, createJSONVoiceAssistantModel, createOpenAIVoiceAssistantModel, createVoiceProviderOrchestrationProfile, resolveVoiceProviderRoutingPolicyPreset, createVoiceProviderRouter, } from "./modelAdapters";
 export { createOpenAIVoiceTTS } from "./openaiTTS";