@absolutejs/voice 0.0.22-beta.6 → 0.0.22-beta.600

package/dist/core/dncRegistry.d.ts

@@ -0,0 +1,38 @@
+export type VoiceDNCSource = "internal" | "regulatory" | "imported";
+export type VoiceDNCEntry = {
+    phoneNumber: string;
+    source: VoiceDNCSource;
+    reason?: string;
+    addedAt: number;
+    expiresAt?: number;
+};
+export type VoiceDNCLookupVerdict = {
+    blocked: boolean;
+    entry: VoiceDNCEntry | null;
+    matchedFromExternal?: boolean;
+};
+export type VoiceDNCExternalLookup = (phoneNumber: string) => Promise<VoiceDNCEntry | null> | VoiceDNCEntry | null;
+export type CreateVoiceDNCRegistryOptions = {
+    entries?: VoiceDNCEntry[];
+    externalLookup?: VoiceDNCExternalLookup;
+    now?: () => number;
+};
+export declare const createVoiceDNCRegistry: (options?: CreateVoiceDNCRegistryOptions) => {
+    block: (phoneNumber: string, options?: {
+        source?: VoiceDNCSource;
+        reason?: string;
+        expiresAt?: number;
+    }) => VoiceDNCEntry;
+    unblock: (phoneNumber: string) => boolean;
+    check(phoneNumber: string): Promise<VoiceDNCLookupVerdict>;
+    checkSync(phoneNumber: string): VoiceDNCLookupVerdict;
+    has(phoneNumber: string): boolean;
+    snapshot(): VoiceDNCEntry[];
+};
+export type VoiceDNCRegistry = ReturnType<typeof createVoiceDNCRegistry>;
+export declare const importVoiceDNCFromCSV: (csv: string, options?: {
+    phoneColumn?: string;
+    reasonColumn?: string;
+    source?: VoiceDNCSource;
+    now?: () => number;
+}) => VoiceDNCEntry[];

package/dist/core/dtmfCollector.d.ts

@@ -0,0 +1,37 @@
+export type VoiceDTMFDigit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "*" | "#";
+export declare const VOICE_DTMF_DIGITS: readonly VoiceDTMFDigit[];
+export type VoiceDTMFCollectorState = {
+    status: "collecting";
+    digits: string;
+} | {
+    status: "completed";
+    digits: string;
+    reason: "length" | "terminator";
+} | {
+    status: "cancelled";
+    digits: string;
+} | {
+    status: "rejected";
+    digits: string;
+    reason: "invalid" | "timeout" | "too-short";
+};
+export type CreateVoiceDTMFCollectorOptions = {
+    prompt: string;
+    minLength?: number;
+    maxLength?: number;
+    terminator?: VoiceDTMFDigit | null;
+    timeoutMs?: number;
+    interDigitTimeoutMs?: number;
+    validator?: (digits: string) => boolean | string;
+    now?: () => number;
+};
+export declare const collectVoiceDTMFInput: (options: CreateVoiceDTMFCollectorOptions) => {
+    prompt: string;
+    cancel(): VoiceDTMFCollectorState;
+    feed(digit: string, at?: number): VoiceDTMFCollectorState;
+    getState: () => VoiceDTMFCollectorState;
+    subscribe(listener: (state: VoiceDTMFCollectorState) => void): () => void;
+    tick(at?: number): VoiceDTMFCollectorState;
+};
+export type VoiceDTMFCollector = ReturnType<typeof collectVoiceDTMFInput>;
+export declare const validateVoiceDTMFLuhn: (digits: string) => boolean;

package/dist/core/evalRoutes.d.ts

