@drax/ai-back 3.26.0 → 3.28.0

package/.env

@@ -0,0 +1,4 @@
+#IA
+OPENAI_API_KEY=sk-svcacct-Jm8f5uVnoe2Jl71Hux1vslYU3w0roJyGiV-itniyrDVw191uhGcSHgTh0O59VGAT3BlbkFJaeneUjBAPPC4pMQIVmeTL98U6cp0vnIR-wugCX-wGxxqpjB2vVRj4GRz3sjpkLQA
+OPENAI_MODEL=gpt-5.4
+OPENAI_VISION_MODEL=gpt-5.4

package/dist/providers/OpenAiProvider.js

@@ -92,6 +92,11 @@ class OpenAiProvider {
             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) {
@@ -155,6 +160,58 @@ class OpenAiProvider {
         });
         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");
@@ -170,21 +227,41 @@ class OpenAiProvider {
         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 chatCompletion = await this.client.chat.completions.create({
-                messages: [
-                    { role: 'system', content: systemPrompt },
-                    ...this.mapHistory(input.history),
-                    { role: 'user', content: userInput },
-                ],
-                ...(input.zodSchema ? { response_format: zodResponseFormat(input.zodSchema, "event") } : {}),
-                ...(input.jsonSchema ? { response_format: input.jsonSchema } : {}),
-                model: model,
-            });
-            const output = chatCompletion.choices[0].message.content;
-            const tokens = chatCompletion.usage.total_tokens;
-            const inputTokens = chatCompletion.usage.prompt_tokens;
-            const outputTokens = chatCompletion.usage.completion_tokens;
+            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();

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.26.0",
+  "version": "3.28.0",
   "description": "Ai utils",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -19,7 +19,7 @@
   "license": "ISC",
   "dependencies": {
     "@drax/ai-share": "^3.18.0",
-    "@drax/crud-back": "^3.26.0",
+    "@drax/crud-back": "^3.28.0",
     "mongoose": "^8.23.0",
     "mongoose-paginate-v2": "^1.8.3"
   },
@@ -44,5 +44,5 @@
     "typescript": "^5.9.3",
     "vitest": "^3.0.8"
   },
-  "gitHead": "482f91f51a9e783ac9131f557ace113f3b3404fa"
+  "gitHead": "f9787aec59da68ec6d84d0c5e3ee3471eb65ad07"
 }

package/src/index.ts

