@absolutejs/voice 0.0.22-beta.0 → 0.0.22-beta.2

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/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/testing/index.js

@@ -3747,6 +3747,17 @@ var createVoiceSession = (options) => {
     settleMs: options.sttFallback.settleMs ?? DEFAULT_FALLBACK_SETTLE_MS,
     trigger: options.sttFallback.trigger ?? "empty-or-low-confidence"
   } : undefined;
+  const appendTrace = async (input) => {
+    await options.trace?.append({
+      at: Date.now(),
+      metadata: input.metadata,
+      payload: input.payload,
+      scenarioId: input.session?.scenarioId ?? options.scenarioId,
+      sessionId: options.id,
+      turnId: input.turnId,
+      type: input.type
+    });
+  };
   const phraseHints = options.phraseHints ?? [];
   const lexicon = options.lexicon ?? [];
   let socket = options.socket;
@@ -3927,6 +3938,23 @@ var createVoiceSession = (options) => {
       return;
     }
     const resolvedError = toError(error);
+    await appendTrace({
+      payload: {
+        error: resolvedError.message,
+        recoverable: false
+      },
+      session,
+      type: "session.error"
+    });
+    await appendTrace({
+      payload: {
+        disposition: "failed",
+        reason: resolvedError.message,
+        type: "end"
+      },
+      session,
+      type: "call.lifecycle"
+    });
     await send({
       message: resolvedError.message,
       recoverable: false,
@@ -3984,6 +4012,16 @@ var createVoiceSession = (options) => {
     if (!didComplete) {
       return;
     }
+    await appendTrace({
+      payload: {
+        disposition,
+        reason: input.reason,
+        target: input.target,
+        type: "end"
+      },
+      session,
+      type: "call.lifecycle"
+    });
     await send({
       sessionId: options.id,
       type: "complete"
@@ -4045,7 +4083,7 @@ var createVoiceSession = (options) => {
     });
   };
   const transferInternal = async (input) => {
-    await writeSession((currentSession) => {
+    const session = await writeSession((currentSession) => {
       pushCallLifecycleEvent(currentSession, {
         metadata: input.metadata,
         reason: input.reason,
@@ -4053,6 +4091,16 @@ var createVoiceSession = (options) => {
         type: "transfer"
       });
     });
+    await appendTrace({
+      metadata: input.metadata,
+      payload: {
+        reason: input.reason,
+        target: input.target,
+        type: "transfer"
+      },
+      session,
+      type: "call.lifecycle"
+    });
     await completeInternal(input.result, {
       disposition: "transferred",
       invokeOnComplete: false,
@@ -4062,13 +4110,22 @@ var createVoiceSession = (options) => {
     });
   };
   const escalateInternal = async (input) => {
-    await writeSession((currentSession) => {
+    const session = await writeSession((currentSession) => {
       pushCallLifecycleEvent(currentSession, {
         metadata: input.metadata,
         reason: input.reason,
         type: "escalation"
       });
     });
+    await appendTrace({
+      metadata: input.metadata,
+      payload: {
+        reason: input.reason,
+        type: "escalation"
+      },
+      session,
+      type: "call.lifecycle"
+    });
     await completeInternal(input.result, {
       disposition: "escalated",
       invokeOnComplete: false,
@@ -4077,12 +4134,20 @@ var createVoiceSession = (options) => {
     });
   };
   const markNoAnswerInternal = async (input) => {
-    await writeSession((currentSession) => {
+    const session = await writeSession((currentSession) => {
       pushCallLifecycleEvent(currentSession, {
         metadata: input?.metadata,
         type: "no-answer"
       });
     });
+    await appendTrace({
+      metadata: input?.metadata,
+      payload: {
+        type: "no-answer"
+      },
+      session,
+      type: "call.lifecycle"
+    });
     await completeInternal(input?.result, {
       disposition: "no-answer",
       invokeOnComplete: false,
@@ -4090,12 +4155,20 @@ var createVoiceSession = (options) => {
     });
   };
   const markVoicemailInternal = async (input) => {
-    await writeSession((currentSession) => {
+    const session = await writeSession((currentSession) => {
       pushCallLifecycleEvent(currentSession, {
         metadata: input?.metadata,
         type: "voicemail"
       });
     });
+    await appendTrace({
+      metadata: input?.metadata,
+      payload: {
+        type: "voicemail"
+      },
+      session,
+      type: "call.lifecycle"
+    });
     await completeInternal(input?.result, {
       disposition: "voicemail",
       invokeOnComplete: false,
@@ -4103,6 +4176,14 @@ var createVoiceSession = (options) => {
     });
   };
   const handleError = async (event) => {
+    await appendTrace({
+      payload: {
+        code: event.code,
+        error: event.error.message,
+        recoverable: event.recoverable
+      },
+      type: "session.error"
+    });
     await send({
       message: event.error.message,
       recoverable: event.recoverable,
@@ -4391,6 +4472,20 @@ var createVoiceSession = (options) => {
       transcript,
       type: "partial"
     });
+    await appendTrace({
+      payload: {
+        confidence: transcript.confidence,
+        isFinal: false,
+        language: transcript.language,
+        receivedAt: Date.now(),
+        speaker: transcript.speaker,
+        text: transcript.text,
+        transcriptId: transcript.id,
+        vendor: transcript.vendor
+      },
+      session,
+      type: "turn.transcript"
+    });
   };
   const handleFinal = async (transcript) => {
     const session = await writeSession((session2) => {
@@ -4420,6 +4515,20 @@ var createVoiceSession = (options) => {
       transcript,
       type: "final"
     });
+    await appendTrace({
+      payload: {
+        confidence: transcript.confidence,
+        isFinal: true,
+        language: transcript.language,
+        receivedAt: Date.now(),
+        speaker: transcript.speaker,
+        text: transcript.text,
+        transcriptId: transcript.id,
+        vendor: transcript.vendor
+      },
+      session,
+      type: "turn.transcript"
+    });
   };
   const resumePendingTurnCommit = (session) => {
     const pendingText = buildTurnText(session.currentTurn.transcripts, session.currentTurn.partialText, {
@@ -4576,11 +4685,30 @@ var createVoiceSession = (options) => {
         turnId: turn.id,
         type: "assistant"
       });
+      await appendTrace({
+        payload: {
+          text: output.assistantText,
+          ttsConfigured: Boolean(options.tts)
+        },
+        session,
+        turnId: turn.id,
+        type: "turn.assistant"
+      });
       try {
         const activeTTSSession = await ensureTTSSession();
         if (activeTTSSession) {
+          const ttsStartedAt = Date.now();
           activeTTSTurnId = turn.id;
           await activeTTSSession.send(output.assistantText);
+          await appendTrace({
+            payload: {
+              elapsedMs: Date.now() - ttsStartedAt,
+              status: "sent"
+            },
+            session,
+            turnId: turn.id,
+            type: "turn.assistant"
+          });
         }
       } catch (error) {
         logger.warn("voice tts send failed", {
@@ -4588,6 +4716,15 @@ var createVoiceSession = (options) => {
           sessionId: options.id,
           turnId: turn.id
         });
+        await appendTrace({
+          payload: {
+            error: toError(error).message,
+            status: "tts-send-failed"
+          },
+          session,
+          turnId: turn.id,
+          type: "session.error"
+        });
       }
     }
     if (output?.result !== undefined) {
@@ -4737,6 +4874,28 @@ var createVoiceSession = (options) => {
       session: updatedSession,
       turn
     });
+    await appendTrace({
+      payload: {
+        correctionChanged: correctionDiagnostics?.changed,
+        correctionProvider: correctionDiagnostics?.provider,
+        fallbackUsed,
+        reason,
+        source,
+        text: turn.text,
+        transcriptCount: turn.transcripts.length
+      },
+      session: updatedSession,
+      turnId: turn.id,
+      type: "turn.committed"
+    });
+    await appendTrace({
+      payload: {
+        ...costEstimate
+      },
+      session: updatedSession,
+      turnId: turn.id,
+      type: "turn.cost"
+    });
     await send({
       turn,
       type: "turn"
@@ -4788,6 +4947,15 @@ var createVoiceSession = (options) => {
       });
     }
     await options.store.set(options.id, session);
+    if (shouldFireOnSession) {
+      await appendTrace({
+        payload: {
+          type: "start"
+        },
+        session,
+        type: "call.lifecycle"
+      });
+    }
     await send({
       sessionId: options.id,
       status: session.status,
@@ -4894,6 +5062,15 @@ var createVoiceSession = (options) => {
         await closeAdapter(reason);
         await Promise.resolve(socket.close(1000, reason));
         if (session.call?.endedAt && session.call.disposition === "closed") {
+          await appendTrace({
+            payload: {
+              disposition: "closed",
+              reason,
+              type: "end"
+            },
+            session,
+            type: "call.lifecycle"
+          });
           await options.route.onCallEnd?.({
             api,
             context: options.context,