@superpanel-sdk/runtime 0.5.0 → 0.7.0

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

@@ -0,0 +1,604 @@
+/**
+ * Voice service ⇄ Backend call protocol — the shared type file.
+ *
+ * Self-contained on purpose: no imports. The Backend copies this file as is
+ * (jupiter-backend-and-worker: packages/runtime/src/voice-service/protocol.ts); change it here first and
+ * copy it over, never edit the copy. Design: jupiter-voice-service docs/voice-service-event-protocol.md.
+ *
+ * Compatibility rules (there is one protocol version, no negotiation):
+ * - A receiver ignores any `type` it does not know.
+ * - Fields are only ever added, and every added field is optional.
+ */
+export interface Envelope<T extends string = string, D = unknown> {
+    /**
+     * The sender's counter, from 1, one per reliable message, each direction on its own. `0` marks a
+     * control message outside the reliable stream (`ack`, `session.resume`, `session.resumed`, `drain`):
+     * never acked, never resent.
+     */
+    seq: number;
+    /** The highest contiguous `seq` received from the other side; may ride on any message. */
+    ack?: number;
+    type: T;
+    /** Sender's clock, ms since epoch. */
+    ts: number;
+    data: D;
+}
+/** Control messages: `seq: 0`. */
+export type ControlType = 'ack' | 'session.resume' | 'session.resumed' | 'drain';
+/** Close code a Backend uses to refuse the socket (bad signature, unknown call). Not retried. */
+export declare const CLOSE_UNAUTHORIZED = 4401;
+/**
+ * `elevenlabs` and `elevenlabs-http` are the platform's older names (its voice profiles): taken as
+ * `elevenlabs-ttd`, the voice service's one ElevenLabs client. Send the canonical names; see `canonicalTtsProvider`.
+ */
+export type TtsProvider = 'cartesia' | 'elevenlabs-ttd' | 'inworld' | 'fish' | 'elevenlabs' | 'elevenlabs-http';
+export type CanonicalTtsProvider = 'cartesia' | 'elevenlabs-ttd' | 'inworld' | 'fish';
+/** The provider as the voice service runs it; null for one it does not have. */
+export declare function canonicalTtsProvider(provider: string | undefined | null): CanonicalTtsProvider | null;
+/** A TTS voice (part two). Keys never travel: the voice service reads them from its environment. */
+export interface Voice {
+    provider: TtsProvider;
+    voiceId: string;
+    model?: string;
+    language?: string;
+    speed?: number;
+    /** Passed through to the provider's config as is (emotion, stability, pronunciation dictionary…). */
+    options?: Record<string, unknown>;
+    /** Said with this voice when this one fails. May nest. */
+    fallback?: Voice;
+}
+export type CallDirection = 'inbound' | 'outbound';
+export interface CallContext {
+    callSid: string;
+    fromNumber: string;
+    toNumber: string;
+    forwardedFrom?: string;
+    direction: CallDirection;
+    /** Our number on this call. */
+    serviceNumber: string;
+    appId: string;
+    startTs: string | Date;
+    source?: 'pstn' | 'sip';
+    sip?: {
+        fromUri?: string;
+        toUri?: string;
+        domain?: string;
+        domainSid?: string;
+        callId?: string;
+        sourceIp?: string;
+        headers: Record<string, string>;
+    };
+    callToken?: string;
+    unavailableServices?: string[];
+}
+export type DtmfDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '*' | '#';
+export type FallbackAction = 'end-call' | 'restore-normal-call-state';
+/** One entry of the transcript the voice service keeps (§1.17); the Backend builds LLM context from it. */
+export interface ChatItem {
+    role: 'assistant' | 'user' | 'system';
+    type: 'chat' | 'transfer' | 'end-call' | 'silence-signal' | 'field-collect';
+    content: string;
+    timestamp: number;
+    /** When it was audible, ms since the call's conversation started. */
+    startMs?: number;
+    endMs?: number;
+    params?: {
+        /** Said over the AI without interrupting it. */
+        bargeIn?: boolean;
+        /** Said inside a `realtime_chat` sub-flow. */
+        source?: 'realtime';
+        /** Structured form of a `[category] …` note. */
+        category?: 'amd' | 'far-end' | 'transfer' | 'field-collect' | 'silence' | 'system';
+        [key: string]: unknown;
+    };
+}
+export interface InterruptionSettings {
+    enabled: boolean;
+    /** Words the caller must say before the AI stops. */
+    minWords: number;
+    /** The first ms of each sentence's audio cannot be interrupted. */
+    protectMs: number;
+    /** Said as an overlay right after an interruption; empty for none (the default: it lands on the caller's words). */
+    backchannels: string[];
+    /**
+     * A collision, not an interruption: the caller's first words come while the AI's speech is not heard yet,
+     * or has been heard for at most this long (the caller began first, or both at about the same moment). The AI stops at that first word, without
+     * `minWords`. 0 turns it off. Default 1500.
+     */
+    collisionMs?: number;
+}
+export interface SttSettings {
+    /**
+     * The call's language (BCP-47): what the caller is spoken to in. The STT does not reconnect for it; it only
+     * changes who ends turns, from the next turn on (48 §7.1). `session.updated` follows.
+     */
+    language?: string;
+    /** Names and terms to listen for, given to every engine (it reconnects for them). */
+    keyterms?: string[];
+    /** Report `user.partial`. Default false. */
+    partials?: boolean;
+    /** Stop listening until set back to false. */
+    paused?: boolean;
+}
+export interface FarEndHintSettings {
+    enabled: boolean;
+    /** Regex sources (case-insensitive) that send a greeting to the voicemail check (65 §3.1); omitted, the defaults. */
+    voicemail?: string[];
+}
+export interface QuietSettings {
+    /** Notify after this long quiet; 0 pauses notifications. Default 9000. */
+    notifyAfterMs: number;
+    /** Hang up after this many notifications in a row with the caller never speaking. Default 15. */
+    hangupAfterTimes: number;
+    /** Hang up when the caller has not spoken for this long, whatever the AI said. Default 180000. */
+    hangupAfterNoUserMs: number;
+    /**
+     * Once: a `call.quiet { checkBack: true }` after this long quiet (counted from the update, and again from
+     * the end of any AI speech), whatever `notifyAfterMs` is. Dropped when the caller speaks or after it is
+     * sent; the usual notices go on as before and it does not count in `times`. 0 drops one set.
+     */
+    checkBackMs?: number;
+}
+export interface ThinkingSettings {
+    /** How long a caller who finished speaking waits for a reply (or a stalled stream for more). Default 30000. */
+    maxWaitMs: number;
+    /** `say`: the fallback text, then listen again. `hangup`: the fallback text, then hang up. */
+    onTimeout: 'say' | 'hangup' | 'none';
+}
+export interface FallbackSettings {
+    /** Said when the Backend cannot be heard from. */
+    text: string;
+    voice?: Voice;
+    /** No Backend socket this long after the call is answered: say `text`, hang up. */
+    connectTimeoutMs: number;
+    /** Nothing said this long after `call.answered`: say `text`, hang up. */
+    firstSpeechTimeoutMs: number;
+    /** Played while the Backend socket is down (raw μ-law 8 kHz: asset name or https URL). */
+    waitSound: string;
+    waitSoundVolume: number;
+}
+export interface QueueSettings {
+    /** Items waiting behind the running one. Default 5; more are dropped with an `error`. */
+    maxItems: number;
+}
+/** `session.update` and the initial `session`: only the fields given change. */
+export interface SessionSettings {
+    /** The default voice from now on. */
+    voice?: Voice;
+    /** Voices to connect ahead of use. */
+    voices?: Voice[];
+    interruption?: Partial<InterruptionSettings>;
+    stt?: SttSettings;
+    farEndHint?: Partial<FarEndHintSettings>;
+    quiet?: Partial<QuietSettings>;
+    thinking?: Partial<ThinkingSettings>;
+    fallback?: Partial<FallbackSettings>;
+    queue?: Partial<QueueSettings>;
+    /**
+     * Provider settings, deep-merged over the call's (the same shape as `CallSetup.cfg`): TTS and the like.
+     * How the call is heard is the voice service's own (48 §10.3): a `cfg.stt` is not taken.
+     */
+    cfg?: Record<string, unknown>;
+}
+export type CallRoute = {
+    type: 'assistant';
+    ringSeconds?: number;
+} | {
+    type: 'dial';
+    toNumber: string;
+    ringSeconds?: number;
+}
+/** Not taken. Inbound: `say` (if any) is read to the caller first, by Twilio's own voice. */
+ | {
+    type: 'reject';
+    reason?: string;
+    say?: string;
+};
+export interface PreloadItem {
+    text: string;
+    voice?: Voice;
+}
+export interface CallSetup {
+    route: CallRoute;
+    session?: SessionSettings;
+    /** Synthesized into the TTS cache while the call rings: the first `speak` with this text starts at once. */
+    preload?: PreloadItem[];
+    /** Started as soon as the call is answered (usually the background). */
+    sounds?: SoundPlayCommand[];
+    /** The number this call is taken as, when it is not the one it came in on (SIP). */
+    serviceNumber?: string;
+    /** Voice service provider settings for this call, deep-merged over its defaults. */
+    cfg?: Record<string, unknown>;
+}
+/**
+ * How a queued command enters the play queue (§1.6):
+ * - `queue` (default): after everything queued.
+ * - `next`: right after the running item.
+ * - `replace`: stop the running item, clear the queue (epoch + 1), then this.
+ * - `overlay`: `speak` only — played at once over whatever plays, outside the queue.
+ */
+export type QueueMode = 'queue' | 'next' | 'replace' | 'overlay';
+export interface QueuedCommand {
+    mode?: QueueMode;
+    /** The epoch the Backend last saw; older than the current one → dropped (`cause: dropped`). */
+    epoch?: number;
+}
+export interface SpeakCommand extends QueuedCommand {
+    text: string;
+    voice?: Voice;
+    /** Default true. */
+    interruptible?: boolean;
+    /**
+     * One more way to cut this line off, besides the session's rules (which still apply): the caller's words
+     * begun while it is heard, once the STT's final has them, this many of them not counting fillers ("uh",
+     * "mm"). The voicemail message takes 1: a "Hello?" over it is a person who picked up (65 §3.3); the tail of
+     * the greeting, a partial taken back, or an "mm" of line noise is not. Only for an interruptible line, only
+     * while interruptions are on; it changes no other line.
+     */
+    interruptMinWords?: number;
+    /** Dropped when its turn comes while the caller is speaking. */
+    onlyIfQuiet?: boolean;
+    /** Default true: a whole sentence goes through the TTS cache. */
+    cache?: boolean;
+}
+export type SpeakStartCommand = Omit<SpeakCommand, 'text' | 'cache'>;
+/** Belongs to the latest `speak.start` not yet ended; dropped once that one is over. */
+export interface SpeakDeltaCommand {
+    text: string;
+    epoch?: number;
+}
+export interface SpeakEndCommand {
+    epoch?: number;
+}
+export interface PlayCommand extends QueuedCommand {
+    /** Raw μ-law 8 kHz: asset name or https URL. */
+    url: string;
+    interruptible?: boolean;
+    onlyIfQuiet?: boolean;
+}
+export type TransferType = 'cold' | 'warm' | 'async-warm';
+export interface TransferCommand extends QueuedCommand {
+    toNumber: string;
+    transferType?: TransferType;
+    /** Said to the caller before transferring (empty: nothing). */
+    say?: string;
+    /** Said to the caller when the transfer fails (empty: nothing). */
+    unsuccessfulSay?: string;
+    /** Read to the person taking the call: cold, as it connects; warm, once they confirm. */
+    briefing?: string;
+    /**
+     * Warm and background (76 §2.9): who it is and what about, looped to the person taking the call before
+     * they confirm; the voice service adds how to confirm. Without it: "You have a call from {companyName}".
+     * English for now.
+     */
+    whisper?: string;
+    /** Warm and background: the company's display name, for the loop line without a whisper. */
+    companyName?: string;
+    /** SIP/custom parameters for the outbound leg (JSON text). */
+    arguments?: string;
+    voice?: Voice;
+    warmTransferConfirmMode?: Array<'keypad' | 'llm'>;
+    warmTransferConfirmKeypad?: DtmfDigit;
+    warmTransferConfig?: {
+        confirmTimeoutMs?: number;
+        pauseAfterSayMs?: number;
+        /** Looped to the person taking the call until they confirm. */
+        loopSayText?: string;
+        fallbackAction?: FallbackAction;
+        /** Decides, from what the person said, whether they take the call ("CONFIRMED"). */
+        confirmLlmPrompt?: string;
+        /** Said to the person taking the call when the customer hung up meanwhile, in their language. */
+        customerGoneSay?: string;
+        inboundCallTransferCallerId?: 'customer' | 'assistant';
+        warmTransferWaitingMusicURL?: string;
+        warmTransferWaitingMusicVolume?: number;
+    };
+    asyncWarmTransferBridge?: {
+        targetSayTemplate?: string;
+        customerSayTemplate?: string;
+    };
+}
+export interface FieldCollectConfig {
+    confirmTimeoutMs: number;
+    pauseAfterSayMs: number;
+    loopSayText: string;
+    fallbackAction: FallbackAction;
+    enterModeSayText: string | null;
+    succeedSayText: string | null;
+    unsuccessSayText: string | null;
+    validateDigits: DtmfDigit[];
+    digitsValueMap: Record<string, string>;
+}
+export interface FieldCollectCommand extends QueuedCommand {
+    fieldName: string;
+    userdata?: string;
+    config: FieldCollectConfig;
+    voice?: Voice;
+}
+export interface RealtimeChatCommand extends QueuedCommand {
+    instructions: string;
+    /** gpt-live built-in voice name, or `{ id }` for a custom one. */
+    voice?: string | {
+        id: string;
+    };
+    historyContext?: 'none' | 'last-n' | 'full';
+    historyContextLastN?: number;
+    exit?: {
+        onTool?: string[];
+        onSilenceMs?: number;
+    };
+    /** Any subset of the voice service's gpt-live settings. */
+    configOverride?: Record<string, unknown>;
+}
+export interface SendDigitsCommand extends QueuedCommand {
+    /** `0-9 * #`; `w` waits half a second. */
+    digits: string;
+}
+export interface HangupCommand extends QueuedCommand {
+    reason: string;
+}
+export interface WaitCommand extends QueuedCommand {
+    ms: number;
+}
+export interface StopCommand {
+    /** Also clear the queue (epoch + 1). */
+    clearQueue?: boolean;
+}
+export interface CancelCommand {
+    /** The `seq` of the command to take back. */
+    ref: number;
+}
+export interface SoundPlayCommand {
+    /** Your name for it; playing the same id again replaces it. */
+    soundId: string;
+    /** Raw μ-law 8 kHz: asset name or https URL. */
+    src: string;
+    loop?: boolean;
+    /** 0–1. */
+    volume?: number;
+    /** Stopped as soon as anyone speaks: the AI's next sentence, or the caller. */
+    stopOnSpeech?: boolean;
+}
+export interface SoundStopCommand {
+    soundId: string;
+}
+export type DownstreamCommands = {
+    speak: SpeakCommand;
+    'speak.start': SpeakStartCommand;
+    'speak.delta': SpeakDeltaCommand;
+    'speak.end': SpeakEndCommand;
+    play: PlayCommand;
+    transfer: TransferCommand;
+    field_collect: FieldCollectCommand;
+    realtime_chat: RealtimeChatCommand;
+    send_digits: SendDigitsCommand;
+    hangup: HangupCommand;
+    wait: WaitCommand;
+    stop: StopCommand;
+    cancel: CancelCommand;
+    'sound.play': SoundPlayCommand;
+    'sound.stop': SoundStopCommand;
+    'session.update': SessionSettings;
+};
+export type DownstreamType = keyof DownstreamCommands;
+export type DownstreamMessage = {
+    [T in DownstreamType]: Envelope<T, DownstreamCommands[T]>;
+}[DownstreamType];
+/** Commands that go through the play queue and are checked against the epoch. */
+export declare const QUEUED_COMMANDS: readonly ['speak', 'speak.start', 'play', 'transfer', 'field_collect', 'realtime_chat', 'send_digits', 'hangup', 'wait'];
+export type QueuedCommandType = (typeof QUEUED_COMMANDS)[number];
+export type SpeechCause = 'user' | 'replaced' | 'stopped' | 'dropped' | 'timeout' | 'error';
+export interface VoiceReport {
+    provider: TtsProvider;
+    voiceId: string;
+    model?: string;
+    /** The requested voice failed and this one said it. */
+    fallback?: boolean;
+}
+export type ActionKind = 'transfer' | 'field_collect' | 'realtime_chat' | 'send_digits' | 'hangup';
+export type TransferResult = 'start-transfer' | 'transfer-failed' | 'transfer-completed' | 'async-warm-transfer-bridging';
+export interface TransferOutcome {
+    transferType: TransferType;
+    result: TransferResult;
+    fallbackAction: FallbackAction;
+    /** Why it failed, when it did. */
+    reason?: string;
+}
+export interface FieldCollectOutcome {
+    fieldName: string;
+    succeed: boolean;
+    /** Keys pressed. */
+    result: DtmfDigit[];
+    /** Keys mapped through `digitsValueMap`. */
+    value: string;
+    userdata?: string;
+}
+export interface SpokenAt {
+    start: number;
+    end: number;
+}
+/** How the engines came to a turn's text (backend design 48 §7.3). */
+export interface SttFusion {
+    /** agree: every engine heard the same; primary: only the turn source heard it; voted: word by word; rescue: the turn source heard nothing. */
+    method: 'agree' | 'primary' | 'voted' | 'rescue';
+    /** The engine that ended the turn (its id). */
+    turnsBy?: string;
+    /** The turn's language as worked out (the call's): for looking into a turn, not for deciding anything. */
+    language?: string;
+    /** What each engine heard (as configured: always, on disagreement, never). */
+    engines?: Array<{
+        engine: string;
+        provider: string;
+        text: string;
+        state: 'final' | 'interim' | 'none' | 'down';
+        /** How much its words counted in the turn's language. */
+        weight?: number;
+    }>;
+    /**
+     * The words the voting engines did not agree on (backend design 63 §6): `[start, end)` in the turn's
+     * `text`, which reads `text` there, and what the other engines heard instead. Fillers ("uh") are no
+     * disagreement; a number is marked whole. Absent when they agreed.
+     */
+    unclear?: Array<{
+        start: number;
+        end: number;
+        text: string;
+        alsoHeard: string[];
+    }>;
+    /** They disagreed over much of the turn (more than two stretches, or half the words): what each heard, whole. */
+    unclearTurn?: string[];
+}
+export type UpstreamEvents = {
+    /** seq 1 on the first socket. */
+    'session.start': {
+        callSid: string;
+        call: CallContext;
+        voiceServiceUrl: string;
+    };
+    /** Control (seq 0): first message on a later socket. The Backend answers `session.resumed { lastAck }`. */
+    'session.resume': {
+        callSid: string;
+        lastAck: number;
+        call?: CallContext;
+        voiceServiceUrl?: string;
+    };
+    /** Media flowing, STT and the default voice ready. */
+    'call.answered': {
+        direction: CallDirection;
+        answeredAt: number;
+    };
+    'call.ended': {
+        reason: string;
+    };
+    'user.started': {
+        utteranceId: string;
+        overlappedRef?: number;
+    };
+    'user.partial': {
+        utteranceId: string;
+        text: string;
+    };
+    'user.finished': {
+        utteranceId: string;
+        text: string;
+        spokenAt?: SpokenAt;
+        /** The `seq` of the speech playing as the caller started. */
+        overlappedRef?: number;
+        /** What of that speech had been said by then. */
+        saidTextAtStart?: string;
+        /** It interrupted the AI (the queue was cleared). */
+        interrupted: boolean;
+        /** Every word is a backchannel ("Okay.", "Mm-hm.", "Got it."): said to show the caller listens, not to take the turn. */
+        backchannel?: boolean;
+        source?: 'realtime';
+        /** How the engines came to its text (48 §7.3). */
+        fusion?: SttFusion;
+    };
+    /** A finished turn's text changed: an engine's late words came after `user.finished` (48 §7.3). */
+    'user.revised': {
+        utteranceId: string;
+        text: string;
+        previousText: string;
+        fusion?: SttFusion;
+    };
+    'speech.started': {
+        ref: number;
+        voice?: VoiceReport;
+        ttfbMs: number;
+    };
+    'speech.finished': {
+        ref?: number;
+        saidText: string;
+        spokenAt?: SpokenAt;
+        source?: 'realtime';
+    };
+    'speech.interrupted': {
+        ref: number;
+        saidText: string;
+        cause: SpeechCause;
+    };
+    chatItem: {
+        item: ChatItem;
+    };
+    /** A `session.update` that needed a reconnect (STT) took effect. */
+    'session.updated': SessionSettings;
+    'action.started': {
+        ref: number;
+        type: ActionKind;
+    };
+    'action.finished': {
+        ref: number;
+        type: ActionKind;
+        /** `restore`: the call goes on with the AI. `cancelled`: stopped by `cancel` / `replace` / an interruption. */
+        result: 'success' | 'failed' | 'restore' | 'cancelled';
+        transfer?: TransferOutcome;
+        fieldCollect?: FieldCollectOutcome;
+        reason?: string;
+    };
+    /** A background (async-warm) transfer, after its action finished. */
+    'transfer.status': {
+        ref: number;
+        transfer: TransferOutcome;
+    };
+    'transfer.target_answered': {
+        ref: number;
+    };
+    'transfer.target_confirmed': {
+        ref: number;
+    };
+    'transfer.target_failed': {
+        ref: number;
+        reason?: string;
+    };
+    /** A key the caller pressed outside `field_collect`. */
+    dtmf: {
+        digit: string;
+    };
+    /** Twilio AMD as it came. `answeredBy`: human | machine_start | machine_end_beep | machine_end_silence | machine_end_other | fax | unknown. */
+    amd: {
+        answeredBy: string;
+        machineDetectionDuration?: number;
+    };
+    'far_end.hint': {
+        kind: 'voicemail' | 'human';
+        said: string;
+    };
+    /** Quiet for `notifyAfterMs` (again). `times` counts in a row, reset only by the caller speaking. */
+    /** `checkBack`: the one-shot notice `quiet.checkBackMs` asked for, not a usual one. */
+    'call.quiet': {
+        quietMs: number;
+        times: number;
+        checkBack?: boolean;
+    };
+    'instance.draining': {
+        deadlineMs: number;
+    };
+    error: {
+        code: string;
+        message: string;
+        ref?: number;
+    };
+};
+export type UpstreamType = keyof UpstreamEvents;
+/** Every upstream event carries the epoch current when it was sent. */
+export type UpstreamData<T extends UpstreamType> = UpstreamEvents[T] & {
+    epoch?: number;
+};
+export type UpstreamMessage = {
+    [T in UpstreamType]: Envelope<T, UpstreamData<T>>;
+}[UpstreamType];
+/**
+ * HTTP `onCallEvents`: upstream messages the Backend never acked on the socket, sent once the socket is
+ * gone. Deduplicate by (`callSid`, `seq`).
+ */
+export interface CallEventsBatch {
+    callSid: string;
+    events: UpstreamMessage[];
+}
+export declare const DEFAULT_INTERRUPTION: InterruptionSettings;
+export declare const DEFAULT_QUIET: QuietSettings;
+/** Only for a Backend that says nothing at all: the fallback line, then the end. A Backend sets its own. */
+export declare const DEFAULT_THINKING: ThinkingSettings;
+export declare const DEFAULT_FALLBACK: FallbackSettings;
+export declare const DEFAULT_QUEUE: QueueSettings;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/voice-service/protocol.js

