@drax/ai-back 3.41.0 → 3.43.0

package/dist/providers/tts/ElevenLabsTTSProvider.js

@@ -0,0 +1,108 @@
+class ElevenLabsTTSProvider {
+    constructor(apiKey, model, voiceId, baseUrl = "https://api.elevenlabs.io", outputFormat) {
+        if (!apiKey) {
+            throw new Error("ElevenLabs apiKey required");
+        }
+        if (!model) {
+            throw new Error("ElevenLabs model required");
+        }
+        if (!voiceId) {
+            throw new Error("ElevenLabs voiceId required");
+        }
+        this._apiKey = apiKey;
+        this._model = model;
+        this._voiceId = voiceId;
+        this._baseUrl = baseUrl.replace(/\/+$/, "");
+        this._outputFormat = outputFormat;
+    }
+    get model() {
+        if (!this._model) {
+            throw new Error("ElevenLabs model not found");
+        }
+        return this._model;
+    }
+    get voiceId() {
+        if (!this._voiceId) {
+            throw new Error("ElevenLabs voiceId not found");
+        }
+        return this._voiceId;
+    }
+    mapContentType(outputFormat) {
+        if (!outputFormat) {
+            return "audio/mpeg";
+        }
+        if (outputFormat.startsWith("mp3")) {
+            return "audio/mpeg";
+        }
+        if (outputFormat.startsWith("opus")) {
+            return "audio/ogg";
+        }
+        if (outputFormat.startsWith("pcm")) {
+            return "audio/wav";
+        }
+        if (outputFormat.startsWith("ulaw") || outputFormat.startsWith("alaw")) {
+            return "audio/basic";
+        }
+        return "application/octet-stream";
+    }
+    mapVoiceSettings(voiceSettings) {
+        if (!voiceSettings) {
+            return undefined;
+        }
+        return {
+            stability: voiceSettings.stability,
+            similarity_boost: voiceSettings.similarityBoost,
+            style: voiceSettings.style,
+            use_speaker_boost: voiceSettings.useSpeakerBoost,
+            speed: voiceSettings.speed,
+        };
+    }
+    buildBody(input, model) {
+        return {
+            text: input.text,
+            model_id: model,
+            ...(input.voiceSettings ? { voice_settings: this.mapVoiceSettings(input.voiceSettings) } : {}),
+            ...(input.previousText ? { previous_text: input.previousText } : {}),
+            ...(input.nextText ? { next_text: input.nextText } : {}),
+            ...(input.languageCode ? { language_code: input.languageCode } : {}),
+            ...(input.seed !== undefined ? { seed: input.seed } : {}),
+        };
+    }
+    async textToSpeech(input) {
+        const startedAt = Date.now();
+        const model = input.model ?? this.model;
+        const voiceId = input.voiceId ?? this.voiceId;
+        const outputFormat = input.outputFormat ?? this._outputFormat;
+        const url = new URL(`${this._baseUrl}/v1/text-to-speech/${encodeURIComponent(voiceId)}`);
+        if (outputFormat) {
+            url.searchParams.set("output_format", outputFormat);
+        }
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Accept": this.mapContentType(outputFormat),
+                "Content-Type": "application/json",
+                "xi-api-key": this._apiKey,
+            },
+            body: JSON.stringify(this.buildBody(input, model)),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`ElevenLabs TTS request failed (${response.status}): ${errorText}`);
+        }
+        const audio = Buffer.from(await response.arrayBuffer());
+        const contentType = response.headers.get("content-type") ?? this.mapContentType(outputFormat);
+        return {
+            audio,
+            contentType,
+            size: audio.byteLength,
+            time: Date.now() - startedAt,
+            provider: "elevenlabs",
+            model,
+            voiceId,
+            outputFormat,
+        };
+    }
+}
+export default ElevenLabsTTSProvider;
+export { ElevenLabsTTSProvider };

package/dist/routes/TTSRoutes.js

@@ -0,0 +1,8 @@
+import TTSGenericController from "../controllers/TTSGenericController.js";
+async function TTSFastifyRoutes(fastify, options) {
+    const genericController = new TTSGenericController();
+    fastify.get('/api/tts/providers', (req, rep) => genericController.availableProviders(req, rep));
+    fastify.post('/api/tts', (req, rep) => genericController.textToSpeech(req, rep));
+}
+export default TTSFastifyRoutes;
+export { TTSFastifyRoutes };

