@drax/ai-back 3.0.0 → 3.16.0

package/dist/config/OpenAiConfig.js

@@ -2,6 +2,7 @@ var OpenAiConfig;
 (function (OpenAiConfig) {
     OpenAiConfig["OpenAiApiKey"] = "OPENAI_API_KEY";
     OpenAiConfig["OpenAiModel"] = "OPENAI_MODEL";
+    OpenAiConfig["OpenAiVisionModel"] = "OPENAI_VISION_MODEL";
 })(OpenAiConfig || (OpenAiConfig = {}));
 export default OpenAiConfig;
 export { OpenAiConfig };

package/dist/controllers/AILogController.js

@@ -0,0 +1,18 @@
+import AILogServiceFactory from "../factory/services/AILogServiceFactory.js";
+import { AbstractFastifyController } from "@drax/crud-back";
+import AILogPermissions from "../permissions/AILogPermissions.js";
+class AILogController extends AbstractFastifyController {
+    constructor() {
+        super(AILogServiceFactory.instance, AILogPermissions);
+        this.tenantField = "tenant";
+        this.userField = "user";
+        this.tenantFilter = true;
+        this.tenantSetter = true;
+        this.tenantAssert = true;
+        this.userFilter = true;
+        this.userSetter = true;
+        this.userAssert = true;
+    }
+}
+export default AILogController;
+export { AILogController };

package/dist/factory/OpenAiProviderFactory.js

@@ -1,10 +1,11 @@
 import { DraxConfig } from "@drax/common-back";
 import OpenAiConfig from "../config/OpenAiConfig.js";
 import OpenAiProvider from "../providers/OpenAiProvider.js";
