@absolutejs/voice 0.0.21 → 0.0.22-beta.1

package/dist/queue.d.ts

@@ -0,0 +1,276 @@
+import type { RedisClient } from 'bun';
+import type { VoiceIntegrationSink } from './opsSinks';
+import type { VoiceTraceRedactionConfig, VoiceTraceSink, VoiceTraceSinkDeliveryRecord, VoiceTraceSinkDeliveryStore, VoiceTraceSinkDeliveryQueueStatus } from './trace';
+import type { VoiceOpsTaskPriority, StoredVoiceOpsTask, StoredVoiceIntegrationEvent, VoiceIntegrationDeliveryStatus, VoiceIntegrationEventStore, VoiceIntegrationWebhookConfig, VoiceOpsTaskKind, VoiceOpsTaskStatus, VoiceOpsTaskStore } from './ops';
+export type VoiceOpsTaskLease = {
+    expiresAt: number;
+    taskId: string;
+    workerId: string;
+};
+export type VoiceRedisTaskLeaseClient = Pick<RedisClient, 'get' | 'send' | 'set'>;
+export type VoiceRedisTaskLeaseCoordinatorOptions = {
+    client?: VoiceRedisTaskLeaseClient;
+    keyPrefix?: string;
+    url?: string;
+};
+export type VoiceRedisTaskLeaseCoordinator = {
+    claim: (input: {
+        leaseMs: number;
+        taskId: string;
+        workerId: string;
+    }) => Promise<boolean>;
+    get: (taskId: string) => Promise<VoiceOpsTaskLease | null>;
+    release: (input: {
+        taskId: string;
+        workerId: string;
+    }) => Promise<boolean>;
+    renew: (input: {
+        leaseMs: number;
+        taskId: string;
+        workerId: string;
+    }) => Promise<boolean>;
+};
+export type VoiceIdempotencyStore = {
+    has: (key: string) => Promise<boolean> | boolean;
+    remove: (key: string) => Promise<void> | void;
+    set: (key: string, input?: {
+        ttlSeconds?: number;
+    }) => Promise<void> | void;
+};
+export type VoiceRedisIdempotencyClient = Pick<RedisClient, 'del' | 'exists' | 'set'>;
+export type VoiceRedisIdempotencyStoreOptions = {
+    client?: VoiceRedisIdempotencyClient;
+    keyPrefix?: string;
+    ttlSeconds?: number;
+    url?: string;
+};
+export type VoiceWebhookDeliveryWorkerOptions<TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent> = {
+    deadLetters?: VoiceIntegrationEventStore<TEvent>;
+    events: VoiceIntegrationEventStore<TEvent>;
+    idempotency?: VoiceIdempotencyStore;
+    idempotencyTtlSeconds?: number;
+    leaseMs?: number;
+    leases: VoiceRedisTaskLeaseCoordinator;
+    maxFailures?: number;
+    onDeadLetter?: (event: TEvent) => Promise<void> | void;
+    statuses?: VoiceIntegrationDeliveryStatus[];
+    webhook: VoiceIntegrationWebhookConfig;
+    workerId: string;
+};
+export type VoiceWebhookDeliveryWorkerResult = {
+    alreadyProcessed: number;
+    attempted: number;
+    deadLettered: number;
+    delivered: number;
+    failed: number;
+    skipped: number;
+};
+export type VoiceIntegrationEventQueueSummary = {
+    byType: Array<[StoredVoiceIntegrationEvent['type'], number]>;
+    deadLettered: number;
+    delivered: number;
+    failed: number;
+    pending: number;
+    retryEligible: number;
+    skipped: number;
+    total: number;
+};
+export type VoiceWebhookDeliveryWorkerLoopOptions<TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent> = {
+    onError?: (error: unknown) => Promise<void> | void;
+    pollIntervalMs?: number;
+    worker: ReturnType<typeof createVoiceWebhookDeliveryWorker<TEvent>>;
+};
+export type VoiceWebhookDeliveryWorkerLoop = {
+    isRunning: () => boolean;
+    start: () => void;
+    stop: () => void;
+    tick: () => Promise<VoiceWebhookDeliveryWorkerResult>;
+};
+export type VoiceIntegrationSinkWorkerOptions<TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent> = {
+    deadLetters?: VoiceIntegrationEventStore<TEvent>;
+    events: VoiceIntegrationEventStore<TEvent>;
+    idempotency?: VoiceIdempotencyStore;
+    idempotencyTtlSeconds?: number;
+    leaseMs?: number;
+    leases: VoiceRedisTaskLeaseCoordinator;
+    maxFailures?: number;
+    onDeadLetter?: (event: TEvent) => Promise<void> | void;
+    sinks: VoiceIntegrationSink[];
+    workerId: string;
+};
+export type VoiceIntegrationSinkWorkerResult = {
+    alreadyProcessed: number;
+    attempted: number;
+    deadLettered: number;
+    delivered: number;
+    failed: number;
+    skipped: number;
+};
+export type VoiceIntegrationSinkWorkerLoopOptions<TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent> = {
+    onError?: (error: unknown) => Promise<void> | void;
+    pollIntervalMs?: number;
+    worker: ReturnType<typeof createVoiceIntegrationSinkWorker<TEvent>>;
+};
+export type VoiceIntegrationSinkWorkerLoop = {
+    isRunning: () => boolean;
+    start: () => void;
+    stop: () => void;
+    tick: () => Promise<VoiceIntegrationSinkWorkerResult>;
+};
+export type VoiceTraceSinkDeliveryWorkerOptions<TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord> = {
+    deadLetters?: VoiceTraceSinkDeliveryStore<TDelivery>;
+    deliveries: VoiceTraceSinkDeliveryStore<TDelivery>;
+    idempotency?: VoiceIdempotencyStore;
+    idempotencyTtlSeconds?: number;
+    leaseMs?: number;
+    leases: VoiceRedisTaskLeaseCoordinator;
+    maxFailures?: number;
+    onDeadLetter?: (delivery: TDelivery) => Promise<void> | void;
+    redact?: VoiceTraceRedactionConfig;
+    sinks: VoiceTraceSink[];
+    statuses?: VoiceTraceSinkDeliveryQueueStatus[];
+    workerId: string;
+};
+export type VoiceTraceSinkDeliveryWorkerResult = {
+    alreadyProcessed: number;
+    attempted: number;
+    deadLettered: number;
+    delivered: number;
+    failed: number;
+    skipped: number;
+};
+export type VoiceTraceSinkDeliveryWorkerLoopOptions<TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord> = {
+    onError?: (error: unknown) => Promise<void> | void;
+    pollIntervalMs?: number;
+    worker: ReturnType<typeof createVoiceTraceSinkDeliveryWorker<TDelivery>>;
+};
+export type VoiceTraceSinkDeliveryWorkerLoop = {
+    isRunning: () => boolean;
+    start: () => void;
+    stop: () => void;
+    tick: () => Promise<VoiceTraceSinkDeliveryWorkerResult>;
+};
+export type VoiceTraceSinkDeliveryQueueSummary = {
+    deadLettered: number;
+    delivered: number;
+    failed: number;
+    pending: number;
+    retryEligible: number;
+    skipped: number;
+    total: number;
+};
+export type VoiceOpsTaskWorkerOptions<TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask> = {
+    leaseMs?: number;
+    leases: VoiceRedisTaskLeaseCoordinator;
+    tasks: VoiceOpsTaskStore<TTask>;
+    workerId: string;
+};
+export type VoiceOpsTaskClaimFilters = {
+    assignee?: string;
+    excludeTaskIds?: string[];
+    kinds?: VoiceOpsTaskKind[];
+};
+export type VoiceOpsTaskWorker<TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask> = {
+    assign: (taskId: string, assignee: string, input?: {
+        actor?: string;
+        at?: number;
+    }) => Promise<TTask>;
+    claimNext: (filters?: VoiceOpsTaskClaimFilters) => Promise<TTask | null>;
+    complete: (taskId: string, input?: {
+        actor?: string;
+        at?: number;
+        detail?: string;
+    }) => Promise<TTask>;
+    heartbeat: (taskId: string, input?: {
+        actor?: string;
+        at?: number;
+        detail?: string;
+        leaseMs?: number;
+    }) => Promise<TTask>;
+    requeue: (taskId: string, input?: {
+        actor?: string;
+        at?: number;
+        detail?: string;
+    }) => Promise<TTask>;
+    release: (taskId: string) => Promise<boolean>;
+};
+export type VoiceOpsTaskQueueSummary = {
+    byAssignee: Array<[string, number]>;
+    byClaimedBy: Array<[string, number]>;
+    claimed: number;
+    deadLettered: number;
+    byKind: Array<[VoiceOpsTaskKind, number]>;
+    byPriority: Array<[VoiceOpsTaskPriority, number]>;
+    byStatus: Array<[VoiceOpsTaskStatus, number]>;
+    failed: number;
+    inProgress: number;
+    open: number;
+    overdue: number;
+    retryEligible: number;
+    total: number;
+    unclaimed: number;
+};
+export type VoiceOpsTaskProcessorWorkerOptions<TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask> = {
+    deadLetters?: VoiceOpsTaskStore<TTask>;
+    filters?: VoiceOpsTaskClaimFilters;
+    leaseMs?: number;
+    maxFailures?: number;
+    onDeadLetter?: (task: TTask) => Promise<void> | void;
+    onError?: (error: unknown, task: TTask) => Promise<void> | void;
+    process: (task: TTask) => Promise<void | 'complete' | 'requeue' | {
+        action?: 'complete' | 'requeue';
+        detail?: string;
+    }> | void | 'complete' | 'requeue' | {
+        action?: 'complete' | 'requeue';
+        detail?: string;
+    };
+    tasks: VoiceOpsTaskStore<TTask>;
+    worker: VoiceOpsTaskWorker<TTask>;
+};
+export type VoiceOpsTaskProcessorWorkerResult = {
+    attempted: number;
+    completed: number;
+    deadLettered: number;
+    failed: number;
+    idle: number;
+    requeued: number;
+};
+export type VoiceOpsTaskProcessorWorkerLoopOptions<TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask> = {
+    onError?: (error: unknown) => Promise<void> | void;
+    pollIntervalMs?: number;
+    worker: ReturnType<typeof createVoiceOpsTaskProcessorWorker<TTask>>;
+};
+export type VoiceOpsTaskProcessorWorkerLoop = {
+    isRunning: () => boolean;
+    start: () => void;
+    stop: () => void;
+    tick: () => Promise<VoiceOpsTaskProcessorWorkerResult>;
+};
+export declare const summarizeVoiceIntegrationEvents: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(events: TEvent[], input?: {
+    deadLetters?: VoiceIntegrationEventStore<TEvent>;
+}) => Promise<VoiceIntegrationEventQueueSummary> | VoiceIntegrationEventQueueSummary;
+export declare const summarizeVoiceTraceSinkDeliveries: <TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(deliveries: TDelivery[], input?: {
+    deadLetters?: VoiceTraceSinkDeliveryStore<TDelivery>;
+}) => Promise<VoiceTraceSinkDeliveryQueueSummary> | VoiceTraceSinkDeliveryQueueSummary;
+export declare const summarizeVoiceOpsTaskQueue: <TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask>(tasks: TTask[], input?: {
+    deadLetters?: VoiceOpsTaskStore<TTask>;
+}) => Promise<VoiceOpsTaskQueueSummary> | VoiceOpsTaskQueueSummary;
+export declare const createVoiceRedisTaskLeaseCoordinator: (options?: VoiceRedisTaskLeaseCoordinatorOptions) => VoiceRedisTaskLeaseCoordinator;
+export declare const createVoiceRedisIdempotencyStore: (options?: VoiceRedisIdempotencyStoreOptions) => VoiceIdempotencyStore;
+export declare const createVoiceWebhookDeliveryWorker: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(options: VoiceWebhookDeliveryWorkerOptions<TEvent>) => {
+    drain: () => Promise<VoiceWebhookDeliveryWorkerResult>;
+};
+export declare const createVoiceWebhookDeliveryWorkerLoop: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(options: VoiceWebhookDeliveryWorkerLoopOptions<TEvent>) => VoiceWebhookDeliveryWorkerLoop;
+export declare const createVoiceIntegrationSinkWorker: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(options: VoiceIntegrationSinkWorkerOptions<TEvent>) => {
+    drain: () => Promise<VoiceIntegrationSinkWorkerResult>;
+};
+export declare const createVoiceIntegrationSinkWorkerLoop: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(options: VoiceIntegrationSinkWorkerLoopOptions<TEvent>) => VoiceIntegrationSinkWorkerLoop;
+export declare const createVoiceTraceSinkDeliveryWorker: <TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(options: VoiceTraceSinkDeliveryWorkerOptions<TDelivery>) => {
+    drain: () => Promise<VoiceTraceSinkDeliveryWorkerResult>;
+};
+export declare const createVoiceTraceSinkDeliveryWorkerLoop: <TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(options: VoiceTraceSinkDeliveryWorkerLoopOptions<TDelivery>) => VoiceTraceSinkDeliveryWorkerLoop;
+export declare const createVoiceOpsTaskWorker: <TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask>(options: VoiceOpsTaskWorkerOptions<TTask>) => VoiceOpsTaskWorker<TTask>;
+export declare const createVoiceOpsTaskProcessorWorker: <TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask>(options: VoiceOpsTaskProcessorWorkerOptions<TTask>) => {
+    drain: () => Promise<VoiceOpsTaskProcessorWorkerResult>;
+};
+export declare const createVoiceOpsTaskProcessorWorkerLoop: <TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask>(options: VoiceOpsTaskProcessorWorkerLoopOptions<TTask>) => VoiceOpsTaskProcessorWorkerLoop;