@@ -0,0 +1,219 @@
+import { Elysia } from "elysia";
+import { type VoiceQualityReport, type VoiceQualityThresholds } from "./qualityRoutes";
+import { summarizeVoiceTrace, type StoredVoiceTraceEvent, type VoiceTraceEventStore } from "./trace";
+export type VoiceEvalStatus = "pass" | "fail";
+export type VoiceEvalSessionReport = {
+    endedAt?: number;
+    eventCount: number;
+    operationsRecordHref?: string;
+    quality: VoiceQualityReport;
+    scenarioId?: string;
+    sessionId: string;
+    startedAt?: number;
+    status: VoiceEvalStatus;
+    summary: ReturnType<typeof summarizeVoiceTrace>;
+};
+export type VoiceEvalTrendBucket = {
+    endedAt: number;
+    failed: number;
+    key: string;
+    passed: number;
+    total: number;
+};
+export type VoiceEvalReport = {
+    checkedAt: number;
+    failed: number;
+    passed: number;
+    sessions: VoiceEvalSessionReport[];
+    status: VoiceEvalStatus;
+    total: number;
+    trend: VoiceEvalTrendBucket[];
+};
+export type VoiceEvalBaselineSummary = {
+    failed: number;
+    failedSessionIds: string[];
+    passRate: number;
+    passed: number;
+    total: number;
+};
+export type VoiceEvalBaselineComparison = {
+    baseline: VoiceEvalBaselineSummary;
+    checkedAt: number;
+    current: VoiceEvalBaselineSummary;
+    deltas: {
+        failed: number;
+        passRate: number;
+        passed: number;
+        total: number;
+    };
+    newFailedSessionIds: string[];
+    recoveredSessionIds: string[];
+    reasons: string[];
+    status: VoiceEvalStatus;
+};
+export type VoiceEvalBaselineComparisonOptions = {
+    failOnNewFailedSessions?: boolean;
+    maxFailedDelta?: number;
+    maxPassRateDrop?: number;
+};
+export type VoiceEvalBaselineStore = {
+    get: () => Promise<VoiceEvalReport | undefined>;
+    set: (report: VoiceEvalReport) => Promise<void>;
+};
+export type VoiceScenarioEvalDefinition = {
+    description?: string;
+    forbiddenHandoffActions?: string[];
+    forbiddenLifecycleTypes?: string[];
+    id: string;
+    label?: string;
+    maxProviderErrors?: number;
+    maxSessionErrors?: number;
+    minSessions?: number;
+    minTurns?: number;
+    requiredAssistantIncludes?: string[];
+    requiredDisposition?: string;
+    requiredHandoffActions?: string[];
+    requiredLifecycleTypes?: string[];
+    requiredPayloadPaths?: string[];
+    requiredTranscriptIncludes?: string[];
+    requiredWorkflowContracts?: string[];
+    scenarioId?: string;
+};
+export type VoiceScenarioEvalSessionResult = {
+    eventCount: number;
+    issues: string[];
+    operationsRecordHref?: string;
+    sessionId: string;
+    status: VoiceEvalStatus;
+};
+export type VoiceScenarioEvalResult = {
+    description?: string;
+    failed: number;
+    id: string;
+    issues: string[];
+    label: string;
+    matchedSessions: number;
+    passed: number;
+    sessions: VoiceScenarioEvalSessionResult[];
+    status: VoiceEvalStatus;
+};
+export type VoiceScenarioEvalReport = {
+    checkedAt: number;
+    failed: number;
+    passed: number;
+    scenarios: VoiceScenarioEvalResult[];
+    status: VoiceEvalStatus;
+    total: number;
+};
+export type VoiceScenarioFixture = {
+    description?: string;
+    events: StoredVoiceTraceEvent[];
+    id: string;
+    label?: string;
+};
+export type VoiceScenarioFixtureStore = {
+    list: () => Promise<VoiceScenarioFixture[]>;
+};
+export type VoiceScenarioFixtureEvalResult = {
+    description?: string;
+    fixtureId: string;
+    label: string;
+    report: VoiceScenarioEvalReport;
+    status: VoiceEvalStatus;
+};
+export type VoiceScenarioFixtureEvalReport = {
+    checkedAt: number;
+    failed: number;
+    fixtures: VoiceScenarioFixtureEvalResult[];
+    passed: number;
+    status: VoiceEvalStatus;
+    total: number;
+};
+export type VoiceEvalLink = {
+    href: string;
+    label: string;
+};
+export type VoiceEvalRoutesOptions = {
+    baseline?: VoiceEvalReport | (() => Promise<VoiceEvalReport | undefined>);
+    baselineComparison?: VoiceEvalBaselineComparisonOptions;
+    baselineStore?: VoiceEvalBaselineStore;
+    events?: StoredVoiceTraceEvent[];
+    fixtures?: VoiceScenarioFixture[];
+    fixtureStore?: VoiceScenarioFixtureStore;
+    headers?: HeadersInit;
+    links?: VoiceEvalLink[];
+    limit?: number;
+    name?: string;
+    operationsRecordHref?: false | string | ((sessionId: string) => string);
+    path?: string;
+    scenarios?: VoiceScenarioEvalDefinition[];
+    store?: VoiceTraceEventStore;
+    thresholds?: VoiceQualityThresholds;
+    title?: string;
+};
+export declare const runVoiceSessionEvals: (options?: {
+    events?: StoredVoiceTraceEvent[];
+    limit?: number;
+    operationsRecordHref?: false | string | ((sessionId: string) => string);
+    store?: VoiceTraceEventStore;
+    thresholds?: VoiceQualityThresholds;
+}) => Promise<VoiceEvalReport>;
+export declare const runVoiceScenarioEvals: (options?: {
+    events?: StoredVoiceTraceEvent[];
+    operationsRecordHref?: false | string | ((sessionId: string) => string);
+    scenarios?: VoiceScenarioEvalDefinition[];
+    store?: VoiceTraceEventStore;
+}) => Promise<VoiceScenarioEvalReport>;
+export declare const runVoiceScenarioFixtureEvals: (options?: {
+    fixtures?: VoiceScenarioFixture[];
+    fixtureStore?: VoiceScenarioFixtureStore;
+    operationsRecordHref?: false | string | ((sessionId: string) => string);
+    scenarios?: VoiceScenarioEvalDefinition[];
+}) => Promise<VoiceScenarioFixtureEvalReport>;
+export declare const compareVoiceEvalBaseline: (currentReport: VoiceEvalReport, baselineReport: VoiceEvalReport, options?: VoiceEvalBaselineComparisonOptions) => VoiceEvalBaselineComparison;
+export declare const createVoiceFileEvalBaselineStore: (filePath: string) => VoiceEvalBaselineStore;
+export declare const createVoiceFileScenarioFixtureStore: (filePath: string) => VoiceScenarioFixtureStore;
+export declare const createVoiceEvalRoutes: (options: VoiceEvalRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const renderVoiceEvalBaselineHTML: (comparison: VoiceEvalBaselineComparison, options?: {
+    links?: VoiceEvalLink[];
+    title?: string;
+}) => string;
+export declare const renderVoiceEvalHTML: (report: VoiceEvalReport, options?: {
+    links?: VoiceEvalLink[];
+    title?: string;
+}) => string;
+export declare const renderVoiceScenarioEvalHTML: (report: VoiceScenarioEvalReport, options?: {
+    links?: VoiceEvalLink[];
+    title?: string;
+}) => string;
+export declare const renderVoiceScenarioFixtureEvalHTML: (report: VoiceScenarioFixtureEvalReport, options?: {
+    links?: VoiceEvalLink[];
+    title?: string;
+}) => string;

package/dist/{fileStore.d.ts → core/fileStore.d.ts}

@@ -1,15 +1,24 @@
-import { type VoiceAssistantMemoryRecord, type VoiceAssistantMemoryStore } from './assistantMemory';
-import { type StoredVoiceTraceEvent, type VoiceTraceSinkDeliveryRecord, type VoiceTraceSinkDeliveryStore, type VoiceTraceEventStore } from './trace';
-import type { StoredVoiceIntegrationEvent, StoredVoiceExternalObjectMap, StoredVoiceOpsTask, VoiceExternalObjectMap, VoiceExternalObjectMapStore, VoiceIntegrationEvent, VoiceIntegrationEventStore, VoiceOpsTask, VoiceOpsTaskStore } from './ops';
-import type { StoredVoiceCallReviewArtifact, VoiceCallReviewArtifact, VoiceCallReviewStore } from './testing/review';
-import type { VoiceSessionRecord, VoiceSessionStore } from './types';
+import { type StoredVoiceAuditEvent, type VoiceAuditEventStore } from "./audit";
+import type { VoiceAuditSinkDeliveryRecord, VoiceAuditSinkDeliveryStore } from "./auditSinks";
+import type { VoiceCampaignStore } from "./campaign";
+import { type VoiceAssistantMemoryRecord, type VoiceAssistantMemoryStore } from "./assistantMemory";
+import type { StoredVoiceIncidentBundleArtifact, VoiceIncidentBundleStore } from "./incidentBundle";
+import { type StoredVoiceTraceEvent, type VoiceTraceSinkDeliveryRecord, type VoiceTraceSinkDeliveryStore, type VoiceTraceEventStore } from "./trace";
+import type { StoredVoiceIntegrationEvent, StoredVoiceExternalObjectMap, StoredVoiceOpsTask, VoiceExternalObjectMap, VoiceExternalObjectMapStore, VoiceIntegrationEvent, VoiceIntegrationEventStore, VoiceOpsTask, VoiceOpsTaskStore } from "./ops";
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewArtifact, VoiceCallReviewStore } from "../testing/review";
+import type { VoiceSessionRecord, VoiceSessionStore } from "./types";
+import type { VoiceRecordingStore } from "./recordingStore";
 export type VoiceFileStoreOptions = {
     directory: string;
     pretty?: boolean;
 };
