@absolutejs/voice 0.0.22-beta.51 → 0.0.22-beta.510

package/dist/testing/ioProviderSimulator.d.ts

@@ -1,13 +1,13 @@
-import type { VoiceIOProviderRouterEvent } from '../providerAdapters';
-export type VoiceIOProviderFailureSimulationMode = 'failure' | 'recovery';
-export type VoiceIOProviderFailureSimulationKind = 'stt' | 'tts';
-export type VoiceIOProviderFailureSimulationOperation = 'open' | 'send';
+import type { VoiceIOProviderRouterEvent } from "../providerAdapters";
+export type VoiceIOProviderFailureSimulationMode = "failure" | "recovery";
+export type VoiceIOProviderFailureSimulationKind = "stt" | "tts";
+export type VoiceIOProviderFailureSimulationOperation = "open" | "send";
 export type VoiceIOProviderFailureSimulationResult<TProvider extends string = string> = {
     fallbackProvider?: TProvider;
     mode: VoiceIOProviderFailureSimulationMode;
     provider: TProvider;
     sessionId: string;
-    status: 'simulated';
+    status: "simulated";
     suppressedUntil?: number;
 };
 export type VoiceIOProviderFailureSimulatorOptions<TProvider extends string = string> = {

package/dist/testing/providerSimulator.d.ts

@@ -1,7 +1,7 @@
-import type { VoiceAgentModelInput, VoiceAgentModelOutput } from '../agent';
-import type { VoiceSessionRecord } from '../types';
-import type { VoiceProviderRouterEvent, VoiceProviderRouterHealthOptions } from '../modelAdapters';
-export type VoiceProviderFailureSimulationMode = 'failure' | 'recovery';
+import type { VoiceAgentModelInput, VoiceAgentModelOutput } from "../agent";
+import type { VoiceSessionRecord } from "../types";
+import type { VoiceProviderRouterEvent, VoiceProviderRouterHealthOptions } from "../modelAdapters";
+export type VoiceProviderFailureSimulationMode = "failure" | "recovery";
 export type VoiceProviderFailureSimulationContext<TProvider extends string = string> = {
     query: {
         provider: TProvider;
@@ -15,7 +15,7 @@ export type VoiceProviderFailureSimulationResult<TProvider extends string = stri
     replayHref?: string;
     result: VoiceAgentModelOutput<TResult>;
     sessionId: string;
-    status: 'simulated';
+    status: "simulated";
     turnId: string;
 };
 type ProviderListResolver<TContext, TSession extends VoiceSessionRecord, TProvider extends string> = readonly TProvider[] | ((input: VoiceAgentModelInput<TContext, TSession>) => readonly TProvider[] | Promise<readonly TProvider[]>);

package/dist/testing/review.d.ts

@@ -1,5 +1,5 @@
-import type { VoiceCallDisposition, VoiceServerMessage } from '../types';
-type ReviewTimelineSource = 'benchmark' | 'stt' | 'turn' | 'twilio';
+import type { VoiceCallDisposition, VoiceServerMessage } from "../types";
+type ReviewTimelineSource = "benchmark" | "stt" | "turn" | "twilio";
 export type VoiceCallReviewTimelineEvent = {
     atMs: number;
     event: string;
@@ -113,7 +113,7 @@ export type VoiceCallReviewRecorder = {
     recordTwilioInbound: (input: {
         bytes?: number;
         chunkDurationMs?: number;
-        event: 'connected' | 'mark' | 'media' | 'start' | 'stop';
+        event: "connected" | "mark" | "media" | "start" | "stop";
         name?: string;
         reason?: string;
         text?: string;
@@ -122,7 +122,7 @@ export type VoiceCallReviewRecorder = {
     recordTwilioOutbound: (input: {
         bytes?: number;
         chunkDurationMs?: number;
-        event: 'clear' | 'mark' | 'media';
+        event: "clear" | "mark" | "media";
         name?: string;
         reason?: string;
         text?: string;

package/dist/testing/sessionBenchmark.d.ts

@@ -1,6 +1,6 @@
-import type { STTAdapter, VoiceAudioConditioningConfig, VoicePhraseHint, VoiceSTTFallbackConfig, VoiceSTTLifecycle, VoiceTurnCorrectionHandler, VoiceTurnProfile, VoiceTranscriptQuality } from '../types';
-import { type VoiceTranscriptAccuracy } from './accuracy';
-import type { VoiceTestFixture } from './fixtures';
+import type { STTAdapter, VoiceAudioConditioningConfig, VoicePhraseHint, VoiceSTTFallbackConfig, VoiceSTTLifecycle, VoiceTurnCorrectionHandler, VoiceTurnProfile, VoiceTranscriptQuality } from "../types";
+import { type VoiceTranscriptAccuracy } from "./accuracy";
+import type { VoiceTestFixture } from "./fixtures";
 export type VoiceSessionBenchmarkScenario = VoiceTestFixture & {
     expectedTurnTexts: string[];
     phraseHints?: VoicePhraseHint[];

package/dist/testing/stt.d.ts

@@ -1,6 +1,6 @@
-import { type VoiceTranscriptAccuracy } from './accuracy';
-import type { STTAdapter, STTAdapterOpenOptions, VoiceCloseEvent, VoiceEndOfTurnEvent, VoiceErrorEvent, VoiceFinalEvent, VoicePartialEvent } from '../types';
-import type { VoiceTestFixture } from './fixtures';
+import { type VoiceTranscriptAccuracy } from "./accuracy";
+import type { STTAdapter, STTAdapterOpenOptions, VoiceCloseEvent, VoiceEndOfTurnEvent, VoiceErrorEvent, VoiceFinalEvent, VoicePartialEvent } from "../types";
+import type { VoiceTestFixture } from "./fixtures";
 export type VoiceSTTAdapterHarnessOptions = {
     chunkDurationMs?: number;
     idleTimeoutMs?: number;

package/dist/testing/telephony.d.ts

@@ -1,3 +1,5 @@
+import { type VoiceOperationsRecord } from "../operationsRecord";
+import { type VoiceTraceEventStore } from "../trace";
 export type VoiceTelephonyBenchmarkScenario = {
     expectClear: boolean;
     expectMark: boolean;
@@ -40,9 +42,32 @@ export type VoiceTelephonyBenchmarkReport = {
     generatedAt: number;
     summary: VoiceTelephonyBenchmarkSummary;
 };
+export type VoiceTelephonyMediaOperationsSmokeOptions = {
+    callSid?: string;
+    operationsRecordHref?: string | ((input: {
+        sessionId: string;
+        streamSid: string;
+    }) => string);
+    scenarioId?: string;
+    sessionId?: string;
+    store?: VoiceTraceEventStore;
+    streamSid?: string;
+    timeoutMs?: number;
+};
+export type VoiceTelephonyMediaOperationsSmokeReport = {
+    issues: string[];
+    ok: boolean;
+    operationsRecord: VoiceOperationsRecord;
+    operationsRecordHref?: string;
+    sentEvents: string[];
+    sessionId: string;
+    streamSid: string;
+    telephonyMedia: VoiceOperationsRecord["telephonyMedia"];
+};
 type VoiceTelephonyBenchmarkOptions = {
     timeoutMs?: number;
 };
+export declare const runVoiceTelephonyMediaOperationsSmoke: (options?: VoiceTelephonyMediaOperationsSmokeOptions) => Promise<VoiceTelephonyMediaOperationsSmokeReport>;
 export declare const getDefaultVoiceTelephonyBenchmarkScenarios: () => {
     expectClear: boolean;
     expectMark: boolean;

package/dist/testing/tts.d.ts

@@ -1,4 +1,4 @@
-import type { AudioFormat, RealtimeAdapter, RealtimeAdapterOpenOptions, TTSAdapter, TTSAdapterOpenOptions } from '../types';
+import type { AudioFormat, RealtimeAdapter, RealtimeAdapterOpenOptions, TTSAdapter, TTSAdapterOpenOptions } from "../types";
 export type VoiceTTSBenchmarkFixture = {
     id: string;
     tags?: string[];

package/dist/toolContract.d.ts

@@ -0,0 +1,161 @@
+import { Elysia } from "elysia";
+import type { VoiceAgentTool } from "./agent";
+import { type VoiceToolRuntimeOptions } from "./toolRuntime";
+import type { VoiceSessionRecord, VoiceTurnRecord } from "./types";
+export type VoiceToolContractExpectation = {
+    expectedAttempts?: number;
+    expectedErrorIncludes?: string;
+    expectedResult?: unknown;
+    expectIdempotent?: boolean;
+    expectStatus?: "error" | "ok";
+    expectTimedOut?: boolean;
+    maxElapsedMs?: number;
+};
+export type VoiceToolContractCase<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TArgs = Record<string, unknown>, TToolResult = unknown, TRouteResult = unknown> = {
+    args: TArgs;
+    context?: TContext;
+    expect?: VoiceToolContractExpectation;
+    id: string;
+    label?: string;
+    runtime?: VoiceToolRuntimeOptions<TContext, TSession, TRouteResult>;
+    session?: TSession;
+    toolCallId?: string;
+    turn?: VoiceTurnRecord;
+};
+export type VoiceToolContractDefinition<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TArgs = Record<string, unknown>, TToolResult = unknown, TRouteResult = unknown> = {
+    cases: Array<VoiceToolContractCase<TContext, TSession, TArgs, TToolResult, TRouteResult>>;
+    defaultRuntime?: VoiceToolRuntimeOptions<TContext, TSession, TRouteResult>;
+    description?: string;
+    id: string;
+    label?: string;
+    tool: VoiceAgentTool<TContext, TSession, TArgs, TToolResult, TRouteResult>;
+};
+export type VoiceToolContractIssue = {
+    caseId: string;
+    code: string;
+    message: string;
+};
+export type VoiceToolContractCaseReport = {
+    attempts: number;
+    caseId: string;
+    elapsedMs: number;
+    error?: string;
+    issues: VoiceToolContractIssue[];
+    label?: string;
+    operationsRecordHref?: string;
+    pass: boolean;
+    sessionId: string;
+    status: "error" | "ok";
+    timedOut: boolean;
+};
+export type VoiceToolContractReport = {
+    cases: VoiceToolContractCaseReport[];
+    contractId: string;
+    label?: string;
+    issues: VoiceToolContractIssue[];
+    pass: boolean;
+    toolName: string;
+};
+export type VoiceToolContractSuiteReport = {
+    checkedAt: number;
+    contracts: VoiceToolContractReport[];
+    failed: number;
+    passed: number;
+    status: "fail" | "pass";
+    total: number;
+};
+export type VoiceToolContractAssertionInput = {
+    maxFailed?: number;
+    maxIssues?: number;
+    maxTimedOut?: number;
+    minCases?: number;
+    minContracts?: number;
+    requireOperationRecordHrefs?: boolean;
+    requiredCaseStatuses?: Array<"error" | "ok">;
+    requiredContractIds?: string[];
+    requiredToolNames?: string[];
+};
+export type VoiceToolContractAssertionReport = {
+    caseStatuses: Array<"error" | "ok">;
+    cases: number;
+    contractIds: string[];
+    failed: number;
+    issues: string[];
+    issueCount: number;
+    missingOperationsRecordHrefs: number;
+    ok: boolean;
+    passed: number;
+    status: VoiceToolContractSuiteReport["status"];
+    timedOut: number;
+    toolNames: string[];
+    total: number;
+};
+export type VoiceToolContractHandlerOptions = {
+    contracts: VoiceToolContractDefinition[];
+    operationsRecordHref?: false | string | ((sessionId: string) => string);
+};
+export type VoiceToolContractHTMLHandlerOptions = VoiceToolContractHandlerOptions & {
+    headers?: HeadersInit;
+    render?: (report: VoiceToolContractSuiteReport) => string | Promise<string>;
+    title?: string;
+};
+export type VoiceToolContractRoutesOptions = VoiceToolContractHTMLHandlerOptions & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export declare const runVoiceToolContract: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TArgs = Record<string, unknown>, TToolResult = unknown, TRouteResult = unknown>(definition: VoiceToolContractDefinition<TContext, TSession, TArgs, TToolResult, TRouteResult>, options?: Pick<VoiceToolContractHandlerOptions, "operationsRecordHref">) => Promise<VoiceToolContractReport>;
+export declare const createVoiceToolContract: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TArgs = Record<string, unknown>, TToolResult = unknown, TRouteResult = unknown>(definition: VoiceToolContractDefinition<TContext, TSession, TArgs, TToolResult, TRouteResult>) => {
+    assert: () => Promise<VoiceToolContractReport>;
+    definition: VoiceToolContractDefinition<TContext, TSession, TArgs, TToolResult, TRouteResult>;
+    run: () => Promise<VoiceToolContractReport>;
+};
+export declare const createVoiceToolRuntimeContractDefaults: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TRouteResult = unknown>() => VoiceToolRuntimeOptions<TContext, TSession, TRouteResult>;
+export declare const runVoiceToolContractSuite: (options: VoiceToolContractHandlerOptions) => Promise<VoiceToolContractSuiteReport>;
+export declare const evaluateVoiceToolContractEvidence: (report: VoiceToolContractSuiteReport, input?: VoiceToolContractAssertionInput) => VoiceToolContractAssertionReport;
+export declare const assertVoiceToolContractEvidence: (report: VoiceToolContractSuiteReport, input?: VoiceToolContractAssertionInput) => VoiceToolContractAssertionReport;
+export declare const renderVoiceToolContractHTML: (report: VoiceToolContractSuiteReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceToolContractJSONHandler: (options: VoiceToolContractHandlerOptions) => () => Promise<VoiceToolContractSuiteReport>;
+export declare const createVoiceToolContractHTMLHandler: (options: VoiceToolContractHTMLHandlerOptions) => () => Promise<Response>;
+export declare const createVoiceToolContractRoutes: (options: VoiceToolContractRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: VoiceToolContractSuiteReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/toolRuntime.d.ts

@@ -0,0 +1,50 @@
+import type { VoiceAgentTool, VoiceAgentToolResult } from "./agent";
+import type { VoiceSessionHandle, VoiceSessionRecord, VoiceTurnRecord } from "./types";
+import type { VoiceTraceEventStore } from "./trace";
+export type VoiceToolRetryDelay = number | ((input: {
+    attempt: number;
+    error: unknown;
+    toolName: string;
+}) => number);
+export type VoiceToolRuntimeOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TRouteResult = unknown> = {
+    idempotencyKey?: (input: {
+        args: unknown;
+        context: TContext;
+        session: TSession;
+        toolCallId?: string;
+        toolName: string;
+        turn: VoiceTurnRecord;
+    }) => string | undefined;
+    idempotencyTtlMs?: number;
+    maxRetries?: number;
+    retryDelayMs?: VoiceToolRetryDelay;
+    timeoutMs?: number;
+    trace?: VoiceTraceEventStore;
+};
+export type VoiceToolRuntimeExecuteInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TArgs = Record<string, unknown>, TToolResult = unknown, TRouteResult = unknown> = {
+    api: VoiceSessionHandle<TContext, TSession, TRouteResult>;
+    args: TArgs;
+    context: TContext;
+    session: TSession;
+    tool: VoiceAgentTool<TContext, TSession, TArgs, TToolResult, TRouteResult>;
+    toolCallId?: string;
+    turn: VoiceTurnRecord;
+};
+export type VoiceToolRuntimeResult<TToolResult = unknown> = VoiceAgentToolResult<TToolResult> & {
+    attempts: number;
+    elapsedMs: number;
+    idempotencyKey?: string;
+    timedOut: boolean;
+};
+export type VoiceToolRuntime<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TRouteResult = unknown> = {
+    execute: <TArgs = Record<string, unknown>, TToolResult = unknown>(input: VoiceToolRuntimeExecuteInput<TContext, TSession, TArgs, TToolResult, TRouteResult>) => Promise<VoiceToolRuntimeResult<TToolResult>>;
+    wrapTool: <TArgs = Record<string, unknown>, TToolResult = unknown>(tool: VoiceAgentTool<TContext, TSession, TArgs, TToolResult, TRouteResult>) => VoiceAgentTool<TContext, TSession, TArgs, TToolResult, TRouteResult>;
+};
+export declare const createVoiceToolRuntime: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TRouteResult = unknown>(options?: VoiceToolRuntimeOptions<TContext, TSession, TRouteResult>) => VoiceToolRuntime<TContext, TSession, TRouteResult>;
+export declare const createVoiceToolIdempotencyKey: (input: {
+    args: unknown;
+    sessionId: string;
+    toolCallId?: string;
+    toolName: string;
+    turnId: string;
+}) => string;

package/dist/trace.d.ts

@@ -1,4 +1,5 @@
-export type VoiceTraceEventType = 'assistant.guardrail' | 'assistant.memory' | 'assistant.run' | 'agent.handoff' | 'agent.model' | 'agent.result' | 'agent.tool' | 'call.handoff' | 'call.lifecycle' | 'session.error' | 'turn.assistant' | 'turn.committed' | 'turn.cost' | 'turn.transcript' | 'workflow.contract';
+import type { S3Client, S3Options } from "bun";
+export type VoiceTraceEventType = "assistant.guardrail" | "assistant.memory" | "assistant.run" | "agent.context" | "agent.handoff" | "agent.model" | "agent.result" | "agent.tool" | "call.handoff" | "call.lifecycle" | "client.barge_in" | "client.browser_media" | "client.live_latency" | "client.reconnect" | "client.telephony_media" | "cost.ready" | "operator.action" | "provider.decision" | "recording.ready" | "session.error" | "turn.assistant" | "turn.committed" | "turn.cost" | "turn_latency.stage" | "turn.transcript" | "workflow.contract";
 export type VoiceTraceEvent<TPayload extends Record<string, unknown> = Record<string, unknown>> = {
     at: number;
     id?: string;
@@ -15,6 +16,7 @@ export type StoredVoiceTraceEvent<TPayload extends Record<string, unknown> = Rec
 };
 export type VoiceTraceEventFilter = {
     limit?: number;
+    readWindow?: "recent";
     scenarioId?: string;
     sessionId?: string;
     traceId?: string;
@@ -27,7 +29,13 @@ export type VoiceTraceEventStore<TEvent extends StoredVoiceTraceEvent = StoredVo
     list: (filter?: VoiceTraceEventFilter) => Promise<TEvent[]>;
     remove: (id: string) => Promise<void>;
 };
-export type VoiceTracePruneFilter = Omit<VoiceTraceEventFilter, 'limit'>;
+export type VoiceScopedTraceEventStoreOptions = VoiceTraceEventFilter;
+export type VoiceProofTraceStoreOptions<TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent> = {
+    mirrorStore?: VoiceTraceEventStore<TEvent>;
+    proofStore?: VoiceTraceEventStore<TEvent>;
+    scope?: VoiceScopedTraceEventStoreOptions;
+};
+export type VoiceTracePruneFilter = Omit<VoiceTraceEventFilter, "limit">;
 export type VoiceTracePruneOptions = {
     before?: number;
     beforeOrAt?: number;
@@ -43,8 +51,8 @@ export type VoiceTracePruneResult = {
     dryRun: boolean;
     scannedCount: number;
 };
-export type VoiceTraceSinkDeliveryStatus = 'delivered' | 'failed' | 'skipped';
-export type VoiceTraceSinkDeliveryQueueStatus = VoiceTraceSinkDeliveryStatus | 'pending';
+export type VoiceTraceSinkDeliveryStatus = "delivered" | "failed" | "skipped";
+export type VoiceTraceSinkDeliveryQueueStatus = VoiceTraceSinkDeliveryStatus | "pending";
 export type VoiceTraceSinkDeliveryResult = {
     attempts: number;
     deliveredAt?: number;
@@ -95,12 +103,28 @@ export type VoiceTraceHTTPSinkOptions<TBody extends Record<string, unknown> = Re
     headers?: Record<string, string>;
     id: string;
     kind?: string;
-    method?: 'POST' | 'PUT' | 'PATCH';
+    method?: "POST" | "PUT" | "PATCH";
     retries?: number;
     signingSecret?: string;
     timeoutMs?: number;
     url: string;
 };
+export type VoiceS3TraceSinkFile = {
+    write: (data: string, options?: BlobPropertyBag) => Promise<number> | number;
+};
+export type VoiceS3TraceSinkClient = Pick<S3Client, "file">;
+export type VoiceTraceS3SinkOptions<TBody extends Record<string, unknown> = Record<string, unknown>> = S3Options & {
+    body?: (input: {
+        events: StoredVoiceTraceEvent[];
+        key: string;
+    }) => Promise<TBody> | TBody;
+    client?: VoiceS3TraceSinkClient;
+    contentType?: string;
+    eventTypes?: VoiceTraceEventType[];
+    id: string;
+    keyPrefix?: string;
+    kind?: string;
+};
 export type VoiceTraceSinkStoreOptions<TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent> = {
     awaitDelivery?: boolean;
     deliveryQueue?: VoiceTraceSinkDeliveryStore;
@@ -110,6 +134,17 @@ export type VoiceTraceSinkStoreOptions<TEvent extends StoredVoiceTraceEvent = St
     sinks: VoiceTraceSink[];
     store: VoiceTraceEventStore<TEvent>;
 };
+export type VoiceProfileTraceTaggerProfile = {
+    description?: string;
+    id: string;
+    label?: string;
+};
+export type VoiceProfileTraceTaggerOptions<TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent> = {
+    defaultProfile?: VoiceProfileTraceTaggerProfile | string;
+    profiles?: readonly VoiceProfileTraceTaggerProfile[];
+    resolveProfile?: (event: VoiceTraceEvent | TEvent) => Promise<VoiceProfileTraceTaggerProfile | string | undefined> | VoiceProfileTraceTaggerProfile | string | undefined;
+    store: VoiceTraceEventStore<TEvent>;
+};
 export type VoiceTraceSummary = {
     assistantReplyCount: number;
     callDurationMs?: number;
@@ -131,7 +166,7 @@ export type VoiceTraceSummary = {
     transcriptCount: number;
     turnCount: number;
 };
-export type VoiceTraceIssueSeverity = 'error' | 'warning';
+export type VoiceTraceIssueSeverity = "error" | "warning";
 export type VoiceTraceIssue = {
     code: string;
     message: string;
@@ -165,7 +200,7 @@ export type VoiceTraceRedactionOptions = {
     textKeys?: string[];
 };
 export type VoiceTraceRedactionConfig = boolean | VoiceTraceRedactionOptions;
-export type VoiceResolvedTraceRedactionOptions = Required<Pick<VoiceTraceRedactionOptions, 'redactEmails' | 'redactPhoneNumbers' | 'redactText'>> & {
+export type VoiceResolvedTraceRedactionOptions = Required<Pick<VoiceTraceRedactionOptions, "redactEmails" | "redactPhoneNumbers" | "redactText">> & {
     keys: string[];
     replacement: VoiceTraceRedactionReplacement;
     textKeys: string[];
@@ -184,15 +219,19 @@ export declare const createVoiceTraceSinkDeliveryRecord: (input: {
     id?: string;
 } & Partial<Omit<VoiceTraceSinkDeliveryRecord, "createdAt" | "events" | "id">>) => VoiceTraceSinkDeliveryRecord;
 export declare const filterVoiceTraceEvents: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(events: TEvent[], filter?: VoiceTraceEventFilter) => TEvent[];
+export declare const createVoiceScopedTraceEventStore: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(store: VoiceTraceEventStore<TEvent>, scope: VoiceScopedTraceEventStoreOptions) => VoiceTraceEventStore<TEvent>;
+export declare const createVoiceProofTraceStore: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(options?: VoiceProofTraceStoreOptions<TEvent>) => VoiceTraceEventStore<TEvent>;
 export declare const selectVoiceTraceEventsForPrune: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(events: TEvent[], options?: Omit<VoiceTracePruneOptions, "store">) => TEvent[];
 export declare const pruneVoiceTraceEvents: (options: VoiceTracePruneOptions) => Promise<VoiceTracePruneResult>;
 export declare const createVoiceTraceHTTPSink: <TBody extends Record<string, unknown> = Record<string, unknown>>(options: VoiceTraceHTTPSinkOptions<TBody>) => VoiceTraceSink;
+export declare const createVoiceTraceS3Sink: <TBody extends Record<string, unknown> = Record<string, unknown>>(options: VoiceTraceS3SinkOptions<TBody>) => VoiceTraceSink;
 export declare const deliverVoiceTraceEventsToSinks: (input: {
     events: StoredVoiceTraceEvent[];
     redact?: VoiceTraceRedactionConfig;
     sinks: VoiceTraceSink[];
 }) => Promise<VoiceTraceSinkFanoutResult>;
 export declare const createVoiceTraceSinkStore: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(options: VoiceTraceSinkStoreOptions<TEvent>) => VoiceTraceEventStore<TEvent>;
+export declare const createVoiceProfileTraceTagger: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(options: VoiceProfileTraceTaggerOptions<TEvent>) => VoiceTraceEventStore<TEvent>;
 export declare const createVoiceMemoryTraceSinkDeliveryStore: <TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>() => VoiceTraceSinkDeliveryStore<TDelivery>;
 export declare const createVoiceMemoryTraceEventStore: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>() => VoiceTraceEventStore<TEvent>;
 export declare const exportVoiceTrace: (input: {

package/dist/traceDeliveryRoutes.d.ts

@@ -0,0 +1,86 @@
+import { Elysia } from "elysia";
+import { type VoiceTraceSinkDeliveryQueueSummary, type VoiceTraceSinkDeliveryWorkerResult } from "./queue";
+import type { VoiceTraceSinkDeliveryQueueStatus, VoiceTraceSinkDeliveryRecord, VoiceTraceSinkDeliveryStore } from "./trace";
+export type VoiceTraceDeliveryReport = {
+    checkedAt: number;
+    deliveries: VoiceTraceSinkDeliveryRecord[];
+    filter: VoiceTraceDeliveryFilter;
+    summary: VoiceTraceSinkDeliveryQueueSummary;
+};
+export type VoiceTraceDeliveryDrainWorker = {
+    drain: () => Promise<VoiceTraceSinkDeliveryWorkerResult> | VoiceTraceSinkDeliveryWorkerResult;
+};
+export type VoiceTraceDeliveryDrainReport = VoiceTraceSinkDeliveryWorkerResult & {
+    drainedAt: number;
+};
+export type VoiceTraceDeliveryFilter = {
+    limit?: number;
+    q?: string;
+    status?: VoiceTraceSinkDeliveryQueueStatus | "all";
+};
+export type VoiceTraceDeliveryRoutesOptions = {
+    deadLetters?: VoiceTraceSinkDeliveryStore;
+    filter?: VoiceTraceDeliveryFilter;
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    limit?: number;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceTraceDeliveryReport) => string | Promise<string>;
+    store: VoiceTraceSinkDeliveryStore;
+    title?: string;
+    worker?: VoiceTraceDeliveryDrainWorker;
+    workerPath?: false | string;
+};
+export declare const resolveVoiceTraceDeliveryFilter: (query?: Record<string, unknown>, base?: VoiceTraceDeliveryFilter) => VoiceTraceDeliveryFilter;
+export declare const buildVoiceTraceDeliveryReport: (options: VoiceTraceDeliveryRoutesOptions, filter?: VoiceTraceDeliveryFilter) => Promise<VoiceTraceDeliveryReport>;
+export declare const renderVoiceTraceDeliveryHTML: (report: VoiceTraceDeliveryReport, options?: {
+    title?: string;
+    workerPath?: false | string;
+}) => string;
+export declare const createVoiceTraceDeliveryJSONHandler: (options: VoiceTraceDeliveryRoutesOptions) => ({ query }: {
+    query?: Record<string, string | undefined>;
+}) => Promise<VoiceTraceDeliveryReport>;
+export declare const createVoiceTraceDeliveryHTMLHandler: (options: VoiceTraceDeliveryRoutesOptions) => ({ query }: {
+    query?: Record<string, string | undefined>;
+}) => Promise<Response>;
+export declare const createVoiceTraceDeliveryRoutes: (options: VoiceTraceDeliveryRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: VoiceTraceDeliveryReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/traceTimeline.d.ts

@@ -0,0 +1,97 @@
+import { Elysia } from "elysia";
+import { evaluateVoiceTrace, type StoredVoiceTraceEvent, type VoiceTraceEvaluationOptions, type VoiceTraceEventStore, type VoiceTraceRedactionConfig, type VoiceTraceSummary } from "./trace";
+export type VoiceTraceTimelineEvent = {
+    at: number;
+    elapsedMs?: number;
+    id: string;
+    label: string;
+    offsetMs: number;
+    payload: Record<string, unknown>;
+    provider?: string;
+    status?: string;
+    turnId?: string;
+    type: StoredVoiceTraceEvent["type"];
+};
+export type VoiceTraceTimelineProviderSummary = {
+    averageElapsedMs?: number;
+    errorCount: number;
+    eventCount: number;
+    fallbackCount: number;
+    maxElapsedMs?: number;
+    provider: string;
+    successCount: number;
+    timeoutCount: number;
+};
+export type VoiceTraceTimelineSession = {
+    endedAt?: number;
+    evaluation: ReturnType<typeof evaluateVoiceTrace>;
+    events: VoiceTraceTimelineEvent[];
+    lastEventAt?: number;
+    operationsRecordHref?: string;
+    providers: VoiceTraceTimelineProviderSummary[];
+    sessionId: string;
+    startedAt?: number;
+    status: "failed" | "healthy" | "warning";
+    summary: VoiceTraceSummary;
+};
+export type VoiceTraceTimelineReport = {
+    checkedAt: number;
+    failed: number;
+    sessions: VoiceTraceTimelineSession[];
+    total: number;
+    warnings: number;
+};
+export type VoiceTraceTimelineRoutesOptions = {
+    evaluation?: VoiceTraceEvaluationOptions;
+    headers?: HeadersInit;
+    htmlPath?: string;
+    limit?: number;
+    name?: string;
+    operationsRecordHref?: false | string | ((sessionId: string) => string);
+    path?: string;
+    redact?: VoiceTraceRedactionConfig;
+    render?: (report: VoiceTraceTimelineReport) => string | Promise<string>;
+    renderSession?: (session: VoiceTraceTimelineSession) => string | Promise<string>;
+    store: VoiceTraceEventStore;
+    title?: string;
+};
+export declare const summarizeVoiceTraceTimeline: (events: StoredVoiceTraceEvent[], options?: {
+    evaluation?: VoiceTraceEvaluationOptions;
+    limit?: number;
+    operationsRecordHref?: false | string | ((sessionId: string) => string);
+    redact?: VoiceTraceRedactionConfig;
+}) => VoiceTraceTimelineReport;
+export declare const renderVoiceTraceTimelineSessionHTML: (session: VoiceTraceTimelineSession, options?: {
+    title?: string;
+}) => string;
+export declare const renderVoiceTraceTimelineHTML: (report: VoiceTraceTimelineReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceTraceTimelineRoutes: (options: VoiceTraceTimelineRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/turnDetection.d.ts

@@ -1,4 +1,4 @@
-import type { AudioChunk, Transcript } from './types';
+import type { AudioChunk, Transcript } from "./types";
 export declare const DEFAULT_SILENCE_MS = 700;
 export declare const DEFAULT_SPEECH_THRESHOLD = 0.015;
 export declare const measureAudioLevel: (audio: AudioChunk) => number;