@happyvertical/speech 0.110.1 → 0.111.0

package/dist/index.js

@@ -1,6 +1,172 @@
-import { a as SpeechProviderError, i as SpeechError, n as PcmCaptureError, o as WavFormatError, r as SpeechConfigurationError, t as InvalidSpeechAdapterError } from "./chunks/errors-Cs0vX-mV.js";
-import { i as toWebSocketUrl, n as messageDataToText, r as resolveWebSocketFactory, t as isBrowserRuntime } from "./chunks/websocket-YbAfY6YI.js";
-import { _ as mimeTypeToAudioExtension, a as TRANSCRIBER_ENV_KEYS, c as hasTranscriberEnv, d as parseOptionalInteger, f as readEnv, g as DEFAULT_MAX_AUDIO_BYTES, h as reportSpeechUsage, i as registeredOptionalTranscribers, l as mergeHeaderInits, m as audioSecondsFromProviderUsage, n as optionalTranscriberEntry, o as defaultEnv, p as resolveTranscriberConfig, s as hasAnyEnv, t as getOptionalTranscriberFactory, u as parseHeadersEnv, v as normalizeAudioInput, y as normalizeMimeType } from "./chunks/registry-DFSF3WoM.js";
+import { a as SpeechError, c as SpeechProviderUnavailableError, i as SpeechConfigurationError, l as WavFormatError, n as PcmCaptureError, o as SpeechInvalidAudioError, r as SpeechAudioTooLargeError, s as SpeechProviderError, t as InvalidSpeechAdapterError } from "./chunks/errors-CzsR_5dE.js";
+import { i as toWebSocketUrl, n as messageDataToText, r as resolveWebSocketFactory, t as isBrowserRuntime } from "./chunks/websocket-DLZLLyD9.js";
+import { _ as mimeTypeToAudioExtension, a as TRANSCRIBER_ENV_KEYS, c as hasTranscriberEnv, d as parseOptionalInteger, f as readEnv, g as DEFAULT_MAX_AUDIO_BYTES, h as reportSpeechUsage, i as registeredOptionalTranscribers, l as mergeHeaderInits, m as audioSecondsFromProviderUsage, n as optionalTranscriberEntry, o as defaultEnv, p as resolveTranscriberConfig, s as hasAnyEnv, t as getOptionalTranscriberFactory, u as parseHeadersEnv, v as normalizeAudioInput, y as normalizeMimeType } from "./chunks/registry-DhB2589P.js";
+//#region src/shared/probe.ts
+/**
+* Readiness probes (#1345): check that a configured speech endpoint answers,
+* accepts the credentials, and (where the server lists models) serves the
+* configured model, without sending audio or text to synthesize.
+*/
+var DEFAULT_SPEECH_PROBE_TIMEOUT_MS = 1e4;
+/** A model list from `GET /models` is read up to this many bytes. */
+var MAX_MODEL_LIST_BYTES = 4 * 1024 * 1024;
+/**
+* Derives the OpenAI-style model list URL from a resolved endpoint: the
+* trailing `/<resource>` is replaced with `/models` (the query is kept). An
+* endpoint that does not end in `resource` gets `models` resolved beside it.
+*/
+function modelsUrlFor(endpoint, resource) {
+	const url = new URL(endpoint);
+	const suffix = `/${resource.replace(/^\/+|\/+$/g, "")}`;
+	const pathname = url.pathname.replace(/\/+$/, "");
+	url.pathname = pathname.endsWith(suffix) ? `${pathname.slice(0, -suffix.length)}/models` : `${pathname.replace(/\/[^/]*$/, "")}/models`;
+	url.hash = "";
+	return url.toString();
+}
+/** `ws:`/`wss:` to `http:`/`https:`; other URLs are returned unchanged. */
+function toHttpUrl(url) {
+	const parsed = new URL(url);
+	if (parsed.protocol === "ws:") parsed.protocol = "http:";
+	else if (parsed.protocol === "wss:") parsed.protocol = "https:";
+	return parsed.toString();
+}
+function unsupportedProbe(adapter, message) {
+	return {
+		ok: false,
+		adapter,
+		reason: "unsupported",
+		message,
+		latencyMs: 0
+	};
+}
+/**
+* Sends one `GET` and classifies the outcome. Resolves for every outcome
+* except a caller abort, which rejects with the signal's reason.
+*/
+async function probeHttpEndpoint(target, options = {}) {
+	const startedAt = Date.now();
+	const { adapter, model } = target;
+	const fail = (reason, message, status) => ({
+		ok: false,
+		adapter,
+		reason,
+		...status !== void 0 ? { status } : {},
+		...model !== void 0 ? { model } : {},
+		message,
+		latencyMs: Date.now() - startedAt
+	});
+	const pass = (checked) => ({
+		ok: true,
+		adapter,
+		checked,
+		...model !== void 0 ? { model } : {},
+		latencyMs: Date.now() - startedAt
+	});
+	options.signal?.throwIfAborted();
+	let url;
+	let fetchImpl;
+	let headers;
+	try {
+		url = target.url();
+		fetchImpl = resolveFetch(target.fetch);
+		headers = mergeHeaders({
+			apiKey: target.apiKey,
+			headers: target.headers
+		}, options.headers);
+	} catch (error) {
+		if (error instanceof SpeechConfigurationError) return fail("misconfigured", error.message);
+		return fail("misconfigured", `${adapter} has an invalid header or credential`);
+	}
+	if (target.listsModels) headers.set("accept", "application/json");
+	const timeoutMs = [options.timeoutMs, target.timeoutMs].find((value) => typeof value === "number" && Number.isFinite(value) && value > 0) ?? 1e4;
+	const timeout = new AbortController();
+	const timer = setTimeout(() => timeout.abort(), timeoutMs);
+	const signal = options.signal ? AbortSignal.any([options.signal, timeout.signal]) : timeout.signal;
+	try {
+		let response;
+		try {
+			response = await fetchImpl(url, {
+				method: "GET",
+				headers,
+				signal
+			});
+		} catch {
+			if (options.signal?.aborted) throw options.signal.reason;
+			if (timeout.signal.aborted) return fail("timeout", `${adapter} did not answer in ${timeoutMs} ms`);
+			return fail("unreachable", `${adapter} speech service could not be reached`);
+		}
+		if (response.status === 401 || response.status === 403) {
+			await discard(response);
+			return fail("unauthorized", `${adapter} rejected the credentials (HTTP ${response.status})`, response.status);
+		}
+		if (!target.listsModels) {
+			await discard(response);
+			return response.status < 500 ? pass("reachability") : fail("provider_error", `${adapter} answered HTTP ${response.status}`, response.status);
+		}
+		if ([
+			404,
+			405,
+			501
+		].includes(response.status)) {
+			await discard(response);
+			return pass("reachability");
+		}
+		if (!response.ok) {
+			await discard(response);
+			return fail("provider_error", `${adapter} model list failed with HTTP ${response.status}`, response.status);
+		}
+		let ids;
+		try {
+			ids = readModelIds(await readBounded(response, MAX_MODEL_LIST_BYTES));
+		} catch {
+			if (options.signal?.aborted) throw options.signal.reason;
+			if (timeout.signal.aborted) return fail("timeout", `${adapter} did not answer in ${timeoutMs} ms`);
+		}
+		if (!ids) return fail("provider_error", `${adapter} model list was not an OpenAI-style { data: [{ id }] } list`, response.status);
+		if (model === void 0) return pass("reachability");
+		return ids.includes(model) ? pass("model") : fail("model_not_found", `${adapter} does not list the configured model`, response.status);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+function readModelIds(text) {
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		return;
+	}
+	const data = parsed?.data;
+	if (!Array.isArray(data)) return void 0;
+	return data.map((entry) => entry?.id).filter((id) => typeof id === "string");
+}
+async function readBounded(response, limit) {
+	if (!response.body) return response.text();
+	const reader = response.body.getReader();
+	const chunks = [];
+	let total = 0;
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		total += value.byteLength;
+		if (total > limit) {
+			await reader.cancel().catch(() => void 0);
+			throw new Error("model list too large");
+		}
+		chunks.push(value);
+	}
+	const bytes = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		bytes.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return new TextDecoder().decode(bytes);
+}
+async function discard(response) {
+	await response.body?.cancel().catch(() => void 0);
+}
+//#endregion
 //#region src/shared/retry.ts
 /**
 * Retry with exponential backoff for speech provider calls. Retries only
@@ -162,6 +328,16 @@ var HttpSpeechAdapter = class {
 		this.headers = options.headers;
 		this.timeoutMs = options.timeoutMs;
 	}
+	/** Runs a readiness probe with this adapter's fetch, auth and headers. */
+	probeEndpoint(target, options) {
+		return probeHttpEndpoint({
+			...target,
+			fetch: this.fetchImpl,
+			apiKey: this.apiKey,
+			headers: this.headers,
+			timeoutMs: this.timeoutMs
+		}, options);
+	}
 	/**
 	* POSTs to `path` (relative to `baseUrl`, or an absolute URL). The optional
 	* `retry` policy retries 429/5xx responses; `timeoutMs` applies per attempt.
@@ -177,15 +353,21 @@ var HttpSpeechAdapter = class {
 		const requestSignal = composeAbortSignals(init.signal, timeoutController?.signal);
 		try {
 			requestSignal.signal?.throwIfAborted();
-			const response = await this.fetchImpl(resolveSpeechUrl(this.baseUrl, path), {
-				...init,
-				method: "POST",
-				headers: mergeHeaders({
-					apiKey: this.apiKey,
-					headers: this.headers
-				}, init.headers),
-				signal: requestSignal.signal
-			});
+			let response;
+			try {
+				response = await this.fetchImpl(resolveSpeechUrl(this.baseUrl, path), {
+					...init,
+					method: "POST",
+					headers: mergeHeaders({
+						apiKey: this.apiKey,
+						headers: this.headers
+					}, init.headers),
+					signal: requestSignal.signal
+				});
+			} catch (error) {
+				if (requestSignal.signal?.aborted) throw error;
+				throw new SpeechProviderUnavailableError(adapterName, `${adapterName} speech service could not be reached`, error);
+			}
 			await assertOk(response, adapterName, this.apiKey);
 			return await readResponse(response);
 		} finally {
@@ -544,7 +726,7 @@ function unwrapRawAudio(bytes, mimeType, adapter) {
 		})
 	};
 	if (RAW_PCM_TYPES.has(essence)) {
-		if (essence === "audio/l16" && bytes.byteLength % 2 !== 0) throw new SpeechConfigurationError(`audio/L16 payload has an odd byte length (${bytes.byteLength}); 16-bit samples need an even number of bytes`, adapter);
+		if (essence === "audio/l16" && bytes.byteLength % 2 !== 0) throw new SpeechInvalidAudioError(`audio/L16 payload has an odd byte length (${bytes.byteLength}); 16-bit samples need an even number of bytes`, adapter);
 		return {
 			bytes: essence === "audio/l16" ? swapBytePairs(bytes) : bytes,
 			format: compact({
@@ -570,7 +752,7 @@ function unwrapRawAudio(bytes, mimeType, adapter) {
 			channels
 		})
 	};
-	throw new SpeechConfigurationError(`${adapter} streams raw audio and cannot decode ${essence}; send PCM WAV or raw PCM, or use an HTTP transcriber for compressed recordings`, adapter);
+	throw new SpeechInvalidAudioError(`${adapter} streams raw audio and cannot decode ${essence}; send PCM WAV or raw PCM, or use an HTTP transcriber for compressed recordings`, adapter);
 }
 /** Returns a copy with each 16-bit sample's bytes swapped. */
 function swapBytePairs(bytes) {
@@ -585,7 +767,7 @@ function isRiffWave(bytes) {
 	return bytes.byteLength >= 12 && ascii(bytes, 0, 4) === "RIFF" && ascii(bytes, 8, 4) === "WAVE";
 }
 function parseWav(bytes, adapter) {
-	if (!isRiffWave(bytes)) throw new SpeechConfigurationError("Invalid WAV header", adapter);
+	if (!isRiffWave(bytes)) throw new SpeechInvalidAudioError("Invalid WAV header", adapter);
 	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
 	let offset = 12;
 	let format;
@@ -603,7 +785,7 @@ function parseWav(bytes, adapter) {
 				channels
 			};
 		} else if (id === "data") {
-			if (!format) throw new SpeechConfigurationError("WAV data chunk precedes its fmt chunk", adapter);
+			if (!format) throw new SpeechInvalidAudioError("WAV data chunk precedes its fmt chunk", adapter);
 			const end = Math.min(bytes.byteLength, body + size);
 			return {
 				bytes: bytes.subarray(body, end),
@@ -612,13 +794,13 @@ function parseWav(bytes, adapter) {
 		}
 		offset = body + size + size % 2;
 	}
-	throw new SpeechConfigurationError("WAV file has no data chunk", adapter);
+	throw new SpeechInvalidAudioError("WAV file has no data chunk", adapter);
 }
 function wavEncoding(audioFormat, bitsPerSample, adapter) {
 	if ((audioFormat === 1 || audioFormat === 65534) && bitsPerSample === 16) return "pcm16";
 	if (audioFormat === 7 && bitsPerSample === 8) return "g711_ulaw";
 	if (audioFormat === 6 && bitsPerSample === 8) return "g711_alaw";
-	throw new SpeechConfigurationError(`Unsupported WAV encoding (format ${audioFormat}, ${bitsPerSample}-bit); expected 16-bit PCM or 8-bit G.711`, adapter);
+	throw new SpeechInvalidAudioError(`Unsupported WAV encoding (format ${audioFormat}, ${bitsPerSample}-bit); expected 16-bit PCM or 8-bit G.711`, adapter);
 }
 function ascii(bytes, offset, length) {
 	return String.fromCharCode(...bytes.subarray(offset, offset + length));
@@ -1581,6 +1763,29 @@ var OpenAIRealtimeTranscriber = class {
 		resolveTurnLimit(ADAPTER$1, void 0, options);
 	}
 	/**
+	* `GET` of the server's model list (the realtime URL's `/models`, over
+	* HTTP), confirming the configured model is listed. Needs `apiKey` or no
+	* auth (vLLM): a browser `clientSecret` alone cannot read the list, so the
+	* result is then `unsupported`.
+	*/
+	probe(options) {
+		if (!this.options.apiKey && this.options.clientSecret) return Promise.resolve(unsupportedProbe(ADAPTER$1, `${ADAPTER$1} with only a clientSecret cannot be probed without opening a session`));
+		return probeHttpEndpoint({
+			adapter: ADAPTER$1,
+			url: () => {
+				const url = new URL(modelsUrlFor(toHttpUrl(this.url), "realtime"));
+				url.searchParams.delete("intent");
+				return url.toString();
+			},
+			listsModels: true,
+			model: this.options.model?.trim() || "gpt-4o-transcribe",
+			fetch: this.options.fetch,
+			apiKey: this.options.apiKey,
+			headers: this.options.headers,
+			timeoutMs: this.options.connectTimeoutMs
+		}, options);
+	}
+	/**
 	* A turn limit applies only to `manual` sessions with `maxTurnSeconds` set;
 	* under server or semantic VAD the provider ends turns itself.
 	*/
@@ -1822,6 +2027,29 @@ var VoxtralRealtimeTranscriber = class {
 		assertTurnDetection(options.turnDetection);
 		this.resolveTurnLimit();
 	}
+	/**
+	* `GET` of the server's model list (the realtime URL's `/models`, over
+	* HTTP), confirming the configured model is listed. Needs `apiKey` or no
+	* auth (vLLM): a browser `clientSecret` alone cannot read the list, so the
+	* result is then `unsupported`.
+	*/
+	probe(options) {
+		if (!this.options.apiKey && this.options.clientSecret) return Promise.resolve(unsupportedProbe(ADAPTER, `${ADAPTER} with only a clientSecret cannot be probed without opening a session`));
+		return probeHttpEndpoint({
+			adapter: ADAPTER,
+			url: () => {
+				const url = new URL(modelsUrlFor(toHttpUrl(this.url), "realtime"));
+				url.searchParams.delete("intent");
+				return url.toString();
+			},
+			listsModels: true,
+			model: this.options.model?.trim() || "mistralai/Voxtral-Mini-4B-Realtime-2602",
+			fetch: this.options.fetch,
+			apiKey: this.options.apiKey,
+			headers: this.options.headers,
+			timeoutMs: this.options.connectTimeoutMs
+		}, options);
+	}
 	turnLimit(options = {}) {
 		assertFormat(options.format);
 		return describeTurnLimit(this.resolveTurnLimit(options), VOXTRAL_REALTIME_AUDIO_FORMAT);
@@ -1911,6 +2139,15 @@ var OpenAICompatibleSpeechSynthesizer = class extends HttpSpeechAdapter {
 			model: speech.model ?? String(payload.model)
 		};
 	}
+	/** `GET <api root>/models`, confirming `defaultModel` is listed. */
+	probe(options) {
+		return this.probeEndpoint({
+			adapter: this.type,
+			url: () => modelsUrlFor(this.speechPath ? resolveSpeechUrl(this.baseUrl, this.speechPath) : resolveOpenAICompatibleUrl(this.baseUrl, "audio/speech"), "audio/speech"),
+			listsModels: true,
+			model: this.defaultModel
+		}, options);
+	}
 };
 //#endregion
 //#region src/adapters/openai-compatible-transcriber.ts
@@ -2015,6 +2252,15 @@ var OpenAICompatibleTranscriber = class extends HttpSpeechAdapter {
 			timestampGranularities
 		};
 	}