-export type VoiceFileRuntimeStorage<TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord, TMemory extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord> = {
+export type VoiceFileRuntimeStorage<TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord, TAudit extends StoredVoiceAuditEvent = StoredVoiceAuditEvent, TAuditDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord, TIncident extends StoredVoiceIncidentBundleArtifact = StoredVoiceIncidentBundleArtifact, TMemory extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord> = {
+    audit: VoiceAuditEventStore<TAudit>;
+    auditDeliveries: VoiceAuditSinkDeliveryStore<TAuditDelivery>;
+    campaigns: VoiceCampaignStore;
     events: VoiceIntegrationEventStore<TEvent>;
     externalObjects: VoiceExternalObjectMapStore<TMapping>;
+    incidentBundles: VoiceIncidentBundleStore<TIncident>;
     memories: VoiceAssistantMemoryStore<TMemory>;
     reviews: VoiceCallReviewStore<TReview>;
     session: VoiceSessionStore<TSession>;
@@ -17,24 +26,29 @@ export type VoiceFileRuntimeStorage<TSession extends VoiceSessionRecord = VoiceS
     traceDeliveries: VoiceTraceSinkDeliveryStore<TTraceDelivery>;
     traces: VoiceTraceEventStore<TTrace>;
 };
-export declare const createVoiceFileSessionStore: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceFileStoreOptions) => VoiceSessionStore<TSession>;
-export declare const createVoiceFileReviewStore: <TArtifact extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact>(options: VoiceFileStoreOptions) => VoiceCallReviewStore<TArtifact>;
-export declare const createVoiceFileTaskStore: <TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask>(options: VoiceFileStoreOptions) => VoiceOpsTaskStore<TTask>;
-export declare const createVoiceFileIntegrationEventStore: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(options: VoiceFileStoreOptions) => VoiceIntegrationEventStore<TEvent>;
-export declare const createVoiceFileExternalObjectMapStore: <TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap>(options: VoiceFileStoreOptions) => VoiceExternalObjectMapStore<TMapping>;
-export declare const createVoiceFileTraceEventStore: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(options: VoiceFileStoreOptions) => VoiceTraceEventStore<TEvent>;
-export declare const createVoiceFileTraceSinkDeliveryStore: <TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(options: VoiceFileStoreOptions) => VoiceTraceSinkDeliveryStore<TDelivery>;
-export declare const createVoiceFileAssistantMemoryStore: <TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord>(options: VoiceFileStoreOptions) => VoiceAssistantMemoryStore<TRecord>;
-export declare const createVoiceFileRuntimeStorage: <TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord, TMemory extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord>(options: VoiceFileStoreOptions) => VoiceFileRuntimeStorage<TSession, TReview, TTask, TEvent, TMapping, TTrace, TTraceDelivery, TMemory>;
 export declare const createStoredVoiceCallReviewArtifact: <TArtifact extends VoiceCallReviewArtifact = VoiceCallReviewArtifact>(id: string, artifact: TArtifact) => TArtifact & {
     id: string;
 };
