@drax/ai-back 3.0.0 → 3.17.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/AIController.js

@@ -0,0 +1,150 @@
+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.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 AIController extends CommonController {
+    buildFieldValueSchema(field) {
+        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);
+        }
+    }
+    buildFieldShape(fields) {
+        return fields.reduce((acc, field) => {
+            acc[field.name] = this.buildFieldValueSchema(field);
+            return acc;
+        }, {});
+    }
+    buildSystemPrompt(input) {
+        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");
+    }
+    buildUserInput(input) {
+        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) {
+            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 AIController;
+export { AIController };

package/dist/controllers/AICrudController.js

@@ -0,0 +1,150 @@
+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.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 {
+    buildFieldValueSchema(field) {
+        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);
+        }
+    }
+    buildFieldShape(fields) {
+        return fields.reduce((acc, field) => {
+            acc[field.name] = this.buildFieldValueSchema(field);
+            return acc;
+        }, {});
+    }
+    buildSystemPrompt(input) {
+        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");
+    }
+    buildUserInput(input) {
+        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) {
+            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 };

package/dist/controllers/AIGenericController.js

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import { CommonController } from "@drax/common-back";
+import AiProviderFactory from "../factory/AiProviderFactory.js";
+import AIPermissions from "../permissions/AIPermissions.js";
+const PromptImageSchema = z.object({
+    url: z.string().min(1),
+    detail: z.enum(["auto", "low", "high"]).optional(),
+});
+const PromptContentPartSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("text"),
+        text: z.string(),
+    }),
+    z.object({
+        type: z.literal("image"),
+        imageUrl: z.string().min(1),
+        detail: z.enum(["auto", "low", "high"]).optional(),
+    }),
+]);
+const PromptMessageSchema = z.object({
+    role: z.enum(["user", "assistant", "system"]),
+    content: z.union([
+        z.string(),
+        z.array(PromptContentPartSchema),
+    ]),
+});
+const PromptMemorySchema = z.object({
+    key: z.string().min(1),
+    value: z.string(),
+});
+const PromptInputFileSchema = z.object({
+    filename: z.string().optional(),
+    filepath: z.string().optional(),
+    size: z.number().nullable().optional(),
+    mimetype: z.string().optional(),
+    url: z.string().optional(),
+});
+const GenericPromptRequestSchema = z.object({
+    systemPrompt: z.string().min(1),
+    userInput: z.string().optional(),
+    userImages: z.array(PromptImageSchema).optional(),
+    inputFiles: z.array(PromptInputFileSchema).optional(),
+    userContent: z.array(PromptContentPartSchema).optional(),
+    history: z.array(PromptMessageSchema).optional(),
+    memory: z.array(PromptMemorySchema).optional(),
+    memoryHeader: z.string().optional(),
+    knowledgeBase: z.array(z.string()).optional(),
+    knowledgeBaseHeader: z.string().optional(),
+    jsonSchema: z.record(z.string(), z.any()).or(z.array(z.any())).optional(),
+    model: z.string().optional(),
+    operationTitle: z.string().optional(),
+    operationGroup: z.string().optional(),
+});
+class AIGenericController extends CommonController {
+    async prompt(request, reply) {
+        try {
+            request.rbac.assertPermission(AIPermissions.Prompt);
+            const input = GenericPromptRequestSchema.parse(request.body ?? {});
+            const aiProvider = AiProviderFactory.instance();
+            const promptInput = {
+                ...input,
+                operationTitle: input.operationTitle ?? "generic-ai-prompt",
+                operationGroup: input.operationGroup ?? "generic-ai-prompt",
+                ip: request.ip,
+                userAgent: request.headers["user-agent"],
+                tenant: request.rbac?.tenantId ?? null,
+                user: request.rbac?.userId ?? null,
+            };
+            const response = await aiProvider.prompt(promptInput);
+            return reply.send(response);
+        }
+        catch (e) {
+            if (e?.name === "ZodError") {
+                return reply.status(400).send({
+                    message: e?.message || "AI prompt validation error",
+                });
+            }
+            this.handleError(e, reply);
+        }
+    }
+}
+export default AIGenericController;
+export { AIGenericController };

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/AiProviderFactory.js

@@ -1,6 +1,6 @@
 import OpenAiProviderFactory from "./OpenAiProviderFactory.js";
 class AiProviderFactory {
-    static instance(provider) {
+    static instance(provider = 'OpenAi') {
         if (!AiProviderFactory.singleton) {
             switch (provider) {
                 case 'OpenAi':

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,18 @@
 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 AIPermissions from "./permissions/AIPermissions.js";
+import AILogController from "./controllers/AILogController.js";
+import AICrudController from "./controllers/AICrudController.js";
+import AIGenericController from "./controllers/AIGenericController.js";
+import AILogRoutes from "./routes/AILogRoutes.js";
+import AIRoutes from "./routes/AIRoutes.js";
+export { OpenAiConfig, AILogSchema, AILogBaseSchema, AILogModel, AILogMongoRepository, AILogSqliteRepository, OpenAiProviderFactory, AILogServiceFactory, OpenAiProvider, KnowledgeService, AILogService, AILogPermissions, AIPermissions, AILogController, AICrudController, AIGenericController, AILogRoutes, AIRoutes };

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/permissions/AIPermissions.js

@@ -0,0 +1,7 @@
+var AIPermissions;
+(function (AIPermissions) {
+    AIPermissions["Prompt"] = "ai:prompt";
+    AIPermissions["PromptCrud"] = "ai:promptCrud";
+})(AIPermissions || (AIPermissions = {}));
+export { AIPermissions };
+export default AIPermissions;