@absolutejs/voice 0.0.22-beta.51 → 0.0.22-beta.511

package/dist/client/voiceWidgetView.d.ts

@@ -0,0 +1,50 @@
+import type { VoiceAgentUIState } from "../agentState";
+import type { VoiceControllerState } from "../types";
+export type VoiceWidgetTheme = {
+    accent?: string;
+    background?: string;
+    errorAccent?: string;
+    fontFamily?: string;
+    foreground?: string;
+    radius?: number | string;
+};
+export type VoiceWidgetLabels = {
+    callEnded?: string;
+    connecting?: string;
+    endCall?: string;
+    idle?: string;
+    listening?: string;
+    mute?: string;
+    speaking?: string;
+    startCall?: string;
+    thinking?: string;
+    unmute?: string;
+};
+export type VoiceWidgetViewModelInput = {
+    labels?: VoiceWidgetLabels;
+    state: Pick<VoiceControllerState, "assistantAudio" | "error" | "isConnected" | "isRecording" | "partial" | "status" | "turns">;
+    theme?: VoiceWidgetTheme;
+    title?: string;
+};
+export type VoiceWidgetViewModel = {
+    agentState: VoiceAgentUIState;
+    classes: {
+        container: string;
+        dot: string;
+    };
+    controls: {
+        canEnd: boolean;
+        canMute: boolean;
+        canStart: boolean;
+    };
+    errorMessage?: string;
+    labels: Required<VoiceWidgetLabels>;
+    partial?: string;
+    statusLabel: string;
+    theme: Required<VoiceWidgetTheme>;
+    title: string;
+};
+export declare const DEFAULT_VOICE_WIDGET_THEME: Required<VoiceWidgetTheme>;
+export declare const DEFAULT_VOICE_WIDGET_LABELS: Required<VoiceWidgetLabels>;
+export declare const createVoiceWidgetViewModel: (input: VoiceWidgetViewModelInput) => VoiceWidgetViewModel;
+export declare const renderVoiceWidgetHTML: (model: VoiceWidgetViewModel) => string;

package/dist/client/workflowStatus.d.ts

