@hexabot-ai/api 3.2.2-alpha.14 → 3.2.2-alpha.16

package/dist/mcp/tools/workflow-mcp.tools.d.ts

@@ -0,0 +1,468 @@
+import { WorkflowService } from "../../workflow/services/workflow.service";
+import { DirectionType, WorkflowType, WorkflowVersionAction } from "../../workflow/types";
+import { HexabotMcpRequest } from '../types';
+import { HexabotMcpToolBase } from './hexabot-mcp-tool.base';
+import { PaginationArgs } from './hexabot-mcp.schemas';
+import { HexabotWorkflowMcpHelper } from './workflow-mcp.helper';
+export declare class HexabotWorkflowMcpTools extends HexabotMcpToolBase {
+    private readonly workflowService;
+    private readonly workflowHelper;
+    constructor(workflowService: WorkflowService, workflowHelper: HexabotWorkflowMcpHelper);
+    searchWorkflows(args: {
+        query?: string;
+        type?: WorkflowType;
+        createdById?: string;
+    } & PaginationArgs): Promise<{
+        items: unknown[];
+        total: number;
+        limit: number | undefined;
+        skip: number | undefined;
+    }>;
+    getWorkflow(args: {
+        id: string;
+    }): Promise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        name: string;
+        description: string | null;
+        type: import("@hexabot-ai/types/dist/types/workflow/domain").WorkflowType;
+        schedule: string | null;
+        inputSchema: any;
+        builtin: boolean;
+        x: number;
+        y: number;
+        zoom: number;
+        direction: import("@hexabot-ai/types/dist/types/workflow/domain").DirectionType;
+        currentVersion: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            version: number;
+            definitionYml: string;
+            checksum: string;
+            message: string | null;
+            action: import("@hexabot-ai/types/dist/types/workflow/domain").WorkflowVersionAction | null;
+            parentVersion: string | null;
+            workflow: string;
+            createdBy: string | null;
+        } | null;
+        publishedVersion: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            version: number;
+            definitionYml: string;
+            checksum: string;
+            message: string | null;
+            action: import("@hexabot-ai/types/dist/types/workflow/domain").WorkflowVersionAction | null;
+            parentVersion: string | null;
+            workflow: string;
+            createdBy: string | null;
+        } | null;
+        createdBy: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            firstName: string;
+            lastName: string;
+            language: string | null;
+            timezone: number;
+            locale: string | null;
+            gender: string | null;
+            country: string | null;
+            foreignId: string | null;
+            assignedAt: Date | null;
+            lastvisit: Date | null;
+            retainedFrom: Date | null;
+            channel: {
+                name: string | null;
+                data?: Record<string, any> | null | undefined;
+            };
+            username: string;
+            email: string;
+            sendEmail: boolean;
+            state: boolean;
+            resetCount: number;
+            resetToken: string | null;
+            labels: string[];
+            assignedTo: string | null;
+            roles: string[];
+            avatar: string | null;
+            provider?: {
+                strategy: "local";
+                sub?: string | undefined;
+            } | undefined;
+        } | null;
+        definitionYml?: string | undefined;
+        definition?: any;
+    }>;
+    getWorkflowVersionStatus(args: {
+        id: string;
+    }): Promise<{
+        workflow: {
+            id: string;
+            name: string;
+            type: WorkflowType;
+        };
+        currentVersion: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            message: string | null;
+            action: import("@hexabot-ai/types/dist/types/workflow/domain").WorkflowVersionAction | null;
+            createdBy: string | null;
+            workflow: string;
+            version: number;
+            parentVersion: string | null;
+            checksum: string;
+        } | null;
+        publishedVersion: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            message: string | null;
+            action: import("@hexabot-ai/types/dist/types/workflow/domain").WorkflowVersionAction | null;
+            createdBy: string | null;
+            workflow: string;
+            version: number;
+            parentVersion: string | null;
+            checksum: string;
+        } | null;
+        currentVersionId: string | null;
+        publishedVersionId: string | null;
+        isPublished: boolean;
+        isCurrentVersionPublished: boolean;
+        hasUnpublishedChanges: boolean;
+    }>;
+    createWorkflow(args: {
+        name: string;
+        description?: string;
+        type?: WorkflowType;
+        schedule?: string | null;
+        inputSchema?: Record<string, unknown>;
+        builtin?: boolean;
+        x?: number;
+        y?: number;
+        zoom?: number;
+        direction?: DirectionType;
+        definitionYml?: string;
+        versionMessage?: string;
+    }, _context: unknown, request?: HexabotMcpRequest): Promise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        name: string;
+        description: string | null;
+        type: import("@hexabot-ai/types/dist/types/workflow/domain").WorkflowType;
+        schedule: string | null;
+        inputSchema: any;
+        builtin: boolean;
+        x: number;
+        y: number;
+        zoom: number;
+        direction: import("@hexabot-ai/types/dist/types/workflow/domain").DirectionType;
+        currentVersion: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            version: number;
+            definitionYml: string;
+            checksum: string;
+            message: string | null;
+            action: import("@hexabot-ai/types/dist/types/workflow/domain").WorkflowVersionAction | null;
+            parentVersion: string | null;
+            workflow: string;
+            createdBy: string | null;
+        } | null;
+        publishedVersion: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            version: number;
+            definitionYml: string;
+            checksum: string;
+            message: string | null;
+            action: import("@hexabot-ai/types/dist/types/workflow/domain").WorkflowVersionAction | null;
+            parentVersion: string | null;
+            workflow: string;
+            createdBy: string | null;
+        } | null;
+        createdBy: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            firstName: string;
+            lastName: string;
+            language: string | null;
+            timezone: number;
+            locale: string | null;
+            gender: string | null;
+            country: string | null;
+            foreignId: string | null;
+            assignedAt: Date | null;
+            lastvisit: Date | null;
+            retainedFrom: Date | null;
+            channel: {
+                name: string | null;
+                data?: Record<string, any> | null | undefined;
+            };
+            username: string;
+            email: string;
+            sendEmail: boolean;
+            state: boolean;
+            resetCount: number;
+            resetToken: string | null;
+            labels: string[];
+            assignedTo: string | null;
+            roles: string[];
+            avatar: string | null;
+            provider?: {
+                strategy: "local";
+                sub?: string | undefined;
+            } | undefined;
+        } | null;
+        definitionYml?: string | undefined;
+        definition?: any;
+    }>;
+    updateWorkflow(args: {
+        id: string;
+        definitionYml?: string;
+        versionMessage?: string;
+    } & Record<string, unknown>, _context: unknown, request?: HexabotMcpRequest): Promise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        name: string;
+        description: string | null;
+        type: import("@hexabot-ai/types/dist/types/workflow/domain").WorkflowType;
+        schedule: string | null;
+        inputSchema: any;
+        builtin: boolean;
+        x: number;
+        y: number;
+        zoom: number;
+        direction: import("@hexabot-ai/types/dist/types/workflow/domain").DirectionType;
+        currentVersion: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            version: number;
+            definitionYml: string;
+            checksum: string;
+            message: string | null;
+            action: import("@hexabot-ai/types/dist/types/workflow/domain").WorkflowVersionAction | null;
+            parentVersion: string | null;
+            workflow: string;
+            createdBy: string | null;
+        } | null;
+        publishedVersion: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            version: number;
+            definitionYml: string;
+            checksum: string;
+            message: string | null;
+            action: import("@hexabot-ai/types/dist/types/workflow/domain").WorkflowVersionAction | null;
+            parentVersion: string | null;
+            workflow: string;
+            createdBy: string | null;
+        } | null;
+        createdBy: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            firstName: string;
+            lastName: string;
+            language: string | null;
+            timezone: number;
+            locale: string | null;
+            gender: string | null;
+            country: string | null;
+            foreignId: string | null;
+            assignedAt: Date | null;
+            lastvisit: Date | null;
+            retainedFrom: Date | null;
+            channel: {
+                name: string | null;
+                data?: Record<string, any> | null | undefined;
+            };
+            username: string;
+            email: string;
+            sendEmail: boolean;
+            state: boolean;
+            resetCount: number;
+            resetToken: string | null;
+            labels: string[];
+            assignedTo: string | null;
+            roles: string[];
+            avatar: string | null;
+            provider?: {
+                strategy: "local";
+                sub?: string | undefined;
+            } | undefined;
+        } | null;
+        definitionYml?: string | undefined;
+        definition?: any;
+    }>;
+    publishWorkflow(args: {
+        id: string;
+    }): Promise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        name: string;
+        description: string | null;
+        type: import("@hexabot-ai/types/dist/types/workflow/domain").WorkflowType;
+        schedule: string | null;
+        inputSchema: any;
+        builtin: boolean;
+        x: number;
+        y: number;
+        zoom: number;
+        direction: import("@hexabot-ai/types/dist/types/workflow/domain").DirectionType;
+        currentVersion: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            version: number;
+            definitionYml: string;
+            checksum: string;
+            message: string | null;
+            action: import("@hexabot-ai/types/dist/types/workflow/domain").WorkflowVersionAction | null;
+            parentVersion: string | null;
+            workflow: string;
+            createdBy: string | null;
+        } | null;
+        publishedVersion: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            version: number;
+            definitionYml: string;
+            checksum: string;
+            message: string | null;
+            action: import("@hexabot-ai/types/dist/types/workflow/domain").WorkflowVersionAction | null;
+            parentVersion: string | null;
+            workflow: string;
+            createdBy: string | null;
+        } | null;
+        createdBy: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            firstName: string;
+            lastName: string;
+            language: string | null;
+            timezone: number;
+            locale: string | null;
+            gender: string | null;
+            country: string | null;
+            foreignId: string | null;
+            assignedAt: Date | null;
+            lastvisit: Date | null;
+            retainedFrom: Date | null;
+            channel: {
+                name: string | null;
+                data?: Record<string, any> | null | undefined;
+            };
+            username: string;
+            email: string;
+            sendEmail: boolean;
+            state: boolean;
+            resetCount: number;
+            resetToken: string | null;
+            labels: string[];
+            assignedTo: string | null;
+            roles: string[];
+            avatar: string | null;
+            provider?: {
+                strategy: "local";
+                sub?: string | undefined;
+            } | undefined;
+        } | null;
+        definitionYml?: string | undefined;
+        definition?: any;
+    }>;
+    unpublishWorkflow(args: {
+        id: string;
+    }): Promise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        name: string;
+        description: string | null;
+        type: import("@hexabot-ai/types/dist/types/workflow/domain").WorkflowType;
+        schedule: string | null;
+        inputSchema: any;
+        builtin: boolean;
+        x: number;
+        y: number;
+        zoom: number;
+        direction: import("@hexabot-ai/types/dist/types/workflow/domain").DirectionType;
+        currentVersion: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            version: number;
+            definitionYml: string;
+            checksum: string;
+            message: string | null;
+            action: import("@hexabot-ai/types/dist/types/workflow/domain").WorkflowVersionAction | null;
+            parentVersion: string | null;
+            workflow: string;
+            createdBy: string | null;
+        } | null;
+        publishedVersion: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            version: number;
+            definitionYml: string;
+            checksum: string;
+            message: string | null;
+            action: import("@hexabot-ai/types/dist/types/workflow/domain").WorkflowVersionAction | null;
+            parentVersion: string | null;
+            workflow: string;
+            createdBy: string | null;
+        } | null;
+        createdBy: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            firstName: string;
+            lastName: string;
+            language: string | null;
+            timezone: number;
+            locale: string | null;
+            gender: string | null;
+            country: string | null;
+            foreignId: string | null;
+            assignedAt: Date | null;
+            lastvisit: Date | null;
+            retainedFrom: Date | null;
+            channel: {
+                name: string | null;
+                data?: Record<string, any> | null | undefined;
+            };
+            username: string;
+            email: string;
+            sendEmail: boolean;
+            state: boolean;
+            resetCount: number;
+            resetToken: string | null;
+            labels: string[];
+            assignedTo: string | null;
+            roles: string[];
+            avatar: string | null;
+            provider?: {
+                strategy: "local";
+                sub?: string | undefined;
+            } | undefined;
+        } | null;
+        definitionYml?: string | undefined;
+        definition?: any;
+    }>;
+    private buildWorkflowWhere;
+}

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

