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

package/dist/telephonyOutcome.d.ts

@@ -0,0 +1,273 @@
+import { Elysia } from "elysia";
+import type { VoiceCallDisposition, VoiceRouteResult, VoiceSessionHandle, VoiceSessionRecord } from "./types";
+export type VoiceTelephonyOutcomeAction = "complete" | "escalate" | "ignore" | "no-answer" | "transfer" | "voicemail";
+export type VoiceTelephonyOutcomeProviderEvent = {
+    answeredBy?: string;
+    durationMs?: number;
+    from?: string;
+    metadata?: Record<string, unknown>;
+    provider?: string;
+    reason?: string;
+    sipCode?: number;
+    status?: string;
+    target?: string;
+    to?: string;
+};
+export type VoiceTelephonyOutcomeDecision = {
+    action: VoiceTelephonyOutcomeAction;
+    confidence: "high" | "low" | "medium";
+    disposition?: VoiceCallDisposition;
+    metadata?: Record<string, unknown>;
+    reason?: string;
+    source: "answered-by" | "duration" | "explicit-target" | "policy" | "sip" | "status";
+    target?: string;
+};
+export type VoiceTelephonyOutcomeStatusDecision = VoiceTelephonyOutcomeAction | (Omit<VoiceTelephonyOutcomeDecision, "confidence" | "source"> & {
+    confidence?: VoiceTelephonyOutcomeDecision["confidence"];
+    source?: VoiceTelephonyOutcomeDecision["source"];
+});
+export type VoiceTelephonyOutcomePolicy = {
+    completedStatuses?: string[];
+    escalationStatuses?: string[];
+    failedAsNoAnswer?: boolean;
+    failedStatuses?: string[];
+    includeProviderPayload?: boolean;
+    machineDetectionVoicemailValues?: string[];
+    metadata?: Record<string, unknown>;
+    minAnsweredDurationMs?: number;
+    noAnswerOnZeroDuration?: boolean;
+    noAnswerSipCodes?: number[];
+    noAnswerStatuses?: string[];
+    statusMap?: Record<string, VoiceTelephonyOutcomeStatusDecision>;
+    transferStatuses?: string[];
+    transferTarget?: string | ((event: VoiceTelephonyOutcomeProviderEvent) => string | undefined);
+    voicemailStatuses?: string[];
+};
+export type VoiceTelephonyOutcomeRouteResult<TResult = unknown> = VoiceRouteResult<TResult>;
+export type VoiceTelephonyWebhookProvider = "generic" | "plivo" | "telnyx" | "twilio";
+export type VoiceTelephonyWebhookParseInput = {
+    body: unknown;
+    headers: Headers;
+    provider: VoiceTelephonyWebhookProvider;
+    query: Record<string, unknown>;
+    request: Request;
+};
+export type VoiceTelephonyWebhookDecision<TResult = unknown> = {
+    applied: boolean;
+    decision: VoiceTelephonyOutcomeDecision;
+    duplicate?: boolean;
+    event: VoiceTelephonyOutcomeProviderEvent;
+    idempotencyKey?: string;
+    routeResult: VoiceTelephonyOutcomeRouteResult<TResult>;
+    sessionId?: string;
+};
+export type StoredVoiceTelephonyWebhookDecision<TResult = unknown> = VoiceTelephonyWebhookDecision<TResult> & {
+    createdAt: number;
+    updatedAt: number;
+};
+export type VoiceTelephonyWebhookNormalizationEvidenceDecision = {
+    action?: VoiceTelephonyOutcomeAction | string;
+    applied?: boolean;
+    decision?: {
+        action?: VoiceTelephonyOutcomeAction | string;
+        disposition?: VoiceCallDisposition | string;
+        source?: VoiceTelephonyOutcomeDecision["source"] | string;
+    };
+    disposition?: VoiceCallDisposition | string;
+    duplicate?: boolean;
+    campaignOutcome?: unknown;
+    event?: VoiceTelephonyOutcomeProviderEvent;
+    idempotencyKey?: string;
+    provider?: VoiceTelephonyWebhookProvider | string;
+    routeResult?: unknown;
+    sessionId?: string;
+    source?: VoiceTelephonyOutcomeDecision["source"] | string;
+};
+export type VoiceTelephonyWebhookVerificationEvidenceAttempt = {
+    decisions?: number;
+    provider?: VoiceTelephonyWebhookProvider | string;
+    rejected?: boolean;
+    replayRejected?: boolean;
+    sideEffects?: number;
+    status?: number;
+    verification?: VoiceTelephonyWebhookVerificationResult;
+};
+export type VoiceTelephonyWebhookNormalizationEvidenceInput = {
+    decisions?: VoiceTelephonyWebhookNormalizationEvidenceDecision[];
+    maxMissingSessionIds?: number;
+    minApplied?: number;
+    minDecisions?: number;
+    minDuplicateIdempotencyKeys?: number;
+    minDuplicates?: number;
+    maxDuplicateCampaignOutcomesApplied?: number;
+    maxRejectedVerificationSideEffects?: number;
+    minRejectedVerificationAttempts?: number;
+    minReplayRejectedVerificationAttempts?: number;
+    requiredActions?: VoiceTelephonyOutcomeAction[];
+    requiredDispositions?: VoiceCallDisposition[];
+    requiredDuplicateProviders?: VoiceTelephonyWebhookProvider[];
+    requiredProviders?: VoiceTelephonyWebhookProvider[];
+    requiredReplayRejectedVerificationProviders?: VoiceTelephonyWebhookProvider[];
+    requiredRejectedVerificationProviders?: VoiceTelephonyWebhookProvider[];
+    requireRouteResults?: boolean;
+    verificationAttempts?: VoiceTelephonyWebhookVerificationEvidenceAttempt[];
+};
+export type VoiceTelephonyWebhookNormalizationEvidenceReport = {
+    actions: VoiceTelephonyOutcomeAction[];
+    applied: number;
+    decisions: number;
+    dispositions: VoiceCallDisposition[];
+    duplicateCampaignOutcomesApplied: number;
+    duplicateIdempotencyKeys: number;
+    duplicateOutcomeReasons: string[];
+    duplicateProviders: VoiceTelephonyWebhookProvider[];
+    duplicates: number;
+    issues: string[];
+    missingSessionIds: number;
+    ok: boolean;
+    providers: VoiceTelephonyWebhookProvider[];
+    rejectedVerificationAttempts: number;
+    rejectedVerificationProviders: VoiceTelephonyWebhookProvider[];
+    rejectedVerificationSideEffects: number;
+    replayRejectedVerificationAttempts: number;
+    replayRejectedVerificationProviders: VoiceTelephonyWebhookProvider[];
+    routeResults: number;
+    sources: string[];
+    verificationAttempts: number;
+};
+export type VoiceTelephonyWebhookIdempotencyStore<TResult = unknown> = {
+    get: (key: string) => Promise<StoredVoiceTelephonyWebhookDecision<TResult> | undefined> | StoredVoiceTelephonyWebhookDecision<TResult> | undefined;
+    set: (key: string, decision: StoredVoiceTelephonyWebhookDecision<TResult>) => Promise<void> | void;
+};
+export type VoiceTelephonyWebhookVerificationResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: "invalid-signature" | "missing-secret" | "missing-signature" | "unsupported-provider";
+};
+export type VoiceTelephonyWebhookHandlerOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    apply?: boolean | ((input: VoiceTelephonyWebhookDecision<TResult>) => boolean);
+    context?: TContext;
+    getSessionHandle?: (input: {
+        context: TContext;
+        decision: VoiceTelephonyOutcomeDecision;
+        event: VoiceTelephonyOutcomeProviderEvent;
+        request: Request;
+        sessionId?: string;
+    }) => Promise<VoiceSessionHandle<TContext, TSession, TResult> | undefined> | VoiceSessionHandle<TContext, TSession, TResult> | undefined;
+    idempotency?: {
+        enabled?: boolean;
+        key?: (input: {
+            body: unknown;
+            event: VoiceTelephonyOutcomeProviderEvent;
+            provider: VoiceTelephonyWebhookProvider;
+            query: Record<string, unknown>;
+            request: Request;
+            sessionId?: string;
+        }) => Promise<string | undefined> | string | undefined;
+        store?: VoiceTelephonyWebhookIdempotencyStore<TResult>;
+    };
+    onDecision?: (input: VoiceTelephonyWebhookDecision<TResult> & {
+        context: TContext;
+        request: Request;
+    }) => Promise<void> | void;
+    parse?: (input: VoiceTelephonyWebhookParseInput) => Promise<VoiceTelephonyOutcomeProviderEvent> | VoiceTelephonyOutcomeProviderEvent;
+    policy?: VoiceTelephonyOutcomePolicy;
+    provider?: VoiceTelephonyWebhookProvider;
+    requireVerification?: boolean;
+    resolveSessionId?: (input: {
+        body: unknown;
+        event: VoiceTelephonyOutcomeProviderEvent;
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<string | undefined> | string | undefined;
+    result?: TResult | ((input: {
+        decision: VoiceTelephonyOutcomeDecision;
+        event: VoiceTelephonyOutcomeProviderEvent;
+        sessionId?: string;
+    }) => Promise<TResult | undefined> | TResult | undefined);
+    signingSecret?: string;
+    verificationUrl?: string | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => string);
+    verify?: (input: {
+        body: unknown;
+        headers: Headers;
+        provider: VoiceTelephonyWebhookProvider;
+        query: Record<string, unknown>;
+        rawBody: string;
+        request: Request;
+    }) => Promise<VoiceTelephonyWebhookVerificationResult> | VoiceTelephonyWebhookVerificationResult;
+};
+export type VoiceTelephonyWebhookRoutesOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = VoiceTelephonyWebhookHandlerOptions<TContext, TSession, TResult> & {
+    name?: string;
+    path?: string;
+};
+export declare class VoiceTelephonyWebhookVerificationError extends Error {
+    result: VoiceTelephonyWebhookVerificationResult;
+    constructor(result: VoiceTelephonyWebhookVerificationResult);
+}
+export declare const createMemoryVoiceTelephonyWebhookIdempotencyStore: <TResult = unknown>() => VoiceTelephonyWebhookIdempotencyStore<TResult>;
+export declare const evaluateVoiceTelephonyWebhookNormalizationEvidence: (input?: VoiceTelephonyWebhookNormalizationEvidenceInput) => VoiceTelephonyWebhookNormalizationEvidenceReport;
+export declare const assertVoiceTelephonyWebhookNormalizationEvidence: (input?: VoiceTelephonyWebhookNormalizationEvidenceInput) => VoiceTelephonyWebhookNormalizationEvidenceReport;
+export declare const createVoiceTelephonyOutcomePolicy: (policy?: VoiceTelephonyOutcomePolicy) => Required<Pick<VoiceTelephonyOutcomePolicy, "completedStatuses" | "escalationStatuses" | "failedAsNoAnswer" | "failedStatuses" | "includeProviderPayload" | "machineDetectionVoicemailValues" | "noAnswerOnZeroDuration" | "noAnswerSipCodes" | "noAnswerStatuses" | "transferStatuses" | "voicemailStatuses">> & VoiceTelephonyOutcomePolicy;
+export declare const resolveVoiceTelephonyOutcome: (event: VoiceTelephonyOutcomeProviderEvent, policyInput?: VoiceTelephonyOutcomePolicy) => VoiceTelephonyOutcomeDecision;
+export declare const voiceTelephonyOutcomeToRouteResult: <TResult = unknown>(decision: VoiceTelephonyOutcomeDecision, result?: TResult) => VoiceTelephonyOutcomeRouteResult<TResult>;
+export declare const applyVoiceTelephonyOutcome: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(api: VoiceSessionHandle<TContext, TSession, TResult>, decision: VoiceTelephonyOutcomeDecision, result?: TResult) => Promise<void>;
+export declare const signVoiceTwilioWebhook: (input: {
+    authToken: string;
+    body?: unknown;
+    url: string;
+}) => Promise<string>;
+export declare const verifyVoiceTwilioWebhookSignature: (input: {
+    authToken?: string;
+    body?: unknown;
+    headers: Headers;
+    url: string;
+}) => Promise<VoiceTelephonyWebhookVerificationResult>;
+export declare const parseVoiceTelephonyWebhookEvent: (input: VoiceTelephonyWebhookParseInput) => VoiceTelephonyOutcomeProviderEvent;
+export declare const createVoiceTelephonyWebhookHandler: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options?: VoiceTelephonyWebhookHandlerOptions<TContext, TSession, TResult>) => (input: {
+    query?: Record<string, unknown>;
+    request: Request;
+}) => Promise<VoiceTelephonyWebhookDecision<TResult>>;
+export declare const createVoiceTelephonyWebhookRoutes: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options?: VoiceTelephonyWebhookRoutesOptions<TContext, TSession, TResult>) => 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: Response | VoiceTelephonyWebhookDecision<TResult>;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/testing/accuracy.d.ts

