@drax/ai-back 3.40.0 → 3.41.0

package/dist/config/DeepSeekConfig.js

@@ -0,0 +1,9 @@
+var DeepSeekConfig;
+(function (DeepSeekConfig) {
+    DeepSeekConfig["DeepSeekApiKey"] = "DEEPSEEK_API_KEY";
+    DeepSeekConfig["DeepSeekModel"] = "DEEPSEEK_MODEL";
+    DeepSeekConfig["DeepSeekBaseUrl"] = "DEEPSEEK_BASE_URL";
+    DeepSeekConfig["DeepSeekVisionModel"] = "DEEPSEEK_VISION_MODEL";
+})(DeepSeekConfig || (DeepSeekConfig = {}));
+export default DeepSeekConfig;
+export { DeepSeekConfig };

package/dist/factory/AiProviderFactory.js

@@ -1,6 +1,7 @@
 import OpenAiProviderFactory from "./OpenAiProviderFactory.js";
 import GoogleAiProviderFactory from "./GoogleAiProviderFactory.js";
 import OllamaAiProviderFactory from "./OllamaAiProviderFactory.js";
+import DeepSeekProviderFactory from "./DeepSeekProviderFactory.js";
 class AiProviderFactory {
     static instance(provider = 'OpenAi') {
         if (!AiProviderFactory.singletons[provider]) {
@@ -14,6 +15,9 @@ class AiProviderFactory {
                 case 'OllamaAi':
                     AiProviderFactory.singletons[provider] = OllamaAiProviderFactory.instance();
                     break;
+                case 'DeepSeek':
+                    AiProviderFactory.singletons[provider] = DeepSeekProviderFactory.instance();
+                    break;
                 default:
                     throw new Error(`Unsupported AI provider: ${provider}`);
             }

package/dist/factory/DeepSeekProviderFactory.js

@@ -0,0 +1,14 @@
+import { DraxConfig } from "@drax/common-back";
+import DeepSeekConfig from "../config/DeepSeekConfig.js";
+import DeepSeekProvider from "../providers/DeepSeekProvider.js";
+import AILogServiceFactory from "./services/AILogServiceFactory.js";
+class DeepSeekProviderFactory {
+    static instance() {
+        if (!DeepSeekProviderFactory.singleton) {
+            DeepSeekProviderFactory.singleton = new DeepSeekProvider(DraxConfig.getOrLoad(DeepSeekConfig.DeepSeekApiKey), DraxConfig.getOrLoad(DeepSeekConfig.DeepSeekModel), DraxConfig.getOrLoad(DeepSeekConfig.DeepSeekBaseUrl, "string", "https://api.deepseek.com"), DraxConfig.getOrLoad(DeepSeekConfig.DeepSeekVisionModel), AILogServiceFactory.instance);
+        }
+        return DeepSeekProviderFactory.singleton;
+    }
+}
+export default DeepSeekProviderFactory;
+export { DeepSeekProviderFactory };

package/dist/index.js

@@ -1,6 +1,7 @@
 import { OpenAiConfig } from "./config/OpenAiConfig.js";
 import { GoogleAiConfig } from "./config/GoogleAiConfig.js";
 import { OllamaAiConfig } from "./config/OllamaAiConfig.js";
+import { DeepSeekConfig } from "./config/DeepSeekConfig.js";
 import { AILogSchema, AILogBaseSchema } from "./schemas/AILogSchema.js";
 import AILogModel from "./models/AILogModel.js";
 import AILogMongoRepository from "./repository/mongo/AILogMongoRepository.js";
@@ -8,12 +9,14 @@ 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 { DeepSeekProviderFactory } from "./factory/DeepSeekProviderFactory.js";
 import { AiProviderFactory } from "./factory/AiProviderFactory.js";
 import { DraxAgentFactory } from "./factory/DraxAgentFactory.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 { DeepSeekProvider } from "./providers/DeepSeekProvider.js";
 import { BuilderTool } from "./tools/BuilderTool.js";
 import { KnowledgeService } from "./services/KnowledgeService.js";
 import { AILogService } from "./services/AILogService.js";
@@ -31,7 +34,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, GoogleAiConfig, OllamaAiConfig, AILogSchema, AILogBaseSchema, AILogModel, AILogMongoRepository, AILogSqliteRepository, OpenAiProviderFactory, GoogleAiProviderFactory, OllamaAiProviderFactory, AiProviderFactory, DraxAgentFactory, AILogServiceFactory, OpenAiProvider, GoogleAiProvider, OllamaAiProvider, BuilderTool, 
+export { OpenAiConfig, GoogleAiConfig, OllamaAiConfig, DeepSeekConfig, AILogSchema, AILogBaseSchema, AILogModel, AILogMongoRepository, AILogSqliteRepository, OpenAiProviderFactory, GoogleAiProviderFactory, OllamaAiProviderFactory, DeepSeekProviderFactory, AiProviderFactory, DraxAgentFactory, AILogServiceFactory, OpenAiProvider, GoogleAiProvider, OllamaAiProvider, DeepSeekProvider, BuilderTool, 
 //Service
 KnowledgeService, AILogService, 
 //Permissions

package/dist/providers/DeepSeekProvider.js

@@ -0,0 +1,34 @@
+import OpenAI from "openai";
+import OpenAiProvider from "./OpenAiProvider.js";
+class DeepSeekProvider extends OpenAiProvider {
+    constructor(apiKey, model, baseUrl = "https://api.deepseek.com", visionModel, aiLogService) {
+        if (!apiKey) {
+            throw new Error("DeepSeek apiKey required");
+        }
+        if (!model) {
+            throw new Error("DeepSeek model required");
+        }
+        super(apiKey, model, visionModel, aiLogService);
+        if (!baseUrl) {
+            throw new Error("DeepSeek baseUrl required");
+        }
+        this._baseUrl = baseUrl;
+    }
+    get client() {
+        if (!this._client) {
+            this._client = new OpenAI({
+                apiKey: this._apiKey,
+                baseURL: this._baseUrl,
+            });
+        }
+        return this._client;
+    }
+    buildLogPayload(input, params) {
+        return {
+            ...super.buildLogPayload(input, params),
+            provider: "deepseek",
+        };
+    }
+}
+export default DeepSeekProvider;
+export { DeepSeekProvider };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.40.0",
+  "version": "3.41.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": "1165402155066a0da2db001923dd138ec774f8f7"
+  "gitHead": "21f6bdb9f6cc6da6c74dee8aef275d8f88755dd4"
 }

package/src/config/DeepSeekConfig.ts

@@ -0,0 +1,14 @@
+
+enum DeepSeekConfig {
+
+    DeepSeekApiKey = "DEEPSEEK_API_KEY",
+    DeepSeekModel = "DEEPSEEK_MODEL",
+    DeepSeekBaseUrl = "DEEPSEEK_BASE_URL",
+    DeepSeekVisionModel = "DEEPSEEK_VISION_MODEL",
+
+}
+
+
+export default DeepSeekConfig;
+
+export {DeepSeekConfig}

package/src/factory/AiProviderFactory.ts

@@ -2,6 +2,7 @@ import type {IAIProvider} from "../interfaces/IAIProvider"
 import OpenAiProviderFactory from "./OpenAiProviderFactory.js";
 import GoogleAiProviderFactory from "./GoogleAiProviderFactory.js";
 import OllamaAiProviderFactory from "./OllamaAiProviderFactory.js";
+import DeepSeekProviderFactory from "./DeepSeekProviderFactory.js";
 
 class AiProviderFactory {
     private static singletons: Record<string, IAIProvider> = {};
@@ -18,6 +19,9 @@ class AiProviderFactory {
                 case 'OllamaAi':
                     AiProviderFactory.singletons[provider] =  OllamaAiProviderFactory.instance()
                     break;
+                case 'DeepSeek':
+                    AiProviderFactory.singletons[provider] =  DeepSeekProviderFactory.instance()
+                    break;
                 default:
                     throw new Error(`Unsupported AI provider: ${provider}`);
             }

package/src/factory/DeepSeekProviderFactory.ts

@@ -0,0 +1,27 @@
+import {DraxConfig} from "@drax/common-back";
+import DeepSeekConfig from "../config/DeepSeekConfig.js";
+import type {IAIProvider} from "../interfaces/IAIProvider"
+import DeepSeekProvider from "../providers/DeepSeekProvider.js";
+import AILogServiceFactory from "./services/AILogServiceFactory.js";
+
+class DeepSeekProviderFactory {
+    private static singleton: IAIProvider;
+
+    public static instance(): IAIProvider {
+        if (!DeepSeekProviderFactory.singleton) {
+            DeepSeekProviderFactory.singleton = new DeepSeekProvider(
+                DraxConfig.getOrLoad(DeepSeekConfig.DeepSeekApiKey),
+                DraxConfig.getOrLoad(DeepSeekConfig.DeepSeekModel),
+                DraxConfig.getOrLoad(DeepSeekConfig.DeepSeekBaseUrl, "string", "https://api.deepseek.com"),
+                DraxConfig.getOrLoad(DeepSeekConfig.DeepSeekVisionModel),
+                AILogServiceFactory.instance
+            );
+        }
+        return DeepSeekProviderFactory.singleton;
+    }
+}
+
+export default DeepSeekProviderFactory
+export {
+    DeepSeekProviderFactory
+}

package/src/index.ts

@@ -1,6 +1,7 @@
 import {OpenAiConfig} from "./config/OpenAiConfig.js";
 import {GoogleAiConfig} from "./config/GoogleAiConfig.js";
 import {OllamaAiConfig} from "./config/OllamaAiConfig.js";
+import {DeepSeekConfig} from "./config/DeepSeekConfig.js";
 import {AILogSchema, AILogBaseSchema} from "./schemas/AILogSchema.js";
 import AILogModel from "./models/AILogModel.js";
 import AILogMongoRepository from "./repository/mongo/AILogMongoRepository.js";
@@ -8,12 +9,14 @@ 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 {DeepSeekProviderFactory} from "./factory/DeepSeekProviderFactory.js";
 import {AiProviderFactory} from "./factory/AiProviderFactory.js";
 import {DraxAgentFactory} from "./factory/DraxAgentFactory.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 {DeepSeekProvider} from "./providers/DeepSeekProvider.js";
 import {BuilderTool} from "./tools/BuilderTool.js";
 import {KnowledgeService} from "./services/KnowledgeService.js";
 import {AILogService} from "./services/AILogService.js";
@@ -104,6 +107,7 @@ export {
     OpenAiConfig,
     GoogleAiConfig,
     OllamaAiConfig,
+    DeepSeekConfig,
     AILogSchema,
     AILogBaseSchema,
     AILogModel,
@@ -112,12 +116,14 @@ export {
     OpenAiProviderFactory,
     GoogleAiProviderFactory,
     OllamaAiProviderFactory,
+    DeepSeekProviderFactory,
     AiProviderFactory,
     DraxAgentFactory,
     AILogServiceFactory,
     OpenAiProvider,
     GoogleAiProvider,
     OllamaAiProvider,
+    DeepSeekProvider,
     BuilderTool,
     //Service
     KnowledgeService,

package/src/providers/DeepSeekProvider.ts

@@ -0,0 +1,58 @@
+import OpenAI from "openai";
+import type {IAILogBase} from "@drax/ai-share";
+import type {IPromptParams} from "../interfaces/IAIProvider.js";
+import type {AILogService} from "../services/AILogService.js";
+import OpenAiProvider from "./OpenAiProvider.js";
+
+class DeepSeekProvider extends OpenAiProvider{
+    protected _baseUrl: string
+
+    constructor(apiKey: string, model: string, baseUrl: string = "https://api.deepseek.com", visionModel?: string, aiLogService?: AILogService) {
+        if (!apiKey) {
+            throw new Error("DeepSeek apiKey required")
+        }
+        if (!model) {
+            throw new Error("DeepSeek model required")
+        }
+
+        super(apiKey, model, visionModel, aiLogService)
+
+        if (!baseUrl) {
+            throw new Error("DeepSeek baseUrl required")
+        }
+
+        this._baseUrl = baseUrl
+    }
+
+    get client(){
+        if(!this._client){
+            this._client = new OpenAI({
+                apiKey: this._apiKey,
+                baseURL: this._baseUrl,
+            });
+        }
+
+        return this._client
+    }
+
+    protected buildLogPayload(input: IPromptParams, params: {
+        model: string,
+        systemPrompt: string,
+        startedAt: Date,
+        endedAt?: Date,
+        inputTokens?: number,
+        outputTokens?: number,
+        tokens?: number,
+        output?: unknown,
+        success: boolean,
+        errorMessage?: string,
+    }): IAILogBase {
+        return {
+            ...super.buildLogPayload(input, params),
+            provider: "deepseek",
+        }
+    }
+}
+
+export default DeepSeekProvider
+export {DeepSeekProvider}

package/test/DeepSeekProvider.test.ts

@@ -0,0 +1,146 @@
+import {describe, expect, test} from "vitest";
+import {AiProviderFactory, DeepSeekProvider} from "../src";
+import {IPromptTool} from "../src/interfaces/IAIProvider";
+
+describe("DeepSeekProvider Test", () => {
+
+    test("DeepSeek prompt uses OpenAI-compatible chat completions", async () => {
+        let request: any
+
+        class MockedDeepSeekProvider extends DeepSeekProvider {
+            constructor() {
+                super("test-key", "deepseek-chat")
+                this._client = {
+                    chat: {
+                        completions: {
+                            create: async (payload: any) => {
+                                request = payload
+                                return {
+                                    choices: [{message: {content: "Buenos Aires"}}],
+                                    usage: {
+                                        total_tokens: 8,
+                                        prompt_tokens: 6,
+                                        completion_tokens: 2
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        const deepSeek = new MockedDeepSeekProvider()
+
+        const r = await deepSeek.prompt({
+            systemPrompt: "You are an AI assistant.",
+            userInput: "What is the capital of Argentina?"
+        })
+
+        expect(r.output).toBe("Buenos Aires")
+        expect(request.model).toBe("deepseek-chat")
+        expect(request.messages[1]).toEqual({
+            role: "user",
+            content: "What is the capital of Argentina?"
+        })
+    })
+
+    test("DeepSeek prompt executes tools through OpenAI-compatible tool calls", 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 MockedDeepSeekProvider extends DeepSeekProvider {
+            constructor() {
+                super("test-key", "deepseek-chat")
+                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 deepSeek = new MockedDeepSeekProvider()
+        const r = await deepSeek.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("AiProviderFactory supports DeepSeek option", () => {
+        process.env.DEEPSEEK_API_KEY = "test-key"
+        process.env.DEEPSEEK_MODEL = "deepseek-chat"
+        process.env.DEEPSEEK_BASE_URL = "https://api.deepseek.com"
+        process.env.DEEPSEEK_VISION_MODEL = "deepseek-chat"
+        process.env.DRAX_DB_ENGINE = "mongo"
+
+        const deepSeek = AiProviderFactory.instance("DeepSeek")
+        expect(deepSeek).toBeInstanceOf(DeepSeekProvider)
+    })
+})