@drax/ai-back 3.32.0 → 3.35.1

package/dist/providers/OllamaAiProvider.js

@@ -0,0 +1,342 @@
+import { toJSONSchema } from "zod";
+class OllamaAiProvider {
+    constructor(baseUrl, model, visionModel, embeddingModel, aiLogService) {
+        if (!baseUrl) {
+            throw new Error("Ollama AI baseUrl required");
+        }
+        if (!model) {
+            throw new Error("Ollama AI model required");
+        }
+        this._baseUrl = baseUrl.replace(/\/+$/, "");
+        this._model = model;
+        this._visionModel = visionModel;
+        this._embeddingModel = embeddingModel;
+        this._aiLogService = aiLogService;
+    }
+    get model() {
+        if (!this._model) {
+            throw new Error("Ollama AI model not found");
+        }
+        return this._model;
+    }
+    get visionModel() {
+        return this._visionModel;
+    }
+    get embeddingModel() {
+        return this._embeddingModel ?? this.model;
+    }
+    async post(path, body) {
+        const response = await fetch(`${this._baseUrl}${path}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Ollama AI request failed (${response.status}): ${errorText}`);
+        }
+        return await response.json();
+    }
+    async buildUserMessage(input) {
+        if (input.userContent && input.userContent.length > 0) {
+            return await this.mapContentPartsToMessage(input.userContent);
+        }
+        if (input.userImages && input.userImages.length > 0) {
+            return {
+                role: "user",
+                content: input.userInput ?? "",
+                images: await Promise.all(input.userImages.map(image => this.imageUrlToBase64(image.url))),
+            };
+        }
+        return {
+            role: "user",
+            content: input.userInput ?? "",
+        };
+    }
+    async mapContentPartsToMessage(content, role = "user") {
+        const text = [];
+        const images = [];
+        for (const part of content) {
+            if (part.type === "text") {
+                text.push(part.text);
+                continue;
+            }
+            images.push(await this.imageUrlToBase64(part.imageUrl));
+        }
+        return {
+            role,
+            content: text.join("\n"),
+            ...(images.length > 0 ? { images } : {}),
+        };
+    }
+    async imageUrlToBase64(url) {
+        const dataUrlMatch = url.match(/^data:[^;,]+;base64,(.+)$/);
+        if (dataUrlMatch) {
+            return dataUrlMatch[1];
+        }
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Ollama AI image request failed (${response.status}): ${url}`);
+        }
+        const buffer = Buffer.from(await response.arrayBuffer());
+        return buffer.toString("base64");
+    }
+    async mapHistory(history = []) {
+        const messages = [];
+        for (const message of history) {
+            if (typeof message.content === "string") {
+                messages.push({
+                    role: message.role,
+                    content: message.content,
+                });
+                continue;
+            }
+            messages.push(await this.mapContentPartsToMessage(message.content, message.role));
+        }
+        return messages;
+    }
+    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: "ollamaai",
+            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 }) {
+        const response = await this.post("/api/embed", {
+            model: model ?? this.embeddingModel,
+            input: text,
+        });
+        return response.embeddings?.[0] ?? response.embedding ?? [];
+    }
+    mapTools(tools = []) {
+        return tools.map(tool => ({
+            type: "function",
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters ?? {
+                    type: "object",
+                    properties: {},
+                    additionalProperties: false,
+                },
+            },
+        }));
+    }
+    normalizeResponseFormat(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;
+    }
+    parseToolArguments(args) {
+        if (!args) {
+            return {};
+        }
+        if (typeof args === "object") {
+            return args;
+        }
+        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",
+                name: toolName,
+                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 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 },
+                ...await this.mapHistory(input.history),
+                await this.buildUserMessage(input),
+            ];
+            const tools = input.tools ?? [];
+            const maxIterations = input.toolMaxIterations ?? 5;
+            const responseFormat = this.normalizeResponseFormat(input);
+            let output;
+            for (let iteration = 0; iteration < maxIterations; iteration++) {
+                const response = await this.post("/api/chat", {
+                    model,
+                    messages,
+                    stream: false,
+                    ...(responseFormat ? { format: responseFormat } : {}),
+                    ...(tools.length > 0 ? { tools: this.mapTools(tools) } : {}),
+                });
+                inputTokens += response.prompt_eval_count ?? 0;
+                outputTokens += response.eval_count ?? 0;
+                tokens += (response.prompt_eval_count ?? 0) + (response.eval_count ?? 0);
+                const message = response.message ?? {};
+                const toolCalls = message.tool_calls ?? [];
+                if (toolCalls.length === 0) {
+                    output = message.content ?? response.response ?? "";
+                    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 OllamaAiProvider;
+export { OllamaAiProvider };

package/dist/tools/BuilderTool.js

@@ -224,6 +224,15 @@ class BuilderTool {
         if (typeof f?.unwrap === "function" && typeName === "ZodNullable") {
             return this.fieldAdapter(f.unwrap()).nullable();
         }
+        if (typeof f?.unwrap === "function" && typeName === "ZodDefault") {
+            return this.fieldAdapter(f.unwrap()).default(f.def.defaultValue);
+        }
+        if (typeof f?.unwrap === "function" && typeName === "ZodCatch") {
+            return this.fieldAdapter(f.unwrap()).catch(f.def.catchValue);
+        }
+        if (typeof f?.unwrap === "function" && typeName === "ZodReadonly") {
+            return this.fieldAdapter(f.unwrap()).readonly();
+        }
         if (typeName === "ZodArray" && f?.element) {
             return z.array(this.fieldAdapter(f.element));
         }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.32.0",
+  "version": "3.35.1",
   "description": "Ai utils",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -24,6 +24,7 @@
     "mongoose-paginate-v2": "^1.8.3"
   },
   "peerDependencies": {
+    "@google/genai": "^1.52.0",
     "jsdom": "^26.0.0",
     "office-text-extractor": "^3.0.3",
     "openai": "^6.0.0",
@@ -35,6 +36,7 @@
     }
   },
   "devDependencies": {
+    "@google/genai": "^1.52.0",
     "@types/node": "^25.2.3",
     "jsdom": "^26.0.0",
     "office-text-extractor": "^3.0.3",
@@ -44,5 +46,5 @@
     "typescript": "^5.9.3",
     "vitest": "^3.0.8"
   },
-  "gitHead": "ebb9acff2133065ac6fd549fead7cc38ce1c0913"
+  "gitHead": "5c5d65ae83b6da98c044cc868150e5e1780e18ca"
 }

package/src/config/GoogleAiConfig.ts

@@ -0,0 +1,13 @@
+
+enum GoogleAiConfig {
+
+    GoogleAiApiKey = "GOOGLE_AI_API_KEY",
+    GoogleAiModel = "GOOGLE_AI_MODEL",
+    GoogleAiVisionModel = "GOOGLE_AI_VISION_MODEL",
+
+}
+
+
+export default GoogleAiConfig;
+
+export {GoogleAiConfig}

package/src/config/OllamaAiConfig.ts

@@ -0,0 +1,14 @@
+
+enum OllamaAiConfig {
+
+    OllamaAiBaseUrl = "OLLAMA_AI_BASE_URL",
+    OllamaAiModel = "OLLAMA_AI_MODEL",
+    OllamaAiVisionModel = "OLLAMA_AI_VISION_MODEL",
+    OllamaAiEmbeddingModel = "OLLAMA_AI_EMBEDDING_MODEL",
+
+}
+
+
+export default OllamaAiConfig;
+
+export {OllamaAiConfig}

package/src/factory/AiProviderFactory.ts

@@ -1,20 +1,28 @@
 import type {IAIProvider} from "../interfaces/IAIProvider"
 import OpenAiProviderFactory from "./OpenAiProviderFactory.js";
+import GoogleAiProviderFactory from "./GoogleAiProviderFactory.js";
+import OllamaAiProviderFactory from "./OllamaAiProviderFactory.js";
 
 class AiProviderFactory {
-    private static singleton: IAIProvider;
+    private static singletons: Record<string, IAIProvider> = {};
 
     public static instance(provider: string = 'OpenAi'): IAIProvider {
-        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];
     }
 }
 
@@ -22,4 +30,3 @@ export default AiProviderFactory
 export {
     AiProviderFactory
 }
-

package/src/factory/GoogleAiProviderFactory.ts

@@ -0,0 +1,26 @@
+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";
+
+class GoogleAiProviderFactory {
+    private static singleton: IAIProvider;
+
+    public static instance(): IAIProvider {
+        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/src/factory/OllamaAiProviderFactory.ts

@@ -0,0 +1,27 @@
+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";
+
+class OllamaAiProviderFactory {
+    private static singleton: IAIProvider;
+
+    public static instance(): IAIProvider {
+        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/src/index.ts

@@ -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";
@@ -95,15 +101,21 @@ export type {
 
 export {
     OpenAiConfig,
+    GoogleAiConfig,
+    OllamaAiConfig,
     AILogSchema,
     AILogBaseSchema,
     AILogModel,
     AILogMongoRepository,
     AILogSqliteRepository,
     OpenAiProviderFactory,
+    GoogleAiProviderFactory,
+    OllamaAiProviderFactory,
     AiProviderFactory,
     AILogServiceFactory,
     OpenAiProvider,
+    GoogleAiProvider,
+    OllamaAiProvider,
     BuilderTool,
     //Service
     KnowledgeService,