@@ -1,4 +1,4 @@
-import type { Transcript } from '../types';
+import type { Transcript } from "../types";
 export type VoiceTranscriptAccuracy = {
     actualText: string;
     charDistance: number;

package/dist/testing/benchmark.d.ts

@@ -1,6 +1,6 @@
-import type { STTAdapter, STTAdapterOpenOptions } from '../types';
-import { type VoiceSTTAdapterHarnessOptions, type VoiceSTTAdapterHarnessResult } from './stt';
-import type { VoiceTestFixture } from './fixtures';
+import type { STTAdapter, STTAdapterOpenOptions } from "../types";
+import { type VoiceSTTAdapterHarnessOptions, type VoiceSTTAdapterHarnessResult } from "./stt";
+import type { VoiceTestFixture } from "./fixtures";
 export type VoiceExpectedTermAccuracy = {
     allMatched: boolean;
     expectedTerms: string[];
@@ -8,7 +8,7 @@ export type VoiceExpectedTermAccuracy = {
     missingTerms: string[];
     recall: number;
 };
-export type VoiceSTTFixtureEnvironment = 'accent' | 'accent-noisy' | 'clean' | 'code-switch' | 'jargon' | 'multilingual' | 'multi-speaker' | 'noisy' | 'telephony' | 'other';
+export type VoiceSTTFixtureEnvironment = "accent" | "accent-noisy" | "clean" | "code-switch" | "jargon" | "multilingual" | "multi-speaker" | "noisy" | "telephony" | "other";
 export type VoiceSpeakerTurnAccuracy = {
     available: boolean;
     actualTurnCount: number;
@@ -18,9 +18,9 @@ export type VoiceSpeakerTurnAccuracy = {
     postClustered?: boolean;
 };
 export type VoiceSTTBenchmarkFixtureResult = {
-    accuracy: VoiceSTTAdapterHarnessResult['accuracy'];
+    accuracy: VoiceSTTAdapterHarnessResult["accuracy"];
     closeCount: number;
-    difficulty?: VoiceTestFixture['difficulty'];
+    difficulty?: VoiceTestFixture["difficulty"];
     elapsedMs: number;
     endOfTurnCount: number;
     errorCount: number;
@@ -141,14 +141,14 @@ export type VoiceSTTBenchmarkAcceptanceResult = {
     score: number;
 };
 export type VoiceSTTBenchmarkOptions = VoiceSTTAdapterHarnessOptions & {
-    fixtureOptions?: Record<string, Omit<VoiceSTTAdapterHarnessOptions, 'fixtureOptions' | 'openOptions'>>;
+    fixtureOptions?: Record<string, Omit<VoiceSTTAdapterHarnessOptions, "fixtureOptions" | "openOptions">>;
     openOptions?: Partial<STTAdapterOpenOptions> | ((fixture: VoiceTestFixture) => Partial<STTAdapterOpenOptions> | undefined);
 };
 export declare const resolveFixtureEnvironment: (fixture: Pick<VoiceTestFixture, "language" | "tags">) => VoiceSTTFixtureEnvironment;
 export declare const summarizeSTTBenchmark: (adapterId: string, fixtures: VoiceSTTBenchmarkFixtureResult[]) => VoiceSTTBenchmarkSummary;
 export declare const evaluateSTTBenchmarkAcceptance: (report: VoiceSTTBenchmarkReport, thresholds?: VoiceSTTBenchmarkAcceptanceThresholds) => VoiceSTTBenchmarkAcceptanceResult;
 export declare const compareSTTBenchmarks: (reports: VoiceSTTBenchmarkReport[]) => VoiceSTTBenchmarkComparison;
-export declare const runSTTAdapterBenchmark: ({ adapter, adapterId, fixtures, options }: {
+export declare const runSTTAdapterBenchmark: ({ adapter, adapterId, fixtures, options, }: {
     adapter: STTAdapter;
     adapterId: string;
     fixtures: VoiceTestFixture[];
@@ -158,7 +158,7 @@ export declare const summarizeSTTBenchmarkSeries: (input: {
     adapterId: string;
     reports: VoiceSTTBenchmarkReport[];
 }) => VoiceSTTBenchmarkSeriesReport;
-export declare const runSTTAdapterBenchmarkSeries: ({ adapter, adapterId, fixtures, options, runs }: {
+export declare const runSTTAdapterBenchmarkSeries: ({ adapter, adapterId, fixtures, options, runs, }: {
     adapter: STTAdapter;
     adapterId: string;
     fixtures: VoiceTestFixture[];

package/dist/testing/corrected.d.ts

@@ -1,8 +1,8 @@
-import type { VoiceLexiconEntry, VoicePhraseHint, VoiceTurnCorrectionHandler } from '../types';
-import { type VoiceExpectedTermAccuracy, type VoiceSTTBenchmarkReport } from './benchmark';
-import type { VoiceSessionBenchmarkReport } from './sessionBenchmark';
-import type { VoiceTestFixture } from './fixtures';
-export type VoiceCorrectionHintProfile = 'generic' | 'benchmark-seeded';
+import type { VoiceLexiconEntry, VoicePhraseHint, VoiceTurnCorrectionHandler } from "../types";
+import { type VoiceExpectedTermAccuracy, type VoiceSTTBenchmarkReport } from "./benchmark";
+import type { VoiceSessionBenchmarkReport } from "./sessionBenchmark";
+import type { VoiceTestFixture } from "./fixtures";
+export type VoiceCorrectionHintProfile = "generic" | "benchmark-seeded";
 type VoiceCorrectionAuditSlice<TReport> = {
     fixtureIds: string[];
     raw: TReport;

package/dist/testing/duplex.d.ts

@@ -1,11 +1,11 @@
-import type { VoiceBargeInOptions } from '../types';
+import type { VoiceBargeInOptions } from "../types";
 export type VoiceDuplexBenchmarkScenario = {
     expectedInterruptCount: number;
     id: string;
     initialPartial?: string;
     interruptDelayMs?: number;
     level?: number;
-    mode: 'audio-send' | 'input-level' | 'partial';
+    mode: "audio-send" | "input-level" | "partial";
     partial?: string;
     title: string;
 };
@@ -15,7 +15,7 @@ export type VoiceDuplexBenchmarkScenarioResult = {
     expectedInterruptCount: number;
     fixtureId: string;
     interruptLatencyMs?: number;
-    mode: VoiceDuplexBenchmarkScenario['mode'];
+    mode: VoiceDuplexBenchmarkScenario["mode"];
     passes: boolean;
     title: string;
 };

package/dist/testing/fixtures.d.ts

@@ -1,4 +1,4 @@
-import type { AudioFormat, VoiceExpectedSpeakerTurn } from '../types';
+import type { AudioFormat, VoiceExpectedSpeakerTurn } from "../types";
 export type VoiceTestFixtureManifestEntry = {
     id: string;
     title: string;
@@ -9,12 +9,12 @@ export type VoiceTestFixtureManifestEntry = {
     expectedTurnTexts?: string[];
     chunkDurationMs?: number;
     language?: string;
-    difficulty?: 'clean' | 'noisy' | 'challenging';
+    difficulty?: "clean" | "noisy" | "challenging";
     tags?: string[];
     tailPaddingMs?: number;
     format?: Partial<AudioFormat>;
 };
-export type VoiceTestFixture = Omit<VoiceTestFixtureManifestEntry, 'audioPath'> & {
+export type VoiceTestFixture = Omit<VoiceTestFixtureManifestEntry, "audioPath"> & {
     audio: Uint8Array;
     audioPath: string;
     format: AudioFormat;

package/dist/testing/index.d.ts

@@ -1,13 +1,13 @@
-export * from './accuracy';
-export * from './benchmark';
-export * from './corrected';
-export * from './duplex';
-export * from './fixtures';
-export * from './ioProviderSimulator';
-export * from './providerSimulator';
-export * from './resilience';
-export * from './review';
-export * from './sessionBenchmark';
-export * from './stt';
-export * from './telephony';
-export * from './tts';
+export * from "./accuracy";
+export * from "./benchmark";
+export * from "./corrected";
+export * from "./duplex";
+export * from "./fixtures";
+export * from "./ioProviderSimulator";
+export * from "./providerSimulator";
+export * from "./resilience";
+export * from "./review";
+export * from "./sessionBenchmark";
+export * from "./stt";
+export * from "./telephony";
+export * from "./tts";