@@ -0,0 +1,222 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HexabotWorkflowMcpTools = void 0;
+const types_1 = require("@hexabot-ai/types");
+const common_1 = require("@nestjs/common");
+const mcp_nest_1 = require("@rekog/mcp-nest");
+const zod_1 = require("zod");
+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 hexabot_mcp_tool_base_1 = require("./hexabot-mcp-tool.base");
+const hexabot_mcp_schemas_1 = require("./hexabot-mcp.schemas");
+const workflow_mcp_helper_1 = require("./workflow-mcp.helper");
+let HexabotWorkflowMcpTools = class HexabotWorkflowMcpTools extends hexabot_mcp_tool_base_1.HexabotMcpToolBase {
+    constructor(workflowService, workflowHelper) {
+        super();
+        this.workflowService = workflowService;
+        this.workflowHelper = workflowHelper;
+    }
+    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.workflowHelper.requireWorkflow(args.id);
+    }
+    async getWorkflowVersionStatus(args) {
+        const workflow = await this.workflowHelper.requireWorkflow(args.id);
+        return this.workflowHelper.buildWorkflowVersionStatus(workflow);
+    }
+    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.workflowHelper.commitWorkflowDefinition({
+                workflowId: workflow.id,
+                definitionYml,
+                message: versionMessage,
+                action: types_2.WorkflowVersionAction.update,
+                createdBy: actorId,
+            });
+        }
+        return await this.workflowHelper.requireWorkflow(workflow.id);
+    }
+    async updateWorkflow(args, _context, request) {
+        const actorId = this.getActorId(request);
+        const { id, definitionYml, versionMessage, ...updates } = args;
+        await this.workflowHelper.requireWorkflow(id);
+        if (Object.keys(updates).length > 0) {
+            await this.workflowService.updateOne(id, updates);
+        }
+        if (definitionYml) {
+            await this.workflowHelper.commitWorkflowDefinition({
+                workflowId: id,
+                definitionYml,
+                message: versionMessage,
+                action: types_2.WorkflowVersionAction.update,
+                createdBy: actorId,
+            });
+        }
+        return await this.workflowHelper.requireWorkflow(id);
+    }
+    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.workflowHelper.requireWorkflow(args.id);
+    }
+    async unpublishWorkflow(args) {
+        await this.workflowHelper.requireWorkflow(args.id);
+        await this.workflowService.updateOne(args.id, { publishedVersion: null });
+        return await this.workflowHelper.requireWorkflow(args.id);
+    }
+    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;
+    }
+};
+exports.HexabotWorkflowMcpTools = HexabotWorkflowMcpTools;
+__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: hexabot_mcp_schemas_1.uuidSchema.optional(),
+            ...hexabot_mcp_schemas_1.paginationSchema,
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotWorkflowMcpTools.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: hexabot_mcp_schemas_1.uuidSchema,
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotWorkflowMcpTools.prototype, "getWorkflow", 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_version_status',
+        description: 'Check the current and published version pointers for one workflow.',
+        parameters: zod_1.z.object({
+            id: hexabot_mcp_schemas_1.uuidSchema,
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotWorkflowMcpTools.prototype, "getWorkflowVersionStatus", 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({
+            ...hexabot_mcp_schemas_1.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)
+], HexabotWorkflowMcpTools.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: hexabot_mcp_schemas_1.uuidSchema,
+            ...hexabot_mcp_schemas_1.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)
+], HexabotWorkflowMcpTools.prototype, "updateWorkflow", 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: hexabot_mcp_schemas_1.uuidSchema,
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotWorkflowMcpTools.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: hexabot_mcp_schemas_1.uuidSchema,
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HexabotWorkflowMcpTools.prototype, "unpublishWorkflow", null);
+exports.HexabotWorkflowMcpTools = HexabotWorkflowMcpTools = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [workflow_service_1.WorkflowService,
+        workflow_mcp_helper_1.HexabotWorkflowMcpHelper])
+], HexabotWorkflowMcpTools);
+//# sourceMappingURL=workflow-mcp.tools.js.map