@hexabot-ai/api 3.2.2-alpha.1 → 3.2.2-alpha.10

package/dist/mcp/tools/hexabot-mcp.tools.js

@@ -0,0 +1,957 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var HexabotMcpTools_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HexabotMcpTools = void 0;
+const types_1 = require("@hexabot-ai/types");
+const common_1 = require("@nestjs/common");
+const mcp_nest_1 = require("@rekog/mcp-nest");
+const typeorm_1 = require("typeorm");
+const zod_1 = require("zod");
+const actions_service_1 = require("../../actions/actions.service");
+const runtime_bindings_service_1 = require("../../bindings/runtime-bindings.service");
+const content_type_service_1 = require("../../cms/services/content-type.service");
+const content_service_1 = require("../../cms/services/content.service");
+const credential_service_1 = require("../../user/services/credential.service");
+const trigger_event_wrapper_1 = require("../../workflow/lib/trigger-event-wrapper");
+const workflow_definition_1 = require("../../workflow/lib/workflow-definition");
+const agentic_service_1 = require("../../workflow/services/agentic.service");
+const memory_definition_service_1 = require("../../workflow/services/memory-definition.service");
+const workflow_run_service_1 = require("../../workflow/services/workflow-run.service");
+const workflow_version_service_1 = require("../../workflow/services/workflow-version.service");
+const workflow_service_1 = require("../../workflow/services/workflow.service");
+const types_2 = require("../../workflow/types");
+const mcp_permission_decorator_1 = require("../decorators/mcp-permission.decorator");
+const mcp_permission_guard_1 = require("../guards/mcp-permission.guard");
+const uuidSchema = zod_1.z.string().uuid();
+const jsonObjectSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.unknown());
+const paginationSchema = {
+    limit: zod_1.z.number().int().min(1).max(100).default(20),
+    skip: zod_1.z.number().int().min(0).default(0),
+    sortBy: zod_1.z.string().default('createdAt'),
+    sortDirection: zod_1.z.enum(['ASC', 'DESC']).default('DESC'),
+};
+const workflowPayloadSchema = {
+    name: zod_1.z.string().min(1).optional(),
+    description: zod_1.z.string().optional(),
+    type: zod_1.z.enum(types_2.WorkflowType).optional(),
+    schedule: zod_1.z.string().nullable().optional(),
+    inputSchema: jsonObjectSchema.optional(),
+    builtin: zod_1.z.boolean().optional(),
+    x: zod_1.z.number().optional(),
+    y: zod_1.z.number().optional(),
+    zoom: zod_1.z.number().optional(),
+    direction: zod_1.z.enum(types_2.DirectionType).optional(),
+};
+let HexabotMcpTools = HexabotMcpTools_1 = class HexabotMcpTools {
+    constructor(workflowService, workflowVersionService, workflowRunService, agenticService, memoryDefinitionService, actionService, runtimeBindingsService, credentialService, contentTypeService, contentService) {
+        this.workflowService = workflowService;
+        this.workflowVersionService = workflowVersionService;
+        this.workflowRunService = workflowRunService;
+        this.agenticService = agenticService;
+        this.memoryDefinitionService = memoryDefinitionService;
+        this.actionService = actionService;
+        this.runtimeBindingsService = runtimeBindingsService;
+        this.credentialService = credentialService;
+        this.contentTypeService = contentTypeService;
+        this.contentService = contentService;
+    }
+    async searchWorkflows(args) {
+        const where = this.buildWorkflowWhere(args);
+        const options = this.findOptions(args, where);
+        return await this.listWithCount(this.workflowService, options);
+    }
+    async getWorkflow(args) {
+        return await this.requireWorkflow(args.id);
+    }
+    async createWorkflow(args, _context, request) {
+        const actorId = this.getActorId(request);
+        const { definitionYml, versionMessage, ...workflowPayload } = args;
+        const workflow = await this.workflowService.create({
+            ...workflowPayload,
+            createdBy: actorId,
+        });
+        if (definitionYml) {
+            await this.commitWorkflowDefinition({
+                workflowId: workflow.id,
+                definitionYml,
+                message: versionMessage,
+                action: types_2.WorkflowVersionAction.update,
+                createdBy: actorId,
+            });
+        }
+        return await this.requireWorkflow(workflow.id);
+    }
+    async updateWorkflow(args, _context, request) {
+        const actorId = this.getActorId(request);
+        const { id, definitionYml, versionMessage, ...updates } = args;
+        await this.requireWorkflow(id);
+        if (Object.keys(updates).length > 0) {
+            await this.workflowService.updateOne(id, updates);
+        }
+        if (definitionYml) {
+            await this.commitWorkflowDefinition({
+                workflowId: id,
+                definitionYml,
+                message: versionMessage,
+                action: types_2.WorkflowVersionAction.update,
+                createdBy: actorId,
+            });
+        }
+        return await this.requireWorkflow(id);
+    }
+    async commitWorkflowYaml(args, _context, request) {
+        const actorId = this.getActorId(request);
+        return await this.commitWorkflowDefinition({
+            ...args,
+            createdBy: actorId,
+        });
+    }
+    async searchWorkflowVersions(args) {
+        const where = { workflow: { id: args.workflowId } };
+        return await this.listWithCount(this.workflowVersionService, this.findOptions(args, where));
+    }
+    async getWorkflowVersion(args) {
+        const version = await this.workflowVersionService.findOneAndPopulate({
+            where: {
+                id: args.id,
+                ...(args.workflowId ? { workflow: { id: args.workflowId } } : {}),
+            },
+        });
+        if (!version) {
+            throw new common_1.NotFoundException(`Workflow version ${args.id} not found`);
+        }
+        return version;
+    }
+    async updateWorkflowVersion(args) {
+        return await this.workflowVersionService.updateOne(args.id, {
+            message: args.message ?? undefined,
+        });
+    }
+    async restoreWorkflowVersion(args, _context, request) {
+        return await this.workflowVersionService.restoreVersion(args.workflowId, args.versionId, {
+            updatedBy: this.getActorId(request),
+            message: args.message,
+        });
+    }
+    async publishWorkflow(args) {
+        const workflow = await this.workflowService.findOne(args.id);
+        if (!workflow) {
+            throw new common_1.NotFoundException(`Workflow ${args.id} not found`);
+        }
+        if (!workflow.currentVersion) {
+            throw new common_1.BadRequestException('Workflow must have a current version to be published');
+        }
+        await this.workflowService.updateOne(args.id, {
+            publishedVersion: workflow.currentVersion,
+        });
+        return await this.requireWorkflow(args.id);
+    }
+    async unpublishWorkflow(args) {
+        await this.requireWorkflow(args.id);
+        await this.workflowService.updateOne(args.id, { publishedVersion: null });
+        return await this.requireWorkflow(args.id);
+    }
+    async runWorkflow(args, _context, request) {
+        const actor = this.getActor(request);
+        const workflow = await this.workflowService.findOne(args.workflowId);
+        if (!workflow) {
+            throw new common_1.NotFoundException(`Workflow ${args.workflowId} not found`);
+        }
+        if (workflow.type !== types_2.WorkflowType.manual &&
+            workflow.type !== types_2.WorkflowType.scheduled) {
+            throw new common_1.BadRequestException('Workflow must be manual or scheduled to run manually');
+        }
+        const event = workflow.type === types_2.WorkflowType.scheduled
+            ? new trigger_event_wrapper_1.ScheduledEventWrapper({
+                schedule: workflow.schedule ?? null,
+                triggeredAt: new Date(),
+            })
+            : new trigger_event_wrapper_1.ManualEventWrapper(this.workflowService.validateManualInput(args.input ?? {}, workflow.inputSchema), actor.id);
+        event.setInitiator(actor);
+        event.setWorkflowId(workflow.id);
+        const run = await this.agenticService.handleEvent(event);
+        return { accepted: true, run };
+    }
+    async searchWorkflowRuns(args) {
+        const where = {
+            ...(args.workflowId ? { workflow: { id: args.workflowId } } : {}),
+            ...(args.status ? { status: args.status } : {}),
+        };
+        return await this.listWithCount(this.workflowRunService, this.findOptions(args, where));
+    }
+    async getWorkflowRun(args) {
+        const run = await this.workflowRunService.findOneAndPopulate(args.id);
+        if (!run) {
+            throw new common_1.NotFoundException(`Workflow run ${args.id} not found`);
+        }
+        return run;
+    }
+    async searchMemoryDefinitions(args) {
+        const base = args.scope ? { scope: args.scope } : {};
+        const where = args.query
+            ? [
+                { ...base, name: this.contains(args.query) },
+                { ...base, slug: this.contains(args.query) },
+            ]
+            : base;
+        return await this.listWithCount(this.memoryDefinitionService, this.findOptions(args, where));
+    }
+    async getMemoryDefinition(args) {
+        const definition = await this.memoryDefinitionService.findOne(args.id);
+        if (!definition) {
+            throw new common_1.NotFoundException(`Memory definition ${args.id} not found`);
+        }
+        return definition;
+    }
+    async createMemoryDefinition(args) {
+        return await this.memoryDefinitionService.create(args);
+    }
+    async updateMemoryDefinition(args) {
+        const { id, ...updates } = args;
+        return await this.memoryDefinitionService.updateOne(id, updates);
+    }
+    async searchActions(args) {
+        const query = args.query?.toLowerCase();
+        const actions = this.actionService.getAllSchemaDefinitions(args.workflowType);
+        return {
+            items: query
+                ? actions.filter((action) => [
+                    action.name,
+                    action.description,
+                    action.group,
+                    ...(action.workflowTypes ?? []),
+                ]
+                    .filter(Boolean)
+                    .some((value) => `${value}`.toLowerCase().includes(query)))
+                : actions,
+        };
+    }
+    async getAction(args) {
+        const action = this.actionService
+            .getAllSchemaDefinitions()
+            .find((entry) => entry.name === args.name);
+        if (!action) {
+            throw new common_1.NotFoundException(`Action ${args.name} not found`);
+        }
+        return action;
+    }
+    async searchBindings(args) {
+        const query = args.query?.toLowerCase();
+        const entries = Object.entries(this.runtimeBindingsService.getAllSchemaDefinitions()).map(([kind, definition]) => ({ kind, ...definition }));
+        return {
+            items: query
+                ? entries.filter((entry) => [entry.kind, entry.icon, entry.color]
+                    .filter(Boolean)
+                    .some((value) => `${value}`.toLowerCase().includes(query)))
+                : entries,
+        };
+    }
+    async getBinding(args) {
+        const bindings = this.runtimeBindingsService.getAllSchemaDefinitions();
+        const binding = bindings[args.kind];
+        if (!binding) {
+            throw new common_1.NotFoundException(`Binding kind ${args.kind} not found`);
+        }
+        return { kind: args.kind, ...binding };
+    }
+    async searchCredentials(args) {
+        const where = {
+            ...(args.ownerId ? { owner: { id: args.ownerId } } : {}),
+            ...(args.query ? { name: this.contains(args.query) } : {}),
+        };
+        const result = await this.listWithCount(this.credentialService, this.findOptions(args, where));
+        return {
+            ...result,
+            items: result.items.map(HexabotMcpTools_1.sanitizeCredential),
+        };
+    }
+    async getCredential(args) {
+        const credential = await this.credentialService.findOneAndPopulate(args.id);
+        if (!credential) {
+            throw new common_1.NotFoundException(`Credential ${args.id} not found`);
+        }
+        return HexabotMcpTools_1.sanitizeCredential(credential);
+    }
+    async searchContentTypes(args) {
+        const where = args.query ? { name: this.contains(args.query) } : {};
+        return await this.listWithCount(this.contentTypeService, this.findOptions(args, where));
+    }
+    async getContentType(args) {
+        const contentType = await this.contentTypeService.findOne(args.id);
+        if (!contentType) {
+            throw new common_1.NotFoundException(`Content type ${args.id} not found`);
+        }
+        return contentType;
+    }
+    async createContentType(args) {
+        return await this.contentTypeService.create(args);
+    }
+    async updateContentType(args) {
+        const { id, ...updates } = args;
+        return await this.contentTypeService.updateOne(id, updates);
+    }
+    async searchContent(args) {
+        if (args.query) {
+            return {
+                items: await this.contentService.textSearch(args.query, {
+                    status: args.status,
+                    contentTypeId: args.contentTypeId,
+                    limit: args.limit,
+                }),
+                limit: args.limit,
+                skip: 0,
+            };
+        }
+        const where = {
+            ...(args.contentTypeId
+                ? { contentType: { id: args.contentTypeId } }
+                : {}),
+            ...(args.status !== undefined ? { status: args.status } : {}),
+        };
+        return await this.listWithCount(this.contentService, this.findOptions(args, where));
+    }
+    async getContent(args) {
+        const content = await this.contentService.findOneAndPopulate(args.id);
+        if (!content) {
+            throw new common_1.NotFoundException(`Content ${args.id} not found`);
+        }
+        return content;
+    }
+    async createContent(args) {
+        return await this.contentService.create(args);
+    }
+    async updateContent(args) {
+        const { id, ...updates } = args;
+        return await this.contentService.updateOne(id, updates);
+    }
+    async searchRagContent(args) {
+        return {
+            items: await this.contentService.retrieve(args.query, {
+                mode: args.mode,
+                limit: args.limit,
+                contentTypeId: args.contentTypeId,
+                includeInactive: args.includeInactive,
+            }),
+        };
+    }
+    static sanitizeCredential(credential) {
+        const { value: _value, ...safeCredential } = credential;
+        return safeCredential;
+    }
+    buildWorkflowWhere(args) {
+        const base = {
+            ...(args.type ? { type: args.type } : {}),
+            ...(args.createdById ? { createdBy: { id: args.createdById } } : {}),
+        };
+        return args.query
+            ? [
+                { ...base, name: this.contains(args.query) },
+                { ...base, description: this.contains(args.query) },
+            ]
+            : base;
+    }
+    async requireWorkflow(id) {
+        const workflow = await this.workflowService.findOneAndPopulate(id);
+        if (!workflow) {
+            throw new common_1.NotFoundException(`Workflow ${id} not found`);
+        }
+        return workflow;
+    }
+    async commitWorkflowDefinition(params) {
+        await this.requireWorkflow(params.workflowId);
+        try {
+            (0, workflow_definition_1.parseWorkflowDefinition)(params.definitionYml);
+        }
+        catch (error) {
+            throw new common_1.BadRequestException(error instanceof Error ? error.message : 'Invalid workflow YAML');
+        }
+        const payload = {
+            workflow: params.workflowId,
+            definitionYml: params.definitionYml,
+            message: params.message ?? undefined,
+            parentVersion: params.parentVersion ?? undefined,
+            action: params.action ?? types_2.WorkflowVersionAction.update,
+            createdBy: params.createdBy,
+        };
+        return await this.workflowVersionService.commit(payload);
+    }
+    findOptions(args, where) {
+        return {
+            where,
+            take: args.limit,
+            skip: args.skip,
+            order: { [args.sortBy]: args.sortDirection },
+        };
+    }
+    async listWithCount(service, options) {
+        const [items, total] = await Promise.all([
+            service.findAndPopulate(options),
+            service.count({ where: options.where }),
+        ]);
+        return {
+            items,
+            total,
+            limit: options.take,
+            skip: options.skip,
+        };
+    }
+    contains(value) {
+        return (0, typeorm_1.Like)(`%${value}%`);
+    }
+    getActor(request) {
+        const actor = request?.hexabotUser ?? request?.user;
+        if (!actor?.id) {
+            throw new common_1.UnauthorizedException('MCP Hexabot user is required');
+        }
+        return actor;
+    }
+    getActorId(request) {
+        return this.getActor(request).id;
+    }
+};
+exports.HexabotMcpTools = HexabotMcpTools;
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('workflow', types_1.Action.READ),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_workflow_search',
+        description: 'Search Hexabot workflows by metadata.',
+        parameters: zod_1.z.object({
+            query: zod_1.z.string().optional(),
+            type: zod_1.z.enum(types_2.WorkflowType).optional(),
+            createdById: uuidSchema.optional(),
+            ...paginationSchema,
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "searchWorkflows", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('workflow', types_1.Action.READ),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_workflow_get',
+        description: 'Read a Hexabot workflow with populated version metadata.',
+        parameters: zod_1.z.object({
+            id: uuidSchema,
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "getWorkflow", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('workflow', types_1.Action.CREATE),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_workflow_create',
+        description: 'Create a Hexabot workflow. Optionally commit an initial workflow definition YAML.',
+        parameters: zod_1.z.object({
+            ...workflowPayloadSchema,
+            name: zod_1.z.string().min(1),
+            definitionYml: zod_1.z.string().optional(),
+            versionMessage: zod_1.z.string().optional(),
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "createWorkflow", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('workflow', types_1.Action.UPDATE),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_workflow_update',
+        description: 'Update workflow metadata. Optionally commit a new workflow definition YAML version.',
+        parameters: zod_1.z.object({
+            id: uuidSchema,
+            ...workflowPayloadSchema,
+            definitionYml: zod_1.z.string().optional(),
+            versionMessage: zod_1.z.string().optional(),
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "updateWorkflow", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('workflowversion', types_1.Action.CREATE),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_workflow_yaml_commit',
+        description: 'Validate and commit workflow definition YAML as a new version.',
+        parameters: zod_1.z.object({
+            workflowId: uuidSchema,
+            definitionYml: zod_1.z.string().min(1),
+            message: zod_1.z.string().optional(),
+            parentVersion: uuidSchema.nullable().optional(),
+            action: zod_1.z
+                .enum(types_2.WorkflowVersionAction)
+                .default(types_2.WorkflowVersionAction.update),
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "commitWorkflowYaml", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('workflowversion', types_1.Action.READ),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_workflow_version_search',
+        description: 'List workflow definition YAML versions for a workflow.',
+        parameters: zod_1.z.object({
+            workflowId: uuidSchema,
+            ...paginationSchema,
+            sortBy: zod_1.z.string().default('version'),
+            sortDirection: zod_1.z.enum(['ASC', 'DESC']).default('DESC'),
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "searchWorkflowVersions", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('workflowversion', types_1.Action.READ),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_workflow_version_get',
+        description: 'Read one workflow definition YAML version.',
+        parameters: zod_1.z.object({
+            id: uuidSchema,
+            workflowId: uuidSchema.optional(),
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "getWorkflowVersion", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('workflowversion', types_1.Action.UPDATE),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_workflow_version_update',
+        description: 'Update workflow version metadata such as the version message.',
+        parameters: zod_1.z.object({
+            id: uuidSchema,
+            message: zod_1.z.string().nullable().optional(),
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "updateWorkflowVersion", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('workflowversion', types_1.Action.CREATE),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_workflow_version_restore',
+        description: 'Restore a workflow to a previous YAML version by creating a new restore snapshot.',
+        parameters: zod_1.z.object({
+            workflowId: uuidSchema,
+            versionId: uuidSchema,
+            message: zod_1.z.string().optional(),
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "restoreWorkflowVersion", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('workflow', types_1.Action.UPDATE),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_workflow_publish',
+        description: 'Publish the current workflow version.',
+        parameters: zod_1.z.object({
+            id: uuidSchema,
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "publishWorkflow", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('workflow', types_1.Action.UPDATE),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_workflow_unpublish',
+        description: 'Clear the published workflow version.',
+        parameters: zod_1.z.object({
+            id: uuidSchema,
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "unpublishWorkflow", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('workflowrun', types_1.Action.CREATE),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_workflow_run',
+        description: 'Run a manual or scheduled workflow and return the run summary.',
+        parameters: zod_1.z.object({
+            workflowId: uuidSchema,
+            input: jsonObjectSchema.default({}),
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "runWorkflow", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('workflowrun', types_1.Action.READ),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_workflow_run_search',
+        description: 'Search workflow runs by workflow and status.',
+        parameters: zod_1.z.object({
+            workflowId: uuidSchema.optional(),
+            status: zod_1.z.string().optional(),
+            ...paginationSchema,
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "searchWorkflowRuns", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('workflowrun', types_1.Action.READ),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_workflow_run_get',
+        description: 'Read one workflow run with populated workflow metadata.',
+        parameters: zod_1.z.object({
+            id: uuidSchema,
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "getWorkflowRun", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('memorydefinition', types_1.Action.READ),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_memory_definition_search',
+        description: 'Search workflow memory definitions.',
+        parameters: zod_1.z.object({
+            query: zod_1.z.string().optional(),
+            scope: zod_1.z.enum(types_2.MemoryScope).optional(),
+            ...paginationSchema,
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "searchMemoryDefinitions", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('memorydefinition', types_1.Action.READ),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_memory_definition_get',
+        description: 'Read one workflow memory definition.',
+        parameters: zod_1.z.object({
+            id: uuidSchema,
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "getMemoryDefinition", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('memorydefinition', types_1.Action.CREATE),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_memory_definition_create',
+        description: 'Create a workflow memory definition.',
+        parameters: zod_1.z.object({
+            name: zod_1.z.string().min(1),
+            slug: zod_1.z.string().regex(/^[a-z0-9_]+$/),
+            scope: zod_1.z.enum(types_2.MemoryScope),
+            schema: jsonObjectSchema,
+            ttlSeconds: zod_1.z.number().int().min(1).nullable().optional(),
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "createMemoryDefinition", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('memorydefinition', types_1.Action.UPDATE),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_memory_definition_update',
+        description: 'Update a workflow memory definition.',
+        parameters: zod_1.z.object({
+            id: uuidSchema,
+            name: zod_1.z.string().min(1).optional(),
+            slug: zod_1.z
+                .string()
+                .regex(/^[a-z0-9_]+$/)
+                .optional(),
+            scope: zod_1.z.enum(types_2.MemoryScope).optional(),
+            schema: jsonObjectSchema.optional(),
+            ttlSeconds: zod_1.z.number().int().min(1).nullable().optional(),
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "updateMemoryDefinition", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('workflow', types_1.Action.READ),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_action_search',
+        description: 'Search available workflow actions and their schemas.',
+        parameters: zod_1.z.object({
+            query: zod_1.z.string().optional(),
+            workflowType: zod_1.z.enum(types_2.WorkflowType).optional(),
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "searchActions", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('workflow', types_1.Action.READ),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_action_get',
+        description: 'Read schema metadata for one workflow action.',
+        parameters: zod_1.z.object({
+            name: zod_1.z.string().min(1),
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "getAction", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('workflow', types_1.Action.READ),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_binding_search',
+        description: 'Search workflow runtime binding kind schemas.',
+        parameters: zod_1.z.object({
+            query: zod_1.z.string().optional(),
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "searchBindings", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('workflow', types_1.Action.READ),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_binding_get',
+        description: 'Read schema metadata for one workflow runtime binding kind.',
+        parameters: zod_1.z.object({
+            kind: zod_1.z.string().min(1),
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "getBinding", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('credential', types_1.Action.READ),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_credential_search',
+        description: 'Search credentials by metadata only. Secret credential values are never returned.',
+        parameters: zod_1.z.object({
+            query: zod_1.z.string().optional(),
+            ownerId: uuidSchema.optional(),
+            ...paginationSchema,
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "searchCredentials", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('credential', types_1.Action.READ),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_credential_get',
+        description: 'Read credential metadata. Secret credential values are never returned.',
+        parameters: zod_1.z.object({
+            id: uuidSchema,
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "getCredential", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('contenttype', types_1.Action.READ),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_content_type_search',
+        description: 'Search CMS content types.',
+        parameters: zod_1.z.object({
+            query: zod_1.z.string().optional(),
+            ...paginationSchema,
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "searchContentTypes", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('contenttype', types_1.Action.READ),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_content_type_get',
+        description: 'Read one CMS content type.',
+        parameters: zod_1.z.object({
+            id: uuidSchema,
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "getContentType", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('contenttype', types_1.Action.CREATE),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_content_type_create',
+        description: 'Create a CMS content type.',
+        parameters: zod_1.z.object({
+            name: zod_1.z.string().min(1),
+            schema: jsonObjectSchema,
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "createContentType", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('contenttype', types_1.Action.UPDATE),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_content_type_update',
+        description: 'Update a CMS content type.',
+        parameters: zod_1.z.object({
+            id: uuidSchema,
+            name: zod_1.z.string().min(1).optional(),
+            schema: jsonObjectSchema.optional(),
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "updateContentType", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('content', types_1.Action.READ),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_content_search',
+        description: 'Search CMS content records.',
+        parameters: zod_1.z.object({
+            query: zod_1.z.string().optional(),
+            contentTypeId: uuidSchema.optional(),
+            status: zod_1.z.boolean().optional(),
+            ...paginationSchema,
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "searchContent", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('content', types_1.Action.READ),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_content_get',
+        description: 'Read one CMS content record.',
+        parameters: zod_1.z.object({
+            id: uuidSchema,
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "getContent", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('content', types_1.Action.CREATE),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_content_create',
+        description: 'Create a CMS content record.',
+        parameters: zod_1.z.object({
+            contentType: uuidSchema,
+            title: zod_1.z.string().min(1),
+            status: zod_1.z.boolean().optional(),
+            properties: jsonObjectSchema.optional(),
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "createContent", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('content', types_1.Action.UPDATE),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_content_update',
+        description: 'Update a CMS content record.',
+        parameters: zod_1.z.object({
+            id: uuidSchema,
+            contentType: uuidSchema.optional(),
+            title: zod_1.z.string().min(1).optional(),
+            status: zod_1.z.boolean().optional(),
+            properties: jsonObjectSchema.optional(),
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "updateContent", null);
+__decorate([
+    (0, mcp_permission_decorator_1.McpPermission)('content', types_1.Action.READ),
+    (0, mcp_nest_1.ToolGuards)([mcp_permission_guard_1.McpPermissionGuard]),
+    (0, mcp_nest_1.Tool)({
+        name: 'hexabot_rag_content_search',
+        description: 'Search indexed CMS content through Hexabot RAG retrieval.',
+        parameters: zod_1.z.object({
+            query: zod_1.z.string().min(1),
+            mode: zod_1.z.enum(['embedding', 'lexical']).optional(),
+            limit: zod_1.z.number().int().min(1).max(50).default(10),
+            contentTypeId: uuidSchema.optional(),
+            includeInactive: zod_1.z.boolean().optional(),
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotMcpTools.prototype, "searchRagContent", null);
+exports.HexabotMcpTools = HexabotMcpTools = HexabotMcpTools_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [workflow_service_1.WorkflowService,
+        workflow_version_service_1.WorkflowVersionService,
+        workflow_run_service_1.WorkflowRunService,
+        agentic_service_1.AgenticService,
+        memory_definition_service_1.MemoryDefinitionService,
+        actions_service_1.ActionService,
+        runtime_bindings_service_1.RuntimeBindingsService,
+        credential_service_1.CredentialService,
+        content_type_service_1.ContentTypeService,
+        content_service_1.ContentService])
+], HexabotMcpTools);
+//# sourceMappingURL=hexabot-mcp.tools.js.map