@drax/ai-back 3.41.0 → 3.42.0

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,
+}

package/src/index.ts

@@ -2,35 +2,45 @@ 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 type {TTSProviderInfo} 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 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";
@@ -48,6 +58,19 @@ import type {
     IPromptResponse,
     IPromptTool
 } from "./interfaces/IAIProvider.js";
+import type {
+    ITTSParams,
+    ITTSProvider,
+    ITTSResponse,
+    ITTSVoiceSettings,
+} from "./interfaces/ITTSProvider.js";
+import type {
+    TTSRequest,
+    TTSVoiceSettings,
+} from "./schemas/TTSRequestSchema.js";
+import type {
+    TTSRequestContext,
+} from "./services/TTSGenericService.js";
 import type {
     ToolBuilderMethod,
     ToolBuilderOptions,
@@ -86,6 +109,14 @@ export type {
     IPromptContentPartImage,
     IPromptContentPartText,
     IPromptResponse,
+    ITTSProvider,
+    ITTSParams,
+    ITTSResponse,
+    ITTSVoiceSettings,
+    TTSRequest,
+    TTSVoiceSettings,
+    TTSRequestContext,
+    TTSProviderInfo,
     ToolBuilderMethod,
     ToolBuilderOptions,
     ToolBuilderService,
@@ -108,40 +139,50 @@ export {
     GoogleAiConfig,
     OllamaAiConfig,
     DeepSeekConfig,
+    ElevenLabsTTSConfig,
     AILogSchema,
     AILogBaseSchema,
+    TTSRequestSchema,
+    TTSVoiceSettingsSchema,
     AILogModel,
     AILogMongoRepository,
     AILogSqliteRepository,
     OpenAiProviderFactory,
     GoogleAiProviderFactory,
     OllamaAiProviderFactory,
-    DeepSeekProviderFactory,
+    DeepSeekAiProviderFactory,
     AiProviderFactory,
+    ElevenLabsTTSProviderFactory,
+    TTSProviderFactory,
     DraxAgentFactory,
     AILogServiceFactory,
     OpenAiProvider,
     GoogleAiProvider,
     OllamaAiProvider,
-    DeepSeekProvider,
+    DeepSeekAiProvider,
+    ElevenLabsTTSProvider,
     BuilderTool,
     //Service
     KnowledgeService,
     AILogService,
+    TTSGenericService,
     //Permissions
     AILogPermissions,
     AgentPermissions,
     AIPermissions,
+    TTSPermissions,
     AgentSessionPermissions,
     //Controllers
     AILogController,
     AICrudController,
     AIGenericController,
+    TTSGenericController,
     DraxAgentController,
     AgentSessionController,
     DraxAgent,
     AILogRoutes,
     AIRoutes,
+    TTSRoutes,
     DraxAgentRoutes,
     AgentSessionRoutes
 }

package/src/interfaces/ITTSProvider.ts

@@ -0,0 +1,47 @@
+interface ITTSVoiceSettings {
+    stability?: number;
+    similarityBoost?: number;
+    style?: number;
+    useSpeakerBoost?: boolean;
+    speed?: number;
+}
+
+interface ITTSParams {
+    text: string;
+    voiceId?: string;
+    model?: string;
+    outputFormat?: string;
+    voiceSettings?: ITTSVoiceSettings;
+    previousText?: string;
+    nextText?: string;
+    languageCode?: string;
+    seed?: number;
+    operationTitle?: string;
+    operationGroup?: string;
+    ip?: string;
+    userAgent?: string;
+    tenant?: string | null;
+    user?: string | null;
+}
+
+interface ITTSResponse {
+    audio: Buffer;
+    contentType: string;
+    size: number;
+    time: number;
+    provider: string;
+    model: string;
+    voiceId: string;
+    outputFormat?: string;
+}
+
+interface ITTSProvider {
+    textToSpeech(input: ITTSParams): Promise<ITTSResponse>
+}
+
+export type {
+    ITTSProvider,
+    ITTSParams,
+    ITTSResponse,
+    ITTSVoiceSettings,
+}

package/src/permissions/AIPermissions.ts

@@ -8,4 +8,3 @@ enum AIPermissions {
 
 export { AIPermissions };
 export default AIPermissions;
-

package/src/permissions/TTSPermissions.ts

@@ -0,0 +1,8 @@
+enum TTSPermissions {
+
+    TextToSpeech = "tts:textToSpeech",
+
+}
+
+export { TTSPermissions };
+export default TTSPermissions;

package/src/providers/{DeepSeekProvider.ts → ai/DeepSeekAiProvider.ts}

@@ -1,10 +1,10 @@
 import OpenAI from "openai";
 import type {IAILogBase} from "@drax/ai-share";
-import type {IPromptParams} from "../interfaces/IAIProvider.js";
-import type {AILogService} from "../services/AILogService.js";
+import type {IPromptParams} from "../../interfaces/IAIProvider.js";
+import type {AILogService} from "../../services/AILogService.js";
 import OpenAiProvider from "./OpenAiProvider.js";
 
-class DeepSeekProvider extends OpenAiProvider{
+class DeepSeekAiProvider extends OpenAiProvider{
     protected _baseUrl: string
 
     constructor(apiKey: string, model: string, baseUrl: string = "https://api.deepseek.com", visionModel?: string, aiLogService?: AILogService) {
@@ -54,5 +54,5 @@ class DeepSeekProvider extends OpenAiProvider{
     }
 }
 
-export default DeepSeekProvider
-export {DeepSeekProvider}
+export default DeepSeekAiProvider
+export {DeepSeekAiProvider}

package/src/providers/{GoogleAiProvider.ts → ai/GoogleAiProvider.ts}

@@ -14,8 +14,8 @@ import type {
     IPromptParams,
     IPromptResponse,
     IPromptTool
-} from "../interfaces/IAIProvider";
-import type {AILogService} from "../services/AILogService";
+} from "../../interfaces/IAIProvider.js";
+import type {AILogService} from "../../services/AILogService.js";
 import type {IAILogBase} from "@drax/ai-share";
 
 class GoogleAiProvider implements IAIProvider{

package/src/providers/{OllamaAiProvider.ts → ai/OllamaAiProvider.ts}

@@ -6,8 +6,8 @@ import type {
     IPromptParams,
     IPromptResponse,
     IPromptTool
-} from "../interfaces/IAIProvider";
-import type {AILogService} from "../services/AILogService";
+} from "../../interfaces/IAIProvider.js";
+import type {AILogService} from "../../services/AILogService.js";
 import type {IAILogBase} from "@drax/ai-share";
 
 type OllamaMessage = {

package/src/providers/{OpenAiProvider.ts → ai/OpenAiProvider.ts}

@@ -7,8 +7,8 @@ import type {
     IPromptParams,
     IPromptResponse,
     IPromptTool
-} from "../interfaces/IAIProvider";
-import type {AILogService} from "../services/AILogService";
+} from "../../interfaces/IAIProvider.js";
+import type {AILogService} from "../../services/AILogService.js";
 import type {IAILogBase} from "@drax/ai-share";
 
 class OpenAiProvider implements IAIProvider{

package/src/providers/tts/ElevenLabsTTSProvider.ts

@@ -0,0 +1,132 @@
+import type {ITTSParams, ITTSProvider, ITTSResponse} from "../../interfaces/ITTSProvider.js";
+
+class ElevenLabsTTSProvider implements ITTSProvider {
+    protected _apiKey: string
+    protected _baseUrl: string
+    protected _model: string
+    protected _voiceId: string
+    protected _outputFormat?: string
+
+    constructor(apiKey: string, model: string, voiceId: string, baseUrl: string = "https://api.elevenlabs.io", outputFormat?: string) {
+        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
+    }
+
+    protected mapContentType(outputFormat?: string) {
+        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"
+    }
+
+    protected mapVoiceSettings(voiceSettings: ITTSParams["voiceSettings"]) {
+        if (!voiceSettings) {
+            return undefined
+        }
+
+        return {
+            stability: voiceSettings.stability,
+            similarity_boost: voiceSettings.similarityBoost,
+            style: voiceSettings.style,
+            use_speaker_boost: voiceSettings.useSpeakerBoost,
+            speed: voiceSettings.speed,
+        }
+    }
+
+    protected buildBody(input: ITTSParams, model: string) {
+        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: ITTSParams): Promise<ITTSResponse> {
+        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/src/routes/TTSRoutes.ts

@@ -0,0 +1,13 @@
+import TTSGenericController from "../controllers/TTSGenericController.js";
+
+async function TTSFastifyRoutes(fastify, options) {
+
+    const genericController: TTSGenericController = 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/src/schemas/TTSRequestSchema.ts

@@ -0,0 +1,38 @@
+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(),
+})
+
+type TTSRequest = z.infer<typeof TTSRequestSchema>
+type TTSVoiceSettings = z.infer<typeof TTSVoiceSettingsSchema>
+
+export {
+    TTSRequestSchema,
+    TTSVoiceSettingsSchema,
+}
+
+export type {
+    TTSRequest,
+    TTSVoiceSettings,
+}

package/src/services/TTSGenericService.ts

@@ -0,0 +1,41 @@
+import TTSProviderFactory from "../factory/tts/TTSProviderFactory.js";
+import type {TTSProviderInfo} from "../factory/tts/TTSProviderFactory.js";
+import type {ITTSParams, ITTSResponse} from "../interfaces/ITTSProvider.js";
+import type {TTSRequest} from "../schemas/TTSRequestSchema.js";
+
+type TTSRequestContext = {
+    ip?: string;
+    userAgent?: string;
+    tenant?: string | null;
+    user?: string | null;
+}
+
+class TTSGenericService {
+
+    availableProviders(): TTSProviderInfo[] {
+        return TTSProviderFactory.availableProviders()
+    }
+
+    async textToSpeech(input: TTSRequest, context: TTSRequestContext = {}): Promise<ITTSResponse> {
+        const ttsProvider = TTSProviderFactory.instance(input.provider)
+        const ttsInput: ITTSParams = {
+            ...(input as ITTSParams),
+            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,
+}
+export type {
+    TTSRequestContext,
+}

package/test/DeepSeekProvider.test.ts

@@ -1,5 +1,5 @@
 import {describe, expect, test} from "vitest";
-import {AiProviderFactory, DeepSeekProvider} from "../src";
+import {AiProviderFactory, DeepSeekAiProvider} from "../src";
 import {IPromptTool} from "../src/interfaces/IAIProvider";
 
 describe("DeepSeekProvider Test", () => {
@@ -7,7 +7,7 @@ describe("DeepSeekProvider Test", () => {
     test("DeepSeek prompt uses OpenAI-compatible chat completions", async () => {
         let request: any
 
-        class MockedDeepSeekProvider extends DeepSeekProvider {
+        class MockedDeepSeekProvider extends DeepSeekAiProvider {
             constructor() {
                 super("test-key", "deepseek-chat")
                 this._client = {
@@ -61,7 +61,7 @@ describe("DeepSeekProvider Test", () => {
             execute: async ({city}) => ({city, temperature: 21})
         }
 
-        class MockedDeepSeekProvider extends DeepSeekProvider {
+        class MockedDeepSeekProvider extends DeepSeekAiProvider {
             constructor() {
                 super("test-key", "deepseek-chat")
                 this._client = {
@@ -141,6 +141,6 @@ describe("DeepSeekProvider Test", () => {
         process.env.DRAX_DB_ENGINE = "mongo"
 
         const deepSeek = AiProviderFactory.instance("DeepSeek")
-        expect(deepSeek).toBeInstanceOf(DeepSeekProvider)
+        expect(deepSeek).toBeInstanceOf(DeepSeekAiProvider)
     })
 })