@drax/ai-back 3.35.1 → 3.37.0

package/dist/agents/DraxAgent.js

@@ -2,18 +2,14 @@ import { randomUUID } from "node:crypto";
 import AiProviderFactory from "../factory/AiProviderFactory.js";
 import AgentSessionServiceFactory from "../factory/services/AgentSessionServiceFactory.js";
 class DraxAgent {
-    constructor() {
+    constructor(identifier = "default", description = "") {
+        this.identifier = identifier;
+        this.description = description;
         this.sessions = new Map();
         this.config = {
             systemPrompt: "Sos un asistente del sistema. Responde de forma clara, breve y util.",
         };
     }
-    static instance() {
-        if (!DraxAgent.singleton) {
-            DraxAgent.singleton = new DraxAgent();
-        }
-        return DraxAgent.singleton;
-    }
     configure(config) {
         this.config = {
             ...this.config,
@@ -95,6 +91,7 @@ class DraxAgent {
             outputTokens: response.outputTokens,
         });
         return {
+            agentIdentifier: this.identifier,
             sessionId: session.id,
             message: assistantMessage,
             navigationPath: navigationState.path,

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { CommonController } from "@drax/common-back";
-import { DraxAgent } from "../agents/DraxAgent.js";
+import DraxAgentFactory from "../factory/DraxAgentFactory.js";
 import { AgentPermissions } from "../permissions/AgentPermissions.js";
 const PromptImageSchema = z.object({
     url: z.string().min(1),
@@ -29,6 +29,7 @@ const PromptInputFileSchema = z.object({
     url: z.string().optional(),
 });
 const AgentSessionRequestSchema = z.object({
+    identifier: z.string().min(1).optional(),
     sessionId: z.string().optional(),
     userId: z.string().optional().nullable(),
     tenantId: z.string().optional().nullable(),
@@ -48,21 +49,39 @@ const AgentMessageRequestSchema = AgentSessionRequestSchema.extend({
     operationGroup: z.string().optional(),
 });
 class DraxAgentController extends CommonController {
-    constructor() {
+    constructor(options = {}) {
         super();
-        this.permission = AgentPermissions.Session;
-        this.agent = DraxAgent.instance();
+        this.permission = options.permission ?? AgentPermissions.Session;
+        this.defaultAgentIdentifier = options.agentIdentifier ?? "default";
+        this.defaultAgentDescription = options.agentDescription ?? "";
+        DraxAgentFactory.instance(this.defaultAgentIdentifier, this.defaultAgentDescription);
+    }
+    async agents(request, reply) {
+        try {
+            this.assertAccess(request);
+            return reply.send({
+                agents: DraxAgentFactory.agents().map(agent => ({
+                    identifier: agent.identifier,
+                    description: agent.description,
+                })),
+            });
+        }
+        catch (e) {
+            this.handleControllerError(e, reply);
+        }
     }
     async startSession(request, reply) {
         try {
             this.assertAccess(request);
             const input = AgentSessionRequestSchema.parse(request.body ?? {});
-            const session = await this.agent.startSession({
+            const agent = this.resolveAgent(input.identifier);
+            const session = await agent.startSession({
                 sessionId: input.sessionId,
                 userId: this.resolveUserId(request, input.userId),
                 tenantId: this.resolveTenantId(request, input.tenantId),
             });
             return reply.send({
+                agentIdentifier: agent.identifier,
                 sessionId: session.id,
                 createdAt: session.createdAt,
                 updatedAt: session.updatedAt,
@@ -76,7 +95,8 @@ class DraxAgentController extends CommonController {
         try {
             this.assertAccess(request);
             const input = AgentMessageRequestSchema.parse(request.body ?? {});
-            const response = await this.agent.sendMessage({
+            const agent = this.resolveAgent(input.identifier);
+            const response = await agent.sendMessage({
                 ...input,
                 userId: this.resolveUserId(request, input.userId),
                 tenantId: this.resolveTenantId(request, input.tenantId),
@@ -89,6 +109,9 @@ class DraxAgentController extends CommonController {
             this.handleControllerError(e, reply);
         }
     }
+    resolveAgent(identifier) {
+        return DraxAgentFactory.instance(identifier ?? this.defaultAgentIdentifier);
+    }
     assertAccess(request) {
         if (this.permission === false) {
             return;

package/dist/factory/DraxAgentFactory.js

@@ -0,0 +1,15 @@
+import DraxAgent from "../agents/DraxAgent.js";
+class DraxAgentFactory {
+    static instance(identifier = "default", description = "") {
+        if (!DraxAgentFactory.singletons[identifier]) {
+            DraxAgentFactory.singletons[identifier] = new DraxAgent(identifier, description);
+        }
+        return DraxAgentFactory.singletons[identifier];
+    }
+    static agents() {
+        return Object.values(DraxAgentFactory.singletons);
+    }
+}
+DraxAgentFactory.singletons = {};
+export default DraxAgentFactory;
+export { DraxAgentFactory, };

package/dist/index.js

@@ -9,6 +9,7 @@ import { OpenAiProviderFactory } from "./factory/OpenAiProviderFactory.js";
 import { GoogleAiProviderFactory } from "./factory/GoogleAiProviderFactory.js";
 import { OllamaAiProviderFactory } from "./factory/OllamaAiProviderFactory.js";
 import { AiProviderFactory } from "./factory/AiProviderFactory.js";
+import { DraxAgentFactory } from "./factory/DraxAgentFactory.js";
 import AILogServiceFactory from "./factory/services/AILogServiceFactory.js";
 import { OpenAiProvider } from "./providers/OpenAiProvider.js";
 import { GoogleAiProvider } from "./providers/GoogleAiProvider.js";
@@ -30,7 +31,7 @@ import AIRoutes from "./routes/AIRoutes.js";
 import DraxAgentRoutes from "./routes/DraxAgentRoutes.js";
 import AgentSessionRoutes from "./routes/AgentSessionRoutes.js";
 import { DraxAgent } from "./agents/DraxAgent.js";
-export { OpenAiConfig, GoogleAiConfig, OllamaAiConfig, AILogSchema, AILogBaseSchema, AILogModel, AILogMongoRepository, AILogSqliteRepository, OpenAiProviderFactory, GoogleAiProviderFactory, OllamaAiProviderFactory, AiProviderFactory, AILogServiceFactory, OpenAiProvider, GoogleAiProvider, OllamaAiProvider, BuilderTool, 
+export { OpenAiConfig, GoogleAiConfig, OllamaAiConfig, AILogSchema, AILogBaseSchema, AILogModel, AILogMongoRepository, AILogSqliteRepository, OpenAiProviderFactory, GoogleAiProviderFactory, OllamaAiProviderFactory, AiProviderFactory, DraxAgentFactory, AILogServiceFactory, OpenAiProvider, GoogleAiProvider, OllamaAiProvider, BuilderTool, 
 //Service
 KnowledgeService, AILogService, 
 //Permissions

package/dist/interfaces/IAILog.js

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

package/dist/routes/ChatbotTaskRoutes.js

@@ -0,0 +1,8 @@
+import ChatbotTaskController from "../controllers/ChatbotTaskController.js";
+async function ChatbotTaskFastifyRoutes(fastify, options) {
+    const controller = new ChatbotTaskController();
+    fastify.post("/api/chatbot/session", (req, rep) => controller.startSession(req, rep));
+    fastify.post("/api/chatbot/message", (req, rep) => controller.message(req, rep));
+}
+export default ChatbotTaskFastifyRoutes;
+export { ChatbotTaskFastifyRoutes };

package/dist/routes/DraxAgentRoutes.js

@@ -1,7 +1,8 @@
 import DraxAgentController from "../controllers/DraxAgentController.js";
 async function DraxAgentRoutes(fastify, options) {
-    const controller = new DraxAgentController();
+    const controller = new DraxAgentController(options);
     const prefix = "/api/ai/agent";
+    fastify.get(`${prefix}`, (req, rep) => controller.agents(req, rep));
     fastify.post(`${prefix}/session`, (req, rep) => controller.startSession(req, rep));
     fastify.post(`${prefix}/message`, (req, rep) => controller.message(req, rep));
 }

package/dist/tools/ToolBuilder.js

@@ -0,0 +1,243 @@
+import { z } from "zod";
+const emptyParameters = {
+    type: "object",
+    properties: {},
+    additionalProperties: false,
+};
+const idSchema = z.object({
+    id: z.string().describe("Entity identifier"),
+});
+const filtersSchema = z.array(z.object({
+    field: z.string(),
+    operator: z.string(),
+    value: z.any(),
+    orGroup: z.string().optional(),
+})).optional().describe("Optional Drax field filters");
+const toolDefinitions = {
+    create: {
+        description: entityName => `Crear un registro de ${entityName}`,
+        parameters: builder => builder.objectParameters(z.object({
+            data: builder.inputSchema.describe("Data for the entity to create"),
+        })),
+        execute: (service, args) => service.create?.(args.data),
+    },
+    update: {
+        description: entityName => `Reemplazar un registro de ${entityName} por id`,
+        parameters: builder => builder.objectParameters(z.object({
+            id: z.string().describe("Entity identifier"),
+            data: builder.inputSchema.describe("Complete replacement data"),
+        })),
+        execute: (service, args) => service.update?.(args.id, args.data),
+    },
+    updatePartial: {
+        description: entityName => `Actualizar parcialmente un registro de ${entityName} por id`,
+        parameters: builder => builder.objectParameters(z.object({
+            id: z.string().describe("Entity identifier"),
+            data: builder.partialInputSchema.describe("Partial data to update"),
+        })),
+        execute: (service, args) => service.updatePartial?.(args.id, args.data),
+    },
+    delete: {
+        description: entityName => `Eliminar un registro de ${entityName} por id`,
+        parameters: builder => builder.objectParameters(idSchema),
+        execute: (service, args) => service.delete?.(args.id),
+    },
+    findById: {
+        description: entityName => `Buscar un registro de ${entityName} por id`,
+        parameters: builder => builder.objectParameters(idSchema),
+        execute: (service, args) => service.findById?.(args.id),
+    },
+    findByIds: {
+        description: entityName => `Buscar multiples registros de ${entityName} por ids`,
+        parameters: builder => builder.objectParameters(z.object({
+            ids: z.array(z.string()).describe("Entity identifiers"),
+        })),
+        execute: (service, args) => service.findByIds?.(args.ids),
+    },
+    findOneBy: {
+        description: entityName => `Buscar un registro de ${entityName} por valor de campo`,
+        parameters: builder => builder.objectParameters(z.object({
+            field: z.string(),
+            value: z.any(),
+            filters: filtersSchema,
+        })),
+        execute: (service, args) => service.findOneBy?.(args.field, args.value, args.filters ?? []),
+    },
+    findOne: {
+        description: entityName => `Buscar el primer registro de ${entityName} que coincida con busqueda y filtros`,
+        parameters: builder => builder.objectParameters(z.object({
+            search: z.string().optional(),
+            filters: filtersSchema,
+        })),
+        execute: (service, args) => service.findOne?.({
+            search: args.search ?? "",
+            filters: args.filters ?? [],
+        }),
+    },
+    findBy: {
+        description: entityName => `Buscar registros de ${entityName} por valor de campo`,
+        parameters: builder => builder.objectParameters(z.object({
+            field: z.string(),
+            value: z.any(),
+            limit: z.number().optional(),
+            filters: filtersSchema,
+        })),
+        execute: (service, args) => service.findBy?.(args.field, args.value, args.limit ?? 1000, args.filters ?? []),
+    },
+    fetchAll: {
+        description: entityName => `Obtener todos los registros de ${entityName}`,
+        parameters: () => emptyParameters,
+        execute: service => service.fetchAll?.(),
+    },
+    search: {
+        description: entityName => `Buscar registros de ${entityName} por texto`,
+        parameters: builder => builder.objectParameters(z.object({
+            value: z.string().describe("Search text"),
+            limit: z.number().optional(),
+            filters: filtersSchema,
+        })),
+        execute: (service, args) => service.search?.(args.value, args.limit ?? 1000, args.filters ?? []),
+    },
+    find: {
+        description: entityName => `Buscar registros de ${entityName} usando opciones de listado`,
+        parameters: builder => builder.objectParameters(z.object({
+            orderBy: z.string().optional(),
+            order: z.union([z.enum(["asc", "desc"]), z.boolean()]).optional(),
+            search: z.string().optional(),
+            filters: filtersSchema,
+            limit: z.number().optional(),
+        })),
+        execute: (service, args) => service.find?.({
+            orderBy: args.orderBy ?? "",
+            order: args.order ?? false,
+            search: args.search ?? "",
+            filters: args.filters ?? [],
+            limit: args.limit ?? 0,
+        }),
+    },
+    paginate: {
+        description: entityName => `Paginar registros de ${entityName}`,
+        parameters: builder => builder.objectParameters(z.object({
+            page: z.number().optional(),
+            limit: z.number().optional(),
+            orderBy: z.string().optional(),
+            order: z.enum(["asc", "desc"]).optional(),
+            search: z.string().optional(),
+            filters: filtersSchema,
+        })),
+        execute: (service, args) => service.paginate({
+            page: args.page ?? 1,
+            limit: args.limit ?? 10,
+            orderBy: args.orderBy,
+            order: args.order ?? "asc",
+            search: args.search ?? "",
+            filters: args.filters ?? [],
+        }),
+    },
+    groupBy: {
+        description: entityName => `Agrupar registros de ${entityName} por campos`,
+        parameters: builder => builder.objectParameters(z.object({
+            fields: z.array(z.string()).optional(),
+            filters: filtersSchema,
+            dateFormat: z.enum(["year", "month", "day", "hour", "minute", "second"]).optional(),
+        })),
+        execute: (service, args) => service.groupBy?.({
+            fields: args.fields ?? [],
+            filters: args.filters ?? [],
+            dateFormat: args.dateFormat ?? "day",
+        }),
+    },
+};
+class ToolBuilder {
+    constructor(options) {
+        this.options = options;
+        this._inputSchema = this.schemaAdapter(options.schema);
+        this._partialInputSchema = this._inputSchema.partial();
+        this._outputSchema = options.outputSchema ? this.schemaAdapter(options.outputSchema) : undefined;
+    }
+    get inputSchema() {
+        return this._inputSchema;
+    }
+    get partialInputSchema() {
+        return this._partialInputSchema;
+    }
+    get outputSchema() {
+        return this._outputSchema;
+    }
+    getTools() {
+        return this.options.methods.map(method => this.buildTool(method));
+    }
+    getSystemPromptSection() {
+        const entityDescription = this.options.entityDescription
+            ? `\n${this.options.entityDescription}`
+            : "";
+        const tools = this.options.methods
+            .map(method => {
+            const definition = toolDefinitions[method];
+            return `- ${this.getToolName(method)}: ${definition.description(this.options.entityName)}`;
+        })
+            .join("\n");
+        const entitySchema = JSON.stringify(this.toJsonSchema(this._outputSchema ?? this._inputSchema));
+        return [
+            `[ENTIDAD: ${this.options.entityName}]${entityDescription}`,
+            `Schema JSON de la entidad: ${entitySchema}`,
+            "Tools disponibles:",
+            tools,
+        ].join("\n");
+    }
+    objectParameters(schema) {
+        return this.toJsonSchema(this.schemaAdapter(schema));
+    }
+    buildTool(method) {
+        const definition = toolDefinitions[method];
+        const serviceMethod = this.options.service[method];
+        if (typeof serviceMethod !== "function") {
+            throw new Error(`Tool method not available on service: ${method}`);
+        }
+        return {
+            name: this.getToolName(method),
+            description: definition.description(this.options.entityName),
+            parameters: definition.parameters(this),
+            execute: async (args) => definition.execute(this.options.service, args),
+        };
+    }
+    getToolName(method) {
+        return `${this.options.toolNamePrefix ?? this.options.entityName}_${method}`;
+    }
+    toJsonSchema(schema) {
+        return z.toJSONSchema(schema, { target: "openAi" });
+    }
+    getTypeName(field) {
+        return field?.constructor?.name;
+    }
+    fieldAdapter(field) {
+        const f = field;
+        const typeName = this.getTypeName(f);
+        if (typeof f?.unwrap === "function" && typeName === "ZodOptional") {
+            return this.fieldAdapter(f.unwrap()).optional();
+        }
+        if (typeof f?.unwrap === "function" && typeName === "ZodNullable") {
+            return this.fieldAdapter(f.unwrap()).nullable();
+        }
+        if (typeName === "ZodArray" && f?.element) {
+            return z.array(this.fieldAdapter(f.element));
+        }
+        if (typeName === "ZodObject" && f?.shape) {
+            return this.schemaAdapter(f);
+        }
+        if (typeName === "ZodDate") {
+            return z.iso.datetime();
+        }
+        return f;
+    }
+    schemaAdapter(schema) {
+        const shape = schema.shape;
+        const newShape = {};
+        for (const key of Object.keys(shape)) {
+            newShape[key] = this.fieldAdapter(shape[key]);
+        }
+        return z.object(newShape);
+    }
+}
+export default ToolBuilder;
+export { ToolBuilder };

package/dist/vectors/ChromaVector.js

@@ -0,0 +1,65 @@
+import { ChromaClient } from 'chromadb';
+class ChromaVector {
+    constructor(path = 'http://localhost:8000', database) {
+        this.client = new ChromaClient({ path, database });
+        this.collections = new Map();
+    }
+    async initializeCollection(collectionName) {
+        if (!this.collections.has(collectionName)) {
+            const collection = await this.client.createCollection({
+                name: collectionName,
+                // embeddingFunction: embeddingFunction
+            });
+            this.collections.set(collectionName, collection);
+        }
+    }
+    async addDocument(collectionName, document) {
+        await this.initializeCollection(collectionName);
+        const collection = this.collections.get(collectionName);
+        if (collection) {
+            await collection.add({
+                ids: [document.id],
+                documents: [document.content],
+                metadatas: [document.metadata || {}],
+                embeddings: document.embedding ? [document.embedding] : undefined, // Add this line
+            });
+        }
+        else {
+            throw new Error(`Collection ${collectionName} not found`);
+        }
+    }
+    async queryCollection(collectionName, query, topK = 5) {
+        await this.initializeCollection(collectionName);
+        const collection = this.collections.get(collectionName);
+        if (collection) {
+            const results = await collection.query({
+                queryTexts: [query],
+                nResults: topK,
+            });
+            return results.documents[0] || [];
+        }
+        else {
+            throw new Error(`Collection ${collectionName} not found`);
+        }
+    }
+    async deleteDocument(collectionName, documentId) {
+        const collection = this.collections.get(collectionName);
+        if (collection) {
+            await collection.delete({
+                ids: [documentId],
+            });
+        }
+        else {
+            throw new Error(`Collection ${collectionName} not found`);
+        }
+    }
+    async listCollections() {
+        return await this.client.listCollections();
+    }
+    async deleteCollection(collectionName) {
+        await this.client.deleteCollection({ name: collectionName });
+        this.collections.delete(collectionName);
+    }
+}
+export default ChromaVector;
+export { ChromaVector };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.35.1",
+  "version": "3.37.0",
   "description": "Ai utils",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -19,7 +19,7 @@
   "license": "ISC",
   "dependencies": {
     "@drax/ai-share": "^3.31.0",
-    "@drax/crud-back": "^3.32.0",
+    "@drax/crud-back": "^3.36.0",
     "mongoose": "^8.23.0",
     "mongoose-paginate-v2": "^1.8.3"
   },
@@ -46,5 +46,5 @@
     "typescript": "^5.9.3",
     "vitest": "^3.0.8"
   },
-  "gitHead": "5c5d65ae83b6da98c044cc868150e5e1780e18ca"
+  "gitHead": "eb4c24e68c7409b77d724d24f40b1e71b7d6d187"
 }