@otto-code/server 0.5.0

package/dist/server/server/speech/speech-runtime.js

@@ -0,0 +1,615 @@
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+import { ensureLocalSpeechModels, getLocalSpeechModelDir, listLocalSpeechModels, } from "./providers/local/models.js";
+import { initializeLocalSpeechServices } from "./providers/local/runtime.js";
+import { getOpenAiSpeechAvailability, initializeOpenAiSpeechServices, validateOpenAiCredentialRequirements, } from "./providers/openai/runtime.js";
+// Upper bound on preview text so a runaway prompt can't tie up the TTS engine.
+// Voice previews are a single short sentence; real playback splits at ~260.
+const TTS_PREVIEW_MAX_CHARS = 400;
+import { buildSpeechSettingsOptions, } from "./speech-settings-options.js";
+const SPEECH_RUNTIME_MONITOR_INTERVAL_MS = 3000;
+function resolveRequestedSpeechProviders(speechConfig) {
+    const defaults = {
+        dictationStt: { provider: "local", explicit: false, enabled: true },
+        voiceTurnDetection: { provider: "local", explicit: false, enabled: true },
+        voiceStt: { provider: "local", explicit: false, enabled: true },
+        voiceTts: { provider: "local", explicit: false, enabled: true },
+    };
+    const fromConfig = speechConfig?.providers;
+    if (!fromConfig) {
+        return defaults;
+    }
+    return {
+        dictationStt: fromConfig.dictationStt ?? defaults.dictationStt,
+        voiceTurnDetection: fromConfig.voiceTurnDetection ?? defaults.voiceTurnDetection,
+        voiceStt: fromConfig.voiceStt ?? defaults.voiceStt,
+        voiceTts: fromConfig.voiceTts ?? defaults.voiceTts,
+    };
+}
+async function hasRequiredLocalModelFile(filePath) {
+    try {
+        const fileStat = await stat(filePath);
+        if (fileStat.isDirectory()) {
+            return true;
+        }
+        return fileStat.isFile() && fileStat.size > 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function findMissingRequiredLocalModels(params) {
+    const { modelsDir, requiredModelIds } = params;
+    if (!modelsDir || requiredModelIds.length === 0) {
+        return [];
+    }
+    const specsById = new Map(listLocalSpeechModels().map((model) => [model.id, model]));
+    const missing = new Set();
+    const checks = await Promise.all(requiredModelIds.map(async (modelId) => {
+        const spec = specsById.get(modelId);
+        if (!spec)
+            return { modelId, missing: true };
+        const modelDir = getLocalSpeechModelDir(modelsDir, modelId);
+        const filePresence = await Promise.all(spec.requiredFiles.map((relPath) => hasRequiredLocalModelFile(join(modelDir, relPath))));
+        return { modelId, missing: !filePresence.every((present) => present) };
+    }));
+    for (const check of checks) {
+        if (check.missing)
+            missing.add(check.modelId);
+    }
+    return Array.from(missing);
+}
+function joinModelIds(modelIds) {
+    if (modelIds.length === 0) {
+        return "none";
+    }
+    return modelIds.join(", ");
+}
+function buildRealtimeVoiceReadiness(params) {
+    const voiceTurnDetectionEnabled = params.providers.voiceTurnDetection.enabled !== false;
+    const voiceSttEnabled = params.providers.voiceStt.enabled !== false;
+    const voiceTtsEnabled = params.providers.voiceTts.enabled !== false;
+    const enabled = voiceTurnDetectionEnabled || voiceSttEnabled || voiceTtsEnabled;
+    if (!enabled) {
+        return {
+            enabled: false,
+            available: false,
+            reasonCode: "disabled",
+            message: "Realtime voice is disabled in daemon config.",
+            retryable: false,
+            missingModelIds: [],
+        };
+    }
+    if (voiceTurnDetectionEnabled && !params.turnDetectionService) {
+        return {
+            enabled: true,
+            available: false,
+            reasonCode: "turn_detection_unavailable",
+            message: "Realtime voice is unavailable: turn-detection service is not ready.",
+            retryable: false,
+            missingModelIds: [],
+        };
+    }
+    if (voiceSttEnabled && !params.sttService) {
+        return {
+            enabled: true,
+            available: false,
+            reasonCode: "stt_unavailable",
+            message: "Realtime voice is unavailable: speech-to-text service is not ready.",
+            retryable: false,
+            missingModelIds: [],
+        };
+    }
+    if (voiceTtsEnabled && !params.ttsService) {
+        return {
+            enabled: true,
+            available: false,
+            reasonCode: "tts_unavailable",
+            message: "Realtime voice is unavailable: text-to-speech service is not ready.",
+            retryable: false,
+            missingModelIds: [],
+        };
+    }
+    return {
+        enabled: true,
+        available: true,
+        reasonCode: "ready",
+        message: "Realtime voice is ready.",
+        retryable: false,
+        missingModelIds: [],
+    };
+}
+function buildDictationReadiness(params) {
+    const enabled = params.providers.dictationStt.enabled !== false;
+    if (!enabled) {
+        return {
+            enabled: false,
+            available: false,
+            reasonCode: "disabled",
+            message: "Dictation is disabled in daemon config.",
+            retryable: false,
+            missingModelIds: [],
+        };
+    }
+    if (!params.dictationSttService) {
+        return {
+            enabled: true,
+            available: false,
+            reasonCode: "stt_unavailable",
+            message: "Dictation is unavailable: speech-to-text service is not ready.",
+            retryable: false,
+            missingModelIds: [],
+        };
+    }
+    return {
+        enabled: true,
+        available: true,
+        reasonCode: "ready",
+        message: "Dictation is ready.",
+        retryable: false,
+        missingModelIds: [],
+    };
+}
+function buildVoiceFeatureReadiness(params) {
+    const enabled = params.realtimeVoice.enabled || params.dictation.enabled;
+    if (!enabled) {
+        return {
+            enabled: false,
+            available: false,
+            reasonCode: "disabled",
+            message: "Voice features are disabled in daemon config.",
+            retryable: false,
+            missingModelIds: [],
+        };
+    }
+    if (params.missingLocalModelIds.length > 0) {
+        const missingModelIds = [...params.missingLocalModelIds];
+        if (params.backgroundDownloadInProgress) {
+            return {
+                enabled: true,
+                available: false,
+                reasonCode: "model_download_in_progress",
+                message: `Voice features are unavailable while models download in the background (${joinModelIds(missingModelIds)}).`,
+                retryable: true,
+                missingModelIds,
+            };
+        }
+        if (params.backgroundDownloadError) {
+            return {
+                enabled: true,
+                available: false,
+                reasonCode: "model_download_failed",
+                message: `Voice features are unavailable: model download failed (${params.backgroundDownloadError}).`,
+                retryable: false,
+                missingModelIds,
+            };
+        }
+        return {
+            enabled: true,
+            available: false,
+            reasonCode: "models_missing",
+            message: `Voice features are unavailable: missing local models (${joinModelIds(missingModelIds)}).`,
+            retryable: true,
+            missingModelIds,
+        };
+    }
+    return {
+        enabled: true,
+        available: true,
+        reasonCode: "ready",
+        message: "Voice features are ready.",
+        retryable: false,
+        missingModelIds: [],
+    };
+}
+function describeRequestedProviders(providers) {
+    return {
+        dictationStt: {
+            provider: providers.dictationStt.provider,
+            enabled: providers.dictationStt.enabled !== false,
+            explicit: providers.dictationStt.explicit,
+        },
+        voiceTurnDetection: {
+            provider: providers.voiceTurnDetection.provider,
+            enabled: providers.voiceTurnDetection.enabled !== false,
+            explicit: providers.voiceTurnDetection.explicit,
+        },
+        voiceStt: {
+            provider: providers.voiceStt.provider,
+            enabled: providers.voiceStt.enabled !== false,
+            explicit: providers.voiceStt.explicit,
+        },
+        voiceTts: {
+            provider: providers.voiceTts.provider,
+            enabled: providers.voiceTts.enabled !== false,
+            explicit: providers.voiceTts.explicit,
+        },
+    };
+}
+function resolveVoiceTtsLabel(ttsService, localVoiceTtsProvider) {
+    if (!ttsService)
+        return "unavailable";
+    if (ttsService === localVoiceTtsProvider)
+        return "local";
+    return "openai";
+}
+function resolveEffectiveProviderIds(params) {
+    return {
+        dictationStt: params.dictationSttService?.id ?? "unavailable",
+        voiceTurnDetection: params.turnDetectionService?.id ?? "unavailable",
+        voiceStt: params.sttService?.id ?? "unavailable",
+        voiceTts: resolveVoiceTtsLabel(params.ttsService, params.localVoiceTtsProvider),
+    };
+}
+export function createSpeechService(params) {
+    const logger = params.logger.child({ module: "speech-runtime" });
+    let speechConfig = params.speechConfig ?? null;
+    let openaiConfig = params.openaiConfig;
+    let providers = resolveRequestedSpeechProviders(speechConfig);
+    validateOpenAiCredentialRequirements({
+        providers,
+        openaiConfig,
+        logger,
+    });
+    logger.info({
+        requestedProviders: describeRequestedProviders(providers),
+        availability: {
+            openai: getOpenAiSpeechAvailability(openaiConfig),
+        },
+    }, "Speech provider reconciliation started");
+    let sttService = null;
+    let ttsService = null;
+    let dictationSttService = null;
+    let turnDetectionService = null;
+    let localModelConfig = null;
+    let localCleanup = () => { };
+    let localVoiceTtsProvider = null;
+    let missingLocalModelIds = [];
+    let backgroundDownloadInProgress = false;
+    let backgroundDownloadError = null;
+    let stopped = false;
+    let monitorTimeout = null;
+    let reconcileInFlight = null;
+    const readinessListeners = new Set();
+    let lastReadinessFingerprint = null;
+    let lastPublishedReadinessSnapshot = null;
+    let started = false;
+    let readySettled = false;
+    let resolveReady;
+    let rejectReady;
+    const ready = new Promise((resolve, reject) => {
+        resolveReady = resolve;
+        rejectReady = reject;
+    });
+    const computeReadinessSnapshot = () => {
+        const realtimeVoice = buildRealtimeVoiceReadiness({
+            providers,
+            turnDetectionService,
+            sttService,
+            ttsService,
+        });
+        const dictation = buildDictationReadiness({
+            providers,
+            dictationSttService,
+        });
+        const voiceFeature = buildVoiceFeatureReadiness({
+            realtimeVoice,
+            dictation,
+            missingLocalModelIds,
+            backgroundDownloadInProgress,
+            backgroundDownloadError,
+        });
+        return {
+            generatedAt: new Date().toISOString(),
+            requiredLocalModelIds: localModelConfig?.defaultModelIds ?? [],
+            missingLocalModelIds: [...missingLocalModelIds],
+            download: {
+                inProgress: backgroundDownloadInProgress,
+                error: backgroundDownloadError,
+            },
+            realtimeVoice: {
+                ...realtimeVoice,
+            },
+            dictation: {
+                ...dictation,
+            },
+            voiceFeature: {
+                ...voiceFeature,
+            },
+        };
+    };
+    const readinessFingerprint = (snapshot) => JSON.stringify({
+        ...snapshot,
+        generatedAt: "",
+    });
+    const publishReadinessIfChanged = () => {
+        const snapshot = computeReadinessSnapshot();
+        const fingerprint = readinessFingerprint(snapshot);
+        if (fingerprint === lastReadinessFingerprint) {
+            return;
+        }
+        lastReadinessFingerprint = fingerprint;
+        lastPublishedReadinessSnapshot = snapshot;
+        for (const listener of readinessListeners) {
+            try {
+                listener(snapshot);
+            }
+            catch (error) {
+                logger.warn({ err: error }, "Speech readiness listener threw an error");
+            }
+        }
+    };
+    const subscribeSpeechReadiness = (listener) => {
+        readinessListeners.add(listener);
+        const snapshot = lastPublishedReadinessSnapshot ?? computeReadinessSnapshot();
+        if (!lastPublishedReadinessSnapshot) {
+            lastPublishedReadinessSnapshot = snapshot;
+            lastReadinessFingerprint = readinessFingerprint(snapshot);
+        }
+        try {
+            listener(snapshot);
+        }
+        catch (error) {
+            logger.warn({ err: error }, "Speech readiness listener threw an error during subscribe");
+        }
+        return () => {
+            readinessListeners.delete(listener);
+        };
+    };
+    const refreshMissingLocalModels = async () => {
+        missingLocalModelIds = await findMissingRequiredLocalModels({
+            modelsDir: localModelConfig?.modelsDir ?? null,
+            requiredModelIds: localModelConfig?.defaultModelIds ?? [],
+        });
+    };
+    const reconcileServices = async () => {
+        const nextLocalSpeech = await initializeLocalSpeechServices({
+            providers,
+            speechConfig,
+            logger,
+        });
+        const nextOpenAiSpeech = initializeOpenAiSpeechServices({
+            providers,
+            openaiConfig,
+            existing: {
+                turnDetectionService: nextLocalSpeech.turnDetectionService,
+                sttService: nextLocalSpeech.sttService,
+                ttsService: nextLocalSpeech.ttsService,
+                dictationSttService: nextLocalSpeech.dictationSttService,
+            },
+            logger,
+        });
+        const previousLocalCleanup = localCleanup;
+        turnDetectionService = nextOpenAiSpeech.turnDetectionService;
+        sttService = nextOpenAiSpeech.sttService;
+        ttsService = nextOpenAiSpeech.ttsService;
+        dictationSttService = nextOpenAiSpeech.dictationSttService;
+        localModelConfig = nextLocalSpeech.localModelConfig;
+        localVoiceTtsProvider = nextLocalSpeech.localVoiceTtsProvider;
+        localCleanup = nextLocalSpeech.cleanup;
+        previousLocalCleanup();
+        await refreshMissingLocalModels();
+        const effectiveProviders = resolveEffectiveProviderIds({
+            turnDetectionService,
+            sttService,
+            ttsService,
+            dictationSttService,
+            localVoiceTtsProvider,
+        });
+        const unavailableFeatures = [
+            providers.dictationStt.enabled !== false && !dictationSttService ? "dictation.stt" : null,
+            providers.voiceTurnDetection.enabled !== false && !turnDetectionService
+                ? "voice.turnDetection"
+                : null,
+            providers.voiceStt.enabled !== false && !sttService ? "voice.stt" : null,
+            providers.voiceTts.enabled !== false && !ttsService ? "voice.tts" : null,
+        ].filter((feature) => feature !== null);
+        if (unavailableFeatures.length > 0) {
+            logger.warn({
+                requestedProviders: describeRequestedProviders(providers),
+                effectiveProviders,
+                unavailableFeatures,
+                missingLocalModelIds,
+            }, "Speech provider reconciliation completed with unavailable features");
+        }
+        else {
+            logger.info({
+                requestedProviders: describeRequestedProviders(providers),
+                effectiveProviders,
+            }, "Speech provider reconciliation completed");
+        }
+    };
+    const runReconcile = async () => {
+        if (reconcileInFlight) {
+            await reconcileInFlight;
+            publishReadinessIfChanged();
+            return;
+        }
+        reconcileInFlight = reconcileServices().finally(() => {
+            reconcileInFlight = null;
+        });
+        await reconcileInFlight;
+        publishReadinessIfChanged();
+    };
+    const scheduleMonitor = () => {
+        if (stopped || monitorTimeout) {
+            return;
+        }
+        monitorTimeout = setTimeout(() => {
+            monitorTimeout = null;
+            void runMonitorTick();
+        }, SPEECH_RUNTIME_MONITOR_INTERVAL_MS);
+    };
+    const startBackgroundDownload = () => {
+        if (stopped || backgroundDownloadInProgress) {
+            return;
+        }
+        const modelsDir = localModelConfig?.modelsDir ?? null;
+        const modelIds = [...missingLocalModelIds];
+        if (!modelsDir || modelIds.length === 0) {
+            return;
+        }
+        backgroundDownloadInProgress = true;
+        backgroundDownloadError = null;
+        publishReadinessIfChanged();
+        logger.info({
+            modelsDir,
+            modelIds,
+        }, "Starting background download for missing local speech models");
+        void (async () => {
+            try {
+                await ensureLocalSpeechModels({
+                    modelsDir,
+                    modelIds,
+                    logger,
+                });
+                await runReconcile();
+                backgroundDownloadError = null;
+            }
+            catch (error) {
+                backgroundDownloadError = error instanceof Error ? error.message : String(error);
+                publishReadinessIfChanged();
+                logger.error({
+                    err: error,
+                    modelIds,
+                }, "Background local speech model download failed");
+            }
+            finally {
+                backgroundDownloadInProgress = false;
+                await refreshMissingLocalModels().catch((error) => {
+                    logger.warn({ err: error }, "Failed to refresh local speech model status after download");
+                });
+                publishReadinessIfChanged();
+                scheduleMonitor();
+            }
+        })();
+    };
+    const runMonitorTick = async () => {
+        if (stopped) {
+            return;
+        }
+        try {
+            await refreshMissingLocalModels();
+            const snapshot = computeReadinessSnapshot();
+            if (snapshot.voiceFeature.enabled &&
+                !snapshot.voiceFeature.available &&
+                missingLocalModelIds.length === 0 &&
+                !backgroundDownloadInProgress) {
+                await runReconcile();
+            }
+            if (missingLocalModelIds.length > 0 &&
+                !backgroundDownloadInProgress &&
+                !backgroundDownloadError) {
+                startBackgroundDownload();
+            }
+        }
+        catch (error) {
+            logger.warn({ err: error }, "Speech runtime monitor tick failed");
+        }
+        finally {
+            publishReadinessIfChanged();
+            scheduleMonitor();
+        }
+    };
+    const start = () => {
+        if (started || stopped) {
+            return;
+        }
+        started = true;
+        void (async () => {
+            try {
+                await runReconcile();
+                const snapshot = computeReadinessSnapshot();
+                if (snapshot.voiceFeature.enabled && !snapshot.voiceFeature.available) {
+                    if (missingLocalModelIds.length > 0) {
+                        startBackgroundDownload();
+                    }
+                    scheduleMonitor();
+                }
+                if (!readySettled) {
+                    readySettled = true;
+                    resolveReady();
+                }
+            }
+            catch (error) {
+                if (!readySettled) {
+                    readySettled = true;
+                    rejectReady(error);
+                }
+                logger.error({ err: error }, "Speech runtime failed during initial reconcile");
+            }
+        })();
+    };
+    const stop = () => {
+        stopped = true;
+        if (monitorTimeout) {
+            clearTimeout(monitorTimeout);
+            monitorTimeout = null;
+        }
+        localCleanup();
+    };
+    const configFingerprint = (speech, openai) => JSON.stringify({ speech, openai: openai ?? null });
+    let lastConfigFingerprint = configFingerprint(speechConfig, openaiConfig);
+    const reconfigure = async (next) => {
+        if (stopped) {
+            return;
+        }
+        const nextSpeechConfig = next.speechConfig ?? null;
+        const nextFingerprint = configFingerprint(nextSpeechConfig, next.openaiConfig);
+        if (nextFingerprint === lastConfigFingerprint) {
+            return;
+        }
+        lastConfigFingerprint = nextFingerprint;
+        speechConfig = nextSpeechConfig;
+        openaiConfig = next.openaiConfig;
+        providers = resolveRequestedSpeechProviders(speechConfig);
+        validateOpenAiCredentialRequirements({ providers, openaiConfig, logger });
+        logger.info({ requestedProviders: describeRequestedProviders(providers) }, "Speech configuration changed; reconciling providers");
+        // Drain a reconcile that started before the config swap so the follow-up
+        // pass below is guaranteed to see the new config. A reconcile that starts
+        // after the swap already reads the new closure state.
+        const inFlightBeforeSwap = reconcileInFlight;
+        if (inFlightBeforeSwap) {
+            await inFlightBeforeSwap.catch(() => undefined);
+        }
+        await runReconcile();
+        if (missingLocalModelIds.length > 0) {
+            startBackgroundDownload();
+        }
+        scheduleMonitor();
+    };
+    return {
+        resolveTurnDetection: () => turnDetectionService,
+        resolveStt: () => sttService,
+        resolveSttLanguage: () => speechConfig?.sttLanguages?.voice ?? "en",
+        resolveTts: () => ttsService,
+        resolveDictationStt: () => dictationSttService,
+        resolveDictationSttLanguage: () => speechConfig?.sttLanguages?.dictation ?? "en",
+        getReadiness: () => lastPublishedReadinessSnapshot ?? computeReadinessSnapshot(),
+        onReadinessChange: subscribeSpeechReadiness,
+        getSettingsOptions: () => buildSpeechSettingsOptions({
+            openaiAvailability: getOpenAiSpeechAvailability(openaiConfig),
+        }),
+        synthesizePreview: async ({ text, voice }) => {
+            const provider = ttsService;
+            if (!provider)
+                return null;
+            const trimmed = text.trim().slice(0, TTS_PREVIEW_MAX_CHARS);
+            if (trimmed.length === 0)
+                return null;
+            const { stream, format } = await provider.synthesizeSpeech(trimmed, voice);
+            const buffers = [];
+            for await (const chunk of stream) {
+                buffers.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            }
+            if (buffers.length === 0)
+                return null;
+            return { audio: Buffer.concat(buffers).toString("base64"), format };
+        },
+        reconfigure,
+        start,
+        stop,
+        ready,
+    };
+}
+//# sourceMappingURL=speech-runtime.js.map

package/dist/server/server/speech/speech-settings-options.d.ts

@@ -0,0 +1,14 @@
+import type { SpeechSettingsOptions } from "@otto-code/protocol/messages";
+export type { SpeechSettingsOptions };
+export declare const OPENAI_SPEECH_STT_MODELS: string[];
+export declare const OPENAI_SPEECH_TTS_MODELS: string[];
+export declare const OPENAI_SPEECH_TTS_VOICES: string[];
+/** Fallback for sessions constructed without a speech service (tests, minimal daemons). */
+export declare const EMPTY_SPEECH_SETTINGS_OPTIONS: SpeechSettingsOptions;
+export declare function buildSpeechSettingsOptions(params: {
+    openaiAvailability: {
+        stt: boolean;
+        tts: boolean;
+    };
+}): SpeechSettingsOptions;
+//# sourceMappingURL=speech-settings-options.d.ts.map

package/dist/server/server/speech/speech-settings-options.js

@@ -0,0 +1,73 @@
+import { getLocalTtsDefaultSpeakerId, listLocalSpeechModels, listLocalTtsVoices, } from "./providers/local/models.js";
+export const OPENAI_SPEECH_STT_MODELS = [
+    "whisper-1",
+    "gpt-4o-transcribe",
+    "gpt-4o-mini-transcribe",
+];
+export const OPENAI_SPEECH_TTS_MODELS = ["tts-1", "tts-1-hd", "gpt-4o-mini-tts"];
+export const OPENAI_SPEECH_TTS_VOICES = [
+    "alloy",
+    "ash",
+    "ballad",
+    "coral",
+    "echo",
+    "fable",
+    "nova",
+    "onyx",
+    "sage",
+    "shimmer",
+    "verse",
+];
+const OPENAI_UNAVAILABLE_REASON = "OpenAI API key is not configured on the daemon.";
+/** Fallback for sessions constructed without a speech service (tests, minimal daemons). */
+export const EMPTY_SPEECH_SETTINGS_OPTIONS = {
+    sttEngines: [],
+    ttsEngines: [],
+    local: { sttModels: [], ttsModels: [] },
+    openai: { configured: false, sttModels: [], ttsModels: [], ttsVoices: [] },
+};
+function engineOption(id, available) {
+    return {
+        id,
+        available,
+        ...(available ? {} : { reason: OPENAI_UNAVAILABLE_REASON }),
+    };
+}
+export function buildSpeechSettingsOptions(params) {
+    const models = listLocalSpeechModels();
+    const sttModels = models
+        .filter((model) => model.kind !== "tts")
+        .map((model) => ({ id: model.id, label: model.label, description: model.description }));
+    const ttsModels = models
+        .filter((model) => model.kind === "tts")
+        .map((model) => {
+        const modelId = model.id;
+        const voices = listLocalTtsVoices(modelId);
+        const defaultSpeakerId = getLocalTtsDefaultSpeakerId(modelId);
+        return {
+            id: model.id,
+            label: model.label,
+            description: model.description,
+            voices: voices.map((voice) => voice.name),
+            defaultVoice: voices[defaultSpeakerId]?.name ?? voices[0]?.name ?? "",
+        };
+    });
+    return {
+        sttEngines: [
+            engineOption("local", true),
+            engineOption("openai", params.openaiAvailability.stt),
+        ],
+        ttsEngines: [
+            engineOption("local", true),
+            engineOption("openai", params.openaiAvailability.tts),
+        ],
+        local: { sttModels, ttsModels },
+        openai: {
+            configured: params.openaiAvailability.stt || params.openaiAvailability.tts,
+            sttModels: OPENAI_SPEECH_STT_MODELS,
+            ttsModels: OPENAI_SPEECH_TTS_MODELS,
+            ttsVoices: OPENAI_SPEECH_TTS_VOICES,
+        },
+    };
+}
+//# sourceMappingURL=speech-settings-options.js.map