@kognitivedev/backend-cloud 0.2.29

package/src/phone-runtime/openai-twilio-realtime.ts

@@ -0,0 +1,1250 @@
+import { randomUUID } from "crypto";
+import NodeWebSocket, { type RawData, type WebSocket } from "ws";
+import {
+    normalizeCloudVoiceHumanizationConfig,
+    toOpenAITurnDetection,
+} from "../cloud-voice-runtime-service";
+import { resolveCloudVoiceProviderSystemPrompt } from "../cloud-voice-prompt-service";
+import type {
+    CloudVoiceFunctionToolManifest,
+    PreparedCloudVoiceConfig,
+} from "../types";
+import { PhonePlayoutTracker } from "./audio-playout-tracker";
+import {
+    parseTwilioMediaStreamMessage,
+} from "@kognitivedev/telephony";
+import {
+    base64ToPcm16Be,
+    base64ToPcm16Le,
+    createCarrierClearMessage,
+    createCarrierMarkMessage,
+    createCarrierMediaMessage,
+    createPhoneAudioRoute,
+    fromAiOutputAudio,
+    getPhoneMediaProfile,
+    isLikelySpeechPayload,
+    isOpenAIRealtimeAudioReady,
+    isRealtimeAudioReadyForRoute,
+    realtimeAudioFormatForRoute,
+    realtimeOutputAudioFormatForRoute,
+    summarizeCarrierPayload,
+    summarizePcm16Signal as summarizeVoiceMediaPcm16Signal,
+    toAiInputAudio,
+    type PhoneAudioRoute,
+    type PhoneMediaProfile,
+} from "@kognitivedev/voice-media-bridge";
+
+export type OpenAITwilioRealtimeSnapshot = {
+    runtime?: Partial<PreparedCloudVoiceConfig["runtime"]>;
+    voiceConfig?: Partial<PreparedCloudVoiceConfig["voiceConfig"]>;
+    toolManifest?: Array<Partial<CloudVoiceFunctionToolManifest>>;
+    config?: Record<string, unknown>;
+};
+
+export type OpenAITwilioRealtimeCounters = {
+    inboundMediaFrames: number;
+    providerInputFrames: number;
+    providerInputDroppedBeforeReady: number;
+    outboundMediaFrames: number;
+    outboundAudioDroppedMissingStreamSid: number;
+    outboundAudioBytes: number;
+    outboundAudioPeakAbs: number;
+    outboundAudioLastRms: number;
+    clears: number;
+    truncates: number;
+    marks: number;
+    dtmf: number;
+    interruptions: number;
+    ignoredInterruptions: number;
+    toolCalls: number;
+    providerMessages: number;
+};
+
+type BridgeLog = (event: string, data?: Record<string, unknown>) => void;
+type BridgeError = (event: string, error: unknown, data?: Record<string, unknown>) => void;
+
+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: unknown) {
+    const turnDetection = toOpenAITurnDetection(value);
+    if (!turnDetection) return turnDetection;
+
+    const type = getString(turnDetection.type);
+    return {
+        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: unknown) {
+    if (value === null) return null;
+    const turnDetection = getRecord(value);
+    const type = getString(turnDetection.type, "server_vad");
+    if (type !== "server_vad") return { ...DEFAULT_XAI_PHONE_TURN_DETECTION };
+
+    const config: Record<string, unknown> = { ...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;
+}
+
+export type OpenAITwilioRealtimeBridgeInput = {
+    socket: WebSocket;
+    apiKey: string;
+    provider?: "openai-realtime" | "xai-realtime";
+    realtimeUrl?: string;
+    defaultModel?: string;
+    defaultVoice?: string;
+    mediaProfile?: PhoneMediaProfile;
+    audioRoute?: PhoneAudioRoute;
+    bridgeMode?: string;
+    supportsConversationItemTruncate?: boolean;
+    projectId: string;
+    sessionId: string;
+    providerCallId?: string | null;
+    snapshot: OpenAITwilioRealtimeSnapshot;
+    initialPrompt?: string | null;
+    log: BridgeLog;
+    error: BridgeError;
+    appendEvent: (eventType: string, payload?: Record<string, unknown>, message?: string) => void;
+    updateCallLegActive: (metadata: { streamSid: string | null }) => void;
+    updateSessionActive: () => void;
+    onAudioFrame?: (input: {
+        source: "caller" | "assistant";
+        payload: string;
+        metadata?: Record<string, unknown>;
+    }) => void;
+    onCarrierAudioSender?: (sender: ((payload: string) => boolean) | null) => void;
+    isAiPaused?: () => boolean;
+    onAssistantTurnComplete?: () => void;
+    registerPlayoutIdleWaiter?: (waiter: (input?: { timeoutMs?: number; quietMs?: number }) => Promise<unknown>) => () => void;
+    executeTool: (input: {
+        toolId: string;
+        args: unknown;
+        toolCallId?: string | null;
+        providerCallId?: string | null;
+    }) => Promise<{ result: unknown }>;
+};
+
+function getRecord(value: unknown): Record<string, unknown> {
+    return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
+}
+
+function getString(value: unknown, fallback = "") {
+    return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+
+function getRawString(value: unknown) {
+    return typeof value === "string" ? value : "";
+}
+
+function normalizeToolInput(value: unknown) {
+    if (typeof value !== "string") return value;
+    try {
+        return JSON.parse(value);
+    } catch {
+        return value;
+    }
+}
+
+function serializeToolResult(value: unknown) {
+    return typeof value === "string" ? value : JSON.stringify(value);
+}
+
+function serializeError(value: unknown) {
+    if (value instanceof Error) {
+        return {
+            name: value.name,
+            message: value.message,
+            stack: value.stack,
+        };
+    }
+    return value;
+}
+
+function sendJson(socket: WebSocket | NodeWebSocket, message: unknown) {
+    if (socket.readyState !== NodeWebSocket.OPEN) return false;
+    socket.send(JSON.stringify(message));
+    return true;
+}
+
+function sendOpenAIEvent(socket: NodeWebSocket, event: Record<string, unknown>) {
+    return sendJson(socket, event);
+}
+
+function summarizePcm16Signal(samples: Int16Array) {
+    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)),
+    };
+}
+
+export function summarizeTwilioPcmuSignal(base64Audio: string) {
+    return summarizeCarrierPayload(getPhoneMediaProfile("twilio-pcmu-8k"), base64Audio);
+}
+
+function isLikelySpeechTwilioPcmu(base64Audio: string) {
+    return isLikelySpeechPayload(getPhoneMediaProfile("twilio-pcmu-8k"), base64Audio, {
+        rms: LIKELY_SPEECH_RMS,
+        peakAbs: LIKELY_SPEECH_PEAK_ABS,
+    });
+}
+
+function summarizeL16EndianCandidates(profile: PhoneMediaProfile, payload: string) {
+    if (profile.codec !== "l16") return null;
+    const bytes = Buffer.byteLength(payload, "base64");
+    return {
+        configured: profile.carrierByteOrder ?? "be",
+        be: summarizeVoiceMediaPcm16Signal(base64ToPcm16Be(payload), bytes),
+        le: summarizeVoiceMediaPcm16Signal(base64ToPcm16Le(payload), bytes),
+    };
+}
+
+function summarizeOpenAIAudioFormat(value: unknown) {
+    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 ? { type, ...(rate ? { rate } : {}) } : null;
+}
+
+function createOpenAIRealtimeReasoningConfig(snapshot: OpenAITwilioRealtimeSnapshot, model: string) {
+    if (!/^gpt-realtime-2(?:$|-)/.test(model)) return null;
+    const providerOptions = getRecord(snapshot.runtime?.providerOptions);
+    const reasoning = getRecord(providerOptions.reasoning);
+    if (Object.keys(reasoning).length > 0) return reasoning;
+
+    const effort = getString(providerOptions.reasoningEffort, "");
+    return { effort: effort || "low" };
+}
+
+export function isOpenAITwilioRealtimeReady(event: unknown, mediaProfile: PhoneMediaProfile = getPhoneMediaProfile("twilio-pcmu-8k")) {
+    return isOpenAIRealtimeAudioReady(event, mediaProfile);
+}
+
+export function createOpenAITwilioRealtimeTools(snapshot: OpenAITwilioRealtimeSnapshot) {
+    return (snapshot.toolManifest ?? [])
+        .filter((manifest) => getString(manifest.name, ""))
+        .map((manifest) => ({
+            type: "function",
+            name: getString(manifest.name, ""),
+            description: getString(manifest.description, getString(manifest.name, "")),
+            parameters: manifest.parameters ?? { type: "object", additionalProperties: true },
+        }));
+}
+
+export function createOpenAITwilioRealtimeSessionUpdate(
+    snapshot: OpenAITwilioRealtimeSnapshot,
+    model: string,
+    defaultVoice = "alloy",
+    provider: "openai-realtime" | "xai-realtime" = "openai-realtime",
+    mediaProfile: PhoneMediaProfile = getPhoneMediaProfile("twilio-pcmu-8k"),
+    audioRoute: PhoneAudioRoute = createPhoneAudioRoute(mediaProfile, provider),
+) {
+    const voiceConfig = snapshot.voiceConfig ?? {};
+    const inputConfig: Record<string, unknown> = {
+        format: 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(voiceConfig.voice ?? snapshot.runtime?.voice, defaultVoice);
+    const reasoning = provider === "openai-realtime" ? createOpenAIRealtimeReasoningConfig(snapshot, model) : null;
+    const instructions = resolveCloudVoiceProviderSystemPrompt({
+        voiceConfig,
+        config: snapshot.config,
+    });
+    const session: Record<string, unknown> = provider === "xai-realtime" ? {
+        instructions,
+        voice,
+        audio: {
+            input: inputConfig,
+            output: {
+                format: realtimeOutputAudioFormatForRoute(audioRoute),
+            },
+        },
+    } : {
+        type: "realtime",
+        model,
+        instructions,
+        output_modalities: ["audio"],
+        ...(reasoning ? { reasoning } : {}),
+        audio: {
+            input: inputConfig,
+            output: {
+                format: 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: NodeWebSocket, text: string) {
+    sendOpenAIEvent(socket, {
+        type: "conversation.item.create",
+        item: {
+            type: "message",
+            role: "user",
+            content: [{ type: "input_text", text }],
+        },
+    });
+    sendOpenAIEvent(socket, { type: "response.create" });
+}
+
+function summarizeOpenAIResponseOutputTypes(response: unknown) {
+    const output = getRecord(response).output;
+    if (!Array.isArray(output)) return [];
+    return output.map((item) => getString(getRecord(item).type, "unknown"));
+}
+
+function extractOpenAIContentText(content: unknown) {
+    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: Record<string, unknown>) {
+    if (getString(item.type, "") !== "message") return "";
+    const role = getString(item.role, "");
+    if (role && role !== "assistant") return "";
+    return extractOpenAIContentText(item.content);
+}
+
+function extractOpenAIResponseText(response: Record<string, unknown>) {
+    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: Record<string, unknown>) {
+    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: PhoneMediaProfile, raw: string) {
+    const parsed = JSON.parse(raw) as Record<string, unknown>;
+    return profile.provider === "telnyx"
+        ? normalizeTelnyxMediaStreamMessage(parsed)
+        : parseTwilioMediaStreamMessage(parsed);
+}
+
+export async function runOpenAITwilioRealtimeBridge(input: OpenAITwilioRealtimeBridgeInput) {
+    const provider = input.provider ?? "openai-realtime";
+    const providerLogPrefix = provider === "xai-realtime" ? "xai" : "openai";
+    const bridgeMode = input.bridgeMode ?? (provider === "xai-realtime" ? "xai-twilio-realtime" : "openai-twilio-realtime-ga");
+    const supportsConversationItemTruncate = input.supportsConversationItemTruncate ?? provider === "openai-realtime";
+    const model = getString(input.snapshot.runtime?.model, input.defaultModel ?? "gpt-realtime");
+    const realtimeUrl = input.realtimeUrl ?? `wss://api.openai.com/v1/realtime?model=${encodeURIComponent(model)}`;
+    const mediaProfile = input.mediaProfile ?? getPhoneMediaProfile("twilio-pcmu-8k");
+    const audioRoute = input.audioRoute ?? createPhoneAudioRoute(mediaProfile, provider);
+    const tools = createOpenAITwilioRealtimeTools(input.snapshot);
+    const humanization = normalizeCloudVoiceHumanizationConfig(getRecord(input.snapshot.config).humanization);
+    const openAI = new NodeWebSocket(realtimeUrl, {
+        headers: {
+            Authorization: `Bearer ${input.apiKey}`,
+        },
+    });
+
+    let twilioStarted = false;
+    let providerConnected = false;
+    let phoneAudioReady = false;
+    let greeted = false;
+    let streamSid: string | null = null;
+    let latestMediaTimestamp = 0;
+    let responseStartTimestampTwilio: number | null = null;
+    let lastAssistantItemId: string | null = 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: Record<string, number> = {};
+    const preReadyAudioFrames: string[] = [];
+    const markQueue: string[] = [];
+    const playoutTracker = new PhonePlayoutTracker();
+    const unregisterPlayoutIdleWaiter = input.registerPlayoutIdleWaiter?.((waitInput) =>
+        playoutTracker.waitForIdle(waitInput),
+    );
+    const counters: OpenAITwilioRealtimeCounters = {
+        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: unknown, source: string) => {
+        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 = () => {
+        if (greeted || !twilioStarted || !providerConnected || !phoneAudioReady) return;
+        greeted = true;
+        if (preReadyAudioHadSpeech) {
+            input.log(`${providerLogPrefix}.initial_prompt.skipped`, {
+                projectId: input.projectId,
+                sessionId: input.sessionId,
+                providerCallId: input.providerCallId ?? null,
+                reason: "caller_audio_before_ready",
+            });
+            return;
+        }
+        if (input.initialPrompt === null) {
+            input.log(`${providerLogPrefix}.initial_prompt.skipped`, {
+                projectId: input.projectId,
+                sessionId: input.sessionId,
+                providerCallId: input.providerCallId ?? null,
+                reason: "openingMode.wait",
+            });
+            return;
+        }
+        input.log(`${providerLogPrefix}.initial_prompt.sent`, {
+            projectId: input.projectId,
+            sessionId: input.sessionId,
+            providerCallId: input.providerCallId ?? null,
+            method: "conversation.item.create + response.create",
+        });
+        sendOpenAIUserTextTurn(
+            openAI,
+            input.initialPrompt ?? "Start the phone call now. Greet the caller briefly and ask how you can help.",
+        );
+    };
+
+    const appendOpenAIAudio = (audio: string) => {
+        sendOpenAIEvent(openAI, {
+            type: "input_audio_buffer.append",
+            audio: toAiInputAudio(audioRoute, audio),
+        });
+        counters.providerInputFrames += 1;
+    };
+
+    const flushPreReadyAudio = () => {
+        if (!phoneAudioReady || openAI.readyState !== NodeWebSocket.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: input.providerCallId ?? null,
+            frameCount,
+            hadSpeech: preReadyAudioHadSpeech,
+        });
+    };
+
+    const bufferPreReadyAudio = (audio: string) => {
+        if (preReadyAudioFrames.length >= MAX_PRE_READY_AUDIO_FRAMES) {
+            preReadyAudioFrames.shift();
+            counters.providerInputDroppedBeforeReady += 1;
+        }
+        preReadyAudioFrames.push(audio);
+        preReadyAudioHadSpeech ||= isLikelySpeechPayload(mediaProfile, audio, {
+            rms: LIKELY_SPEECH_RMS,
+            peakAbs: LIKELY_SPEECH_PEAK_ABS,
+        });
+    };
+
+    const dropOutboundAudioForMissingStreamSid = (eventType: string, delta: string) => {
+        counters.outboundAudioDroppedMissingStreamSid += 1;
+        const output = 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`, {
+            projectId: input.projectId,
+            sessionId: input.sessionId,
+            ...payload,
+        });
+
+        if (!missingStreamSidAudioWarningEmitted) {
+            missingStreamSidAudioWarningEmitted = true;
+            input.appendEvent("voice.provider.warning", {
+                ...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: string, details: Record<string, unknown> = {}) => {
+        counters.ignoredInterruptions += 1;
+        input.log(`${providerLogPrefix}.audio.interruption_ignored`, {
+            projectId: input.projectId,
+            sessionId: input.sessionId,
+            reason,
+            counters,
+            ...details,
+        });
+        if (counters.ignoredInterruptions === 1 || counters.ignoredInterruptions % 10 === 0) {
+            input.appendEvent("voice.assistant.interruption_ignored", {
+                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", {
+                provider,
+                itemId: lastAssistantItemId,
+                audioEndMs: truncateMs,
+                elapsedMs,
+                ...playoutInterruption,
+                counters,
+            });
+        }
+        counters.clears += 1;
+        const clearMessage = createCarrierClearMessage(mediaProfile, streamSid);
+        if (clearMessage) sendJson(input.socket, clearMessage);
+        input.appendEvent("voice.call.audio.clear_sent", {
+            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", {
+            provider,
+            elapsedMs,
+            ...playoutInterruption,
+        });
+        markQueue.length = 0;
+        responseStartTimestampTwilio = null;
+        lastAssistantItemId = null;
+        lastAssistantItemAudioMs = 0;
+    };
+
+    const handleToolCall = async (item: Record<string, unknown>) => {
+        const toolId = getString(item.name, "");
+        const toolCallId = getString(item.call_id, getString(item.id, randomUUID()));
+        if (!toolId) return;
+
+        counters.toolCalls += 1;
+        input.log(`${providerLogPrefix}.tool.execute.start`, {
+            projectId: input.projectId,
+            sessionId: input.sessionId,
+            providerCallId: input.providerCallId ?? null,
+            toolId,
+            toolCallId,
+            toolLatencyFillerMs: humanization.toolLatencyFillerMs,
+        });
+        try {
+            const result = await input.executeTool({
+                toolId,
+                args: normalizeToolInput(getString(item.arguments, "{}")),
+                toolCallId,
+                providerCallId: input.providerCallId ?? 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: input.providerCallId ?? null,
+                toolId,
+                toolCallId,
+            });
+        } catch (error) {
+            input.error(`${providerLogPrefix}.tool.execute.failed`, error, {
+                projectId: input.projectId,
+                sessionId: input.sessionId,
+                providerCallId: input.providerCallId ?? 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: RawData) => {
+        let event: Record<string, unknown>;
+        try {
+            event = JSON.parse(rawData.toString()) as Record<string, unknown>;
+        } 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 = 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: event.usage ?? 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 (input.isAiPaused?.()) {
+                input.log(`${providerLogPrefix}.audio.output.paused_for_handoff`, {
+                    projectId: input.projectId,
+                    sessionId: input.sessionId,
+                    providerCallId: input.providerCallId ?? null,
+                    outboundMediaFrames: counters.outboundMediaFrames,
+                });
+                return;
+            }
+
+            const carrierOutput = fromAiOutputAudio(audioRoute, delta);
+            const mediaMessage = createCarrierMediaMessage(mediaProfile, streamSid, carrierOutput.payload);
+            const sent = mediaMessage ? sendJson(input.socket, mediaMessage) : false;
+            if (!sent) return;
+
+            const itemId = getString(event.item_id, 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 = createCarrierMarkMessage(mediaProfile, streamSid, markName);
+            if (markMessage) sendJson(input.socket, markMessage);
+            markQueue.push(markName);
+            playoutTracker.recordOutboundFrame({ markName, itemId: itemId || null, durationMs: carrierOutput.durationMs });
+            input.onAudioFrame?.({
+                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: response.status_details ?? null,
+                outputTypes: summarizeOpenAIResponseOutputTypes(response),
+                counters,
+            });
+            input.appendEvent("voice.assistant.stopped", {
+                provider,
+                responseId: getString(response.id, ""),
+                status: getString(response.status, ""),
+                statusDetails: response.status_details ?? undefined,
+                text: text || undefined,
+                usage: response.usage ?? undefined,
+                counters,
+            }, text || undefined);
+            input.onAssistantTurnComplete?.();
+        }
+    };
+
+    const handleTwilioMessage = (data: RawData) => {
+        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(parsed.start.streamSid ?? parsed.streamSid ?? 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: parsed.start.callSid ?? input.providerCallId ?? null,
+                    streamSid,
+                    mediaFormat: parsed.start.mediaFormat,
+                });
+                input.updateSessionActive();
+                input.onCarrierAudioSender?.((payload: string) => {
+                    const mediaMessage = createCarrierMediaMessage(mediaProfile, streamSid, payload);
+                    return mediaMessage ? sendJson(input.socket, mediaMessage) : false;
+                });
+                input.appendEvent("voice.call.started", {
+                    provider: mediaProfile.provider,
+                    providerCallId: parsed.start.callSid ?? input.providerCallId ?? 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] = (carrierMediaTracks[mediaTrackKey] ?? 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: input.providerCallId ?? null,
+                            track: mediaTrack,
+                            ignoredCarrierMediaFrames,
+                            carrierMediaTracks,
+                        });
+                    }
+                    return;
+                }
+                counters.inboundMediaFrames += 1;
+                latestInboundSignal = summarizeCarrierPayload(mediaProfile, parsed.media.payload);
+                const l16EndianSignals = summarizeL16EndianCandidates(mediaProfile, parsed.media.payload);
+                latestMediaTimestamp = Number.parseInt(parsed.media.timestamp ?? "0", 10) || latestMediaTimestamp;
+                input.onAudioFrame?.({
+                    source: "caller",
+                    payload: parsed.media.payload,
+                    metadata: {
+                        provider: mediaProfile.provider,
+                        frame: counters.inboundMediaFrames,
+                        ...(l16EndianSignals ? { l16ByteOrder: l16EndianSignals.configured } : {}),
+                    },
+                });
+                if (input.isAiPaused?.()) {
+                    counters.providerInputDroppedBeforeReady += 1;
+                } else if (openAI.readyState === NodeWebSocket.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`, {
+                        projectId: input.projectId,
+                        sessionId: input.sessionId,
+                        providerCallId: input.providerCallId ?? 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`, {
+                        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(parsed.mark?.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: parsed.stop.callSid ?? input.providerCallId ?? null,
+                    streamSid,
+                    counters,
+                }, `${mediaProfile.provider} media stream stopped`);
+                input.onCarrierAudioSender?.(null);
+                try {
+                    openAI.close();
+                } catch {}
+            }
+        } 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?.();
+        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<void>((resolve, reject) => {
+        openAI.once("open", () => {
+            providerConnected = true;
+            sendOpenAIEvent(openAI, createOpenAITwilioRealtimeSessionUpdate(input.snapshot, model, input.defaultVoice ?? "alloy", provider, mediaProfile, audioRoute));
+            input.log(`${providerLogPrefix}.connected`, {
+                projectId: input.projectId,
+                sessionId: input.sessionId,
+                providerCallId: input.providerCallId ?? 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: string) => {
+            if (openAI.readyState !== NodeWebSocket.OPEN) return false;
+            sendOpenAIUserTextTurn(openAI, text);
+            return true;
+        },
+        close: () => {
+            input.socket.off("message", handleTwilioMessage);
+            input.onCarrierAudioSender?.(null);
+            unregisterPlayoutIdleWaiter?.();
+            try {
+                openAI.close();
+            } catch {}
+        },
+    };
+}
+
+export type XAITwilioRealtimeBridgeInput = Omit<
+    OpenAITwilioRealtimeBridgeInput,
+    "provider" | "realtimeUrl" | "defaultModel" | "defaultVoice" | "bridgeMode" | "supportsConversationItemTruncate"
+>;
+
+export async function runXAITwilioRealtimeBridge(input: XAITwilioRealtimeBridgeInput) {
+    const model = getString(input.snapshot.runtime?.model, "grok-voice-think-fast-1.0");
+    return runOpenAITwilioRealtimeBridge({
+        ...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,
+    });
+}