@drax/ai-back 3.32.0 → 3.35.1

package/dist/config/GoogleAiConfig.js

@@ -0,0 +1,8 @@
+var GoogleAiConfig;
+(function (GoogleAiConfig) {
+    GoogleAiConfig["GoogleAiApiKey"] = "GOOGLE_AI_API_KEY";
+    GoogleAiConfig["GoogleAiModel"] = "GOOGLE_AI_MODEL";
+    GoogleAiConfig["GoogleAiVisionModel"] = "GOOGLE_AI_VISION_MODEL";
+})(GoogleAiConfig || (GoogleAiConfig = {}));
+export default GoogleAiConfig;
+export { GoogleAiConfig };

package/dist/config/OllamaAiConfig.js

@@ -0,0 +1,9 @@
+var OllamaAiConfig;
+(function (OllamaAiConfig) {
+    OllamaAiConfig["OllamaAiBaseUrl"] = "OLLAMA_AI_BASE_URL";
+    OllamaAiConfig["OllamaAiModel"] = "OLLAMA_AI_MODEL";
+    OllamaAiConfig["OllamaAiVisionModel"] = "OLLAMA_AI_VISION_MODEL";
+    OllamaAiConfig["OllamaAiEmbeddingModel"] = "OLLAMA_AI_EMBEDDING_MODEL";
+})(OllamaAiConfig || (OllamaAiConfig = {}));
+export default OllamaAiConfig;
+export { OllamaAiConfig };

package/dist/factory/AiProviderFactory.js

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

package/dist/factory/GoogleAiProviderFactory.js

@@ -0,0 +1,14 @@
+import { DraxConfig } from "@drax/common-back";
+import GoogleAiConfig from "../config/GoogleAiConfig.js";
+import GoogleAiProvider from "../providers/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/OllamaAiProviderFactory.js

@@ -0,0 +1,14 @@
+import { DraxConfig } from "@drax/common-back";
+import OllamaAiConfig from "../config/OllamaAiConfig.js";
+import OllamaAiProvider from "../providers/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/index.js

@@ -1,12 +1,18 @@
 import { OpenAiConfig } from "./config/OpenAiConfig.js";
+import { GoogleAiConfig } from "./config/GoogleAiConfig.js";
+import { OllamaAiConfig } from "./config/OllamaAiConfig.js";
 import { AILogSchema, AILogBaseSchema } from "./schemas/AILogSchema.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 { AiProviderFactory } from "./factory/AiProviderFactory.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 { BuilderTool } from "./tools/BuilderTool.js";
 import { KnowledgeService } from "./services/KnowledgeService.js";
 import { AILogService } from "./services/AILogService.js";
@@ -24,7 +30,7 @@ import AIRoutes from "./routes/AIRoutes.js";
 import DraxAgentRoutes from "./routes/DraxAgentRoutes.js";
 import AgentSessionRoutes from "./routes/AgentSessionRoutes.js";
 import { DraxAgent } from "./agents/DraxAgent.js";