-export declare const createStoredVoiceOpsTask: <TTask extends Omit<VoiceOpsTask, "id"> = Omit<VoiceOpsTask, "id">>(id: string, task: TTask) => TTask & {
+export declare const createStoredVoiceExternalObjectMap: <TMapping extends Omit<VoiceExternalObjectMap, "id" | "createdAt" | "updatedAt"> = Omit<VoiceExternalObjectMap, "id" | "createdAt" | "updatedAt">>(mapping: TMapping & {
+    at?: number;
+}) => VoiceExternalObjectMap;
+export declare const createStoredVoiceIntegrationEvent: <TEvent extends Omit<VoiceIntegrationEvent, "id"> = Omit<VoiceIntegrationEvent, "id">>(id: string, event: TEvent) => TEvent & {
     id: string;
 };
-export declare const createStoredVoiceIntegrationEvent: <TEvent extends Omit<VoiceIntegrationEvent, "id"> = Omit<VoiceIntegrationEvent, "id">>(id: string, event: TEvent) => TEvent & {
+export declare const createStoredVoiceOpsTask: <TTask extends Omit<VoiceOpsTask, "id"> = Omit<VoiceOpsTask, "id">>(id: string, task: TTask) => TTask & {
     id: string;
 };
-export declare const createStoredVoiceExternalObjectMap: <TMapping extends Omit<VoiceExternalObjectMap, "id" | "createdAt" | "updatedAt"> = Omit<VoiceExternalObjectMap, "id" | "createdAt" | "updatedAt">>(mapping: TMapping & {
-    at?: number;
-}) => VoiceExternalObjectMap;
+export declare const createVoiceFileAssistantMemoryStore: <TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord>(options: VoiceFileStoreOptions) => VoiceAssistantMemoryStore<TRecord>;
+export declare const createVoiceFileAuditEventStore: <TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent>(options: VoiceFileStoreOptions) => VoiceAuditEventStore<TEvent>;
+export declare const createVoiceFileAuditSinkDeliveryStore: <TDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord>(options: VoiceFileStoreOptions) => VoiceAuditSinkDeliveryStore<TDelivery>;
+export declare const createVoiceFileCampaignStore: (options: VoiceFileStoreOptions) => VoiceCampaignStore;
+export declare const createVoiceFileExternalObjectMapStore: <TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap>(options: VoiceFileStoreOptions) => VoiceExternalObjectMapStore<TMapping>;
+export declare const createVoiceFileIncidentBundleStore: <TArtifact extends StoredVoiceIncidentBundleArtifact = StoredVoiceIncidentBundleArtifact>(options: VoiceFileStoreOptions) => VoiceIncidentBundleStore<TArtifact>;
+export declare const createVoiceFileIntegrationEventStore: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(options: VoiceFileStoreOptions) => VoiceIntegrationEventStore<TEvent>;
+export declare const createVoiceFileReviewStore: <TArtifact extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact>(options: VoiceFileStoreOptions) => VoiceCallReviewStore<TArtifact>;
+export declare const createVoiceFileRuntimeStorage: <TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord, TAudit extends StoredVoiceAuditEvent = StoredVoiceAuditEvent, TAuditDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord, TIncident extends StoredVoiceIncidentBundleArtifact = StoredVoiceIncidentBundleArtifact, TMemory extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord>(options: VoiceFileStoreOptions) => VoiceFileRuntimeStorage<TSession, TReview, TTask, TEvent, TMapping, TTrace, TTraceDelivery, TAudit, TAuditDelivery, TIncident, TMemory>;
+export declare const createVoiceFileSessionStore: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceFileStoreOptions) => VoiceSessionStore<TSession>;
+export declare const createVoiceFileTaskStore: <TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask>(options: VoiceFileStoreOptions) => VoiceOpsTaskStore<TTask>;
+export declare const createVoiceFileTraceEventStore: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(options: VoiceFileStoreOptions) => VoiceTraceEventStore<TEvent>;
+export declare const createVoiceFileTraceSinkDeliveryStore: <TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(options: VoiceFileStoreOptions) => VoiceTraceSinkDeliveryStore<TDelivery>;
+export declare const createVoiceFileRecordingStore: (options: VoiceFileStoreOptions) => VoiceRecordingStore;

package/dist/core/guardrails.d.ts

@@ -0,0 +1,128 @@
+import { Elysia } from "elysia";
+import type { VoiceAgentTool } from "./agent";
+import type { VoiceTraceEventStore } from "./trace";
+import type { VoiceOnTurnObjectHandler, VoiceRouteResult, VoiceSessionRecord } from "./types";
+import type { VoiceAssistantGuardrails } from "./assistant";
+export type VoiceGuardrailStage = "assistant-output" | "handoff" | "model-input" | "tool-input" | "tool-output" | "transcript";
+export type VoiceGuardrailSeverity = "block" | "warn";
+export type VoiceGuardrailStatus = "blocked" | "pass" | "warn";
+export type VoiceGuardrailRule = {
+    action?: VoiceGuardrailSeverity;
+    description?: string;
+    id: string;
+    label?: string;
+    match: RegExp | string | ((input: VoiceGuardrailEvaluationInput) => boolean | Promise<boolean>);
+    redactWith?: string;
+    stages?: VoiceGuardrailStage[];
+};
+export type VoiceGuardrailEvaluationInput = {
+    content?: unknown;
+    metadata?: Record<string, unknown>;
+    sessionId?: string;
+    stage: VoiceGuardrailStage;
+    turnId?: string;
+};
+export type VoiceGuardrailFinding = {
+    action: VoiceGuardrailSeverity;
+    description?: string;
+    label: string;
+    ruleId: string;
+    stage: VoiceGuardrailStage;
+};
+export type VoiceGuardrailDecision = {
+    allowed: boolean;
+    checkedAt: number;
+    content?: unknown;
+    findings: VoiceGuardrailFinding[];
+    redactedContent?: unknown;
+    sessionId?: string;
+    stage: VoiceGuardrailStage;
+    status: VoiceGuardrailStatus;
+    turnId?: string;
+};
+export type VoiceGuardrailPolicy = {
+    defaultAction?: VoiceGuardrailSeverity;
+    id: string;
+    label?: string;
+    rules: VoiceGuardrailRule[];
+};
+export type VoiceGuardrailReport = {
+    checkedAt: number;
+    decisions: VoiceGuardrailDecision[];
+    failed: number;
+    policies: Array<{
+        id: string;
+        label?: string;
+        rules: number;
+    }>;
+    status: "fail" | "pass" | "warn";
+    summary: {
+        blocked: number;
+        passed: number;
+        warned: number;
+    };
+    total: number;
+};
+export type VoiceGuardrailRoutesOptions = {
+    headers?: HeadersInit;
+    name?: string;
+    path?: string;
+    policies?: VoiceGuardrailPolicy[];
+    source?: ((input: VoiceGuardrailEvaluationInput) => Promise<VoiceGuardrailDecision | VoiceGuardrailReport> | VoiceGuardrailDecision | VoiceGuardrailReport) | VoiceGuardrailDecision | VoiceGuardrailReport;
+    trace?: VoiceTraceEventStore;
+};
+export type VoiceGuardrailRuntimeBlockInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Parameters<VoiceOnTurnObjectHandler<TContext, TSession, TResult>>[0] & {
+    decision: VoiceGuardrailDecision;
+    stage: VoiceGuardrailStage;
+};
+export type VoiceGuardrailRuntimeOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    blockResult?: (input: VoiceGuardrailRuntimeBlockInput<TContext, TSession, TResult>) => Promise<VoiceRouteResult<TResult>> | VoiceRouteResult<TResult>;
+    name?: string;
+    policies: VoiceGuardrailPolicy[];
+    trace?: VoiceTraceEventStore;
+};
+export type VoiceGuardrailRuntime<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    assistantGuardrails: VoiceAssistantGuardrails<TContext, TSession, TResult>;
+    evaluate: (input: VoiceGuardrailEvaluationInput) => Promise<VoiceGuardrailDecision>;
+    wrapTool: <TArgs extends Record<string, unknown>, TToolResult>(tool: VoiceAgentTool<TContext, TSession, TArgs, TToolResult, TResult>) => VoiceAgentTool<TContext, TSession, TArgs, TToolResult, TResult>;
+    wrapTools: (tools: Array<VoiceAgentTool<TContext, TSession, Record<string, unknown>, unknown, TResult>>) => Array<VoiceAgentTool<TContext, TSession, Record<string, unknown>, unknown, TResult>>;
+};
+export declare const buildVoiceGuardrailReport: (input?: {
+    decisions: VoiceGuardrailDecision[];
+    policies?: VoiceGuardrailPolicy[];
+}) => VoiceGuardrailReport;
+export declare const createVoiceGuardrailPolicy: (policy: VoiceGuardrailPolicy) => VoiceGuardrailPolicy;
+export declare const evaluateVoiceGuardrailPolicy: (policy: VoiceGuardrailPolicy, input: VoiceGuardrailEvaluationInput) => Promise<VoiceGuardrailDecision>;
+export declare const voiceGuardrailPolicyPresets: {
+    supportSafeDefaults: VoiceGuardrailPolicy;
+};
+export declare const createVoiceGuardrailRuntime: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoiceGuardrailRuntimeOptions<TContext, TSession, TResult>) => VoiceGuardrailRuntime<TContext, TSession, TResult>;
+export declare const renderVoiceGuardrailMarkdown: (report: VoiceGuardrailReport) => string;
+export declare const createVoiceGuardrailRoutes: (options?: VoiceGuardrailRoutesOptions) => 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/core/handoff.d.ts

