@drax/ai-back 3.41.0 → 3.42.0

package/dist/providers/ai/OpenAiProvider.js

@@ -0,0 +1,302 @@
+import OpenAI from "openai";
+import { zodResponseFormat } from "openai/helpers/zod";
+class OpenAiProvider {
+    constructor(apiKey, model, visionModel, aiLogService) {
+        if (!apiKey) {
+            throw new Error("OpenAI apiKey required");
+        }
+        if (!model) {
+            throw new Error("OpenAI model required");
+        }
+        this._apiKey = apiKey;
+        this._model = model;
+        this._visionModel = visionModel;
+        this._aiLogService = aiLogService;
+    }
+    get model() {
+        if (!this._model) {
+            throw new Error("OpenAI model not found");
+        }
+        return this._model;
+    }
+    get client() {
+        if (!this._client) {
+            this._client = new OpenAI({
+                apiKey: this._apiKey,
+            });
+        }
+        return this._client;
+    }
+    get visionModel() {
+        return this._visionModel;
+    }
+    buildUserContent(input) {
+        if (input.userContent && input.userContent.length > 0) {
+            return this.mapContentParts(input.userContent);
+        }
+        if (input.userImages && input.userImages.length > 0) {
+            const content = [];
+            if (input.userInput) {
+                content.push({ type: 'text', text: input.userInput });
+            }
+            content.push(...input.userImages.map(image => ({
+                type: 'image_url',
+                image_url: {
+                    url: image.url,
+                    ...(image.detail ? { detail: image.detail } : {}),
+                }
+            })));
+            return content;
+        }
+        return input.userInput ?? "";
+    }
+    mapContentParts(content) {
+        return content.map(part => {
+            if (part.type === 'text') {
+                return {
+                    type: 'text',
+                    text: part.text
+                };
+            }
+            return {
+                type: 'image_url',
+                image_url: {
+                    url: part.imageUrl,
+                    ...(part.detail ? { detail: part.detail } : {}),
+                }
+            };
+        });
+    }
+    mapHistory(history = []) {
+        return history.map(message => ({
+            role: message.role,
+            content: typeof message.content === 'string'
+                ? message.content
+                : this.mapContentParts(message.content)
+        }));
+    }
+    hasImageInput(input) {
+        if (input.userImages && input.userImages.length > 0) {
+            return true;
+        }
+        if (input.userContent?.some(part => part.type === 'image')) {
+            return true;
+        }
+        return input.history?.some(message => Array.isArray(message.content) && message.content.some(part => part.type === 'image')) ?? false;
+    }
+    serializePromptInput(input, systemPrompt) {
+        return JSON.stringify({
+            systemPrompt,
+            history: input.history,
+            userInput: input.userInput,
+            userContent: input.userContent,
+            memory: input.memory,
+            knowledgeBase: input.knowledgeBase,
+            tools: input.tools?.map(tool => ({
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters,
+            })),
+        });
+    }
+    serializePromptOutput(output) {
+        if (typeof output === "string") {
+            return output;
+        }
+        if (output === null || output === undefined) {
+            return undefined;
+        }
+        return JSON.stringify(output);
+    }
+    buildLogPayload(input, params) {
+        return {
+            provider: "openai",
+            model: params.model,
+            operationTitle: input.operationTitle,
+            operationGroup: input.operationGroup,
+            ip: input.ip,
+            userAgent: input.userAgent,
+            input: this.serializePromptInput(input, params.systemPrompt),
+            inputImages: input.userImages?.map(image => ({
+                url: image.url,
+            })) ?? input.userContent
+                ?.filter(part => part.type === "image")
+                .map(part => ({
+                url: part.imageUrl,
+            })),
+            inputFiles: input.inputFiles,
+            inputTokens: params.inputTokens,
+            outputTokens: params.outputTokens,
+            tokens: params.tokens,
+            startedAt: params.startedAt,
+            endedAt: params.endedAt,
+            responseTime: params.endedAt ? `${params.endedAt.getTime() - params.startedAt.getTime()}ms` : undefined,
+            output: this.serializePromptOutput(params.output),
+            success: params.success,
+            errorMessage: params.errorMessage,
+            tenant: input.tenant,
+            user: input.user,
+        };
+    }
+    async registerPromptLog(input, params) {
+        if (!this._aiLogService) {
+            return;
+        }
+        try {
+            await this._aiLogService.create(this.buildLogPayload(input, params));
+        }
+        catch (e) {
+            console.error("Error registerPromptLog", {
+                name: e?.name,
+                message: e?.message,
+                stack: e?.stack,
+            });
+        }
+    }
+    async generateEmbedding({ text, model = "text-embedding-ada-002" }) {
+        const response = await this.client.embeddings.create({
+            model: model,
+            input: text,
+        });
+        return response.data[0].embedding;
+    }
+    mapTools(tools = []) {
+        return tools.map(tool => ({
+            type: "function",
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters ?? {
+                    type: "object",
+                    properties: {},
+                    additionalProperties: false,
+                },
+            },
+        }));
+    }
+    parseToolArguments(args) {
+        if (!args) {
+            return {};
+        }
+        try {
+            return JSON.parse(args);
+        }
+        catch (e) {
+            throw new Error(`Invalid tool arguments: ${args}`);
+        }
+    }
+    serializeToolOutput(output) {
+        if (typeof output === "string") {
+            return output;
+        }
+        if (output === undefined) {
+            return "";
+        }
+        return JSON.stringify(output);
+    }
+    async buildToolMessages(toolCalls = [], tools = []) {
+        const toolMessages = [];
+        for (const toolCall of toolCalls) {
+            const toolName = toolCall.function?.name;
+            const tool = tools.find(t => t.name === toolName);
+            if (!tool) {
+                throw new Error(`Tool not found: ${toolName}`);
+            }
+            const args = this.parseToolArguments(toolCall.function?.arguments);
+            const output = await tool.execute(args);
+            toolMessages.push({
+                role: "tool",
+                tool_call_id: toolCall.id,
+                content: this.serializeToolOutput(output),
+            });
+        }
+        return toolMessages;
+    }
+    async prompt(input) {
+        if (!input.systemPrompt) {
+            throw new Error("systemPrompt required");
+        }
+        let systemPrompt = input.systemPrompt;
+        if (input.memory && input.memory.length > 0) {
+            systemPrompt += `\n\n ${input.memoryHeader ?? '[MEMORIA]'}\n ${input.memory.map(m => `${m.key}: ${m.value}`).join('\n')}`;
+        }
+        if (input.knowledgeBase && input.knowledgeBase.length > 0) {
+            systemPrompt += `\n\n${input.knowledgeBaseHeader ?? '[BASE DE CONOCIMIENTO]'}\n ${input.knowledgeBase.join('\n')}`;
+        }
+        const userInput = this.buildUserContent(input);
+        const model = input.model ?? (this.hasImageInput(input) ? this.visionModel ?? this.model : this.model);
+        const startedAt = new Date();
+        const startTime = performance.now();
+        let tokens = 0;
+        let inputTokens = 0;
+        let outputTokens = 0;
+        try {
+            const messages = [
+                { role: 'system', content: systemPrompt },
+                ...this.mapHistory(input.history),
+                { role: 'user', content: userInput },
+            ];
+            const tools = input.tools ?? [];
+            const maxIterations = input.toolMaxIterations ?? 5;
+            let output;
+            for (let iteration = 0; iteration < maxIterations; iteration++) {
+                const chatCompletion = await this.client.chat.completions.create({
+                    messages,
+                    ...(input.zodSchema ? { response_format: zodResponseFormat(input.zodSchema, "event") } : {}),
+                    ...(input.jsonSchema ? { response_format: input.jsonSchema } : {}),
+                    ...(tools.length > 0 ? { tools: this.mapTools(tools) } : {}),
+                    model: model,
+                });
+                tokens += chatCompletion.usage?.total_tokens ?? 0;
+                inputTokens += chatCompletion.usage?.prompt_tokens ?? 0;
+                outputTokens += chatCompletion.usage?.completion_tokens ?? 0;
+                const message = chatCompletion.choices[0].message;
+                const toolCalls = message.tool_calls ?? [];
+                if (toolCalls.length === 0) {
+                    output = message.content;
+                    break;
+                }
+                messages.push(message);
+                messages.push(...await this.buildToolMessages(toolCalls, tools));
+            }
+            if (output === undefined) {
+                throw new Error(`Tool max iterations reached: ${maxIterations}`);
+            }
+            const endTime = performance.now();
+            const time = endTime - startTime;
+            const endedAt = new Date();
+            await this.registerPromptLog(input, {
+                model,
+                systemPrompt,
+                startedAt,
+                endedAt,
+                inputTokens,
+                outputTokens,
+                tokens,
+                output,
+                success: true,
+            });
+            return {
+                output,
+                tokens,
+                inputTokens,
+                outputTokens,
+                time
+            };
+        }
+        catch (e) {
+            const endedAt = new Date();
+            await this.registerPromptLog(input, {
+                model,
+                systemPrompt,
+                startedAt,
+                endedAt,
+                success: false,
+                errorMessage: e?.message,
+            });
+            throw e;
+        }
+    }
+}
+export default OpenAiProvider;
+export { OpenAiProvider };

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/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.42.0",
   "description": "Ai utils",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -46,5 +46,5 @@
     "typescript": "^5.9.3",
     "vitest": "^3.0.8"
   },
-  "gitHead": "21f6bdb9f6cc6da6c74dee8aef275d8f88755dd4"
+  "gitHead": "30b8ca8c49adb16b4617e61c497b554389c49dd1"
 }

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";
 

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";
 

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;