+import AILogServiceFactory from "./services/AILogServiceFactory.js";
 class OpenAiProviderFactory {
     static instance() {
         if (!OpenAiProviderFactory.singleton) {
-            OpenAiProviderFactory.singleton = new OpenAiProvider(DraxConfig.getOrLoad(OpenAiConfig.OpenAiApiKey), DraxConfig.getOrLoad(OpenAiConfig.OpenAiModel));
+            OpenAiProviderFactory.singleton = new OpenAiProvider(DraxConfig.getOrLoad(OpenAiConfig.OpenAiApiKey), DraxConfig.getOrLoad(OpenAiConfig.OpenAiModel), DraxConfig.getOrLoad(OpenAiConfig.OpenAiVisionModel), AILogServiceFactory.instance);
         }
         return OpenAiProviderFactory.singleton;
     }

package/dist/factory/services/AILogServiceFactory.js

@@ -0,0 +1,30 @@
+import AILogMongoRepository from '../../repository/mongo/AILogMongoRepository.js';
+import AILogSqliteRepository from '../../repository/sqlite/AILogSqliteRepository.js';
+import { AILogService } from '../../services/AILogService.js';
+import { AILogBaseSchema, AILogSchema } from "../../schemas/AILogSchema.js";
+import { COMMON, CommonConfig, DraxConfig } from "@drax/common-back";
+class AILogServiceFactory {
+    static get instance() {
+        if (!AILogServiceFactory.service) {
+            let repository;
+            switch (DraxConfig.getOrLoad(CommonConfig.DbEngine)) {
+                case COMMON.DB_ENGINES.MONGODB:
+                    repository = new AILogMongoRepository();
+                    break;
+                case COMMON.DB_ENGINES.SQLITE:
+                    const dbFile = DraxConfig.getOrLoad(CommonConfig.SqliteDbFile);
+                    repository = new AILogSqliteRepository(dbFile, false);
+                    repository.build();
+                    break;
+                default:
+                    throw new Error("DraxConfig.DB_ENGINE must be one of " + Object.values(COMMON.DB_ENGINES).join(", "));
+            }
+            const baseSchema = AILogBaseSchema;
+            const fullSchema = AILogSchema;
+            AILogServiceFactory.service = new AILogService(repository, baseSchema, fullSchema);
+        }
+        return AILogServiceFactory.service;
+    }
+}
+export default AILogServiceFactory;
+export { AILogServiceFactory };

package/dist/index.js

@@ -1,5 +1,14 @@
 import { OpenAiConfig } from "./config/OpenAiConfig.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 AILogServiceFactory from "./factory/services/AILogServiceFactory.js";
 import { OpenAiProvider } from "./providers/OpenAiProvider.js";
 import { KnowledgeService } from "./services/KnowledgeService.js";
-export { OpenAiConfig, OpenAiProviderFactory, OpenAiProvider, KnowledgeService, };
+import { AILogService } from "./services/AILogService.js";
+import AILogPermissions from "./permissions/AILogPermissions.js";
+import AILogController from "./controllers/AILogController.js";
+import AILogRoutes from "./routes/AILogRoutes.js";
+export { OpenAiConfig, AILogSchema, AILogBaseSchema, AILogModel, AILogMongoRepository, AILogSqliteRepository, OpenAiProviderFactory, AILogServiceFactory, OpenAiProvider, KnowledgeService, AILogService, AILogPermissions, AILogController, AILogRoutes, };

package/dist/interfaces/IAILog.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/IAILogRepository.js

@@ -0,0 +1 @@
+export {};

package/dist/models/AILogModel.js

@@ -0,0 +1,50 @@
+import { mongoose } from '@drax/common-back';
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2';
+const AILogSchema = new mongoose.Schema({
+    provider: { type: String, required: false, index: true, unique: false },
+    model: { type: String, required: false, index: true, unique: false },
+    operationTitle: { type: String, required: false, index: false, unique: false },
+    operationGroup: { type: String, required: false, index: false, unique: false },
+    ip: { type: String, required: false, index: false, unique: false },
+    userAgent: { type: String, required: false, index: false, unique: false },
+    input: { type: String, required: false, index: false, unique: false },
+    inputImages: [{
+            filename: { type: String, required: false, index: false, unique: false },
+            filepath: { type: String, required: false, index: false, unique: false },
+            size: { type: Number, required: false, index: false, unique: false },
+            mimetype: { type: String, required: false, index: false, unique: false },
+            url: { type: String, required: false, index: false, unique: false }
+        }],
+    inputFiles: [{
+            filename: { type: String, required: false, index: false, unique: false },
+            filepath: { type: String, required: false, index: false, unique: false },
+            size: { type: Number, required: false, index: false, unique: false },
+            mimetype: { type: String, required: false, index: false, unique: false },
+            url: { type: String, required: false, index: false, unique: false }
+        }],
+    inputTokens: { type: Number, required: false, index: false, unique: false },
+    outputTokens: { type: Number, required: false, index: false, unique: false },
+    tokens: { type: Number, required: false, index: false, unique: false },
+    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 },
+    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 },
+    errorMessage: { type: String, required: false, index: false, unique: false },
+    tenant: { type: mongoose.Schema.Types.ObjectId, ref: 'Tenant', required: false, index: false, unique: false },
+    user: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: false, index: false, unique: false }
+}, { timestamps: true });
+AILogSchema.plugin(uniqueValidator, { message: 'validation.unique' });
+AILogSchema.plugin(mongoosePaginate);
+AILogSchema.virtual("id").get(function () {
+    return this._id.toString();
+});
+AILogSchema.set('toJSON', { getters: true, virtuals: true });
+AILogSchema.set('toObject', { getters: true, virtuals: true });
+const MODEL_NAME = 'AILog';
+const COLLECTION_NAME = 'AILog';
+const AILogModel = mongoose.model(MODEL_NAME, AILogSchema, COLLECTION_NAME);
+export { AILogSchema, AILogModel };
+export default AILogModel;

package/dist/permissions/AILogPermissions.js

@@ -0,0 +1,10 @@
+var AILogPermissions;
+(function (AILogPermissions) {
+    AILogPermissions["Create"] = "ailog:create";
+    AILogPermissions["Update"] = "ailog:update";
+    AILogPermissions["Delete"] = "ailog:delete";
+    AILogPermissions["View"] = "ailog:view";
+    AILogPermissions["Manage"] = "ailog:manage";
+})(AILogPermissions || (AILogPermissions = {}));
+export { AILogPermissions };
+export default AILogPermissions;

package/dist/providers/OpenAiProvider.js