-export { OpenAiConfig, AILogSchema, AILogBaseSchema, AILogModel, AILogMongoRepository, AILogSqliteRepository, OpenAiProviderFactory, AiProviderFactory, AILogServiceFactory, OpenAiProvider, BuilderTool, 
+export { OpenAiConfig, GoogleAiConfig, OllamaAiConfig, AILogSchema, AILogBaseSchema, AILogModel, AILogMongoRepository, AILogSqliteRepository, OpenAiProviderFactory, GoogleAiProviderFactory, OllamaAiProviderFactory, AiProviderFactory, AILogServiceFactory, OpenAiProvider, GoogleAiProvider, OllamaAiProvider, BuilderTool, 
 //Service
 KnowledgeService, AILogService, 
 //Permissions

package/dist/providers/GoogleAiProvider.js

@@ -0,0 +1,367 @@
+import { GoogleGenAI } from "@google/genai";
+import { toJSONSchema } from "zod";
+class GoogleAiProvider {
+    constructor(apiKey, model, visionModel, aiLogService) {
+        if (!apiKey) {
+            throw new Error("Google AI apiKey required");
+        }
+        if (!model) {
+            throw new Error("Google AI model required");
+        }
+        this._apiKey = apiKey;
+        this._model = model;
+        this._visionModel = visionModel;
+        this._aiLogService = aiLogService;
+    }
+    get model() {
+        if (!this._model) {
+            throw new Error("Google AI model not found");
+        }
+        return this._model;
+    }
+    get client() {
+        if (!this._client) {
+            this._client = new GoogleGenAI({
+                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({ text: input.userInput });
+            }
+            content.push(...input.userImages.map(image => this.mapImageUrl(image.url)));
+            return content;
+        }
+        return input.userInput ? [{ text: input.userInput }] : [{ text: "" }];
+    }
+    mapContentParts(content) {
+        return content.map(part => {
+            if (part.type === 'text') {
+                return {
+                    text: part.text
+                };
+            }
+            return this.mapImageUrl(part.imageUrl);
+        });
+    }
+    mapImageUrl(url) {
+        const dataUrlMatch = url.match(/^data:([^;,]+);base64,(.+)$/);
+        if (dataUrlMatch) {
+            return {
+                inlineData: {
+                    mimeType: dataUrlMatch[1],
+                    data: dataUrlMatch[2],
+                }
+            };
+        }
+        return {
+            fileData: {
+                fileUri: url,
+                mimeType: this.inferImageMimeType(url),
+            }
+        };
+    }
+    inferImageMimeType(url) {
+        const normalizedUrl = url.split("?")[0].toLowerCase();
+        if (normalizedUrl.endsWith(".png")) {
+            return "image/png";
+        }
+        if (normalizedUrl.endsWith(".webp")) {
+            return "image/webp";
+        }
+        if (normalizedUrl.endsWith(".gif")) {
+            return "image/gif";
+        }
+        if (normalizedUrl.endsWith(".bmp")) {
+            return "image/bmp";
+        }
+        if (normalizedUrl.endsWith(".heic")) {
+            return "image/heic";
+        }
+        if (normalizedUrl.endsWith(".heif")) {
+            return "image/heif";
+        }
+        return "image/jpeg";
+    }
+    mapHistory(history = []) {
+        return history.map(message => {
+            const parts = typeof message.content === 'string'
+                ? [{ text: message.content }]
+                : this.mapContentParts(message.content);
+            if (message.role === "assistant") {
+                return {
+                    role: "model",
+                    parts,
+                };
+            }
+            if (message.role === "system") {
+                return {
+                    role: "user",
+                    parts: [
+                        { text: "[SYSTEM]" },
+                        ...parts,
+                    ],
+                };
+            }
+            return {
+                role: "user",
+                parts,
+            };
+        });
+    }
+    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: "googleai",
+            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-004" }) {
+        const response = await this.client.models.embedContent({
+            model,
+            contents: text,
+        });
+        return response.embeddings?.[0]?.values ?? [];
+    }
+    mapTools(tools = []) {
+        if (tools.length === 0) {
+            return [];
+        }
+        return [{
+                functionDeclarations: tools.map(tool => ({
+                    name: tool.name,
+                    description: tool.description,
+                    parametersJsonSchema: tool.parameters ?? {
+                        type: "object",
+                        properties: {},
+                        additionalProperties: false,
+                    },
+                }))
+            }];
+    }
+    buildResponseConfig(input, systemPrompt) {
+        const config = {
+            systemInstruction: systemPrompt,
+        };
+        const responseJsonSchema = this.normalizeResponseJsonSchema(input);
+        if (responseJsonSchema) {
+            config.responseMimeType = "application/json";
+            config.responseJsonSchema = responseJsonSchema;
+        }
+        if (input.tools && input.tools.length > 0) {
+            config.tools = this.mapTools(input.tools);
+        }
+        return config;
+    }
+    normalizeResponseJsonSchema(input) {
+        if (input.zodSchema) {
+            return toJSONSchema(input.zodSchema, {
+                target: "draft-7",
+            });
+        }
+        if (!input.jsonSchema) {
+            return undefined;
+        }
+        const jsonSchema = input.jsonSchema;
+        if (jsonSchema.type === "json_schema" && jsonSchema.json_schema?.schema) {
+            return jsonSchema.json_schema.schema;
+        }
+        return jsonSchema;
+    }
+    async buildToolResponseParts(functionCalls = [], tools = []) {
+        const parts = [];
+        for (const functionCall of functionCalls) {
+            const toolName = functionCall.name;
+            const tool = tools.find(t => t.name === toolName);
+            if (!tool) {
+                throw new Error(`Tool not found: ${toolName}`);
+            }
+            const output = await tool.execute(functionCall.args ?? {});
+            parts.push({
+                functionResponse: {
+                    id: functionCall.id,
+                    name: toolName,
+                    response: {
+                        output,
+                    },
+                }
+            });
+        }
+        return parts;
+    }
+    buildModelFunctionCallContent(functionCalls = []) {
+        return {
+            role: "model",
+            parts: functionCalls.map(functionCall => ({
+                functionCall,
+            }))
+        };
+    }
+    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 contents = [
+                ...this.mapHistory(input.history),
+                { role: 'user', parts: userInput },
+            ];
+            const tools = input.tools ?? [];
+            const maxIterations = input.toolMaxIterations ?? 5;
+            let output;
+            for (let iteration = 0; iteration < maxIterations; iteration++) {
+                const response = await this.client.models.generateContent({
+                    model,
+                    contents,
+                    config: this.buildResponseConfig(input, systemPrompt),
+                });
+                tokens += response.usageMetadata?.totalTokenCount ?? 0;
+                inputTokens += response.usageMetadata?.promptTokenCount ?? 0;
+                outputTokens += response.usageMetadata?.candidatesTokenCount ?? 0;
+                const functionCalls = response.functionCalls ?? [];
+                if (functionCalls.length === 0) {
+                    output = response.text;
+                    break;
+                }
+                contents.push(response.candidates?.[0]?.content ?? this.buildModelFunctionCallContent(functionCalls));
+                contents.push({
+                    role: "user",
+                    parts: await this.buildToolResponseParts(functionCalls, 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 GoogleAiProvider;
+export { GoogleAiProvider };