@absolutejs/voice 0.0.22-beta.54 → 0.0.22-beta.540

package/dist/core/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 buildOTELSpanId: (sessionId: string, suffix: string) => string;
+export declare const buildOTELTraceId: (sessionId: 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/core/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 assertVoiceOutcomeContractEvidence: (report: VoiceOutcomeContractSuiteReport, input?: VoiceOutcomeContractAssertionInput) => VoiceOutcomeContractAssertionReport;
+export declare const createVoiceOutcomeContractHTMLHandler: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceOutcomeContractHTMLHandlerOptions<TSession>) => () => Promise<Response>;
+export declare const createVoiceOutcomeContractJSONHandler: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceOutcomeContractOptions<TSession>) => () => Promise<VoiceOutcomeContractSuiteReport>;
+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 declare const evaluateVoiceOutcomeContractEvidence: (report: VoiceOutcomeContractSuiteReport, input?: VoiceOutcomeContractAssertionInput) => VoiceOutcomeContractAssertionReport;
+export declare const renderVoiceOutcomeContractHTML: (report: VoiceOutcomeContractSuiteReport, options?: {
+    title?: string;
+}) => string;
+export declare const runVoiceOutcomeContractSuite: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceOutcomeContractOptions<TSession>) => Promise<VoiceOutcomeContractSuiteReport>;
+export {};

package/dist/{outcomeRecipes.d.ts → core/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;
 };

package/dist/core/pathway.d.ts

@@ -0,0 +1,94 @@
+export type VoicePathwaySlotType = "string" | "number" | "boolean" | "date" | "time" | "phone" | "email" | "currency" | "choice";
+export type VoicePathwaySlot = {
+    id: string;
+    type: VoicePathwaySlotType;
+    prompt: string;
+    required?: boolean;
+    choices?: string[];
+    description?: string;
+    validation?: {
+        minLength?: number;
+        maxLength?: number;
+        pattern?: string;
+        min?: number;
+        max?: number;
+    };
+};
+export type VoicePathwayCondition = {
+    kind: "slot-equals";
+    slotId: string;
+    value: string | number | boolean;
+} | {
+    kind: "slot-filled";
+    slotId: string;
+} | {
+    kind: "slot-matches";
+    slotId: string;
+    pattern: string;
+} | {
+    kind: "always";
+} | {
+    kind: "fallback";
+};
+export type VoicePathwayAction = {
+    kind: "say";
+    text: string;
+} | {
+    kind: "collect-slot";
+    slotId: string;
+} | {
+    kind: "call-tool";
+    toolId: string;
+    argsFromSlots?: string[];
+} | {
+    kind: "set-slot";
+    slotId: string;
+    valueExpression: string;
+} | {
+    kind: "transfer";
+    destination: string;
+} | {
+    kind: "end-call";
+    reason?: string;
+};
+export type VoicePathwayTransition = {
+    to: string;
+    condition: VoicePathwayCondition;
+    description?: string;
+};
+export type VoicePathwayState = {
+    id: string;
+    label: string;
+    kind?: "entry" | "collect" | "branch" | "action" | "terminal";
+    description?: string;
+    systemNote?: string;
+    actions?: VoicePathwayAction[];
+    transitions: VoicePathwayTransition[];
+};
+export type VoicePathway = {
+    id: string;
+    label: string;
+    entryStateId: string;
+    states: VoicePathwayState[];
+    slots: VoicePathwaySlot[];
+    tools?: {
+        id: string;
+        description: string;
+    }[];
+    metadata?: Record<string, string>;
+};
+export type VoicePathwayValidationIssue = {
+    severity: "error" | "warning";
+    code: "duplicate-state" | "duplicate-slot" | "unknown-entry" | "unreachable-state" | "missing-transition-target" | "missing-slot-ref" | "no-terminal-reachable" | "fallback-not-last" | "duplicate-transition";
+    message: string;
+    stateId?: string;
+    slotId?: string;
+};
+export type VoicePathwayValidationReport = {
+    valid: boolean;
+    issues: VoicePathwayValidationIssue[];
+    reachableStates: string[];
+};
+export declare const findVoicePathwaySlot: (pathway: VoicePathway, id: string) => VoicePathwaySlot | null;
+export declare const findVoicePathwayState: (pathway: VoicePathway, id: string) => VoicePathwayState | null;
+export declare const validateVoicePathway: (pathway: VoicePathway) => VoicePathwayValidationReport;

package/dist/core/pathwayCompiler.d.ts

