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

package/dist/core/campaignControls.d.ts

@@ -0,0 +1,37 @@
+import type { VoiceCampaign, VoiceCampaignAttemptStatus, VoiceCampaignRecipient, VoiceCampaignRecord, VoiceCampaignTimeWindow } from "./campaign";
+export type VoiceCampaignDisposition = "answered" | "busy" | "failed" | "no-answer" | "voicemail";
+export type VoiceCampaignDispositionRetryRule = {
+    backoffMs?: number;
+    maxAttempts?: number;
+    retry?: boolean;
+};
+export type VoiceCampaignDispositionRetryPolicy = Partial<Record<VoiceCampaignDisposition, VoiceCampaignDispositionRetryRule>>;
+export type VoiceDNCList = {
+    contains: (phone: string) => boolean | Promise<boolean>;
+};
+export declare const createInMemoryDNCList: (phones: ReadonlyArray<string>) => VoiceDNCList;
+export declare const isPhoneOnDNC: (phone: string, list: VoiceDNCList) => Promise<boolean>;
+export declare const normalizePhoneNumber: (phone: string) => string;
+export type VoiceCampaignWindowCheckInput = {
+    now?: Date;
+    window: VoiceCampaignTimeWindow;
+};
+export declare const isWithinCampaignWindow: (input: VoiceCampaignWindowCheckInput) => boolean;
+export declare const shouldRetryCampaignAttempt: (input: {
+    attempts: number;
+    campaign: Pick<VoiceCampaign, "maxAttempts">;
+    disposition?: VoiceCampaignDisposition;
+    policy?: VoiceCampaignDispositionRetryPolicy;
+}) => {
+    backoffMs?: number;
+    retry: boolean;
+};
+export type VoiceCampaignDispositionSummary = {
+    attempts: number;
+    byDisposition: Partial<Record<VoiceCampaignDisposition, number>>;
+    byStatus: Record<VoiceCampaignAttemptStatus, number>;
+    campaignId: string;
+    recipientsByStatus: Record<VoiceCampaignRecipient["status"], number>;
+    totalRecipients: number;
+};
+export declare const summarizeVoiceCampaignDispositions: (record: VoiceCampaignRecord) => VoiceCampaignDispositionSummary;

package/dist/core/campaignDialers.d.ts

