@absolutejs/voice 0.0.22-beta.23 → 0.0.22-beta.230

package/dist/latencySlo.d.ts

@@ -0,0 +1,56 @@
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
+export type VoiceLatencySLOStatus = 'empty' | 'fail' | 'pass' | 'warn';
+export type VoiceLatencySLOStage = 'assistant_text_to_tts_send' | 'barge_in_stop' | 'commit_to_assistant_text' | 'final_to_commit' | 'live_latency' | 'provider_llm' | 'provider_stt' | 'provider_tts' | 'speech_to_commit' | 'tts_send_duration' | 'tts_to_first_audio';
+export type VoiceLatencySLOBudget = {
+    failAfterMs: number;
+    warnAfterMs?: number;
+};
+export type VoiceLatencySLOMeasurement = {
+    at: number;
+    latencyMs: number;
+    label: string;
+    provider?: string;
+    sessionId: string;
+    stage: VoiceLatencySLOStage;
+    status: Exclude<VoiceLatencySLOStatus, 'empty'>;
+    turnId?: string;
+};
+export type VoiceLatencySLOStageSummary = {
+    averageMs?: number;
+    budget: VoiceLatencySLOBudget;
+    failed: number;
+    label: string;
+    maxMs?: number;
+    measurements: VoiceLatencySLOMeasurement[];
+    p50Ms?: number;
+    p95Ms?: number;
+    stage: VoiceLatencySLOStage;
+    status: VoiceLatencySLOStatus;
+    total: number;
+    warnings: number;
+};
+export type VoiceLatencySLOGateReport = {
+    checkedAt: number;
+    failed: number;
+    measurements: VoiceLatencySLOMeasurement[];
+    stages: VoiceLatencySLOStageSummary[];
+    status: VoiceLatencySLOStatus;
+    total: number;
+    warnings: number;
+};
+export type VoiceLatencySLOGateOptions = {
+    budgets?: Partial<Record<VoiceLatencySLOStage, VoiceLatencySLOBudget>>;
+    events?: StoredVoiceTraceEvent[];
+    failAfterMs?: number;
+    limit?: number;
+    store?: VoiceTraceEventStore;
+    warnAfterMs?: number;
+};
+export type VoiceLatencySLOGateError = Error & {
+    report: VoiceLatencySLOGateReport;
+};
+export declare const buildVoiceLatencySLOGate: (options: VoiceLatencySLOGateOptions) => Promise<VoiceLatencySLOGateReport>;
+export declare const assertVoiceLatencySLOGate: (options: VoiceLatencySLOGateOptions) => Promise<VoiceLatencySLOGateReport>;
+export declare const renderVoiceLatencySLOMarkdown: (report: VoiceLatencySLOGateReport, options?: {
+    title?: string;
+}) => string;

package/dist/liveLatency.d.ts

