@drax/ai-back 3.51.0 → 3.52.0

package/dist/controllers/AILogController.js

@@ -9,9 +9,9 @@ class AILogController extends AbstractFastifyController {
         this.tenantFilter = true;
         this.tenantSetter = true;
         this.tenantAssert = true;
-        this.userFilter = true;
+        this.userFilter = false;
         this.userSetter = true;
-        this.userAssert = true;
+        this.userAssert = false;
     }
 }
 export default AILogController;

package/dist/models/AILogModel.js

@@ -29,6 +29,7 @@ const AILogSchema = new mongoose.Schema({
     startedAt: { type: Date, required: false, index: false, unique: false },
     endedAt: { type: Date, required: false, index: false, unique: false },
     responseTime: { type: String, required: false, index: false, unique: false },
+    responseTimeMS: { type: Number, required: false, index: false, unique: false },
     output: { type: String, required: false, index: false, unique: false },
     success: { type: Boolean, required: false, index: false, unique: false },
     statusCode: { type: Number, required: false, index: false, unique: false },

package/dist/providers/ai/AbstractAiProvider.js

@@ -0,0 +1,90 @@
+class AbstractAiProvider {
+    constructor(providerName, aiLogService) {
+        this.providerName = providerName;
+        this._aiLogService = aiLogService;
+    }
+    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) {
+        const responseTimeMS = params.endedAt
+            ? params.endedAt.getTime() - params.startedAt.getTime()
+            : undefined;
+        return {
+            provider: this.providerName,
+            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: responseTimeMS !== undefined ? `${responseTimeMS}ms` : undefined,
+            responseTimeMS,
+            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,
+            });
+        }
+    }
+}
+export default AbstractAiProvider;
+export { AbstractAiProvider };

package/dist/providers/ai/DeepSeekAiProvider.js

@@ -8,7 +8,7 @@ class DeepSeekAiProvider extends OpenAiProvider {
         if (!model) {
             throw new Error("DeepSeek model required");
         }
-        super(apiKey, model, visionModel, aiLogService);
+        super(apiKey, model, visionModel, aiLogService, "deepseek");
         if (!baseUrl) {
             throw new Error("DeepSeek baseUrl required");
         }
@@ -23,12 +23,6 @@ class DeepSeekAiProvider extends OpenAiProvider {
         }
         return this._client;
     }
-    buildLogPayload(input, params) {
-        return {
-            ...super.buildLogPayload(input, params),
-            provider: "deepseek",
-        };
-    }
 }
 export default DeepSeekAiProvider;
 export { DeepSeekAiProvider };

package/dist/providers/ai/GoogleAiProvider.js

@@ -1,7 +1,8 @@
 import { GoogleGenAI } from "@google/genai";
 import { toJSONSchema } from "zod";
 import PromptAudioService from "../../services/PromptAudioService.js";