+	/** `GET <api root>/models`, confirming the configured `model` is listed. */
+	probe(options) {
+		return this.probeEndpoint({
+			adapter: this.type,
+			url: () => modelsUrlFor(this.endpoint, "audio/transcriptions"),
+			listsModels: true,
+			model: this.model
+		}, options);
+	}
 };
 function isUnsupportedFormatError(error, wire) {
 	return error instanceof SpeechProviderError && (error.status === 400 || error.status === 422) && (wire.responseFormat === "verbose_json" || Boolean(wire.timestampGranularities?.length)) && UNSUPPORTED_FORMAT_ERROR.test(error.responseBody ?? "");
@@ -2049,6 +2295,17 @@ var Qwen3SpeechSynthesizer = class extends HttpSpeechAdapter {
 			model: speech.model ?? request.model ?? this.defaultModel
 		};
 	}
+	/**
+	* `GET` of the model list beside `speechPath` (`/v1/models` by default).
+	* The model is not required to be listed: Qwen3 servers name it freely.
+	*/
+	probe(options) {
+		return this.probeEndpoint({
+			adapter: this.type,
+			url: () => modelsUrlFor(resolveSpeechUrl(this.baseUrl, this.speechPath), "audio/speech"),
+			listsModels: true
+		}, options);
+	}
 };
 //#endregion
 //#region src/adapters/studio-server.ts