@@ -0,0 +1,31 @@
+import { type VoicePathway } from "./pathway";
+export type VoicePathwayCompilerToolDefinition = {
+    name: string;
+    description: string;
+    parameters: {
+        type: "object";
+        properties: Record<string, {
+            type: string;
+            description?: string;
+            enum?: string[];
+        }>;
+        required: string[];
+    };
+};
+export type VoicePathwayCompiledAssistant = {
+    systemPrompt: string;
+    tools: VoicePathwayCompilerToolDefinition[];
+    initialPrompt?: string;
+    metadata: {
+        pathwayId: string;
+        pathwayLabel: string;
+        entryStateId: string;
+    };
+};
+export type CompileVoicePathwayOptions = {
+    pathway: VoicePathway;
+    introduction?: string;
+    fallbackBehavior?: "stay" | "end-call" | "transfer";
+    toolNamePrefix?: string;
+};
+export declare const compileVoicePathwayToAssistant: (options: CompileVoicePathwayOptions) => VoicePathwayCompiledAssistant;

package/dist/core/pathwayGenerator.d.ts

@@ -0,0 +1,27 @@
+import { type VoicePathway, type VoicePathwayValidationReport } from "./pathway";
+export type VoicePathwayGeneratorCompletion = (input: {
+    prompt: string;
+    systemPrompt: string;
+}) => Promise<string>;
+export type GenerateVoicePathwayInput = {
+    /** Plain-text description of the agent / flow to build. */
+    description: string;
+    completion: VoicePathwayGeneratorCompletion;
+    /** Suggested pathway id (slugified). Defaults to "generated-pathway". */
+    id?: string;
+    /** Extra guidance appended to the system prompt. */
+    guidance?: string;
+    /**
+     * If the first attempt fails validation, retry this many times feeding the
+     * issues back to the model. Defaults to 2.
+     */
+    maxRepairAttempts?: number;
+};
+export type GenerateVoicePathwayResult = {
+    pathway: VoicePathway;
+    report: VoicePathwayValidationReport;
+    attempts: number;
+    /** Raw model outputs from each attempt, for debugging. */
+    rawOutputs: string[];
+};
+export declare const generateVoicePathwayFromPrompt: (input: GenerateVoicePathwayInput) => Promise<GenerateVoicePathwayResult>;

package/dist/core/pathwayRuntime.d.ts

@@ -0,0 +1,57 @@
+import { type VoicePathway, type VoicePathwayAction } from "./pathway";
+export type VoicePathwaySlotValue = string | number | boolean | null;
+export type VoicePathwayRuntimeStatus = "ready" | "awaiting-slot" | "branching" | "ended" | "errored";
+export type VoicePathwayRuntimeState = {
+    currentStateId: string;
+    status: VoicePathwayRuntimeStatus;
+    slots: Record<string, VoicePathwaySlotValue>;
+    awaitingSlotId: string | null;
+    history: {
+        stateId: string;
+        at: number;
+    }[];
+    pendingActions: VoicePathwayAction[];
+    lastError?: string;
+    endedReason?: string;
+};
+export type VoicePathwayToolCall = {
+    toolId: string;
+    args: Record<string, VoicePathwaySlotValue>;
+};
+export type VoicePathwayRuntimeEvent = {
+    type: "say";
+    text: string;
+} | {
+    type: "ask-slot";
+    slotId: string;
+    prompt: string;
+} | {
+    type: "tool-call";
+    call: VoicePathwayToolCall;
+} | {
+    type: "transfer";
+    destination: string;
+} | {
+    type: "end-call";
+    reason?: string;
+} | {
+    type: "state-entered";
+    stateId: string;
+} | {
+    type: "errored";
+    message: string;
+};
+export type CreateVoicePathwayRuntimeOptions = {
+    pathway: VoicePathway;
+    initialSlots?: Record<string, VoicePathwaySlotValue>;
+    now?: () => number;
+    skipValidation?: boolean;
+};
+export declare const createVoicePathwayRuntime: (options: CreateVoicePathwayRuntimeOptions) => {
+    fillSlot: (slotId: string, value: VoicePathwaySlotValue) => void;
+    start: () => void;
+    tryTransition: () => void;
+    getState: () => VoicePathwayRuntimeState;
+    subscribe(listener: (event: VoicePathwayRuntimeEvent) => void): () => void;
+};
+export type VoicePathwayRuntime = ReturnType<typeof createVoicePathwayRuntime>;

package/dist/core/pathwaySlotCollector.d.ts

