@drax/ai-back 3.0.0 → 3.17.0

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/routes/AIRoutes.js

@@ -0,0 +1,10 @@
+import AICrudController from "../controllers/AICrudController.js";
+import AIGenericController from "../controllers/AIGenericController.js";
+async function AiFastifyRoutes(fastify, options) {
+    const crudController = new AICrudController();
+    const genericController = new AIGenericController();
+    fastify.post('/api/ai/prompt/crud', (req, rep) => crudController.prompt(req, rep));
+    fastify.post('/api/ai/prompt/generic', (req, rep) => genericController.prompt(req, rep));
+}
+export default AiFastifyRoutes;
+export { AiFastifyRoutes };

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.17.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.17.0",
+    "@drax/crud-back": "^3.17.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": "d8a056b087d67157bc8c2e684b7e6696399d06a4"
 }

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/AICrudController.ts

@@ -0,0 +1,168 @@
+import {z} from "zod";
+import {CommonController} from "@drax/common-back";
+import AiProviderFactory from "../factory/AiProviderFactory.js";
+import AIPermissions from "../permissions/AIPermissions.js";
+
+const CrudAiFieldSchema: z.ZodType<any> = z.lazy(() => z.object({
+    name: z.string(),
+    type: z.string(),
+    label: z.string(),
+    hint: z.string().nullable().default(null),
+    placeholder: z.string().nullable().default(null),
+    readonly: z.boolean().nullable().default(null),
+    default: z.any().nullable().default(null),
+    enum: z.array(z.string()).nullable().default(null),
+    items: z.array(z.object({
+        title: z.string().nullable().default(null),
+        value: z.any().nullable().default(null),
+    })).nullable().default(null),
+    ref: z.string().nullable().default(null),
+    refDisplay: z.string().nullable().default(null),
+    objectFields: z.array(CrudAiFieldSchema).nullable().default(null),
+}))
+
+const PromptRequestSchema = z.object({
+    prompt: z.string().min(1),
+    operation: z.enum(["create", "edit"]).default("create"),
+    entity: z.object({
+        name: z.string(),
+        identifier: z.string().optional().nullable(),
+    }),
+    currentValues: z.record(z.string(), z.any()).default({}),
+    fields: z.array(CrudAiFieldSchema).min(1),
+})
+
+class AICrudController extends CommonController {
+
+    protected buildFieldValueSchema(field: any): z.ZodTypeAny {
+        switch (field.type) {
+            case "number":
+                return z.number().nullable().default(null)
+            case "boolean":
+                return z.boolean().nullable().default(null)
+            case "array.string":
+            case "array.enum":
+            case "array.ref":
+                return z.array(z.string()).nullable().default(null)
+            case "array.number":
+                return z.array(z.number()).nullable().default(null)
+            case "object":
+                if (field.objectFields && Array.isArray(field.objectFields) && field.objectFields.length > 0) {
+                    return z.object(this.buildFieldShape(field.objectFields)).nullable().default(null)
+                }
+                return z.string().nullable().default(null)
+            case "record":
+            case "array.object":
+            case "array.record":
+            case "array.fullFile":
+            case "file":
+            case "fullFile":
+                return z.string().nullable().default(null)
+            case "id":
+            case "string":
+            case "longString":
+            case "date":
+            case "ref":
+            case "enum":
+            case "select":
+            case "password":
+            default:
+                return z.string().nullable().default(null)
+        }
+    }
+
+    protected buildFieldShape(fields: any[]): Record<string, z.ZodTypeAny> {
+        return fields.reduce((acc, field) => {
+            acc[field.name] = this.buildFieldValueSchema(field)
+            return acc
+        }, {} as Record<string, z.ZodTypeAny>)
+    }
+
+    protected buildSystemPrompt(input: z.infer<typeof PromptRequestSchema>) {
+        return [
+            "Sos un asistente de formularios para un sistema CRUD.",
+            "Tu tarea es proponer valores JSON para completar o editar una entidad.",
+            "Debes respetar exactamente los nombres de campo entregados.",
+            "No inventes campos adicionales.",
+            "Si un campo no tiene una propuesta razonable, omitilo.",
+            "Usa tipos compatibles con JSON.",
+            "Para campos enum o select, elegí solamente valores válidos de la lista provista.",
+            "Para campos record, object sin estructura fija, array.object o array.record, devolve un string JSON serializado valido.",
+            "La respuesta debe describir sugerencias concretas, breves y aplicables.",
+            `Operacion actual: ${input.operation}.`,
+            `Entidad actual: ${input.entity.name}.`,
+        ].join("\n")
+    }
+
+    protected buildUserInput(input: z.infer<typeof PromptRequestSchema>) {
+        return JSON.stringify({
+            task: input.prompt,
+            operation: input.operation,
+            entity: input.entity,
+            currentValues: input.currentValues,
+            fields: input.fields,
+            expectedResponse: {
+                message: "string",
+                suggestions: "object with proposed values indexed by field name",
+                warnings: ["optional string warnings"],
+            }
+        })
+    }
+
+    async prompt(req, rep) {
+        try {
+            req.rbac.assertPermission(AIPermissions.PromptCrud)
+
+            const input = PromptRequestSchema.parse(req.body ?? {})
+            const aiProvider = AiProviderFactory.instance()
+
+            const responseSchema = z.object({
+                message: z.string().nullable().default(null),
+                suggestions: z.object(this.buildFieldShape(input.fields)).strict().default({}),
+                warnings: z.array(z.string()).default([]),
+            })
+
+            const response = await aiProvider.prompt({
+                systemPrompt: this.buildSystemPrompt(input),
+                userInput: this.buildUserInput(input),
+                zodSchema: responseSchema,
+                operationTitle: `crud-${input.operation}-assistant`,
+                operationGroup: "crud-form-assistant",
+                ip: req.ip,
+                userAgent: req.headers["user-agent"],
+                tenant: req.rbac?.tenantId ?? null,
+                user: req.rbac?.userId ?? null,
+            })
+
+            const parsedOutput = responseSchema.parse(
+                typeof response.output === "string"
+                    ? JSON.parse(response.output)
+                    : response.output
+            )
+
+            return rep.send({
+                message: parsedOutput.message,
+                suggestions: parsedOutput.suggestions,
+                warnings: parsedOutput.warnings,
+                meta: {
+                    tokens: response.tokens,
+                    inputTokens: response.inputTokens,
+                    outputTokens: response.outputTokens,
+                    time: response.time,
+                }
+            })
+        } catch (e: any) {
+            console.error("AIController.prompt error", e)
+
+            const statusCode = e?.name === "ZodError" ? 400 : 500
+
+            return rep.status(statusCode).send({
+                message: e?.message || "AI prompt error",
+            })
+        }
+    }
+
+}
+
+export default AICrudController;
+export {AICrudController};