@drax/ai-back 3.54.1 → 3.57.0

package/src/providers/ai/AbstractAiProvider.ts

@@ -3,6 +3,7 @@ import type {
     IAIProvider,
     IPromptParams,
     IPromptResponse,
+    IPromptTool,
 } from "../../interfaces/IAIProvider.js";
 import type {AILogService} from "../../services/AILogService.js";
 
@@ -30,6 +31,74 @@ abstract class AbstractAiProvider implements IAIProvider {
 
     abstract prompt(input: IPromptParams): Promise<IPromptResponse>
 
+    protected buildSystemPrompt(input: IPromptParams){
+        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')}`
+        }
+
+        return systemPrompt
+    }
+
+    protected resolvePromptModel(input: IPromptParams, model: string, visionModel?: string){
+        return input.model ?? (this.hasImageInput(input) ? visionModel ?? model : model)
+    }
+
+    protected getDefaultToolParameters(){
+        return {
+            type: "object",
+            properties: {},
+            additionalProperties: false,
+        }
+    }
+
+    protected findToolOrThrow(toolName: string | undefined, tools: IPromptTool[] = []){
+        const tool = tools.find(t => t.name === toolName)
+
+        if(!tool){
+            throw new Error(`Tool not found: ${toolName}`)
+        }
+
+        return tool
+    }
+
+    protected parseToolArguments(args: string | object | undefined){
+        if(!args){
+            return {}
+        }
+
+        if(typeof args === "object"){
+            return args
+        }
+
+        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 hasImageInput(input: IPromptParams){
         if(input.userImages && input.userImages.length > 0){
             return true

package/src/providers/ai/DeepSeekAiProvider.ts

@@ -1,9 +1,22 @@
 import OpenAI from "openai";
+import {toJSONSchema} from "zod";
+import type {
+    IPromptContentPart,
+    IPromptMessage,
+    IPromptParams,
+    IPromptResponse,
+    IPromptTool
+} from "../../interfaces/IAIProvider.js";
 import type {AILogService} from "../../services/AILogService.js";
-import OpenAiProvider from "./OpenAiProvider.js";
+import PromptAudioService from "../../services/PromptAudioService.js";
+import AbstractAiProvider from "./AbstractAiProvider.js";
 
-class DeepSeekAiProvider extends OpenAiProvider{
+class DeepSeekAiProvider extends AbstractAiProvider{
+    protected _apiKey: string
+    protected _model: any
     protected _baseUrl: string
+    protected _visionModel?: string
+    protected _client: any
 
     constructor(apiKey: string, model: string, baseUrl: string = "https://api.deepseek.com", visionModel?: string, aiLogService?: AILogService) {
         if (!apiKey) {
@@ -12,14 +25,23 @@ class DeepSeekAiProvider extends OpenAiProvider{
         if (!model) {
             throw new Error("DeepSeek model required")
         }
-
-        super(apiKey, model, visionModel, aiLogService, "deepseek")
-
         if (!baseUrl) {
             throw new Error("DeepSeek baseUrl required")
         }
 
+        super("deepseek", aiLogService)
+
+        this._apiKey = apiKey
+        this._model = model
         this._baseUrl = baseUrl
+        this._visionModel = visionModel
+    }
+
+    get model(){
+        if(!this._model){
+            throw new Error("DeepSeek model not found")
+        }
+        return this._model;
     }
 
     get client(){
@@ -33,6 +55,242 @@ class DeepSeekAiProvider extends OpenAiProvider{
         return this._client
     }
 
+    protected get visionModel(){
+        return this._visionModel
+    }
+
+    protected buildUserContent(input: IPromptParams): string | Array<{type: 'text', text: string} | {type: 'image_url', image_url: {url: string, detail?: 'auto' | 'low' | 'high'}}> {
+        if(input.userContent && input.userContent.length > 0){
+            return this.mapContentParts(input.userContent)
+        }
+
+        if(input.userImages && input.userImages.length > 0){
+            const content: Array<{type: 'text', text: string} | {type: 'image_url', image_url: {url: string, detail?: 'auto' | 'low' | 'high'}}> = []
+
+            if(input.userInput){
+                content.push({type: 'text', text: input.userInput})
+            }
+
+            content.push(...input.userImages.map(image => ({
+                type: 'image_url' as const,
+                image_url: {
+                    url: image.url,
+                    ...(image.detail ? {detail: image.detail} : {}),
+                }
+            })))
+
+            return content
+        }
+
+        return input.userInput ?? ""
+    }
+
+    protected mapContentParts(content: IPromptContentPart[]){
+        return content.map(part => {
+            if(part.type === 'text'){
+                return {
+                    type: 'text' as const,
+                    text: part.text
+                }
+            }
+
+            return {
+                type: 'image_url' as const,
+                image_url: {
+                    url: part.imageUrl,
+                    ...(part.detail ? {detail: part.detail} : {}),
+                }
+            }
+        })
+    }
+
+    protected mapHistory(history: IPromptMessage[] = []){
+        return history.map(message => ({
+            role: message.role,
+            content: typeof message.content === 'string'
+                ? message.content
+                : this.mapContentParts(message.content)
+        }))
+    }
+
+    async generateEmbedding({text, model="text-embedding-ada-002"}: {text:string,model:string }): Promise<number[]> {
+        const response = await this.client.embeddings.create({
+            model: model,
+            input: text,
+        });
+        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 ?? this.getDefaultToolParameters(),
+            },
+        }))
+    }
+
+    protected normalizeJsonSchema(input: IPromptParams){
+        if(input.zodSchema){
+            return toJSONSchema(input.zodSchema, {
+                target: "draft-7",
+            })
+        }
+
+        if(!input.jsonSchema){
+            return undefined
+        }
+
+        const jsonSchema: any = input.jsonSchema
+
+        if(jsonSchema.type === "json_schema" && jsonSchema.json_schema?.schema){
+            return jsonSchema.json_schema.schema
+        }
+
+        if(jsonSchema.type === "json_object"){
+            return undefined
+        }
+
+        return jsonSchema
+    }
+
+    protected normalizeResponseFormat(input: IPromptParams){
+        if(input.zodSchema || input.jsonSchema){
+            return {type: "json_object" as const}
+        }
+
+        return undefined
+    }
+
+    protected buildDeepSeekSystemPrompt(input: IPromptParams){
+        const systemPrompt = this.buildSystemPrompt(input)
+        const jsonSchema = this.normalizeJsonSchema(input)
+
+        if(!jsonSchema){
+            return systemPrompt
+        }
+
+        return `${systemPrompt}
+
+Respond only with valid JSON matching this JSON Schema. Do not wrap the response in markdown or include any extra text.
+
+JSON Schema:
+${JSON.stringify(jsonSchema, null, 2)}`
+    }
+
+    protected async buildToolMessages(toolCalls: any[] = [], tools: IPromptTool[] = []){
+        const toolMessages: any[] = []
+
+        for(const toolCall of toolCalls){
+            const toolName = toolCall.function?.name
+            const tool = this.findToolOrThrow(toolName, tools)
+
+            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> {
+
+        const systemPrompt = this.buildDeepSeekSystemPrompt(input)
+        const userInput = this.buildUserContent(input)
+        const model = this.resolvePromptModel(input, this.model, this.visionModel)
+        const startedAt = new Date()
+        const startTime = performance.now()
+        let tokens = 0
+        let inputTokens = 0
+        let outputTokens = 0
+
+        try {
+            const messages: any[] = [
+                {role: 'system', content: systemPrompt},
+                ...this.mapHistory(input.history),
+                {role: 'user', content: userInput},
+            ]
+            const tools = input.tools ?? []
+            const maxIterations = input.toolMaxIterations ?? 5
+            const responseFormat = this.normalizeResponseFormat(input)
+            let output: any
+
+            for(let iteration = 0; iteration < maxIterations; iteration++){
+                const chatCompletion = await this.client.chat.completions.create({
+                    messages,
+
+                    ...(responseFormat ? {response_format: responseFormat} : {}),
+                    ...(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()
+            const audio = await PromptAudioService.build(input, output)
+
+            await this.registerPromptLog(input, {
+                model,
+                systemPrompt,
+                startedAt,
+                endedAt,
+                inputTokens,
+                outputTokens,
+                tokens,
+                output,
+                success: true,
+            })
+
+            return {
+                output,
+                tokens,
+                inputTokens,
+                outputTokens,
+                time,
+                ...(audio ? {audio} : {}),
+            }
+        } catch (e: any) {
+            const endedAt = new Date()
+
+            await this.registerPromptLog(input, {
+                model,
+                systemPrompt,
+                startedAt,
+                endedAt,
+                success: false,
+                errorMessage: e?.message,
+            })
+
+            throw e
+        }
+    }
 }
 
 export default DeepSeekAiProvider

package/src/providers/ai/GoogleAiProvider.ts

@@ -185,11 +185,7 @@ class GoogleAiProvider extends AbstractAiProvider{
             functionDeclarations: tools.map(tool => ({
                 name: tool.name,
                 description: tool.description,
-                parametersJsonSchema: tool.parameters ?? {
-                    type: "object",
-                    properties: {},
-                    additionalProperties: false,
-                },
+                parametersJsonSchema: tool.parameters ?? this.getDefaultToolParameters(),
             }))
         }]
     }
@@ -238,11 +234,7 @@ class GoogleAiProvider extends AbstractAiProvider{
 
         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 tool = this.findToolOrThrow(toolName, tools)
 
             const output = await tool.execute(functionCall.args ?? {})
 
@@ -271,23 +263,9 @@ class GoogleAiProvider extends AbstractAiProvider{
 
     async prompt(input: IPromptParams): Promise<IPromptResponse> {
 
-        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 systemPrompt = this.buildSystemPrompt(input)
         const userInput = this.buildUserContent(input)
-        const model = input.model ?? (this.hasImageInput(input) ? this.visionModel ?? this.model : this.model)
+        const model = this.resolvePromptModel(input, this.model, this.visionModel)
         const startedAt = new Date()
         const startTime = performance.now()
         let tokens = 0

package/src/providers/ai/OllamaAiProvider.ts

@@ -168,11 +168,7 @@ class OllamaAiProvider extends AbstractAiProvider{
             function: {
                 name: tool.name,
                 description: tool.description,
-                parameters: tool.parameters ?? {
-                    type: "object",
-                    properties: {},
-                    additionalProperties: false,
-                },
+                parameters: tool.parameters ?? this.getDefaultToolParameters(),
             },
         }))
     }
@@ -197,44 +193,12 @@ class OllamaAiProvider extends AbstractAiProvider{
         return jsonSchema
     }
 
-    protected parseToolArguments(args: string | object | undefined){
-        if(!args){
-            return {}
-        }
-
-        if(typeof args === "object"){
-            return args
-        }
-
-        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: OllamaToolCall[] = [], tools: IPromptTool[] = []){
         const toolMessages: OllamaMessage[] = []
 
         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 tool = this.findToolOrThrow(toolName, tools)
 
             const args = this.parseToolArguments(toolCall.function?.arguments)
             const output = await tool.execute(args)
@@ -251,21 +215,8 @@ class OllamaAiProvider extends AbstractAiProvider{
 
     async prompt(input: IPromptParams): Promise<IPromptResponse> {
 
-        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 systemPrompt = this.buildSystemPrompt(input)
+        const model = this.resolvePromptModel(input, this.model, this.visionModel)
         const startedAt = new Date()
         const startTime = performance.now()
         let tokens = 0

package/src/providers/ai/OpenAiProvider.ts

@@ -122,49 +122,17 @@ class OpenAiProvider extends AbstractAiProvider{
             function: {
                 name: tool.name,
                 description: tool.description,
-                parameters: tool.parameters ?? {
-                    type: "object",
-                    properties: {},
-                    additionalProperties: false,
-                },
+                parameters: tool.parameters ?? this.getDefaultToolParameters(),
             },
         }))
     }
 
-    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 tool = this.findToolOrThrow(toolName, tools)
 
             const args = this.parseToolArguments(toolCall.function?.arguments)
             const output = await tool.execute(args)
@@ -181,23 +149,9 @@ class OpenAiProvider extends AbstractAiProvider{
 
     async prompt(input: IPromptParams): Promise<IPromptResponse> {
 
-        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 systemPrompt = this.buildSystemPrompt(input)
         const userInput = this.buildUserContent(input)
-        const model = input.model ?? (this.hasImageInput(input) ? this.visionModel ?? this.model : this.model)
+        const model = this.resolvePromptModel(input, this.model, this.visionModel)
         const startedAt = new Date()
         const startTime = performance.now()
         let tokens = 0

package/test/DeepSeekProvider.test.ts

@@ -1,4 +1,5 @@
 import {describe, expect, test} from "vitest";
+import {z} from "zod";
 import {AiProviderFactory, DeepSeekAiProvider} from "../src";
 import {IPromptTool} from "../src/interfaces/IAIProvider";
 
@@ -45,6 +46,99 @@ describe("DeepSeekProvider Test", () => {
         })
     })
 
+    test("DeepSeek prompt falls back from OpenAI json_schema to json_object with schema instructions", async () => {
+        let request: any
+
+        class MockedDeepSeekProvider extends DeepSeekAiProvider {
+            constructor() {
+                super("test-key", "deepseek-chat")
+                this._client = {
+                    chat: {
+                        completions: {
+                            create: async (payload: any) => {
+                                request = payload
+                                return {
+                                    choices: [{message: {content: "{\"name\":\"Pikachu\"}"}}],
+                                    usage: {
+                                        total_tokens: 8,
+                                        prompt_tokens: 6,
+                                        completion_tokens: 2
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        const jsonSchema = {
+            type: "json_schema",
+            json_schema: {
+                name: "element_description",
+                schema: {
+                    type: "object",
+                    properties: {
+                        name: {type: "string"}
+                    },
+                    required: ["name"]
+                }
+            }
+        }
+
+        const deepSeek = new MockedDeepSeekProvider()
+        await deepSeek.prompt({
+            systemPrompt: "You are an AI assistant.",
+            userInput: "What is the most famous pokemon?",
+            jsonSchema,
+        })
+
+        expect(request.response_format).toEqual({type: "json_object"})
+        expect(request.messages[0].content).toContain("Respond only with valid JSON")
+        expect(request.messages[0].content).toContain("\"required\": [")
+        expect(request.messages[0].content).toContain("\"name\"")
+    })
+
+    test("DeepSeek prompt falls back from zod schema to json_object with generated schema instructions", async () => {
+        let request: any
+
+        class MockedDeepSeekProvider extends DeepSeekAiProvider {
+            constructor() {
+                super("test-key", "deepseek-chat")
+                this._client = {
+                    chat: {
+                        completions: {
+                            create: async (payload: any) => {
+                                request = payload
+                                return {
+                                    choices: [{message: {content: "{\"name\":\"Pikachu\"}"}}],
+                                    usage: {
+                                        total_tokens: 8,
+                                        prompt_tokens: 6,
+                                        completion_tokens: 2
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        const deepSeek = new MockedDeepSeekProvider()
+        await deepSeek.prompt({
+            systemPrompt: "You are an AI assistant.",
+            userInput: "What is the most famous pokemon?",
+            zodSchema: z.object({
+                name: z.string(),
+            }),
+        })
+
+        expect(request.response_format).toEqual({type: "json_object"})
+        expect(request.messages[0].content).toContain("JSON Schema")
+        expect(request.messages[0].content).toContain("\"name\"")
+    })
+
     test("DeepSeek prompt executes tools through OpenAI-compatible tool calls", async () => {
         const requests: any[] = []
         const weatherTool: IPromptTool = {