@drax/ai-back 3.29.0 → 3.32.0

package/dist/models/AgentSessionModel.js

@@ -0,0 +1,31 @@
+import { mongoose } from '@drax/common-back';
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2';
+const AgentSessionSchema = new mongoose.Schema({
+    sessionId: { type: String, required: true, index: true, unique: false },
+    title: { type: String, required: false, index: false, unique: false },
+    lastMessageAt: { type: Date, required: false, index: true, unique: false },
+    messages: [{
+            role: { type: String, enum: ['user', 'assistant', 'system'], required: true, index: false, unique: false },
+            content: { type: String, required: true, index: false, unique: false },
+            createdAt: { type: Date, required: false, index: false, unique: false }
+        }],
+    messageCount: { type: Number, 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 },
+    tenant: { type: mongoose.Schema.Types.ObjectId, ref: 'Tenant', required: false, index: true, unique: false },
+    user: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: false, index: true, unique: false }
+}, { timestamps: true });
+AgentSessionSchema.plugin(uniqueValidator, { message: 'validation.unique' });
+AgentSessionSchema.plugin(mongoosePaginate);
+AgentSessionSchema.virtual("id").get(function () {
+    return this._id.toString();
+});
+AgentSessionSchema.set('toJSON', { getters: true, virtuals: true });
+AgentSessionSchema.set('toObject', { getters: true, virtuals: true });
+const MODEL_NAME = 'AgentSession';
+const COLLECTION_NAME = 'AgentSession';
+const AgentSessionModel = mongoose.model(MODEL_NAME, AgentSessionSchema, COLLECTION_NAME);
+export { AgentSessionSchema, AgentSessionModel };
+export default AgentSessionModel;

package/dist/permissions/AgentPermissions.js

@@ -0,0 +1,6 @@
+var AgentPermissions;
+(function (AgentPermissions) {
+    AgentPermissions["Session"] = "agent:session";
+})(AgentPermissions || (AgentPermissions = {}));
+export { AgentPermissions };
+export default AgentPermissions;

package/dist/permissions/AgentSessionPermissions.js

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

package/dist/repository/mongo/AgentSessionMongoRepository.js

@@ -0,0 +1,13 @@
+import { AbstractMongoRepository } from "@drax/crud-back";
+import { AgentSessionModel } from "../../models/AgentSessionModel.js";
+class AgentSessionMongoRepository extends AbstractMongoRepository {
+    constructor() {
+        super();
+        this._model = AgentSessionModel;
+        this._searchFields = ['sessionId', 'title'];
+        this._populateFields = ['tenant', 'user'];
+        this._lean = true;
+    }
+}
+export default AgentSessionMongoRepository;
+export { AgentSessionMongoRepository };

package/dist/repository/sqlite/AgentSessionSqliteRepository.js

@@ -0,0 +1,34 @@
+import { AbstractSqliteRepository } from "@drax/crud-back";
+class AgentSessionSqliteRepository extends AbstractSqliteRepository {
+    constructor() {
+        super(...arguments);
+        this.tableName = 'AgentSession';
+        this.searchFields = ['sessionId', 'title'];
+        this.booleanFields = [];
+        this.jsonFields = ['messages'];
+        this.identifier = '_id';
+        this.populateFields = [
+            { field: 'tenant', table: 'tenant', identifier: '_id' },
+            { field: 'user', table: 'user', identifier: '_id' }
+        ];
+        this.verbose = false;
+        this.tableFields = [
+            { name: "sessionId", type: "TEXT", unique: false, primary: false },
+            { name: "title", type: "TEXT", unique: false, primary: false },
+            { name: "lastMessageAt", type: "TEXT", unique: false, primary: false },
+            { name: "messages", type: "TEXT", unique: false, primary: false },
+            { name: "messageCount", type: "NUMERIC", unique: false, primary: false },
+            { name: "messageCount", type: "TEXT", unique: false, primary: false },
+            { name: "inputTokens", type: "NUMERIC", unique: false, primary: false },
+            { name: "inputTokens", type: "TEXT", unique: false, primary: false },
+            { name: "outputTokens", type: "NUMERIC", unique: false, primary: false },
+            { name: "outputTokens", type: "TEXT", unique: false, primary: false },
+            { name: "tokens", type: "NUMERIC", unique: false, primary: false },
+            { name: "tokens", type: "TEXT", unique: false, primary: false },
+            { name: "tenant", type: "TEXT", unique: false, primary: false },
+            { name: "user", type: "TEXT", unique: false, primary: false }
+        ];
+    }
+}
+export default AgentSessionSqliteRepository;
+export { AgentSessionSqliteRepository };