@@ -0,0 +1,29 @@
+import type { VoicePathwaySlot, VoicePathwaySlotType } from "./pathway";
+import type { VoicePathwaySlotValue } from "./pathwayRuntime";
+export type VoicePathwaySlotParseResult = {
+    ok: true;
+    value: VoicePathwaySlotValue;
+    normalized: string;
+} | {
+    ok: false;
+    reason: "empty" | "type-mismatch" | "out-of-range" | "no-match";
+    hint?: string;
+};
+export type VoicePathwaySlotParser = (raw: string, slot: VoicePathwaySlot) => VoicePathwaySlotParseResult;
+export declare const DEFAULT_VOICE_PATHWAY_SLOT_PARSERS: Record<VoicePathwaySlotType, VoicePathwaySlotParser>;
+export type CreateVoicePathwaySlotCollectorOptions = {
+    parsers?: Partial<Record<VoicePathwaySlotType, VoicePathwaySlotParser>>;
+    maxAttemptsPerSlot?: number;
+};
+export type VoicePathwaySlotCollectorAttempt = {
+    slotId: string;
+    raw: string;
+    result: VoicePathwaySlotParseResult;
+    attempt: number;
+};
+export declare const createVoicePathwaySlotCollector: (options?: CreateVoicePathwaySlotCollectorOptions) => {
+    attemptsExceeded: (slotId: string) => boolean;
+    interpret: (slot: VoicePathwaySlot, raw: string) => VoicePathwaySlotCollectorAttempt;
+    reset: (slotId?: string) => void;
+};
+export type VoicePathwaySlotCollector = ReturnType<typeof createVoicePathwaySlotCollector>;

package/dist/core/pathwayVisualizer.d.ts

@@ -0,0 +1,8 @@
+import type { VoicePathway } from "./pathway";
+export declare const renderVoicePathwayMermaid: (pathway: VoicePathway) => string;
+export declare const renderVoicePathwayText: (pathway: VoicePathway) => string;
+export type VoicePathwayVisualization = {
+    mermaid: string;
+    text: string;
+};
+export declare const visualizeVoicePathway: (pathway: VoicePathway) => VoicePathwayVisualization;

package/dist/core/phoneAgent.d.ts

