@absolutejs/voice 0.0.22-beta.54 → 0.0.22-beta.540

package/dist/core/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 assertVoiceToolContractEvidence: (report: VoiceToolContractSuiteReport, input?: VoiceToolContractAssertionInput) => VoiceToolContractAssertionReport;
+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>) => {
+    definition: VoiceToolContractDefinition<TContext, TSession, TArgs, TToolResult, TRouteResult>;
+    assert: () => Promise<VoiceToolContractReport>;
+    run: () => Promise<VoiceToolContractReport>;
+};
+export declare const createVoiceToolContractHTMLHandler: (options: VoiceToolContractHTMLHandlerOptions) => () => Promise<Response>;
+export declare const createVoiceToolContractJSONHandler: (options: VoiceToolContractHandlerOptions) => () => Promise<VoiceToolContractSuiteReport>;
+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: {};
+}>;
+export declare const createVoiceToolRuntimeContractDefaults: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TRouteResult = unknown>() => VoiceToolRuntimeOptions<TContext, TSession, TRouteResult>;
+export declare const evaluateVoiceToolContractEvidence: (report: VoiceToolContractSuiteReport, input?: VoiceToolContractAssertionInput) => VoiceToolContractAssertionReport;
+export declare const renderVoiceToolContractHTML: (report: VoiceToolContractSuiteReport, options?: {
+    title?: string;
+}) => 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 runVoiceToolContractSuite: (options: VoiceToolContractHandlerOptions) => Promise<VoiceToolContractSuiteReport>;

package/dist/core/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 createVoiceToolIdempotencyKey: (input: {
+    args: unknown;
+    sessionId: string;
+    toolCallId?: string;
+    toolName: string;
+    turnId: string;
+}) => string;
+export declare const createVoiceToolRuntime: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TRouteResult = unknown>(options?: VoiceToolRuntimeOptions<TContext, TSession, TRouteResult>) => VoiceToolRuntime<TContext, TSession, TRouteResult>;

package/dist/{trace.d.ts → core/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,36 +200,40 @@ 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[];
 };
+export declare const createVoiceTraceEvent: <TEvent extends VoiceTraceEvent = VoiceTraceEvent>(event: TEvent) => StoredVoiceTraceEvent<TEvent["payload"]>;
 export declare const createVoiceTraceEventId: (event: {
     at?: number;
     sessionId: string;
     turnId?: string;
     type: VoiceTraceEventType;
 }) => string;
-export declare const createVoiceTraceEvent: <TEvent extends VoiceTraceEvent = VoiceTraceEvent>(event: TEvent) => StoredVoiceTraceEvent<TEvent["payload"]>;
 export declare const createVoiceTraceSinkDeliveryId: (events: StoredVoiceTraceEvent[]) => string;
 export declare const createVoiceTraceSinkDeliveryRecord: (input: {
     createdAt?: number;
     events: StoredVoiceTraceEvent[];
     id?: string;
 } & Partial<Omit<VoiceTraceSinkDeliveryRecord, "createdAt" | "events" | "id">>) => VoiceTraceSinkDeliveryRecord;
+export declare const createVoiceProofTraceStore: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(options?: VoiceProofTraceStoreOptions<TEvent>) => VoiceTraceEventStore<TEvent>;
+export declare const createVoiceScopedTraceEventStore: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(store: VoiceTraceEventStore<TEvent>, scope: VoiceScopedTraceEventStoreOptions) => VoiceTraceEventStore<TEvent>;
 export declare const filterVoiceTraceEvents: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(events: TEvent[], filter?: VoiceTraceEventFilter) => 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 selectVoiceTraceEventsForPrune: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(events: TEvent[], options?: Omit<VoiceTracePruneOptions, "store">) => TEvent[];
 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 createVoiceTraceSinkStore: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(options: VoiceTraceSinkStoreOptions<TEvent>) => VoiceTraceEventStore<TEvent>;
 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 createVoiceMemoryTraceSinkDeliveryStore: <TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>() => VoiceTraceSinkDeliveryStore<TDelivery>;
 export declare const createVoiceMemoryTraceEventStore: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>() => VoiceTraceEventStore<TEvent>;
