@absolutejs/voice 0.0.22-beta.53 → 0.0.22-beta.530

package/dist/opsRecovery.d.ts

@@ -0,0 +1,137 @@
+import { Elysia } from "elysia";
+import { type VoiceAuditSinkDeliveryQueueSummary, type VoiceAuditSinkDeliveryStore } from "./auditSinks";
+import { type VoiceLatencySLOGateOptions, type VoiceLatencySLOGateReport } from "./latencySlo";
+import { type VoiceHandoffDeliveryQueueSummary, type VoiceTraceSinkDeliveryQueueSummary } from "./queue";
+import { type VoiceProviderHealthSummary } from "./providerHealth";
+import type { VoiceProductionReadinessCheck } from "./productionReadiness";
+import type { VoiceHandoffDeliveryStore } from "./types";
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore, VoiceTraceSinkDeliveryStore } from "./trace";
+export type VoiceOpsRecoveryStatus = "fail" | "pass" | "warn";
+export type VoiceOpsRecoveryIssueCode = "voice.ops_recovery.audit_delivery_failed" | "voice.ops_recovery.audit_delivery_pending" | "voice.ops_recovery.handoff_failed" | "voice.ops_recovery.handoff_pending" | "voice.ops_recovery.latency_slo_failed" | "voice.ops_recovery.latency_slo_warn" | "voice.ops_recovery.provider_unresolved_failure" | "voice.ops_recovery.trace_delivery_failed" | "voice.ops_recovery.trace_delivery_pending";
+export type VoiceOpsRecoveryIssue = {
+    code: VoiceOpsRecoveryIssueCode;
+    detail?: string;
+    href?: string;
+    label: string;
+    severity: Exclude<VoiceOpsRecoveryStatus, "pass">;
+    value?: number | string;
+};
+export type VoiceOpsRecoveryProviderSummary<TProvider extends string = string> = {
+    healthy: number;
+    providers: VoiceProviderHealthSummary<TProvider>[];
+    recoveredFallbacks: number;
+    unresolvedFailures: number;
+};
+export type VoiceOpsRecoveryInterventionSummary = {
+    events: Array<{
+        action?: string;
+        at: number;
+        operatorId?: string;
+        sessionId: string;
+        traceId?: string;
+    }>;
+    total: number;
+};
+export type VoiceOpsRecoveryFailedSession = {
+    at: number;
+    error?: string;
+    operationsRecordHref?: string;
+    provider?: string;
+    sessionId: string;
+    traceId?: string;
+};
+export type VoiceOpsRecoveryReport<TProvider extends string = string> = {
+    auditDeliveries?: VoiceAuditSinkDeliveryQueueSummary;
+    checkedAt: number;
+    failedSessions: VoiceOpsRecoveryFailedSession[];
+    handoffDeliveries?: VoiceHandoffDeliveryQueueSummary;
+    interventions: VoiceOpsRecoveryInterventionSummary;
+    issues: VoiceOpsRecoveryIssue[];
+    latency?: VoiceLatencySLOGateReport;
+    providers: VoiceOpsRecoveryProviderSummary<TProvider>;
+    status: VoiceOpsRecoveryStatus;
+    traceDeliveries?: VoiceTraceSinkDeliveryQueueSummary;
+};
+export type VoiceOpsRecoveryLinks = {
+    auditDeliveries?: string;
+    handoffs?: string;
+    operationsRecords?: string | ((sessionId: string) => string);
+    providers?: string;
+    sessions?: string | ((sessionId: string) => string);
+    traceDeliveries?: string;
+    traces?: string | ((sessionId: string) => string);
+};
+export type VoiceOpsRecoveryReportOptions<TProvider extends string = string> = {
+    auditDeliveryDeadLetters?: VoiceAuditSinkDeliveryStore;
+    auditDeliveries?: VoiceAuditSinkDeliveryStore;
+    events?: StoredVoiceTraceEvent[];
+    handoffDeliveryDeadLetters?: VoiceHandoffDeliveryStore;
+    handoffDeliveries?: VoiceHandoffDeliveryStore;
+    latency?: VoiceLatencySLOGateOptions | false;
+    limit?: number;
+    links?: VoiceOpsRecoveryLinks;
+    providers?: readonly TProvider[];
+    traceDeliveryDeadLetters?: VoiceTraceSinkDeliveryStore;
+    traceDeliveries?: VoiceTraceSinkDeliveryStore;
+    traces?: VoiceTraceEventStore;
+};
+export type VoiceOpsRecoveryRoutesOptions<TProvider extends string = string> = VoiceOpsRecoveryReportOptions<TProvider> & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    markdownPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceOpsRecoveryReport<TProvider>) => string | Promise<string>;
+    title?: string;
+};
+export declare const buildVoiceOpsRecoveryReport: <TProvider extends string = string>(options?: VoiceOpsRecoveryReportOptions<TProvider>) => Promise<VoiceOpsRecoveryReport<TProvider>>;
+export declare const buildVoiceOpsRecoveryReadinessCheck: (report: VoiceOpsRecoveryReport, options?: {
+    href?: string;
+    label?: string;
+}) => VoiceProductionReadinessCheck;
+export declare const renderVoiceOpsRecoveryMarkdown: (report: VoiceOpsRecoveryReport, options?: {
+    title?: string;
+}) => string;
+export declare const renderVoiceOpsRecoveryHTML: (report: VoiceOpsRecoveryReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceOpsRecoveryRoutes: <TProvider extends string = string>(options?: VoiceOpsRecoveryRoutesOptions<TProvider>) => 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: VoiceOpsRecoveryReport<TProvider>;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/opsRuntime.d.ts

@@ -1,15 +1,15 @@
-import type { StoredVoiceIntegrationEvent, StoredVoiceOpsTask, VoiceIntegrationWebhookConfig, VoiceOpsSLABreachPolicy } from './ops';
-import type { VoiceIntegrationSinkWorkerOptions, VoiceIntegrationSinkWorkerResult, VoiceIntegrationEventQueueSummary, VoiceOpsTaskProcessorWorkerOptions, VoiceOpsTaskProcessorWorkerResult, VoiceOpsTaskQueueSummary, VoiceRedisTaskLeaseCoordinator, VoiceWebhookDeliveryWorkerOptions, VoiceWebhookDeliveryWorkerResult } from './queue';
-import type { VoiceCallDisposition, VoiceRuntimeOpsConfig, VoiceSessionHandle, VoiceSessionRecord } from './types';
-export type VoiceOpsRuntimeWebhookWorkerConfig<TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent> = Omit<VoiceWebhookDeliveryWorkerOptions<StoredVoiceIntegrationEvent>, 'events' | 'webhook'> & VoiceIntegrationWebhookConfig & {
+import type { StoredVoiceIntegrationEvent, StoredVoiceOpsTask, VoiceIntegrationWebhookConfig, VoiceOpsSLABreachPolicy } from "./ops";
+import type { VoiceIntegrationSinkWorkerOptions, VoiceIntegrationSinkWorkerResult, VoiceIntegrationEventQueueSummary, VoiceOpsTaskProcessorWorkerOptions, VoiceOpsTaskProcessorWorkerResult, VoiceOpsTaskQueueSummary, VoiceRedisTaskLeaseCoordinator, VoiceWebhookDeliveryWorkerOptions, VoiceWebhookDeliveryWorkerResult } from "./queue";
+import type { VoiceCallDisposition, VoiceRuntimeOpsConfig, VoiceSessionHandle, VoiceSessionRecord } from "./types";
+export type VoiceOpsRuntimeWebhookWorkerConfig<TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent> = Omit<VoiceWebhookDeliveryWorkerOptions<StoredVoiceIntegrationEvent>, "events" | "webhook"> & VoiceIntegrationWebhookConfig & {
     autoStart?: boolean;
     pollIntervalMs?: number;
 };
-export type VoiceOpsRuntimeSinkWorkerConfig<TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent> = Omit<VoiceIntegrationSinkWorkerOptions<StoredVoiceIntegrationEvent>, 'events' | 'sinks'> & {
+export type VoiceOpsRuntimeSinkWorkerConfig<TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent> = Omit<VoiceIntegrationSinkWorkerOptions<StoredVoiceIntegrationEvent>, "events" | "sinks"> & {
     autoStart?: boolean;
     pollIntervalMs?: number;
 };
-export type VoiceOpsRuntimeTaskWorkerConfig<TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask> = Omit<VoiceOpsTaskProcessorWorkerOptions<StoredVoiceOpsTask>, 'tasks' | 'worker'> & {
+export type VoiceOpsRuntimeTaskWorkerConfig<TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask> = Omit<VoiceOpsTaskProcessorWorkerOptions<StoredVoiceOpsTask>, "tasks" | "worker"> & {
     autoStart?: boolean;
     leaseMs?: number;
     leases: VoiceRedisTaskLeaseCoordinator;

package/dist/opsSinks.d.ts

@@ -1,4 +1,4 @@
-import type { StoredVoiceIntegrationEvent, VoiceExternalObjectMapStore, VoiceIntegrationDeliveryStatus, VoiceIntegrationEventType, VoiceIntegrationWebhookConfig } from './ops';
+import type { StoredVoiceIntegrationEvent, VoiceExternalObjectMapStore, VoiceIntegrationDeliveryStatus, VoiceIntegrationEventType, VoiceIntegrationWebhookConfig } from "./ops";
 export type VoiceIntegrationSinkDeliveryResult = {
     attempts: number;
     deliveredAt?: number;
@@ -21,7 +21,7 @@ export type VoiceIntegrationHTTPSinkOptions<TBody extends Record<string, unknown
     }) => TBody | Promise<TBody>;
     id: string;
     kind?: string;
-    method?: 'POST' | 'PUT' | 'PATCH';
+    method?: "POST" | "PUT" | "PATCH";
 };
 export type VoiceHelpdeskTicketSinkOptions = VoiceIntegrationHTTPSinkOptions & {
     project?: string;
@@ -29,7 +29,7 @@ export type VoiceHelpdeskTicketSinkOptions = VoiceIntegrationHTTPSinkOptions & {
 export type VoiceCRMActivitySinkOptions = VoiceIntegrationHTTPSinkOptions & {
     pipeline?: string;
 };
-export type VoiceZendeskTicketSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions, 'body' | 'url'> & {
+export type VoiceZendeskTicketSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions, "body" | "url"> & {
     accessToken: string;
     baseUrl?: string;
     buildTicket?: (input: {
@@ -46,7 +46,7 @@ export type VoiceZendeskTicketSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions
     };
     subdomain?: string;
 };
-export type VoiceZendeskTicketSyncSinkOptions = Omit<VoiceZendeskTicketSinkOptions, 'eventTypes'> & {
+export type VoiceZendeskTicketSyncSinkOptions = Omit<VoiceZendeskTicketSinkOptions, "eventTypes"> & {
     create?: Partial<VoiceZendeskTicketSinkOptions>;
     createId?: string;
     update?: Partial<VoiceZendeskTicketUpdateSinkOptions>;
@@ -55,7 +55,7 @@ export type VoiceZendeskTicketSyncSinkOptions = Omit<VoiceZendeskTicketSinkOptio
 type VoiceSinkValueResolver = string | ((input: {
     event: StoredVoiceIntegrationEvent;
 }) => Promise<string | undefined> | string | undefined);
-export type VoiceZendeskTicketUpdateSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions, 'body' | 'url'> & {
+export type VoiceZendeskTicketUpdateSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions, "body" | "url"> & {
     accessToken: string;
     baseUrl?: string;
     buildTicket?: (input: {
@@ -66,7 +66,7 @@ export type VoiceZendeskTicketUpdateSinkOptions = Omit<VoiceIntegrationHTTPSinkO
     subdomain?: string;
     ticketId?: VoiceSinkValueResolver;
 };
-export type VoiceHubSpotTaskSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions, 'body' | 'url'> & {
+export type VoiceHubSpotTaskSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions, "body" | "url"> & {
     accessToken: string;
     associations?: Array<Record<string, unknown>> | ((input: {
         event: StoredVoiceIntegrationEvent;
@@ -82,13 +82,13 @@ export type VoiceHubSpotTaskSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions,
         responseBody: unknown;
     }) => Promise<string | undefined> | string | undefined;
 };
-export type VoiceHubSpotTaskSyncSinkOptions = Omit<VoiceHubSpotTaskSinkOptions, 'eventTypes'> & {
+export type VoiceHubSpotTaskSyncSinkOptions = Omit<VoiceHubSpotTaskSinkOptions, "eventTypes"> & {
     create?: Partial<VoiceHubSpotTaskSinkOptions>;
     createId?: string;
     update?: Partial<VoiceHubSpotTaskUpdateSinkOptions>;
     updateId?: string;
 };
-export type VoiceHubSpotTaskUpdateSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions, 'body' | 'url'> & {
+export type VoiceHubSpotTaskUpdateSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions, "body" | "url"> & {
     accessToken: string;
     baseUrl?: string;
     buildProperties?: (input: {
@@ -97,9 +97,9 @@ export type VoiceHubSpotTaskUpdateSinkOptions = Omit<VoiceIntegrationHTTPSinkOpt
     externalObjects?: VoiceExternalObjectMapStore;
     taskId?: VoiceSinkValueResolver;
 };
-export type VoiceLinearIssueSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions, 'body' | 'url'> & {
+export type VoiceLinearIssueSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions, "body" | "url"> & {
     apiKey?: string;
-    authMode?: 'api-key' | 'bearer';
+    authMode?: "api-key" | "bearer";
     accessToken?: string;
     apiUrl?: string;
     buildIssueInput?: (input: {
@@ -112,15 +112,15 @@ export type VoiceLinearIssueSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions,
     }) => Promise<string | undefined> | string | undefined;
     teamId: string;
 };
-export type VoiceLinearIssueSyncSinkOptions = Omit<VoiceLinearIssueSinkOptions, 'eventTypes'> & {
+export type VoiceLinearIssueSyncSinkOptions = Omit<VoiceLinearIssueSinkOptions, "eventTypes"> & {
     create?: Partial<VoiceLinearIssueSinkOptions>;
     createId?: string;
     update?: Partial<VoiceLinearIssueUpdateSinkOptions>;
     updateId?: string;
 };
-export type VoiceLinearIssueUpdateSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions, 'body' | 'url'> & {
+export type VoiceLinearIssueUpdateSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions, "body" | "url"> & {
     apiKey?: string;
-    authMode?: 'api-key' | 'bearer';
+    authMode?: "api-key" | "bearer";
     accessToken?: string;
     apiUrl?: string;
     buildIssueInput?: (input: {

package/dist/opsStatus.d.ts

@@ -0,0 +1,76 @@
+import { type VoiceEvalLink, type VoiceEvalRoutesOptions } from "./evalRoutes";
+import { type VoiceDeliverySinkRoutesOptions } from "./deliverySinkRoutes";
+import { type VoiceQualityRoutesOptions } from "./qualityRoutes";
+import { type VoiceProviderFallbackRecoverySummary } from "./sessionReplay";
+import { type VoiceTraceEventStore } from "./trace";
+export type VoiceOpsStatus = "pass" | "fail";
+export type VoiceOpsStatusLink = VoiceEvalLink & {
+    description?: string;
+    statusHref?: string;
+};
+export type VoiceOpsStatusOptions<TProvider extends string = string> = {
+    deliverySinks?: false | VoiceDeliverySinkRoutesOptions;
+    evals?: false | Partial<VoiceEvalRoutesOptions>;
+    include?: {
+        deliverySinks?: boolean;
+        handoffs?: boolean;
+        providers?: boolean;
+        providerRecovery?: boolean;
+        quality?: boolean;
+        sessions?: boolean;
+        workflows?: boolean;
+    };
+    links?: VoiceOpsStatusLink[];
+    llmProviders?: readonly TProvider[];
+    preferFixtureWorkflows?: boolean;
+    quality?: false | Partial<VoiceQualityRoutesOptions>;
+    store: VoiceTraceEventStore;
+    sttProviders?: readonly string[];
+    ttsProviders?: readonly string[];
+};
+export type VoiceOpsStatusReport = {
+    checkedAt: number;
+    failed: number;
+    links: VoiceOpsStatusLink[];
+    passed: number;
+    status: VoiceOpsStatus;
+    surfaces: {
+        handoffs?: {
+            failed: number;
+            status: VoiceOpsStatus;
+            total: number;
+        };
+        deliverySinks?: {
+            auditTotal: number;
+            status: VoiceOpsStatus;
+            traceTotal: number;
+        };
+        providers?: {
+            degraded: number;
+            status: VoiceOpsStatus;
+            total: number;
+        };
+        providerRecovery?: VoiceProviderFallbackRecoverySummary;
+        quality?: {
+            status: VoiceOpsStatus;
+        };
+        sessions?: {
+            failed: number;
+            status: VoiceOpsStatus;
+            total: number;
+        };
+        workflows?: {
+            failed: number;
+            source: "fixtures" | "live";
+            status: VoiceOpsStatus;
+            total: number;
+        };
+    };
+    total: number;
+};
+export type VoiceOpsStatusRoutesOptions<TProvider extends string = string> = VoiceOpsStatusOptions<TProvider> & {
+    headers?: HeadersInit;
+    name?: string;
+    path?: string;
+};
+export declare const summarizeVoiceOpsStatus: <TProvider extends string = string>(options: VoiceOpsStatusOptions<TProvider>) => Promise<VoiceOpsStatusReport>;

package/dist/opsStatusRoutes.d.ts

@@ -0,0 +1,33 @@
+import { Elysia } from "elysia";
+import { type VoiceOpsStatusReport, type VoiceOpsStatusRoutesOptions } from "./opsStatus";
+export declare const renderVoiceOpsStatusHTML: (report: VoiceOpsStatusReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceOpsStatusRoutes: (options: VoiceOpsStatusRoutesOptions) => 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/opsWebhook.d.ts

@@ -1,6 +1,6 @@
-import { Elysia } from 'elysia';
-import type { StoredVoiceIntegrationEvent, VoiceIntegrationEventType } from './ops';
-import type { VoiceIntegrationHTTPSinkOptions, VoiceIntegrationSink } from './opsSinks';
+import { Elysia } from "elysia";
+import type { StoredVoiceIntegrationEvent, VoiceIntegrationEventType } from "./ops";
+import type { VoiceIntegrationHTTPSinkOptions, VoiceIntegrationSink } from "./opsSinks";
 type MaybePromise<T> = T | Promise<T>;
 export type VoiceOpsWebhookLinkResolver = string | ((input: {
     event: StoredVoiceIntegrationEvent;
@@ -32,9 +32,9 @@ export type VoiceOpsWebhookEnvelope = {
         task?: string;
     };
     schemaVersion: 1;
-    source: 'absolutejs-voice';
+    source: "absolutejs-voice";
 };
-export type VoiceOpsWebhookSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions<VoiceOpsWebhookEnvelope>, 'body'> & {
+export type VoiceOpsWebhookSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions<VoiceOpsWebhookEnvelope>, "body"> & {
     baseUrl?: string;
     eventHref?: VoiceOpsWebhookLinkResolver;
     replayHref?: VoiceOpsWebhookLinkResolver;
@@ -45,7 +45,7 @@ export type VoiceOpsWebhookVerificationResult = {
     ok: true;
 } | {
     ok: false;
-    reason: 'invalid-signature' | 'missing-secret' | 'missing-signature' | 'missing-timestamp' | 'stale-timestamp' | 'unsupported-algorithm';
+    reason: "invalid-signature" | "missing-secret" | "missing-signature" | "missing-timestamp" | "stale-timestamp" | "unsupported-algorithm";
 };
 export type VoiceOpsWebhookReceiverRoutesOptions = {
     onEnvelope?: (input: {

package/dist/otelExporter.d.ts

@@ -0,0 +1,83 @@
+import type { StoredVoiceTraceEvent } from "./trace";
+export type VoiceOTELAttribute = {
+    key: string;
+    value: {
+        boolValue: boolean;
+    };
+} | {
+    key: string;
+    value: {
+        doubleValue: number;
+    };
+} | {
+    key: string;
+    value: {
+        intValue: string;
+    };
+} | {
+    key: string;
+    value: {
+        stringValue: string;
+    };
+};
+export type VoiceOTELSpan = {
+    attributes: VoiceOTELAttribute[];
+    endTimeUnixNano: string;
+    kind: number;
+    name: string;
+    parentSpanId?: string;
+    spanId: string;
+    startTimeUnixNano: string;
+    status: {
+        code: number;
+    };
+    traceId: string;
+};
+export type VoiceOTELResourceSpans = {
+    resource: {
+        attributes: VoiceOTELAttribute[];
+    };
+    scopeSpans: ReadonlyArray<{
+        scope: {
+            name: string;
+            version?: string;
+        };
+        spans: VoiceOTELSpan[];
+    }>;
+};
+export type VoiceOTELPayload = {
+    resourceSpans: VoiceOTELResourceSpans[];
+};
+export type VoiceTurnLatencySpanStage = {
+    at: number;
+    stage: string;
+};
+export type VoiceTurnLatencySpanSet = {
+    endedAt: number;
+    scenarioId?: string;
+    sessionId: string;
+    stages: VoiceTurnLatencySpanStage[];
+    startedAt: number;
+    turnId: string;
+};
+export declare const buildOTELTraceId: (sessionId: string) => string;
+export declare const buildOTELSpanId: (sessionId: string, suffix: string) => string;
+export declare const aggregateVoiceTurnLatencySpans: (events: StoredVoiceTraceEvent[]) => VoiceTurnLatencySpanSet[];
+export type VoiceOTELExporterOptions = {
+    fetch?: typeof fetch;
+    headers?: Record<string, string>;
+    resourceAttributes?: Record<string, string>;
+    serviceName?: string;
+    url: string;
+};
+export declare const buildVoiceOTELPayload: (spanSets: VoiceTurnLatencySpanSet[], options?: {
+    resourceAttributes?: Record<string, string>;
+    serviceName?: string;
+}) => VoiceOTELPayload;
+export type VoiceOTELExporter = {
+    export: (events: StoredVoiceTraceEvent[]) => Promise<{
+        ok: boolean;
+        status?: number;
+    }>;
+};
+export declare const createVoiceOTELHTTPExporter: (options: VoiceOTELExporterOptions) => VoiceOTELExporter;

package/dist/outcomeContract.d.ts

@@ -0,0 +1,146 @@
+import { Elysia } from "elysia";
+import type { StoredVoiceHandoffDelivery, VoiceCallDisposition, VoiceHandoffAction, VoiceHandoffDeliveryStore, VoiceSessionRecord, VoiceSessionStore } from "./types";
+import type { StoredVoiceIntegrationEvent, StoredVoiceOpsTask, VoiceIntegrationEventType } from "./ops";
+import type { StoredVoiceCallReviewArtifact } from "./testing/review";
+export type VoiceOutcomeContractStatus = "pass" | "fail";
+export type VoiceOutcomeContractDefinition = {
+    description?: string;
+    expectedDisposition?: VoiceCallDisposition;
+    id: string;
+    label?: string;
+    minSessions?: number;
+    minTasks?: number;
+    requireHandoffActions?: VoiceHandoffAction[];
+    requireIntegrationEvents?: VoiceIntegrationEventType[];
+    requireReview?: boolean;
+    requireTask?: boolean;
+    scenarioId?: string;
+};
+export type VoiceOutcomeContractIssue = {
+    code: string;
+    message: string;
+};
+export type VoiceOutcomeContractReport = {
+    contractId: string;
+    description?: string;
+    issues: VoiceOutcomeContractIssue[];
+    label?: string;
+    matched: {
+        handoffs: number;
+        integrationEvents: number;
+        reviews: number;
+        sessions: number;
+        tasks: number;
+    };
+    operationsRecordHrefs: string[];
+    pass: boolean;
+    sessionIds: string[];
+};
+export type VoiceOutcomeContractSuiteReport = {
+    checkedAt: number;
+    contracts: VoiceOutcomeContractReport[];
+    failed: number;
+    passed: number;
+    status: VoiceOutcomeContractStatus;
+    total: number;
+};
+export type VoiceOutcomeContractAssertionInput = {
+    maxFailed?: number;
+    maxIssues?: number;
+    minContracts?: number;
+    minHandoffs?: number;
+    minIntegrationEvents?: number;
+    minOperationsRecordHrefs?: number;
+    minReviews?: number;
+    minSessions?: number;
+    minTasks?: number;
+    requiredContractIds?: string[];
+    requireOperationRecordHrefs?: boolean;
+};
+export type VoiceOutcomeContractAssertionReport = {
+    contractIds: string[];
+    failed: number;
+    handoffs: number;
+    integrationEvents: number;
+    issues: string[];
+    issueCount: number;
+    ok: boolean;
+    operationsRecordHrefs: number;
+    passed: number;
+    reviews: number;
+    sessions: number;
+    status: VoiceOutcomeContractStatus;
+    tasks: number;
+    total: number;
+};
+type ListStore<T> = {
+    list: () => Promise<T[]> | T[];
+};
+export type VoiceOutcomeContractOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
+    contracts: VoiceOutcomeContractDefinition[];
+    events?: StoredVoiceIntegrationEvent[] | ListStore<StoredVoiceIntegrationEvent>;
+    handoffs?: StoredVoiceHandoffDelivery[] | VoiceHandoffDeliveryStore;
+    operationsRecordHref?: false | string | ((sessionId: string) => string);
+    reviews?: StoredVoiceCallReviewArtifact[] | ListStore<StoredVoiceCallReviewArtifact>;
+    sessions?: TSession[] | VoiceSessionStore<TSession>;
+    tasks?: StoredVoiceOpsTask[] | ListStore<StoredVoiceOpsTask>;
+};
+export type VoiceOutcomeContractHTMLHandlerOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = VoiceOutcomeContractOptions<TSession> & {
+    headers?: HeadersInit;
+    render?: (report: VoiceOutcomeContractSuiteReport) => string | Promise<string>;
+    title?: string;
+};
+export type VoiceOutcomeContractRoutesOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = VoiceOutcomeContractHTMLHandlerOptions<TSession> & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export declare const runVoiceOutcomeContractSuite: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceOutcomeContractOptions<TSession>) => Promise<VoiceOutcomeContractSuiteReport>;
+export declare const evaluateVoiceOutcomeContractEvidence: (report: VoiceOutcomeContractSuiteReport, input?: VoiceOutcomeContractAssertionInput) => VoiceOutcomeContractAssertionReport;
+export declare const assertVoiceOutcomeContractEvidence: (report: VoiceOutcomeContractSuiteReport, input?: VoiceOutcomeContractAssertionInput) => VoiceOutcomeContractAssertionReport;
+export declare const renderVoiceOutcomeContractHTML: (report: VoiceOutcomeContractSuiteReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceOutcomeContractJSONHandler: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceOutcomeContractOptions<TSession>) => () => Promise<VoiceOutcomeContractSuiteReport>;
+export declare const createVoiceOutcomeContractHTMLHandler: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceOutcomeContractHTMLHandlerOptions<TSession>) => () => Promise<Response>;
+export declare const createVoiceOutcomeContractRoutes: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceOutcomeContractRoutesOptions<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: VoiceOutcomeContractSuiteReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export {};

package/dist/outcomeRecipes.d.ts

@@ -1,6 +1,6 @@
-import type { VoiceOpsTaskPriority } from './ops';
-import type { VoiceRuntimeOpsConfig, VoiceSessionRecord } from './types';
-export type VoiceOutcomeRecipeName = 'appointment-booking' | 'lead-qualification' | 'support-triage' | 'voicemail-callback' | 'warm-transfer';
+import type { VoiceOpsTaskPriority } from "./ops";
+import type { VoiceRuntimeOpsConfig, VoiceSessionRecord } from "./types";
+export type VoiceOutcomeRecipeName = "appointment-booking" | "cold-transfer" | "lead-qualification" | "support-triage" | "voicemail-callback" | "warm-transfer";
 export type VoiceOutcomeRecipeOptions = {
     assignee?: string;
     completedCreatesTask?: boolean;
@@ -11,7 +11,7 @@ export type VoiceOutcomeRecipeOptions = {
     queue?: string;
     target?: string;
 };
-export type VoiceOutcomeRecipe<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Pick<VoiceRuntimeOpsConfig<TContext, TSession, TResult>, 'createTaskFromReview' | 'resolveTaskPolicy' | 'taskAssignmentRules' | 'taskPolicies'> & {
+export type VoiceOutcomeRecipe<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Pick<VoiceRuntimeOpsConfig<TContext, TSession, TResult>, "createTaskFromReview" | "resolveTaskPolicy" | "taskAssignmentRules" | "taskPolicies"> & {
     description: string;
     name: VoiceOutcomeRecipeName;
 };