@@ -27,7 +27,8 @@ import type {
     IPromptMessage,
     IPromptMemory,
     IPromptParams,
-    IPromptResponse
+    IPromptResponse,
+    IPromptTool
 } from "./interfaces/IAIProvider.js";
 
 export type {
@@ -37,6 +38,7 @@ export type {
     IPromptParams,
     IPromptMessage,
     IPromptMemory,
+    IPromptTool,
     IPromptImage,
     IPromptImageDetail,
     IPromptContentPart,

package/src/interfaces/IAIProvider.ts

@@ -32,6 +32,13 @@ interface IPromptMemory {
     value: string;
 }
 
+interface IPromptTool {
+    name: string;
+    description: string;
+    parameters?: object;
+    execute: (args: any) => any | Promise<any>;
+}
+
 interface IPromptParams {
     systemPrompt: string,
     userInput?: string,
@@ -51,6 +58,8 @@ interface IPromptParams {
     knowledgeBaseHeader?: string | '[KNOWLEDGE BASE]' | '[BASE DE CONOCIMIENTO]',
     zodSchema?: ZodSchema<any>,
     jsonSchema?: object,
+    tools?: IPromptTool[],
+    toolMaxIterations?: number,
     model?: string,
     operationTitle?: string,
     operationGroup?: string,
@@ -78,6 +87,7 @@ export type {
     IPromptResponse,
     IPromptMessage,
     IPromptMemory,
+    IPromptTool,
     IPromptImage,
     IPromptImageDetail,
     IPromptContentPart,

package/src/providers/OpenAiProvider.ts

@@ -5,7 +5,8 @@ import type {
     IPromptContentPart,
     IPromptMessage,
     IPromptParams,
-    IPromptResponse
+    IPromptResponse,
+    IPromptTool
 } from "../interfaces/IAIProvider";
 import type {AILogService} from "../services/AILogService";
 import type {IAILogBase} from "@drax/ai-share";
@@ -129,6 +130,11 @@ class OpenAiProvider implements IAIProvider{
             userContent: input.userContent,
             memory: input.memory,
             knowledgeBase: input.knowledgeBase,
+            tools: input.tools?.map(tool => ({
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters,
+            })),
         })
     }
 
@@ -221,6 +227,69 @@ class OpenAiProvider implements IAIProvider{
         return response.data[0].embedding;
     }
 
+    protected mapTools(tools: IPromptTool[] = []){
+        return tools.map(tool => ({
+            type: "function" as const,
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters ?? {
+                    type: "object",
+                    properties: {},
+                    additionalProperties: false,
+                },
+            },
+        }))
+    }
+
+    protected parseToolArguments(args: string | undefined){
+        if(!args){
+            return {}
+        }
+
+        try{
+            return JSON.parse(args)
+        }catch(e){
+            throw new Error(`Invalid tool arguments: ${args}`)
+        }
+    }
+
+    protected serializeToolOutput(output: unknown){
+        if(typeof output === "string"){
+            return output
+        }
+
+        if(output === undefined){
+            return ""
+        }
+
+        return JSON.stringify(output)
+    }
+
+    protected async buildToolMessages(toolCalls: any[] = [], tools: IPromptTool[] = []){
+        const toolMessages: any[] = []
+
+        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: IPromptParams): Promise<IPromptResponse> {
 
         if(!input.systemPrompt){
@@ -242,25 +311,49 @@ class OpenAiProvider implements IAIProvider{
         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 chatCompletion = await this.client.chat.completions.create({
-                messages: [
-                    {role: 'system', content: systemPrompt},
-                    ...this.mapHistory(input.history),
-                    {role: 'user', content: userInput},
-                ],
-
-                ...(input.zodSchema ? {response_format: zodResponseFormat(input.zodSchema, "event")} : {}),
-                ...(input.jsonSchema ? {response_format: input.jsonSchema} : {}),
-                model: model,
-            });
+            const messages: any[] = [
+                {role: 'system', content: systemPrompt},
+                ...this.mapHistory(input.history),
+                {role: 'user', content: userInput},
+            ]
+            const tools = input.tools ?? []
+            const maxIterations = input.toolMaxIterations ?? 5
+            let output: any
+
+            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))
+            }
 
-            const output = chatCompletion.choices[0].message.content
-            const tokens = chatCompletion.usage.total_tokens
-            const inputTokens = chatCompletion.usage.prompt_tokens
-            const outputTokens = chatCompletion.usage.completion_tokens
+            if(output === undefined){
+                throw new Error(`Tool max iterations reached: ${maxIterations}`)
+            }
 
             const endTime = performance.now()
             const time = endTime - startTime

package/test/OpenAiProvider.test.ts

@@ -1,11 +1,66 @@
-import {describe, test, expect} from 'vitest'
+import {describe, test, expect, beforeAll, afterAll} from 'vitest'
 import {OpenAiProvider, OpenAiProviderFactory} from "../src";
 import z from "zod";
-import {IPromptMemory, IPromptMessage} from "../src/interfaces/IAIProvider";
+import {IPromptMemory, IPromptMessage, IPromptTool} from "../src/interfaces/IAIProvider";
+import {TestSetup} from "./setup/TestSetup";
+import {existsSync, readFileSync} from "fs";
+import * as path from "path";
+
+function loadEnvFile(){
+    const envPaths = [
+        path.resolve(process.cwd(), ".env"),
+        path.resolve(process.cwd(), "packages/ai/ai-back/.env"),
+    ]
+    const envPath = envPaths.find(filePath => existsSync(filePath))
+
+    if(!envPath){
+        return
+    }
+
+    const envContent = readFileSync(envPath, "utf8")
+
+    for(const line of envContent.split(/\r?\n/)){
+        const trimmedLine = line.trim()
+
+        if(!trimmedLine || trimmedLine.startsWith("#")){
+            continue
+        }
+
+        const separatorIndex = trimmedLine.indexOf("=")
+
+        if(separatorIndex === -1){
+            continue
+        }
+
+        const key = trimmedLine.slice(0, separatorIndex).trim()
+        let value = trimmedLine.slice(separatorIndex + 1).trim()
+
+        if((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))){
+            value = value.slice(1, -1)
+        }
+
+        if(process.env[key] === undefined || process.env[key] === ""){
+            process.env[key] = value
+        }
+    }
+}
+
+loadEnvFile()
 
 
 describe('OpenAi Test', () => {
 
+    let testSetup = new TestSetup("mongo")
+
+    beforeAll(async () => {
+        await testSetup.setup()
+    })
+
+    afterAll(async () => {
+        await testSetup.dropAndClose()
+        return
+    })
+
     test('OpenAi prompt supports image inputs and vision model fallback', async () => {
         let request: any
 
@@ -97,6 +152,94 @@ describe('OpenAi Test', () => {
         })
     })
 
+    test('OpenAi prompt executes tools and sends tool output back to model', async () => {
+        const requests: any[] = []
+        const weatherTool: IPromptTool = {
+            name: 'get_weather',
+            description: 'Get weather for a city',
+            parameters: {
+                type: 'object',
+                properties: {
+                    city: {type: 'string'}
+                },
+                required: ['city'],
+                additionalProperties: false
+            },
+            execute: async ({city}) => ({city, temperature: 21})
+        }
+
+        class MockedOpenAiProvider extends OpenAiProvider {
+            constructor() {
+                super('test-key', 'gpt-4.1-mini')
+                this._client = {
+                    chat: {
+                        completions: {
+                            create: async (payload: any) => {
+                                requests.push(payload)
+
+                                if(requests.length === 1){
+                                    return {
+                                        choices: [{
+                                            message: {
+                                                role: 'assistant',
+                                                content: null,
+                                                tool_calls: [{
+                                                    id: 'call_123',
+                                                    type: 'function',
+                                                    function: {
+                                                        name: 'get_weather',
+                                                        arguments: '{"city":"Buenos Aires"}'
+                                                    }
+                                                }]
+                                            }
+                                        }],
+                                        usage: {
+                                            total_tokens: 15,
+                                            prompt_tokens: 10,
+                                            completion_tokens: 5
+                                        }
+                                    }
+                                }
+
+                                return {
+                                    choices: [{message: {role: 'assistant', content: '21 grados'}}],
+                                    usage: {
+                                        total_tokens: 9,
+                                        prompt_tokens: 7,
+                                        completion_tokens: 2
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        const openAi = new MockedOpenAiProvider()
+        const r = await openAi.prompt({
+            systemPrompt: 'You are an AI assistant.',
+            userInput: 'How is the weather in Buenos Aires?',
+            tools: [weatherTool]
+        })
+
+        expect(r.output).toBe('21 grados')
+        expect(r.tokens).toBe(24)
+        expect(requests[0].tools).toEqual([{
+            type: 'function',
+            function: {
+                name: 'get_weather',
+                description: 'Get weather for a city',
+                parameters: weatherTool.parameters
+            }
+        }])
+        expect(requests[1].messages[3]).toEqual({
+            role: 'tool',
+            tool_call_id: 'call_123',
+            content: '{"city":"Buenos Aires","temperature":21}'
+        })
+    })
+
     test('OpenAi Factory', () => {
         const openAi = OpenAiProviderFactory.instance()
         expect(openAi).toBeInstanceOf(OpenAiProvider)

package/test/setup/MongoInMemory.ts

@@ -0,0 +1,53 @@
+import {mongoose} from '@drax/common-back';
+import {MongoMemoryServer} from 'mongodb-memory-server';
+
+class MongoInMemory {
+
+    mongoServer: MongoMemoryServer
+
+    async connect() {
+        this.mongoServer = await MongoMemoryServer.create();
+        if (this.mongoServer.state == "new") {
+            await this.mongoServer.start()
+        }
+        if (!mongoose.connection.readyState) {
+            await mongoose.connect(this.mongoServer.getUri(), {dbName: "verifyMASTER"});
+        }
+        return
+    }
+
+    get mongooseStatus() {
+        return mongoose.connection.readyState
+    }
+
+    get serverStatus() {
+        return this.mongoServer.state
+    }
+
+    get status() {
+        return mongoose.connection.readyState
+    }
+
+    async disconnect() {
+        await mongoose.disconnect();
+    }
+
+    async dropData() {
+        const collections = await mongoose.connection.listCollections()
+        for (let collection of collections) {
+            console.log(`Dropping collection: ${collection.name}`)
+            await mongoose.connection.dropCollection(collection.name)
+        }
+
+    }
+
+    async dropAndClose() {
+        if (this.mongoServer) {
+            await mongoose.connection.dropDatabase();
+            await mongoose.connection.close();
+            await this.mongoServer.stop();
+        }
+    }
+}
+
+export default MongoInMemory