@superpanel-sdk/runtime 0.0.1-internal.1

package/dist/voice-service/types.d.ts

@@ -0,0 +1,1010 @@
+export interface IMessage {
+    role: IRole;
+    content: string;
+}
+export type STTProvider = 'deepgram-flux' | 'deepgram' | 'aws-transcribe' | 'elevenlabs-stt';
+export type TTSProvider = 'cartesia' | 'elevenlabs' | 'elevenlabs-http' | 'inworld' | 'fish';
+export interface DeepgramFluxSttConfig {
+    apiKey: string;
+    /**
+     * - `flux-general-en`: English-only model.
+     * - `flux-general-multi`: Multilingual model. Required when using `languageHints`.
+     */
+    model: 'flux-general-en' | 'flux-general-multi';
+    encoding?: 'linear16' | 'linear32' | 'mulaw' | 'alaw' | 'opus' | 'ogg-opus';
+    sampleRate?: number;
+    eagerEotThreshold?: number;
+    eotThreshold?: number;
+    eotTimeoutMs?: number;
+    keyterms?: string[];
+    mipOptOut?: boolean;
+    tag?: string;
+    /**
+     * BCP-47 language codes biasing the multilingual model toward specific languages.
+     *
+     * Only valid with `model: 'flux-general-multi'` — sending hints with `flux-general-en`
+     * returns HTTP 400 from Deepgram.
+     *
+     * Behavior:
+     * - Omit / empty: auto-detect (model picks language per turn).
+     * - Single code: locks to that language (accuracy on par with a dedicated monolingual model).
+     * - Multiple codes: biases toward this candidate set (best for known multi-language calls).
+     *
+     * Supported languages (10):
+     *   en (English), es (Spanish), fr (French), de (German), hi (Hindi),
+     *   ru (Russian), pt (Portuguese), ja (Japanese), it (Italian), nl (Dutch).
+     *
+     * Locale subtags like `en-GB` or `pt-BR` are accepted and fall back to the base code.
+     */
+    languageHints?: string[];
+    reconnectAttempts?: number;
+    reconnectDelay?: number;
+    minBufferDurationMs?: number;
+}
+export interface DeepgramApiConfig {
+    model?: 'nova-3' | 'nova-3-general' | 'nova-3-medical' | 'nova-2' | 'nova-2-general' | 'nova-2-automotive' | 'nova' | 'nova-general' | 'nova-phonecall' | 'nova-medical' | 'enhanced' | 'enhanced-general' | 'enhanced-meeting' | 'enhanced-phonecall' | 'enhanced-finance' | 'base' | 'meeting' | 'phonecall' | 'finance' | 'conversationalai' | 'voicemail' | 'video' | 'custom';
+    encoding?: 'linear16' | 'linear32' | 'flac' | 'alaw' | 'mulaw' | 'amr-nb' | 'amr-wb' | 'opus' | 'ogg-opus' | 'speex' | 'g729';
+    sample_rate?: any;
+    channels?: any;
+    language?: any;
+    version?: any;
+    interim_results?: 'true' | 'false';
+    punctuate?: 'true' | 'false';
+    profanity_filter?: 'true' | 'false';
+    redact?: 'true' | 'false' | 'pci' | 'numbers' | 'aggressive_numbers' | 'ssn';
+    diarize?: 'true' | 'false';
+    multichannel?: 'true' | 'false';
+    smart_format?: 'true' | 'false';
+    numerals?: 'true' | 'false';
+    dictation?: 'true' | 'false';
+    utterance_end_ms?: any;
+    vad_events?: 'true' | 'false';
+    endpointing?: any;
+    keywords?: any;
+    keyterm?: any;
+    search?: any;
+    replace?: any;
+    callback?: any;
+    callback_method?: 'POST' | 'GET' | 'PUT' | 'DELETE';
+    tag?: any;
+    extra?: any;
+    mip_opt_out?: any;
+}
+export interface DeepgramSttConfig extends DeepgramApiConfig {
+    reconnectAttempts?: number;
+    reconnectDelay?: number;
+    apiKey: string;
+}
+export interface AwsTranscribeSttConfig {
+    region: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    languageCode?: 'en-US' | 'en-GB' | 'en-AU' | 'es-US' | 'es-ES' | 'fr-FR' | 'fr-CA' | 'de-DE' | 'it-IT' | 'ja-JP' | 'ko-KR' | 'pt-BR' | 'zh-CN' | 'th-TH' | 'ar-SA' | 'pt-PT' | 'ca-ES' | 'ar-AE' | 'hi-IN' | 'zh-HK' | 'nl-NL' | 'no-NO' | 'sv-SE' | 'pl-PL' | 'fi-FI' | 'zh-TW' | 'en-IN' | 'en-IE' | 'en-NZ' | 'en-AB' | 'en-ZA' | 'en-WL' | 'de-CH' | 'af-ZA' | 'eu-ES' | 'hr-HR' | 'cs-CZ' | 'da-DK' | 'fa-IR' | 'gl-ES' | 'el-GR' | 'he-IL' | 'id-ID' | 'lv-LV' | 'ms-MY' | 'ro-RO' | 'ru-RU' | 'sr-RS' | 'sk-SK' | 'so-SO' | 'tl-PH' | 'uk-UA' | 'vi-VN' | 'zu-ZA';
+    mediaSampleRateHertz?: number;
+    vocabularyName?: string;
+    vocabularyNames?: string;
+    vocabularyFilterName?: string;
+    vocabularyFilterNames?: string;
+    vocabularyFilterMethod?: 'remove' | 'mask' | 'tag';
+    showSpeakerLabel?: boolean;
+    enableChannelIdentification?: boolean;
+    numberOfChannels?: number;
+    enablePartialResultsStabilization?: boolean;
+    partialResultsStability?: 'high' | 'medium' | 'low';
+    sessionId?: string;
+    languageModelName?: string;
+    identifyLanguage?: boolean;
+    identifyMultipleLanguages?: boolean;
+    languageOptions?: string;
+    preferredLanguage?: string;
+    contentIdentificationType?: 'PII';
+    contentRedactionType?: 'PII';
+    piiEntityTypes?: string;
+    reconnectAttempts?: number;
+    reconnectDelay?: number;
+}
+export type ElevenLabsSttAudioFormat = 'pcm_8000' | 'pcm_16000' | 'pcm_22050' | 'pcm_24000' | 'pcm_44100' | 'pcm_48000' | 'ulaw_8000';
+export type ElevenLabsSttCommitStrategy = 'manual' | 'vad';
+export interface ElevenLabsSttConfig {
+    apiKey: string;
+    modelId?: string;
+    audioFormat?: ElevenLabsSttAudioFormat;
+    languageCode?: string;
+    commitStrategy?: ElevenLabsSttCommitStrategy;
+    vadSilenceThresholdSecs?: number;
+    vadThreshold?: number;
+    minSpeechDurationMs?: number;
+    minSilenceDurationMs?: number;
+    enableLogging?: boolean;
+    includeTimestamps?: boolean;
+    includeLanguageDetection?: boolean;
+    reconnectAttempts?: number;
+    reconnectDelay?: number;
+}
+export interface GoogleLLMConfig {
+    model?: 'gemini-2.5-flash' | 'gemini-2.5-flash-lite';
+    maxTokens?: number;
+    temperature?: number;
+    systemPrompt?: string;
+}
+export interface CartesiaTTSConfig {
+    apiKey: string;
+    cartesiaVersion: '2024-06-10' | '2024-11-13' | '2025-04-16';
+    reconnectAttempts: number;
+    reconnectDelay: number;
+    model_id: string;
+    voice: {
+        mode: string;
+        id: string;
+    };
+    generation_config?: {
+        volume?: number;
+        speed?: number;
+        emotion?: string;
+    };
+    output_format: {
+        container: 'raw' | 'wav' | 'mp3' | 'flac';
+        encoding: 'pcm_s16le' | 'pcm_f32le' | 'pcm_mulaw' | 'pcm_alaw';
+        sample_rate: number;
+    };
+    language?: string;
+    max_buffer_delay_ms?: number;
+    add_timestamps?: boolean;
+    add_phoneme_timestamps?: boolean;
+    use_normalized_timestamps?: boolean;
+    pronunciation_dict_id?: string;
+    emotion?: string;
+}
+export interface ElevenLabsHttpTTSConfig {
+    apiKey: string;
+    voice_id: string;
+    /**
+     * When false, request runs in zero-retention mode (no history features).
+     * Enterprise-only when set to false. Defaults to ElevenLabs default (true).
+     */
+    enable_logging?: boolean;
+    /**
+     * 0 = default mode (no latency optimizations)
+     * 1 = normal latency optimizations
+     * 2 = strong latency optimizations
+     * 3 = max latency optimizations
+     * 4 = max latency optimizations + text normalizer disabled
+     */
+    optimize_streaming_latency?: 0 | 1 | 2 | 3 | 4;
+    /**
+     * Output audio container/codec/sample_rate/bitrate.
+     * Defaults to mp3_44100_128 on the server side.
+     */
+    output_format?: 'mp3_22050_32' | 'mp3_24000_48' | 'mp3_44100_32' | 'mp3_44100_64' | 'mp3_44100_96' | 'mp3_44100_128' | 'mp3_44100_192' | 'pcm_8000' | 'pcm_16000' | 'pcm_22050' | 'pcm_24000' | 'pcm_32000' | 'pcm_44100' | 'pcm_48000' | 'ulaw_8000' | 'alaw_8000' | 'opus_48000_32' | 'opus_48000_64' | 'opus_48000_96' | 'opus_48000_128' | 'opus_48000_192';
+    /** Defaults to 'eleven_multilingual_v2' on the server side. */
+    model_id?: string;
+    /** ISO 639-1 language code; errors if the model does not support it. */
+    language_code?: string;
+    voice_settings?: {
+        /** [0,1] - lower = more emotional range, higher = more monotonous (default 0.5) */
+        stability?: number;
+        /** [0,1] - how closely to adhere to the original voice (default 0.75) */
+        similarity_boost?: number;
+        /** [0,1] - style exaggeration; non-zero adds latency (default 0) */
+        style?: number;
+        /** Slightly higher latency when true (default true) */
+        use_speaker_boost?: boolean;
+        /** Speech speed multiplier (default 1) */
+        speed?: number;
+    };
+    pronunciation_dictionary_locators?: Array<{
+        pronunciation_dictionary_id: string;
+        version_id: string;
+    }>;
+    /** Best-effort deterministic sampling. Integer in [0, 4294967295]. */
+    seed?: number;
+    /** Improves continuity when concatenating with prior generation. */
+    previous_text?: string;
+    /** Improves continuity when concatenating with next generation. */
+    next_text?: string;
+    /** Up to 3 previous request_ids. Takes precedence over `previous_text`. */
+    previous_request_ids?: string[];
+    /** Up to 3 next request_ids. Takes precedence over `next_text`. */
+    next_request_ids?: string[];
+    /** Force IVC voice instead of PVC version (default false). */
+    use_pvc_as_ivc?: boolean;
+    /** Text normalization mode (default 'auto'). */
+    apply_text_normalization?: 'auto' | 'on' | 'off';
+    /**
+     * Language-specific text normalization (e.g. Japanese).
+     * Heavy latency cost. Default false.
+     */
+    apply_language_text_normalization?: boolean;
+    /**
+     * HTTP request timeout in milliseconds. 0 / undefined disables it.
+     */
+    requestTimeoutMs?: number;
+}
+export interface ElevenLabsTTSConfig {
+    apiKey: string;
+    reconnectAttempts: number;
+    reconnectDelay: number;
+    voice_id: string;
+    model_id?: string;
+    voice_settings?: {
+        stability?: number;
+        similarity_boost?: number;
+        style?: number;
+        use_speaker_boost?: boolean;
+        speed?: number;
+    };
+    generation_config?: {
+        chunk_length_schedule?: number[];
+    };
+    pronunciation_dictionary_locators?: Array<{
+        pronunciation_dictionary_id: string;
+        version_id: string;
+    }>;
+    language_code?: string;
+    output_format?: 'mp3_22050_32' | 'mp3_44100_32' | 'mp3_44100_64' | 'mp3_44100_96' | 'mp3_44100_128' | 'mp3_44100_192' | 'pcm_8000' | 'pcm_16000' | 'pcm_22050' | 'pcm_24000' | 'pcm_44100' | 'ulaw_8000' | 'alaw_8000' | 'opus_48000_32' | 'opus_48000_64' | 'opus_48000_96' | 'opus_48000_128' | 'opus_48000_192';
+    enable_logging?: boolean;
+    enable_ssml_parsing?: boolean;
+    optimize_streaming_latency?: number;
+    apply_text_normalization?: 'auto' | 'on' | 'off';
+    sync_alignment?: boolean;
+    auto_mode?: boolean;
+    inactivity_timeout?: number;
+    seed?: number;
+}
+export interface InworldTTSConfig {
+    apiKey: string;
+    voiceId: string;
+    modelId: string;
+    reconnectAttempts?: number;
+    reconnectDelay?: number;
+    audioConfig?: {
+        audioEncoding?: 'LINEAR16' | 'MP3' | 'OGG_OPUS' | 'ALAW' | 'MULAW';
+        sampleRateHertz?: number;
+        bitRate?: number;
+        speakingRate?: number;
+    };
+    temperature?: number;
+    bufferCharThreshold?: number;
+    maxBufferDelayMs?: number;
+    autoMode?: boolean;
+    applyTextNormalization?: 'APPLY_TEXT_NORMALIZATION_UNSPECIFIED' | 'ON' | 'OFF';
+    timestampType?: 'TIMESTAMP_TYPE_UNSPECIFIED' | 'WORD' | 'CHARACTER';
+    timestampTransportStrategy?: 'TIMESTAMP_TRANSPORT_STRATEGY_UNSPECIFIED' | 'SYNC' | 'ASYNC';
+}
+export interface FishTTSConfig {
+    apiKey: string;
+    model: 's1' | 's2-pro';
+    format: 'pcm';
+    sample_rate: 8000;
+    latency: 'low' | 'normal' | 'balanced';
+    reference_id?: string | string[] | null;
+    references?: unknown;
+    prosody?: {
+        speed?: number;
+        volume?: number;
+        normalize_loudness?: boolean;
+    } | null;
+    temperature?: number;
+    top_p?: number;
+    max_new_tokens?: number;
+    repetition_penalty?: number;
+    min_chunk_length?: number;
+    chunk_length?: number;
+    condition_on_previous_chunks?: boolean;
+    normalize?: boolean;
+    early_stop_threshold?: number;
+    mp3_bitrate?: 64 | 128 | 192;
+    opus_bitrate?: -1000 | 24 | 32 | 48 | 64;
+}
+export interface AssistantConfig {
+    minNumberOfWordsToInterrupt: number;
+    interruptProtectionMs: number;
+    endSpeakTimeoutMs: number;
+    sttProvider: STTProvider;
+    ttsProvider: TTSProvider;
+    goodbyePatterns: string[];
+    defaultTransferingMessage: string;
+    defaultTransferFailedMessage: string;
+    shuttingDownMessage: string;
+    warmTransferPrompt: string;
+    endOfTurnPrompt: string;
+    endOfTurnLlmEnable: boolean;
+    llmFastResponseEnable: boolean;
+    outboundCallFirstSayDelayMs: number;
+}
+export interface VoiceMailConfig {
+    ignoreInFirstTimeMs: number;
+    maxRegexAnalysisRounds: number;
+    regexPatterns: string[];
+    reply?: string;
+    voiceMailSpeakTimeoutMs: number;
+    voiceMailAutoHangupDelayMs: number;
+    voiceMailPrompt?: string;
+}
+export interface UserSilenceConfig {
+    silenceTimeoutMs: number[];
+    maxSilenceCount: number;
+    responseMessages: string[];
+    sendSilenceSignalInMs: number;
+    silenceSignalResponseTimeoutMs: number;
+    maxContinueSilenceSignalCount: number;
+}
+export interface ConversationConfig {
+    enabled?: boolean;
+    autoSave?: boolean;
+}
+export interface SoundEffectConfig {
+    enabled: boolean;
+    volume: number;
+}
+export interface SoundConfig {
+    mainBackground: SoundEffectConfig;
+    mainBackgroundMusicURL?: string;
+    thinkSound: SoundEffectConfig;
+}
+export interface AudioStreamConfig {
+    pushIntervalMs?: number;
+}
+export type TransferType = 'cold' | 'warm' | 'async-warm';
+export type FallbackAction = 'end-call' | 'restore-normal-call-state';
+export interface AsyncWarmTransferBridgeConfig {
+    targetSayTemplate?: string;
+    customerSayTemplate?: string;
+}
+export interface LoopConfirmConfig {
+    confirmTimeoutMs: number;
+    pauseAfterSayMs: number;
+    loopSayText: string;
+    fallbackAction: FallbackAction;
+}
+export interface TransferConfig extends LoopConfirmConfig {
+    confirmLlmPrompt: string;
+    withoutBriefing: boolean;
+    warmTransferWaitingMusicURL?: string;
+    warmTransferWaitingMusicVolume?: number;
+}
+export interface FieldCollectConfig extends LoopConfirmConfig {
+    enterModeSayText: string | null;
+    succeedSayText: string | null;
+    unsuccessSayText: string | null;
+    validateDigits: DtmfDigit[];
+    digitsValueMap: Record<string, string>;
+}
+export interface WarmTransferSession {
+    conferenceName: string;
+    customerCallSid: string;
+    newCallSid: string;
+    briefing: string;
+    loopSayText: string;
+    confirmLlmPrompt: string;
+    newCallStatus: 'calling' | 'connected' | 'bridging' | 'in-conference' | 'failed';
+    failedMessage: string;
+    transferType?: TransferType;
+    fallbackAction?: FallbackAction;
+    requestor?: Requestor;
+    targetBridgeSay?: string;
+    customerBridgeSay?: string;
+    targetCompleted?: boolean;
+    customerCompleted?: boolean;
+    confirmTimeoutMs: number;
+    pauseAfterSayMs: number;
+    createdAt: number;
+    confirmMode: WarmTransferConfirmMethod[];
+    confirmKeypad: DtmfDigit;
+}
+/**
+ * - `connected`           target outbound leg has been answered
+ * - `confirmed`           rep ack'd via DTMF or LLM (still before any briefing/bridge say)
+ * - `target-completed`    target side finished its briefing / targetBridgeSay
+ * - `customer-completed`  customer side finished its customerBridgeSay
+ * - `failed`              any failure: confirm timeout, target hangup, customer-bridge error, or conference join error
+ */
+export type WarmTransferStatus = 'connected' | 'confirmed' | 'target-completed' | 'customer-completed' | 'failed';
+export type WarmTransferStatusMessage = {
+    newCallSid: string;
+    status: WarmTransferStatus;
+    reason?: CallEndReason;
+};
+export interface TTSCacheConfig {
+    enabled: boolean;
+    cacheExpireMs?: number;
+}
+export interface AntiBotMonitorConfig {
+    enabled: boolean;
+    startDelayMs: number;
+    checkIntervalMs: number;
+    maxBotCount: number;
+    maxRunCount: number;
+    prompt: string;
+}
+export interface VoiceAssistantConfig {
+    deepgramFluxStt?: DeepgramFluxSttConfig;
+    deepgramStt?: DeepgramSttConfig;
+    awsTranscribeStt?: AwsTranscribeSttConfig;
+    elevenlabsStt?: ElevenLabsSttConfig;
+    cartesia?: CartesiaTTSConfig;
+    elevenlabs?: ElevenLabsTTSConfig;
+    elevenlabsHttp?: ElevenLabsHttpTTSConfig;
+    inworld?: InworldTTSConfig;
+    fish?: FishTTSConfig;
+    llm: GoogleLLMConfig;
+    antiBotMonitor: AntiBotMonitorConfig;
+    voiceMail: VoiceMailConfig;
+    userSilence: UserSilenceConfig;
+    conversation: ConversationConfig;
+    sound: SoundConfig;
+    audioStream: AudioStreamConfig;
+    transfer: TransferConfig;
+    ttsCache: TTSCacheConfig;
+    assistant: AssistantConfig;
+    /** Per-app baseline for OpenAI Realtime sessions. Per-call `configOverride` shallow-merges on top. */
+    openaiRealtime: OpenAIRealtimeConfig;
+    twilio: {
+        accountSid: string;
+        authToken: string;
+    };
+    language: string;
+}
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+export type OptionalVoiceAssistantConfig = Omit<DeepPartial<VoiceAssistantConfig>, 'deepgramStt' | 'cartesia' | 'elevenlabs' | 'elevenlabsHttp' | 'inworld' | 'fish' | 'deepgramFluxStt' | 'awsTranscribeStt' | 'elevenlabsStt' | 'openaiRealtime'> & {
+    deepgramFluxStt?: Partial<DeepgramFluxSttConfig>;
+    deepgramStt?: Partial<DeepgramSttConfig>;
+    awsTranscribeStt?: Partial<AwsTranscribeSttConfig>;
+    elevenlabsStt?: Partial<ElevenLabsSttConfig>;
+    cartesia?: Partial<CartesiaTTSConfig>;
+    elevenlabs?: Partial<ElevenLabsTTSConfig>;
+    elevenlabsHttp?: Partial<ElevenLabsHttpTTSConfig>;
+    inworld?: Partial<InworldTTSConfig>;
+    fish?: Partial<FishTTSConfig>;
+    openaiRealtime?: Partial<OpenAIRealtimeConfig>;
+};
+export type TwilioCredentials = VoiceAssistantConfig['twilio'];
+export interface AppAction {
+    callSid: string;
+}
+export interface IncomingOutgoingCall extends AppAction {
+    fromNumber: string;
+    toNumber: string;
+    direction: 'inbound' | 'outbound';
+    serviceNumber: string;
+    appId: string;
+    startTs: Date;
+    status?: TwilioCallStatus;
+}
+export interface ChatWebsocketStartMessage extends IncomingOutgoingCall {
+    voiceServiceUrl: string;
+}
+export type CallFailedReason = any;
+export type FirstAction = {
+    type: 'speak-first-say';
+} | {
+    type: 'transfer';
+    req: TransferEvt;
+} | {
+    type: 'field-collect';
+    req: FieldCollectRequest;
+};
+export type ApplicationConfig = {
+    firstSay: string;
+    succeed: boolean;
+    firstActions: FirstAction[];
+    language: string;
+    reason?: CallFailedReason;
+    cfg: VoiceAssistantConfig;
+};
+export type ApplicationConfigResponse = Omit<Partial<ApplicationConfig>, 'cfg'> & {
+    cfg?: OptionalVoiceAssistantConfig;
+};
+export type TwilioCallStatus = 'queued' | 'initiated' | 'ringing' | 'in-progress' | 'completed' | 'busy' | 'failed' | 'no-answer' | 'canceled';
+export interface TwilioCallStatusCallback {
+    CallSid: string;
+    AccountSid: string;
+    From: string;
+    To: string;
+    CallStatus: TwilioCallStatus;
+    ApiVersion: string;
+    Direction: 'inbound' | 'outbound-api' | 'outbound-dial';
+    ForwardedFrom?: string;
+    CallerName?: string;
+    ParentCallSid?: string;
+    CallDuration?: string;
+    SipResponseCode?: string;
+    RecordingUrl?: string;
+    RecordingSid?: string;
+    RecordingDuration?: string;
+    Timestamp: string;
+}
+export interface TwilioAMDStatusCallback {
+    CallSid: string;
+    AccountSid: string;
+    AnsweredBy: 'human' | 'machine_start' | 'machine_end_beep' | 'machine_end_silence' | 'machine_end_other' | 'fax' | 'unknown';
+    MachineDetectionDuration?: string;
+    Confidence?: string;
+}
+export interface TwilioStartEvent {
+    event: 'start';
+    sequenceNumber: string;
+    start: {
+        accountSid: string;
+        streamSid: string;
+        callSid: string;
+        tracks: string[];
+        mediaFormat: {
+            encoding: string;
+            sampleRate: number;
+            channels: number;
+        };
+        customParameters: Record<string, string>;
+    };
+    streamSid: string;
+}
+export interface TwilioDialActionCallback {
+    CallSid: string;
+    AccountSid: string;
+    ApiVersion: string;
+    From: string;
+    To: string;
+    CallStatus: 'queued' | 'ringing' | 'in-progress' | 'completed' | 'busy' | 'failed' | 'no-answer' | 'canceled';
+    Direction: 'inbound' | 'outbound-api' | 'outbound-dial';
+    DialCallStatus?: 'queued' | 'ringing' | 'in-progress' | 'completed' | 'busy' | 'failed' | 'no-answer' | 'canceled';
+    DialCallSid?: string;
+    DialCallDuration?: string;
+    DialBridged?: string;
+    ParentCallSid?: string;
+    Called?: string;
+    CalledCountry?: string;
+    CalledState?: string;
+    CalledCity?: string;
+    CalledZip?: string;
+    CalledVia?: string;
+    Caller?: string;
+    CallerCountry?: string;
+    CallerState?: string;
+    CallerCity?: string;
+    CallerZip?: string;
+    ToState?: string;
+    ToCity?: string;
+    ToZip?: string;
+    ToCountry?: string;
+    FromCountry?: string;
+    FromState?: string;
+    FromCity?: string;
+    FromZip?: string;
+    ForwardedFrom?: string;
+}
+export interface TwilioRecordingStatusCallback {
+    CallSid: string;
+    RecordingSid: string;
+    RecordingUrl: string;
+    RecordingStatus: 'completed' | 'in-progress' | 'absent' | 'failed';
+    RecordingDuration?: string;
+    RecordingChannels?: string;
+    RecordingSource?: string;
+    AccountSid: string;
+}
+export type IRole = 'assistant' | 'user' | 'system';
+export interface ChatItem {
+    timestamp: number;
+    content: string;
+    role: IRole;
+    type: 'chat' | 'transfer' | 'end-call' | 'silence-signal' | 'field-collect';
+    params?: {
+        silenceSignalId?: string;
+    };
+}
+export interface ChatItemWithCallSid extends AppAction {
+    item: ChatItem;
+}
+export interface AssistantFastRsp {
+    text: string;
+}
+export type AssistantLLMType = 'chat' | 'fast-response' | 'voice-mail' | 'anti-bot-detection' | 'transfer-briefing' | 'user-silence-llm-response';
+export interface AssistantLLMStartReq {
+    requestId: string;
+    messages: ChatItem[];
+    type: AssistantLLMType;
+}
+export interface AssistantLLMStopReq {
+    requestId: string;
+}
+export interface AssistantLLMResponse {
+    text: string;
+    requestId: string;
+    done: boolean;
+    error?: string;
+}
+export type WarmTransferConfirmMethod = 'keypad' | 'llm';
+export type DtmfDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '*' | '#';
+export type Requestor = 'step' | 'first-action';
+export interface TransferEvt extends AppAction {
+    type: 'transfer';
+    toNumber: string;
+    say: string;
+    unsuccessfulSay: string;
+    arguments: string;
+    interruptSay: boolean;
+    requestor: Requestor;
+    warmBriefingPrompt: string;
+    transferType?: TransferType;
+    warmTransferConfirmMode?: WarmTransferConfirmMethod[];
+    warmTransferConfirmKeypad?: DtmfDigit;
+    warmTransferConfig?: Partial<TransferConfig>;
+    asyncWarmTransferBridge?: AsyncWarmTransferBridgeConfig;
+}
+export interface MakeCallOptions {
+    withAMD?: boolean;
+    prviderNumber?: string;
+}
+export interface MakeCallRequest extends MakeCallOptions {
+    type: 'make-call';
+    fromNumber: string;
+    toNumber: string;
+    options: MakeCallOptions;
+}
+export interface GlobalInterruptibleRequest extends AppAction {
+    type: 'global-interruption';
+    disableInterrupt: boolean;
+}
+export interface FieldCollectRequest extends AppAction {
+    type: 'field-collect';
+    userdata?: string;
+    requestor: Requestor;
+    fieldName: string;
+    config: FieldCollectConfig;
+}
+export interface FieldCollectResponse extends AppAction {
+    succeed: boolean;
+    fieldName: string;
+    requestor: Requestor;
+    result: DtmfDigit[];
+    value: string;
+    userdata?: string;
+}
+export type ReloadAppConfigReason = 'switch-language';
+export interface ReloadAppConfigRequest extends AppAction {
+    type: 'reload-app-config';
+    reason: ReloadAppConfigReason;
+    config: ApplicationConfigResponse;
+}
+export interface ReloadAppConfigResponse extends AppAction {
+    type: 'reload-app-config-response';
+}
+export interface VoiceServiceResponse {
+    success: boolean;
+    callSid?: string;
+    failedReason?: 'max-outbound-calls-reached' | 'twilio-api-error' | 'voice-service-internal-error' | 'on-outbound-request-error' | 'network-error' | 'fetch-twilio-config-error';
+    message?: string;
+    errorCode?: number;
+    statusCode?: number;
+}
+export declare class VoiceServiceError extends Error {
+    readonly response: VoiceServiceResponse;
+    constructor(message: string, response: VoiceServiceResponse);
+}
+export interface MakeFastReponseRequest extends AppAction {
+    type: 'make-fast-response';
+    text: string;
+}
+export interface ColdTransferMessage {
+    introductionBriefing: string;
+    unsuccessfulSay: string;
+}
+export declare enum AppState {
+    STARTING = "starting",
+    WSS_CHECK_FAILED = "wss_check_failed",
+    READY = "ready",
+    SHUTTING_DOWN = "shutting_down",
+    SHUTDOWN = "shutdown"
+}
+export interface InstanceState {
+    instanceId: string;
+    startTs: number;
+    state: AppState;
+    timestamp: number;
+    activeCalls: number;
+    calls: IncomingOutgoingCall[];
+}
+export interface DispatchRule {
+    id: string;
+    phoneNumber: string;
+    agentServiceUrl: string;
+}
+export type CallEndReason = 'stt-error-exit' | 'voicemail-detected-with-reply' | 'voicemail-detected-no-reply' | 'user-silence-max-reached' | 'user-silence-signal-max-continue-reached' | 'assistant-said-goodbye' | 'instance-shutting-down' | 'customer-ended-call' | 'call-busy' | 'call-no-answer' | 'call-failed' | 'call-canceled' | 'cold-transfer-call-success' | 'cold-transfer-call-success-by-first-action' | 'warm-transfer-call-success' | 'warm-transfer-call-success-by-first-action' | 'warm-transfer-failed-execute-error' | 'warm-transfer-failed-confirm-timeout' | 'warm-transfer-failed-join-conference' | 'warm-transfer-failed-target-no-answer' | 'warm-transfer-failed-target-busy' | 'warm-transfer-failed-target-canceled' | 'warm-transfer-failed-target-hangup' | 'warm-transfer-failed-target-error' | 'warm-transfer-failed-customer-hangup' | 'cold-transfer-failed-no-answer' | 'cold-transfer-failed-busy' | 'cold-transfer-failed-canceled' | 'cold-transfer-failed-error' | 'cold-transfer-failed-customer-hangup' | 'field-collect-failed' | 'field-collect-customer-hangup' | 'user-is-bot' | 'unknown';
+export interface CallStatusChangeEvent extends AppAction {
+    ctx: IncomingOutgoingCall;
+    status: TwilioCallStatusCallback;
+    end?: CallEndReason;
+}
+export interface CallEndEvent extends AppAction {
+    ctx: IncomingOutgoingCall;
+    end: CallEndReason;
+}
+export type CallRecordedEvent = TwilioRecordingStatusCallback & AppAction;
+export type SilenceSignalResponse = AppAction & {
+    type: 'silence-signal-response';
+    signalId: string;
+    result: 'ignore' | 'accept';
+    message?: string;
+};
+export type TransferEvent = AppAction & {
+    type: 'transfer-event';
+    transferType: TransferType;
+    fallbackAction: FallbackAction;
+    requestor: Requestor;
+    result: 'start-transfer' | 'transfer-failed' | 'transfer-completed' | 'async-warm-transfer-bridging';
+};
+/** Built-in voice options for `gpt-realtime` / `gpt-realtime-2`. */
+export type RealtimeBuiltinVoice = 'alloy' | 'ash' | 'ballad' | 'coral' | 'echo' | 'sage' | 'shimmer' | 'verse' | 'marin' | 'cedar';
+/** Built-in voice name or a custom voice reference (`{ id: "voice_1234" }`). */
+export type RealtimeVoiceConfig = RealtimeBuiltinVoice | {
+    id: string;
+};
+/** @deprecated Use `RealtimeBuiltinVoice` or `RealtimeVoiceConfig`. */
+export type RealtimeVoice = RealtimeBuiltinVoice;
+/** Realtime model identifier. */
+export type RealtimeModel = 'gpt-realtime-2';
+/** PCM 16-bit 24 kHz mono — the only audio format this service uses today. */
+export type RealtimeAudioFormat = {
+    type: 'audio/pcm';
+    rate?: 24000;
+};
+export type RealtimeOutputModality = 'text' | 'audio';
+/** The API accepts a single modality per session: `['audio']` or `['text']`. */
+export type RealtimeOutputModalities = ['audio'] | ['text'];
+/**
+ * Noise reduction. `null` (or omitted) disables. Use `near_field` for handset/headset
+ * mics and `far_field` for room/conference mics.
+ */
+export type RealtimeNoiseReduction = {
+    type: 'near_field' | 'far_field';
+} | null;
+export interface RealtimeServerVadConfig {
+    type: 'server_vad';
+    /**
+     * Energy-based speech-activation threshold, 0.0–1.0. Default 0.5. Higher = more
+     * conservative (needs louder audio to count as speech → resists line noise/echo but may
+     * miss soft speech); lower = more sensitive (catches quiet speech but noise can false-trigger).
+     * Telephony usually wants slightly above the default.
+     */
+    threshold?: number;
+    /**
+     * Audio retained *before* the VAD-detected speech onset, in ms. Default 300. VAD always
+     * lags the true onset, so this prefix keeps the first consonants/syllables from being clipped.
+     */
+    prefix_padding_ms?: number;
+    /**
+     * Continuous silence after speech required to mark end-of-speech (EOT) and commit the
+     * input buffer, in ms. Default 500. Lower = snappier turns but mid-sentence pauses can
+     * cut the user off; higher = tolerates thinking pauses at the cost of reply latency.
+     */
+    silence_duration_ms?: number;
+    /**
+     * Idle re-engagement (NOT EOT detection): if the user stays silent for this long *after the
+     * model's last response*, the server auto-fires a new `response.create` to re-prompt them.
+     * Omit/null to never auto-re-prompt. Min 5000ms. Distinct from the session-level
+     * `exit.onSilenceMs`, which tears down the realtime sub-flow instead.
+     */
+    idle_timeout_ms?: number;
+    /**
+     * Auto-create a model response when EOT is detected. Default true. (The very first response
+     * can still be deferred client-side — see `autoCreateInitialResponse` in `RealtimeSession`.)
+     */
+    create_response?: boolean;
+    /**
+     * Auto-cancel an in-flight model response when new user speech is detected
+     * (server-side barge-in). Default true. With this enabled, clients MUST NOT
+     * issue `response.cancel` themselves — the two race and the manual cancel
+     * routinely fails with `response_cancel_not_active`.
+     */
+    interrupt_response?: boolean;
+}
+export interface RealtimeSemanticVadConfig {
+    type: 'semantic_vad';
+    /**
+     * How eagerly the semantic classifier calls end-of-turn. Default 'auto'. `high` = ends turns
+     * fast (snappy, but more likely to cut off a thinking pause); `low` = waits longer for the
+     * user to continue. Unlike `server_vad`, EOT is judged from content/prosody, not raw silence.
+     */
+    eagerness?: 'low' | 'medium' | 'high' | 'auto';
+    /** Auto-create a model response when EOT is detected. Default true. */
+    create_response?: boolean;
+    /** Server-side barge-in: auto-cancel the in-flight response on new user speech. Default true. */
+    interrupt_response?: boolean;
+}
+/** Turn detection. `null` disables VAD entirely (push-to-talk style). */
+export type RealtimeTurnDetection = RealtimeServerVadConfig | RealtimeSemanticVadConfig | null;
+/** Transcription delay. Only supported with `gpt-realtime-whisper` in GA Realtime sessions. */
+export type RealtimeTranscriptionDelay = 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+export type RealtimeTranscriptionModel = 'whisper-1' | 'gpt-4o-mini-transcribe' | 'gpt-4o-mini-transcribe-2025-12-15' | 'gpt-4o-transcribe' | 'gpt-4o-transcribe-diarize' | 'gpt-realtime-whisper' | (string & {});
+/** Input audio transcription (`audio.input.transcription`). */
+export interface RealtimeTranscriptionConfig {
+    model?: RealtimeTranscriptionModel;
+    delay?: RealtimeTranscriptionDelay;
+    language?: string;
+    prompt?: string;
+}
+export type RealtimeToolChoiceMode = 'auto' | 'none' | 'required';
+export interface RealtimeToolChoiceFunction {
+    type: 'function';
+    name: string;
+}
+export interface RealtimeToolChoiceMcp {
+    type: 'mcp';
+    server_label: string;
+    name?: string;
+}
+export type RealtimeToolChoice = RealtimeToolChoiceMode | RealtimeToolChoiceFunction | RealtimeToolChoiceMcp;
+export type RealtimeReasoningEffort = 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+export interface RealtimeReasoningConfig {
+    effort?: RealtimeReasoningEffort;
+}
+export type RealtimeInclude = 'item.input_audio_transcription.logprobs';
+export type RealtimeMaxOutputTokens = number | 'inf';
+export interface RealtimePromptInputText {
+    type: 'input_text';
+    text: string;
+}
+export type RealtimePromptInputImageDetail = 'low' | 'high' | 'auto' | 'original';
+export interface RealtimePromptInputImage {
+    type: 'input_image';
+    detail?: RealtimePromptInputImageDetail;
+    file_id?: string;
+    image_url?: string;
+}
+export type RealtimePromptInputFileDetail = 'low' | 'high';
+export interface RealtimePromptInputFile {
+    type: 'input_file';
+    detail?: RealtimePromptInputFileDetail;
+    file_data?: string;
+    file_id?: string;
+    file_url?: string;
+    filename?: string;
+}
+export type RealtimePromptVariableValue = string | RealtimePromptInputText | RealtimePromptInputImage | RealtimePromptInputFile;
+export interface RealtimePromptConfig {
+    id: string;
+    version?: string;
+    variables?: Record<string, RealtimePromptVariableValue>;
+}
+export type RealtimeTracingConfig = 'auto' | {
+    group_id?: string;
+    metadata?: unknown;
+    workflow_name?: string;
+} | null;
+export type RealtimeTruncationConfig = 'auto' | 'disabled' | {
+    type: 'retention_ratio';
+    retention_ratio: number;
+    token_limits?: {
+        post_instructions?: number;
+    };
+};
+export interface RealtimeFunctionToolDefinition {
+    type: 'function';
+    name: string;
+    description?: string;
+    parameters?: unknown;
+}
+export type RealtimeMcpConnectorId = 'connector_dropbox' | 'connector_gmail' | 'connector_googlecalendar' | 'connector_googledrive' | 'connector_microsoftteams' | 'connector_outlookcalendar' | 'connector_outlookemail' | 'connector_sharepoint';
+export interface RealtimeMcpToolFilter {
+    read_only?: boolean;
+    tool_names?: string[];
+}
+export type RealtimeMcpAllowedTools = string[] | RealtimeMcpToolFilter;
+export interface RealtimeMcpToolApprovalFilter {
+    always?: RealtimeMcpToolFilter;
+    never?: RealtimeMcpToolFilter;
+}
+export type RealtimeMcpToolApproval = 'always' | 'never' | RealtimeMcpToolApprovalFilter;
+export interface RealtimeMcpToolDefinition {
+    type: 'mcp';
+    server_label: string;
+    allowed_tools?: RealtimeMcpAllowedTools;
+    authorization?: string;
+    connector_id?: RealtimeMcpConnectorId;
+    defer_loading?: boolean;
+    headers?: Record<string, string>;
+    require_approval?: RealtimeMcpToolApproval;
+    server_description?: string;
+    server_url?: string;
+}
+export type RealtimeToolDefinition = RealtimeFunctionToolDefinition | RealtimeMcpToolDefinition;
+/**
+ * Client-side barge-in handling for the realtime audio output.
+ *
+ * The server owns turn-level barge-in (`turn_detection.interrupt_response`), but it streams
+ * audio faster than real-time, so several seconds of already-generated audio can sit in the
+ * local playback buffer. Without intervention that tail keeps playing after the caller starts
+ * talking, making the interruption feel like it "didn't work". These knobs let us drop that
+ * residual tail (and optionally reconcile the server's transcript) the instant a barge-in is
+ * flagged.
+ */
+export interface RealtimeBargeInConfig {
+    /**
+     * Drop the locally buffered (not-yet-played) output audio the moment the server flags user
+     * speech while the model is talking. Stops the multi-second tail so the interruption is
+     * immediate. Default `true`.
+     */
+    clearBufferedTailOnBargeIn?: boolean;
+    /**
+     * Only clear when at least this much un-played audio is still buffered (ms). Guards against
+     * chopping the model on a near-empty tail or a `speech_started` that lands right as playback
+     * finishes. Default `40` (~2 Twilio frames).
+     */
+    minBufferedMsToClear?: number;
+    /**
+     * After clearing, send `conversation.item.truncate` so the server's stored assistant turn
+     * reflects only what the caller actually heard (computed from bytes pulled by the mixer, so
+     * `audio_end_ms` is always ≤ generated audio and won't be rejected). Keeps history honest and
+     * avoids the model believing it finished a sentence it was cut off mid-way. Default `true`.
+     */
+    truncateOnBargeIn?: boolean;
+}
+/**
+ * Full per-session OpenAI Realtime configuration.
+ */
+export interface OpenAIRealtimeConfig {
+    apiKey: string;
+    model: RealtimeModel;
+    voice: RealtimeVoiceConfig;
+    /** Defaults to `['audio']`. The API does not support `['text', 'audio']` together. */
+    outputModalities?: RealtimeOutputModalities;
+    inputAudioFormat: RealtimeAudioFormat;
+    outputAudioFormat: RealtimeAudioFormat;
+    outputAudioSpeed?: number;
+    /**
+     * Linear makeup gain applied to the model's output audio before μ-law encoding.
+     * `1.0` = no change. Values > 1 amplify (with hard-clip protection at ±32767).
+     * Use to compensate for gpt-realtime's relatively low native output level.
+     */
+    outputGain?: number;
+    include?: RealtimeInclude[];
+    /** `null` disables noise reduction. */
+    noiseReduction: RealtimeNoiseReduction;
+    /** `null` disables VAD entirely. With `interrupt_response: true` the server owns barge-in. */
+    turnDetection: RealtimeTurnDetection;
+    /** Client-side barge-in tail handling. Omit to use defaults (clear + truncate enabled). */
+    bargeIn?: RealtimeBargeInConfig;
+    transcription: RealtimeTranscriptionConfig | null;
+    maxOutputTokens?: RealtimeMaxOutputTokens;
+    parallelToolCalls?: boolean;
+    prompt?: RealtimePromptConfig;
+    tools?: RealtimeToolDefinition[];
+    toolChoice?: RealtimeToolChoice;
+    /** Reasoning effort for reasoning-capable Realtime models such as `gpt-realtime-2`. */
+    reasoning?: RealtimeReasoningConfig;
+    tracing?: RealtimeTracingConfig;
+    truncation?: RealtimeTruncationConfig;
+}
+export type OptionalOpenAIRealtimeConfig = Partial<OpenAIRealtimeConfig>;
+/** `none`: cold start. `last-n`: replay last `historyContextLastN` items (default 100). `full`: all. */
+export type RealtimeHistoryContext = 'none' | 'last-n' | 'full';
+export type RealtimeExitTrigger = 'tool' | 'silence';
+export interface RealtimeExitConfig {
+    /** Tool names that exit the sub-flow when called by the model. */
+    onTool?: string[];
+    /** Idle silence (ms) after which the sub-flow auto-exits. */
+    onSilenceMs?: number;
+}
+/** Payload for the `RealtimeChat` mid-call action. */
+export interface RealtimeChatActionPayload {
+    callSid: string;
+    instructions: string;
+    voice?: RealtimeVoiceConfig;
+    tools?: RealtimeToolDefinition[];
+    historyContext?: RealtimeHistoryContext;
+    /** Trailing items to inject when `historyContext === 'last-n'`. Default 100 (`DEFAULT_HISTORY_LAST_N`). */
+    historyContextLastN?: number;
+    /** Top-level shortcut for `configOverride.noiseReduction`. `null` disables. */
+    noiseReduction?: RealtimeNoiseReduction;
+    exit?: RealtimeExitConfig;
+    configOverride?: OptionalOpenAIRealtimeConfig;
+}
+/** `/twilio/thirdparty-event` body to trigger a mid-call realtime sub-flow. */
+export interface RealtimeChatRequest extends AppAction {
+    type: 'realtime-chat';
+    payload: Omit<RealtimeChatActionPayload, 'callSid'>;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map