@sentropic/llm-mesh 0.29.0 → 0.31.0

package/dist/speech/openai-transcription.js

@@ -0,0 +1,659 @@
+import { isValidSpeechAudioFrame } from './contracts.js';
+export const OPENAI_TRANSCRIPTION_PROVIDER_ID = 'openai';
+export const OPENAI_TRANSCRIPTION_ADAPTER_ID = 'openai-transcription';
+export const OPENAI_TRANSCRIPTION_ADAPTER_REVISION = '1';
+export const OPENAI_TRANSCRIPTION_PLACEMENT = 'cloud-relay';
+export const OPENAI_TRANSCRIPTION_WS_URL = 'wss://api.openai.com/v1/realtime?intent=transcription';
+export const openAiTranscriptionModels = ['gpt-live-transcribe', 'gpt-realtime-whisper'];
+export const openAiTranscriptionDelays = ['minimal', 'low', 'medium', 'high', 'xhigh'];
+const TRANSCRIPTION_FORMAT = { codec: 'pcm16-le', sampleRateHz: 24000, channels: 1 };
+export const openAiTranscriptionIdentity = (config) => ({
+    providerId: OPENAI_TRANSCRIPTION_PROVIDER_ID,
+    modelId: config.modelId,
+    modelRevision: config.modelRevision,
+    adapterId: OPENAI_TRANSCRIPTION_ADAPTER_ID,
+    adapterRevision: OPENAI_TRANSCRIPTION_ADAPTER_REVISION,
+    placement: OPENAI_TRANSCRIPTION_PLACEMENT,
+});
+const isNonEmptyString = (value) => typeof value === 'string' && value.length > 0;
+/** Per-profile capabilities. TTS is unsupported: synthesis is selected separately (local or L13). */
+export const openAiTranscriptionCapabilities = (config) => {
+    if (!openAiTranscriptionModels.includes(config.modelId)) {
+        throw new OpenAiTranscriptionError('unknown-model', `unknown OpenAI transcription model: ${String(config.modelId)}`);
+    }
+    if (!isNonEmptyString(config.modelRevision)) {
+        throw new OpenAiTranscriptionError('invalid-config', 'modelRevision must be a pinned non-empty revision');
+    }
+    if (!openAiTranscriptionDelays.includes(config.delay)) {
+        throw new OpenAiTranscriptionError('invalid-config', `delay must be one of ${openAiTranscriptionDelays.join(', ')}`);
+    }
+    if (config.turnDetection !== undefined && config.turnDetection !== 'client') {
+        throw new OpenAiTranscriptionError('invalid-config', 'only client turn detection is supported for this profile');
+    }
+    return {
+        binding: openAiTranscriptionIdentity(config),
+        ...(config.language ? { languages: [config.language] } : {}),
+        ...(config.region ? { regions: [config.region] } : {}),
+        features: {
+            streamingStt: 'supported',
+            partialTranscript: 'supported',
+            nativeDuplex: 'unsupported',
+            tts: 'unsupported',
+            serverVad: 'unsupported',
+            clientVad: 'supported',
+            manualCommit: 'supported',
+            playoutTruncate: 'unsupported',
+            toolCancellation: 'unsupported',
+            resume: 'unknown',
+        },
+        inputFormats: [TRANSCRIPTION_FORMAT],
+        outputFormats: [],
+        usageUnits: ['audio-seconds', 'session-seconds'],
+    };
+};
+/** Exact `session.update` body. `turn_detection` is always null (server VAD unsupported). */
+export const buildTranscriptionSessionUpdate = (config) => {
+    // Reuse the capability gate so the wire can never carry an unvalidated profile.
+    openAiTranscriptionCapabilities(config);
+    return {
+        type: 'session.update',
+        session: {
+            type: 'transcription',
+            audio: {
+                input: {
+                    format: { type: 'audio/pcm', rate: TRANSCRIPTION_FORMAT.sampleRateHz },
+                    transcription: {
+                        model: config.modelId,
+                        delay: config.delay,
+                        ...(config.language ? { language: config.language } : {}),
+                        ...(config.prompt ? { prompt: config.prompt } : {}),
+                    },
+                    turn_detection: null,
+                },
+            },
+        },
+    };
+};
+export class OpenAiTranscriptionError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'OpenAiTranscriptionError';
+        this.code = code;
+    }
+}
+/** Portable base64 for PCM payloads (no node:buffer; mesh stays runtime-agnostic). */
+const base64Of = (payload) => {
+    const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    let out = '';
+    for (let i = 0; i < payload.length; i += 3) {
+        const a = payload[i] ?? 0;
+        const b = payload[i + 1] ?? 0;
+        const c = payload[i + 2] ?? 0;
+        const triple = (a << 16) | (b << 8) | c;
+        out += alphabet[(triple >> 18) & 63] + alphabet[(triple >> 12) & 63]
+            + (i + 1 < payload.length ? alphabet[(triple >> 6) & 63] : '=')
+            + (i + 2 < payload.length ? alphabet[triple & 63] : '=');
+    }
+    return out;
+};
+const assertAdmission = (admission) => {
+    if (!admission || !isNonEmptyString(admission.operationId) || !isNonEmptyString(admission.holdRef)
+        || !isNonEmptyString(admission.pricingRevision)
+        || !(admission.ceiling?.connectedSeconds > 0) || !(admission.ceiling?.admittedAudioSeconds > 0)
+        || !(admission.maxDurationMs > 0)) {
+        throw new OpenAiTranscriptionError('admission', 'a valid admission (operation, hold, ceilings) is required');
+    }
+};
+const monotonicNow = (nowMs) => {
+    const now = (nowMs ?? Date.now)();
+    if (!Number.isFinite(now) || now < 0)
+        throw new OpenAiTranscriptionError('invalid-config', 'clock must be finite');
+    return now;
+};
+const errorEvent = (base, eventId, sequence, reason, retryable) => ({
+    schemaVersion: 1,
+    speechSessionId: base.speechSessionId,
+    connectionEpoch: base.connectionEpoch,
+    eventId,
+    sequence,
+    clock: base.clock,
+    type: 'error',
+    reason,
+    retryable,
+});
+export class TranscriptionSession {
+    receipt;
+    events;
+    socket;
+    binding;
+    admission;
+    usage;
+    nowMs;
+    openedAtMs;
+    items = new Map();
+    queue = [];
+    waiters = [];
+    sequence = 0;
+    eventId = 0;
+    audioSeconds = 0;
+    settled = false;
+    outcome = 'completed';
+    pump;
+    signal;
+    effectiveMaxMs;
+    abortHandler;
+    expiryCancel;
+    inPump = false;
+    turnAudioStartMs;
+    /** End of the last frame written in the open turn (capture + frame duration). */
+    turnAudioEndMs;
+    openTurnUtteranceId;
+    turns = [];
+    bindings = new Map();
+    /** Finalized items: late deltas/commits drop silently, a second final errors. */
+    finalizedIds = new Set();
+    /** Cleared items: every late provider frame drops silently. */
+    clearedIds = new Set();
+    committedAudioSeconds = 0;
+    usageRevision = 0;
+    constructor(receipt, socket, binding, admission, usage, nowMs, signal, schedule, maxDurationMs) {
+        this.receipt = receipt;
+        this.socket = socket;
+        this.binding = binding;
+        this.admission = admission;
+        this.usage = usage;
+        this.nowMs = nowMs;
+        this.signal = signal;
+        this.openedAtMs = monotonicNow(nowMs);
+        this.effectiveMaxMs = Math.min(admission.maxDurationMs, maxDurationMs);
+        this.events = this.stream();
+        this.pump = this.run(signal);
+        const arm = schedule ?? ((delayMs, fn) => {
+            const timer = setTimeout(fn, delayMs);
+            return () => clearTimeout(timer);
+        });
+        this.expiryCancel = arm(this.effectiveMaxMs, () => {
+            this.pushError('ceiling', false);
+            this.outcome = 'cancelled';
+            void this.close();
+        });
+        if (signal) {
+            if (signal.aborted) {
+                this.outcome = 'cancelled';
+                void this.close();
+            }
+            else {
+                this.abortHandler = () => {
+                    this.outcome = 'cancelled';
+                    void this.close();
+                };
+                signal.addEventListener('abort', this.abortHandler, { once: true });
+            }
+        }
+    }
+    nextId() {
+        this.eventId += 1;
+        return `evt-${this.eventId}`;
+    }
+    emit(event) {
+        this.queue.push(event);
+        const waiter = this.waiters.shift();
+        if (waiter)
+            waiter();
+    }
+    clock() {
+        return { id: 'openai-transcription', monotonicMs: monotonicNow(this.nowMs) };
+    }
+    async *stream() {
+        let index = 0;
+        for (;;) {
+            while (index >= this.queue.length) {
+                if (this.settled)
+                    return;
+                await new Promise((resolve) => this.waiters.push(resolve));
+            }
+            const event = this.queue[index++];
+            // Bound the queue for long sessions: consumed events are dropped.
+            if (index > 1024) {
+                this.queue.splice(0, index);
+                index = 0;
+            }
+            yield event;
+        }
+    }
+    async write(frame) {
+        if (this.settled)
+            throw new OpenAiTranscriptionError('closed', 'session is closed');
+        if (!isValidSpeechAudioFrame(frame) || frame.type !== 'audio.input') {
+            throw new OpenAiTranscriptionError('invalid-format', 'audio.input frame failed validation');
+        }
+        if (frame.format.codec !== TRANSCRIPTION_FORMAT.codec
+            || frame.format.sampleRateHz !== TRANSCRIPTION_FORMAT.sampleRateHz
+            || frame.format.channels !== TRANSCRIPTION_FORMAT.channels) {
+            throw new OpenAiTranscriptionError('invalid-format', 'only pcm16-le 24kHz mono is admitted');
+        }
+        if (monotonicNow(this.nowMs) - this.openedAtMs >= this.effectiveMaxMs) {
+            throw new OpenAiTranscriptionError('ceiling', 'session duration bound reached');
+        }
+        const seconds = frame.sampleCount / frame.format.sampleRateHz;
+        if (!(seconds > 0) || this.audioSeconds + seconds > this.admission.ceiling.admittedAudioSeconds) {
+            throw new OpenAiTranscriptionError('ceiling', 'admitted audio ceiling reached');
+        }
+        this.audioSeconds += seconds;
+        this.openTurnUtteranceId = frame.utteranceId;
+        // Capture-domain turn window for the final's audioInterval: the window
+        // belongs to the open turn only, never to a session-wide maximum (a later
+        // turn must not stretch an earlier turn's interval). Dispatch ordering
+        // stays with L2.
+        if (Number.isFinite(frame.capturedAtMs) && frame.capturedAtMs >= 0) {
+            this.turnAudioStartMs ??= frame.capturedAtMs;
+            this.turnAudioEndMs = frame.capturedAtMs + (frame.sampleCount / frame.format.sampleRateHz) * 1000;
+        }
+        // The payload is encoded and released here; the adapter retains only counters.
+        const audio = base64Of(frame.payload);
+        this.socket.send(JSON.stringify({ type: 'input_audio_buffer.append', audio }));
+    }
+    async command(command) {
+        if (this.settled && command.type !== 'session.close') {
+            throw new OpenAiTranscriptionError('closed', 'session is closed');
+        }
+        switch (command.type) {
+            case 'input.commit': {
+                if (monotonicNow(this.nowMs) - this.openedAtMs >= this.effectiveMaxMs) {
+                    throw new OpenAiTranscriptionError('ceiling', 'session duration bound reached');
+                }
+                this.socket.send(JSON.stringify({ type: 'input_audio_buffer.commit' }));
+                this.turns.push({
+                    utteranceId: command.utteranceId,
+                    startMs: this.turnAudioStartMs ?? 0,
+                    endMs: this.turnAudioEndMs ?? this.turnAudioStartMs ?? 0,
+                });
+                this.turnAudioStartMs = undefined;
+                this.turnAudioEndMs = undefined;
+                this.openTurnUtteranceId = undefined;
+                // Cumulative operational totals (L8 sums incremental events per eventId,
+                // so a per-turn total would double-count); the composition settles from these.
+                this.committedAudioSeconds = this.audioSeconds;
+                await this.usage.record({
+                    eventId: `${this.admission.operationId}:audio`,
+                    revision: this.usageRevision++,
+                    mode: 'cumulative',
+                    usage: {
+                        admittedAudioSeconds: this.committedAudioSeconds,
+                        connectedSeconds: Math.max(0, (monotonicNow(this.nowMs) - this.openedAtMs) / 1000),
+                    },
+                });
+                return;
+            }
+            case 'input.clear':
+                // Clear the uncommitted provider buffer, then drop every local trace
+                // of the client utterance so late provider frames cannot resurrect it.
+                this.socket.send(JSON.stringify({ type: 'input_audio_buffer.clear' }));
+                for (let index = this.turns.length - 1; index >= 0; index--) {
+                    const turn = this.turns[index];
+                    if (turn && turn.utteranceId === command.utteranceId && !turn.cleared) {
+                        this.turns[index] = { ...turn, cleared: true };
+                    }
+                }
+                for (const [itemId, turn] of this.bindings) {
+                    if (turn.utteranceId === command.utteranceId) {
+                        this.clearedIds.add(itemId);
+                        this.bindings.delete(itemId);
+                    }
+                }
+                for (const [itemId, item] of this.items) {
+                    if (item.utteranceId === command.utteranceId) {
+                        this.clearedIds.add(itemId);
+                        this.items.delete(itemId);
+                    }
+                }
+                if (this.openTurnUtteranceId === command.utteranceId)
+                    this.openTurnUtteranceId = undefined;
+                return;
+            case 'session.mute':
+                // Mute is enforced by capture (no audio written); the cloud adapter holds no gate.
+                return;
+            case 'session.close':
+                await this.close();
+                return;
+            default:
+                throw new OpenAiTranscriptionError('unsupported-command', `not applicable to STT-only transcription: ${command.type}`);
+        }
+    }
+    async close() {
+        if (this.settled)
+            return;
+        this.settled = true;
+        this.expiryCancel?.();
+        this.expiryCancel = undefined;
+        if (this.signal && this.abortHandler)
+            this.signal.removeEventListener('abort', this.abortHandler);
+        try {
+            await this.socket.close();
+        }
+        finally {
+            // No usage attached: locally measured seconds are operational estimates,
+            // not provider-attested finals. The composition settles from the recorded
+            // cumulative totals (or provider-reported usage with a revision), so an
+            // L8 `settleSpeech` missing-dimension estimate stays valid.
+            await this.usage.settle({
+                operationId: this.admission.operationId,
+                outcome: this.outcome,
+            });
+            while (this.waiters.length > 0)
+                this.waiters.shift()?.();
+            if (!this.inPump)
+                await this.pump.catch(() => undefined);
+        }
+    }
+    pushError(reason, retryable) {
+        this.sequence += 1;
+        this.emit(errorEvent({ speechSessionId: this.receipt.speechSessionId, connectionEpoch: this.receipt.connectionEpoch, clock: this.clock() }, this.nextId(), this.sequence, reason, retryable));
+    }
+    /**
+     * Resolve the client turn for a provider item. Committed binds are
+     * authoritative; before the `committed` frame arrives the oldest
+     * unconfirmed turn is used (peeked, never consumed), falling back to the
+     * turn currently being recorded. Sequential client turns make all three agree.
+     */
+    attribute(itemId) {
+        const bound = this.bindings.get(itemId);
+        if (bound)
+            return bound;
+        if (this.turns.length > 0)
+            return this.turns[0];
+        if (this.openTurnUtteranceId !== undefined) {
+            return {
+                utteranceId: this.openTurnUtteranceId,
+                startMs: this.turnAudioStartMs ?? 0,
+                endMs: this.turnAudioEndMs ?? this.turnAudioStartMs ?? 0,
+            };
+        }
+        return undefined;
+    }
+    newItem(itemId, turn) {
+        const item = {
+            text: '',
+            revision: 0,
+            utteranceId: turn.utteranceId,
+            audioStartMs: turn.startMs,
+            audioEndMs: turn.endMs,
+            finalized: false,
+            speechSessionId: this.receipt.speechSessionId,
+            connectionEpoch: this.receipt.connectionEpoch,
+            binding: this.binding,
+        };
+        this.items.set(itemId, item);
+        return item;
+    }
+    onCommitted(itemId) {
+        if (this.finalizedIds.has(itemId) || this.clearedIds.has(itemId))
+            return;
+        const turn = this.turns.shift();
+        if (!turn) {
+            this.pushError('invalid-format', true);
+            return;
+        }
+        // A clear landed after the commit but before this bind: consume the
+        // tombstone and drop the late item instead of binding the next turn.
+        if (turn.cleared) {
+            this.clearedIds.add(itemId);
+            return;
+        }
+        this.bindings.set(itemId, turn);
+        // The bind is authoritative: align a live hypothesis created by early deltas.
+        const item = this.items.get(itemId);
+        if (item && !item.finalized) {
+            item.utteranceId = turn.utteranceId;
+            item.audioStartMs = turn.startMs;
+            item.audioEndMs = turn.endMs;
+        }
+    }
+    onDelta(itemId, contentIndex, delta) {
+        if (contentIndex !== 0) {
+            this.pushError('invalid-format', true);
+            return;
+        }
+        if (this.finalizedIds.has(itemId) || this.clearedIds.has(itemId))
+            return;
+        let item = this.items.get(itemId);
+        if (!item) {
+            const turn = this.attribute(itemId);
+            if (!turn) {
+                this.pushError('invalid-format', true);
+                return;
+            }
+            item = this.newItem(itemId, turn);
+        }
+        if (item.finalized)
+            return;
+        const start = item.text.length;
+        item.text += delta;
+        item.revision += 1;
+        this.sequence += 1;
+        const partial = {
+            schemaVersion: 1,
+            speechSessionId: item.speechSessionId,
+            connectionEpoch: item.connectionEpoch,
+            eventId: this.nextId(),
+            sequence: this.sequence,
+            clock: this.clock(),
+            type: 'transcript.partial',
+            binding: this.binding,
+            utteranceId: item.utteranceId,
+            revision: item.revision,
+            replaces: { start, end: start },
+            text: delta,
+        };
+        this.emit(partial);
+    }
+    onCompleted(itemId, transcript, languages) {
+        if (this.clearedIds.has(itemId))
+            return;
+        if (this.finalizedIds.has(itemId)) {
+            this.pushError('invalid-format', true);
+            return;
+        }
+        let item = this.items.get(itemId);
+        if (!item) {
+            // A completion without prior deltas (empty turn, unsent deltas for the
+            // model/delay) still finalizes the bound turn; otherwise it is orphaned.
+            const bound = this.bindings.get(itemId);
+            const turn = bound ?? this.attribute(itemId);
+            if (!turn) {
+                this.pushError('invalid-format', true);
+                return;
+            }
+            item = this.newItem(itemId, turn);
+        }
+        if (item.finalized) {
+            this.pushError('invalid-format', true);
+            return;
+        }
+        item.finalized = true;
+        this.finalizedIds.add(itemId);
+        item.revision += 1;
+        // The window stays the bound turn's: every path into onCompleted (live
+        // hypothesis, bind alignment, completed-only creation) already carries it.
+        this.sequence += 1;
+        let language = this.binding.language;
+        if (!language && Array.isArray(languages)) {
+            const first = languages[0];
+            if (first && typeof first.code === 'string' && first.code)
+                language = first.code;
+        }
+        const final = {
+            schemaVersion: 1,
+            speechSessionId: item.speechSessionId,
+            connectionEpoch: item.connectionEpoch,
+            eventId: this.nextId(),
+            sequence: this.sequence,
+            clock: this.clock(),
+            type: 'transcript.final',
+            binding: this.binding,
+            utteranceId: item.utteranceId,
+            revision: item.revision,
+            text: transcript,
+            language: language ?? 'und',
+            audioInterval: { startMs: item.audioStartMs, endMs: item.audioEndMs },
+        };
+        // Partials are ephemeral: the hypothesis buffer is released with the final.
+        this.items.delete(itemId);
+        this.emit(final);
+    }
+    onFrame(raw) {
+        if (this.settled)
+            return;
+        let frame;
+        try {
+            frame = JSON.parse(raw);
+        }
+        catch {
+            this.pushError('invalid-format', true);
+            return;
+        }
+        if (!frame || typeof frame !== 'object') {
+            this.pushError('invalid-format', true);
+            return;
+        }
+        const type = frame.type;
+        if (type === 'conversation.item.input_audio_transcription.delta') {
+            const record = frame;
+            if (!isNonEmptyString(record.item_id) || typeof record.delta !== 'string'
+                || typeof record.content_index !== 'number') {
+                this.pushError('invalid-format', true);
+                return;
+            }
+            this.onDelta(record.item_id, record.content_index, record.delta);
+            return;
+        }
+        if (type === 'conversation.item.input_audio_transcription.completed') {
+            const record = frame;
+            if (!isNonEmptyString(record.item_id) || typeof record.transcript !== 'string') {
+                this.pushError('invalid-format', true);
+                return;
+            }
+            this.onCompleted(record.item_id, record.transcript, record.languages);
+            return;
+        }
+        if (type === 'input_audio_buffer.committed') {
+            const record = frame;
+            if (!isNonEmptyString(record.item_id)) {
+                this.pushError('invalid-format', true);
+                return;
+            }
+            this.onCommitted(record.item_id);
+            return;
+        }
+        if (type === 'error') {
+            this.pushError('provider-error', false);
+            return;
+        }
+        // Unknown provider event types are tolerated (forward compatibility); the stream continues.
+    }
+    async run(signal) {
+        this.inPump = true;
+        try {
+            for await (const raw of this.socket.messages()) {
+                if (this.settled)
+                    break;
+                if (signal?.aborted) {
+                    this.outcome = 'cancelled';
+                    break;
+                }
+                this.onFrame(raw);
+            }
+        }
+        catch {
+            if (!this.settled) {
+                this.outcome = 'failed';
+                this.pushError('transport', false);
+            }
+        }
+        finally {
+            this.inPump = false;
+            if (!this.settled)
+                await this.close();
+        }
+    }
+}
+/**
+ * Redact the bearer material from any message before it reaches an error.
+ * A provider that echoes the Authorization header must never leak it through
+ * session events or thrown errors.
+ */
+const redactBearer = (message, token) => {
+    if (!token)
+        return message;
+    return message.split(`Bearer ${token}`).join('Bearer [REDACTED]').split(token).join('[REDACTED]');
+};
+/**
+ * Open an admitted transcription session. The bearer token travels only into
+ * the socket handshake; failures never echo it. The `session.update` is sent
+ * before any audio; an aborted signal refuses without connecting.
+ */
+export const openTranscriptionSession = async (config, options) => {
+    const capabilities = openAiTranscriptionCapabilities(config);
+    const binding = {
+        ...openAiTranscriptionIdentity(config),
+        ...(config.language ? { language: config.language } : {}),
+        ...(config.accountRef ? { accountRef: config.accountRef } : {}),
+        ...(config.region ? { region: config.region } : {}),
+    };
+    assertAdmission(options.admission);
+    if (!isNonEmptyString(options.bearerToken)) {
+        throw new OpenAiTranscriptionError('invalid-config', 'bearer token is required');
+    }
+    const { request } = options;
+    // TTS bindings are refused here (fail-closed): a later duplex composition
+    // may split them onto a synthesis adapter, but this module never synthesizes.
+    if (request.pipeline !== 'chained' || request.bindings.stt === undefined
+        || request.bindings.stt.providerId !== binding.providerId
+        || request.bindings.stt.modelId !== binding.modelId
+        || request.bindings.tts !== undefined) {
+        throw new OpenAiTranscriptionError('invalid-config', 'STT-only chained binding for this profile is required');
+    }
+    for (const format of [...(request.inputFormats ?? []), ...(request.outputFormats ?? [])]) {
+        if (format.codec !== TRANSCRIPTION_FORMAT.codec || format.sampleRateHz !== TRANSCRIPTION_FORMAT.sampleRateHz
+            || format.channels !== TRANSCRIPTION_FORMAT.channels) {
+            throw new OpenAiTranscriptionError('invalid-config', 'only pcm16-le 24kHz mono is supported');
+        }
+    }
+    if (options.signal?.aborted) {
+        throw new OpenAiTranscriptionError('aborted', 'open aborted before connect');
+    }
+    const receipt = {
+        protocolVersion: 1,
+        speechSessionId: `speech-${options.admission.operationId}`,
+        connectionEpoch: request.target.controllerEpoch,
+        configuration: request.configuration,
+        target: request.target,
+        pipeline: 'chained',
+        micMode: request.micMode,
+        stages: { stt: capabilities },
+        inputFormat: TRANSCRIPTION_FORMAT,
+    };
+    let socket;
+    try {
+        socket = await options.connect(OPENAI_TRANSCRIPTION_WS_URL, {
+            authorization: `Bearer ${options.bearerToken}`,
+            originator: options.originator ?? 'sentropic-llm-mesh',
+        });
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : 'unknown';
+        throw new OpenAiTranscriptionError('transport', `provider connect failed: ${redactBearer(detail, options.bearerToken)}`);
+    }
+    const session = new TranscriptionSession(receipt, socket, binding, options.admission, options.usage, options.nowMs, options.signal, options.schedule, request.maxDurationMs);
+    try {
+        socket.send(JSON.stringify(buildTranscriptionSessionUpdate(config)));
+    }
+    catch (error) {
+        await session.close();
+        const detail = error instanceof Error ? error.message : 'unknown';
+        throw new OpenAiTranscriptionError('transport', `session update failed: ${redactBearer(detail, options.bearerToken)}`);
+    }
+    return session;
+};
+//# sourceMappingURL=openai-transcription.js.map