package/dist/react/index.js

@@ -102,6 +102,14 @@ var normalizeErrorMessage = (value) => {
 };
 var serverMessageToAction = (message) => {
   switch (message.type) {
+    case "audio":
+      return {
+        chunk: Uint8Array.from(atob(message.chunkBase64), (char) => char.charCodeAt(0)),
+        format: message.format,
+        receivedAt: message.receivedAt,
+        turnId: message.turnId,
+        type: "audio"
+      };
     case "assistant":
       return {
         text: message.text,
@@ -182,6 +190,7 @@ var isVoiceServerMessage = (value) => {
     return false;
   }
   switch (value.type) {
+    case "audio":
     case "assistant":
     case "complete":
     case "error":
@@ -354,6 +363,7 @@ var createVoiceConnection = (path, options = {}) => {
 
 // src/client/store.ts
 var createInitialState = () => ({
+  assistantAudio: [],
   assistantTexts: [],
   error: null,
   isConnected: false,
@@ -371,6 +381,20 @@ var createVoiceStreamStore = () => {
   };
   const dispatch = (action) => {
     switch (action.type) {
+      case "audio":
+        state = {
+          ...state,
+          assistantAudio: [
+            ...state.assistantAudio,
+            {
+              chunk: action.chunk,
+              format: action.format,
+              receivedAt: action.receivedAt,
+              turnId: action.turnId
+            }
+          ]
+        };
+        break;
       case "assistant":
         state = {
           ...state,
@@ -510,6 +534,9 @@ var createVoiceStream = (path, options = {}) => {
     get assistantTexts() {
       return store.getSnapshot().assistantTexts;
     },
+    get assistantAudio() {
+      return store.getSnapshot().assistantAudio;
+    },
     sendAudio(audio) {
       connection.sendAudio(audio);
     },
@@ -524,6 +551,7 @@ var createVoiceStream = (path, options = {}) => {
 
 // src/react/useVoiceStream.tsx
 var EMPTY_SNAPSHOT = {
+  assistantAudio: [],
   assistantTexts: [],
   error: null,
   isConnected: false,
@@ -915,6 +943,58 @@ var PRESET_INPUTS = {
       transcriptStabilityMs: 1650
     }
   },
+  "pstn-balanced": {
+    audioConditioning: {
+      enabled: true,
+      maxGain: 2.8,
+      noiseGateAttenuation: 0.07,
+      noiseGateThreshold: 0.005,
+      targetLevel: 0.08
+    },
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 14,
+      pingInterval: 45000,
+      reconnect: true
+    },
+    sttLifecycle: "continuous",
+    turnDetection: {
+      qualityProfile: "noisy-room",
+      profile: "long-form",
+      silenceMs: 660,
+      speechThreshold: 0.012,
+      transcriptStabilityMs: 300
+    }
+  },
+  "pstn-fast": {
+    audioConditioning: {
+      enabled: true,
+      maxGain: 2.75,
+      noiseGateAttenuation: 0.06,
+      noiseGateThreshold: 0.005,
+      targetLevel: 0.08
+    },
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 14,
+      pingInterval: 45000,
+      reconnect: true
+    },
+    sttLifecycle: "continuous",
+    turnDetection: {
+      qualityProfile: "noisy-room",
+      profile: "long-form",
+      silenceMs: 620,
+      speechThreshold: 0.012,
+      transcriptStabilityMs: 280
+    }
+  },
   reliability: {
     audioConditioning: {
       enabled: true,
@@ -958,6 +1038,7 @@ var resolveVoiceRuntimePreset = (name = "default") => {
 
 // src/client/controller.ts
 var createInitialState2 = (stream) => ({
+  assistantAudio: [...stream.assistantAudio],
   assistantTexts: [...stream.assistantTexts],
   error: stream.error,
   isConnected: stream.isConnected,
@@ -986,6 +1067,7 @@ var createVoiceController = (path, options = {}) => {
   const sync = () => {
     state = {
       ...state,
+      assistantAudio: [...stream.assistantAudio],
       assistantTexts: [...stream.assistantTexts],
       error: stream.error,
       isConnected: stream.isConnected,
@@ -1113,12 +1195,16 @@ var createVoiceController = (path, options = {}) => {
     },
     get assistantTexts() {
       return state.assistantTexts;
+    },
+    get assistantAudio() {
+      return state.assistantAudio;
     }
   };
 };
 
 // src/react/useVoiceController.tsx
 var EMPTY_SNAPSHOT2 = {
+  assistantAudio: [],
   assistantTexts: [],
   error: null,
   isConnected: false,

package/dist/react/useVoiceController.d.ts

@@ -13,6 +13,12 @@ export declare const useVoiceController: <TResult = unknown>(path: string, optio
     partial: string;
     turns: import("..").VoiceTurnRecord<TResult>[];
     assistantTexts: string[];
+    assistantAudio: Array<{
+        chunk: Uint8Array;
+        format: import("..").AudioFormat;
+        receivedAt: number;
+        turnId?: string;
+    }>;
     error: string | null;
     isConnected: boolean;
     isRecording: boolean;

package/dist/react/useVoiceStream.d.ts

@@ -9,6 +9,12 @@ export declare const useVoiceStream: <TResult = unknown>(path: string, options?:
     partial: string;
     turns: import("..").VoiceTurnRecord<TResult>[];
     assistantTexts: string[];
+    assistantAudio: Array<{
+        chunk: Uint8Array;
+        format: import("..").AudioFormat;
+        receivedAt: number;
+        turnId?: string;
+    }>;
     error: string | null;
     isConnected: boolean;
 };

package/dist/routing.d.ts

@@ -0,0 +1,3 @@
+import type { VoiceSTTRoutingCorrectionMode, VoiceSTTRoutingGoal, VoiceSTTRoutingStrategy, VoiceTurnCorrectionHandler } from './types';
+export declare const resolveVoiceSTTRoutingStrategy: (goal?: VoiceSTTRoutingGoal) => VoiceSTTRoutingStrategy;
+export declare const createVoiceSTTRoutingCorrectionHandler: (mode?: VoiceSTTRoutingCorrectionMode) => VoiceTurnCorrectionHandler | undefined;

package/dist/runtimeOps.d.ts

@@ -0,0 +1,23 @@
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewArtifact } from './testing/review';
+import type { VoiceOpsTask } from './ops';
+import type { VoiceCallDisposition, VoiceRuntimeOpsConfig, VoiceSessionHandle, VoiceSessionRecord } from './types';
+export declare const createVoiceCallReviewFromSession: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(input: {
+    disposition: VoiceCallDisposition;
+    generatedAt?: number;
+    reason?: string;
+    session: TSession;
+    target?: string;
+}) => VoiceCallReviewArtifact;
+export declare const recordVoiceRuntimeOps: <TContext, TSession extends VoiceSessionRecord, TResult>(input: {
+    api: VoiceSessionHandle<TContext, TSession, TResult>;
+    config?: VoiceRuntimeOpsConfig<TContext, TSession, TResult>;
+    context: TContext;
+    disposition: VoiceCallDisposition;
+    metadata?: Record<string, unknown>;
+    reason?: string;
+    session: TSession;
+    target?: string;
+}) => Promise<{
+    review: StoredVoiceCallReviewArtifact | undefined;
+    task: VoiceOpsTask | undefined;
+} | undefined>;

package/dist/s3Store.d.ts

@@ -0,0 +1,14 @@
+import type { S3Client, S3Options } from 'bun';
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewStore } from './testing/review';
+export type VoiceS3ReviewStoreFile = {
+    delete: () => Promise<void>;
+    exists: () => Promise<boolean>;
+    text: () => Promise<string>;
+    write: (data: string) => Promise<number>;
+};
+export type VoiceS3ReviewStoreClient = Pick<S3Client, 'file' | 'list'>;
+export type VoiceS3ReviewStoreOptions = S3Options & {
+    client?: VoiceS3ReviewStoreClient;
+    keyPrefix?: string;
+};
+export declare const createVoiceS3ReviewStore: <TArtifact extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact>(options: VoiceS3ReviewStoreOptions) => VoiceCallReviewStore<TArtifact>;

package/dist/sqliteStore.d.ts

@@ -0,0 +1,26 @@
+import { type StoredVoiceTraceEvent, type VoiceTraceSinkDeliveryRecord, type VoiceTraceSinkDeliveryStore, type VoiceTraceEventStore } from './trace';
+import type { StoredVoiceIntegrationEvent, StoredVoiceExternalObjectMap, StoredVoiceOpsTask, VoiceExternalObjectMapStore, VoiceIntegrationEventStore, VoiceOpsTaskStore } from './ops';
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewStore } from './testing/review';
+import type { VoiceSessionRecord, VoiceSessionStore } from './types';
+export type VoiceSQLiteStoreOptions = {
+    path: string;
+    tableName?: string;
+    tablePrefix?: string;
+};
+export type VoiceSQLiteRuntimeStorage<TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord> = {
+    events: VoiceIntegrationEventStore<TEvent>;
+    externalObjects: VoiceExternalObjectMapStore<TMapping>;
+    reviews: VoiceCallReviewStore<TReview>;
+    session: VoiceSessionStore<TSession>;
+    tasks: VoiceOpsTaskStore<TTask>;
+    traceDeliveries: VoiceTraceSinkDeliveryStore<TTraceDelivery>;
+    traces: VoiceTraceEventStore<TTrace>;
+};
+export declare const createVoiceSQLiteSessionStore: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceSQLiteStoreOptions) => VoiceSessionStore<TSession>;
+export declare const createVoiceSQLiteReviewStore: <TArtifact extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact>(options: VoiceSQLiteStoreOptions) => VoiceCallReviewStore<TArtifact>;
+export declare const createVoiceSQLiteTaskStore: <TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask>(options: VoiceSQLiteStoreOptions) => VoiceOpsTaskStore<TTask>;
+export declare const createVoiceSQLiteIntegrationEventStore: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(options: VoiceSQLiteStoreOptions) => VoiceIntegrationEventStore<TEvent>;
+export declare const createVoiceSQLiteExternalObjectMapStore: <TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap>(options: VoiceSQLiteStoreOptions) => VoiceExternalObjectMapStore<TMapping>;
+export declare const createVoiceSQLiteTraceEventStore: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(options: VoiceSQLiteStoreOptions) => VoiceTraceEventStore<TEvent>;
+export declare const createVoiceSQLiteTraceSinkDeliveryStore: <TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(options: VoiceSQLiteStoreOptions) => VoiceTraceSinkDeliveryStore<TDelivery>;
+export declare const createVoiceSQLiteRuntimeStorage: <TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(options: VoiceSQLiteStoreOptions) => VoiceSQLiteRuntimeStorage<TSession, TReview, TTask, TEvent, TMapping, TTrace, TTraceDelivery>;

package/dist/svelte/index.js

@@ -99,6 +99,14 @@ var normalizeErrorMessage = (value) => {
 };
 var serverMessageToAction = (message) => {
   switch (message.type) {
+    case "audio":
+      return {
+        chunk: Uint8Array.from(atob(message.chunkBase64), (char) => char.charCodeAt(0)),
+        format: message.format,
+        receivedAt: message.receivedAt,
+        turnId: message.turnId,
+        type: "audio"
+      };
     case "assistant":
       return {
         text: message.text,
@@ -179,6 +187,7 @@ var isVoiceServerMessage = (value) => {
     return false;
   }
   switch (value.type) {
+    case "audio":
     case "assistant":
     case "complete":
     case "error":
@@ -351,6 +360,7 @@ var createVoiceConnection = (path, options = {}) => {
 
 // src/client/store.ts
 var createInitialState = () => ({
+  assistantAudio: [],
   assistantTexts: [],
   error: null,
   isConnected: false,
@@ -368,6 +378,20 @@ var createVoiceStreamStore = () => {
   };
   const dispatch = (action) => {
     switch (action.type) {
+      case "audio":
+        state = {
+          ...state,
+          assistantAudio: [
+            ...state.assistantAudio,
+            {
+              chunk: action.chunk,
+              format: action.format,
+              receivedAt: action.receivedAt,
+              turnId: action.turnId
+            }
+          ]
+        };
+        break;
       case "assistant":
         state = {
           ...state,
@@ -507,6 +531,9 @@ var createVoiceStream = (path, options = {}) => {
     get assistantTexts() {
       return store.getSnapshot().assistantTexts;
     },
+    get assistantAudio() {
+      return store.getSnapshot().assistantAudio;
+    },
     sendAudio(audio) {
       connection.sendAudio(audio);
     },
@@ -886,6 +913,58 @@ var PRESET_INPUTS = {
       transcriptStabilityMs: 1650
     }
   },
+  "pstn-balanced": {
+    audioConditioning: {
+      enabled: true,
+      maxGain: 2.8,
+      noiseGateAttenuation: 0.07,
+      noiseGateThreshold: 0.005,
+      targetLevel: 0.08
+    },
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 14,
+      pingInterval: 45000,
+      reconnect: true
+    },
+    sttLifecycle: "continuous",
+    turnDetection: {
+      qualityProfile: "noisy-room",
+      profile: "long-form",
+      silenceMs: 660,
+      speechThreshold: 0.012,
+      transcriptStabilityMs: 300
+    }
+  },
+  "pstn-fast": {
+    audioConditioning: {
+      enabled: true,
+      maxGain: 2.75,
+      noiseGateAttenuation: 0.06,
+      noiseGateThreshold: 0.005,
+      targetLevel: 0.08
+    },
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 14,
+      pingInterval: 45000,
+      reconnect: true
+    },
+    sttLifecycle: "continuous",
+    turnDetection: {
+      qualityProfile: "noisy-room",
+      profile: "long-form",
+      silenceMs: 620,
+      speechThreshold: 0.012,
+      transcriptStabilityMs: 280
+    }
+  },
   reliability: {
     audioConditioning: {
       enabled: true,
@@ -929,6 +1008,7 @@ var resolveVoiceRuntimePreset = (name = "default") => {
 
 // src/client/controller.ts
 var createInitialState2 = (stream) => ({
+  assistantAudio: [...stream.assistantAudio],
   assistantTexts: [...stream.assistantTexts],
   error: stream.error,
   isConnected: stream.isConnected,
@@ -957,6 +1037,7 @@ var createVoiceController = (path, options = {}) => {
   const sync = () => {
     state = {
       ...state,
+      assistantAudio: [...stream.assistantAudio],
       assistantTexts: [...stream.assistantTexts],
       error: stream.error,
       isConnected: stream.isConnected,
@@ -1084,6 +1165,9 @@ var createVoiceController = (path, options = {}) => {
     },
     get assistantTexts() {
       return state.assistantTexts;
+    },
+    get assistantAudio() {
+      return state.assistantAudio;
     }
   };
 };

package/dist/telephony/response.d.ts

@@ -0,0 +1,7 @@
+export type TelephonyResponseShapeMode = 'full' | 'lead-clause';
+export type TelephonyResponseShapeOptions = {
+    mode?: TelephonyResponseShapeMode;
+    maxChars?: number;
+    maxWords?: number;
+};
+export declare const shapeTelephonyAssistantText: (text: string, options?: TelephonyResponseShapeOptions) => string;