@kognitivedev/backend-cloud 0.2.29

package/dist/phone-runtime/openai-twilio-realtime.js

@@ -0,0 +1,1074 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeTwilioPcmuSignal = summarizeTwilioPcmuSignal;
+exports.isOpenAITwilioRealtimeReady = isOpenAITwilioRealtimeReady;
+exports.createOpenAITwilioRealtimeTools = createOpenAITwilioRealtimeTools;
+exports.createOpenAITwilioRealtimeSessionUpdate = createOpenAITwilioRealtimeSessionUpdate;
+exports.runOpenAITwilioRealtimeBridge = runOpenAITwilioRealtimeBridge;
+exports.runXAITwilioRealtimeBridge = runXAITwilioRealtimeBridge;
+const crypto_1 = require("crypto");
+const ws_1 = __importDefault(require("ws"));
+const cloud_voice_runtime_service_1 = require("../cloud-voice-runtime-service");
+const cloud_voice_prompt_service_1 = require("../cloud-voice-prompt-service");
+const audio_playout_tracker_1 = require("./audio-playout-tracker");
+const telephony_1 = require("@kognitivedev/telephony");
+const voice_media_bridge_1 = require("@kognitivedev/voice-media-bridge");
+const MAX_PRE_READY_AUDIO_FRAMES = 250;
+const LIKELY_SPEECH_RMS = 400;
+const LIKELY_SPEECH_PEAK_ABS = 2500;
+const MIN_INTERRUPT_ASSISTANT_AUDIO_MS = 240;
+const MIN_INTERRUPT_ELAPSED_MS = 120;
+const MIN_INTERRUPT_SPEECH_RMS = 220;
+const MIN_INTERRUPT_SPEECH_PEAK_ABS = 1400;
+const DEFAULT_PHONE_TURN_DETECTION = {
+    type: "server_vad",
+    create_response: true,
+    interrupt_response: true,
+};
+const DEFAULT_XAI_PHONE_TURN_DETECTION = {
+    type: "server_vad",
+    threshold: 0.55,
+    prefix_padding_ms: 160,
+    silence_duration_ms: 450,
+};
+function toOpenAIPhoneTurnDetection(value) {
+    const turnDetection = (0, cloud_voice_runtime_service_1.toOpenAITurnDetection)(value);
+    if (!turnDetection)
+        return turnDetection;
+    const type = getString(turnDetection.type);
+    return Object.assign(Object.assign(Object.assign({ type }, (typeof turnDetection.create_response === "boolean" ? { create_response: turnDetection.create_response } : {})), (typeof turnDetection.interrupt_response === "boolean" ? { interrupt_response: turnDetection.interrupt_response } : {})), (type === "semantic_vad" && typeof turnDetection.eagerness === "string" ? { eagerness: turnDetection.eagerness } : {}));
+}
+function toXAIPhoneTurnDetection(value) {
+    if (value === null)
+        return null;
+    const turnDetection = getRecord(value);
+    const type = getString(turnDetection.type, "server_vad");
+    if (type !== "server_vad")
+        return Object.assign({}, DEFAULT_XAI_PHONE_TURN_DETECTION);
+    const config = Object.assign({}, DEFAULT_XAI_PHONE_TURN_DETECTION);
+    if (typeof turnDetection.threshold === "number") {
+        config.threshold = turnDetection.threshold;
+    }
+    if (typeof turnDetection.prefix_padding_ms === "number") {
+        config.prefix_padding_ms = turnDetection.prefix_padding_ms;
+    }
+    else if (typeof turnDetection.prefixPaddingMs === "number") {
+        config.prefix_padding_ms = turnDetection.prefixPaddingMs;
+    }
+    if (typeof turnDetection.silence_duration_ms === "number") {
+        config.silence_duration_ms = turnDetection.silence_duration_ms;
+    }
+    else if (typeof turnDetection.silenceDurationMs === "number") {
+        config.silence_duration_ms = turnDetection.silenceDurationMs;
+    }
+    return config;
+}
+function getRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function getString(value, fallback = "") {
+    return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+function getRawString(value) {
+    return typeof value === "string" ? value : "";
+}
+function normalizeToolInput(value) {
+    if (typeof value !== "string")
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch (_a) {
+        return value;
+    }
+}
+function serializeToolResult(value) {
+    return typeof value === "string" ? value : JSON.stringify(value);
+}
+function serializeError(value) {
+    if (value instanceof Error) {
+        return {
+            name: value.name,
+            message: value.message,
+            stack: value.stack,
+        };
+    }
+    return value;
+}
+function sendJson(socket, message) {
+    if (socket.readyState !== ws_1.default.OPEN)
+        return false;
+    socket.send(JSON.stringify(message));
+    return true;
+}
+function sendOpenAIEvent(socket, event) {
+    return sendJson(socket, event);
+}
+function summarizePcm16Signal(samples) {
+    if (samples.length === 0)
+        return { samples: 0, peakAbs: 0, rms: 0 };
+    let peakAbs = 0;
+    let squareSum = 0;
+    for (const sample of samples) {
+        const abs = Math.abs(sample);
+        if (abs > peakAbs)
+            peakAbs = abs;
+        squareSum += sample * sample;
+    }
+    return {
+        samples: samples.length,
+        peakAbs,
+        rms: Math.round(Math.sqrt(squareSum / samples.length)),
+    };
+}
+function summarizeTwilioPcmuSignal(base64Audio) {
+    return (0, voice_media_bridge_1.summarizeCarrierPayload)((0, voice_media_bridge_1.getPhoneMediaProfile)("twilio-pcmu-8k"), base64Audio);
+}
+function isLikelySpeechTwilioPcmu(base64Audio) {
+    return (0, voice_media_bridge_1.isLikelySpeechPayload)((0, voice_media_bridge_1.getPhoneMediaProfile)("twilio-pcmu-8k"), base64Audio, {
+        rms: LIKELY_SPEECH_RMS,
+        peakAbs: LIKELY_SPEECH_PEAK_ABS,
+    });
+}
+function summarizeL16EndianCandidates(profile, payload) {
+    var _a;
+    if (profile.codec !== "l16")
+        return null;
+    const bytes = Buffer.byteLength(payload, "base64");
+    return {
+        configured: (_a = profile.carrierByteOrder) !== null && _a !== void 0 ? _a : "be",
+        be: (0, voice_media_bridge_1.summarizePcm16Signal)((0, voice_media_bridge_1.base64ToPcm16Be)(payload), bytes),
+        le: (0, voice_media_bridge_1.summarizePcm16Signal)((0, voice_media_bridge_1.base64ToPcm16Le)(payload), bytes),
+    };
+}
+function summarizeOpenAIAudioFormat(value) {
+    if (typeof value === "string")
+        return value;
+    const record = getRecord(value);
+    const type = getString(record.type, "");
+    const rate = typeof record.rate === "number" ? record.rate : undefined;
+    return type ? Object.assign({ type }, (rate ? { rate } : {})) : null;
+}
+function createOpenAIRealtimeReasoningConfig(snapshot, model) {
+    var _a;
+    if (!/^gpt-realtime-2(?:$|-)/.test(model))
+        return null;
+    const providerOptions = getRecord((_a = snapshot.runtime) === null || _a === void 0 ? void 0 : _a.providerOptions);
+    const reasoning = getRecord(providerOptions.reasoning);
+    if (Object.keys(reasoning).length > 0)
+        return reasoning;
+    const effort = getString(providerOptions.reasoningEffort, "");
+    return { effort: effort || "low" };
+}
+function isOpenAITwilioRealtimeReady(event, mediaProfile = (0, voice_media_bridge_1.getPhoneMediaProfile)("twilio-pcmu-8k")) {
+    return (0, voice_media_bridge_1.isOpenAIRealtimeAudioReady)(event, mediaProfile);
+}
+function createOpenAITwilioRealtimeTools(snapshot) {
+    var _a;
+    return ((_a = snapshot.toolManifest) !== null && _a !== void 0 ? _a : [])
+        .filter((manifest) => getString(manifest.name, ""))
+        .map((manifest) => {
+        var _a;
+        return ({
+            type: "function",
+            name: getString(manifest.name, ""),
+            description: getString(manifest.description, getString(manifest.name, "")),
+            parameters: (_a = manifest.parameters) !== null && _a !== void 0 ? _a : { type: "object", additionalProperties: true },
+        });
+    });
+}
+function createOpenAITwilioRealtimeSessionUpdate(snapshot, model, defaultVoice = "alloy", provider = "openai-realtime", mediaProfile = (0, voice_media_bridge_1.getPhoneMediaProfile)("twilio-pcmu-8k"), audioRoute = (0, voice_media_bridge_1.createPhoneAudioRoute)(mediaProfile, provider)) {
+    var _a, _b, _c;
+    const voiceConfig = (_a = snapshot.voiceConfig) !== null && _a !== void 0 ? _a : {};
+    const inputConfig = {
+        format: (0, voice_media_bridge_1.realtimeAudioFormatForRoute)(audioRoute),
+    };
+    const turnDetection = provider === "xai-realtime"
+        ? toXAIPhoneTurnDetection(voiceConfig.turnDetection)
+        : toOpenAIPhoneTurnDetection(voiceConfig.turnDetection);
+    if (provider !== "xai-realtime") {
+        inputConfig.turn_detection = typeof turnDetection === "undefined"
+            ? DEFAULT_PHONE_TURN_DETECTION
+            : turnDetection;
+    }
+    if (voiceConfig.transcription && typeof voiceConfig.transcription === "object") {
+        inputConfig.transcription = voiceConfig.transcription;
+    }
+    if (voiceConfig.inputNoiseReduction && typeof voiceConfig.inputNoiseReduction === "object") {
+        inputConfig.noise_reduction = voiceConfig.inputNoiseReduction;
+    }
+    const tools = createOpenAITwilioRealtimeTools(snapshot);
+    const voice = getString((_b = voiceConfig.voice) !== null && _b !== void 0 ? _b : (_c = snapshot.runtime) === null || _c === void 0 ? void 0 : _c.voice, defaultVoice);
+    const reasoning = provider === "openai-realtime" ? createOpenAIRealtimeReasoningConfig(snapshot, model) : null;
+    const instructions = (0, cloud_voice_prompt_service_1.resolveCloudVoiceProviderSystemPrompt)({
+        voiceConfig,
+        config: snapshot.config,
+    });
+    const session = provider === "xai-realtime" ? {
+        instructions,
+        voice,
+        audio: {
+            input: inputConfig,
+            output: {
+                format: (0, voice_media_bridge_1.realtimeOutputAudioFormatForRoute)(audioRoute),
+            },
+        },
+    } : Object.assign(Object.assign({ type: "realtime", model,
+        instructions, output_modalities: ["audio"] }, (reasoning ? { reasoning } : {})), { audio: {
+            input: inputConfig,
+            output: {
+                format: (0, voice_media_bridge_1.realtimeOutputAudioFormatForRoute)(audioRoute),
+                voice,
+            },
+        } });
+    if (provider === "xai-realtime") {
+        session.turn_detection = typeof turnDetection === "undefined"
+            ? { type: "server_vad" }
+            : turnDetection;
+    }
+    if (tools.length > 0) {
+        session.tools = tools;
+        if (provider !== "xai-realtime") {
+            session.tool_choice = "auto";
+        }
+    }
+    return {
+        type: "session.update",
+        session,
+    };
+}
+function sendOpenAIUserTextTurn(socket, text) {
+    sendOpenAIEvent(socket, {
+        type: "conversation.item.create",
+        item: {
+            type: "message",
+            role: "user",
+            content: [{ type: "input_text", text }],
+        },
+    });
+    sendOpenAIEvent(socket, { type: "response.create" });
+}
+function summarizeOpenAIResponseOutputTypes(response) {
+    const output = getRecord(response).output;
+    if (!Array.isArray(output))
+        return [];
+    return output.map((item) => getString(getRecord(item).type, "unknown"));
+}
+function extractOpenAIContentText(content) {
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .flatMap((part) => {
+        const record = getRecord(part);
+        const transcript = getRawString(record.transcript).trim();
+        if (transcript)
+            return [transcript];
+        const text = getRawString(record.text).trim();
+        if (text)
+            return [text];
+        return [];
+    })
+        .join("\n")
+        .trim();
+}
+function extractOpenAIAssistantItemText(item) {
+    if (getString(item.type, "") !== "message")
+        return "";
+    const role = getString(item.role, "");
+    if (role && role !== "assistant")
+        return "";
+    return extractOpenAIContentText(item.content);
+}
+function extractOpenAIResponseText(response) {
+    const output = response.output;
+    if (!Array.isArray(output))
+        return "";
+    return output
+        .flatMap((item) => {
+        const text = extractOpenAIAssistantItemText(getRecord(item));
+        return text ? [text] : [];
+    })
+        .join("\n")
+        .trim();
+}
+function normalizeTelnyxMediaStreamMessage(raw) {
+    const event = getString(raw.event);
+    const streamId = getString(raw.stream_id);
+    const start = getRecord(raw.start);
+    const media = getRecord(raw.media);
+    const stop = getRecord(raw.stop);
+    const dtmf = getRecord(raw.dtmf);
+    return {
+        event,
+        protocol: getString(raw.protocol),
+        version: getString(raw.version),
+        streamSid: streamId,
+        start: {
+            streamSid: streamId,
+            accountSid: null,
+            callSid: getString(start.call_control_id),
+            tracks: [],
+            mediaFormat: getRecord(start.media_format),
+            customParameters: {
+                callSessionId: getString(start.call_session_id),
+                clientState: getString(start.client_state),
+            },
+        },
+        media: {
+            track: getString(media.track),
+            chunk: getString(media.chunk),
+            timestamp: getString(media.timestamp),
+            payload: getString(media.payload),
+        },
+        mark: getRecord(raw.mark),
+        dtmf: {
+            digit: getString(dtmf.digit),
+        },
+        stop: {
+            accountSid: null,
+            callSid: getString(stop.call_control_id),
+        },
+    };
+}
+function parseCarrierMediaStreamMessage(profile, raw) {
+    const parsed = JSON.parse(raw);
+    return profile.provider === "telnyx"
+        ? normalizeTelnyxMediaStreamMessage(parsed)
+        : (0, telephony_1.parseTwilioMediaStreamMessage)(parsed);
+}
+async function runOpenAITwilioRealtimeBridge(input) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    const provider = (_a = input.provider) !== null && _a !== void 0 ? _a : "openai-realtime";
+    const providerLogPrefix = provider === "xai-realtime" ? "xai" : "openai";
+    const bridgeMode = (_b = input.bridgeMode) !== null && _b !== void 0 ? _b : (provider === "xai-realtime" ? "xai-twilio-realtime" : "openai-twilio-realtime-ga");
+    const supportsConversationItemTruncate = (_c = input.supportsConversationItemTruncate) !== null && _c !== void 0 ? _c : provider === "openai-realtime";
+    const model = getString((_d = input.snapshot.runtime) === null || _d === void 0 ? void 0 : _d.model, (_e = input.defaultModel) !== null && _e !== void 0 ? _e : "gpt-realtime");
+    const realtimeUrl = (_f = input.realtimeUrl) !== null && _f !== void 0 ? _f : `wss://api.openai.com/v1/realtime?model=${encodeURIComponent(model)}`;
+    const mediaProfile = (_g = input.mediaProfile) !== null && _g !== void 0 ? _g : (0, voice_media_bridge_1.getPhoneMediaProfile)("twilio-pcmu-8k");
+    const audioRoute = (_h = input.audioRoute) !== null && _h !== void 0 ? _h : (0, voice_media_bridge_1.createPhoneAudioRoute)(mediaProfile, provider);
+    const tools = createOpenAITwilioRealtimeTools(input.snapshot);
+    const humanization = (0, cloud_voice_runtime_service_1.normalizeCloudVoiceHumanizationConfig)(getRecord(input.snapshot.config).humanization);
+    const openAI = new ws_1.default(realtimeUrl, {
+        headers: {
+            Authorization: `Bearer ${input.apiKey}`,
+        },
+    });
+    let twilioStarted = false;
+    let providerConnected = false;
+    let phoneAudioReady = false;
+    let greeted = false;
+    let streamSid = null;
+    let latestMediaTimestamp = 0;
+    let responseStartTimestampTwilio = null;
+    let lastAssistantItemId = null;
+    let lastAssistantItemAudioMs = 0;
+    let responseOutboundFramesAtStart = 0;
+    let currentAssistantTranscript = "";
+    let currentAssistantFinalTranscript = "";
+    let missingStreamSidAudioWarningEmitted = false;
+    let preReadyAudioHadSpeech = false;
+    let latestInboundSignal = { bytes: 0, samples: 0, peakAbs: 0, rms: 0 };
+    let ignoredCarrierMediaFrames = 0;
+    const carrierMediaTracks = {};
+    const preReadyAudioFrames = [];
+    const markQueue = [];
+    const playoutTracker = new audio_playout_tracker_1.PhonePlayoutTracker();
+    const unregisterPlayoutIdleWaiter = (_j = input.registerPlayoutIdleWaiter) === null || _j === void 0 ? void 0 : _j.call(input, (waitInput) => playoutTracker.waitForIdle(waitInput));
+    const counters = {
+        inboundMediaFrames: 0,
+        providerInputFrames: 0,
+        providerInputDroppedBeforeReady: 0,
+        outboundMediaFrames: 0,
+        outboundAudioDroppedMissingStreamSid: 0,
+        outboundAudioBytes: 0,
+        outboundAudioPeakAbs: 0,
+        outboundAudioLastRms: 0,
+        clears: 0,
+        truncates: 0,
+        marks: 0,
+        dtmf: 0,
+        interruptions: 0,
+        ignoredInterruptions: 0,
+        toolCalls: 0,
+        providerMessages: 0,
+    };
+    const bindStreamSid = (nextStreamSid, source) => {
+        const next = getString(nextStreamSid, "");
+        if (!next || next === streamSid)
+            return;
+        streamSid = next;
+        input.updateCallLegActive({ streamSid });
+        input.log("twilio.stream_sid.bound", {
+            projectId: input.projectId,
+            sessionId: input.sessionId,
+            streamSid,
+            source,
+        });
+    };
+    const maybeGreet = () => {
+        var _a, _b, _c, _d;
+        if (greeted || !twilioStarted || !providerConnected || !phoneAudioReady)
+            return;
+        greeted = true;
+        if (preReadyAudioHadSpeech) {
+            input.log(`${providerLogPrefix}.initial_prompt.skipped`, {
+                projectId: input.projectId,
+                sessionId: input.sessionId,
+                providerCallId: (_a = input.providerCallId) !== null && _a !== void 0 ? _a : null,
+                reason: "caller_audio_before_ready",
+            });
+            return;
+        }
+        if (input.initialPrompt === null) {
+            input.log(`${providerLogPrefix}.initial_prompt.skipped`, {
+                projectId: input.projectId,
+                sessionId: input.sessionId,
+                providerCallId: (_b = input.providerCallId) !== null && _b !== void 0 ? _b : null,
+                reason: "openingMode.wait",
+            });
+            return;
+        }
+        input.log(`${providerLogPrefix}.initial_prompt.sent`, {
+            projectId: input.projectId,
+            sessionId: input.sessionId,
+            providerCallId: (_c = input.providerCallId) !== null && _c !== void 0 ? _c : null,
+            method: "conversation.item.create + response.create",
+        });
+        sendOpenAIUserTextTurn(openAI, (_d = input.initialPrompt) !== null && _d !== void 0 ? _d : "Start the phone call now. Greet the caller briefly and ask how you can help.");
+    };
+    const appendOpenAIAudio = (audio) => {
+        sendOpenAIEvent(openAI, {
+            type: "input_audio_buffer.append",
+            audio: (0, voice_media_bridge_1.toAiInputAudio)(audioRoute, audio),
+        });
+        counters.providerInputFrames += 1;
+    };
+    const flushPreReadyAudio = () => {
+        var _a;
+        if (!phoneAudioReady || openAI.readyState !== ws_1.default.OPEN || preReadyAudioFrames.length === 0)
+            return;
+        const frameCount = preReadyAudioFrames.length;
+        for (const audio of preReadyAudioFrames.splice(0)) {
+            appendOpenAIAudio(audio);
+        }
+        input.log(`${providerLogPrefix}.audio.input.pre_ready_flushed`, {
+            projectId: input.projectId,
+            sessionId: input.sessionId,
+            providerCallId: (_a = input.providerCallId) !== null && _a !== void 0 ? _a : null,
+            frameCount,
+            hadSpeech: preReadyAudioHadSpeech,
+        });
+    };
+    const bufferPreReadyAudio = (audio) => {
+        if (preReadyAudioFrames.length >= MAX_PRE_READY_AUDIO_FRAMES) {
+            preReadyAudioFrames.shift();
+            counters.providerInputDroppedBeforeReady += 1;
+        }
+        preReadyAudioFrames.push(audio);
+        preReadyAudioHadSpeech || (preReadyAudioHadSpeech = (0, voice_media_bridge_1.isLikelySpeechPayload)(mediaProfile, audio, {
+            rms: LIKELY_SPEECH_RMS,
+            peakAbs: LIKELY_SPEECH_PEAK_ABS,
+        }));
+    };
+    const dropOutboundAudioForMissingStreamSid = (eventType, delta) => {
+        counters.outboundAudioDroppedMissingStreamSid += 1;
+        const output = (0, voice_media_bridge_1.fromAiOutputAudio)(audioRoute, delta);
+        const signal = output.signal;
+        const payload = {
+            provider,
+            reason: "missing_twilio_stream_sid",
+            eventType,
+            droppedFrames: counters.outboundAudioDroppedMissingStreamSid,
+            droppedAudioBytes: signal.bytes,
+            inboundMediaFrames: counters.inboundMediaFrames,
+            providerInputFrames: counters.providerInputFrames,
+            providerMessages: counters.providerMessages,
+        };
+        input.log(`${providerLogPrefix}.audio.output.dropped`, Object.assign({ projectId: input.projectId, sessionId: input.sessionId }, payload));
+        if (!missingStreamSidAudioWarningEmitted) {
+            missingStreamSidAudioWarningEmitted = true;
+            input.appendEvent("voice.provider.warning", Object.assign(Object.assign({}, payload), { message: `${provider === "xai-realtime" ? "xAI" : "OpenAI"} returned assistant audio, but the bridge has no Twilio streamSid to send it to.` }), "Assistant audio could not be sent to Twilio");
+        }
+        if (counters.outboundAudioDroppedMissingStreamSid === 1 || counters.outboundAudioDroppedMissingStreamSid % 50 === 0) {
+            input.appendEvent("voice.call.audio.dropped", payload, "Assistant audio dropped before Twilio stream was bound");
+        }
+    };
+    const ignoreAssistantInterruption = (reason, details = {}) => {
+        counters.ignoredInterruptions += 1;
+        input.log(`${providerLogPrefix}.audio.interruption_ignored`, Object.assign({ projectId: input.projectId, sessionId: input.sessionId, reason,
+            counters }, details));
+        if (counters.ignoredInterruptions === 1 || counters.ignoredInterruptions % 10 === 0) {
+            input.appendEvent("voice.assistant.interruption_ignored", Object.assign({ provider,
+                reason,
+                counters }, details));
+        }
+    };
+    const interruptAssistantAudio = () => {
+        if (!streamSid || markQueue.length === 0 || responseStartTimestampTwilio === null)
+            return;
+        const elapsedMs = Math.max(0, latestMediaTimestamp - responseStartTimestampTwilio);
+        if (elapsedMs < MIN_INTERRUPT_ELAPSED_MS || lastAssistantItemAudioMs < MIN_INTERRUPT_ASSISTANT_AUDIO_MS) {
+            ignoreAssistantInterruption("assistant_audio_too_short", {
+                elapsedMs,
+                assistantAudioMs: lastAssistantItemAudioMs,
+                pendingMarks: markQueue.length,
+            });
+            return;
+        }
+        if (latestInboundSignal.samples > 0
+            && latestInboundSignal.rms < MIN_INTERRUPT_SPEECH_RMS
+            && latestInboundSignal.peakAbs < MIN_INTERRUPT_SPEECH_PEAK_ABS) {
+            ignoreAssistantInterruption("weak_recent_input_signal", {
+                elapsedMs,
+                assistantAudioMs: lastAssistantItemAudioMs,
+                latestInboundSignal,
+                pendingMarks: markQueue.length,
+            });
+            return;
+        }
+        const truncateMs = lastAssistantItemAudioMs > 0
+            ? Math.min(elapsedMs, Math.max(0, lastAssistantItemAudioMs - 20))
+            : elapsedMs;
+        counters.interruptions += 1;
+        const playoutInterruption = playoutTracker.interrupt({
+            elapsedMs: truncateMs,
+            providerTruncationSupported: supportsConversationItemTruncate,
+        });
+        if (supportsConversationItemTruncate && lastAssistantItemId && truncateMs >= 0) {
+            counters.truncates += 1;
+            sendOpenAIEvent(openAI, {
+                type: "conversation.item.truncate",
+                item_id: lastAssistantItemId,
+                content_index: 0,
+                audio_end_ms: truncateMs,
+            });
+            input.appendEvent("voice.call.audio.truncate_sent", Object.assign(Object.assign({ provider, itemId: lastAssistantItemId, audioEndMs: truncateMs, elapsedMs }, playoutInterruption), { counters }));
+        }
+        counters.clears += 1;
+        const clearMessage = (0, voice_media_bridge_1.createCarrierClearMessage)(mediaProfile, streamSid);
+        if (clearMessage)
+            sendJson(input.socket, clearMessage);
+        input.appendEvent("voice.call.audio.clear_sent", Object.assign(Object.assign({ provider: mediaProfile.provider, streamSid,
+            elapsedMs }, playoutInterruption), { counters }));
+        if (!supportsConversationItemTruncate) {
+            sendOpenAIEvent(openAI, { type: "response.cancel" });
+            input.appendEvent("voice.call.response_cancel_sent", {
+                provider,
+                elapsedMs,
+                counters,
+            });
+        }
+        input.log(`${providerLogPrefix}.audio.interrupted`, {
+            projectId: input.projectId,
+            sessionId: input.sessionId,
+            streamSid,
+            elapsedMs,
+            truncateMs,
+            assistantAudioMs: lastAssistantItemAudioMs,
+            pendingMarks: markQueue.length,
+        });
+        input.appendEvent("voice.assistant.interrupted", Object.assign({ provider,
+            elapsedMs }, playoutInterruption));
+        markQueue.length = 0;
+        responseStartTimestampTwilio = null;
+        lastAssistantItemId = null;
+        lastAssistantItemAudioMs = 0;
+    };
+    const handleToolCall = async (item) => {
+        var _a, _b, _c, _d;
+        const toolId = getString(item.name, "");
+        const toolCallId = getString(item.call_id, getString(item.id, (0, crypto_1.randomUUID)()));
+        if (!toolId)
+            return;
+        counters.toolCalls += 1;
+        input.log(`${providerLogPrefix}.tool.execute.start`, {
+            projectId: input.projectId,
+            sessionId: input.sessionId,
+            providerCallId: (_a = input.providerCallId) !== null && _a !== void 0 ? _a : null,
+            toolId,
+            toolCallId,
+            toolLatencyFillerMs: humanization.toolLatencyFillerMs,
+        });
+        try {
+            const result = await input.executeTool({
+                toolId,
+                args: normalizeToolInput(getString(item.arguments, "{}")),
+                toolCallId,
+                providerCallId: (_b = input.providerCallId) !== null && _b !== void 0 ? _b : null,
+            });
+            sendOpenAIEvent(openAI, {
+                type: "conversation.item.create",
+                item: {
+                    type: "function_call_output",
+                    call_id: toolCallId,
+                    output: serializeToolResult(result.result),
+                },
+            });
+            sendOpenAIEvent(openAI, { type: "response.create" });
+            input.log(`${providerLogPrefix}.tool.execute.completed`, {
+                projectId: input.projectId,
+                sessionId: input.sessionId,
+                providerCallId: (_c = input.providerCallId) !== null && _c !== void 0 ? _c : null,
+                toolId,
+                toolCallId,
+            });
+        }
+        catch (error) {
+            input.error(`${providerLogPrefix}.tool.execute.failed`, error, {
+                projectId: input.projectId,
+                sessionId: input.sessionId,
+                providerCallId: (_d = input.providerCallId) !== null && _d !== void 0 ? _d : null,
+                toolId,
+                toolCallId,
+            });
+            sendOpenAIEvent(openAI, {
+                type: "conversation.item.create",
+                item: {
+                    type: "function_call_output",
+                    call_id: toolCallId,
+                    output: serializeToolResult({ error: error instanceof Error ? error.message : String(error) }),
+                },
+            });
+            sendOpenAIEvent(openAI, { type: "response.create" });
+        }
+    };
+    const handleOpenAIMessage = (rawData) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        let event;
+        try {
+            event = JSON.parse(rawData.toString());
+        }
+        catch (error) {
+            input.error(`${providerLogPrefix}.message.parse.failed`, error, { projectId: input.projectId, sessionId: input.sessionId });
+            return;
+        }
+        counters.providerMessages += 1;
+        const eventType = getString(event.type, "");
+        if (eventType === "error") {
+            input.error(`${providerLogPrefix}.session.error`, event, { projectId: input.projectId, sessionId: input.sessionId });
+            input.appendEvent("voice.provider.error", { provider, error: event });
+            return;
+        }
+        if (eventType === "session.updated") {
+            phoneAudioReady = (0, voice_media_bridge_1.isRealtimeAudioReadyForRoute)(event, audioRoute);
+            const audio = getRecord(getRecord(event.session).audio);
+            input.log(`${providerLogPrefix}.session.updated`, {
+                projectId: input.projectId,
+                sessionId: input.sessionId,
+                inputFormat: summarizeOpenAIAudioFormat(getRecord(audio.input).format),
+                outputFormat: summarizeOpenAIAudioFormat(getRecord(audio.output).format),
+                phoneAudioReady,
+                mediaProfile: mediaProfile.id,
+            });
+            if (!phoneAudioReady) {
+                input.appendEvent("voice.provider.warning", {
+                    provider,
+                    reason: `${provider === "xai-realtime" ? "xAI" : "OpenAI"} session did not confirm ${audioRoute.aiInput.format} phone audio format`,
+                    inputFormat: summarizeOpenAIAudioFormat(getRecord(audio.input).format),
+                    outputFormat: summarizeOpenAIAudioFormat(getRecord(audio.output).format),
+                    mediaProfile: mediaProfile.id,
+                });
+            }
+            flushPreReadyAudio();
+            maybeGreet();
+            return;
+        }
+        if (eventType === "input_audio_buffer.speech_started") {
+            interruptAssistantAudio();
+            return;
+        }
+        if (eventType === "conversation.item.input_audio_transcription.completed") {
+            const transcript = getString(event.transcript, "");
+            if (transcript) {
+                input.appendEvent("voice.user.transcribed", {
+                    provider,
+                    text: transcript,
+                    usage: (_a = event.usage) !== null && _a !== void 0 ? _a : undefined,
+                }, transcript);
+            }
+            return;
+        }
+        if (eventType === "response.created") {
+            const response = getRecord(event.response);
+            responseStartTimestampTwilio = null;
+            lastAssistantItemId = null;
+            lastAssistantItemAudioMs = 0;
+            responseOutboundFramesAtStart = counters.outboundMediaFrames;
+            currentAssistantTranscript = "";
+            currentAssistantFinalTranscript = "";
+            input.log(`${providerLogPrefix}.response.created`, {
+                projectId: input.projectId,
+                sessionId: input.sessionId,
+                responseId: getString(response.id, ""),
+            });
+            input.appendEvent("voice.assistant.started", {
+                provider,
+                responseId: getString(response.id, ""),
+            });
+            return;
+        }
+        if (eventType === "response.output_audio.delta" || eventType === "response.audio.delta") {
+            const delta = getString(event.delta, "");
+            if (!delta)
+                return;
+            if (!streamSid && mediaProfile.provider !== "telnyx") {
+                dropOutboundAudioForMissingStreamSid(eventType, delta);
+                return;
+            }
+            if ((_b = input.isAiPaused) === null || _b === void 0 ? void 0 : _b.call(input)) {
+                input.log(`${providerLogPrefix}.audio.output.paused_for_handoff`, {
+                    projectId: input.projectId,
+                    sessionId: input.sessionId,
+                    providerCallId: (_c = input.providerCallId) !== null && _c !== void 0 ? _c : null,
+                    outboundMediaFrames: counters.outboundMediaFrames,
+                });
+                return;
+            }
+            const carrierOutput = (0, voice_media_bridge_1.fromAiOutputAudio)(audioRoute, delta);
+            const mediaMessage = (0, voice_media_bridge_1.createCarrierMediaMessage)(mediaProfile, streamSid, carrierOutput.payload);
+            const sent = mediaMessage ? sendJson(input.socket, mediaMessage) : false;
+            if (!sent)
+                return;
+            const itemId = getString(event.item_id, lastAssistantItemId !== null && lastAssistantItemId !== void 0 ? lastAssistantItemId : "");
+            if (itemId && itemId !== lastAssistantItemId) {
+                responseStartTimestampTwilio = latestMediaTimestamp;
+                lastAssistantItemAudioMs = 0;
+                playoutTracker.startAssistantItem(itemId || null);
+            }
+            counters.outboundMediaFrames += 1;
+            const signal = carrierOutput.signal;
+            counters.outboundAudioBytes += signal.bytes;
+            counters.outboundAudioPeakAbs = Math.max(counters.outboundAudioPeakAbs, signal.peakAbs);
+            counters.outboundAudioLastRms = signal.rms;
+            lastAssistantItemAudioMs += carrierOutput.durationMs;
+            if (responseStartTimestampTwilio === null)
+                responseStartTimestampTwilio = latestMediaTimestamp;
+            lastAssistantItemId = itemId;
+            const markName = `${providerLogPrefix}:${counters.outboundMediaFrames}`;
+            const markMessage = (0, voice_media_bridge_1.createCarrierMarkMessage)(mediaProfile, streamSid, markName);
+            if (markMessage)
+                sendJson(input.socket, markMessage);
+            markQueue.push(markName);
+            playoutTracker.recordOutboundFrame({ markName, itemId: itemId || null, durationMs: carrierOutput.durationMs });
+            (_d = input.onAudioFrame) === null || _d === void 0 ? void 0 : _d.call(input, {
+                source: "assistant",
+                payload: carrierOutput.payload,
+                metadata: { provider, frame: counters.outboundMediaFrames },
+            });
+            if (counters.outboundMediaFrames === 1 || counters.outboundMediaFrames % 50 === 0) {
+                input.log(`${providerLogPrefix}.audio.output.summary`, {
+                    projectId: input.projectId,
+                    sessionId: input.sessionId,
+                    streamSid,
+                    outboundMediaFrames: counters.outboundMediaFrames,
+                    outboundAudioBytes: counters.outboundAudioBytes,
+                    lastSignal: signal,
+                });
+            }
+            return;
+        }
+        if (eventType === "response.output_audio_transcript.delta" || eventType === "response.audio_transcript.delta") {
+            const delta = getRawString(event.delta);
+            currentAssistantTranscript += delta;
+            if (delta) {
+                input.appendEvent("voice.assistant.transcript.delta", {
+                    provider,
+                    delta,
+                }, delta);
+            }
+            return;
+        }
+        if (eventType === "response.output_audio_transcript.done" || eventType === "response.audio_transcript.done") {
+            const transcript = getRawString(event.transcript).trim();
+            if (transcript)
+                currentAssistantFinalTranscript = transcript;
+            return;
+        }
+        if (eventType === "response.output_audio.done" || eventType === "response.audio.done") {
+            input.log(`${providerLogPrefix}.audio.output.done`, {
+                projectId: input.projectId,
+                sessionId: input.sessionId,
+                responseId: getString(event.response_id, ""),
+                outboundMediaFrames: counters.outboundMediaFrames,
+                outboundAudioBytes: counters.outboundAudioBytes,
+            });
+            return;
+        }
+        if (eventType === "response.output_item.done") {
+            const item = getRecord(event.item);
+            const assistantText = extractOpenAIAssistantItemText(item);
+            if (assistantText)
+                currentAssistantFinalTranscript = assistantText;
+            if (item.type === "function_call" && getString(item.status, "") === "completed") {
+                void handleToolCall(item);
+            }
+            return;
+        }
+        if (eventType === "response.done") {
+            const response = getRecord(event.response);
+            const text = currentAssistantFinalTranscript
+                || extractOpenAIResponseText(response)
+                || currentAssistantTranscript.trim();
+            const status = getString(response.status, "");
+            if (text && status !== "cancelled" && counters.outboundMediaFrames === responseOutboundFramesAtStart) {
+                input.appendEvent("voice.provider.warning", {
+                    provider,
+                    reason: "assistant_text_without_outbound_audio",
+                    responseId: getString(response.id, ""),
+                    text,
+                    streamSid,
+                    counters,
+                }, "Assistant response produced text but no outbound phone audio");
+            }
+            currentAssistantTranscript = "";
+            currentAssistantFinalTranscript = "";
+            input.log(`${providerLogPrefix}.response.done`, {
+                projectId: input.projectId,
+                sessionId: input.sessionId,
+                responseId: getString(response.id, ""),
+                status,
+                statusDetails: (_e = response.status_details) !== null && _e !== void 0 ? _e : null,
+                outputTypes: summarizeOpenAIResponseOutputTypes(response),
+                counters,
+            });
+            input.appendEvent("voice.assistant.stopped", {
+                provider,
+                responseId: getString(response.id, ""),
+                status: getString(response.status, ""),
+                statusDetails: (_f = response.status_details) !== null && _f !== void 0 ? _f : undefined,
+                text: text || undefined,
+                usage: (_g = response.usage) !== null && _g !== void 0 ? _g : undefined,
+                counters,
+            }, text || undefined);
+            (_h = input.onAssistantTurnComplete) === null || _h === void 0 ? void 0 : _h.call(input);
+        }
+    };
+    const handleTwilioMessage = (data) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+        try {
+            const parsed = parseCarrierMediaStreamMessage(mediaProfile, typeof data === "string" ? data : data.toString());
+            if (parsed.event === "connected") {
+                input.log(`${mediaProfile.provider}.connected`, {
+                    projectId: input.projectId,
+                    sessionId: input.sessionId,
+                    protocol: parsed.protocol,
+                    version: parsed.version,
+                });
+            }
+            else if (parsed.event === "start") {
+                twilioStarted = true;
+                bindStreamSid((_b = (_a = parsed.start.streamSid) !== null && _a !== void 0 ? _a : parsed.streamSid) !== null && _b !== void 0 ? _b : null, `${mediaProfile.provider}.start`);
+                responseStartTimestampTwilio = null;
+                latestMediaTimestamp = 0;
+                lastAssistantItemId = null;
+                lastAssistantItemAudioMs = 0;
+                preReadyAudioFrames.length = 0;
+                preReadyAudioHadSpeech = false;
+                markQueue.length = 0;
+                input.log(`${mediaProfile.provider}.start`, {
+                    projectId: input.projectId,
+                    sessionId: input.sessionId,
+                    providerCallId: (_d = (_c = parsed.start.callSid) !== null && _c !== void 0 ? _c : input.providerCallId) !== null && _d !== void 0 ? _d : null,
+                    streamSid,
+                    mediaFormat: parsed.start.mediaFormat,
+                });
+                input.updateSessionActive();
+                (_e = input.onCarrierAudioSender) === null || _e === void 0 ? void 0 : _e.call(input, (payload) => {
+                    const mediaMessage = (0, voice_media_bridge_1.createCarrierMediaMessage)(mediaProfile, streamSid, payload);
+                    return mediaMessage ? sendJson(input.socket, mediaMessage) : false;
+                });
+                input.appendEvent("voice.call.started", {
+                    provider: mediaProfile.provider,
+                    providerCallId: (_g = (_f = parsed.start.callSid) !== null && _f !== void 0 ? _f : input.providerCallId) !== null && _g !== void 0 ? _g : null,
+                    streamSid,
+                    mediaFormat: parsed.start.mediaFormat,
+                }, `${mediaProfile.provider} media stream started`);
+                maybeGreet();
+            }
+            else if (parsed.event === "media") {
+                bindStreamSid(parsed.streamSid, `${mediaProfile.provider}.media`);
+                const mediaTrack = getString(parsed.media.track, "");
+                const mediaTrackKey = mediaTrack || "unknown";
+                carrierMediaTracks[mediaTrackKey] = ((_h = carrierMediaTracks[mediaTrackKey]) !== null && _h !== void 0 ? _h : 0) + 1;
+                if (mediaProfile.provider === "telnyx" && mediaTrack && mediaTrack !== "inbound") {
+                    ignoredCarrierMediaFrames += 1;
+                    if (ignoredCarrierMediaFrames === 1 || ignoredCarrierMediaFrames % 250 === 0) {
+                        input.log(`${mediaProfile.provider}.media.ignored`, {
+                            projectId: input.projectId,
+                            sessionId: input.sessionId,
+                            providerCallId: (_j = input.providerCallId) !== null && _j !== void 0 ? _j : null,
+                            track: mediaTrack,
+                            ignoredCarrierMediaFrames,
+                            carrierMediaTracks,
+                        });
+                    }
+                    return;
+                }
+                counters.inboundMediaFrames += 1;
+                latestInboundSignal = (0, voice_media_bridge_1.summarizeCarrierPayload)(mediaProfile, parsed.media.payload);
+                const l16EndianSignals = summarizeL16EndianCandidates(mediaProfile, parsed.media.payload);
+                latestMediaTimestamp = Number.parseInt((_k = parsed.media.timestamp) !== null && _k !== void 0 ? _k : "0", 10) || latestMediaTimestamp;
+                (_l = input.onAudioFrame) === null || _l === void 0 ? void 0 : _l.call(input, {
+                    source: "caller",
+                    payload: parsed.media.payload,
+                    metadata: Object.assign({ provider: mediaProfile.provider, frame: counters.inboundMediaFrames }, (l16EndianSignals ? { l16ByteOrder: l16EndianSignals.configured } : {})),
+                });
+                if ((_m = input.isAiPaused) === null || _m === void 0 ? void 0 : _m.call(input)) {
+                    counters.providerInputDroppedBeforeReady += 1;
+                }
+                else if (openAI.readyState === ws_1.default.OPEN && phoneAudioReady) {
+                    appendOpenAIAudio(parsed.media.payload);
+                }
+                else {
+                    bufferPreReadyAudio(parsed.media.payload);
+                }
+                if (counters.inboundMediaFrames === 1
+                    || counters.inboundMediaFrames % 250 === 0
+                    || counters.providerInputDroppedBeforeReady === 1) {
+                    input.log(`${providerLogPrefix}.audio.input.summary`, Object.assign(Object.assign({ projectId: input.projectId, sessionId: input.sessionId, providerCallId: (_o = input.providerCallId) !== null && _o !== void 0 ? _o : null, inboundMediaFrames: counters.inboundMediaFrames, providerInputFrames: counters.providerInputFrames, providerInputDroppedBeforeReady: counters.providerInputDroppedBeforeReady, providerInputBufferedBeforeReady: preReadyAudioFrames.length, preReadyAudioHadSpeech,
+                        latestInboundSignal }, (l16EndianSignals ? { l16EndianSignals } : {})), { carrierMediaTracks,
+                        ignoredCarrierMediaFrames, mediaTrack: mediaTrack || null, providerConnected,
+                        phoneAudioReady }));
+                }
+                if (counters.inboundMediaFrames === 1 || counters.inboundMediaFrames % 250 === 0) {
+                    input.log(`${mediaProfile.provider}.media.summary`, Object.assign(Object.assign({ projectId: input.projectId, sessionId: input.sessionId, inboundMediaFrames: counters.inboundMediaFrames, latestInboundSignal }, (l16EndianSignals ? { l16EndianSignals } : {})), { carrierMediaTracks,
+                        ignoredCarrierMediaFrames }));
+                    input.appendEvent("voice.call.audio.summary", {
+                        provider: mediaProfile.provider,
+                        mediaProfile: mediaProfile.id,
+                        inboundMediaFrames: counters.inboundMediaFrames,
+                    });
+                }
+            }
+            else if (parsed.event === "mark") {
+                bindStreamSid(parsed.streamSid, `${mediaProfile.provider}.mark`);
+                counters.marks += 1;
+                const markName = getString((_p = parsed.mark) === null || _p === void 0 ? void 0 : _p.name, "");
+                if (markQueue.length > 0)
+                    markQueue.shift();
+                playoutTracker.recordCarrierMark(markName);
+            }
+            else if (parsed.event === "dtmf") {
+                bindStreamSid(parsed.streamSid, `${mediaProfile.provider}.dtmf`);
+                counters.dtmf += 1;
+                input.appendEvent("voice.call.dtmf", {
+                    provider: mediaProfile.provider,
+                    digit: parsed.dtmf.digit,
+                }, `DTMF ${parsed.dtmf.digit}`);
+            }
+            else if (parsed.event === "stop") {
+                bindStreamSid(parsed.streamSid, `${mediaProfile.provider}.stop`);
+                input.log(`${mediaProfile.provider}.stop`, {
+                    projectId: input.projectId,
+                    sessionId: input.sessionId,
+                    streamSid,
+                    counters,
+                });
+                input.appendEvent("voice.call.ended", {
+                    provider: mediaProfile.provider,
+                    providerCallId: (_r = (_q = parsed.stop.callSid) !== null && _q !== void 0 ? _q : input.providerCallId) !== null && _r !== void 0 ? _r : null,
+                    streamSid,
+                    counters,
+                }, `${mediaProfile.provider} media stream stopped`);
+                (_s = input.onCarrierAudioSender) === null || _s === void 0 ? void 0 : _s.call(input, null);
+                try {
+                    openAI.close();
+                }
+                catch (_t) { }
+            }
+        }
+        catch (error) {
+            input.error(`${mediaProfile.provider}.message.parse.failed`, error, {
+                projectId: input.projectId,
+                sessionId: input.sessionId,
+                mediaProfile: mediaProfile.id,
+            });
+            input.appendEvent("voice.phone.codec.validation_failed", {
+                provider: mediaProfile.provider,
+                mediaProfile: mediaProfile.id,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    };
+    input.socket.on("message", handleTwilioMessage);
+    openAI.on("message", handleOpenAIMessage);
+    openAI.on("close", (code, reason) => {
+        unregisterPlayoutIdleWaiter === null || unregisterPlayoutIdleWaiter === void 0 ? void 0 : unregisterPlayoutIdleWaiter();
+        input.log(`${providerLogPrefix}.closed`, {
+            projectId: input.projectId,
+            sessionId: input.sessionId,
+            code,
+            reason: reason.toString(),
+            counters,
+        });
+        input.appendEvent("voice.provider.closed", {
+            provider,
+            code,
+            reason: reason.toString(),
+            counters,
+        });
+    });
+    openAI.on("error", (error) => {
+        input.error(`${providerLogPrefix}.socket.error`, error, { projectId: input.projectId, sessionId: input.sessionId });
+        input.appendEvent("voice.provider.error", {
+            provider,
+            error: serializeError(error),
+        });
+    });
+    await new Promise((resolve, reject) => {
+        openAI.once("open", () => {
+            var _a, _b;
+            providerConnected = true;
+            sendOpenAIEvent(openAI, createOpenAITwilioRealtimeSessionUpdate(input.snapshot, model, (_a = input.defaultVoice) !== null && _a !== void 0 ? _a : "alloy", provider, mediaProfile, audioRoute));
+            input.log(`${providerLogPrefix}.connected`, {
+                projectId: input.projectId,
+                sessionId: input.sessionId,
+                providerCallId: (_b = input.providerCallId) !== null && _b !== void 0 ? _b : null,
+                model,
+                toolCount: tools.length,
+                tools: tools.map((tool) => ({ name: tool.name, description: tool.description })),
+                bridgeMode,
+                humanization,
+                mediaProfile: mediaProfile.id,
+                waitingForPhoneAudioReady: !phoneAudioReady,
+            });
+            input.appendEvent("voice.provider.connected", {
+                provider,
+                model,
+                toolCount: tools.length,
+                tools: tools.map((tool) => tool.name),
+                bridgeMode,
+                mediaProfile: mediaProfile.id,
+            });
+            maybeGreet();
+            resolve();
+        });
+        openAI.once("error", reject);
+    });
+    return {
+        sendTextTurn: (text) => {
+            if (openAI.readyState !== ws_1.default.OPEN)
+                return false;
+            sendOpenAIUserTextTurn(openAI, text);
+            return true;
+        },
+        close: () => {
+            var _a;
+            input.socket.off("message", handleTwilioMessage);
+            (_a = input.onCarrierAudioSender) === null || _a === void 0 ? void 0 : _a.call(input, null);
+            unregisterPlayoutIdleWaiter === null || unregisterPlayoutIdleWaiter === void 0 ? void 0 : unregisterPlayoutIdleWaiter();
+            try {
+                openAI.close();
+            }
+            catch (_b) { }
+        },
+    };
+}
+async function runXAITwilioRealtimeBridge(input) {
+    var _a;
+    const model = getString((_a = input.snapshot.runtime) === null || _a === void 0 ? void 0 : _a.model, "grok-voice-think-fast-1.0");
+    return runOpenAITwilioRealtimeBridge(Object.assign(Object.assign({}, input), { provider: "xai-realtime", realtimeUrl: `wss://api.x.ai/v1/realtime?model=${encodeURIComponent(model)}`, defaultModel: "grok-voice-think-fast-1.0", defaultVoice: "eve", bridgeMode: "xai-twilio-realtime", supportsConversationItemTruncate: false }));
+}