@@ -0,0 +1,54 @@
+import type { VoiceHandoffAction, VoiceHandoffAdapter, VoiceHandoffConfig, VoiceHandoffDeliveryStore, VoiceHandoffInput, VoiceHandoffResult, VoiceSessionRecord, StoredVoiceHandoffDelivery } from "./types";
+type MaybePromise<T> = T | Promise<T>;
+export type VoiceHandoffDelivery = VoiceHandoffResult & {
+    adapterId: string;
+    adapterKind?: string;
+};
+export type VoiceHandoffDeliveryRecord<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = StoredVoiceHandoffDelivery<TContext, TSession, TResult>;
+export type VoiceHandoffFanoutResult = {
+    action: VoiceHandoffAction;
+    deliveries: Record<string, VoiceHandoffDelivery>;
+    status: VoiceHandoffResult["status"];
+};
+export type VoiceHandoffDeliveryRecordInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Omit<VoiceHandoffInput<TContext, TSession, TResult>, "api"> & {
+    id?: string;
+};
+export type VoiceQueuedHandoffDeliveryOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    adapters: VoiceHandoffAdapter<TContext, TSession, TResult>[];
+    api: VoiceHandoffInput<TContext, TSession, TResult>["api"];
+    delivery: VoiceHandoffDeliveryRecord<TContext, TSession, TResult>;
+    failMode?: VoiceHandoffConfig<TContext, TSession, TResult>["failMode"];
+};
+export type VoiceWebhookHandoffAdapterOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    actions?: VoiceHandoffAction[];
+    body?: (input: VoiceHandoffInput<TContext, TSession, TResult>) => MaybePromise<Record<string, unknown>>;
+    fetch?: typeof fetch;
+    headers?: Record<string, string>;
+    id: string;
+    kind?: string;
+    method?: "POST" | "PUT" | "PATCH";
+    signingSecret?: string;
+    timeoutMs?: number;
+    url: string;
+};
+export type VoiceTwilioRedirectHandoffAdapterOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    accountSid: string;
+    actions?: VoiceHandoffAction[];
+    authToken: string;
+    buildTwiML?: (input: VoiceHandoffInput<TContext, TSession, TResult>) => MaybePromise<string>;
+    callSid?: string | ((input: VoiceHandoffInput<TContext, TSession, TResult>) => MaybePromise<string | undefined>);
+    fetch?: typeof fetch;
+    id?: string;
+    timeoutMs?: number;
+};
+export declare const applyVoiceHandoffDeliveryResult: <TContext, TSession extends VoiceSessionRecord, TResult>(delivery: VoiceHandoffDeliveryRecord<TContext, TSession, TResult>, result: VoiceHandoffFanoutResult) => VoiceHandoffDeliveryRecord<TContext, TSession, TResult>;
+export declare const createVoiceHandoffDeliveryRecord: <TContext, TSession extends VoiceSessionRecord, TResult>(input: VoiceHandoffDeliveryRecordInput<TContext, TSession, TResult>) => VoiceHandoffDeliveryRecord<TContext, TSession, TResult>;
+export declare const createVoiceMemoryHandoffDeliveryStore: <TDelivery extends VoiceHandoffDeliveryRecord = VoiceHandoffDeliveryRecord>() => VoiceHandoffDeliveryStore<TDelivery>;
+export declare const createVoiceWebhookHandoffAdapter: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoiceWebhookHandoffAdapterOptions<TContext, TSession, TResult>) => VoiceHandoffAdapter<TContext, TSession, TResult>;
+export declare const deliverVoiceHandoff: <TContext, TSession extends VoiceSessionRecord, TResult>(input: {
+    config?: VoiceHandoffConfig<TContext, TSession, TResult>;
+    handoff: VoiceHandoffInput<TContext, TSession, TResult>;
+}) => Promise<VoiceHandoffFanoutResult | undefined>;
+export declare const deliverVoiceHandoffDelivery: <TContext, TSession extends VoiceSessionRecord, TResult>(options: VoiceQueuedHandoffDeliveryOptions<TContext, TSession, TResult>) => Promise<VoiceHandoffDeliveryRecord<TContext, TSession, TResult>>;
+export declare const createVoiceTwilioRedirectHandoffAdapter: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoiceTwilioRedirectHandoffAdapterOptions<TContext, TSession, TResult>) => VoiceHandoffAdapter<TContext, TSession, TResult>;
+export {};