@@ -1,4 +1,4 @@
-import type { VoiceScenarioEvalReport } from '../evalRoutes';
+import type { VoiceScenarioEvalReport } from "../evalRoutes";
 export type VoiceWorkflowStatusClientOptions = {
     fetch?: typeof fetch;
     intervalMs?: number;

package/dist/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 buildVoiceCompetitiveCoverageReport: (input: VoiceCompetitiveCoverageReportInput) => VoiceCompetitiveCoverageReport;
+export declare const evaluateVoiceCompetitiveCoverage: (report: VoiceCompetitiveCoverageReport, input?: VoiceCompetitiveCoverageAssertionInput) => VoiceCompetitiveCoverageAssertionReport;
+export declare const assertVoiceCompetitiveCoverage: (report: VoiceCompetitiveCoverageReport, input?: VoiceCompetitiveCoverageAssertionInput) => VoiceCompetitiveCoverageAssertionReport;
+export declare const renderVoiceCompetitiveCoverageMarkdown: (report: VoiceCompetitiveCoverageReport, title?: string) => string;
+export declare const renderVoiceCompetitiveCoverageHTML: (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/correction.d.ts

@@ -1,4 +1,4 @@
-import type { VoiceCorrectionRiskTier, VoiceDomainTerm, VoiceLexiconEntry, VoicePhraseHint, VoiceTurnCorrectionHandler } from './types';
+import type { VoiceCorrectionRiskTier, VoiceDomainTerm, VoiceLexiconEntry, VoicePhraseHint, VoiceTurnCorrectionHandler } from "./types";
 export type VoicePhraseHintCorrectionMatch = {
     alias: string;
     hint: VoicePhraseHint;
@@ -18,7 +18,7 @@ export type VoiceDomainHintGenerationOptions = {
 };
 export type VoiceRiskyTurnCorrectionHandlerOptions = VoicePhraseHintCorrectionOptions & {
     maxAverageConfidence?: number;
-    riskTier?: Exclude<VoiceCorrectionRiskTier, 'safe'>;
+    riskTier?: Exclude<VoiceCorrectionRiskTier, "safe">;
 };
 export type VoicePhraseHintCorrectionRunOptions = {
     riskTier?: VoiceCorrectionRiskTier;

package/dist/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/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/dataControl.d.ts

@@ -0,0 +1,180 @@
+import type { VoiceCampaignStore } from "./campaign";
+import { Elysia } from "elysia";
+import { type VoiceAuditActor, type VoiceAuditEventFilter, type VoiceAuditEventStore } from "./audit";
+import { exportVoiceAuditTrail } from "./auditExport";
+import type { VoiceAuditSinkDeliveryStore } from "./auditSinks";
+import type { VoiceIntegrationEventStore, VoiceOpsTaskStore } from "./ops";
+import type { VoiceIncidentBundleStore } from "./incidentBundle";
+import type { VoiceCallReviewStore } from "./testing/review";
+import type { VoiceTraceEventStore, VoiceTracePruneFilter, VoiceTraceSinkDeliveryStore } from "./trace";
+import type { VoiceSessionStore } from "./types";
+export declare const voiceComplianceRedactionDefaults: {
+    keys: string[];
+    redactEmails: true;
+    redactPhoneNumbers: true;
+};
+export type VoiceDataRetentionScope = "auditDeliveries" | "campaigns" | "events" | "incidentBundles" | "reviews" | "sessions" | "tasks" | "traceDeliveries" | "traces";
+export type VoiceDataRetentionStores = {
+    campaigns?: VoiceCampaignStore;
+    events?: VoiceIntegrationEventStore;
+    incidentBundles?: VoiceIncidentBundleStore;
+    reviews?: VoiceCallReviewStore;
+    session?: VoiceSessionStore;
+    sessions?: VoiceSessionStore;
+    tasks?: VoiceOpsTaskStore;
+    traceDeliveries?: VoiceTraceSinkDeliveryStore;
+    traces?: VoiceTraceEventStore;
+};
+export type VoiceDataRetentionPolicy = VoiceDataRetentionStores & {
+    audit?: VoiceAuditEventStore;
+    auditDeliveries?: VoiceAuditSinkDeliveryStore;
+    auditActor?: VoiceAuditActor;
+    before?: number;
+    beforeOrAt?: number;
+    dryRun?: boolean;
+    keepNewest?: Partial<Record<VoiceDataRetentionScope, number>>;
+    limit?: number;
+    scopes?: VoiceDataRetentionScope[];
+    traceFilter?: VoiceTracePruneFilter;
+};
+export type VoiceDataRetentionScopeReport = {
+    deletedIds: string[];
+    deletedCount: number;
+    dryRun: boolean;
+    keepNewest?: number;
+    scannedCount: number;
+    scope: VoiceDataRetentionScope;
+    skippedReason?: "missing-store" | "missing-selector";
+};
+export type VoiceDataRetentionReport = {
+    checkedAt: number;
+    deletedCount: number;
+    dryRun: boolean;
+    scopes: VoiceDataRetentionScopeReport[];
+};
+export type VoiceDataControlStorageSurface = {
+    configured: boolean;
+    control: "audit" | "artifact" | "queue" | "session" | "workflow";
+    name: string;
+    selfHosted: boolean;
+};
+export type VoiceDataControlProviderKeySurface = {
+    env?: string;
+    name: string;
+    recommendation: string;
+    required: boolean;
+};
+export type VoiceDataControlReport = {
+    auditExport?: Awaited<ReturnType<typeof exportVoiceAuditTrail>>;
+    checkedAt: number;
+    deletionProof?: VoiceDataRetentionReport;
+    redaction: {
+        defaults: typeof voiceComplianceRedactionDefaults;
+        enabled: boolean;
+    };
+    retentionPlan: VoiceDataRetentionReport;
+    storage: VoiceDataControlStorageSurface[];
+    providerKeys: VoiceDataControlProviderKeySurface[];
+    zeroRetentionAvailable: boolean;
+};
+export type VoiceDataControlAssertionInput = {
+    maxDeletionDeleted?: number;
+    maxMissingConfiguredStorage?: number;
+    maxMissingSelfHostedStorage?: number;
+    maxRetentionDeleted?: number;
+    minAuditExportEvents?: number;
+    minConfiguredStorage?: number;
+    minProviderKeys?: number;
+    requiredControls?: VoiceDataControlStorageSurface["control"][];
+    requiredDeletionScopes?: VoiceDataRetentionScope[];
+    requiredProviderKeys?: string[];
+    requiredRetentionScopes?: VoiceDataRetentionScope[];
+    requiredStorage?: string[];
+    requireAuditExport?: boolean;
+    requireDeletionDryRun?: boolean;
+    requireDeletionProof?: boolean;
+    requireRedaction?: boolean;
+    requireRetentionDryRun?: boolean;
+    requireSelfHostedStorage?: boolean;
+    requireZeroRetentionAvailable?: boolean;
+};
+export type VoiceDataControlAssertionReport = {
+    auditExportEvents: number;
+    configuredStorage: string[];
+    controls: VoiceDataControlStorageSurface["control"][];
+    deletionDeleted: number;
+    deletionDryRun?: boolean;
+    deletionScopes: VoiceDataRetentionScope[];
+    issues: string[];
+    ok: boolean;
+    providerKeys: string[];
+    redactionEnabled: boolean;
+    retentionDeleted: number;
+    retentionDryRun: boolean;
+    retentionScopes: VoiceDataRetentionScope[];
+    selfHostedConfiguredStorage: string[];
+    zeroRetentionAvailable: boolean;
+};
+export type VoiceDataControlRoutesOptions = VoiceDataRetentionStores & {
+    audit?: VoiceAuditEventStore;
+    auditActor?: VoiceAuditActor;
+    auditDeliveries?: VoiceAuditSinkDeliveryStore;
+    headers?: HeadersInit;
+    name?: string;
+    path?: string;
+    providerKeys?: VoiceDataControlProviderKeySurface[];
+    redact?: import("./trace").VoiceTraceRedactionConfig | boolean;
+    title?: string;
+    traceDeliveries?: VoiceTraceSinkDeliveryStore;
+};
+export declare const applyVoiceDataRetentionPolicy: (options: VoiceDataRetentionPolicy) => Promise<VoiceDataRetentionReport>;
+export declare const buildVoiceDataRetentionPlan: (options: Omit<VoiceDataRetentionPolicy, "dryRun">) => Promise<VoiceDataRetentionReport>;
+export declare const evaluateVoiceDataControlEvidence: (report: VoiceDataControlReport, input?: VoiceDataControlAssertionInput) => VoiceDataControlAssertionReport;
+export declare const assertVoiceDataControlEvidence: (report: VoiceDataControlReport, input?: VoiceDataControlAssertionInput) => VoiceDataControlAssertionReport;
+export declare const createVoiceZeroRetentionPolicy: (options: VoiceDataRetentionStores & {
+    audit?: VoiceAuditEventStore;
+    auditActor?: VoiceAuditActor;
+    auditDeliveries?: VoiceAuditSinkDeliveryStore;
+    beforeOrAt?: number;
+    dryRun?: boolean;
+    scopes?: VoiceDataRetentionScope[];
+    traceDeliveries?: VoiceTraceSinkDeliveryStore;
+}) => VoiceDataRetentionPolicy;
+export declare const buildVoiceDataControlReport: (options: VoiceDataControlRoutesOptions & {
+    auditFilter?: VoiceAuditEventFilter;
+    retention?: Omit<VoiceDataRetentionPolicy, "dryRun">;
+}) => Promise<VoiceDataControlReport>;
+export declare const renderVoiceDataControlHTML: (report: VoiceDataControlReport, options?: {
+    title?: string;
+}) => string;
+export declare const renderVoiceDataControlMarkdown: (report: VoiceDataControlReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceDataControlRoutes: (options: VoiceDataControlRoutesOptions) => 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/defineVoiceAssistant.d.ts

@@ -0,0 +1,68 @@
+import { type VoiceAssistant, type VoiceAssistantAgentSource, type VoiceAssistantGuardrails, type VoiceAssistantMemoryLifecycle } from "./assistant";
+import type { AudioFormat, CreateVoiceSessionOptions, RealtimeAdapter, STTAdapter, TTSAdapter, VoiceLanguageStrategy, VoiceLexiconEntry, VoicePhraseHint, VoiceReconnectConfig, VoiceResolvedSTTFallbackConfig, VoiceResolvedAudioConditioningConfig, VoiceRouteConfig, VoiceSessionRecord, VoiceSessionRecordingConfig, VoiceSessionStore, VoiceSocket, VoiceSTTLifecycle, VoiceTTSProsody, VoiceTurnDetectionConfig } from "./types";
+import type { VoiceAssistantMemoryOptions } from "./assistantMemory";
+import type { VoiceAgentTool } from "./agent";
+import type { VoiceAMDDetector } from "./amdDetector";
+import type { VoiceCostAccountant } from "./costAccounting";
+import type { VoiceTraceEventStore } from "./trace";
+import type { VoiceTranscriptRedactor } from "./redaction";
+import type { VoiceSemanticTurnDetector } from "./semanticTurn";
+import type { VoiceAssistantMode } from "./assistantMode";
+import type { VoiceRuntimeOpsConfig } from "./types";
+export type VoiceAssistantVoiceConfig = {
+    prosody?: VoiceTTSProsody;
+    realtime?: RealtimeAdapter;
+    realtimeInputFormat?: AudioFormat;
+    stt?: STTAdapter;
+    sttFallback?: VoiceResolvedSTTFallbackConfig;
+    tts?: TTSAdapter;
+};
+export type VoiceAssistantObservabilityConfig = {
+    costAccountant?: VoiceCostAccountant;
+    costTelephony?: {
+        provider?: string;
+    };
+    recording?: VoiceSessionRecordingConfig;
+    trace?: VoiceTraceEventStore;
+};
+export type VoiceAssistantDefinition<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    agent: VoiceAssistantAgentSource<TContext, TSession, TResult>;
+    amd?: VoiceAMDDetector<TContext, TSession, TResult>;
+    assistantMode?: VoiceAssistantMode;
+    audioConditioning?: VoiceResolvedAudioConditioningConfig;
+    callSilenceTimeoutMs?: number;
+    guardrails?: VoiceAssistantGuardrails<TContext, TSession, TResult>;
+    id: string;
+    languageStrategy?: VoiceLanguageStrategy;
+    lexicon?: VoiceLexiconEntry[];
+    memory?: VoiceAssistantMemoryOptions<TContext, TSession>;
+    memoryLifecycle?: VoiceAssistantMemoryLifecycle<TContext, TSession, TResult>;
+    metadata?: Record<string, unknown>;
+    modalities?: ReadonlyArray<"audio" | "text">;
+    ops?: VoiceRuntimeOpsConfig<TContext, TSession, TResult>;
+    observability?: VoiceAssistantObservabilityConfig;
+    phraseHints?: VoicePhraseHint[];
+    redact?: VoiceTranscriptRedactor;
+    route?: Partial<VoiceRouteConfig<TContext, TSession, TResult>>;
+    semanticTurnDetector?: VoiceSemanticTurnDetector;
+    tools?: ReadonlyArray<VoiceAgentTool<TContext, TSession, Record<string, unknown>, unknown, TResult>>;
+    turnDetection?: VoiceTurnDetectionConfig;
+    voice: VoiceAssistantVoiceConfig;
+};
+export type VoiceAssistantSessionInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
+    context: TContext;
+    id: string;
+    reconnect?: Partial<VoiceReconnectConfig>;
+    scenarioId?: string;
+    sessionMetadata?: Record<string, unknown>;
+    socket: VoiceSocket;
+    sttLifecycle?: VoiceSTTLifecycle;
+    store: VoiceSessionStore<TSession>;
+};
+export type DefinedVoiceAssistant<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    assistant: VoiceAssistant<TContext, TSession, TResult>;
+    definition: VoiceAssistantDefinition<TContext, TSession, TResult>;
+    id: string;
+    toSessionOptions: (input: VoiceAssistantSessionInput<TContext, TSession>) => CreateVoiceSessionOptions<TContext, TSession, TResult>;
+};
+export declare const defineVoiceAssistant: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(definition: VoiceAssistantDefinition<TContext, TSession, TResult>) => DefinedVoiceAssistant<TContext, TSession, TResult>;