@@ -2076,6 +2333,17 @@ var StudioServerTranscriber = class extends HttpSpeechAdapter {
 			signal: request.signal
 		}, (response) => readTranscriptResponse(response, this.type));
 	}
+	/**
+	* `GET` of `baseUrl`: Studio Server has no model list, so a success only
+	* shows a server answered (`checked: 'reachability'`).
+	*/
+	probe(options) {
+		return this.probeEndpoint({
+			adapter: this.type,
+			url: () => normalizeBaseUrl(this.baseUrl),
+			listsModels: false
+		}, options);
+	}
 };
 var StudioServerSpeechSynthesizer = class extends HttpSpeechAdapter {
 	type = "studio-server";
@@ -2093,6 +2361,17 @@ var StudioServerSpeechSynthesizer = class extends HttpSpeechAdapter {
 			signal: request.signal
 		}, (response) => readSynthesizedSpeechResponse(response, this.type));
 	}
+	/**
+	* `GET` of `baseUrl`: Studio Server has no model list, so a success only
+	* shows a server answered (`checked: 'reachability'`).
+	*/
+	probe(options) {
+		return this.probeEndpoint({
+			adapter: this.type,
+			url: () => normalizeBaseUrl(this.baseUrl),
+			listsModels: false
+		}, options);
+	}
 };
 //#endregion
 //#region src/shared/streaming-factory.ts
