@drax/ai-back 3.41.0 → 3.43.0

package/src/services/PromptAudioService.ts

@@ -0,0 +1,87 @@
+import TTSProviderFactory from "../factory/tts/TTSProviderFactory.js";
+import type {IPromptAudioParams, IPromptAudioResponse, IPromptParams} from "../interfaces/IAIProvider.js";
+
+class PromptAudioService {
+
+    static audioParams(input: IPromptParams): IPromptAudioParams | null {
+        if(!input.audioResponse){
+            return null
+        }
+
+        if(input.audioResponse === true){
+            return {}
+        }
+
+        if(input.audioResponse.enabled === false){
+            return null
+        }
+
+        return input.audioResponse
+    }
+
+    static outputToText(output: unknown): string {
+        if(typeof output === "string"){
+            return output
+        }
+
+        if(output === null || output === undefined){
+            return ""
+        }
+
+        return JSON.stringify(output)
+    }
+
+    static async build(input: IPromptParams, output: unknown): Promise<IPromptAudioResponse | undefined> {
+        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/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)
     })
 })

package/test/DraxAgent.test.ts

@@ -144,6 +144,70 @@ describe("DraxAgent", () => {
         ]);
     });
 
+    test("passes audioResponse to provider and returns prompt audio", async () => {
+        class AudioMockProvider extends MockProvider {
+            async prompt(input: IPromptParams): Promise<IPromptResponse> {
+                this.requests.push(input);
+
+                return {
+                    output: "respuesta hablada",
+                    tokens: 10,
+                    inputTokens: 6,
+                    outputTokens: 4,
+                    time: 12,
+                    audio: {
+                        audio: Buffer.from("audio").toString("base64"),
+                        contentType: "audio/mpeg",
+                        encoding: "base64",
+                        meta: {
+                            provider: "elevenlabs",
+                            model: "eleven_multilingual_v2",
+                            voiceId: "voice-1",
+                            size: 5,
+                            time: 20,
+                        },
+                    },
+                };
+            }
+        }
+
+        const provider = new AudioMockProvider();
+        const agent = new DraxAgent().configure({
+            provider,
+            systemPrompt: "Sos un asistente.",
+            sessionService: false,
+            toolBuilders: undefined,
+            tools: undefined,
+        });
+
+        const response = await agent.sendMessage({
+            userId: "user-1",
+            message: "Hola",
+            audioResponse: {
+                provider: "ElevenLabs",
+                languageCode: "es",
+            },
+        });
+
+        expect(provider.requests[0].audioResponse).toEqual({
+            provider: "ElevenLabs",
+            languageCode: "es",
+        });
+        expect(response.message).toBe("respuesta hablada");
+        expect(response.audio).toEqual({
+            audio: Buffer.from("audio").toString("base64"),
+            contentType: "audio/mpeg",
+            encoding: "base64",
+            meta: {
+                provider: "elevenlabs",
+                model: "eleven_multilingual_v2",
+                voiceId: "voice-1",
+                size: 5,
+                time: 20,
+            },
+        });
+    });
+
     test("returns a navigation path from tool execution metadata", async () => {
         const provider = new MockProvider();
         const agent = new DraxAgent().configure({

package/test/PromptAudioService.test.ts

@@ -0,0 +1,115 @@
+import {afterEach, describe, expect, test, vi} from "vitest";
+import {PromptAudioService, TTSProviderFactory} from "../src";
+
+describe("PromptAudioService Test", () => {
+
+    afterEach(() => {
+        vi.restoreAllMocks()
+    })
+
+    test("does not generate audio when audioResponse is not requested", async () => {
+        const instanceSpy = vi.spyOn(TTSProviderFactory, "instance")
+
+        const audio = await PromptAudioService.build({
+            systemPrompt: "You are an assistant.",
+        }, "Hola")
+
+        expect(audio).toBeUndefined()
+        expect(instanceSpy).not.toHaveBeenCalled()
+    })
+
+    test("generates base64 prompt audio with default ElevenLabs provider", async () => {
+        const textToSpeech = vi.fn(async () => ({
+            audio: Buffer.from("audio-bytes"),
+            contentType: "audio/mpeg",
+            size: 11,
+            time: 25,
+            provider: "elevenlabs",
+            model: "eleven_multilingual_v2",
+            voiceId: "voice-1",
+            outputFormat: "mp3_44100_128",
+        }))
+        const instanceSpy = vi.spyOn(TTSProviderFactory, "instance").mockReturnValue({
+            textToSpeech,
+        })
+
+        const audio = await PromptAudioService.build({
+            systemPrompt: "You are an assistant.",
+            audioResponse: true,
+            operationTitle: "prompt-title",
+            operationGroup: "prompt-group",
+            ip: "127.0.0.1",
+            userAgent: "vitest",
+            tenant: "tenant-1",
+            user: "user-1",
+        }, "Hola mundo")
+
+        expect(instanceSpy).toHaveBeenCalledWith("ElevenLabs")
+        expect(textToSpeech).toHaveBeenCalledWith({
+            text: "Hola mundo",
+            voiceId: undefined,
+            model: undefined,
+            outputFormat: undefined,
+            voiceSettings: undefined,
+            previousText: undefined,
+            nextText: undefined,
+            languageCode: undefined,
+            seed: undefined,
+            operationTitle: "prompt-title",
+            operationGroup: "prompt-group",
+            ip: "127.0.0.1",
+            userAgent: "vitest",
+            tenant: "tenant-1",
+            user: "user-1",
+        })
+        expect(audio).toEqual({
+            audio: Buffer.from("audio-bytes").toString("base64"),
+            contentType: "audio/mpeg",
+            encoding: "base64",
+            meta: {
+                provider: "elevenlabs",
+                model: "eleven_multilingual_v2",
+                voiceId: "voice-1",
+                outputFormat: "mp3_44100_128",
+                size: 11,
+                time: 25,
+            },
+        })
+    })
+
+    test("supports custom TTS provider params", async () => {
+        const textToSpeech = vi.fn(async () => ({
+            audio: Buffer.from("custom-audio"),
+            contentType: "audio/ogg",
+            size: 12,
+            time: 31,
+            provider: "custom",
+            model: "custom-model",
+            voiceId: "voice-2",
+        }))
+        const instanceSpy = vi.spyOn(TTSProviderFactory, "instance").mockReturnValue({
+            textToSpeech,
+        })
+
+        await PromptAudioService.build({
+            systemPrompt: "You are an assistant.",
+            audioResponse: {
+                provider: "CustomTTS",
+                voiceId: "voice-2",
+                model: "custom-model",
+                languageCode: "es",
+                operationTitle: "tts-title",
+            },
+        }, {message: "Hola"})
+
+        expect(instanceSpy).toHaveBeenCalledWith("CustomTTS")
+        expect(textToSpeech).toHaveBeenCalledWith(expect.objectContaining({
+            text: "{\"message\":\"Hola\"}",
+            voiceId: "voice-2",
+            model: "custom-model",
+            languageCode: "es",
+            operationTitle: "tts-title",
+        }))
+    })
+
+})