package/dist/routes/AgentSessionRoutes.js

@@ -0,0 +1,21 @@
+import AgentSessionController from "../controllers/AgentSessionController.js";
+import { CrudSchemaBuilder } from "@drax/crud-back";
+import { AgentSessionSchema, AgentSessionBaseSchema } from '../schemas/AgentSessionSchema.js';
+async function AgentSessionRoutes(fastify, options) {
+    const controller = new AgentSessionController();
+    const schemas = new CrudSchemaBuilder(AgentSessionSchema, AgentSessionBaseSchema, AgentSessionBaseSchema, 'AgentSession', 'openapi-3.0', ['ai']);
+    fastify.get('/api/agentsession', { schema: schemas.paginateSchema }, (req, rep) => controller.paginate(req, rep));
+    fastify.get('/api/agentsession/find', { schema: schemas.findSchema }, (req, rep) => controller.find(req, rep));
+    fastify.get('/api/agentsession/search', { schema: schemas.searchSchema }, (req, rep) => controller.search(req, rep));
+    fastify.get('/api/agentsession/:id', { schema: schemas.findByIdSchema }, (req, rep) => controller.findById(req, rep));
+    fastify.get('/api/agentsession/find-one', { schema: schemas.findOneSchema }, (req, rep) => controller.findOne(req, rep));
+    fastify.get('/api/agentsession/group-by', { schema: schemas.groupBySchema }, (req, rep) => controller.groupBy(req, rep));
+    fastify.post('/api/agentsession', { schema: schemas.createSchema }, (req, rep) => controller.create(req, rep));
+    fastify.put('/api/agentsession/:id', { schema: schemas.updateSchema }, (req, rep) => controller.update(req, rep));
+    fastify.patch('/api/agentsession/:id', { schema: schemas.updateSchema }, (req, rep) => controller.updatePartial(req, rep));
+    fastify.delete('/api/agentsession/:id', { schema: schemas.deleteSchema }, (req, rep) => controller.delete(req, rep));
+    fastify.get('/api/agentsession/export', (req, rep) => controller.export(req, rep));
+    fastify.post('/api/agentsession/import', (req, rep) => controller.import(req, rep));
+}
+export default AgentSessionRoutes;
+export { AgentSessionRoutes };

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

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

package/dist/schemas/AgentSessionSchema.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+const AgentSessionBaseSchema = z.object({
+    sessionId: z.string().min(1, 'validation.required'),
+    title: z.string().optional(),
+    lastMessageAt: z.coerce.date().nullable().optional(),
+    messages: z.array(z.object({
+        role: z.enum(['user', 'assistant', 'system']),
+        content: z.string().min(1, 'validation.required'),
+        createdAt: z.coerce.date().nullable().optional()
+    })).optional(),
+    messageCount: z.number().nullable().optional(),
+    inputTokens: z.number().nullable().optional(),
+    outputTokens: z.number().nullable().optional(),
+    tokens: z.number().nullable().optional(),
+    tenant: z.coerce.string().optional().nullable(),
+    user: z.coerce.string().optional().nullable()
+});
+const AgentSessionSchema = AgentSessionBaseSchema
+    .extend({
+    _id: z.coerce.string(),
+    tenant: z.object({ _id: z.coerce.string(), name: z.string().optional() }).nullable(),
+    user: z.object({ _id: z.coerce.string(), username: z.string().optional() }).nullable()
+});
+export default AgentSessionSchema;
+export { AgentSessionSchema, AgentSessionBaseSchema };

package/dist/services/AgentSessionService.js

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

package/dist/tools/BuilderTool.js

@@ -0,0 +1,248 @@
+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 BuilderTool {
+    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),
+            navigation: {
+                entityName: this.options.entityName,
+                method,
+                basePath: this.options.navigationBasePath,
+            },
+            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 BuilderTool;
+export { BuilderTool };

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 };