@@ -1,7 +1,7 @@
 import OpenAI from "openai";
 import { zodResponseFormat } from "openai/helpers/zod";
 class OpenAiProvider {
-    constructor(apiKey, model) {
+    constructor(apiKey, model, visionModel, aiLogService) {
         if (!apiKey) {
             throw new Error("OpenAI apiKey required");
         }
@@ -10,6 +10,8 @@ class OpenAiProvider {
         }
         this._apiKey = apiKey;
         this._model = model;
+        this._visionModel = visionModel;
+        this._aiLogService = aiLogService;
     }
     get model() {
         if (!this._model) {
@@ -25,6 +27,127 @@ class OpenAiProvider {
         }
         return this._client;
     }
+    get visionModel() {
+        return this._visionModel;
+    }
+    buildUserContent(input) {
+        if (input.userContent && input.userContent.length > 0) {
+            return this.mapContentParts(input.userContent);
+        }
+        if (input.userImages && input.userImages.length > 0) {
+            const content = [];
+            if (input.userInput) {
+                content.push({ type: 'text', text: input.userInput });
+            }
+            content.push(...input.userImages.map(image => ({
+                type: 'image_url',
+                image_url: {
+                    url: image.url,
+                    ...(image.detail ? { detail: image.detail } : {}),
+                }
+            })));
+            return content;
+        }
+        return input.userInput ?? "";
+    }
+    mapContentParts(content) {
+        return content.map(part => {
+            if (part.type === 'text') {
+                return {
+                    type: 'text',
+                    text: part.text
+                };
+            }
+            return {
+                type: 'image_url',
+                image_url: {
+                    url: part.imageUrl,
+                    ...(part.detail ? { detail: part.detail } : {}),
+                }
+            };
+        });
+    }
+    mapHistory(history = []) {
+        return history.map(message => ({
+            role: message.role,
+            content: typeof message.content === 'string'
+                ? message.content
+                : 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,
+        });
+    }
+    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,
@@ -36,7 +159,6 @@ class OpenAiProvider {
         if (!input.systemPrompt) {
             throw new Error("systemPrompt required");
         }
-        const model = input.model ?? this.model;
         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')}`;
@@ -44,31 +166,59 @@ class OpenAiProvider {
         if (input.knowledgeBase && input.knowledgeBase.length > 0) {
             systemPrompt += `\n\n${input.knowledgeBaseHeader ?? '[BASE DE CONOCIMIENTO]'}\n ${input.knowledgeBase.join('\n')}`;
         }
-        let userInput = input.userInput;
+        const userInput = this.buildUserContent(input);
+        const model = input.model ?? (this.hasImageInput(input) ? this.visionModel ?? this.model : this.model);
+        const startedAt = new Date();
         const startTime = performance.now();
-        const chatCompletion = await this.client.chat.completions.create({
-            messages: [
-                { role: 'system', content: systemPrompt },
-                ...(input.history ? 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 endTime = performance.now();
-        const time = endTime - startTime;
-        return {
-            output,
-            tokens,
-            inputTokens,
-            outputTokens,
-            time
-        };
+        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 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 OpenAiProvider;

package/dist/repository/mongo/AILogMongoRepository.js

@@ -0,0 +1,13 @@
+import { AbstractMongoRepository } from "@drax/crud-back";
+import { AILogModel } from "../../models/AILogModel.js";
+class AILogMongoRepository extends AbstractMongoRepository {
+    constructor() {
+        super();
+        this._model = AILogModel;
+        this._searchFields = ['provider', 'model', 'operationTitle', 'operationGroup', 'ip', 'userAgent', 'input', 'output', 'errorMessage'];
+        this._populateFields = ['tenant', 'user'];
+        this._lean = true;
+    }
+}
+export default AILogMongoRepository;
+export { AILogMongoRepository };

package/dist/repository/sqlite/AILogSqliteRepository.js

@@ -0,0 +1,45 @@
+import { AbstractSqliteRepository } from "@drax/crud-back";
+class AILogSqliteRepository extends AbstractSqliteRepository {
+    constructor() {
+        super(...arguments);
+        this.tableName = 'AILog';
+        this.searchFields = ['provider', 'model', 'operationTitle', 'operationGroup', 'ip', 'userAgent', 'input', 'output', 'errorMessage'];
+        this.booleanFields = ['success'];
+        this.jsonFields = ['inputImages', 'inputFiles'];
+        this.identifier = '_id';
+        this.populateFields = [
+            { field: 'tenant', table: 'tenant', identifier: '_id' },
+            { field: 'user', table: 'user', identifier: '_id' }
+        ];
+        this.verbose = false;
+        this.tableFields = [
+            { name: "provider", type: "TEXT", unique: false, primary: false },
+            { name: "model", type: "TEXT", unique: false, primary: false },
+            { name: "operationTitle", type: "TEXT", unique: false, primary: false },
+            { name: "operationGroup", type: "TEXT", unique: false, primary: false },
+            { name: "ip", type: "TEXT", unique: false, primary: false },
+            { name: "userAgent", type: "TEXT", unique: false, primary: false },
+            { name: "input", type: "TEXT", unique: false, primary: false },
+            { name: "inputImages", type: "TEXT", unique: false, primary: false },
+            { name: "inputFiles", type: "TEXT", unique: false, primary: false },
+            { name: "inputTokens", type: "INTEGER", unique: false, primary: false },
+            { name: "inputTokens", type: "TEXT", unique: false, primary: false },
+            { name: "outputTokens", type: "INTEGER", unique: false, primary: false },
+            { name: "outputTokens", type: "TEXT", unique: false, primary: false },
+            { name: "tokens", type: "INTEGER", unique: false, primary: false },
+            { name: "tokens", type: "TEXT", unique: false, primary: false },
+            { 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: "output", type: "TEXT", unique: false, primary: false },
+            { name: "success", type: "TEXT", unique: false, primary: false },
+            { name: "statusCode", type: "INTEGER", unique: false, primary: false },
+            { name: "statusCode", type: "TEXT", unique: false, primary: false },
+            { name: "errorMessage", type: "TEXT", unique: false, primary: false },
+            { name: "tenant", type: "TEXT", unique: false, primary: false },
+            { name: "user", type: "TEXT", unique: false, primary: false }
+        ];
+    }
+}
+export default AILogSqliteRepository;
+export { AILogSqliteRepository };

package/dist/routes/AILogRoutes.js

@@ -0,0 +1,21 @@
+import AILogController from "../controllers/AILogController.js";
+import { CrudSchemaBuilder } from "@drax/crud-back";
+import { AILogSchema, AILogBaseSchema } from '../schemas/AILogSchema.js';
+async function AILogFastifyRoutes(fastify, options) {
+    const controller = new AILogController();
+    const schemas = new CrudSchemaBuilder(AILogSchema, AILogBaseSchema, AILogBaseSchema, 'AILog', 'openapi-3.0', ['ai']);
+    fastify.get('/api/ailog', { schema: schemas.paginateSchema }, (req, rep) => controller.paginate(req, rep));
+    fastify.get('/api/ailog/find', { schema: schemas.findSchema }, (req, rep) => controller.find(req, rep));
+    fastify.get('/api/ailog/search', { schema: schemas.searchSchema }, (req, rep) => controller.search(req, rep));
+    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.get('/api/ailog/export', (req, rep) => controller.export(req, rep));
+    fastify.post('/api/ailog/import', (req, rep) => controller.import(req, rep));
+}
+export default AILogFastifyRoutes;
+export { AILogFastifyRoutes };

package/dist/schemas/AILogSchema.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+const AILogBaseSchema = z.object({
+    provider: z.string().optional(),
+    model: z.string().optional(),
+    operationTitle: z.string().optional(),
+    operationGroup: z.string().optional(),
+    ip: z.string().optional(),
+    userAgent: z.string().optional(),
+    input: z.string().optional(),
+    inputImages: z.array(z.object({
+        filename: z.string().optional(),
+        filepath: z.string().optional(),
+        size: z.number().nullable().optional(),
+        mimetype: z.string().optional(),
+        url: z.string().optional()
+    })).optional(),
+    inputFiles: z.array(z.object({
+        filename: z.string().optional(),
+        filepath: z.string().optional(),
+        size: z.number().nullable().optional(),
+        mimetype: z.string().optional(),
+        url: z.string().optional()
+    })).optional(),
+    inputTokens: z.number().nullable().optional(),
+    outputTokens: z.number().nullable().optional(),
+    tokens: z.number().nullable().optional(),
+    startedAt: z.coerce.date().nullable().optional(),
+    endedAt: z.coerce.date().nullable().optional(),
+    responseTime: z.string().optional(),
+    output: z.string().optional(),
+    success: z.boolean().optional(),
+    statusCode: z.number().nullable().optional(),
+    errorMessage: z.string().optional(),
+    tenant: z.coerce.string().optional().nullable(),
+    user: z.coerce.string().optional().nullable()
+});
+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()
+});
+export default AILogSchema;
+export { AILogSchema, AILogBaseSchema };

package/dist/services/AILogService.js

@@ -0,0 +1,9 @@
+import { AbstractService } from "@drax/crud-back";
+class AILogService extends AbstractService {
+    constructor(AILogRepository, baseSchema, fullSchema) {
+        super(AILogRepository, baseSchema, fullSchema);
+        this._validateOutput = true;
+    }
+}
+export default AILogService;
+export { AILogService };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.0.0",
+  "version": "3.16.0",
   "description": "Ai utils",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -17,6 +17,12 @@
   },
   "author": "Cristian Incarnato & Drax Team",
   "license": "ISC",
+  "dependencies": {
+    "@drax/ai-share": "^3.16.0",
+    "@drax/crud-back": "^3.15.0",
+    "mongoose": "^8.23.0",
+    "mongoose-paginate-v2": "^1.8.3"
+  },
   "peerDependencies": {
     "jsdom": "^26.0.0",
     "office-text-extractor": "^3.0.3",
@@ -38,5 +44,5 @@
     "typescript": "^5.9.3",
     "vitest": "^3.0.8"
   },
-  "gitHead": "63ae718b24ea25ae80b1a9a5dfb84a3abbb95199"
+  "gitHead": "5254c8b1b2b59de46654f135122f38bd29ae5452"
 }

package/src/config/OpenAiConfig.ts

@@ -3,6 +3,7 @@ enum OpenAiConfig {
 
     OpenAiApiKey = "OPENAI_API_KEY",
     OpenAiModel = "OPENAI_MODEL",
+    OpenAiVisionModel = "OPENAI_VISION_MODEL",
 
 }
 

package/src/controllers/AILogController.ts

@@ -0,0 +1,29 @@
+
+import AILogServiceFactory from "../factory/services/AILogServiceFactory.js";
+import {AbstractFastifyController} from "@drax/crud-back";
+import AILogPermissions from "../permissions/AILogPermissions.js";
+import type {IAILog, IAILogBase} from "@drax/ai-share";
+
+class AILogController extends AbstractFastifyController<IAILog, IAILogBase, IAILogBase>   {
+
+    constructor() {
+        super(AILogServiceFactory.instance, AILogPermissions)
+        this.tenantField = "tenant";
+        this.userField = "user";
+
+        this.tenantFilter = true;
+        this.tenantSetter = true;
+        this.tenantAssert = true;
+
+        this.userFilter = true;
+        this.userSetter = true;
+        this.userAssert = true;
+    }
+
+}
+
+export default AILogController;
+export {
+    AILogController
+}
+

package/src/factory/OpenAiProviderFactory.ts

@@ -2,6 +2,7 @@ import {DraxConfig} from "@drax/common-back";
 import OpenAiConfig from "../config/OpenAiConfig.js";
 import type {IAIProvider} from "../interfaces/IAIProvider"
 import OpenAiProvider from "../providers/OpenAiProvider.js";
+import AILogServiceFactory from "./services/AILogServiceFactory.js";
 
 class OpenAiProviderFactory {
     private static singleton: IAIProvider;
@@ -10,7 +11,9 @@ class OpenAiProviderFactory {
         if (!OpenAiProviderFactory.singleton) {
             OpenAiProviderFactory.singleton = new OpenAiProvider(
                 DraxConfig.getOrLoad(OpenAiConfig.OpenAiApiKey),
-                DraxConfig.getOrLoad(OpenAiConfig.OpenAiModel)
+                DraxConfig.getOrLoad(OpenAiConfig.OpenAiModel),
+                DraxConfig.getOrLoad(OpenAiConfig.OpenAiVisionModel),
+                AILogServiceFactory.instance
             );
         }
         return OpenAiProviderFactory.singleton;
@@ -21,4 +24,3 @@ export default OpenAiProviderFactory
 export {
     OpenAiProviderFactory
 }
-