-class GoogleAiProvider {
+import AbstractAiProvider from "./AbstractAiProvider.js";
+class GoogleAiProvider extends AbstractAiProvider {
     constructor(apiKey, model, visionModel, aiLogService) {
         if (!apiKey) {
             throw new Error("Google AI apiKey required");
@@ -9,10 +10,10 @@ class GoogleAiProvider {
         if (!model) {
             throw new Error("Google AI model required");
         }
+        super("googleai", aiLogService);
         this._apiKey = apiKey;
         this._model = model;
         this._visionModel = visionModel;
-        this._aiLogService = aiLogService;
     }
     get model() {
         if (!this._model) {
@@ -120,84 +121,6 @@ class GoogleAiProvider {
             };
         });
     }
-    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,

package/dist/providers/ai/OllamaAiProvider.js

@@ -1,6 +1,7 @@
 import { toJSONSchema } from "zod";
 import PromptAudioService from "../../services/PromptAudioService.js";
-class OllamaAiProvider {
+import AbstractAiProvider from "./AbstractAiProvider.js";
+class OllamaAiProvider extends AbstractAiProvider {
     constructor(baseUrl, model, visionModel, embeddingModel, aiLogService) {
         if (!baseUrl) {
             throw new Error("Ollama AI baseUrl required");
@@ -8,11 +9,11 @@ class OllamaAiProvider {
         if (!model) {
             throw new Error("Ollama AI model required");
         }
+        super("ollamaai", aiLogService);
         this._baseUrl = baseUrl.replace(/\/+$/, "");
         this._model = model;
         this._visionModel = visionModel;
         this._embeddingModel = embeddingModel;
-        this._aiLogService = aiLogService;
     }
     get model() {
         if (!this._model) {
@@ -98,84 +99,6 @@ class OllamaAiProvider {
         }
         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,

package/dist/providers/ai/OpenAiProvider.js

@@ -1,18 +1,19 @@
 import OpenAI from "openai";
 import { zodResponseFormat } from "openai/helpers/zod";
 import PromptAudioService from "../../services/PromptAudioService.js";
-class OpenAiProvider {
-    constructor(apiKey, model, visionModel, aiLogService) {
+import AbstractAiProvider from "./AbstractAiProvider.js";
+class OpenAiProvider extends AbstractAiProvider {
+    constructor(apiKey, model, visionModel, aiLogService, providerName = "openai") {
         if (!apiKey) {
             throw new Error("OpenAI apiKey required");
         }
         if (!model) {
             throw new Error("OpenAI model required");
         }
+        super(providerName, aiLogService);
         this._apiKey = apiKey;
         this._model = model;
         this._visionModel = visionModel;
-        this._aiLogService = aiLogService;
     }
     get model() {
         if (!this._model) {
@@ -76,84 +77,6 @@ class OpenAiProvider {
                 : this.mapContentParts(message.content)
         }));
     }
-    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: "openai",
-            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-ada-002" }) {
         const response = await this.client.embeddings.create({
             model: model,

package/dist/repository/sqlite/AILogSqliteRepository.js

@@ -31,6 +31,7 @@ class AILogSqliteRepository extends AbstractSqliteRepository {
             { name: "startedAt", type: "TEXT", unique: false, primary: false },
             { name: "endedAt", type: "TEXT", unique: false, primary: false },
             { name: "responseTime", type: "TEXT", unique: false, primary: false },
+            { name: "responseTimeMS", type: "REAL", unique: false, primary: false },
             { name: "output", type: "TEXT", unique: false, primary: false },
             { name: "success", type: "TEXT", unique: false, primary: false },
             { name: "statusCode", type: "INTEGER", unique: false, primary: false },

package/dist/routes/AILogRoutes.js

@@ -10,12 +10,12 @@ async function AILogFastifyRoutes(fastify, options) {
     fastify.get('/api/ailog/:id', { schema: schemas.findByIdSchema }, (req, rep) => controller.findById(req, rep));
     fastify.get('/api/ailog/find-one', { schema: schemas.findOneSchema }, (req, rep) => controller.findOne(req, rep));
     fastify.get('/api/ailog/group-by', { schema: schemas.groupBySchema }, (req, rep) => controller.groupBy(req, rep));
-    fastify.post('/api/ailog', { schema: schemas.createSchema }, (req, rep) => controller.create(req, rep));
-    fastify.put('/api/ailog/:id', { schema: schemas.updateSchema }, (req, rep) => controller.update(req, rep));
-    fastify.patch('/api/ailog/:id', { schema: schemas.updateSchema }, (req, rep) => controller.updatePartial(req, rep));
-    fastify.delete('/api/ailog/:id', { schema: schemas.deleteSchema }, (req, rep) => controller.delete(req, rep));
+    // fastify.post('/api/ailog', {schema: schemas.createSchema}, (req,rep) =>controller.create(req,rep))
+    // fastify.put('/api/ailog/:id', {schema: schemas.updateSchema}, (req,rep) =>controller.update(req,rep))
+    // fastify.patch('/api/ailog/:id', {schema: schemas.updateSchema}, (req,rep) =>controller.updatePartial(req,rep))
+    // fastify.delete('/api/ailog/:id', {schema: schemas.deleteSchema}, (req,rep) =>controller.delete(req,rep))
     fastify.get('/api/ailog/export', (req, rep) => controller.export(req, rep));
-    fastify.post('/api/ailog/import', (req, rep) => controller.import(req, rep));
+    // fastify.post('/api/ailog/import', (req,rep) => controller.import(req,rep))
 }
 export default AILogFastifyRoutes;
 export { AILogFastifyRoutes };

package/dist/schemas/AILogSchema.js

@@ -27,6 +27,7 @@ const AILogBaseSchema = z.object({
     startedAt: z.coerce.date().nullable().optional(),
     endedAt: z.coerce.date().nullable().optional(),
     responseTime: z.string().optional(),
+    responseTimeMS: z.number().nullable().optional(),
     output: z.string().optional(),
     success: z.boolean().optional(),
     statusCode: z.number().nullable().optional(),
@@ -38,7 +39,9 @@ const AILogSchema = AILogBaseSchema
     .extend({
     _id: z.coerce.string(),
     tenant: z.object({ _id: z.coerce.string(), name: z.string() }).nullable().optional(),
-    user: z.object({ _id: z.coerce.string(), username: z.string() }).nullable().optional()
+    user: z.object({ _id: z.coerce.string(), username: z.string() }).nullable().optional(),
+    createdAt: z.coerce.date().nullable().optional(),
+    updatedAt: z.coerce.date().nullable().optional(),
 });
 export default AILogSchema;
 export { AILogSchema, AILogBaseSchema };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.51.0",
+  "version": "3.52.0",
   "description": "Ai utils",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -18,7 +18,7 @@
   "author": "Cristian Incarnato & Drax Team",
   "license": "ISC",
   "dependencies": {
-    "@drax/ai-share": "^3.45.0",
+    "@drax/ai-share": "^3.52.0",
     "@drax/crud-back": "^3.51.0",
     "mongoose": "^8.23.0",
     "mongoose-paginate-v2": "^1.8.3"
@@ -46,5 +46,5 @@
     "typescript": "^5.9.3",
     "vitest": "^3.0.8"
   },
-  "gitHead": "62e011454676e3e1d5977be0fcfedba6bd568624"
+  "gitHead": "3c78a6b0da9e2b69b231c57730c450964d532978"
 }

package/src/controllers/AILogController.ts

@@ -15,9 +15,9 @@ class AILogController extends AbstractFastifyController<IAILog, IAILogBase, IAIL
         this.tenantSetter = true;
         this.tenantAssert = true;
 
-        this.userFilter = true;
+        this.userFilter = false;
         this.userSetter = true;
-        this.userAssert = true;
+        this.userAssert = false;
     }
 
 }

package/src/models/AILogModel.ts

@@ -33,6 +33,7 @@ const AILogSchema = new mongoose.Schema<IAILog>({
             startedAt: {type: Date,   required: false, index: false, unique: false },
             endedAt: {type: Date,   required: false, index: false, unique: false },
             responseTime: {type: String,   required: false, index: false, unique: false },
+            responseTimeMS: {type: Number,   required: false, index: false, unique: false },
             output: {type: String,   required: false, index: false, unique: false },
             success: {type: Boolean,   required: false, index: false, unique: false },
             statusCode: {type: Number,   required: false, index: false, unique: false },

package/src/providers/ai/AbstractAiProvider.ts

@@ -0,0 +1,129 @@
+import type {IAILogBase} from "@drax/ai-share";
+import type {
+    IAIProvider,
+    IPromptParams,
+    IPromptResponse,
+} from "../../interfaces/IAIProvider.js";
+import type {AILogService} from "../../services/AILogService.js";
+
+type PromptLogParams = {
+    model: string,
+    systemPrompt: string,
+    startedAt: Date,
+    endedAt?: Date,
+    inputTokens?: number,
+    outputTokens?: number,
+    tokens?: number,
+    output?: unknown,
+    success: boolean,
+    errorMessage?: string,
+}
+
+abstract class AbstractAiProvider implements IAIProvider {
+    protected readonly providerName: string
+    protected _aiLogService?: AILogService
+
+    protected constructor(providerName: string, aiLogService?: AILogService) {
+        this.providerName = providerName
+        this._aiLogService = aiLogService
+    }
+
+    abstract prompt(input: IPromptParams): Promise<IPromptResponse>
+
+    protected hasImageInput(input: IPromptParams){
+        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
+    }
+
+    protected serializePromptInput(input: IPromptParams, systemPrompt: string){
+        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,
+            })),
+        })
+    }
+
+    protected serializePromptOutput(output: unknown){
+        if (typeof output === "string") {
+            return output
+        }
+
+        if (output === null || output === undefined) {
+            return undefined
+        }
+
+        return JSON.stringify(output)
+    }
+
+    protected buildLogPayload(input: IPromptParams, params: PromptLogParams): IAILogBase {
+        const responseTimeMS = params.endedAt
+            ? params.endedAt.getTime() - params.startedAt.getTime()
+            : undefined
+
+        return {
+            provider: this.providerName,
+            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: responseTimeMS !== undefined ? `${responseTimeMS}ms` : undefined,
+            responseTimeMS,
+            output: this.serializePromptOutput(params.output),
+            success: params.success,
+            errorMessage: params.errorMessage,
+            tenant: input.tenant,
+            user: input.user,
+        }
+    }
+
+    protected async registerPromptLog(input: IPromptParams, params: PromptLogParams){
+        if(!this._aiLogService){
+            return
+        }
+
+        try{
+            await this._aiLogService.create(this.buildLogPayload(input, params))
+        }catch(e: any){
+            console.error("Error registerPromptLog", {
+                name: e?.name,
+                message: e?.message,
+                stack: e?.stack,
+            })
+        }
+    }
+}
+
+export default AbstractAiProvider
+export {AbstractAiProvider}