@absolutejs/voice 0.0.22-beta.41 → 0.0.22-beta.411

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/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';
+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' | 'operator.action' | 'provider.decision' | '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;
@@ -101,6 +102,22 @@ export type VoiceTraceHTTPSinkOptions<TBody extends Record<string, unknown> = Re
     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 +127,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;
@@ -187,12 +215,14 @@ export declare const filterVoiceTraceEvents: <TEvent extends StoredVoiceTraceEve
 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/turnLatency.d.ts

@@ -0,0 +1,95 @@
+import { Elysia } from 'elysia';
+import type { VoiceTraceEventStore } from './trace';
+import type { VoiceSessionRecord, VoiceSessionStore } from './types';
+export type VoiceTurnLatencyStatus = 'pass' | 'warn' | 'fail' | 'empty';
+export type VoiceTurnLatencyStage = {
+    label: string;
+    valueMs?: number;
+};
+export type VoiceTurnLatencyItem = {
+    assistantTextStartedAt?: number;
+    committedAt: number;
+    finalTranscriptAt?: number;
+    firstTranscriptAt?: number;
+    sessionId: string;
+    stages: VoiceTurnLatencyStage[];
+    status: VoiceTurnLatencyStatus;
+    text: string;
+    totalMs?: number;
+    turnId: string;
+};
+export type VoiceTurnLatencyReport = {
+    averageTotalMs?: number;
+    checkedAt: number;
+    failed: number;
+    sessions: number;
+    status: VoiceTurnLatencyStatus;
+    total: number;
+    turns: VoiceTurnLatencyItem[];
+    warnings: number;
+};
+export type VoiceTurnLatencyOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
+    limit?: number;
+    sessionIds?: string[];
+    sessions?: TSession[];
+    store?: VoiceSessionStore<TSession>;
+    traceStore?: VoiceTraceEventStore;
+    warnAfterMs?: number;
+    failAfterMs?: number;
+};
+export type VoiceTurnLatencyHTMLHandlerOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = VoiceTurnLatencyOptions<TSession> & {
+    headers?: HeadersInit;
+    render?: (report: VoiceTurnLatencyReport) => string | Promise<string>;
+    title?: string;
+};
+export type VoiceTurnLatencyRoutesOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = VoiceTurnLatencyHTMLHandlerOptions<TSession> & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export declare const summarizeVoiceTurnLatency: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceTurnLatencyOptions<TSession>) => Promise<VoiceTurnLatencyReport>;
+export declare const renderVoiceTurnLatencyHTML: (report: VoiceTurnLatencyReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceTurnLatencyJSONHandler: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceTurnLatencyOptions<TSession>) => () => Promise<VoiceTurnLatencyReport>;
+export declare const createVoiceTurnLatencyHTMLHandler: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceTurnLatencyHTMLHandlerOptions<TSession>) => () => Promise<Response>;
+export declare const createVoiceTurnLatencyRoutes: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceTurnLatencyRoutesOptions<TSession>) => 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: VoiceTurnLatencyReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/turnQuality.d.ts

@@ -0,0 +1,94 @@
+import { Elysia } from 'elysia';
+import type { VoiceSessionRecord, VoiceSessionStore, VoiceTranscriptQuality } from './types';
+export type VoiceTurnQualityStatus = 'pass' | 'warn' | 'fail' | 'unknown';
+export type VoiceTurnQualityItem = {
+    averageConfidence?: number;
+    committedAt: number;
+    correctionChanged: boolean;
+    correctionProvider?: string;
+    correctionReason?: string;
+    costUnits?: number;
+    fallbackSelectionReason?: string;
+    fallbackUsed: boolean;
+    finalTranscriptCount: number;
+    latencyMs?: number;
+    partialTranscriptCount: number;
+    selectedTranscriptCount: number;
+    sessionId: string;
+    source?: VoiceTranscriptQuality['source'];
+    status: VoiceTurnQualityStatus;
+    text: string;
+    turnId: string;
+};
+export type VoiceTurnQualityReport = {
+    checkedAt: number;
+    failed: number;
+    sessions: number;
+    status: VoiceTurnQualityStatus;
+    total: number;
+    turns: VoiceTurnQualityItem[];
+    warnings: number;
+};
+export type VoiceTurnQualityOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
+    confidenceWarnThreshold?: number;
+    limit?: number;
+    sessionIds?: string[];
+    sessions?: TSession[];
+    store?: VoiceSessionStore<TSession>;
+};
+export type VoiceTurnQualityHTMLHandlerOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = VoiceTurnQualityOptions<TSession> & {
+    headers?: HeadersInit;
+    render?: (report: VoiceTurnQualityReport) => string | Promise<string>;
+    title?: string;
+};
+export type VoiceTurnQualityRoutesOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = VoiceTurnQualityHTMLHandlerOptions<TSession> & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export declare const summarizeVoiceTurnQuality: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceTurnQualityOptions<TSession>) => Promise<VoiceTurnQualityReport>;
+export declare const renderVoiceTurnQualityHTML: (report: VoiceTurnQualityReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceTurnQualityJSONHandler: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceTurnQualityOptions<TSession>) => () => Promise<VoiceTurnQualityReport>;
+export declare const createVoiceTurnQualityHTMLHandler: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceTurnQualityHTMLHandlerOptions<TSession>) => () => Promise<Response>;
+export declare const createVoiceTurnQualityRoutes: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceTurnQualityRoutesOptions<TSession>) => 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: VoiceTurnQualityReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;