@drax/ai-back 3.41.0 → 3.43.0

package/dist/agents/DraxAgent.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import AiProviderFactory from "../factory/AiProviderFactory.js";
+import AiProviderFactory from "../factory/ai/AiProviderFactory.js";
 import AgentSessionServiceFactory from "../factory/services/AgentSessionServiceFactory.js";
 class DraxAgent {
     constructor(identifier = "default", description = "") {
@@ -78,6 +78,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);
         const now = new Date();
@@ -100,6 +101,7 @@ class DraxAgent {
             inputTokens: response.inputTokens,
             outputTokens: response.outputTokens,
             time: response.time,
+            ...(response.audio ? { audio: response.audio } : {}),
         };
     }
     async createSession(input = {}) {

package/dist/config/ElevenLabsTTSConfig.js

@@ -0,0 +1,10 @@
+var ElevenLabsTTSConfig;
+(function (ElevenLabsTTSConfig) {
+    ElevenLabsTTSConfig["ElevenLabsApiKey"] = "ELEVENLABS_API_KEY";
+    ElevenLabsTTSConfig["ElevenLabsBaseUrl"] = "ELEVENLABS_BASE_URL";
+    ElevenLabsTTSConfig["ElevenLabsModel"] = "ELEVENLABS_MODEL";
+    ElevenLabsTTSConfig["ElevenLabsVoiceId"] = "ELEVENLABS_VOICE_ID";
+    ElevenLabsTTSConfig["ElevenLabsOutputFormat"] = "ELEVENLABS_OUTPUT_FORMAT";
+})(ElevenLabsTTSConfig || (ElevenLabsTTSConfig = {}));
+export default ElevenLabsTTSConfig;
+export { ElevenLabsTTSConfig };

package/dist/controllers/AICrudController.js

@@ -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.lazy(() => z.object({
     name: z.string(),

package/dist/controllers/AIGenericController.js

@@ -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 PromptImageSchema = z.object({
     url: z.string().min(1),
@@ -35,6 +35,27 @@ const PromptInputFileSchema = z.object({
     mimetype: z.string().optional(),
     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(),
@@ -50,6 +71,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 {
     async prompt(request, reply) {

package/dist/controllers/DraxAgentController.js

@@ -28,6 +28,27 @@ const PromptInputFileSchema = z.object({
     mimetype: z.string().optional(),
     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(),
@@ -47,6 +68,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 {
     constructor(options = {}) {

package/dist/controllers/TTSGenericController.js

@@ -0,0 +1,61 @@
+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 {
+    constructor(service = 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) {
+            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) {
+            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/dist/factory/ElevenLabsTTSProviderFactory.js

@@ -0,0 +1,13 @@
+import { DraxConfig } from "@drax/common-back";
+import ElevenLabsTTSConfig from "../config/ElevenLabsTTSConfig.js";
+import ElevenLabsTTSProvider from "../providers/ElevenLabsTTSProvider.js";
+class ElevenLabsTTSProviderFactory {
+    static instance() {
+        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/dist/factory/TTSProviderFactory.js

@@ -0,0 +1,27 @@
+import ElevenLabsTTSProviderFactory from "./ElevenLabsTTSProviderFactory.js";
+class TTSProviderFactory {
+    static availableProviders() {
+        return TTSProviderFactory.providers;
+    }
+    static instance(provider = "ElevenLabs") {
+        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];
+    }
+}
+TTSProviderFactory.singletons = {};
+TTSProviderFactory.providers = [
+    {
+        name: "ElevenLabs",
+        label: "ElevenLabs",
+    },
+];
+export default TTSProviderFactory;
+export { TTSProviderFactory };

package/dist/factory/ai/AiProviderFactory.js

@@ -0,0 +1,30 @@
+import OpenAiProviderFactory from "./OpenAiProviderFactory.js";
+import GoogleAiProviderFactory from "./GoogleAiProviderFactory.js";
+import OllamaAiProviderFactory from "./OllamaAiProviderFactory.js";
+import DeepSeekAiProviderFactory from "./DeepSeekAiProviderFactory.js";
+class AiProviderFactory {
+    static instance(provider = 'OpenAi') {
+        if (!AiProviderFactory.singletons[provider]) {
+            switch (provider) {
+                case 'OpenAi':
+                    AiProviderFactory.singletons[provider] = OpenAiProviderFactory.instance();
+                    break;
+                case 'GoogleAi':
+                    AiProviderFactory.singletons[provider] = GoogleAiProviderFactory.instance();
+                    break;
+                case 'OllamaAi':
+                    AiProviderFactory.singletons[provider] = OllamaAiProviderFactory.instance();
+                    break;
+                case 'DeepSeek':
+                    AiProviderFactory.singletons[provider] = DeepSeekAiProviderFactory.instance();
+                    break;
+                default:
+                    throw new Error(`Unsupported AI provider: ${provider}`);
+            }
+        }
+        return AiProviderFactory.singletons[provider];
+    }
+}
+AiProviderFactory.singletons = {};
+export default AiProviderFactory;
+export { AiProviderFactory };

package/dist/factory/ai/DeepSeekAiProviderFactory.js

@@ -0,0 +1,14 @@
+import { DraxConfig } from "@drax/common-back";
+import DeepSeekConfig from "../../config/DeepSeekConfig.js";
+import DeepSeekAiProvider from "../../providers/ai/DeepSeekAiProvider.js";
+import AILogServiceFactory from "../services/AILogServiceFactory.js";
+class DeepSeekAiProviderFactory {
+    static instance() {
+        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/dist/factory/ai/GoogleAiProviderFactory.js

@@ -0,0 +1,14 @@
+import { DraxConfig } from "@drax/common-back";
+import GoogleAiConfig from "../../config/GoogleAiConfig.js";
+import GoogleAiProvider from "../../providers/ai/GoogleAiProvider.js";
+import AILogServiceFactory from "../services/AILogServiceFactory.js";
+class GoogleAiProviderFactory {
+    static instance() {
+        if (!GoogleAiProviderFactory.singleton) {
+            GoogleAiProviderFactory.singleton = new GoogleAiProvider(DraxConfig.getOrLoad(GoogleAiConfig.GoogleAiApiKey), DraxConfig.getOrLoad(GoogleAiConfig.GoogleAiModel), DraxConfig.getOrLoad(GoogleAiConfig.GoogleAiVisionModel), AILogServiceFactory.instance);
+        }
+        return GoogleAiProviderFactory.singleton;
+    }
+}
+export default GoogleAiProviderFactory;
+export { GoogleAiProviderFactory };

package/dist/factory/ai/OllamaAiProviderFactory.js

@@ -0,0 +1,14 @@
+import { DraxConfig } from "@drax/common-back";
+import OllamaAiConfig from "../../config/OllamaAiConfig.js";
+import OllamaAiProvider from "../../providers/ai/OllamaAiProvider.js";
+import AILogServiceFactory from "../services/AILogServiceFactory.js";
+class OllamaAiProviderFactory {
+    static instance() {
+        if (!OllamaAiProviderFactory.singleton) {
+            OllamaAiProviderFactory.singleton = new OllamaAiProvider(DraxConfig.getOrLoad(OllamaAiConfig.OllamaAiBaseUrl, "string", "http://localhost:11434"), DraxConfig.getOrLoad(OllamaAiConfig.OllamaAiModel), DraxConfig.getOrLoad(OllamaAiConfig.OllamaAiVisionModel), DraxConfig.getOrLoad(OllamaAiConfig.OllamaAiEmbeddingModel), AILogServiceFactory.instance);
+        }
+        return OllamaAiProviderFactory.singleton;
+    }
+}
+export default OllamaAiProviderFactory;
+export { OllamaAiProviderFactory };

package/dist/factory/ai/OpenAiProviderFactory.js

@@ -0,0 +1,14 @@
+import { DraxConfig } from "@drax/common-back";
+import OpenAiConfig from "../../config/OpenAiConfig.js";
+import OpenAiProvider from "../../providers/ai/OpenAiProvider.js";
+import AILogServiceFactory from "../services/AILogServiceFactory.js";
+class OpenAiProviderFactory {
+    static instance() {
+        if (!OpenAiProviderFactory.singleton) {
+            OpenAiProviderFactory.singleton = new OpenAiProvider(DraxConfig.getOrLoad(OpenAiConfig.OpenAiApiKey), DraxConfig.getOrLoad(OpenAiConfig.OpenAiModel), DraxConfig.getOrLoad(OpenAiConfig.OpenAiVisionModel), AILogServiceFactory.instance);
+        }
+        return OpenAiProviderFactory.singleton;
+    }
+}
+export default OpenAiProviderFactory;
+export { OpenAiProviderFactory };

package/dist/factory/tts/ElevenLabsTTSProviderFactory.js

@@ -0,0 +1,13 @@
+import { DraxConfig } from "@drax/common-back";
+import ElevenLabsTTSConfig from "../../config/ElevenLabsTTSConfig.js";
+import ElevenLabsTTSProvider from "../../providers/tts/ElevenLabsTTSProvider.js";
+class ElevenLabsTTSProviderFactory {
+    static instance() {
+        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/dist/factory/tts/TTSProviderFactory.js

@@ -0,0 +1,27 @@
+import ElevenLabsTTSProviderFactory from "./ElevenLabsTTSProviderFactory.js";
+class TTSProviderFactory {
+    static availableProviders() {
+        return TTSProviderFactory.providers;
+    }
+    static instance(provider = "ElevenLabs") {
+        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];
+    }
+}
+TTSProviderFactory.singletons = {};
+TTSProviderFactory.providers = [
+    {
+        name: "ElevenLabs",
+        label: "ElevenLabs",
+    },
+];
+export default TTSProviderFactory;
+export { TTSProviderFactory };

package/dist/index.js

@@ -2,42 +2,52 @@ import { OpenAiConfig } from "./config/OpenAiConfig.js";
 import { GoogleAiConfig } from "./config/GoogleAiConfig.js";
 import { OllamaAiConfig } from "./config/OllamaAiConfig.js";
 import { DeepSeekConfig } from "./config/DeepSeekConfig.js";
+import { ElevenLabsTTSConfig } from "./config/ElevenLabsTTSConfig.js";
 import { AILogSchema, AILogBaseSchema } from "./schemas/AILogSchema.js";
+import { TTSRequestSchema, TTSVoiceSettingsSchema } from "./schemas/TTSRequestSchema.js";
 import AILogModel from "./models/AILogModel.js";
 import AILogMongoRepository from "./repository/mongo/AILogMongoRepository.js";
 import AILogSqliteRepository from "./repository/sqlite/AILogSqliteRepository.js";
-import { OpenAiProviderFactory } from "./factory/OpenAiProviderFactory.js";
-import { GoogleAiProviderFactory } from "./factory/GoogleAiProviderFactory.js";
-import { OllamaAiProviderFactory } from "./factory/OllamaAiProviderFactory.js";
-import { DeepSeekProviderFactory } from "./factory/DeepSeekProviderFactory.js";
-import { AiProviderFactory } from "./factory/AiProviderFactory.js";
+import { OpenAiProviderFactory } from "./factory/ai/OpenAiProviderFactory.js";
+import { GoogleAiProviderFactory } from "./factory/ai/GoogleAiProviderFactory.js";
+import { OllamaAiProviderFactory } from "./factory/ai/OllamaAiProviderFactory.js";
+import { DeepSeekAiProviderFactory } from "./factory/ai/DeepSeekAiProviderFactory.js";
+import { AiProviderFactory } from "./factory/ai/AiProviderFactory.js";
+import { ElevenLabsTTSProviderFactory } from "./factory/tts/ElevenLabsTTSProviderFactory.js";
+import { TTSProviderFactory } from "./factory/tts/TTSProviderFactory.js";
 import { DraxAgentFactory } from "./factory/DraxAgentFactory.js";
 import AILogServiceFactory from "./factory/services/AILogServiceFactory.js";
-import { OpenAiProvider } from "./providers/OpenAiProvider.js";
-import { GoogleAiProvider } from "./providers/GoogleAiProvider.js";
-import { OllamaAiProvider } from "./providers/OllamaAiProvider.js";
-import { DeepSeekProvider } from "./providers/DeepSeekProvider.js";
+import { OpenAiProvider } from "./providers/ai/OpenAiProvider.js";
+import { GoogleAiProvider } from "./providers/ai/GoogleAiProvider.js";
+import { OllamaAiProvider } from "./providers/ai/OllamaAiProvider.js";
+import { DeepSeekAiProvider } from "./providers/ai/DeepSeekAiProvider.js";
+import { ElevenLabsTTSProvider } from "./providers/tts/ElevenLabsTTSProvider.js";
 import { BuilderTool } from "./tools/BuilderTool.js";
 import { KnowledgeService } from "./services/KnowledgeService.js";
 import { AILogService } from "./services/AILogService.js";
+import { TTSGenericService } from "./services/TTSGenericService.js";
+import { PromptAudioService } from "./services/PromptAudioService.js";
 import AILogPermissions from "./permissions/AILogPermissions.js";
 import AgentPermissions from "./permissions/AgentPermissions.js";
 import AgentSessionPermissions from "./permissions/AgentSessionPermissions.js";
 import AIPermissions from "./permissions/AIPermissions.js";
+import TTSPermissions from "./permissions/TTSPermissions.js";
 import AILogController from "./controllers/AILogController.js";
 import AICrudController from "./controllers/AICrudController.js";
 import AIGenericController from "./controllers/AIGenericController.js";
+import TTSGenericController from "./controllers/TTSGenericController.js";
 import DraxAgentController from "./controllers/DraxAgentController.js";
 import AgentSessionController from "./controllers/AgentSessionController.js";
 import AILogRoutes from "./routes/AILogRoutes.js";
 import AIRoutes from "./routes/AIRoutes.js";
+import TTSRoutes from "./routes/TTSRoutes.js";
 import DraxAgentRoutes from "./routes/DraxAgentRoutes.js";
 import AgentSessionRoutes from "./routes/AgentSessionRoutes.js";
 import { DraxAgent } from "./agents/DraxAgent.js";
-export { OpenAiConfig, GoogleAiConfig, OllamaAiConfig, DeepSeekConfig, AILogSchema, AILogBaseSchema, AILogModel, AILogMongoRepository, AILogSqliteRepository, OpenAiProviderFactory, GoogleAiProviderFactory, OllamaAiProviderFactory, DeepSeekProviderFactory, AiProviderFactory, DraxAgentFactory, AILogServiceFactory, OpenAiProvider, GoogleAiProvider, OllamaAiProvider, DeepSeekProvider, BuilderTool, 
+export { OpenAiConfig, GoogleAiConfig, OllamaAiConfig, DeepSeekConfig, ElevenLabsTTSConfig, AILogSchema, AILogBaseSchema, TTSRequestSchema, TTSVoiceSettingsSchema, AILogModel, AILogMongoRepository, AILogSqliteRepository, OpenAiProviderFactory, GoogleAiProviderFactory, OllamaAiProviderFactory, DeepSeekAiProviderFactory, AiProviderFactory, ElevenLabsTTSProviderFactory, TTSProviderFactory, DraxAgentFactory, AILogServiceFactory, OpenAiProvider, GoogleAiProvider, OllamaAiProvider, DeepSeekAiProvider, ElevenLabsTTSProvider, BuilderTool, 
 //Service
-KnowledgeService, AILogService, 
+KnowledgeService, AILogService, TTSGenericService, PromptAudioService, 
 //Permissions
-AILogPermissions, AgentPermissions, AIPermissions, AgentSessionPermissions, 
+AILogPermissions, AgentPermissions, AIPermissions, TTSPermissions, AgentSessionPermissions, 
 //Controllers
-AILogController, AICrudController, AIGenericController, DraxAgentController, AgentSessionController, DraxAgent, AILogRoutes, AIRoutes, DraxAgentRoutes, AgentSessionRoutes };
+AILogController, AICrudController, AIGenericController, TTSGenericController, DraxAgentController, AgentSessionController, DraxAgent, AILogRoutes, AIRoutes, TTSRoutes, DraxAgentRoutes, AgentSessionRoutes };

package/dist/interfaces/ITTSProvider.js

@@ -0,0 +1 @@
+export {};

package/dist/permissions/TTSPermissions.js

@@ -0,0 +1,6 @@
+var TTSPermissions;
+(function (TTSPermissions) {
+    TTSPermissions["TextToSpeech"] = "tts:textToSpeech";
+})(TTSPermissions || (TTSPermissions = {}));
+export { TTSPermissions };
+export default TTSPermissions;

package/dist/providers/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/providers/ai/DeepSeekAiProvider.js

@@ -0,0 +1,34 @@
+import OpenAI from "openai";
+import OpenAiProvider from "./OpenAiProvider.js";
+class DeepSeekAiProvider extends OpenAiProvider {
+    constructor(apiKey, model, baseUrl = "https://api.deepseek.com", visionModel, aiLogService) {
+        if (!apiKey) {
+            throw new Error("DeepSeek apiKey required");
+        }
+        if (!model) {
+            throw new Error("DeepSeek model required");
+        }
+        super(apiKey, model, visionModel, aiLogService);
+        if (!baseUrl) {
+            throw new Error("DeepSeek baseUrl required");
+        }
+        this._baseUrl = baseUrl;
+    }
+    get client() {
+        if (!this._client) {
+            this._client = new OpenAI({
+                apiKey: this._apiKey,
+                baseURL: this._baseUrl,
+            });
+        }
+        return this._client;
+    }
+    buildLogPayload(input, params) {
+        return {
+            ...super.buildLogPayload(input, params),
+            provider: "deepseek",
+        };
+    }
+}
+export default DeepSeekAiProvider;
+export { DeepSeekAiProvider };