package/dist/schemas/TTSRequestSchema.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+const TTSVoiceSettingsSchema = z.object({
+    stability: z.number().min(0).max(1).optional(),
+    similarityBoost: z.number().min(0).max(1).optional(),
+    style: z.number().min(0).max(1).optional(),
+    useSpeakerBoost: z.boolean().optional(),
+    speed: z.number().positive().optional(),
+});
+const TTSRequestSchema = z.object({
+    text: z.string().min(1),
+    provider: z.string().default("ElevenLabs"),
+    voiceId: z.string().optional(),
+    model: z.string().optional(),
+    outputFormat: z.string().optional(),
+    voiceSettings: TTSVoiceSettingsSchema.optional(),
+    previousText: z.string().optional(),
+    nextText: z.string().optional(),
+    languageCode: z.string().optional(),
+    seed: z.number().int().optional(),
+    responseFormat: z.enum(["audio", "base64"]).default("audio"),
+    operationTitle: z.string().optional(),
+    operationGroup: z.string().optional(),
+});
+export { TTSRequestSchema, TTSVoiceSettingsSchema, };

package/dist/services/PromptAudioService.js

@@ -0,0 +1,68 @@
+import TTSProviderFactory from "../factory/tts/TTSProviderFactory.js";
+class PromptAudioService {
+    static audioParams(input) {
+        if (!input.audioResponse) {
+            return null;
+        }
+        if (input.audioResponse === true) {
+            return {};
+        }
+        if (input.audioResponse.enabled === false) {
+            return null;
+        }
+        return input.audioResponse;
+    }
+    static outputToText(output) {
+        if (typeof output === "string") {
+            return output;
+        }
+        if (output === null || output === undefined) {
+            return "";
+        }
+        return JSON.stringify(output);
+    }
+    static async build(input, output) {
+        const audioParams = PromptAudioService.audioParams(input);
+        if (!audioParams) {
+            return undefined;
+        }
+        const text = PromptAudioService.outputToText(output).trim();
+        if (!text) {
+            return undefined;
+        }
+        const providerName = audioParams.provider ?? "ElevenLabs";
+        const ttsProvider = TTSProviderFactory.instance(providerName);
+        const response = await ttsProvider.textToSpeech({
+            text,
+            voiceId: audioParams.voiceId,
+            model: audioParams.model,
+            outputFormat: audioParams.outputFormat,
+            voiceSettings: audioParams.voiceSettings,
+            previousText: audioParams.previousText,
+            nextText: audioParams.nextText,
+            languageCode: audioParams.languageCode,
+            seed: audioParams.seed,
+            operationTitle: audioParams.operationTitle ?? input.operationTitle,
+            operationGroup: audioParams.operationGroup ?? input.operationGroup,
+            ip: input.ip,
+            userAgent: input.userAgent,
+            tenant: input.tenant,
+            user: input.user,
+        });
+        return {
+            audio: response.audio.toString("base64"),
+            contentType: response.contentType,
+            encoding: "base64",
+            meta: {
+                provider: response.provider,
+                model: response.model,
+                voiceId: response.voiceId,
+                outputFormat: response.outputFormat,
+                size: response.size,
+                time: response.time,
+            },
+        };
+    }
+}
+export default PromptAudioService;
+export { PromptAudioService, };

package/dist/services/TTSGenericService.js

@@ -0,0 +1,21 @@
+import TTSProviderFactory from "../factory/tts/TTSProviderFactory.js";
+class TTSGenericService {
+    availableProviders() {
+        return TTSProviderFactory.availableProviders();
+    }
+    async textToSpeech(input, context = {}) {
+        const ttsProvider = TTSProviderFactory.instance(input.provider);
+        const ttsInput = {
+            ...input,
+            operationTitle: input.operationTitle ?? "generic-tts",
+            operationGroup: input.operationGroup ?? "generic-tts",
+            ip: context.ip,
+            userAgent: context.userAgent,
+            tenant: context.tenant ?? null,
+            user: context.user ?? null,
+        };
+        return ttsProvider.textToSpeech(ttsInput);
+    }
+}
+export default TTSGenericService;
+export { TTSGenericService, };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.41.0",
+  "version": "3.43.0",
   "description": "Ai utils",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -18,7 +18,7 @@
   "author": "Cristian Incarnato & Drax Team",
   "license": "ISC",
   "dependencies": {
-    "@drax/ai-share": "^3.31.0",
+    "@drax/ai-share": "^3.43.0",
     "@drax/crud-back": "^3.39.0",
     "mongoose": "^8.23.0",
     "mongoose-paginate-v2": "^1.8.3"
@@ -46,5 +46,5 @@
     "typescript": "^5.9.3",
     "vitest": "^3.0.8"
   },