@@ -0,0 +1,111 @@
+import { applyVoiceCampaignTelephonyOutcome, VoiceCampaignDialer, VoiceCampaignDialerInput, type VoiceCampaignRecord, type VoiceCampaignStore, type VoiceCampaignTickResult } from "./campaign";
+type VoiceCampaignDialerFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+type VoiceCampaignDialerMetadataInput = VoiceCampaignDialerInput & {
+    provider: "plivo" | "telnyx" | "twilio";
+};
+type VoiceCampaignDialerMetadata = Record<string, string | number | boolean | undefined> | ((input: VoiceCampaignDialerMetadataInput) => Record<string, string | number | boolean | undefined> | Promise<Record<string, string | number | boolean | undefined>>);
+type VoiceCampaignURLInput = {
+    attempt: VoiceCampaignDialerInput["attempt"];
+    campaign: VoiceCampaignDialerInput["campaign"];
+    recipient: VoiceCampaignDialerInput["recipient"];
+};
+type VoiceCampaignURLResolver = string | ((input: VoiceCampaignURLInput) => string | Promise<string>);
+export type VoiceTwilioCampaignDialerOptions = {
+    accountSid: string;
+    answerMethod?: "GET" | "POST";
+    answerUrl: VoiceCampaignURLResolver;
+    apiBaseUrl?: string;
+    authToken: string;
+    fetch?: VoiceCampaignDialerFetch;
+    from: string;
+    machineDetection?: string;
+    metadata?: VoiceCampaignDialerMetadata;
+    statusCallbackEvents?: string[];
+    statusCallbackMethod?: "GET" | "POST";
+    statusCallbackUrl?: VoiceCampaignURLResolver;
+};
+export type VoiceTelnyxCampaignDialerOptions = {
+    apiBaseUrl?: string;
+    apiKey: string;
+    clientState?: VoiceCampaignDialerMetadata;
+    connectionId: string;
+    fetch?: VoiceCampaignDialerFetch;
+    from: string;
+    webhookUrl?: VoiceCampaignURLResolver;
+    webhookUrlMethod?: "GET" | "POST";
+};
+export type VoicePlivoCampaignDialerOptions = {
+    answerMethod?: "GET" | "POST";
+    answerUrl: VoiceCampaignURLResolver;
+    apiBaseUrl?: string;
+    authId: string;
+    authToken: string;
+    callbackMethod?: "GET" | "POST";
+    callbackUrl?: VoiceCampaignURLResolver;
+    fetch?: VoiceCampaignDialerFetch;
+    from: string;
+    metadata?: VoiceCampaignDialerMetadata;
+};
+export type VoiceCampaignDialerProofProvider = "plivo" | "telnyx" | "twilio";
+export type VoiceCampaignDialerProofCarrierRequest = {
+    body: unknown;
+    method: string;
+    provider: VoiceCampaignDialerProofProvider;
+    url: string;
+};
+export type VoiceCampaignDialerProofProviderResult = {
+    campaignId: string;
+    carrierRequests: VoiceCampaignDialerProofCarrierRequest[];
+    final?: VoiceCampaignRecord;
+    outcomes: Awaited<ReturnType<typeof applyVoiceCampaignTelephonyOutcome>>[];
+    provider: VoiceCampaignDialerProofProvider;
+    tick: VoiceCampaignTickResult;
+};
+export type VoiceCampaignDialerProofReport = {
+    generatedAt: number;
+    mode: "dry-run";
+    ok: boolean;
+    providers: VoiceCampaignDialerProofProviderResult[];
+};
+export type VoiceCampaignDialerProofStatus = {
+    generatedAt: number;
+    mode: "dry-run";
+    ok: boolean;
+    providers: VoiceCampaignDialerProofProvider[];
+    runPath?: string;
+    safe: true;
+};
+export type VoiceCampaignDialerProofOptions = {
+    baseUrl?: string;
+    from?: string;
+    providers?: VoiceCampaignDialerProofProvider[];
+    runPath?: string;
+    store?: VoiceCampaignStore;
+};
+export type VoiceCampaignDialerProofAssertionInput = {
+    maxFailedProviders?: number;
+    minCarrierRequests?: number;
+    minProviders?: number;
+    minSuccessfulOutcomes?: number;
+    requiredProviders?: VoiceCampaignDialerProofProvider[];
+    requireDryRun?: boolean;
+    requireOk?: boolean;
+};
+export type VoiceCampaignDialerProofAssertionReport = {
+    carrierRequests: number;
+    failedProviders: number;
+    issues: string[];
+    mode: VoiceCampaignDialerProofReport["mode"];
+    ok: boolean;
+    providers: VoiceCampaignDialerProofProvider[];
+    successfulOutcomes: number;
+    totalProviders: number;
+};
+export declare const createVoicePlivoCampaignDialer: (options: VoicePlivoCampaignDialerOptions) => VoiceCampaignDialer;
+export declare const createVoiceTelnyxCampaignDialer: (options: VoiceTelnyxCampaignDialerOptions) => VoiceCampaignDialer;
+export declare const createVoiceTwilioCampaignDialer: (options: VoiceTwilioCampaignDialerOptions) => VoiceCampaignDialer;
+export declare const assertVoiceCampaignDialerProofEvidence: (report: VoiceCampaignDialerProofReport, input?: VoiceCampaignDialerProofAssertionInput) => VoiceCampaignDialerProofAssertionReport;
+export declare const evaluateVoiceCampaignDialerProofEvidence: (report: VoiceCampaignDialerProofReport, input?: VoiceCampaignDialerProofAssertionInput) => VoiceCampaignDialerProofAssertionReport;
+export declare const getVoiceCampaignDialerProofStatus: (options?: Pick<VoiceCampaignDialerProofOptions, "providers" | "runPath">) => VoiceCampaignDialerProofStatus;
+export declare const runVoiceCampaignDialerProof: (options?: VoiceCampaignDialerProofOptions) => Promise<VoiceCampaignDialerProofReport>;
+export {};

package/dist/core/campaignTemplate.d.ts