@@ -0,0 +1,67 @@
+/**
+ * Voice service ⇄ Backend call protocol — the shared type file.
+ *
+ * Self-contained on purpose: no imports. The Backend copies this file as is
+ * (jupiter-backend-and-worker: packages/runtime/src/voice-service/protocol.ts); change it here first and
+ * copy it over, never edit the copy. Design: jupiter-voice-service docs/voice-service-event-protocol.md.
+ *
+ * Compatibility rules (there is one protocol version, no negotiation):
+ * - A receiver ignores any `type` it does not know.
+ * - Fields are only ever added, and every added field is optional.
+ */
+/** Close code a Backend uses to refuse the socket (bad signature, unknown call). Not retried. */
+export const CLOSE_UNAUTHORIZED = 4401;
+/** The provider as the voice service runs it; null for one it does not have. */
+export function canonicalTtsProvider(provider) {
+    switch (provider) {
+        case 'cartesia':
+        case 'inworld':
+        case 'fish':
+        case 'elevenlabs-ttd':
+            return provider;
+        case 'elevenlabs':
+        case 'elevenlabs-http':
+            return 'elevenlabs-ttd';
+        default:
+            return null;
+    }
+}
+/** Commands that go through the play queue and are checked against the epoch. */
+export const QUEUED_COMMANDS = [
+    'speak',
+    'speak.start',
+    'play',
+    'transfer',
+    'field_collect',
+    'realtime_chat',
+    'send_digits',
+    'hangup',
+    'wait',
+];
+// ═══ Defaults ══════════════════════════════════════════════════════════════════
+export const DEFAULT_INTERRUPTION = {
+    enabled: true,
+    minWords: 2,
+    protectMs: 0,
+    backchannels: [],
+    collisionMs: 1500,
+};
+export const DEFAULT_QUIET = {
+    notifyAfterMs: 9_000,
+    hangupAfterTimes: 15,
+    hangupAfterNoUserMs: 180_000,
+};
+/** Only for a Backend that says nothing at all: the fallback line, then the end. A Backend sets its own. */
+export const DEFAULT_THINKING = {
+    maxWaitMs: 30_000,
+    onTimeout: 'hangup',
+};
+export const DEFAULT_FALLBACK = {
+    text: 'Sorry, we are having technical difficulties. Please call back later. Goodbye.',
+    connectTimeoutMs: 8_000,
+    firstSpeechTimeoutMs: 10_000,
+    waitSound: 'music/jazz-01.ulaw',
+    waitSoundVolume: 0.3,
+};
+export const DEFAULT_QUEUE = { maxItems: 5 };
+//# sourceMappingURL=protocol.js.map