@@ -0,0 +1,78 @@
+import { Elysia } from 'elysia';
+import type { VoiceTraceEventStore } from './trace';
+export type VoiceLiveLatencyStatus = 'empty' | 'fail' | 'pass' | 'warn';
+export type VoiceLiveLatencySample = {
+    at: number;
+    latencyMs: number;
+    sessionId: string;
+    status?: string;
+    traceId?: string;
+};
+export type VoiceLiveLatencyReport = {
+    averageLatencyMs?: number;
+    checkedAt: number;
+    failed: number;
+    p50LatencyMs?: number;
+    p95LatencyMs?: number;
+    recent: VoiceLiveLatencySample[];
+    status: VoiceLiveLatencyStatus;
+    total: number;
+    warnings: number;
+};
+export type VoiceLiveLatencyOptions = {
+    failAfterMs?: number;
+    limit?: number;
+    store: VoiceTraceEventStore;
+    warnAfterMs?: number;
+};
+export type VoiceLiveLatencyRoutesOptions = VoiceLiveLatencyOptions & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+    title?: string;
+};
+export declare const summarizeVoiceLiveLatency: (options: VoiceLiveLatencyOptions) => Promise<VoiceLiveLatencyReport>;
+export declare const renderVoiceLiveLatencyHTML: (report: VoiceLiveLatencyReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceLiveLatencyRoutes: (options: VoiceLiveLatencyRoutesOptions) => 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: VoiceLiveLatencyReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/liveOps.d.ts

@@ -0,0 +1,122 @@
+import { Elysia } from 'elysia';
+import { type VoiceAuditEventStore } from './audit';
+import { type VoiceTraceEventStore } from './trace';
+export declare const VOICE_LIVE_OPS_ACTIONS: readonly ["assign", "create-task", "escalate", "force-handoff", "inject-instruction", "operator-takeover", "pause-assistant", "resume-assistant", "tag"];
+export type VoiceLiveOpsAction = (typeof VOICE_LIVE_OPS_ACTIONS)[number];
+export type VoiceLiveOpsControlStatus = 'assistant-paused' | 'assistant-resumed' | 'handoff-forced' | 'instruction-injected' | 'operator-takeover' | 'recorded';
+export type VoiceLiveOpsControlState = {
+    assistantPaused: boolean;
+    handoffTarget?: string;
+    injectedInstruction?: string;
+    lastAction: VoiceLiveOpsAction;
+    lastUpdatedAt: number;
+    operator?: string;
+    operatorTakeover: boolean;
+    status: VoiceLiveOpsControlStatus;
+    tag?: string;
+};
+export type VoiceLiveOpsActionInput = {
+    action: VoiceLiveOpsAction;
+    assignee?: string;
+    detail?: string;
+    sessionId: string;
+    tag?: string;
+};
+export type VoiceLiveOpsActionResult = {
+    action: VoiceLiveOpsAction;
+    control: VoiceLiveOpsControlState;
+    ok: true;
+    sessionId: string;
+};
+export type VoiceLiveOpsControlStore = {
+    get: (sessionId: string) => Promise<VoiceLiveOpsControlState | undefined> | VoiceLiveOpsControlState | undefined;
+    set: (sessionId: string, state: VoiceLiveOpsControlState) => Promise<void> | void;
+};
+export type VoiceLiveOpsControllerOptions = {
+    audit?: VoiceAuditEventStore;
+    defaultAssignee?: string;
+    defaultDetail?: string;
+    defaultTag?: string;
+    onAction?: (result: VoiceLiveOpsActionResult & {
+        assignee: string;
+        detail: string;
+        tag: string;
+    }) => Promise<void> | void;
+    store?: VoiceLiveOpsControlStore;
+    trace?: VoiceTraceEventStore;
+};
+export type VoiceLiveOpsRoutesOptions = VoiceLiveOpsControllerOptions & {
+    controlPath?: string;
+    name?: string;
+    path?: string;
+};
+export declare const createVoiceMemoryLiveOpsControlStore: () => VoiceLiveOpsControlStore;
+export declare const getVoiceLiveOpsControlStatus: (action: VoiceLiveOpsAction) => VoiceLiveOpsControlStatus;
+export declare const buildVoiceLiveOpsControlState: (input: VoiceLiveOpsActionInput & {
+    at?: number;
+    previous?: VoiceLiveOpsControlState;
+}) => VoiceLiveOpsControlState;
+export declare const createVoiceLiveOpsController: (options?: VoiceLiveOpsControllerOptions) => {
+    get: (sessionId: string) => VoiceLiveOpsControlState | Promise<VoiceLiveOpsControlState | undefined> | undefined;
+    perform: (input: VoiceLiveOpsActionInput) => Promise<VoiceLiveOpsActionResult>;
+    store: VoiceLiveOpsControlStore;
+};
+export declare const createVoiceLiveOpsRoutes: (options?: VoiceLiveOpsRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: VoiceLiveOpsActionResult | {
+                    error: string;
+                    ok: boolean;
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: {
+                    control: VoiceLiveOpsControlState | undefined;
+                    ok: boolean;
+                    sessionId: string;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/modelAdapters.d.ts

@@ -36,9 +36,11 @@ export type GeminiVoiceAssistantModelOptions = {
 };
 export type VoiceProviderRouterEvent<TProvider extends string = string> = {
     at: number;
+    attempt: number;
     elapsedMs: number;
     error?: string;
     fallbackProvider?: TProvider;
+    latencyBudgetMs?: number;
     provider: TProvider;
     providerHealth?: VoiceProviderRouterProviderHealth<TProvider>;
     rateLimited?: boolean;
@@ -47,18 +49,35 @@ export type VoiceProviderRouterEvent<TProvider extends string = string> = {
     suppressionRemainingMs?: number;
     suppressedUntil?: number;
     status: 'error' | 'fallback' | 'success';
+    timedOut?: boolean;
 };
 export type VoiceProviderRouterFallbackMode = 'never' | 'provider-error' | 'rate-limit';
-export type VoiceProviderRouterPolicy<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TProvider extends string = string> = 'ordered' | 'prefer-cheapest' | 'prefer-fastest' | 'prefer-selected' | {
+export type VoiceProviderRouterStrategy = 'balanced' | 'ordered' | 'prefer-cheapest' | 'prefer-fastest' | 'prefer-selected' | 'quality-first';
+export type VoiceProviderRouterPolicyPreset = 'balanced' | 'cost-cap' | 'cost-first' | 'latency-first' | 'quality-first';
+export type VoiceProviderRouterPolicyWeights = {
+    cost?: number;
+    latencyMs?: number;
+    priority?: number;
+    quality?: number;
+};
+export type VoiceProviderRouterPolicy<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TProvider extends string = string> = VoiceProviderRouterStrategy | VoiceProviderRouterPolicyPreset | {
     allowProviders?: readonly TProvider[] | ((input: VoiceAgentModelInput<TContext, TSession>) => readonly TProvider[] | Promise<readonly TProvider[]>);
     fallbackMode?: VoiceProviderRouterFallbackMode;
-    strategy?: 'ordered' | 'prefer-cheapest' | 'prefer-fastest' | 'prefer-selected';
+    maxCost?: number;
+    maxLatencyMs?: number;
+    minQuality?: number;
+    scoreProvider?: (provider: TProvider, profile: VoiceProviderRouterProviderProfile | undefined) => number;
+    strategy?: VoiceProviderRouterStrategy;
+    weights?: VoiceProviderRouterPolicyWeights;
 };
 export type VoiceProviderRouterProviderProfile = {
     cost?: number;
     latencyMs?: number;
     priority?: number;
+    quality?: number;
+    timeoutMs?: number;
 };
+export declare const resolveVoiceProviderRoutingPolicyPreset: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TProvider extends string = string>(preset: VoiceProviderRouterPolicyPreset, options?: Omit<Extract<VoiceProviderRouterPolicy<TContext, TSession, TProvider>, Record<string, unknown>>, "strategy">) => Extract<VoiceProviderRouterPolicy<TContext, TSession, TProvider>, Record<string, unknown>>;
 export type VoiceProviderRouterHealthOptions = {
     cooldownMs?: number;
     failureThreshold?: number;
@@ -79,10 +98,12 @@ export type VoiceProviderRouterOptions<TContext = unknown, TSession extends Voic
     fallbackMode?: VoiceProviderRouterFallbackMode;
     isProviderError?: (error: unknown, provider: TProvider) => boolean;
     isRateLimitError?: (error: unknown, provider: TProvider) => boolean;
+    isTimeoutError?: (error: unknown, provider: TProvider) => boolean;
     onProviderEvent?: (event: VoiceProviderRouterEvent<TProvider>, input: VoiceAgentModelInput<TContext, TSession>) => Promise<void> | void;
     policy?: VoiceProviderRouterPolicy<TContext, TSession, TProvider>;
     providerHealth?: boolean | VoiceProviderRouterHealthOptions;
     providerProfiles?: Partial<Record<TProvider, VoiceProviderRouterProviderProfile>>;
+    timeoutMs?: number;
     providers: Partial<Record<TProvider, VoiceAgentModel<TContext, TSession, TResult>>>;
     selectProvider?: (input: VoiceAgentModelInput<TContext, TSession>) => TProvider | undefined | Promise<TProvider | undefined>;
 };

package/dist/observabilityExport.d.ts

@@ -0,0 +1,297 @@
+import { Elysia } from 'elysia';
+import type { S3Client, S3Options } from 'bun';
+import { Database } from 'bun:sqlite';
+import { type VoiceAuditSinkDeliveryQueueSummary, type VoiceAuditSinkDeliveryRecord, type VoiceAuditSinkDeliveryStore } from './auditSinks';
+import type { VoiceAuditEventStore, VoiceAuditEventType } from './audit';
+import { type VoiceOperationsRecord } from './operationsRecord';
+import { type VoiceTraceSinkDeliveryQueueSummary } from './queue';
+import { type StoredVoiceTraceEvent, type VoiceTraceEventStore, type VoiceTraceEventType, type VoiceTraceRedactionConfig, type VoiceTraceSinkDeliveryRecord, type VoiceTraceSinkDeliveryStore, type VoiceTraceSummary } from './trace';
+import type { VoicePostgresClient } from './postgresStore';
+export type VoiceObservabilityExportStatus = 'fail' | 'pass' | 'warn';
+export declare const voiceObservabilityExportSchemaVersion = "1.0.0";
+export declare const voiceObservabilityExportSchemaId = "com.absolutejs.voice.observability-export";
+export type VoiceObservabilityExportSchema = {
+    id: typeof voiceObservabilityExportSchemaId;
+    version: typeof voiceObservabilityExportSchemaVersion;
+};
+export declare const createVoiceObservabilityExportSchema: () => VoiceObservabilityExportSchema;
+export declare const assertVoiceObservabilityExportSchema: (input: {
+    schema?: {
+        id?: string;
+        version?: string;
+    };
+}) => void;
+export type VoiceObservabilityExportArtifactKind = 'incident' | 'markdown' | 'operations-record' | 'proof-pack' | 'readiness' | 'screenshot' | 'slo' | 'trace' | 'audit' | 'custom';
+export type VoiceObservabilityExportArtifactChecksum = {
+    algorithm: 'sha256';
+    value: string;
+};
+export type VoiceObservabilityExportArtifactFreshness = {
+    ageMs?: number;
+    checkedAt: number;
+    generatedAt?: number | string;
+    maxAgeMs?: number;
+    status: VoiceObservabilityExportStatus;
+};
+export type VoiceObservabilityExportArtifact = {
+    bytes?: number;
+    checksum?: VoiceObservabilityExportArtifactChecksum;
+    contentType?: string;
+    downloadHref?: string;
+    freshness?: VoiceObservabilityExportArtifactFreshness;
+    generatedAt?: number | string;
+    href?: string;
+    id: string;
+    kind: VoiceObservabilityExportArtifactKind;
+    label: string;
+    maxAgeMs?: number;
+    path?: string;
+    required?: boolean;
+    sessionId?: string;
+    status?: VoiceObservabilityExportStatus;
+};
+export type VoiceObservabilityExportEnvelope = {
+    at: number;
+    eventId: string;
+    eventType: VoiceTraceEventType | VoiceAuditEventType;
+    kind: 'audit' | 'trace';
+    operationsRecordHref?: string;
+    provider?: string;
+    providerKind?: string;
+    scenarioId?: string;
+    sessionId?: string;
+    severity: VoiceObservabilityExportStatus;
+    traceId?: string;
+};
+export type VoiceObservabilityExportIssueCode = 'voice.observability.no_evidence' | 'voice.observability.operation_failed' | 'voice.observability.artifact_missing' | 'voice.observability.artifact_stale' | 'voice.observability.audit_delivery_failed' | 'voice.observability.audit_delivery_pending' | 'voice.observability.trace_delivery_failed' | 'voice.observability.trace_delivery_pending';
+export type VoiceObservabilityExportIssue = {
+    code: VoiceObservabilityExportIssueCode;
+    detail?: string;
+    label: string;
+    severity: Exclude<VoiceObservabilityExportStatus, 'pass'>;
+    value?: number | string;
+};
+export type VoiceObservabilityExportDeliverySummary = {
+    audit?: VoiceAuditSinkDeliveryQueueSummary;
+    trace?: VoiceTraceSinkDeliveryQueueSummary;
+};
+export type VoiceObservabilityExportRedactionSummary = {
+    enabled: boolean;
+    mode: 'none' | 'redacted';
+};
+export type VoiceObservabilityExportReport = {
+    artifacts: VoiceObservabilityExportArtifact[];
+    checkedAt: number;
+    deliveries: VoiceObservabilityExportDeliverySummary;
+    envelopes: VoiceObservabilityExportEnvelope[];
+    issues: VoiceObservabilityExportIssue[];
+    operationsRecords: VoiceOperationsRecord[];
+    redaction: VoiceObservabilityExportRedactionSummary;
+    schema: VoiceObservabilityExportSchema;
+    sessionIds: string[];
+    status: VoiceObservabilityExportStatus;
+    summary: {
+        auditEvents: number;
+        events: number;
+        failedOperationsRecords: number;
+        trace: VoiceTraceSummary;
+        traceEvents: number;
+    };
+};
+export type VoiceObservabilityExportArtifactIndexItem = {
+    bytes?: number;
+    checksum?: VoiceObservabilityExportArtifactChecksum;
+    contentType?: string;
+    downloadHref?: string;
+    freshness?: VoiceObservabilityExportArtifactFreshness;
+    href?: string;
+    id: string;
+    kind: VoiceObservabilityExportArtifactKind;
+    label: string;
+    required?: boolean;
+    sessionId?: string;
+    status?: VoiceObservabilityExportStatus;
+};
+export type VoiceObservabilityExportArtifactIndex = {
+    artifacts: VoiceObservabilityExportArtifactIndexItem[];
+    checkedAt: number;
+    schema: VoiceObservabilityExportSchema;
+    status: VoiceObservabilityExportStatus;
+    summary: {
+        downloadable: number;
+        failed: number;
+        required: number;
+        total: number;
+        warn: number;
+    };
+};
+export type VoiceObservabilityExportDeliveryDestination = {
+    directory: string;
+    id?: string;
+    includeArtifacts?: boolean;
+    kind: 'file';
+    label?: string;
+} | (S3Options & {
+    bucket?: string;
+    client?: Pick<S3Client, 'file'>;
+    id?: string;
+    includeArtifacts?: boolean;
+    keyPrefix?: string;
+    kind: 's3';
+    label?: string;
+}) | {
+    database?: Database;
+    id?: string;
+    kind: 'sqlite';
+    label?: string;
+    path?: string;
+    tableName?: string;
+} | {
+    connectionString?: string;
+    id?: string;
+    kind: 'postgres';
+    label?: string;
+    schemaName?: string;
+    sql?: VoicePostgresClient;
+    tableName?: string;
+} | {
+    fetch?: typeof fetch;
+    headers?: Record<string, string>;
+    id?: string;
+    includeArtifacts?: boolean;
+    kind: 'webhook';
+    label?: string;
+    timeoutMs?: number;
+    url: string;
+};
+export type VoiceObservabilityExportDeliveryDestinationResult = {
+    artifactCount: number;
+    deliveredAt: number;
+    destinationId: string;
+    destinationKind: VoiceObservabilityExportDeliveryDestination['kind'];
+    error?: string;
+    label: string;
+    manifestBytes: number;
+    schema: VoiceObservabilityExportSchema;
+    status: 'delivered' | 'failed';
+    target: string;
+};
+export type VoiceObservabilityExportDeliveryReport = {
+    checkedAt: number;
+    destinations: VoiceObservabilityExportDeliveryDestinationResult[];
+    exportStatus: VoiceObservabilityExportStatus;
+    status: VoiceObservabilityExportStatus;
+    summary: {
+        delivered: number;
+        failed: number;
+        total: number;
+    };
+};
+export type VoiceObservabilityExportDeliveryReceipt = {
+    checkedAt: number;
+    destinations: VoiceObservabilityExportDeliveryDestinationResult[];
+    exportStatus: VoiceObservabilityExportStatus;
+    id: string;
+    runId: string;
+    status: VoiceObservabilityExportStatus;
+    summary: VoiceObservabilityExportDeliveryReport['summary'];
+};
+export type VoiceObservabilityExportDeliveryReceiptStore = {
+    get: (id: string) => Promise<VoiceObservabilityExportDeliveryReceipt | undefined> | VoiceObservabilityExportDeliveryReceipt | undefined;
+    list: () => Promise<VoiceObservabilityExportDeliveryReceipt[]> | VoiceObservabilityExportDeliveryReceipt[];
+    remove: (id: string) => Promise<void> | void;
+    set: (id: string, receipt: VoiceObservabilityExportDeliveryReceipt) => Promise<void> | void;
+};
+export type VoiceObservabilityExportDeliveryHistory = {
+    checkedAt: number;
+    receipts: VoiceObservabilityExportDeliveryReceipt[];
+    status: VoiceObservabilityExportStatus;
+    summary: {
+        delivered: number;
+        failed: number;
+        receipts: number;
+        totalDestinations: number;
+    };
+};
+export type VoiceObservabilityExportDeliveryOptions = {
+    destinations: VoiceObservabilityExportDeliveryDestination[];
+    report: VoiceObservabilityExportReport;
+    receipts?: VoiceObservabilityExportDeliveryReceiptStore;
+    runId?: string;
+};
+export type VoiceObservabilityExportOptions = {
+    artifacts?: VoiceObservabilityExportArtifact[];
+    artifactIntegrity?: {
+        checksum?: false | 'sha256';
+        maxAgeMs?: number;
+        missingSeverity?: Exclude<VoiceObservabilityExportStatus, 'pass'>;
+        now?: number;
+        staleSeverity?: Exclude<VoiceObservabilityExportStatus, 'pass'>;
+    };
+    audit?: VoiceAuditEventStore;
+    auditDeliveries?: VoiceAuditSinkDeliveryRecord[] | VoiceAuditSinkDeliveryStore;
+    events?: StoredVoiceTraceEvent[];
+    includeOperationsRecords?: boolean;
+    links?: {
+        artifactDownload?: (artifact: VoiceObservabilityExportArtifact) => string;
+        operationsRecord?: (sessionId: string) => string;
+    };
+    operationsRecords?: VoiceOperationsRecord[];
+    redact?: VoiceTraceRedactionConfig;
+    sessionIds?: string[];
+    store?: VoiceTraceEventStore;
+    traceDeliveries?: VoiceTraceSinkDeliveryRecord[] | VoiceTraceSinkDeliveryStore;
+};
+export type VoiceObservabilityExportRoutesOptions = VoiceObservabilityExportOptions & {
+    headers?: HeadersInit;
+    artifactDownloadPath?: false | string;
+    artifactIndexPath?: false | string;
+    deliveryDestinations?: VoiceObservabilityExportDeliveryDestination[];
+    deliveryPath?: false | string;
+    deliveryReceipts?: VoiceObservabilityExportDeliveryReceiptStore;
+    htmlPath?: false | string;
+    markdownPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceObservabilityExportReport) => string | Promise<string>;
+    title?: string;
+};
+export declare const createVoiceMemoryObservabilityExportDeliveryReceiptStore: () => VoiceObservabilityExportDeliveryReceiptStore;
+export declare const createVoiceFileObservabilityExportDeliveryReceiptStore: (options: {
+    directory: string;
+}) => VoiceObservabilityExportDeliveryReceiptStore;
+export declare const buildVoiceObservabilityExportDeliveryHistory: (store: VoiceObservabilityExportDeliveryReceiptStore) => Promise<VoiceObservabilityExportDeliveryHistory>;
+export declare const buildVoiceObservabilityExport: (options?: VoiceObservabilityExportOptions) => Promise<VoiceObservabilityExportReport>;
+export declare const renderVoiceObservabilityExportMarkdown: (report: VoiceObservabilityExportReport, options?: {
+    title?: string;
+}) => string;
+export declare const buildVoiceObservabilityArtifactIndex: (report: VoiceObservabilityExportReport) => VoiceObservabilityExportArtifactIndex;
+export declare const deliverVoiceObservabilityExport: (options: VoiceObservabilityExportDeliveryOptions) => Promise<VoiceObservabilityExportDeliveryReport>;
+export declare const createVoiceObservabilityExportRoutes: (options?: VoiceObservabilityExportRoutesOptions) => 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/openaiRealtime.d.ts

@@ -0,0 +1,27 @@
+import type { RealtimeAdapter } from './types';
+export type OpenAIRealtimeModel = 'gpt-realtime' | 'gpt-realtime-mini' | 'gpt-4o-realtime-preview' | 'gpt-4o-mini-realtime-preview' | (string & {});
+export type OpenAIRealtimeVoice = 'alloy' | 'ash' | 'ballad' | 'cedar' | 'coral' | 'echo' | 'marin' | 'sage' | 'shimmer' | 'verse' | {
+    id: string;
+} | (string & {});
+export type OpenAIRealtimeTranscriptionModel = 'gpt-4o-mini-transcribe' | 'gpt-4o-transcribe' | 'whisper-1' | (string & {});
+export type OpenAIRealtimeNoiseReduction = 'near_field' | 'far_field';
+export type OpenAIRealtimeResponseMode = 'audio' | 'text';
+export type OpenAIRealtimeAdapterOptions = {
+    apiKey: string;
+    autoCommitSilenceMs?: number;
+    baseUrl?: string;
+    emitResponseTranscripts?: boolean;
+    inputTranscriptionLanguage?: string;
+    inputTranscriptionModel?: OpenAIRealtimeTranscriptionModel | null;
+    inputTranscriptionPrompt?: string;
+    instructions?: string;
+    maxOutputTokens?: number | 'inf';
+    model?: OpenAIRealtimeModel;
+    noiseReduction?: OpenAIRealtimeNoiseReduction;
+    responseMode?: OpenAIRealtimeResponseMode;
+    speed?: number;
+    temperature?: number;
+    voice?: OpenAIRealtimeVoice;
+    webSocket?: typeof WebSocket;
+};
+export declare const createOpenAIRealtimeAdapter: (options: OpenAIRealtimeAdapterOptions) => RealtimeAdapter;

package/dist/openaiTTS.d.ts

@@ -0,0 +1,18 @@
+import type { TTSAdapter, TTSAdapterOpenOptions, VoiceLexiconEntry } from './types';
+export type OpenAIVoiceTTSVoice = 'alloy' | 'ash' | 'ballad' | 'cedar' | 'coral' | 'echo' | 'fable' | 'marin' | 'nova' | 'onyx' | 'sage' | 'shimmer' | 'verse' | (string & {});
+export type OpenAIVoiceTTSOptions = {
+    apiKey: string;
+    baseUrl?: string;
+    fetch?: typeof fetch;
+    instructions?: string | ((input: {
+        lexicon?: VoiceLexiconEntry[];
+        sessionId: string;
+        text: string;
+    }) => Promise<string | undefined> | string | undefined);
+    model?: 'gpt-4o-mini-tts' | 'tts-1' | 'tts-1-hd' | (string & {});
+    speed?: number;
+    voice?: OpenAIVoiceTTSVoice | {
+        id: string;
+    };
+};
+export declare const createOpenAIVoiceTTS: (options: OpenAIVoiceTTSOptions) => TTSAdapter<TTSAdapterOpenOptions>;