@@ -0,0 +1,16 @@
+export type VoiceCampaignTemplateValue = string | number | boolean | null | undefined;
+export type VoiceCampaignTemplateScope = Record<string, VoiceCampaignTemplateValue | Record<string, VoiceCampaignTemplateValue>>;
+export type VoiceCampaignTemplateFilter = (value: VoiceCampaignTemplateValue, ...args: string[]) => VoiceCampaignTemplateValue;
+export type VoiceCampaignTemplateResolveResult = {
+    output: string;
+    missingVariables: string[];
+};
+export type ResolveVoiceCampaignTemplateOptions = {
+    scope: VoiceCampaignTemplateScope;
+    filters?: Record<string, VoiceCampaignTemplateFilter>;
+    fallback?: string;
+    strict?: boolean;
+};
+export declare const DEFAULT_VOICE_CAMPAIGN_TEMPLATE_FILTERS: Record<string, VoiceCampaignTemplateFilter>;
+export declare const collectVoiceCampaignTemplateVariables: (template: string) => string[];
+export declare const resolveVoiceCampaignTemplate: (template: string, options: ResolveVoiceCampaignTemplateOptions) => VoiceCampaignTemplateResolveResult;

package/dist/core/competitiveCoverage.d.ts

@@ -0,0 +1,141 @@
+import { Elysia } from "elysia";
+export type VoiceCompetitiveCoverageStatus = "fail" | "pass" | "warn";
+export type VoiceCompetitiveCoverageLevel = "covered" | "intentional-gap" | "missing" | "partial";
+export type VoiceCompetitiveDepthLevel = "advantage" | "covered" | "intentional-gap" | "lag" | "parity";
+export type VoiceCompetitiveEvidence = {
+    href?: string;
+    kind?: "docs" | "example" | "failure-replay" | "operations-record" | "proof" | "readiness" | "route" | "test";
+    name: string;
+    required?: boolean;
+    status?: "fail" | "pass" | "warn";
+};
+export type VoiceCompetitiveSurface = {
+    buyerNeed?: string;
+    competitors?: string[];
+    coverage: VoiceCompetitiveCoverageLevel;
+    depth: VoiceCompetitiveDepthLevel;
+    evidence?: VoiceCompetitiveEvidence[];
+    frameworkPrimitives?: string[];
+    operationsRecord?: "linked" | "not-applicable" | "required" | "unknown";
+    readinessGate?: "not-applicable" | "present" | "recommended" | "required" | "unknown";
+    remainingGap?: string;
+    status?: VoiceCompetitiveCoverageStatus;
+    surface: string;
+    why: string;
+    nextMove?: string;
+};
+export type VoiceCompetitiveCoverageReportInput = {
+    generatedAt?: string;
+    marketCoverageEstimate?: string;
+    notes?: string[];
+    source?: string;
+    surfaces: VoiceCompetitiveSurface[];
+    vapiCoverageEstimate?: string;
+};
+export type VoiceCompetitiveCoverageSummary = {
+    advantage: number;
+    covered: number;
+    failed: number;
+    intentionalGaps: number;
+    missing: number;
+    parity: number;
+    passed: number;
+    surfaces: number;
+    warned: number;
+};
+export type VoiceCompetitiveCoverageIssue = {
+    code: string;
+    message: string;
+    severity: "error" | "warning";
+    surface?: string;
+};
+export type VoiceCompetitiveCoverageReport = {
+    generatedAt: string;
+    issues: VoiceCompetitiveCoverageIssue[];
+    marketCoverageEstimate: string;
+    notes: string[];
+    ok: boolean;
+    source?: string;
+    status: VoiceCompetitiveCoverageStatus;
+    summary: VoiceCompetitiveCoverageSummary;
+    surfaces: Array<VoiceCompetitiveSurface & {
+        status: VoiceCompetitiveCoverageStatus;
+    }>;
+    vapiCoverageEstimate: string;
+};
+export type VoiceCompetitiveCoverageAssertionInput = {
+    maxFailedSurfaces?: number;
+    maxMissingSurfaces?: number;
+    minAdvantageSurfaces?: number;
+    minSurfaces?: number;
+    requireOperationsRecordLinks?: boolean;
+    requirePass?: boolean;
+    requireReadinessGates?: boolean;
+    requiredEvidence?: string[];
+    requiredSurfaces?: string[];
+};
+export type VoiceCompetitiveCoverageAssertionReport = {
+    advantage: number;
+    failed: number;
+    issues: string[];
+    missing: number;
+    ok: boolean;
+    status: VoiceCompetitiveCoverageStatus;
+    surfaces: string[];
+    total: number;
+};
+export type VoiceCompetitiveCoverageRoutesOptions = {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    markdownPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceCompetitiveCoverageReport) => Promise<string> | string;
+    source: (() => Promise<VoiceCompetitiveCoverageReport | VoiceCompetitiveCoverageReportInput> | VoiceCompetitiveCoverageReport | VoiceCompetitiveCoverageReportInput) | VoiceCompetitiveCoverageReport | VoiceCompetitiveCoverageReportInput;
+    title?: string;
+};
+export declare const assertVoiceCompetitiveCoverage: (report: VoiceCompetitiveCoverageReport, input?: VoiceCompetitiveCoverageAssertionInput) => VoiceCompetitiveCoverageAssertionReport;
+export declare const buildVoiceCompetitiveCoverageReport: (input: VoiceCompetitiveCoverageReportInput) => VoiceCompetitiveCoverageReport;
+export declare const evaluateVoiceCompetitiveCoverage: (report: VoiceCompetitiveCoverageReport, input?: VoiceCompetitiveCoverageAssertionInput) => VoiceCompetitiveCoverageAssertionReport;
+export declare const renderVoiceCompetitiveCoverageHTML: (report: VoiceCompetitiveCoverageReport, title?: string) => string;
+export declare const renderVoiceCompetitiveCoverageMarkdown: (report: VoiceCompetitiveCoverageReport, title?: string) => string;
+export declare const createVoiceCompetitiveCoverageRoutes: (options: VoiceCompetitiveCoverageRoutesOptions) => 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: Response;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/core/conversationSimulator.d.ts