-  "gitHead": "21f6bdb9f6cc6da6c74dee8aef275d8f88755dd4"
+  "gitHead": "9cb1cab8a6fe2a6c574d08596bc6287f5a5311a6"
 }

package/src/agents/DraxAgent.ts

@@ -14,7 +14,7 @@ import type {
 } from "../interfaces/IDraxAgent.js";
 import type {IPromptMessage} from "../interfaces/IAIProvider.js";
 import type {IAgentSession, IAgentSessionBase} from "../interfaces/IAgentSession.js";
-import AiProviderFactory from "../factory/AiProviderFactory.js";
+import AiProviderFactory from "../factory/ai/AiProviderFactory.js";
 import AgentSessionServiceFactory from "../factory/services/AgentSessionServiceFactory.js";
 import type {AgentSessionService} from "../services/AgentSessionService.js";
 
@@ -110,6 +110,7 @@ class DraxAgent {
             userAgent: input.userAgent,
             tenant: input.tenantId ?? session.tenantId ?? null,
             user: input.userId ?? session.userId ?? null,
+            audioResponse: input.audioResponse,
         });
 
         const assistantMessage = this.normalizeOutput(response.output);
@@ -134,6 +135,7 @@ class DraxAgent {
             inputTokens: response.inputTokens,
             outputTokens: response.outputTokens,
             time: response.time,
+            ...(response.audio ? {audio: response.audio} : {}),
         };
     }
 

package/src/config/ElevenLabsTTSConfig.ts

@@ -0,0 +1,13 @@
+enum ElevenLabsTTSConfig {
+
+    ElevenLabsApiKey = "ELEVENLABS_API_KEY",
+    ElevenLabsBaseUrl = "ELEVENLABS_BASE_URL",
+    ElevenLabsModel = "ELEVENLABS_MODEL",
+    ElevenLabsVoiceId = "ELEVENLABS_VOICE_ID",
+    ElevenLabsOutputFormat = "ELEVENLABS_OUTPUT_FORMAT",
+
+}
+
+export default ElevenLabsTTSConfig;
+
+export {ElevenLabsTTSConfig}

package/src/controllers/AICrudController.ts

@@ -1,6 +1,6 @@
 import {z} from "zod";
 import {CommonController} from "@drax/common-back";