package/dist/core/handoffHealth.d.ts

@@ -0,0 +1,94 @@
+import { Elysia } from "elysia";
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from "./trace";
+export type VoiceHandoffHealthStatus = "delivered" | "failed" | "skipped";
+export type VoiceHandoffHealthDelivery = {
+    adapterId: string;
+    adapterKind?: string;
+    deliveredAt?: number;
+    deliveredTo?: string;
+    error?: string;
+    status: VoiceHandoffHealthStatus;
+};
+export type VoiceHandoffHealthEvent = {
+    action?: string;
+    at: number;
+    deliveries: VoiceHandoffHealthDelivery[];
+    reason?: string;
+    replayHref?: string;
+    sessionId: string;
+    status: VoiceHandoffHealthStatus;
+    target?: string;
+};
+export type VoiceHandoffHealthSummary = {
+    byAction: Record<string, number>;
+    byAdapter: Record<string, Record<VoiceHandoffHealthStatus, number>>;
+    byStatus: Record<VoiceHandoffHealthStatus, number>;
+    events: VoiceHandoffHealthEvent[];
+    failed: number;
+    total: number;
+};
+export type VoiceHandoffHealthSummaryOptions = {
+    events?: StoredVoiceTraceEvent[];
+    limit?: number;
+    q?: string;
+    replayHref?: false | string | ((event: Omit<VoiceHandoffHealthEvent, "replayHref">) => string);
+    status?: VoiceHandoffHealthStatus | "all";
+    store?: VoiceTraceEventStore;
+};
+export type VoiceHandoffHealthHTMLHandlerOptions = VoiceHandoffHealthSummaryOptions & {
+    headers?: HeadersInit;
+    render?: (summary: VoiceHandoffHealthSummary) => string | Promise<string>;
+};
+export type VoiceHandoffHealthRoutesOptions = VoiceHandoffHealthHTMLHandlerOptions & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export declare const summarizeVoiceHandoffHealth: (options?: VoiceHandoffHealthSummaryOptions) => Promise<VoiceHandoffHealthSummary>;
+export declare const createVoiceHandoffHealthHTMLHandler: (options?: VoiceHandoffHealthHTMLHandlerOptions) => ({ query }: {
+    query?: Record<string, string | undefined>;
+}) => Promise<Response>;
+export declare const createVoiceHandoffHealthJSONHandler: (options?: VoiceHandoffHealthSummaryOptions) => ({ query }: {
+    query?: Record<string, string | undefined>;
+}) => Promise<VoiceHandoffHealthSummary>;
+export declare const createVoiceHandoffHealthRoutes: (options?: VoiceHandoffHealthRoutesOptions) => 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: VoiceHandoffHealthSummary;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const renderVoiceHandoffHealthHTML: (summary: VoiceHandoffHealthSummary) => string;

package/dist/core/hardenedFetch.d.ts

@@ -0,0 +1,3 @@
+export declare const hardenFetch: (baseFetch?: typeof fetch) => ((input: Parameters<typeof fetch>[0], init: Parameters<typeof fetch>[1]) => Promise<Response>) & {
+    preconnect: typeof fetch.preconnect;
+};