@@ -0,0 +1,73 @@
+import type { VoiceAgent, VoiceAgentRunResult } from "./agent";
+import type { VoiceSessionRecord } from "./types";
+export type VoiceSimulatedSpeaker = "caller" | "agent";
+export type VoiceSimulatedTurn = {
+    role: VoiceSimulatedSpeaker;
+    text: string;
+    at: number;
+};
+export type VoiceSimulatorCallerReply = {
+    text: string;
+    /** When true the synthetic caller ends the call after this utterance. */
+    done?: boolean;
+};
+export type VoiceSimulatorCallerModel = (input: {
+    persona: string;
+    transcript: ReadonlyArray<VoiceSimulatedTurn>;
+    turnIndex: number;
+}) => Promise<VoiceSimulatorCallerReply> | VoiceSimulatorCallerReply;
+export type VoiceSimulatorCaller = {
+    kind: "script";
+    /** Fixed caller utterances, delivered in order. */
+    utterances: ReadonlyArray<string>;
+} | {
+    kind: "model";
+    /** System description of who the caller is and what they want. */
+    persona: string;
+    model: VoiceSimulatorCallerModel;
+    /** Hard cap on caller turns (defaults to maxTurns). */
+    maxCallerTurns?: number;
+};
+export type VoiceConversationSimulationEndedReason = "agent-complete" | "caller-hung-up" | "max-turns" | "script-exhausted";
+export type VoiceConversationSimulationResult<TResult = unknown> = {
+    transcript: VoiceSimulatedTurn[];
+    turnCount: number;
+    endedReason: VoiceConversationSimulationEndedReason;
+    agentResults: VoiceAgentRunResult<TResult>[];
+};
+export type RunVoiceConversationSimulationInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    agent: Pick<VoiceAgent<TContext, TSession, TResult>, "run">;
+    caller: VoiceSimulatorCaller;
+    context?: TContext;
+    session?: TSession;
+    sessionId?: string;
+    /** Hard cap on caller↔agent exchanges (default 12). */
+    maxTurns?: number;
+    /** Stop early when the agent route returns `complete: true` (default true). */
+    stopOnAgentComplete?: boolean;
+    now?: () => number;
+    generateId?: () => string;
+};
+export declare const renderVoiceSimulationTranscript: (transcript: ReadonlyArray<VoiceSimulatedTurn>, labels?: {
+    caller?: string;
+    agent?: string;
+}) => string;
+export declare const runVoiceConversationSimulation: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(input: RunVoiceConversationSimulationInput<TContext, TSession, TResult>) => Promise<VoiceConversationSimulationResult<TResult>>;
+export type VoiceScriptedCallerStep = string;
+/** Convenience: build a deterministic scripted caller from a list of lines. */
+export declare const createScriptedVoiceCaller: (utterances: ReadonlyArray<VoiceScriptedCallerStep>) => VoiceSimulatorCaller;
+export type VoicePersonaCallerCompletion = (input: {
+    prompt: string;
+    systemPrompt: string;
+}) => Promise<string>;
+/**
+ * Builds an LLM-backed synthetic caller. The completion returns the caller's
+ * next line; appending the sentinel `[[END]]` (case-insensitive) signals the
+ * caller wants to hang up.
+ */
+export declare const createPersonaVoiceCaller: (options: {
+    persona: string;
+    completion: VoicePersonaCallerCompletion;
+    maxCallerTurns?: number;
+    endSentinel?: string;
+}) => VoiceSimulatorCaller;

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