-import AiProviderFactory from "../factory/AiProviderFactory.js";
+import AiProviderFactory from "../factory/ai/AiProviderFactory.js";
 import AIPermissions from "../permissions/AIPermissions.js";
 
 const CrudAiFieldSchema: z.ZodType<any> = z.lazy(() => z.object({

package/src/controllers/AIGenericController.ts

@@ -1,6 +1,6 @@
 import {z} from "zod";
 import {CommonController} from "@drax/common-back";
-import AiProviderFactory from "../factory/AiProviderFactory.js";
+import AiProviderFactory from "../factory/ai/AiProviderFactory.js";
 import AIPermissions from "../permissions/AIPermissions.js";
 import type {IPromptParams} from "../interfaces/IAIProvider.js";
 
@@ -42,6 +42,29 @@ const PromptInputFileSchema = z.object({
     url: z.string().optional(),
 })
 
+const PromptAudioVoiceSettingsSchema = z.object({
+    stability: z.number().min(0).max(1).optional(),
+    similarityBoost: z.number().min(0).max(1).optional(),
+    style: z.number().min(0).max(1).optional(),
+    useSpeakerBoost: z.boolean().optional(),
+    speed: z.number().positive().optional(),
+})
+
+const PromptAudioParamsSchema = z.object({
+    enabled: z.boolean().optional(),
+    provider: z.string().optional(),
+    voiceId: z.string().optional(),
+    model: z.string().optional(),
+    outputFormat: z.string().optional(),
+    voiceSettings: PromptAudioVoiceSettingsSchema.optional(),
+    previousText: z.string().optional(),
+    nextText: z.string().optional(),
+    languageCode: z.string().optional(),
+    seed: z.number().int().optional(),
+    operationTitle: z.string().optional(),
+    operationGroup: z.string().optional(),
+})
+
 const GenericPromptRequestSchema = z.object({
     systemPrompt: z.string().min(1),
     userInput: z.string().optional(),
@@ -57,6 +80,7 @@ const GenericPromptRequestSchema = z.object({
     model: z.string().optional(),
     operationTitle: z.string().optional(),
     operationGroup: z.string().optional(),
+    audioResponse: z.union([z.boolean(), PromptAudioParamsSchema]).optional(),
 })
 
 class AIGenericController extends CommonController {

package/src/controllers/DraxAgentController.ts

@@ -35,6 +35,29 @@ const PromptInputFileSchema = z.object({
     url: z.string().optional(),
 });
 
+const PromptAudioVoiceSettingsSchema = z.object({
+    stability: z.number().min(0).max(1).optional(),
+    similarityBoost: z.number().min(0).max(1).optional(),
+    style: z.number().min(0).max(1).optional(),
+    useSpeakerBoost: z.boolean().optional(),
+    speed: z.number().positive().optional(),
+});
+
+const PromptAudioParamsSchema = z.object({
+    enabled: z.boolean().optional(),
+    provider: z.string().optional(),
+    voiceId: z.string().optional(),
+    model: z.string().optional(),
+    outputFormat: z.string().optional(),
+    voiceSettings: PromptAudioVoiceSettingsSchema.optional(),
+    previousText: z.string().optional(),
+    nextText: z.string().optional(),
+    languageCode: z.string().optional(),
+    seed: z.number().int().optional(),
+    operationTitle: z.string().optional(),
+    operationGroup: z.string().optional(),
+});
+
 const AgentSessionRequestSchema = z.object({
     identifier: z.string().min(1).optional(),
     sessionId: z.string().optional(),
@@ -55,6 +78,7 @@ const AgentMessageRequestSchema = AgentSessionRequestSchema.extend({
     toolMaxIterations: z.number().optional(),
     operationTitle: z.string().optional(),
     operationGroup: z.string().optional(),
+    audioResponse: z.union([z.boolean(), PromptAudioParamsSchema]).optional(),
 });
 
 class DraxAgentController extends CommonController {

package/src/controllers/TTSGenericController.ts

@@ -0,0 +1,70 @@
+import {CommonController} from "@drax/common-back";
+import TTSPermissions from "../permissions/TTSPermissions.js";
+import {TTSRequestSchema} from "../schemas/TTSRequestSchema.js";
+import TTSGenericService from "../services/TTSGenericService.js";
+
+class TTSGenericController extends CommonController {
+    protected service: TTSGenericService
+
+    constructor(service: TTSGenericService = new TTSGenericService()) {
+        super()
+        this.service = service
+    }
+
+    async availableProviders(request, reply) {
+        try {
+            request.rbac.assertPermission(TTSPermissions.TextToSpeech)
+
+            return reply.send({
+                providers: this.service.availableProviders(),
+            })
+        } catch (e: any) {
+            this.handleError(e, reply)
+        }
+    }
+
+    async textToSpeech(request, reply) {
+        try {
+            request.rbac.assertPermission(TTSPermissions.TextToSpeech)
+
+            const input = TTSRequestSchema.parse(request.body ?? {})
+            const response = await this.service.textToSpeech(input, {
+                ip: request.ip,
+                userAgent: request.headers["user-agent"],
+                tenant: request.rbac?.tenantId ?? null,
+                user: request.rbac?.userId ?? null,
+            })
+
+            if (input.responseFormat === "base64") {
+                return reply.send({
+                    audio: response.audio.toString("base64"),
+                    contentType: response.contentType,
+                    meta: {
+                        provider: response.provider,
+                        model: response.model,
+                        voiceId: response.voiceId,
+                        outputFormat: response.outputFormat,
+                        size: response.size,
+                        time: response.time,
+                    },
+                })
+            }
+
+            return reply
+                .header("Content-Type", response.contentType)
+                .header("Content-Length", response.size)
+                .send(response.audio)
+        } catch (e: any) {
+            if (e?.name === "ZodError") {
+                return reply.status(400).send({
+                    message: e?.message || "TTS validation error",
+                })
+            }
+
+            this.handleError(e, reply)
+        }
+    }
+}
+
+export default TTSGenericController;
+export {TTSGenericController};

package/src/factory/{AiProviderFactory.ts → ai/AiProviderFactory.ts}

@@ -1,8 +1,8 @@
-import type {IAIProvider} from "../interfaces/IAIProvider"
+import type {IAIProvider} from "../../interfaces/IAIProvider.js"
 import OpenAiProviderFactory from "./OpenAiProviderFactory.js";
 import GoogleAiProviderFactory from "./GoogleAiProviderFactory.js";
 import OllamaAiProviderFactory from "./OllamaAiProviderFactory.js";
-import DeepSeekProviderFactory from "./DeepSeekProviderFactory.js";
+import DeepSeekAiProviderFactory from "./DeepSeekAiProviderFactory.js";
 
 class AiProviderFactory {
     private static singletons: Record<string, IAIProvider> = {};
@@ -20,7 +20,7 @@ class AiProviderFactory {
                     AiProviderFactory.singletons[provider] =  OllamaAiProviderFactory.instance()
                     break;
                 case 'DeepSeek':
-                    AiProviderFactory.singletons[provider] =  DeepSeekProviderFactory.instance()
+                    AiProviderFactory.singletons[provider] =  DeepSeekAiProviderFactory.instance()
                     break;
                 default:
                     throw new Error(`Unsupported AI provider: ${provider}`);

package/src/factory/ai/DeepSeekAiProviderFactory.ts

@@ -0,0 +1,27 @@
+import {DraxConfig} from "@drax/common-back";
+import DeepSeekConfig from "../../config/DeepSeekConfig.js";
+import type {IAIProvider} from "../../interfaces/IAIProvider.js"
+import DeepSeekAiProvider from "../../providers/ai/DeepSeekAiProvider.js";
+import AILogServiceFactory from "../services/AILogServiceFactory.js";
+
+class DeepSeekAiProviderFactory {
+    private static singleton: IAIProvider;
+
+    public static instance(): IAIProvider {
+        if (!DeepSeekAiProviderFactory.singleton) {
+            DeepSeekAiProviderFactory.singleton = new DeepSeekAiProvider(
+                DraxConfig.getOrLoad(DeepSeekConfig.DeepSeekApiKey),
+                DraxConfig.getOrLoad(DeepSeekConfig.DeepSeekModel),
+                DraxConfig.getOrLoad(DeepSeekConfig.DeepSeekBaseUrl, "string", "https://api.deepseek.com"),
+                DraxConfig.getOrLoad(DeepSeekConfig.DeepSeekVisionModel),
+                AILogServiceFactory.instance
+            );
+        }
+        return DeepSeekAiProviderFactory.singleton;
+    }
+}
+
+export default DeepSeekAiProviderFactory
+export {
+    DeepSeekAiProviderFactory
+}

package/src/factory/{GoogleAiProviderFactory.ts → ai/GoogleAiProviderFactory.ts}

@@ -1,8 +1,8 @@
 import {DraxConfig} from "@drax/common-back";
-import GoogleAiConfig from "../config/GoogleAiConfig.js";
-import type {IAIProvider} from "../interfaces/IAIProvider"
-import GoogleAiProvider from "../providers/GoogleAiProvider.js";
-import AILogServiceFactory from "./services/AILogServiceFactory.js";
+import GoogleAiConfig from "../../config/GoogleAiConfig.js";
+import type {IAIProvider} from "../../interfaces/IAIProvider.js"
+import GoogleAiProvider from "../../providers/ai/GoogleAiProvider.js";
+import AILogServiceFactory from "../services/AILogServiceFactory.js";
 
 class GoogleAiProviderFactory {
     private static singleton: IAIProvider;

package/src/factory/{OllamaAiProviderFactory.ts → ai/OllamaAiProviderFactory.ts}

@@ -1,8 +1,8 @@
 import {DraxConfig} from "@drax/common-back";
-import OllamaAiConfig from "../config/OllamaAiConfig.js";
-import type {IAIProvider} from "../interfaces/IAIProvider"
-import OllamaAiProvider from "../providers/OllamaAiProvider.js";
-import AILogServiceFactory from "./services/AILogServiceFactory.js";
+import OllamaAiConfig from "../../config/OllamaAiConfig.js";
+import type {IAIProvider} from "../../interfaces/IAIProvider.js"
+import OllamaAiProvider from "../../providers/ai/OllamaAiProvider.js";
+import AILogServiceFactory from "../services/AILogServiceFactory.js";
 
 class OllamaAiProviderFactory {
     private static singleton: IAIProvider;

package/src/factory/{OpenAiProviderFactory.ts → ai/OpenAiProviderFactory.ts}

@@ -1,8 +1,8 @@
 import {DraxConfig} from "@drax/common-back";
-import OpenAiConfig from "../config/OpenAiConfig.js";
-import type {IAIProvider} from "../interfaces/IAIProvider"
-import OpenAiProvider from "../providers/OpenAiProvider.js";
-import AILogServiceFactory from "./services/AILogServiceFactory.js";
+import OpenAiConfig from "../../config/OpenAiConfig.js";
+import type {IAIProvider} from "../../interfaces/IAIProvider.js"
+import OpenAiProvider from "../../providers/ai/OpenAiProvider.js";
+import AILogServiceFactory from "../services/AILogServiceFactory.js";
 
 class OpenAiProviderFactory {
     private static singleton: IAIProvider;

package/src/factory/tts/ElevenLabsTTSProviderFactory.ts

@@ -0,0 +1,26 @@
+import {DraxConfig} from "@drax/common-back";
+import ElevenLabsTTSConfig from "../../config/ElevenLabsTTSConfig.js";
+import type {ITTSProvider} from "../../interfaces/ITTSProvider.js";
+import ElevenLabsTTSProvider from "../../providers/tts/ElevenLabsTTSProvider.js";
+
+class ElevenLabsTTSProviderFactory {
+    private static singleton: ITTSProvider;
+
+    public static instance(): ITTSProvider {
+        if (!ElevenLabsTTSProviderFactory.singleton) {
+            ElevenLabsTTSProviderFactory.singleton = new ElevenLabsTTSProvider(
+                DraxConfig.getOrLoad(ElevenLabsTTSConfig.ElevenLabsApiKey),
+                DraxConfig.getOrLoad(ElevenLabsTTSConfig.ElevenLabsModel, "string", "eleven_multilingual_v2"),
+                DraxConfig.getOrLoad(ElevenLabsTTSConfig.ElevenLabsVoiceId),
+                DraxConfig.getOrLoad(ElevenLabsTTSConfig.ElevenLabsBaseUrl, "string", "https://api.elevenlabs.io"),
+                DraxConfig.getOrLoad(ElevenLabsTTSConfig.ElevenLabsOutputFormat, "string", "mp3_44100_128"),
+            );
+        }
+        return ElevenLabsTTSProviderFactory.singleton;
+    }
+}
+
+export default ElevenLabsTTSProviderFactory
+export {
+    ElevenLabsTTSProviderFactory
+}

package/src/factory/tts/TTSProviderFactory.ts

@@ -0,0 +1,42 @@
+import type {ITTSProvider} from "../../interfaces/ITTSProvider.js";
+import ElevenLabsTTSProviderFactory from "./ElevenLabsTTSProviderFactory.js";
+
+type TTSProviderInfo = {
+    name: string;
+    label: string;
+}
+
+class TTSProviderFactory {
+    private static singletons: Record<string, ITTSProvider> = {};
+    private static providers: TTSProviderInfo[] = [
+        {
+            name: "ElevenLabs",
+            label: "ElevenLabs",
+        },
+    ];
+
+    public static availableProviders(): TTSProviderInfo[] {
+        return TTSProviderFactory.providers
+    }
+
+    public static instance(provider: string = "ElevenLabs"): ITTSProvider {
+        if (!TTSProviderFactory.singletons[provider]) {
+            switch (provider) {
+                case "ElevenLabs":
+                    TTSProviderFactory.singletons[provider] = ElevenLabsTTSProviderFactory.instance()
+                    break;
+                default:
+                    throw new Error(`Unsupported TTS provider: ${provider}`);
+            }
+        }
+        return TTSProviderFactory.singletons[provider];
+    }
+}
+
+export default TTSProviderFactory
+export {
+    TTSProviderFactory
+}
+export type {
+    TTSProviderInfo,
+}