@byokit/realtime 0.1.0

package/dist/providers/xai.js

@@ -0,0 +1,542 @@
+import WebSocket from 'ws';
+import { responseFence } from "../policy.js";
+import { cleanProse, providerRefusal as refusal } from "../prose.js";
+// Lifted wire behavior; this module is loaded only by the kit child process.
+export function createAdapter(options) {
+    const MODEL = options.model ?? 'grok-voice-think-fast-2.0';
+    const RATE = 24000;
+    const PROVIDER_URL = options.endpoint ?? `wss://api.x.ai/v1/realtime?model=${MODEL}`;
+    let endAfterResponse = false;
+    const providerTools = options.tools.map((tool) => ({ type: 'function', ...tool }));
+    const currentContext = '';
+    const isExplicitHangup = options.hangup ?? (() => false);
+    const cleanProviderProse = (value, fallback, max) => cleanProse(value, fallback, max, options.redact);
+    const providerRefusal = (status, body) => refusal(status, body, options.redact);
+    const MAX_STDOUT_BYTES = 256 * 1024;
+    const MAX_REFUSAL_BODY_BYTES = 16 * 1024;
+    const stdoutQueue = [];
+    let stdoutBytes = 0;
+    let stdoutBlocked = false;
+    let stdoutOverflowed = false;
+    function syncProviderReadState() {
+        if (ws?.readyState !== WebSocket.OPEN)
+            return;
+        if (stdoutBlocked || stdoutQueue.length > 0 || outputPausedByClient)
+            ws.pause();
+        else
+            ws.resume();
+    }
+    const flushStdout = () => {
+        while (!stdoutBlocked && stdoutQueue.length > 0) {
+            const item = stdoutQueue.shift();
+            stdoutBytes -= item.line.length;
+            stdoutBlocked = !process.stdout.write(item.line, item.done);
+        }
+        syncProviderReadState();
+    };
+    process.stdout.on('drain', () => { stdoutBlocked = false; flushStdout(); });
+    const emit = (frame, done, force = false) => {
+        const line = `${JSON.stringify(frame)}\n`;
+        if (!force && stdoutBytes + line.length > MAX_STDOUT_BYTES) {
+            if (!stdoutOverflowed) {
+                stdoutOverflowed = true;
+                stopped = true;
+                ws?.close();
+                close('Voice output buffer overflowed.', true);
+            }
+            return false;
+        }
+        if (!stdoutBlocked && stdoutQueue.length === 0) {
+            stdoutBlocked = !process.stdout.write(line, done);
+            syncProviderReadState();
+        }
+        else {
+            stdoutQueue.push({ line, done, audio: frame.type === 'realtime.audio' });
+            stdoutBytes += line.length;
+            syncProviderReadState();
+        }
+        return true;
+    };
+    // Provider deltas may exceed the public frame bound after tool calls. Base64 is
+    // independently decodable when split on four-character boundaries.
+    function chunkAudio(audio) {
+        const chunks = [];
+        const chunkSize = 64 * 1024;
+        for (let offset = 0; offset < audio.length; offset += chunkSize)
+            chunks.push(audio.slice(offset, offset + chunkSize));
+        return chunks;
+    }
+    const emitAudio = (audio) => {
+        let emitted = false;
+        for (const data of chunkAudio(audio))
+            emitted = emit({ type: 'realtime.audio', data }) || emitted;
+        return emitted;
+    };
+    const state = (value, detail) => tools.state(value, detail);
+    const PROMPT = options.instructions;
+    const tools = options.bridge;
+    const fence = responseFence();
+    let closing = false;
+    const close = (reason, forceExit = false) => {
+        if (closing)
+            return;
+        closing = true;
+        fence.interrupt();
+        clearTimeout(reconnectTimer);
+        clearTimeout(stableTimer);
+        tools.close();
+        clearTimeout(inputPoll);
+        const timer = setTimeout(() => process.exit(forceExit ? 1 : 0), 1000);
+        emit({ type: 'realtime.closed', reason }, () => {
+            clearTimeout(timer);
+            process.exit(forceExit ? 1 : 0);
+        }, true);
+        flushStdout();
+    };
+    let ws;
+    let stopped = false;
+    let providerReconnects = 0;
+    let reconnectTimer;
+    let stableTimer;
+    let providerEpoch = 0;
+    let providerReady = false;
+    let inputPoll;
+    let outputFenced = false;
+    let responseActive = false;
+    let responseGeneration = 0;
+    let clearedGeneration = -1;
+    let deferredClearGeneration;
+    let deferredClearContinuation;
+    let deferredClearPending = false;
+    const playbackGenerations = new Set();
+    const playbackDrainQueue = [];
+    let gracefulEndPending = false;
+    let outputPausedByClient = false;
+    const MAX_INPUT_BYTES = 96000;
+    const PROVIDER_BUFFER_LIMIT = 512 * 1024;
+    const clientQueue = [];
+    let clientQueueBytes = 0;
+    let inputOverflowPending = false;
+    /** A provider link alive this long was healthy; forget its retries. */
+    const PROVIDER_STABLE_AFTER_MS = 30000;
+    const text = (value) => String(value ?? '').trim();
+    function providerError(error) {
+        const raw = typeof error === 'string' ? error : error?.message ?? error?.code ?? 'provider error';
+        const detail = cleanProviderProse(raw, 'provider error', 200);
+        return { detail, terminal: /api key|auth|credit|quota|billing|permission|forbidden|invalid json|invalid payload|unknown name|unsupported/i.test(detail) };
+    }
+    const runTool = (name, input, operationId) => tools.run(name, input, operationId);
+    const currentProvider = (current, epoch) => !stopped && ws === current && providerEpoch === epoch;
+    const finishGracefulEndIfDrained = () => {
+        if (!gracefulEndPending || playbackDrainQueue.length > 0 || deferredClearPending)
+            return;
+        stopped = true;
+        ws?.close();
+        close('ended');
+    };
+    const continueAfterClear = (continuation) => {
+        if (gracefulEndPending)
+            finishGracefulEndIfDrained();
+        else
+            continuation?.();
+    };
+    const finishDeferredClearIfDrained = () => {
+        if (!deferredClearPending || playbackDrainQueue.length > 0)
+            return;
+        const generation = deferredClearGeneration;
+        const continuation = deferredClearContinuation;
+        deferredClearPending = false;
+        deferredClearGeneration = undefined;
+        deferredClearContinuation = undefined;
+        if (generation !== undefined)
+            playbackGenerations.delete(generation);
+        if (generation !== undefined && clearedGeneration !== generation) {
+            clearedGeneration = generation;
+            emit({ type: 'realtime.audio.clear' });
+        }
+        syncProviderReadState();
+        continueAfterClear(continuation);
+    };
+    const clearIncompleteOutput = () => {
+        fence.interrupt();
+        for (let index = stdoutQueue.length - 1; index >= 0; index--) {
+            if (stdoutQueue[index].audio) {
+                stdoutBytes -= stdoutQueue[index].line.length;
+                stdoutQueue.splice(index, 1);
+            }
+        }
+        outputFenced = true;
+        responseActive = false;
+        const continuation = deferredClearContinuation;
+        deferredClearPending = false;
+        deferredClearGeneration = undefined;
+        deferredClearContinuation = undefined;
+        playbackGenerations.clear();
+        playbackDrainQueue.length = 0;
+        if (clearedGeneration !== responseGeneration) {
+            clearedGeneration = responseGeneration;
+            emit({ type: 'realtime.audio.clear' });
+        }
+        syncProviderReadState();
+        continueAfterClear(continuation);
+    };
+    const fenceActiveResponse = (continuation) => {
+        fence.interrupt();
+        outputFenced = true;
+        if (!responseActive) {
+            if (deferredClearPending || playbackDrainQueue.length > 0) {
+                deferredClearPending = true;
+                deferredClearContinuation = continuation;
+            }
+            else
+                continueAfterClear(continuation);
+            return;
+        }
+        responseActive = false;
+        if (!playbackGenerations.has(responseGeneration)) {
+            if (playbackDrainQueue.length > 0) {
+                deferredClearPending = true;
+                deferredClearContinuation = continuation;
+            }
+            else
+                continueAfterClear(continuation);
+        }
+        else if (playbackDrainQueue.length > 0) {
+            deferredClearPending = true;
+            deferredClearGeneration = responseGeneration;
+            deferredClearContinuation = continuation;
+            syncProviderReadState();
+        }
+        else {
+            playbackGenerations.delete(responseGeneration);
+            if (clearedGeneration !== responseGeneration) {
+                clearedGeneration = responseGeneration;
+                emit({ type: 'realtime.audio.clear' });
+            }
+            continueAfterClear(continuation);
+        }
+    };
+    const deliverAfterClear = (continuation) => {
+        if (deferredClearPending || playbackDrainQueue.length > 0) {
+            deferredClearPending = true;
+            deferredClearContinuation = continuation;
+        }
+        else
+            continueAfterClear(continuation);
+    };
+    function handleXaiEvent(raw, current, epoch) {
+        if (!currentProvider(current, epoch))
+            return;
+        let message;
+        try {
+            message = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if (deferredClearPending && message.type !== 'input_audio_buffer.speech_started' && message.type !== 'error')
+            return;
+        switch (message.type) {
+            case 'input_audio_buffer.speech_started':
+                clearIncompleteOutput();
+                break;
+            case 'response.created':
+                if (!fence.begin(message.response?.id))
+                    break;
+                responseGeneration += 1;
+                responseActive = true;
+                outputFenced = false;
+                state('thinking');
+                break;
+            case 'response.output_audio.delta':
+            case 'response.audio.delta': {
+                const audio = typeof message.delta === 'string' ? message.delta : typeof message.audio === 'string' ? message.audio : '';
+                if (audio && !outputFenced && fence.accepts(message.response_id) && emitAudio(audio))
+                    playbackGenerations.add(responseGeneration);
+                break;
+            }
+            case 'response.done':
+                if (!fence.accepts(message.response?.id))
+                    break;
+                if (!responseActive)
+                    break;
+                responseActive = false;
+                if (playbackGenerations.has(responseGeneration) && !playbackDrainQueue.includes(responseGeneration)) {
+                    playbackDrainQueue.push(responseGeneration);
+                }
+                state('connected');
+                if (endAfterResponse) {
+                    gracefulEndPending = true;
+                    finishGracefulEndIfDrained();
+                }
+                break;
+            case 'conversation.item.input_audio_transcription.completed':
+                if (typeof message.transcript === 'string' && message.transcript.trim() !== '') {
+                    if (isExplicitHangup(message.transcript))
+                        endAfterResponse = true;
+                    emit({ type: 'realtime.transcript', role: 'user', text: message.transcript });
+                }
+                break;
+            case 'response.output_audio_transcript.done':
+                if (!fence.accepts(message.response_id))
+                    break;
+                if (typeof message.transcript === 'string' && message.transcript.trim() !== '') {
+                    tools.answered();
+                    emit({ type: 'realtime.transcript', role: 'agent', text: message.transcript });
+                }
+                break;
+            case 'response.function_call_arguments.done': {
+                if (!fence.accepts(message.response_id))
+                    break;
+                const signal = fence.signal;
+                const callGeneration = responseGeneration;
+                void (async () => {
+                    let args = {};
+                    try {
+                        args = JSON.parse(message.arguments || '{}');
+                    }
+                    catch { /* interrupted arguments */ }
+                    let output;
+                    try {
+                        output = await tools.run(message.name, args, message.call_id, signal);
+                    }
+                    catch {
+                        output = 'The request could not be completed. Please try again.';
+                    }
+                    if (signal.aborted || !currentProvider(current, epoch) || current.readyState !== WebSocket.OPEN || outputFenced || callGeneration !== responseGeneration)
+                        return;
+                    current.send(JSON.stringify({
+                        type: 'conversation.item.create',
+                        item: { type: 'function_call_output', call_id: message.call_id, output: text(output).slice(0, 24000) },
+                    }));
+                    if (currentProvider(current, epoch) && !outputFenced && callGeneration === responseGeneration)
+                        current.send(JSON.stringify({ type: 'response.create' }));
+                })();
+                break;
+            }
+            case 'error': {
+                const { detail, terminal } = providerError(message.error);
+                if (terminal) {
+                    providerReady = false;
+                    if (endAfterResponse)
+                        gracefulEndPending = true;
+                    fenceActiveResponse(() => close(`Voice provider error: ${detail}`));
+                    stopped = true;
+                    current.close();
+                }
+                else {
+                    if (endAfterResponse)
+                        gracefulEndPending = true;
+                    fenceActiveResponse(() => state('connected', detail));
+                }
+                break;
+            }
+        }
+    }
+    function sendClientFrame(current, frame) {
+        if (frame.type === 'realtime.audio') {
+            current.send(JSON.stringify({ type: 'input_audio_buffer.append', audio: frame.data }));
+        }
+        else if (frame.type === 'realtime.say') {
+            current.send(JSON.stringify({
+                type: 'conversation.item.create',
+                item: { type: 'message', role: 'user', content: [{ type: 'input_text', text: frame.text }] },
+            }));
+            current.send(JSON.stringify({ type: 'response.create' }));
+        }
+    }
+    function flushClientFrames(current = ws, epoch = providerEpoch) {
+        clearTimeout(inputPoll);
+        inputPoll = undefined;
+        if (!current || !currentProvider(current, epoch) || !providerReady || current.readyState !== WebSocket.OPEN)
+            return;
+        while (clientQueue.length > 0 && current.bufferedAmount <= PROVIDER_BUFFER_LIMIT) {
+            const item = clientQueue.shift();
+            clientQueueBytes -= item.bytes;
+            sendClientFrame(current, item.frame);
+        }
+        if (clientQueue.length > 0)
+            inputPoll = setTimeout(() => flushClientFrames(current, epoch), 20);
+    }
+    const clientFrameBytes = (frame) => frame.type === 'realtime.audio'
+        ? Math.floor(frame.data.length * 3 / 4)
+        : Buffer.byteLength(JSON.stringify(frame));
+    function handleClientFrame(frame) {
+        if (tools.receive(frame))
+            return;
+        if (frame.type === 'realtime.control') {
+            if (frame.action === 'stop') {
+                stopped = true;
+                ws?.close();
+                close('ended');
+            }
+            else if (frame.action === 'interrupt') {
+                const cancel = responseActive;
+                clearIncompleteOutput();
+                if (cancel && ws?.readyState === WebSocket.OPEN)
+                    ws.send(JSON.stringify({ type: 'response.cancel' }));
+            }
+            else if (frame.action === 'pause_output') {
+                outputPausedByClient = true;
+                syncProviderReadState();
+            }
+            else if (frame.action === 'resume_output') {
+                outputPausedByClient = false;
+                syncProviderReadState();
+            }
+            else if (frame.action === 'output_drained') {
+                const drainedGeneration = playbackDrainQueue.shift();
+                if (drainedGeneration !== undefined)
+                    playbackGenerations.delete(drainedGeneration);
+                finishDeferredClearIfDrained();
+                finishGracefulEndIfDrained();
+            }
+            return;
+        }
+        if (inputOverflowPending)
+            return;
+        if (frame.type !== 'realtime.audio' && frame.type !== 'realtime.say')
+            return;
+        const bytes = clientFrameBytes(frame);
+        if (clientQueueBytes + bytes > MAX_INPUT_BYTES) {
+            inputOverflowPending = true;
+            providerReady = false;
+            clearTimeout(inputPoll);
+            inputPoll = undefined;
+            fenceActiveResponse(() => close('Voice input buffer overflowed.'));
+            stopped = true;
+            ws?.close();
+            return;
+        }
+        clientQueue.push({ frame, bytes });
+        clientQueueBytes += bytes;
+        flushClientFrames();
+        // mute/unmute are enforced on the phone's capture side; nothing to forward.
+    }
+    function connectProvider(key) {
+        if (stopped)
+            return;
+        clearTimeout(reconnectTimer);
+        reconnectTimer = undefined;
+        clearTimeout(stableTimer);
+        stableTimer = undefined;
+        providerReady = false;
+        const epoch = ++providerEpoch;
+        deliverAfterClear(() => state('connecting', providerReconnects === 0 ? undefined : 'Voice provider reconnecting'));
+        const current = new WebSocket(PROVIDER_URL, {
+            headers: { Authorization: `Bearer ${key}` },
+            maxPayload: 4 * 1024 * 1024,
+        });
+        ws = current;
+        let downHandled = false;
+        const onDown = (reason) => {
+            if (downHandled || stopped || ws !== current || providerEpoch !== epoch)
+                return;
+            downHandled = true;
+            providerReady = false;
+            clearTimeout(stableTimer);
+            stableTimer = undefined;
+            clearTimeout(inputPoll);
+            inputPoll = undefined;
+            if (endAfterResponse)
+                gracefulEndPending = true;
+            fenceActiveResponse(providerReconnects >= 2 ? () => close(reason) : undefined);
+            if (!gracefulEndPending && providerReconnects < 2) {
+                providerReconnects += 1;
+                clearTimeout(reconnectTimer);
+                reconnectTimer = setTimeout(() => connectProvider(key), providerReconnects * 500);
+            }
+        };
+        current.on('open', () => {
+            if (!currentProvider(current, epoch))
+                return;
+            syncProviderReadState();
+            current.send(JSON.stringify({
+                type: 'session.update',
+                session: {
+                    instructions: PROMPT + currentContext,
+                    voice: options.voice ?? 'ara',
+                    reasoning: { effort: 'none' },
+                    turn_detection: { type: 'server_vad', threshold: 0.9, silence_duration_ms: 700, prefix_padding_ms: 300 },
+                    audio: {
+                        input: { format: { type: 'audio/pcm', rate: RATE }, transport: 'json' },
+                        output: { format: { type: 'audio/pcm', rate: RATE }, transport: 'json' },
+                    },
+                    tools: providerTools,
+                },
+            }), (error) => {
+                if (error) {
+                    onDown('Voice provider session setup failed.');
+                    return;
+                }
+                if (!currentProvider(current, epoch))
+                    return;
+                providerReady = true;
+                flushClientFrames(current, epoch);
+                deliverAfterClear(() => {
+                    emit({ type: 'realtime.ready', inputRate: RATE, outputRate: RATE });
+                    state('connected', providerReconnects === 0 ? undefined : 'Voice provider reconnected');
+                });
+                // Reconnect budget is consecutive, not cumulative: a long healthy
+                // call gets the full budget again after its next transient drop.
+                clearTimeout(stableTimer);
+                stableTimer = setTimeout(() => {
+                    if (currentProvider(current, epoch))
+                        providerReconnects = 0;
+                }, PROVIDER_STABLE_AFTER_MS);
+            });
+        });
+        current.on('message', (data) => handleXaiEvent(String(data), current, epoch));
+        // ws suppresses 'error' and 'close' once this is handled, so the failure
+        // path is driven from here. Auth and permission refusals are terminal:
+        // retrying an out-of-credits account only delays the real message.
+        current.on('unexpected-response', (_request, response) => {
+            const bodyBuffer = Buffer.alloc(MAX_REFUSAL_BODY_BYTES);
+            let bodyBytes = 0;
+            response.on('data', (chunk) => {
+                const admitted = Math.min(chunk.length, MAX_REFUSAL_BODY_BYTES - bodyBytes);
+                if (admitted > 0)
+                    bodyBytes += chunk.copy(bodyBuffer, bodyBytes, 0, admitted);
+            });
+            response.on('end', () => {
+                if (!currentProvider(current, epoch))
+                    return;
+                const body = bodyBuffer.subarray(0, bodyBytes).toString('utf8');
+                const reason = providerRefusal(response.statusCode, body);
+                if (response.statusCode === 401 || response.statusCode === 403) {
+                    providerReady = false;
+                    if (endAfterResponse)
+                        gracefulEndPending = true;
+                    fenceActiveResponse(() => close(reason));
+                    stopped = true;
+                }
+                else
+                    onDown(reason);
+                current.terminate();
+            });
+        });
+        current.on('close', (code, reasonBuffer) => {
+            if (stopped || ws !== current)
+                return;
+            const reason = cleanProviderProse(String(reasonBuffer), '', 160);
+            const detail = `The voice provider disconnected (${code})${reason ? `: ${reason}` : '.'}`;
+            if (providerError(reason).terminal) {
+                providerReady = false;
+                if (endAfterResponse)
+                    gracefulEndPending = true;
+                fenceActiveResponse(() => close(detail));
+                stopped = true;
+            }
+            else {
+                onDown(detail);
+            }
+        });
+        current.on('error', (error) => {
+            if (currentProvider(current, epoch)) {
+                deliverAfterClear(() => state('connecting', `Voice provider connection interrupted: ${cleanProviderProse(error.message, 'connection error', 160)}`));
+            }
+        });
+    }
+    connectProvider(options.key);
+    return { receive: handleClientFrame, close: (reason = 'ended') => { stopped = true; ws?.close(); close(reason); } };
+}

package/dist/rn-webrtc.d.ts

@@ -0,0 +1,5 @@
+import { type WebRtcOptions } from './webrtc.ts';
+export type { WebRtcOptions, WebRtcHandle } from './webrtc.ts';
+/** Native media stays unloaded until the app actually starts a voice session. */
+export declare function webRtcPeer(options: WebRtcOptions): Promise<import("./webrtc.ts").WebRtcHandle>;
+export { webRtcPeer as reactNativeWebRtcPeer };

package/dist/rn-webrtc.js

@@ -0,0 +1,12 @@
+import { webRtcPeer as createPeer } from "./webrtc.js";
+/** Native media stays unloaded until the app actually starts a voice session. */
+export async function webRtcPeer(options) {
+    if (options.platform)
+        return createPeer(options);
+    const native = await import('react-native-webrtc');
+    return createPeer({ ...options, platform: {
+            createPeer: () => new native.RTCPeerConnection({ bundlePolicy: 'max-bundle', rtcpMuxPolicy: 'require' }),
+            getUserMedia: () => native.mediaDevices.getUserMedia({ audio: true, video: false }),
+        } });
+}
+export { webRtcPeer as reactNativeWebRtcPeer };

package/dist/tools.d.ts

@@ -0,0 +1,30 @@
+import type { RealtimeTool } from './types.ts';
+import type { RealtimeHostFrame, RealtimeClientFrame, RealtimeAppAction, RealtimeState } from './frames.ts';
+export type ToolHandler = (args: Record<string, unknown>, context: {
+    id: string;
+    signal: AbortSignal;
+}) => Promise<string>;
+export type ToolBridgeOptions = {
+    emit(frame: RealtimeHostFrame): void;
+    tools: RealtimeTool[];
+    handlers: Record<string, ToolHandler>;
+    timeoutFor?: (name: string) => number;
+    answerTimeoutMs?: number;
+    failure(name: string, error: unknown, timedOut: boolean): string;
+};
+/** Bounded, deduplicated tool execution. Product authorization stays in handlers. */
+export declare function toolBridge(options: ToolBridgeOptions): {
+    run: (name: string, args?: unknown, id?: string, signal?: AbortSignal) => Promise<string>;
+    state: (value: RealtimeState, detail?: string) => void;
+    answered: () => void;
+    receive: (_frame: RealtimeClientFrame) => boolean;
+    close(): void;
+};
+export declare function appBridge(emit: (frame: RealtimeHostFrame) => void | boolean, options?: {
+    timeoutMs?: number;
+    maxPending?: number;
+}): {
+    run(action: RealtimeAppAction, target?: string, signal?: AbortSignal): Promise<string>;
+    receive(frame: RealtimeClientFrame): boolean;
+    close(): void;
+};

package/dist/tools.js

@@ -0,0 +1,93 @@
+import { randomUUID } from 'node:crypto';
+/** Bounded, deduplicated tool execution. Product authorization stays in handlers. */
+export function toolBridge(options) {
+    const lifetime = new AbortController();
+    const requests = new Map();
+    let active = 0, waiting = false;
+    let answerTimer;
+    const state = (value, detail) => options.emit({ type: 'realtime.state', state: value === 'connected' && (active > 0 || waiting) ? 'thinking' : value, ...(detail ? { detail } : {}) });
+    const answered = () => { if (active)
+        return; clearTimeout(answerTimer); waiting = false; };
+    const run = (name, args = {}, id = randomUUID(), signal) => {
+        if (lifetime.signal.aborted)
+            return Promise.resolve('The request was cancelled.');
+        let key;
+        try {
+            key = JSON.stringify([name, args]);
+        }
+        catch {
+            return Promise.resolve('That request is invalid.');
+        }
+        if (!options.tools.some(tool => tool.name === name) || !Object.hasOwn(options.handlers, name) || !args || typeof args !== 'object' || Array.isArray(args) || typeof id !== 'string' || id.length > 160 || Buffer.byteLength(JSON.stringify(args)) > 16000)
+            return Promise.resolve('That request is invalid.');
+        const prior = requests.get(id);
+        if (prior)
+            return prior.key === key ? prior.promise : Promise.resolve('Conflicting repeated request. No additional action was performed.');
+        if (active >= 8 || requests.size >= 128)
+            return Promise.resolve('Requests are at the session limit.');
+        const controller = new AbortController();
+        const combined = AbortSignal.any([lifetime.signal, controller.signal, ...(signal ? [signal] : [])]);
+        active++;
+        clearTimeout(answerTimer);
+        waiting = false;
+        state('thinking');
+        const promise = (async () => {
+            let abort = () => { };
+            const timer = setTimeout(() => controller.abort(), options.timeoutFor?.(name) ?? 20000);
+            try {
+                const aborted = new Promise((_, reject) => { abort = () => reject(new Error('cancelled')); combined.addEventListener('abort', abort, { once: true }); if (combined.aborted)
+                    abort(); });
+                const operation = Promise.resolve().then(() => { combined.throwIfAborted(); return options.handlers[name](args, { id, signal: combined }); });
+                return String(await Promise.race([operation, aborted])).slice(0, 8000);
+            }
+            catch (error) {
+                return options.failure(name, error, controller.signal.aborted).slice(0, 8000);
+            }
+            finally {
+                clearTimeout(timer);
+                combined.removeEventListener('abort', abort);
+                active--;
+                if (!combined.aborted && !lifetime.signal.aborted) {
+                    waiting = true;
+                    clearTimeout(answerTimer);
+                    answerTimer = setTimeout(() => { waiting = false; state('connected', 'The voice provider did not finish answering the request.'); }, options.answerTimeoutMs ?? 20000);
+                }
+            }
+        })();
+        requests.set(id, { key, promise });
+        return promise;
+    };
+    return { run, state, answered, receive: (_frame) => false, close() { lifetime.abort(); clearTimeout(answerTimer); waiting = false; } };
+}
+export function appBridge(emit, options = {}) {
+    const pending = new Map();
+    return {
+        run(action, target, signal) {
+            if (signal?.aborted)
+                return Promise.resolve('The app request was cancelled.');
+            if (!['view', 'navigate', 'activate'].includes(action) || action !== 'view' && (!target?.trim() || Buffer.byteLength(target) > 160))
+                return Promise.resolve('That app request is invalid.');
+            if (pending.size >= (options.maxPending ?? 8))
+                return Promise.resolve('The app is busy.');
+            return new Promise(resolve => {
+                const requestId = randomUUID();
+                const finish = (text) => { clearTimeout(timer); signal?.removeEventListener('abort', abort); pending.delete(requestId); resolve(text); };
+                const abort = () => finish('The app request was cancelled.');
+                const timer = setTimeout(() => finish('The app did not answer that request.'), options.timeoutMs ?? 15000);
+                pending.set(requestId, finish);
+                signal?.addEventListener('abort', abort, { once: true });
+                try {
+                    if (emit({ type: 'realtime.app.request', requestId, action, ...(action === 'view' ? {} : { target }) }) === false)
+                        finish('The app could not receive that request.');
+                }
+                catch {
+                    finish('The app is unavailable.');
+                }
+            });
+        },
+        receive(frame) { if (frame.type !== 'realtime.app.result')
+            return false; pending.get(frame.requestId)?.(frame.ok ? frame.text.slice(0, 4000) : 'The app could not complete that request.'); return true; },
+        close() { for (const finish of pending.values())
+            finish('The app request was cancelled.'); },
+    };
+}