+export declare const createVoiceMemoryTraceSinkDeliveryStore: <TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>() => VoiceTraceSinkDeliveryStore<TDelivery>;
+export declare const createVoiceProfileTraceTagger: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(options: VoiceProfileTraceTaggerOptions<TEvent>) => VoiceTraceEventStore<TEvent>;
 export declare const exportVoiceTrace: (input: {
     filter?: VoiceTraceEventFilter;
     redact?: VoiceTraceRedactionConfig;
@@ -210,20 +249,10 @@ export declare const redactVoiceTraceText: (value: string, options?: VoiceTraceR
     key?: string;
     path?: string[];
 }) => string;
+export declare const evaluateVoiceTrace: (events: StoredVoiceTraceEvent[], options?: VoiceTraceEvaluationOptions) => VoiceTraceEvaluation;
 export declare const redactVoiceTraceEvent: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(event: TEvent, options?: VoiceTraceRedactionConfig) => TEvent;
 export declare const redactVoiceTraceEvents: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(events: TEvent[], options?: VoiceTraceRedactionConfig) => TEvent[];
 export declare const summarizeVoiceTrace: (events: StoredVoiceTraceEvent[]) => VoiceTraceSummary;
-export declare const evaluateVoiceTrace: (events: StoredVoiceTraceEvent[], options?: VoiceTraceEvaluationOptions) => VoiceTraceEvaluation;
-export declare const renderVoiceTraceMarkdown: (events: StoredVoiceTraceEvent[], options?: {
-    title?: string;
-    evaluation?: VoiceTraceEvaluationOptions;
-    redact?: VoiceTraceRedactionConfig;
-}) => string;
-export declare const renderVoiceTraceHTML: (events: StoredVoiceTraceEvent[], options?: {
-    title?: string;
-    evaluation?: VoiceTraceEvaluationOptions;
-    redact?: VoiceTraceRedactionConfig;
-}) => string;
 export declare const buildVoiceTraceReplay: (events: StoredVoiceTraceEvent[], options?: {
     evaluation?: VoiceTraceEvaluationOptions;
     redact?: VoiceTraceRedactionConfig;
@@ -234,3 +263,13 @@ export declare const buildVoiceTraceReplay: (events: StoredVoiceTraceEvent[], op
     markdown: string;
     summary: VoiceTraceSummary;
 };
+export declare const renderVoiceTraceHTML: (events: StoredVoiceTraceEvent[], options?: {
+    title?: string;
+    evaluation?: VoiceTraceEvaluationOptions;
+    redact?: VoiceTraceRedactionConfig;
+}) => string;
+export declare const renderVoiceTraceMarkdown: (events: StoredVoiceTraceEvent[], options?: {
+    title?: string;
+    evaluation?: VoiceTraceEvaluationOptions;
+    redact?: VoiceTraceRedactionConfig;
+}) => string;

package/dist/core/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 createVoiceTraceDeliveryHTMLHandler: (options: VoiceTraceDeliveryRoutesOptions) => ({ query }: {
+    query?: Record<string, string | undefined>;
+}) => Promise<Response>;
+export declare const createVoiceTraceDeliveryJSONHandler: (options: VoiceTraceDeliveryRoutesOptions) => ({ query }: {
+    query?: Record<string, string | undefined>;
+}) => Promise<VoiceTraceDeliveryReport>;
+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: {};
+}>;
+export declare const renderVoiceTraceDeliveryHTML: (report: VoiceTraceDeliveryReport, options?: {
+    title?: string;
+    workerPath?: false | string;
+}) => string;

package/dist/core/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 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: {};
+}>;
+export declare const renderVoiceTraceTimelineHTML: (report: VoiceTraceTimelineReport, options?: {
+    title?: string;
+}) => string;

package/dist/core/transcriptAnnotator.d.ts

@@ -0,0 +1,41 @@
+export type VoiceTranscriptAnnotationKind = "great-recovery" | "missed-objection" | "compliance-concern" | "tone-issue" | "knowledge-gap" | "follow-up-needed" | "custom";
+export type VoiceTranscriptAnnotation = {
+    id: string;
+    sessionId: string;
+    supervisorId: string;
+    kind: VoiceTranscriptAnnotationKind;
+    customLabel?: string;
+    text?: string;
+    turnId?: string;
+    rangeStartMs: number;
+    rangeEndMs?: number;
+    createdAt: number;
+    severity: "info" | "minor" | "major";
+};
+export type CreateVoiceTranscriptAnnotatorOptions = {
+    sessionId: string;
+    generateId?: () => string;
+    now?: () => number;
+};
+export declare const DEFAULT_VOICE_ANNOTATION_KIND_SEVERITY: Record<VoiceTranscriptAnnotationKind, VoiceTranscriptAnnotation["severity"]>;
+export declare const createVoiceTranscriptAnnotator: (options: CreateVoiceTranscriptAnnotatorOptions) => {
+    add: (input: Omit<VoiceTranscriptAnnotation, "id" | "createdAt" | "sessionId" | "severity"> & {
+        severity?: VoiceTranscriptAnnotation["severity"];
+        id?: string;
+    }) => VoiceTranscriptAnnotation;
+    list: (filter?: {
+        kind?: VoiceTranscriptAnnotationKind;
+        supervisorId?: string;
+        severity?: VoiceTranscriptAnnotation["severity"];
+        fromMs?: number;
+        toMs?: number;
+    }) => VoiceTranscriptAnnotation[];
+    remove: (id: string) => boolean;
+    sessionId: string;
+    summarize: () => {
+        byKind: Partial<Record<VoiceTranscriptAnnotationKind, number>>;
+        bySeverity: Record<"info" | "minor" | "major", number>;
+        total: number;
+    };
+};
+export type VoiceTranscriptAnnotator = ReturnType<typeof createVoiceTranscriptAnnotator>;

package/dist/{turnDetection.d.ts → core/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;