@@ -2190,8 +2469,10 @@ function parseMaxTurnSeconds(value) {
 function wrapStreamingTranscriber(streaming, options = {}) {
 	const chunkBytes = options.chunkBytes ?? 64 * 1024;
 	if (!Number.isInteger(chunkBytes) || chunkBytes <= 0) throw new SpeechConfigurationError("chunkBytes must be a positive integer", streaming.type);
+	const probe = streaming.probe?.bind(streaming);
 	return {
 		type: streaming.type,
+		...probe ? { probe } : {},
 		async transcribe(request) {
 			const audio = await normalizeAudioInput(request.audio, {
 				mimeType: request.mimeType,
@@ -2308,7 +2589,8 @@ function getWrappedStreamingTranscriber(type, options, context) {
 			model: options.model,
 			headers: options.headers,
 			timeoutMs: options.timeoutMs,
-			onUsage: options.onUsage
+			onUsage: options.onUsage,
+			fetch: options.fetch
 		})
 	}, {
 		env: context.env,
@@ -2568,6 +2850,6 @@ var ClientSecretClient = class extends HttpSpeechAdapter {
 	}
 };
 //#endregion
-export { CLIENT_SECRET_TTL_RANGE, DEFAULT_CLIENT_SECRET_TTL_SECONDS, DEFAULT_MAX_AUDIO_BYTES, DEFAULT_MAX_TURN_SECONDS, DEFAULT_ROLLOVER_MIN_SILENCE_MS, DEFAULT_ROLLOVER_SILENCE_THRESHOLD, DEFAULT_ROLLOVER_WINDOW_SECONDS, InvalidSpeechAdapterError, OPENAI_REALTIME_DEFAULT_MODEL, OPENAI_REALTIME_DEFAULT_URL, PcmCaptureError, RealtimeTranscriptionSession, STREAMING_TRANSCRIBER_ENV_KEYS, STREAMING_TRANSCRIBER_TYPES, SpeechConfigurationError, SpeechError, SpeechProviderError, TRANSCRIBER_ENV_KEYS, VOXTRAL_REALTIME_AUDIO_FORMAT, VOXTRAL_REALTIME_DEFAULT_MODEL, WavFormatError, audioSecondsForBytes, bytesPerSecond, createStreamingClientSecret, getAvailableSpeechAdapters, getSpeech, getSpeechSynthesizer, getStreamingTranscriber, getTranscriber, isBrowserRuntime, isStreamingTranscriberType, mimeTypeToAudioExtension, openAIRealtimeProtocol, openAIRealtimeTranscriptionSession, parseMaxTurnSeconds, parseOpenAIRealtimeEvent, parseVoxtralRealtimeEvent, resolveClientSecretUrl, resolveOpenAIRealtimeFormat, resolveRealtimeUrl, resolveVoxtralRealtimeUrl, transcriberInputFormat, unwrapRawAudio, voxtralRealtimeProtocol, wrapStreamingTranscriber };
+export { CLIENT_SECRET_TTL_RANGE, DEFAULT_CLIENT_SECRET_TTL_SECONDS, DEFAULT_MAX_AUDIO_BYTES, DEFAULT_MAX_TURN_SECONDS, DEFAULT_ROLLOVER_MIN_SILENCE_MS, DEFAULT_ROLLOVER_SILENCE_THRESHOLD, DEFAULT_ROLLOVER_WINDOW_SECONDS, DEFAULT_SPEECH_PROBE_TIMEOUT_MS, InvalidSpeechAdapterError, OPENAI_REALTIME_DEFAULT_MODEL, OPENAI_REALTIME_DEFAULT_URL, PcmCaptureError, RealtimeTranscriptionSession, STREAMING_TRANSCRIBER_ENV_KEYS, STREAMING_TRANSCRIBER_TYPES, SpeechAudioTooLargeError, SpeechConfigurationError, SpeechError, SpeechInvalidAudioError, SpeechProviderError, SpeechProviderUnavailableError, TRANSCRIBER_ENV_KEYS, VOXTRAL_REALTIME_AUDIO_FORMAT, VOXTRAL_REALTIME_DEFAULT_MODEL, WavFormatError, audioSecondsForBytes, bytesPerSecond, createStreamingClientSecret, getAvailableSpeechAdapters, getSpeech, getSpeechSynthesizer, getStreamingTranscriber, getTranscriber, isBrowserRuntime, isStreamingTranscriberType, mimeTypeToAudioExtension, openAIRealtimeProtocol, openAIRealtimeTranscriptionSession, parseMaxTurnSeconds, parseOpenAIRealtimeEvent, parseVoxtralRealtimeEvent, resolveClientSecretUrl, resolveOpenAIRealtimeFormat, resolveRealtimeUrl, resolveVoxtralRealtimeUrl, transcriberInputFormat, unwrapRawAudio, voxtralRealtimeProtocol, wrapStreamingTranscriber };
 
 //# sourceMappingURL=index.js.map