@otto-code/server 0.5.0

package/dist/server/server/speech/providers/local/worker-process.js

@@ -0,0 +1,270 @@
+import pino from "pino";
+import { getLocalSpeechModelDir } from "./models.js";
+import { SherpaOfflineRecognizerEngine } from "./sherpa/sherpa-offline-recognizer.js";
+import { SherpaOnnxParakeetSTT } from "./sherpa/sherpa-parakeet-stt.js";
+import { SherpaParakeetRealtimeTranscriptionSession } from "./sherpa/sherpa-parakeet-realtime-session.js";
+import { SherpaOnnxTTS } from "./sherpa/sherpa-tts.js";
+import { ensureSileroVadModel, SherpaSileroTurnDetectionProvider, } from "./sherpa/silero-vad-provider.js";
+import { bufferToWorkerBytes, workerBytesToBuffer } from "./worker-bytes.js";
+process.title = "Otto Voice";
+const logger = pino({
+    level: process.env.OTTO_LOG_LEVEL ?? "info",
+}).child({ module: "speech", component: "local-worker" });
+const sttEngines = new Map();
+const sttProviders = new Map();
+const ttsProviders = new Map();
+const sessions = new Map();
+const unsubscribeBySessionId = new Map();
+let ipcClosing = false;
+function sendToParent(message) {
+    if (ipcClosing || !process.connected || !process.send) {
+        return;
+    }
+    try {
+        process.send(message, (error) => {
+            if (error) {
+                ipcClosing = true;
+            }
+        });
+    }
+    catch {
+        ipcClosing = true;
+    }
+}
+function sttModelId(config, model) {
+    return (model === "voice" ? config.voiceSttModel : config.dictationSttModel);
+}
+function ttsModelId(config) {
+    return config.voiceTtsModel;
+}
+function sttEngineKey(config, modelId) {
+    return `${config.modelsDir}:${modelId}`;
+}
+function ttsKey(config) {
+    return [
+        config.modelsDir,
+        config.voiceTtsModel,
+        config.voiceTtsSpeakerId ?? 0,
+        config.voiceTtsSpeed ?? 1,
+    ].join(":");
+}
+function getSttEngine(config, model) {
+    const modelId = sttModelId(config, model);
+    const key = sttEngineKey(config, modelId);
+    const existing = sttEngines.get(key);
+    if (existing) {
+        return existing;
+    }
+    const modelDir = getLocalSpeechModelDir(config.modelsDir, modelId);
+    const created = new SherpaOfflineRecognizerEngine({
+        model: {
+            kind: "nemo_transducer",
+            encoder: `${modelDir}/encoder.int8.onnx`,
+            decoder: `${modelDir}/decoder.int8.onnx`,
+            joiner: `${modelDir}/joiner.int8.onnx`,
+            tokens: `${modelDir}/tokens.txt`,
+        },
+        numThreads: 2,
+        debug: 0,
+    }, logger);
+    sttEngines.set(key, created);
+    return created;
+}
+function getSttProvider(config, model) {
+    const modelId = sttModelId(config, model);
+    const key = sttEngineKey(config, modelId);
+    const existing = sttProviders.get(key);
+    if (existing) {
+        return existing;
+    }
+    const created = new SherpaOnnxParakeetSTT({ engine: getSttEngine(config, model) }, logger);
+    sttProviders.set(key, created);
+    return created;
+}
+function getTtsProvider(config) {
+    const key = ttsKey(config);
+    const existing = ttsProviders.get(key);
+    if (existing) {
+        return existing;
+    }
+    const modelDir = getLocalSpeechModelDir(config.modelsDir, ttsModelId(config));
+    const created = new SherpaOnnxTTS({
+        preset: ttsModelId(config),
+        modelDir,
+        speakerId: config.voiceTtsSpeakerId,
+        speed: config.voiceTtsSpeed,
+    }, logger);
+    ttsProviders.set(key, created);
+    return created;
+}
+function cleanupSession(sessionId) {
+    const unsubscribe = unsubscribeBySessionId.get(sessionId);
+    if (unsubscribe) {
+        for (const fn of unsubscribe) {
+            try {
+                fn();
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    unsubscribeBySessionId.delete(sessionId);
+    const session = sessions.get(sessionId);
+    sessions.delete(sessionId);
+    try {
+        session?.close();
+    }
+    catch {
+        // ignore
+    }
+}
+function trackTranscriptionSession(sessionId, session) {
+    session.on("committed", (payload) => {
+        sendToParent({ type: "session.committed", sessionId, payload });
+    });
+    session.on("transcript", (payload) => {
+        sendToParent({ type: "session.transcript", sessionId, payload });
+    });
+    session.on("error", (err) => {
+        sendToParent({
+            type: "session.error",
+            sessionId,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    });
+    unsubscribeBySessionId.set(sessionId, []);
+}
+function trackTurnDetectionSession(sessionId, session) {
+    session.on("speech_started", () => {
+        sendToParent({ type: "session.speech_started", sessionId });
+    });
+    session.on("speech_stopped", () => {
+        sendToParent({ type: "session.speech_stopped", sessionId });
+    });
+    session.on("error", (err) => {
+        sendToParent({
+            type: "session.error",
+            sessionId,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    });
+    unsubscribeBySessionId.set(sessionId, []);
+}
+async function createSession(message) {
+    cleanupSession(message.sessionId);
+    if (message.kind === "vad") {
+        let vadModelPath;
+        try {
+            vadModelPath = await ensureSileroVadModel(message.config.modelsDir, logger);
+        }
+        catch (err) {
+            logger.warn({ err }, "Failed to provision Silero VAD model, falling back to bundled");
+        }
+        const provider = new SherpaSileroTurnDetectionProvider({ modelPath: vadModelPath }, logger);
+        const session = provider.createSession({ logger });
+        trackTurnDetectionSession(message.sessionId, session);
+        await session.connect();
+        sessions.set(message.sessionId, session);
+        return { requiredSampleRate: session.requiredSampleRate };
+    }
+    const model = message.kind === "voiceStt" ? "voice" : "dictation";
+    const engine = getSttEngine(message.config, model);
+    const session = message.kind === "voiceStt"
+        ? getSttProvider(message.config, "voice").createSession({ logger })
+        : new SherpaParakeetRealtimeTranscriptionSession({ engine });
+    trackTranscriptionSession(message.sessionId, session);
+    await session.connect();
+    sessions.set(message.sessionId, session);
+    return { requiredSampleRate: session.requiredSampleRate };
+}
+function sendOk(requestId, result) {
+    sendToParent({ type: "response", requestId, ok: true, result });
+}
+function handleSessionRequest(message) {
+    if (message.type === "session.close") {
+        cleanupSession(message.sessionId);
+        sendOk(message.requestId);
+        return;
+    }
+    const session = sessions.get(message.sessionId);
+    switch (message.type) {
+        case "session.append":
+            session?.appendPcm16(workerBytesToBuffer(message.audio));
+            break;
+        case "session.commit":
+            if (session && "commit" in session) {
+                session.commit();
+            }
+            break;
+        case "session.clear":
+            if (session && "clear" in session) {
+                session.clear();
+            }
+            break;
+        case "session.flush":
+            if (session && "flush" in session) {
+                session.flush();
+            }
+            break;
+        case "session.reset":
+            if (session && "reset" in session) {
+                session.reset();
+            }
+            break;
+    }
+    sendOk(message.requestId);
+}
+async function handleRequest(message) {
+    if (message.type === "tts.synthesize") {
+        const result = await getTtsProvider(message.config).synthesizeSpeech(message.text, message.voice);
+        const chunks = [];
+        for await (const chunk of result.stream) {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        }
+        sendOk(message.requestId, {
+            audio: bufferToWorkerBytes(Buffer.concat(chunks)),
+            format: result.format,
+        });
+        return;
+    }
+    if (message.type === "stt.transcribe") {
+        const result = await getSttProvider(message.config, message.model).transcribeAudio(workerBytesToBuffer(message.audio), message.format);
+        sendOk(message.requestId, result);
+        return;
+    }
+    if (message.type === "session.create") {
+        const result = await createSession(message);
+        sendOk(message.requestId, result);
+        return;
+    }
+    handleSessionRequest(message);
+}
+process.on("message", (message) => {
+    void handleRequest(message).catch((error) => {
+        sendToParent({
+            type: "response",
+            requestId: message.requestId,
+            ok: false,
+            error: error instanceof Error ? error.message : "Local speech worker request failed",
+        });
+    });
+});
+process.once("disconnect", () => {
+    ipcClosing = true;
+    for (const sessionId of Array.from(sessions.keys())) {
+        cleanupSession(sessionId);
+    }
+    for (const tts of ttsProviders.values()) {
+        try {
+            tts.free();
+        }
+        catch {
+            // ignore
+        }
+    }
+    for (const engine of sttEngines.values()) {
+        engine.free();
+    }
+});
+//# sourceMappingURL=worker-process.js.map

package/dist/server/server/speech/providers/local/worker-protocol.d.ts

@@ -0,0 +1,96 @@
+import type { SpeechVoiceOverride, StreamingTranscriptionCommittedEvent, StreamingTranscriptionEvent, TranscriptionResult } from "../../speech-provider.js";
+import type { LocalSpeechWorkerBytes } from "./worker-bytes.js";
+export interface LocalSpeechWorkerConfig {
+    modelsDir: string;
+    voiceSttModel: string;
+    dictationSttModel: string;
+    voiceTtsModel: string;
+    voiceTtsSpeakerId?: number;
+    voiceTtsSpeed?: number;
+}
+export type LocalSpeechSessionKind = "voiceStt" | "dictationStt" | "vad";
+export type LocalSpeechWorkerRequest = {
+    type: "tts.synthesize";
+    requestId: string;
+    config: LocalSpeechWorkerConfig;
+    text: string;
+    voice?: SpeechVoiceOverride;
+} | {
+    type: "stt.transcribe";
+    requestId: string;
+    config: LocalSpeechWorkerConfig;
+    model: "voice" | "dictation";
+    audio: LocalSpeechWorkerBytes;
+    format: string;
+} | {
+    type: "session.create";
+    requestId: string;
+    config: LocalSpeechWorkerConfig;
+    sessionId: string;
+    kind: LocalSpeechSessionKind;
+} | {
+    type: "session.append";
+    requestId: string;
+    sessionId: string;
+    audio: LocalSpeechWorkerBytes;
+} | {
+    type: "session.commit";
+    requestId: string;
+    sessionId: string;
+} | {
+    type: "session.clear";
+    requestId: string;
+    sessionId: string;
+} | {
+    type: "session.flush";
+    requestId: string;
+    sessionId: string;
+} | {
+    type: "session.reset";
+    requestId: string;
+    sessionId: string;
+} | {
+    type: "session.close";
+    requestId: string;
+    sessionId: string;
+};
+export type LocalSpeechWorkerResponse = {
+    type: "response";
+    requestId: string;
+    ok: true;
+    result?: unknown;
+} | {
+    type: "response";
+    requestId: string;
+    ok: false;
+    error: string;
+};
+export type LocalSpeechWorkerEvent = {
+    type: "session.committed";
+    sessionId: string;
+    payload: StreamingTranscriptionCommittedEvent;
+} | {
+    type: "session.transcript";
+    sessionId: string;
+    payload: StreamingTranscriptionEvent;
+} | {
+    type: "session.speech_started";
+    sessionId: string;
+} | {
+    type: "session.speech_stopped";
+    sessionId: string;
+} | {
+    type: "session.error";
+    sessionId: string;
+    error: string;
+};
+export type LocalSpeechWorkerToParentMessage = LocalSpeechWorkerResponse | LocalSpeechWorkerEvent;
+export interface LocalSpeechCreateSessionResult {
+    requiredSampleRate: number;
+}
+export interface LocalSpeechTtsResult {
+    audio: LocalSpeechWorkerBytes;
+    format: string;
+}
+export type LocalSpeechTranscriptionResult = TranscriptionResult;
+//# sourceMappingURL=worker-protocol.d.ts.map

package/dist/server/server/speech/providers/local/worker-protocol.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=worker-protocol.js.map

package/dist/server/server/speech/providers/openai/config.d.ts

@@ -0,0 +1,19 @@
+import type { PersistedConfig } from "../../../persisted-config.js";
+import type { RequestedSpeechProviders } from "../../speech-types.js";
+import type { STTConfig } from "./stt.js";
+import type { TTSConfig } from "./tts.js";
+export declare const DEFAULT_OPENAI_TTS_MODEL = "tts-1";
+export interface OpenAiSpeechProviderConfig {
+    stt?: Partial<STTConfig> & {
+        apiKey?: string;
+    };
+    tts?: Partial<TTSConfig> & {
+        apiKey?: string;
+    };
+}
+export declare function resolveOpenAiSpeechConfig(params: {
+    env: NodeJS.ProcessEnv;
+    persisted: PersistedConfig;
+    providers: RequestedSpeechProviders;
+}): OpenAiSpeechProviderConfig | undefined;
+//# sourceMappingURL=config.d.ts.map

package/dist/server/server/speech/providers/openai/config.js

@@ -0,0 +1,160 @@
+import { z } from "zod";
+export const DEFAULT_OPENAI_TTS_MODEL = "tts-1";
+const OpenAiTtsVoiceSchema = z.enum([
+    "alloy",
+    "ash",
+    "ballad",
+    "coral",
+    "echo",
+    "fable",
+    "nova",
+    "onyx",
+    "sage",
+    "shimmer",
+    "verse",
+]);
+const OpenAiTtsModelSchema = z.enum(["tts-1", "tts-1-hd", "gpt-4o-mini-tts"]);
+const NumberLikeSchema = z.union([z.number(), z.string().trim().min(1)]);
+const OptionalFiniteNumberSchema = NumberLikeSchema.pipe(z.coerce.number().finite()).optional();
+const OptionalTrimmedStringSchema = z
+    .string()
+    .trim()
+    .optional()
+    .transform((value) => (value && value.length > 0 ? value : undefined));
+// Endpoint credentials only — plain trimmed strings, so this never throws on a
+// malformed value. The STT/TTS option groups parse separately and only for the
+// endpoint that is actually configured, so a stale env var for an unused endpoint
+// (e.g. a leftover TTS_VOICE in an STT-only setup) can't break the other one.
+const OpenAiEndpointKeysSchema = z.object({
+    sttApiKey: OptionalTrimmedStringSchema,
+    sttBaseUrl: OptionalTrimmedStringSchema,
+    ttsApiKey: OptionalTrimmedStringSchema,
+    ttsBaseUrl: OptionalTrimmedStringSchema,
+});
+const OpenAiSttOptionsSchema = z.object({
+    sttConfidenceThreshold: OptionalFiniteNumberSchema,
+    sttModel: OptionalTrimmedStringSchema,
+});
+const OpenAiTtsOptionsSchema = z.object({
+    ttsVoice: z.string().trim().toLowerCase().pipe(OpenAiTtsVoiceSchema).default("alloy"),
+    ttsModel: z
+        .string()
+        .trim()
+        .toLowerCase()
+        .pipe(OpenAiTtsModelSchema)
+        .default(DEFAULT_OPENAI_TTS_MODEL),
+});
+function isOpenAiProviderActive(provider) {
+    return provider.enabled !== false && provider.provider === "openai";
+}
+function pickIfOpenAi(provider, value) {
+    return isOpenAiProviderActive(provider) ? value : undefined;
+}
+function firstDefined(values) {
+    for (const value of values) {
+        if (value === undefined || value === null) {
+            continue;
+        }
+        // Empty/whitespace env vars (e.g. a copied .env.example with OPENAI_STT_API_KEY=)
+        // must not shadow a later fallback such as OPENAI_API_KEY.
+        if (typeof value === "string" && value.trim().length === 0) {
+            continue;
+        }
+        return value;
+    }
+    return undefined;
+}
+function buildOpenAiSttInput(params) {
+    const { env, persisted, providers } = params;
+    return {
+        sttConfidenceThreshold: firstDefined([
+            env.STT_CONFIDENCE_THRESHOLD,
+            persisted.features?.dictation?.stt?.confidenceThreshold,
+        ]),
+        sttModel: firstDefined([
+            env.STT_MODEL,
+            pickIfOpenAi(providers.voiceStt, persisted.features?.voiceMode?.stt?.model),
+            pickIfOpenAi(providers.dictationStt, persisted.features?.dictation?.stt?.model),
+        ]),
+    };
+}
+function buildOpenAiTtsInput(params) {
+    const { env, persisted, providers } = params;
+    return {
+        ttsVoice: firstDefined([
+            env.TTS_VOICE,
+            pickIfOpenAi(providers.voiceTts, persisted.features?.voiceMode?.tts?.voice),
+            "alloy",
+        ]),
+        ttsModel: firstDefined([
+            env.TTS_MODEL,
+            pickIfOpenAi(providers.voiceTts, persisted.features?.voiceMode?.tts?.model),
+            DEFAULT_OPENAI_TTS_MODEL,
+        ]),
+    };
+}
+function buildOpenAiResolutionInput(params) {
+    const { env } = params;
+    const openai = params.persisted.providers?.openai;
+    return {
+        sttApiKey: firstDefined([
+            openai?.stt?.apiKey,
+            env.OPENAI_STT_API_KEY,
+            openai?.apiKey,
+            env.OPENAI_API_KEY,
+        ]),
+        sttBaseUrl: firstDefined([
+            openai?.stt?.baseUrl,
+            env.OPENAI_STT_BASE_URL,
+            openai?.baseUrl,
+            env.OPENAI_BASE_URL,
+        ]),
+        ttsApiKey: firstDefined([
+            openai?.tts?.apiKey,
+            env.OPENAI_TTS_API_KEY,
+            openai?.apiKey,
+            env.OPENAI_API_KEY,
+        ]),
+        ttsBaseUrl: firstDefined([
+            openai?.tts?.baseUrl,
+            env.OPENAI_TTS_BASE_URL,
+            openai?.baseUrl,
+            env.OPENAI_BASE_URL,
+        ]),
+        ...buildOpenAiSttInput(params),
+        ...buildOpenAiTtsInput(params),
+    };
+}
+export function resolveOpenAiSpeechConfig(params) {
+    const input = buildOpenAiResolutionInput(params);
+    const keys = OpenAiEndpointKeysSchema.parse(input);
+    if (!keys.sttApiKey && !keys.ttsApiKey) {
+        return undefined;
+    }
+    return {
+        ...(keys.sttApiKey ? { stt: buildSttConfig(keys.sttApiKey, keys.sttBaseUrl, input) } : {}),
+        ...(keys.ttsApiKey ? { tts: buildTtsConfig(keys.ttsApiKey, keys.ttsBaseUrl, input) } : {}),
+    };
+}
+function buildSttConfig(apiKey, baseUrl, input) {
+    const options = OpenAiSttOptionsSchema.parse(input);
+    return {
+        apiKey,
+        ...(baseUrl ? { baseUrl } : {}),
+        ...(options.sttConfidenceThreshold !== undefined
+            ? { confidenceThreshold: options.sttConfidenceThreshold }
+            : {}),
+        ...(options.sttModel ? { model: options.sttModel } : {}),
+    };
+}
+function buildTtsConfig(apiKey, baseUrl, input) {
+    const options = OpenAiTtsOptionsSchema.parse(input);
+    return {
+        apiKey,
+        ...(baseUrl ? { baseUrl } : {}),
+        voice: options.ttsVoice,
+        model: options.ttsModel,
+        responseFormat: "pcm",
+    };
+}
+//# sourceMappingURL=config.js.map

package/dist/server/server/speech/providers/openai/runtime.d.ts

@@ -0,0 +1,29 @@
+import type { Logger } from "pino";
+import type { SpeechToTextProvider, TextToSpeechProvider } from "../../speech-provider.js";
+import type { RequestedSpeechProviders } from "../../speech-types.js";
+import type { TurnDetectionProvider } from "../../turn-detection-provider.js";
+import { type OpenAiSpeechProviderConfig } from "./config.js";
+export interface OpenAiSpeechAvailability {
+    stt: boolean;
+    tts: boolean;
+    dictationStt: boolean;
+}
+export interface SpeechServices {
+    turnDetectionService: TurnDetectionProvider | null;
+    sttService: SpeechToTextProvider | null;
+    ttsService: TextToSpeechProvider | null;
+    dictationSttService: SpeechToTextProvider | null;
+}
+export declare function getOpenAiSpeechAvailability(openaiConfig: OpenAiSpeechProviderConfig | undefined): OpenAiSpeechAvailability;
+export declare function validateOpenAiCredentialRequirements(params: {
+    providers: RequestedSpeechProviders;
+    openaiConfig: OpenAiSpeechProviderConfig | undefined;
+    logger: Logger;
+}): void;
+export declare function initializeOpenAiSpeechServices(params: {
+    providers: RequestedSpeechProviders;
+    openaiConfig: OpenAiSpeechProviderConfig | undefined;
+    existing: SpeechServices;
+    logger: Logger;
+}): SpeechServices;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/server/server/speech/providers/openai/runtime.js

@@ -0,0 +1,102 @@
+import { DEFAULT_OPENAI_TTS_MODEL } from "./config.js";
+import { OpenAISTT } from "./stt.js";
+import { OpenAITTS } from "./tts.js";
+function resolveOpenAiCredentials(openaiConfig) {
+    const sttApiKey = openaiConfig?.stt?.apiKey;
+    return {
+        openaiSttApiKey: sttApiKey,
+        openaiTtsApiKey: openaiConfig?.tts?.apiKey,
+        openaiDictationApiKey: sttApiKey,
+    };
+}
+export function getOpenAiSpeechAvailability(openaiConfig) {
+    const credentials = resolveOpenAiCredentials(openaiConfig);
+    return {
+        stt: Boolean(credentials.openaiSttApiKey),
+        tts: Boolean(credentials.openaiTtsApiKey),
+        dictationStt: Boolean(credentials.openaiDictationApiKey),
+    };
+}
+export function validateOpenAiCredentialRequirements(params) {
+    const { providers, logger, openaiConfig } = params;
+    const openAiCredentials = resolveOpenAiCredentials(openaiConfig);
+    const missingOpenAiCredentialsFor = [];
+    if (providers.voiceStt.enabled !== false &&
+        providers.voiceStt.provider === "openai" &&
+        !openAiCredentials.openaiSttApiKey) {
+        missingOpenAiCredentialsFor.push("voice.stt");
+    }
+    if (providers.voiceTts.enabled !== false &&
+        providers.voiceTts.provider === "openai" &&
+        !openAiCredentials.openaiTtsApiKey) {
+        missingOpenAiCredentialsFor.push("voice.tts");
+    }
+    if (providers.dictationStt.enabled !== false &&
+        providers.dictationStt.provider === "openai" &&
+        !openAiCredentials.openaiDictationApiKey) {
+        missingOpenAiCredentialsFor.push("dictation.stt");
+    }
+    if (missingOpenAiCredentialsFor.length > 0) {
+        logger.warn({
+            requestedProviders: {
+                dictationStt: providers.dictationStt.provider,
+                voiceStt: providers.voiceStt.provider,
+                voiceTts: providers.voiceTts.provider,
+            },
+            missingOpenAiCredentialsFor,
+        }, "Invalid speech configuration: OpenAI provider selected but credentials are missing — speech features will be unavailable");
+    }
+}
+function createOpenAiStt(apiKey, openaiConfig, logger) {
+    const { apiKey: _sttApiKey, ...sttConfig } = openaiConfig?.stt ?? {};
+    return new OpenAISTT({ apiKey, ...sttConfig }, logger);
+}
+function createOpenAiTts(apiKey, openaiConfig, logger) {
+    const { apiKey: _ttsApiKey, ...ttsConfig } = openaiConfig?.tts ?? {};
+    return new OpenAITTS({
+        apiKey,
+        voice: "alloy",
+        model: DEFAULT_OPENAI_TTS_MODEL,
+        responseFormat: "pcm",
+        ...ttsConfig,
+    }, logger);
+}
+export function initializeOpenAiSpeechServices(params) {
+    const { providers, openaiConfig, existing, logger } = params;
+    const openAiCredentials = resolveOpenAiCredentials(openaiConfig);
+    let sttService = existing.sttService;
+    let ttsService = existing.ttsService;
+    let dictationSttService = existing.dictationSttService;
+    const turnDetectionService = existing.turnDetectionService;
+    const needsOpenAiStt = !sttService && providers.voiceStt.enabled !== false && providers.voiceStt.provider === "openai";
+    const needsOpenAiTts = !ttsService && providers.voiceTts.enabled !== false && providers.voiceTts.provider === "openai";
+    const needsOpenAiDictation = !dictationSttService &&
+        providers.dictationStt.enabled !== false &&
+        providers.dictationStt.provider === "openai";
+    const needsAnyOpenAi = needsOpenAiStt || needsOpenAiTts || needsOpenAiDictation;
+    const hasAnyOpenAiCredential = Boolean(openAiCredentials.openaiSttApiKey) ||
+        Boolean(openAiCredentials.openaiTtsApiKey) ||
+        Boolean(openAiCredentials.openaiDictationApiKey);
+    if (needsAnyOpenAi && hasAnyOpenAiCredential) {
+        logger.info("OpenAI speech provider initialized");
+        if (needsOpenAiStt && openAiCredentials.openaiSttApiKey) {
+            sttService = createOpenAiStt(openAiCredentials.openaiSttApiKey, openaiConfig, logger);
+        }
+        if (needsOpenAiTts && openAiCredentials.openaiTtsApiKey) {
+            ttsService = createOpenAiTts(openAiCredentials.openaiTtsApiKey, openaiConfig, logger);
+        }
+        if (needsOpenAiDictation && openAiCredentials.openaiDictationApiKey) {
+            dictationSttService = createOpenAiStt(openAiCredentials.openaiDictationApiKey, openaiConfig, logger);
+        }
+    }
+    else if (needsAnyOpenAi) {
+        // validateOpenAiCredentialRequirements already warned about missing credentials
+    }
+    return {
+        turnDetectionService,
+        sttService,
+        ttsService,
+        dictationSttService,
+    };
+}
+//# sourceMappingURL=runtime.js.map