@@ -1,5 +1,5 @@
-import type { VoiceCorrectionRiskTier, VoiceDomainTerm, VoiceLexiconEntry, VoicePhraseHint, VoiceTurnCorrectionHandler } from './types';
-export type VoicePhraseHintCorrectionMatch = {
+import type { VoiceCorrectionRiskTier, VoiceDomainTerm, VoiceLexiconEntry, VoicePhraseHint, VoiceTurnCorrectionHandler } from "./types";
+type VoicePhraseHintCorrectionMatch = {
     alias: string;
     hint: VoicePhraseHint;
 };
@@ -18,16 +18,17 @@ export type VoiceDomainHintGenerationOptions = {
 };
 export type VoiceRiskyTurnCorrectionHandlerOptions = VoicePhraseHintCorrectionOptions & {
     maxAverageConfidence?: number;
-    riskTier?: Exclude<VoiceCorrectionRiskTier, 'safe'>;
+    riskTier?: Exclude<VoiceCorrectionRiskTier, "safe">;
 };
 export type VoicePhraseHintCorrectionRunOptions = {
     riskTier?: VoiceCorrectionRiskTier;
 };
 export declare const applyPhraseHintCorrections: (text: string, phraseHints: VoicePhraseHint[]) => VoicePhraseHintCorrectionResult;
 export declare const applyRiskTieredPhraseHintCorrections: (text: string, phraseHints: VoicePhraseHint[], options?: VoicePhraseHintCorrectionRunOptions) => VoicePhraseHintCorrectionResult;
-export declare const createDomainPhraseHints: (terms: VoiceDomainTerm[], options?: VoiceDomainHintGenerationOptions) => VoicePhraseHint[];
 export declare const createDomainLexicon: (terms: VoiceDomainTerm[]) => VoiceLexiconEntry[];
+export declare const createDomainPhraseHints: (terms: VoiceDomainTerm[], options?: VoiceDomainHintGenerationOptions) => VoicePhraseHint[];
 export declare const createPhraseHintCorrectionHandler: (options?: VoicePhraseHintCorrectionOptions) => VoiceTurnCorrectionHandler;
 export declare const applyLexiconCorrections: (text: string, lexicon: VoiceLexiconEntry[]) => VoicePhraseHintCorrectionResult;
 export declare const createLexiconCorrectionHandler: (options?: VoiceLexiconCorrectionOptions) => VoiceTurnCorrectionHandler;
 export declare const createRiskyTurnCorrectionHandler: (options?: VoiceRiskyTurnCorrectionHandlerOptions) => VoiceTurnCorrectionHandler;
+export {};

package/dist/core/costAccounting.d.ts

@@ -0,0 +1,76 @@
+export type VoiceProviderRates = {
+    llm?: {
+        cachedInputPerMillionTokensUsd?: number;
+        inputPerMillionTokensUsd: number;
+        outputPerMillionTokensUsd: number;
+    };
+    stt?: {
+        perSecondUsd: number;
+    };
+    telephony?: {
+        perMinuteUsd: number;
+    };
+    tts?: {
+        perMillionCharactersUsd?: number;
+        perSecondUsd?: number;
+    };
+};
+export type VoicePriceBook = Record<string, VoiceProviderRates>;
+export declare const DEFAULT_VOICE_PRICE_BOOK: VoicePriceBook;
+export type VoiceCostLLMRecord = {
+    cachedInputTokens?: number;
+    inputTokens?: number;
+    model?: string;
+    outputTokens?: number;
+    provider?: string;
+};
+export type VoiceCostTTSRecord = {
+    audioMs?: number;
+    characters?: number;
+    provider?: string;
+    voice?: string;
+};
+export type VoiceCostSTTRecord = {
+    audioMs: number;
+    model?: string;
+    provider?: string;
+};
+export type VoiceCostTelephonyRecord = {
+    minutes: number;
+    provider?: string;
+};
+export type VoiceCostBreakdown = {
+    llm: {
+        cachedInputTokens: number;
+        inputTokens: number;
+        outputTokens: number;
+        usd: number;
+    };
+    sessionId?: string;
+    stt: {
+        audioMs: number;
+        usd: number;
+    };
+    telephony: {
+        minutes: number;
+        usd: number;
+    };
+    totalUsd: number;
+    tts: {
+        audioMs: number;
+        characters: number;
+        usd: number;
+    };
+};
+export type VoiceCostAccountant = {
+    recordLLM: (usage: VoiceCostLLMRecord) => void;
+    recordSTT: (input: VoiceCostSTTRecord) => void;
+    recordTTS: (input: VoiceCostTTSRecord) => void;
+    recordTelephony: (input: VoiceCostTelephonyRecord) => void;
+    snapshot: () => VoiceCostBreakdown;
+};
+export type CreateVoiceCostAccountantOptions = {
+    priceBook?: VoicePriceBook;
+    sessionId?: string;
+};
+export declare const createVoiceCostAccountant: (options?: CreateVoiceCostAccountantOptions) => VoiceCostAccountant;

package/dist/core/costPredictor.d.ts

@@ -0,0 +1,74 @@
+import { type VoicePriceBook } from "./costAccounting";
+export type VoiceCostProfile = {
+    /** Stored callers? Set to true to include caller-memory storage costs (per snapshot, monthly). Default false (we don't model storage here). */
+    includeCallerMemory?: boolean;
+    /** Inbound calls per day. */
+    inboundPerDay?: number;
+    /** Average input tokens per agent turn. */
+    inputTokensPerTurn: number;
+    /** LLM model id used for provider:model price lookup. */
+    llmModel: string;
+    /** LLM provider — must match price book namespace. */
+    llmProvider: string;
+    /** Average minutes per call. */
+    minutesPerCall: number;
+    /** Outbound calls per day. */
+    outboundPerDay?: number;
+    /** Average output tokens per agent turn. */
+    outputTokensPerTurn: number;
+    /** STT model. */
+    sttModel?: string;
+    /** STT provider. */
+    sttProvider?: string;
+    /** Telephony provider key in the price book (e.g. 'twilio', 'telnyx'). */
+    telephonyProvider?: string;
+    /** Total turns per call. */
+    turnsPerCall: number;
+    /** Average TTS characters spoken per agent turn. */
+    ttsCharsPerTurn: number;
+    /** TTS model / voice id. */
+    ttsModel?: string;
+    /** TTS provider. */
+    ttsProvider?: string;
+};
+export type VoiceCostPrediction = {
+    callsPerDay: number;
+    monthly: {
+        llmUsd: number;
+        sttUsd: number;
+        telephonyUsd: number;
+        totalUsd: number;
+        ttsUsd: number;
+    };
+    perCall: {
+        llmUsd: number;
+        sttUsd: number;
+        telephonyUsd: number;
+        totalUsd: number;
+        ttsUsd: number;
+    };
+};
+export type PredictVoiceCallCostInput = {
+    priceBook?: VoicePriceBook;
+    profile: VoiceCostProfile;
+};
+export declare const predictVoiceCallCost: (input: PredictVoiceCallCostInput) => VoiceCostPrediction;
+export type VoiceCostScenarioComparison = {
+    delta: {
+        monthlyUsd: number;
+        perCallUsd: number;
+    };
+    prediction: VoiceCostPrediction;
+    scenarioId: string;
+};
+export declare const compareVoiceCostScenarios: (input: {
+    baselineId: string;
+    priceBook?: VoicePriceBook;
+    scenarios: ReadonlyArray<{
+        id: string;
+        profile: VoiceCostProfile;
+    }>;
+}) => {
+    baseline: VoiceCostPrediction;
+    scenarios: VoiceCostScenarioComparison[];
+};

package/dist/core/crmCallLogger.d.ts

@@ -0,0 +1,37 @@
+import type { VoiceCRMContract } from "./crmContract";
+export type VoiceCRMCallLoggerInput = {
+    sessionId: string;
+    contactId?: string;
+    startedAt: number;
+    endedAt?: number;
+    durationSeconds?: number;
+    summary?: string;
+    disposition?: string;
+    recordingUrl?: string;
+    transcriptUrl?: string;
+    metadata?: Record<string, unknown>;
+};
+export type VoiceCRMCallLogResult = {
+    activityId: string;
+    vendor: string;
+    loggedAt: number;
+};
+export type VoiceCRMCallLogErrorPolicy = "throw" | "swallow" | "queue";
+export type CreateVoiceCRMCallLoggerOptions = {
+    contract: VoiceCRMContract;
+    errorPolicy?: VoiceCRMCallLogErrorPolicy;
+    onError?: (error: Error, input: VoiceCRMCallLoggerInput) => void | Promise<void>;
+    enqueueOnFailure?: (input: VoiceCRMCallLoggerInput) => Promise<void> | void;
+    now?: () => number;
+};
+export declare const createVoiceCRMCallLogger: (options: CreateVoiceCRMCallLoggerOptions) => {
+    contract: VoiceCRMContract;
+    logCallEnd: (input: VoiceCRMCallLoggerInput) => Promise<VoiceCRMCallLogResult | null>;
+    noteOnContact: (input: {
+        contactId: string;
+        body: string;
+    }) => Promise<{
+        noteId: string;
+    } | null>;
+};
+export type VoiceCRMCallLogger = ReturnType<typeof createVoiceCRMCallLogger>;

package/dist/core/crmContract.d.ts

@@ -0,0 +1,70 @@
+export type VoiceCRMContactSummary = {
+    id: string;
+    vendor?: string;
+    firstName?: string;
+    lastName?: string;
+    email?: string;
+    phone?: string;
+    jobTitle?: string;
+    metadata?: Record<string, unknown>;
+};
+export type VoiceCRMLeadInput = {
+    firstName?: string;
+    lastName?: string;
+    email?: string;
+    phone?: string;
+    company?: string;
+    jobTitle?: string;
+    source?: string;
+    notes?: string;
+    metadata?: Record<string, unknown>;
+};
+export type VoiceCRMCallActivityInput = {
+    contactId?: string;
+    sessionId: string;
+    startedAt: number;
+    endedAt: number;
+    durationSeconds: number;
+    summary?: string;
+    disposition?: string;
+    recordingUrl?: string;
+    transcriptUrl?: string;
+    metadata?: Record<string, unknown>;
+};
+export type VoiceCRMNoteInput = {
+    contactId: string;
+    body: string;
+    metadata?: Record<string, unknown>;
+};
+export type VoiceCRMTaskInput = {
+    contactId?: string;
+    subject: string;
+    description?: string;
+    dueAt?: number;
+    priority?: "low" | "normal" | "high";
+};
+export type VoiceCRMContract = {
+    readonly vendor: string;
+    lookupByPhone(phone: string): Promise<VoiceCRMContactSummary | null>;
+    lookupByEmail(email: string): Promise<VoiceCRMContactSummary | null>;
+    createLead(input: VoiceCRMLeadInput): Promise<VoiceCRMContactSummary>;
+    logCall(input: VoiceCRMCallActivityInput): Promise<{
+        activityId: string;
+    }>;
+    addNote(input: VoiceCRMNoteInput): Promise<{
+        noteId: string;
+    }>;
+    createTask?(input: VoiceCRMTaskInput): Promise<{
+        taskId: string;
+    }>;
+};
+export type VoiceCRMRegistry = {
+    default(): VoiceCRMContract | null;
+    get(vendor: string): VoiceCRMContract | null;
+    list(): VoiceCRMContract[];
+};
+export type CreateVoiceCRMRegistryOptions = {
+    contracts: VoiceCRMContract[];
+    defaultVendor?: string;
+};
+export declare const createVoiceCRMRegistry: (options: CreateVoiceCRMRegistryOptions) => VoiceCRMRegistry;