@@ -0,0 +1,139 @@
+import { Elysia } from "elysia";
+import { type PlivoVoiceRoutesOptions } from "../telephony/plivo";
+import { type TelnyxVoiceRoutesOptions } from "../telephony/telnyx";
+import { type TwilioVoiceRoutesOptions } from "../telephony/twilio";
+import { type VoiceTelephonyCarrierMatrix, type VoiceTelephonyCarrierMatrixRoutesOptions } from "../telephony/matrix";
+import { type VoicePhoneAgentProductionSmokeRoutesOptions } from "./phoneAgentProductionSmoke";
+import { type VoiceCampaignDialerProofAssertionReport, type VoiceCampaignDialerProofProvider, type VoiceCampaignDialerProofReport } from "./campaignDialers";
+import type { VoiceTelephonyProvider } from "../telephony/contract";
+import type { VoicePhoneAgentProductionSmokeReport } from "./phoneAgentProductionSmoke";
+import type { VoiceSessionRecord } from "./types";
+export type VoicePhoneAgentLifecycleStage = "ringing" | "answered" | "media-started" | "transcript" | "assistant-response" | "transfer" | "voicemail" | "no-answer" | "completed" | "failed";
+type VoicePhoneAgentCarrierBase = {
+    name?: string;
+    smokePath?: false | string;
+    setupPath?: false | string;
+};
+export type VoicePhoneAgentTwilioCarrier<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = VoicePhoneAgentCarrierBase & {
+    options: TwilioVoiceRoutesOptions<TContext, TSession, TResult>;
+    provider: "twilio";
+};
+export type VoicePhoneAgentTelnyxCarrier<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = VoicePhoneAgentCarrierBase & {
+    options?: TelnyxVoiceRoutesOptions<TContext, TSession, TResult>;
+    provider: "telnyx";
+};
+export type VoicePhoneAgentPlivoCarrier<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = VoicePhoneAgentCarrierBase & {
+    options?: PlivoVoiceRoutesOptions<TContext, TSession, TResult>;
+    provider: "plivo";
+};
+export type VoicePhoneAgentCarrier<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = VoicePhoneAgentTwilioCarrier<TContext, TSession, TResult> | VoicePhoneAgentTelnyxCarrier<TContext, TSession, TResult> | VoicePhoneAgentPlivoCarrier<TContext, TSession, TResult>;
+export type VoicePhoneAgentRoutesOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    carriers: readonly VoicePhoneAgentCarrier<TContext, TSession, TResult>[];
+    matrix?: false | Omit<VoiceTelephonyCarrierMatrixRoutesOptions, "load">;
+    name?: string;
+    productionSmoke?: false | VoicePhoneAgentProductionSmokeRoutesOptions;
+    setup?: false | {
+        path?: string;
+        title?: string;
+    };
+};
+export type VoicePhoneAgentCarrierSummary = {
+    name?: string;
+    provider: "plivo" | "telnyx" | "twilio";
+    setupPath?: false | string;
+    smokePath?: false | string;
+};
+type VoicePhoneAgentSetupInstruction = {
+    answerLabel: string;
+    answerUrl?: string;
+    carrierName: string;
+    issues: string[];
+    provider: "plivo" | "telnyx" | "twilio";
+    setupPath?: false | string;
+    smokePath?: false | string;
+    status: "fail" | "pass" | "unknown" | "warn";
+    steps: string[];
+    streamUrl?: string;
+    webhookUrl?: string;
+};
+export type VoicePhoneAgentRoutes = {
+    carriers: VoicePhoneAgentCarrierSummary[];
+    matrixPath?: string;
+    productionSmokePath?: string;
+    routes: Elysia;
+    setupPath?: string;
+};
+export type VoicePhoneAgentSetupReport = {
+    carriers: VoicePhoneAgentCarrierSummary[];
+    generatedAt: number;
+    lifecycleStages: VoicePhoneAgentLifecycleStage[];
+    matrix?: VoiceTelephonyCarrierMatrix;
+    matrixPath?: string;
+    productionSmokePath?: string;
+    ready: boolean;
+    setupInstructions: VoicePhoneAgentSetupInstruction[];
+    setupPath?: string;
+    title: string;
+};
+export type VoicePhoneAssistantEvidenceInput = {
+    dialerProof?: VoiceCampaignDialerProofReport;
+    maxCarrierFailures?: number;
+    maxCarrierWarnings?: number;
+    maxFailedDialerProviders?: number;
+    minCarriers?: number;
+    minDialerCarrierRequests?: number;
+    minReadyCarriers?: number;
+    minSmokePassing?: number;
+    minSuccessfulDialerOutcomes?: number;
+    requiredDialerProviders?: VoiceCampaignDialerProofProvider[];
+    requiredLifecycleStages?: VoicePhoneAgentLifecycleStage[];
+    requiredProviders?: VoiceTelephonyProvider[];
+    requireCarrierMatrix?: boolean;
+    requireDialerProof?: boolean;
+    requireMatrixPass?: boolean;
+    requireProductionSmokePath?: boolean;
+    requireReady?: boolean;
+    requireSetupPath?: boolean;
+};
+export type VoicePhoneAssistantEvidenceReport = {
+    carrierFailures: number;
+    carrierWarnings: number;
+    carriers: number;
+    dialer?: VoiceCampaignDialerProofAssertionReport;
+    issues: string[];
+    lifecycleStages: VoicePhoneAgentLifecycleStage[];
+    matrixPass?: boolean;
+    ok: boolean;
+    productionSmokePath?: string;
+    providers: VoiceTelephonyProvider[];
+    ready: boolean;
+    readyCarriers: number;
+    setupPath?: string;
+    smokePassing: number;
+};
+export type VoicePhoneCallControlEvidenceInput = {
+    maxFailedSmokeReports?: number;
+    minPassingSmokeReports?: number;
+    productionSmokes?: VoicePhoneAgentProductionSmokeReport[];
+    requiredLifecycleStages?: VoicePhoneAgentLifecycleStage[];
+    requiredOutcomes?: string[];
+    requiredProviders?: VoiceTelephonyProvider[];
+    requireSetupLifecycleStages?: boolean;
+    setup?: VoicePhoneAgentSetupReport;
+};
+export type VoicePhoneCallControlEvidenceReport = {
+    failedSmokeReports: number;
+    issues: string[];
+    lifecycleStages: VoicePhoneAgentLifecycleStage[];
+    ok: boolean;
+    outcomes: string[];
+    passingSmokeReports: number;
+    providers: VoiceTelephonyProvider[];
+    smokeReports: number;
+};
+export declare const assertVoicePhoneAssistantEvidence: (report: VoicePhoneAgentSetupReport, input?: VoicePhoneAssistantEvidenceInput) => VoicePhoneAssistantEvidenceReport;
+export declare const assertVoicePhoneCallControlEvidence: (input?: VoicePhoneCallControlEvidenceInput) => VoicePhoneCallControlEvidenceReport;
+export declare const evaluateVoicePhoneAssistantEvidence: (report: VoicePhoneAgentSetupReport, input?: VoicePhoneAssistantEvidenceInput) => VoicePhoneAssistantEvidenceReport;
+export declare const evaluateVoicePhoneCallControlEvidence: (input?: VoicePhoneCallControlEvidenceInput) => VoicePhoneCallControlEvidenceReport;
+export declare const createVoicePhoneAgent: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoicePhoneAgentRoutesOptions<TContext, TSession, TResult>) => VoicePhoneAgentRoutes;
+export {};