n8n 2.35.2 → 2.36.0

package/dist/modules/mcp/tools/workflow-builder/update-workflow.tool.js

@@ -1,14 +1,12 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createUpdateWorkflowTool = void 0;
 const db_1 = require("@n8n/db");
 const permissions_1 = require("@n8n/permissions");
 const n8n_workflow_1 = require("n8n-workflow");
-const zod_1 = __importDefault(require("zod"));
-const mcp_constants_1 = require("../../mcp.constants");
+const zod_1 = require("zod");
+const subworkflow_policy_denial_error_1 = require("../../../../errors/subworkflow-policy-denial.error");
+const workflow_helpers_1 = require("../../../../workflow-helpers");
 const connection_structure_check_1 = require("./connection-structure-check");
 const constants_1 = require("./constants");
 const credential_validation_1 = require("./credential-validation");
@@ -17,8 +15,7 @@ const data_table_validation_1 = require("./data-table-validation");
 const skills_used_1 = require("./skills-used");
 const version_metadata_1 = require("./version-metadata");
 const workflow_operations_1 = require("./workflow-operations");
-const subworkflow_policy_denial_error_1 = require("../../../../errors/subworkflow-policy-denial.error");
-const workflow_helpers_1 = require("../../../../workflow-helpers");
+const mcp_constants_1 = require("../../mcp.constants");
 const workflow_validation_utils_1 = require("../workflow-validation.utils");
 const MAX_OPERATIONS_PER_CALL = 100;
 const baseOperationTypes = [
@@ -39,137 +36,127 @@ const baseOperationTypes = [
     'removeTags',
     'setNodeGroups',
 ];
-const gatedGroupOperationTypes = ['addNodeGroup', 'removeNodeGroup', 'updateNodeGroup'];
+const gatedGroupOperationTypes = [
+    'addNodeGroup',
+    'removeNodeGroup',
+    'updateNodeGroup',
+];
 const GATED_GROUP_OP_TYPES = new Set(gatedGroupOperationTypes);
 const buildOperationTypeSchema = (canvasGroupsEnabled) => canvasGroupsEnabled
-    ? zod_1.default.enum([...baseOperationTypes, ...gatedGroupOperationTypes])
-    : zod_1.default.enum(baseOperationTypes);
-const positionInputSchema = zod_1.default.array(zod_1.default.number()).length(2).describe('Canvas [x, y].');
-const credentialsInputSchema = zod_1.default.record(zod_1.default.string(), zod_1.default.object({ id: zod_1.default.string().optional(), name: zod_1.default.string() }));
-const nodeInputSchema = zod_1.default.object({
-    name: zod_1.default.string().describe('Unique node name.'),
-    type: zod_1.default.string().describe('Node type, e.g. "n8n-nodes-base.set".'),
-    typeVersion: zod_1.default.number(),
-    parameters: zod_1.default.record(zod_1.default.string(), zod_1.default.unknown()).optional(),
+    ? zod_1.z.enum([...baseOperationTypes, ...gatedGroupOperationTypes])
+    : zod_1.z.enum(baseOperationTypes);
+const positionInputSchema = zod_1.z.array(zod_1.z.number()).length(2).describe('Canvas [x, y].');
+const credentialsInputSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.object({ id: zod_1.z.string().optional(), name: zod_1.z.string() }));
+const nodeInputSchema = zod_1.z.object({
+    name: zod_1.z.string().describe('Unique node name.'),
+    type: zod_1.z.string().describe('Node type, e.g. "n8n-nodes-base.set".'),
+    typeVersion: zod_1.z.number(),
+    parameters: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
     position: positionInputSchema.optional(),
     credentials: credentialsInputSchema.optional(),
-    disabled: zod_1.default.boolean().optional(),
-    notes: zod_1.default.string().optional(),
-    id: zod_1.default.string().optional(),
+    disabled: zod_1.z.boolean().optional(),
+    notes: zod_1.z.string().optional(),
+    id: zod_1.z.string().optional(),
 });
-const nodeSettingsInputSchema = zod_1.default.object({
-    onError: zod_1.default
+const nodeSettingsInputSchema = zod_1.z.object({
+    onError: zod_1.z
         .enum(['stopWorkflow', 'continueRegularOutput', 'continueErrorOutput'])
         .optional()
         .describe('Error behavior.'),
-    retryOnFail: zod_1.default.boolean().optional(),
-    maxTries: zod_1.default.number().int().min(2).max(5).optional(),
-    waitBetweenTries: zod_1.default.number().int().min(0).max(5000).optional(),
-    alwaysOutputData: zod_1.default.boolean().optional(),
-    executeOnce: zod_1.default.boolean().optional(),
+    retryOnFail: zod_1.z.boolean().optional(),
+    maxTries: zod_1.z.number().int().min(2).max(5).optional(),
+    waitBetweenTries: zod_1.z.number().int().min(0).max(5000).optional(),
+    alwaysOutputData: zod_1.z.boolean().optional(),
+    executeOnce: zod_1.z.boolean().optional(),
 });
-const combinedSettingsInputSchema = zod_1.default
+const combinedSettingsInputSchema = zod_1.z
     .object({
     ...nodeSettingsInputSchema.shape,
     ...workflow_operations_1.workflowSettingsObjectSchema.shape,
 })
     .describe('Settings to write. For setNodeSettings use the node-level keys (onError, retryOnFail, maxTries, waitBetweenTries, alwaysOutputData, executeOnce). For setWorkflowSettings use the workflow-level keys (errorWorkflow, timezone, executionOrder, saveExecutionProgress, saveManualExecutions, saveDataErrorExecution, saveDataSuccessExecution, executionTimeout, timeSavedPerExecution, callerPolicy, callerIds). Provide only the keys for the operation you are running.');
-const buildOperationInputSchema = (canvasGroupsEnabled) => zod_1.default
+const buildOperationInputSchema = (canvasGroupsEnabled) => zod_1.z
     .object({
     type: buildOperationTypeSchema(canvasGroupsEnabled).describe('Operation type.'),
-    nodeName: zod_1.default.string().optional().describe('For node-targeted ops.'),
+    nodeName: zod_1.z.string().optional().describe('For node-targeted ops.'),
     node: nodeInputSchema.optional().describe('For addNode.'),
-    parameters: zod_1.default
-        .record(zod_1.default.string(), zod_1.default.unknown())
+    parameters: zod_1.z
+        .record(zod_1.z.string(), zod_1.z.unknown())
         .optional()
         .describe('For updateNodeParameters.'),
-    replace: zod_1.default.boolean().optional().describe('For updateNodeParameters; default false.'),
-    path: zod_1.default.string().min(2).optional().describe('For setNodeParameter; JSON Pointer path.'),
-    value: zod_1.default.unknown().optional().describe('For setNodeParameter.'),
-    oldName: zod_1.default.string().optional().describe('For renameNode.'),
-    newName: zod_1.default
+    replace: zod_1.z.boolean().optional().describe('For updateNodeParameters; default false.'),
+    path: zod_1.z.string().min(2).optional().describe('For setNodeParameter; JSON Pointer path.'),
+    value: zod_1.z.unknown().optional().describe('For setNodeParameter.'),
+    oldName: zod_1.z.string().optional().describe('For renameNode.'),
+    newName: zod_1.z
         .string()
         .optional()
         .describe(canvasGroupsEnabled ? 'For renameNode or updateNodeGroup.' : 'For renameNode.'),
-    source: zod_1.default.string().optional().describe('For connection ops.'),
-    target: zod_1.default.string().optional().describe('For connection ops.'),
-    sourceIndex: zod_1.default
+    source: zod_1.z.string().optional().describe('For connection ops.'),
+    target: zod_1.z.string().optional().describe('For connection ops.'),
+    sourceIndex: zod_1.z
         .number()
         .int()
         .nonnegative()
         .optional()
         .describe('For connection ops; default 0.'),
-    targetIndex: zod_1.default
+    targetIndex: zod_1.z
         .number()
         .int()
         .nonnegative()
         .optional()
         .describe('For connection ops; default 0.'),
-    connectionType: zod_1.default.string().optional().describe('For connection ops; default "main".'),
-    credentialKey: zod_1.default.string().optional().describe('For setNodeCredential.'),
-    credentialId: zod_1.default.string().optional().describe('For setNodeCredential.'),
-    credentialName: zod_1.default.string().optional().describe('For setNodeCredential.'),
+    connectionType: zod_1.z.string().optional().describe('For connection ops; default "main".'),
+    credentialKey: zod_1.z.string().optional().describe('For setNodeCredential.'),
+    credentialId: zod_1.z.string().optional().describe('For setNodeCredential.'),
+    credentialName: zod_1.z.string().optional().describe('For setNodeCredential.'),
     position: positionInputSchema.optional().describe('For setNodePosition.'),
-    disabled: zod_1.default.boolean().optional().describe('For setNodeDisabled.'),
+    disabled: zod_1.z.boolean().optional().describe('For setNodeDisabled.'),
     settings: combinedSettingsInputSchema
         .optional()
         .describe('For setNodeSettings or setWorkflowSettings.'),
-    name: zod_1.default
+    name: zod_1.z
         .string()
         .max(128)
         .optional()
         .describe(canvasGroupsEnabled
         ? 'For setWorkflowMetadata (workflow name) or addNodeGroup (group name).'
         : 'Only used for setWorkflowMetadata.'),
-    description: zod_1.default
+    description: zod_1.z
         .string()
         .max(255)
         .optional()
         .describe(canvasGroupsEnabled
         ? 'For setWorkflowMetadata, addNodeGroup, or updateNodeGroup.'
         : 'Only used for setWorkflowMetadata.'),
-    names: zod_1.default.array(zod_1.default.string()).optional().describe('For addTags / removeTags.'),
-    nodeGroups: zod_1.default
-        .array(zod_1.default.object({
-        id: zod_1.default.string().optional(),
-        name: zod_1.default.string(),
-        nodeNames: zod_1.default.array(zod_1.default.string()),
-        description: zod_1.default.string().optional(),
+    names: zod_1.z.array(zod_1.z.string()).optional().describe('For addTags / removeTags.'),
+    nodeGroups: zod_1.z
+        .array(zod_1.z.object({
+        id: zod_1.z.string().optional(),
+        name: zod_1.z.string(),
+        nodeNames: zod_1.z.array(zod_1.z.string()),
+        description: zod_1.z.string().optional(),
     }))
         .optional()
         .describe('For setNodeGroups. Replaces all node groups; pass [] to clear. Group members are node names, not ids.'),
     ...(canvasGroupsEnabled
         ? {
-            groupName: zod_1.default.string().optional().describe('For removeNodeGroup / updateNodeGroup.'),
-            nodeNames: zod_1.default
-                .array(zod_1.default.string())
+            groupName: zod_1.z.string().optional().describe('For removeNodeGroup / updateNodeGroup.'),
+            nodeNames: zod_1.z
+                .array(zod_1.z.string())
                 .optional()
                 .describe('For addNodeGroup / updateNodeGroup; group member node names.'),
-            id: zod_1.default.string().optional().describe('For addNodeGroup; group id, generated if omitted.'),
+            id: zod_1.z.string().optional().describe('For addNodeGroup; group id, generated if omitted.'),
         }
         : {}),
 })
     .describe('Workflow update operation. Provide fields matching type.');
-const strictOperationsSchema = zod_1.default.array(workflow_operations_1.partialUpdateOperationSchema);
-function dedupeNamesPreservingCase(names) {
-    const seen = new Set();
-    const result = [];
-    for (const raw of names) {
-        const trimmed = raw.trim();
-        if (trimmed.length === 0)
-            continue;
-        const key = trimmed.toLowerCase();
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        result.push(trimmed);
-    }
-    return result;
-}
+const strictOperationsSchema = zod_1.z.array(workflow_operations_1.partialUpdateOperationSchema);
 function parseStrictOperations(operations) {
     const parsed = strictOperationsSchema.safeParse(operations);
-    if (parsed.success)
+    if (parsed.success) {
         return parsed.data;
+    }
     const details = parsed.error.issues
         .map(({ path, message }) => {
         const [index, ...rest] = path;
@@ -181,50 +168,6 @@ function parseStrictOperations(operations) {
         .join('; ');
     throw new Error(`Invalid operations: ${details}`);
 }
-function collectTouchedNodes(operations) {
-    const touched = new Map();
-    const recordTouch = (name, opIndex) => {
-        if (!touched.has(name))
-            touched.set(name, opIndex);
-    };
-    for (let i = 0; i < operations.length; i++) {
-        const op = operations[i];
-        if (op.type === 'addNode') {
-            recordTouch(op.node.name, i);
-        }
-        else if (op.type === 'updateNodeParameters' || op.type === 'setNodeParameter') {
-            recordTouch(op.nodeName, i);
-        }
-        else if (op.type === 'renameNode') {
-            const idx = touched.get(op.oldName);
-            if (idx !== undefined) {
-                touched.delete(op.oldName);
-                touched.set(op.newName, idx);
-            }
-        }
-        else if (op.type === 'removeNode') {
-            touched.delete(op.nodeName);
-        }
-    }
-    return touched;
-}
-const countOperationsWithNoEffect = (skippedOperations, groupOperations) => {
-    const producedPerOp = new Map();
-    for (const { opIndex } of Object.values(groupOperations)) {
-        producedPerOp.set(opIndex, (producedPerOp.get(opIndex) ?? 0) + 1);
-    }
-    const skippedPerOp = new Map();
-    for (const { opIndex } of skippedOperations) {
-        skippedPerOp.set(opIndex, (skippedPerOp.get(opIndex) ?? 0) + 1);
-    }
-    let count = 0;
-    for (const [opIndex, skipped] of skippedPerOp) {
-        if (skipped >= (producedPerOp.get(opIndex) ?? 0)) {
-            count++;
-        }
-    }
-    return count;
-};
 const NON_FATAL_OPERATION_TYPES_LIST = [...workflow_operations_1.NON_FATAL_OPERATION_TYPES].join(', ');
 const buildToolDescription = (canvasGroupsEnabled) => {
     const base = 'Atomically update an existing workflow with operation objects. Edits nodes/connections and also workflow-level settings via setWorkflowSettings — including the error workflow that runs automatically on failure to send alerts (e.g. when a user asks to "add error handling" or "notify me if this breaks"). Pass skillsUsed if n8n skills were used.';
@@ -233,9 +176,9 @@ const buildToolDescription = (canvasGroupsEnabled) => {
         : base;
 };
 const buildInputSchema = (canvasGroupsEnabled) => ({
-    workflowId: zod_1.default.string().describe('The ID of the workflow to update.'),
-    skillsUsed: zod_1.default.array(zod_1.default.string()).optional().describe(skills_used_1.SKILLS_USED_PARAM_DESCRIPTION),
-    operations: zod_1.default
+    workflowId: zod_1.z.string().describe('The ID of the workflow to update.'),
+    skillsUsed: zod_1.z.array(zod_1.z.string()).optional().describe(skills_used_1.SKILLS_USED_PARAM_DESCRIPTION),
+    operations: zod_1.z
         .array(buildOperationInputSchema(canvasGroupsEnabled))
         .min(1)
         .max(MAX_OPERATIONS_PER_CALL)
@@ -246,62 +189,63 @@ const buildInputSchema = (canvasGroupsEnabled) => ({
     versionDescription: version_metadata_1.versionDescriptionInputSchema.describe('Longer description of what changed and why, shown in the version history alongside the version name.'),
 });
 const outputSchema = {
-    workflowId: zod_1.default.string().optional(),
-    name: zod_1.default.string().optional(),
-    nodeCount: zod_1.default.number().optional(),
-    url: zod_1.default.string().optional(),
-    appliedOperations: zod_1.default
+    workflowId: zod_1.z.string().optional(),
+    name: zod_1.z.string().optional(),
+    nodeCount: zod_1.z.number().optional(),
+    url: zod_1.z.string().optional(),
+    appliedOperations: zod_1.z
         .number()
         .optional()
         .describe('Number of submitted operations that were applied. See skippedOperations for any that were not.'),
-    autoAssignedCredentials: zod_1.default
-        .array(zod_1.default.object({
-        nodeName: zod_1.default.string(),
-        credentialName: zod_1.default.string(),
-        credentialType: zod_1.default.string(),
-        source: zod_1.default.enum(['user', 'aiGateway']).optional(),
+    autoAssignedCredentials: zod_1.z
+        .array(zod_1.z.object({
+        nodeName: zod_1.z.string(),
+        credentialName: zod_1.z.string(),
+        credentialType: zod_1.z.string(),
+        source: zod_1.z.enum(['user', 'aiGateway']).optional(),
     }))
         .optional()
         .describe('Credentials auto-assigned to nodes that were added in this update.'),
-    validationWarnings: zod_1.default
-        .array(zod_1.default.object({
-        code: zod_1.default.string(),
-        message: zod_1.default.string(),
-        nodeName: zod_1.default.string().optional(),
-        preExisting: zod_1.default
+    validationWarnings: zod_1.z
+        .array(zod_1.z.object({
+        code: zod_1.z.string(),
+        message: zod_1.z.string(),
+        nodeName: zod_1.z.string().optional(),
+        preExisting: zod_1.z
             .boolean()
             .optional()
             .describe('True when the same warning already existed before this update — it was not caused by these operations.'),
     }))
         .optional()
         .describe('Graph and JSON validation warnings on the resulting workflow. Warnings marked preExisting (also tagged [pre-existing] in the message) were already present before this update; only self-correct the rest on the next call.'),
-    note: zod_1.default.string().optional(),
-    skippedOperations: zod_1.default
-        .array(zod_1.default.object({
-        opIndex: zod_1.default.number(),
-        type: zod_1.default.string(),
-        reason: zod_1.default.string(),
+    note: zod_1.z.string().optional(),
+    skippedOperations: zod_1.z
+        .array(zod_1.z.object({
+        opIndex: zod_1.z.number(),
+        type: zod_1.z.string(),
+        reason: zod_1.z.string(),
     }))
         .optional()
         .describe('Submitted group operations that did not take effect: either invalid, or their group broke the group rules.'),
-    removedGroups: zod_1.default
-        .array(zod_1.default.object({
-        groupName: zod_1.default.string(),
-        reason: zod_1.default.string(),
+    removedGroups: zod_1.z
+        .array(zod_1.z.object({
+        groupName: zod_1.z.string(),
+        reason: zod_1.z.string(),
     }))
         .optional(),
-    settings: zod_1.default
-        .record(zod_1.default.string(), zod_1.default.unknown())
+    settings: zod_1.z
+        .record(zod_1.z.string(), zod_1.z.unknown())
         .optional()
         .describe('Resulting workflow-level settings after the update. Present only when a setWorkflowSettings operation ran. Reflects server-side cleanup (e.g. "DEFAULT" values are removed).'),
-    error: zod_1.default
+    error: zod_1.z
         .string()
         .optional()
         .describe('Error message explaining why the update failed. Present only on failure.'),
 };
 async function assertErrorWorkflowIsUsable({ errorWorkflowId, parentWorkflowId, user, workflowFinderService, workflowPublishedDataService, useWorkflowPublicationService, nodeTypes, subworkflowPolicyChecker, errorTriggerType, }) {
-    if (!errorWorkflowId || errorWorkflowId === 'DEFAULT')
+    if (!errorWorkflowId || errorWorkflowId === 'DEFAULT') {
         return;
+    }
     const errorWorkflow = await workflowFinderService.findWorkflowForUser(errorWorkflowId, user, ['workflow:read'], { includeActiveVersion: !useWorkflowPublicationService });
     if (!errorWorkflow) {
         throw new Error(`Error workflow '${errorWorkflowId}' was not found or you do not have access to it. Find a valid workflow ID with search_workflows, or create an error-handler workflow first.`);
@@ -341,8 +285,9 @@ async function assertErrorWorkflowIsUsable({ errorWorkflowId, parentWorkflowId,
     }
 }
 function assertCallerPolicyConsistent(settings) {
-    if (settings?.callerPolicy !== 'workflowsFromAList')
+    if (settings?.callerPolicy !== 'workflowsFromAList') {
         return;
+    }
     const callerIds = (settings.callerIds ?? '')
         .split(',')
         .map((id) => id.trim())
@@ -352,262 +297,387 @@ function assertCallerPolicyConsistent(settings) {
     }
 }
 function assertExecutionTimeoutWithinMax(executionTimeout, maxTimeout) {
-    if (executionTimeout === undefined || executionTimeout <= 0 || maxTimeout <= 0)
+    if (executionTimeout === undefined || executionTimeout <= 0 || maxTimeout <= 0) {
         return;
+    }
     if (executionTimeout > maxTimeout) {
         throw new Error(`executionTimeout (${executionTimeout}s) exceeds this instance's maximum of ${maxTimeout}s. Set executionTimeout to ${maxTimeout} or less.`);
     }
 }
-const createUpdateWorkflowTool = (user, workflowFinderService, workflowService, urlService, telemetry, nodeTypes, credentialsService, sharedWorkflowRepository, collaborationService, dataTableOps, tagService, globalConfig, subworkflowPolicyChecker, workflowPublishedDataService, aiGatewayService, options = {}) => ({
-    name: constants_1.MCP_UPDATE_WORKFLOW_TOOL.toolName,
-    config: {
-        description: buildToolDescription(options.canvasGroupsEnabled === true),
-        inputSchema: buildInputSchema(options.canvasGroupsEnabled === true),
-        outputSchema,
-        annotations: {
-            title: constants_1.MCP_UPDATE_WORKFLOW_TOOL.displayTitle,
-            readOnlyHint: false,
-            destructiveHint: true,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
-    handler: async ({ workflowId, skillsUsed, operations, versionName, versionDescription, }) => {
-        const sanitizedSkillsUsed = (0, skills_used_1.sanitizeSkillsUsed)(skillsUsed);
-        const telemetryPayload = {
-            user_id: user.id,
-            tool_name: constants_1.MCP_UPDATE_WORKFLOW_TOOL.toolName,
-            parameters: {
-                workflowId,
-                ...(sanitizedSkillsUsed !== undefined ? { skillsUsed: sanitizedSkillsUsed } : {}),
-                opCount: operations.length,
-                opTypes: operations.map((op) => op.type),
-                hasVersionName: !!versionName,
-                hasVersionDescription: !!versionDescription,
-            },
-        };
-        try {
-            const strictOperations = parseStrictOperations(operations);
-            const hasGatedGroupOperations = strictOperations.some((op) => GATED_GROUP_OP_TYPES.has(op.type));
-            if (hasGatedGroupOperations && options.canvasGroupsEnabled !== true) {
-                throw new Error('Node group operations (addNodeGroup, removeNodeGroup, updateNodeGroup) are not available on this instance.');
-            }
-            const hasTagOperations = strictOperations.some((op) => op.type === 'addTags' || op.type === 'removeTags');
-            if (hasTagOperations && globalConfig.tags.disabled) {
-                throw new Error('Tag operations are not supported on this instance because tags are disabled.');
-            }
-            const existingWorkflow = await (0, workflow_validation_utils_1.getMcpWorkflow)(workflowId, user, ['workflow:update'], workflowFinderService, { includeTags: hasTagOperations });
-            await collaborationService.ensureWorkflowEditable(existingWorkflow.id);
-            const result = (0, workflow_operations_1.applyOperations)((0, workflow_operations_1.toWorkflowSlice)(existingWorkflow, { includeTags: hasTagOperations }), strictOperations, { canvasGroupsEnabled: options.canvasGroupsEnabled });
-            if (!result.success) {
-                throw new Error(result.error);
-            }
-            const skippedOperations = [...result.skippedOperations];
-            const removedGroups = [];
-            let nodeGroupsNeedPersisting = result.nodeGroupsChanged;
-            if (options.canvasGroupsEnabled) {
-                const getNodeType = (0, workflow_helpers_1.makeGetNodeTypeForGrouping)(nodeTypes);
-                const ownGroups = (0, workflow_helpers_1.dropInvalidNodeGroups)(result.workflow, getNodeType, (violation) => result.groupOperations[violation.groupId] !== undefined);
-                const violations = [...ownGroups, ...(0, workflow_helpers_1.dropInvalidNodeGroups)(result.workflow, getNodeType)];
-                if (violations.length > 0) {
-                    nodeGroupsNeedPersisting = true;
-                    for (const violation of violations) {
-                        const requestedBy = result.groupOperations[violation.groupId];
-                        if (requestedBy) {
-                            skippedOperations.push({ ...requestedBy, reason: violation.message });
-                        }
-                        else {
-                            removedGroups.push({
-                                groupName: violation.groupName,
-                                reason: violation.message,
-                            });
-                        }
-                    }
-                }
-            }
-            const credentialCheck = await (0, credential_validation_1.validateCredentialReferences)(strictOperations, existingWorkflow, user, credentialsService, nodeTypes, { workflowId: existingWorkflow.id });
-            if (!credentialCheck.ok) {
-                throw new Error(credentialCheck.error);
-            }
-            const invalidToolSourceResponse = (0, connection_structure_check_1.buildInvalidAiToolSourceErrorResponse)({ nodes: result.workflow.nodes, connections: result.workflow.connections }, nodeTypes, (errorMessage) => ({ error: errorMessage }), telemetryPayload, telemetry);
-            if (invalidToolSourceResponse) {
-                return invalidToolSourceResponse;
+async function assertWorkflowSettingsValid({ strictOperations, settings, workflowId, }, { user, nodeTypes, globalConfig, workflowFinderService, workflowPublishedDataService, subworkflowPolicyChecker, }) {
+    const setsErrorWorkflow = strictOperations.some((op) => op.type === 'setWorkflowSettings' && op.settings.errorWorkflow !== undefined);
+    if (setsErrorWorkflow) {
+        await assertErrorWorkflowIsUsable({
+            errorWorkflowId: settings?.errorWorkflow,
+            parentWorkflowId: workflowId,
+            user,
+            workflowFinderService,
+            workflowPublishedDataService,
+            useWorkflowPublicationService: globalConfig.workflows.useWorkflowPublicationService,
+            nodeTypes,
+            subworkflowPolicyChecker,
+            errorTriggerType: globalConfig.nodes.errorTriggerType,
+        });
+    }
+    const setsCallerConfig = strictOperations.some((op) => op.type === 'setWorkflowSettings' &&
+        (op.settings.callerPolicy !== undefined || op.settings.callerIds !== undefined));
+    if (setsCallerConfig) {
+        assertCallerPolicyConsistent(settings);
+    }
+    const setsExecutionTimeout = strictOperations.some((op) => op.type === 'setWorkflowSettings' && op.settings.executionTimeout !== undefined);
+    if (setsExecutionTimeout) {
+        assertExecutionTimeoutWithinMax(settings?.executionTimeout, globalConfig.executions.maxTimeout);
+    }
+}
+async function assertPublishAllowedForSettingsChange({ hasSettingsOperations, activeVersionId, workflowId, }, { user, workflowFinderService, }) {
+    if (!hasSettingsOperations) {
+        return;
+    }
+    if (!activeVersionId) {
+        return;
+    }
+    if ((0, permissions_1.hasGlobalScope)(user, 'workflow:publish')) {
+        return;
+    }
+    const canPublish = await workflowFinderService.findWorkflowHeadForUser(workflowId, user, [
+        'workflow:publish',
+    ]);
+    if (!canPublish) {
+        throw new Error('Changing settings on a published workflow reactivates it, which requires publish permission. Your account can edit but not publish this workflow. Ask the owner for publish access, or unpublish the workflow first.');
+    }
+}
+function dedupeNamesPreservingCase(names) {
+    const seen = new Set();
+    const result = [];
+    for (const raw of names) {
+        const trimmed = raw.trim();
+        if (trimmed.length === 0) {
+            continue;
+        }
+        const key = trimmed.toLowerCase();
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        result.push(trimmed);
+    }
+    return result;
+}
+function collectTouchedNodes(operations) {
+    const touched = new Map();
+    const recordTouch = (name, opIndex) => {
+        if (!touched.has(name)) {
+            touched.set(name, opIndex);
+        }
+    };
+    for (let i = 0; i < operations.length; i++) {
+        const op = operations[i];
+        if (op.type === 'addNode') {
+            recordTouch(op.node.name, i);
+        }
+        else if (op.type === 'updateNodeParameters' || op.type === 'setNodeParameter') {
+            recordTouch(op.nodeName, i);
+        }
+        else if (op.type === 'renameNode') {
+            const idx = touched.get(op.oldName);
+            if (idx !== undefined) {
+                touched.delete(op.oldName);
+                touched.set(op.newName, idx);
             }
-            const { projectId: workflowProjectId } = await sharedWorkflowRepository.findOneOrFail({
-                where: { workflowId, role: 'workflow:owner' },
-                select: ['projectId'],
+        }
+        else if (op.type === 'removeNode') {
+            touched.delete(op.nodeName);
+        }
+    }
+    return touched;
+}
+const countOperationsWithNoEffect = (skippedOperations, groupOperations) => {
+    const producedPerOp = new Map();
+    for (const { opIndex } of Object.values(groupOperations)) {
+        producedPerOp.set(opIndex, (producedPerOp.get(opIndex) ?? 0) + 1);
+    }
+    const skippedPerOp = new Map();
+    for (const { opIndex } of skippedOperations) {
+        skippedPerOp.set(opIndex, (skippedPerOp.get(opIndex) ?? 0) + 1);
+    }
+    let count = 0;
+    for (const [opIndex, skipped] of skippedPerOp) {
+        if (skipped >= (producedPerOp.get(opIndex) ?? 0)) {
+            count++;
+        }
+    }
+    return count;
+};
+const isTagOperation = (op) => op.type === 'addTags' || op.type === 'removeTags';
+const isSettingsOperation = (op) => op.type === 'setWorkflowSettings';
+function assertOperationsSupported(strictOperations, { canvasGroupsEnabled, tagsDisabled }) {
+    if (!canvasGroupsEnabled && strictOperations.some((op) => GATED_GROUP_OP_TYPES.has(op.type))) {
+        throw new Error('Node group operations (addNodeGroup, removeNodeGroup, updateNodeGroup) are not available on this instance.');
+    }
+    if (tagsDisabled && strictOperations.some(isTagOperation)) {
+        throw new Error('Tag operations are not supported on this instance because tags are disabled.');
+    }
+}
+function resolveNodeGroupViolations(result, canvasGroupsEnabled, nodeTypes) {
+    const skippedOperations = [...result.skippedOperations];
+    const removedGroups = [];
+    const getNodeType = (0, workflow_helpers_1.makeGetNodeTypeForGrouping)(nodeTypes);
+    const violations = canvasGroupsEnabled
+        ? [
+            ...(0, workflow_helpers_1.dropInvalidNodeGroups)(result.workflow, getNodeType, (violation) => result.groupOperations[violation.groupId] !== undefined),
+            ...(0, workflow_helpers_1.dropInvalidNodeGroups)(result.workflow, getNodeType),
+        ]
+        : [];
+    for (const violation of violations) {
+        const requestedBy = result.groupOperations[violation.groupId];
+        if (requestedBy) {
+            skippedOperations.push({ ...requestedBy, reason: violation.message });
+        }
+        else {
+            removedGroups.push({
+                groupName: violation.groupName,
+                reason: violation.message,
             });
-            const dataTableCheck = await (0, data_table_validation_1.validateDataTableReferencesForUpdate)(result.workflow.nodes, collectTouchedNodes(strictOperations), workflowProjectId, dataTableOps);
-            if (!dataTableCheck.ok) {
-                throw new Error(dataTableCheck.error);
+        }
+    }
+    return {
+        skippedOperations,
+        removedGroups,
+        nodeGroupsNeedPersisting: violations.length > 0 || result.nodeGroupsChanged,
+    };
+}
+function buildWorkflowUpdateEntity({ workflow, existingMeta, hasSettingsOperations, hasNonTagOperations, nodeGroupsNeedPersisting, }) {
+    const workflowUpdateData = new db_1.WorkflowEntity();
+    Object.assign(workflowUpdateData, {
+        name: workflow.name,
+        ...(workflow.description !== undefined ? { description: workflow.description } : {}),
+        nodes: workflow.nodes,
+        connections: workflow.connections,
+        ...(hasSettingsOperations ? { settings: workflow.settings } : {}),
+        ...(nodeGroupsNeedPersisting ? { nodeGroups: workflow.nodeGroups } : {}),
+        meta: hasNonTagOperations
+            ? {
+                ...(existingMeta ?? {}),
+                aiBuilderAssisted: true,
+                builderVariant: 'mcp',
             }
-            const setsErrorWorkflow = strictOperations.some((op) => op.type === 'setWorkflowSettings' && op.settings.errorWorkflow !== undefined);
-            if (setsErrorWorkflow) {
-                await assertErrorWorkflowIsUsable({
-                    errorWorkflowId: result.workflow.settings?.errorWorkflow,
-                    parentWorkflowId: workflowId,
-                    user,
-                    workflowFinderService,
-                    workflowPublishedDataService,
-                    useWorkflowPublicationService: globalConfig.workflows.useWorkflowPublicationService,
-                    nodeTypes,
-                    subworkflowPolicyChecker,
-                    errorTriggerType: globalConfig.nodes.errorTriggerType,
+            : (existingMeta ?? {}),
+    });
+    return workflowUpdateData;
+}
+function buildUpdateTelemetryPayload({ userId, workflowId, operations, sanitizedSkillsUsed, versionName, versionDescription, }) {
+    return {
+        user_id: userId,
+        tool_name: constants_1.MCP_UPDATE_WORKFLOW_TOOL.toolName,
+        parameters: {
+            workflowId,
+            ...(sanitizedSkillsUsed !== undefined ? { skillsUsed: sanitizedSkillsUsed } : {}),
+            opCount: operations.length,
+            opTypes: operations.map((op) => op.type),
+            hasVersionName: !!versionName,
+            hasVersionDescription: !!versionDescription,
+        },
+    };
+}
+async function autoAssignCredentialsForAddedNodes({ workflowUpdateData, addedNodeNames, projectId, }, { user, nodeTypes, credentialsService, aiGatewayService, }) {
+    if (addedNodeNames.length === 0) {
+        return { assignments: [], skippedHttpNodes: [], outcomes: [] };
+    }
+    const addedNodeSet = new Set(addedNodeNames);
+    const addedNodes = workflowUpdateData.nodes.filter((n) => addedNodeSet.has(n.name));
+    return await (0, credentials_auto_assign_1.autoPopulateNodeCredentials)({ ...workflowUpdateData, nodes: addedNodes }, user, nodeTypes, credentialsService, projectId, aiGatewayService);
+}
+async function collectValidationWarnings(updated, existing, nodeTypes) {
+    const { ParseValidateHandler, getWarningKey } = await import('@n8n/ai-workflow-builder');
+    const validator = new ParseValidateHandler({
+        generatePinData: false,
+        nodeTypesProvider: nodeTypes,
+    });
+    const validate = (workflow) => validator.validateJSON({
+        name: workflow.name,
+        nodes: workflow.nodes,
+        connections: workflow.connections,
+    });
+    const postUpdateWarnings = validate(updated);
+    if (postUpdateWarnings.length === 0) {
+        return postUpdateWarnings;
+    }
+    let preUpdateWarnings = [];
+    try {
+        preUpdateWarnings = validate(existing);
+    }
+    catch {
+    }
+    const preUpdateKeys = new Set(preUpdateWarnings.map(getWarningKey));
+    return postUpdateWarnings.map((warning) => preUpdateKeys.has(getWarningKey(warning))
+        ? { ...warning, message: `[pre-existing] ${warning.message}`, preExisting: true }
+        : warning);
+}
+async function resolveTagIds(tagNames, user, tagService) {
+    if (tagNames === undefined) {
+        return undefined;
+    }
+    const uniqueTagNames = dedupeNamesPreservingCase(tagNames);
+    if ((0, permissions_1.hasGlobalScope)(user, 'tag:create')) {
+        const resolvedTags = await tagService.findOrCreateByNames(uniqueTagNames);
+        return resolvedTags.map((t) => t.id);
+    }
+    const resolvedTags = await tagService.getByNames(uniqueTagNames);
+    const resolvedNames = new Set(resolvedTags.map((t) => t.name));
+    const missing = uniqueTagNames.filter((name) => !resolvedNames.has(name));
+    if (missing.length > 0) {
+        throw new Error(`Cannot apply the following tags because they don't exist and your account does not have permission to create them: ${missing.join(', ')}`);
+    }
+    return resolvedTags.map((t) => t.id);
+}
+const createUpdateWorkflowTool = (user, workflowFinderService, workflowService, urlService, telemetry, nodeTypes, credentialsService, sharedWorkflowRepository, collaborationService, dataTableOps, tagService, globalConfig, subworkflowPolicyChecker, workflowPublishedDataService, aiGatewayService, options = {}) => {
+    const canvasGroupsEnabled = options.canvasGroupsEnabled === true;
+    const settingsGuardDependencies = {
+        user,
+        nodeTypes,
+        globalConfig,
+        workflowFinderService,
+        workflowPublishedDataService,
+        subworkflowPolicyChecker,
+    };
+    return {
+        name: constants_1.MCP_UPDATE_WORKFLOW_TOOL.toolName,
+        config: {
+            description: buildToolDescription(canvasGroupsEnabled),
+            inputSchema: buildInputSchema(canvasGroupsEnabled),
+            outputSchema,
+            annotations: {
+                title: constants_1.MCP_UPDATE_WORKFLOW_TOOL.displayTitle,
+                readOnlyHint: false,
+                destructiveHint: true,
+                idempotentHint: false,
+                openWorldHint: false,
+            },
+        },
+        handler: async ({ workflowId, skillsUsed, operations, versionName, versionDescription, }) => {
+            const telemetryPayload = buildUpdateTelemetryPayload({
+                userId: user.id,
+                workflowId,
+                operations,
+                sanitizedSkillsUsed: (0, skills_used_1.sanitizeSkillsUsed)(skillsUsed),
+                versionName,
+                versionDescription,
+            });
+            try {
+                const strictOperations = parseStrictOperations(operations);
+                const hasTagOperations = strictOperations.some(isTagOperation);
+                const hasNonTagOperations = strictOperations.some((op) => !isTagOperation(op));
+                const hasSettingsOperations = strictOperations.some(isSettingsOperation);
+                assertOperationsSupported(strictOperations, {
+                    canvasGroupsEnabled,
+                    tagsDisabled: globalConfig.tags.disabled,
                 });
-            }
-            const setsCallerConfig = strictOperations.some((op) => op.type === 'setWorkflowSettings' &&
-                (op.settings.callerPolicy !== undefined || op.settings.callerIds !== undefined));
-            if (setsCallerConfig) {
-                assertCallerPolicyConsistent(result.workflow.settings);
-            }
-            const setsExecutionTimeout = strictOperations.some((op) => op.type === 'setWorkflowSettings' && op.settings.executionTimeout !== undefined);
-            if (setsExecutionTimeout) {
-                assertExecutionTimeoutWithinMax(result.workflow.settings?.executionTimeout, globalConfig.executions.maxTimeout);
-            }
-            const hasNonTagOperations = strictOperations.some((op) => op.type !== 'addTags' && op.type !== 'removeTags');
-            const hasSettingsOperations = strictOperations.some((op) => op.type === 'setWorkflowSettings');
-            if (hasSettingsOperations &&
-                existingWorkflow.activeVersionId &&
-                !(0, permissions_1.hasGlobalScope)(user, 'workflow:publish')) {
-                const canPublish = await workflowFinderService.findWorkflowHeadForUser(workflowId, user, [
-                    'workflow:publish',
-                ]);
-                if (!canPublish) {
-                    throw new Error('Changing settings on a published workflow reactivates it, which requires publish permission. Your account can edit but not publish this workflow. Ask the owner for publish access, or unpublish the workflow first.');
+                const existingWorkflow = await (0, workflow_validation_utils_1.getMcpWorkflow)(workflowId, user, ['workflow:update'], workflowFinderService, { includeTags: hasTagOperations });
+                await collaborationService.ensureWorkflowEditable(existingWorkflow.id);
+                const result = (0, workflow_operations_1.applyOperations)((0, workflow_operations_1.toWorkflowSlice)(existingWorkflow, { includeTags: hasTagOperations }), strictOperations, { canvasGroupsEnabled });
+                if (!result.success) {
+                    throw new Error(result.error);
                 }
-            }
-            const workflowUpdateData = new db_1.WorkflowEntity();
-            Object.assign(workflowUpdateData, {
-                name: result.workflow.name,
-                ...(result.workflow.description !== undefined
-                    ? { description: result.workflow.description }
-                    : {}),
-                nodes: result.workflow.nodes,
-                connections: result.workflow.connections,
-                ...(hasSettingsOperations ? { settings: result.workflow.settings } : {}),
-                ...(nodeGroupsNeedPersisting ? { nodeGroups: result.workflow.nodeGroups } : {}),
-                meta: hasNonTagOperations
-                    ? {
-                        ...(existingWorkflow.meta ?? {}),
-                        aiBuilderAssisted: true,
-                        builderVariant: 'mcp',
-                    }
-                    : (existingWorkflow.meta ?? {}),
-            });
-            (0, workflow_helpers_1.resolveNodeWebhookIds)(workflowUpdateData, nodeTypes);
-            let credentialAssignments = [];
-            let skippedHttpNodes = [];
-            let autoAssignOutcomes = [];
-            if (result.addedNodeNames.length > 0) {
-                const addedNodeSet = new Set(result.addedNodeNames);
-                const addedNodes = workflowUpdateData.nodes.filter((n) => addedNodeSet.has(n.name));
-                const autoAssign = await (0, credentials_auto_assign_1.autoPopulateNodeCredentials)({ ...workflowUpdateData, nodes: addedNodes }, user, nodeTypes, credentialsService, workflowProjectId, aiGatewayService);
-                credentialAssignments = autoAssign.assignments;
-                skippedHttpNodes = autoAssign.skippedHttpNodes;
-                autoAssignOutcomes = autoAssign.outcomes;
-            }
-            const { ParseValidateHandler, getWarningKey } = await import('@n8n/ai-workflow-builder');
-            const validator = new ParseValidateHandler({
-                generatePinData: false,
-                nodeTypesProvider: nodeTypes,
-            });
-            const postUpdateWarnings = validator.validateJSON({
-                name: workflowUpdateData.name,
-                nodes: workflowUpdateData.nodes,
-                connections: workflowUpdateData.connections,
-            });
-            let validationWarnings = postUpdateWarnings;
-            if (postUpdateWarnings.length > 0) {
-                let preUpdateWarnings = [];
-                try {
-                    preUpdateWarnings = validator.validateJSON({
-                        name: existingWorkflow.name,
-                        nodes: existingWorkflow.nodes,
-                        connections: existingWorkflow.connections,
-                    });
+                const { skippedOperations, removedGroups, nodeGroupsNeedPersisting } = resolveNodeGroupViolations(result, canvasGroupsEnabled, nodeTypes);
+                const credentialCheck = await (0, credential_validation_1.validateCredentialReferences)(strictOperations, existingWorkflow, user, credentialsService, nodeTypes, { workflowId: existingWorkflow.id });
+                if (!credentialCheck.ok) {
+                    throw new Error(credentialCheck.error);
                 }
-                catch { }
-                const preUpdateKeys = new Set(preUpdateWarnings.map(getWarningKey));
-                validationWarnings = postUpdateWarnings.map((warning) => preUpdateKeys.has(getWarningKey(warning))
-                    ? { ...warning, message: `[pre-existing] ${warning.message}`, preExisting: true }
-                    : warning);
-            }
-            let tagIds;
-            if (result.tagNames !== undefined) {
-                const uniqueTagNames = dedupeNamesPreservingCase(result.tagNames);
-                if ((0, permissions_1.hasGlobalScope)(user, 'tag:create')) {
-                    const resolvedTags = await tagService.findOrCreateByNames(uniqueTagNames);
-                    tagIds = resolvedTags.map((t) => t.id);
+                const invalidToolSourceResponse = (0, connection_structure_check_1.buildInvalidAiToolSourceErrorResponse)({ nodes: result.workflow.nodes, connections: result.workflow.connections }, nodeTypes, (errorMessage) => ({ error: errorMessage }), telemetryPayload, telemetry);
+                if (invalidToolSourceResponse) {
+                    return invalidToolSourceResponse;
                 }
-                else {
-                    const resolvedTags = await tagService.getByNames(uniqueTagNames);
-                    const resolvedNames = new Set(resolvedTags.map((t) => t.name));
-                    const missing = uniqueTagNames.filter((name) => !resolvedNames.has(name));
-                    if (missing.length > 0) {
-                        throw new Error(`Cannot apply the following tags because they don't exist and your account does not have permission to create them: ${missing.join(', ')}`);
-                    }
-                    tagIds = resolvedTags.map((t) => t.id);
+                const { projectId: workflowProjectId } = await sharedWorkflowRepository.findOneOrFail({
+                    where: { workflowId, role: 'workflow:owner' },
+                    select: ['projectId'],
+                });
+                const dataTableCheck = await (0, data_table_validation_1.validateDataTableReferencesForUpdate)(result.workflow.nodes, collectTouchedNodes(strictOperations), workflowProjectId, dataTableOps);
+                if (!dataTableCheck.ok) {
+                    throw new Error(dataTableCheck.error);
                 }
-            }
-            const versionMetadata = (0, version_metadata_1.resolveVersionMetadata)({ versionName, versionDescription }, (0, version_metadata_1.buildUpdateVersionMetadata)({ nodes: existingWorkflow.nodes, connections: existingWorkflow.connections }, { nodes: workflowUpdateData.nodes, connections: workflowUpdateData.connections }));
-            const updatedWorkflow = await workflowService.update(user, workflowUpdateData, workflowId, {
-                aiBuilderAssisted: hasNonTagOperations,
-                source: 'n8n-mcp',
-                versionName: versionMetadata.name,
-                versionDescription: versionMetadata.description,
-                ...(tagIds !== undefined ? { tagIds } : {}),
-            });
-            if (autoAssignOutcomes.length > 0) {
-                const nodeTypesByName = new Map(updatedWorkflow.nodes.map((n) => [n.name, n.type]));
-                (0, credentials_auto_assign_1.trackAutoassignOutcomes)(telemetry, user.id, 'update_workflow', autoAssignOutcomes, nodeTypesByName, workflowId);
-            }
-            void collaborationService.broadcastWorkflowUpdate(workflowId, user.id).catch(() => { });
-            const baseUrl = urlService.getInstanceBaseUrl();
-            const workflowUrl = `${baseUrl}/workflow/${updatedWorkflow.id}`;
-            telemetryPayload.results = {
-                success: true,
-                data: {
+                await assertWorkflowSettingsValid({ strictOperations, settings: result.workflow.settings, workflowId }, settingsGuardDependencies);
+                await assertPublishAllowedForSettingsChange({
+                    hasSettingsOperations,
+                    activeVersionId: existingWorkflow.activeVersionId,
+                    workflowId,
+                }, settingsGuardDependencies);
+                const workflowUpdateData = buildWorkflowUpdateEntity({
+                    workflow: result.workflow,
+                    existingMeta: existingWorkflow.meta,
+                    hasSettingsOperations,
+                    hasNonTagOperations,
+                    nodeGroupsNeedPersisting,
+                });
+                (0, workflow_helpers_1.resolveNodeWebhookIds)(workflowUpdateData, nodeTypes);
+                const { assignments: credentialAssignments, skippedHttpNodes, outcomes: autoAssignOutcomes, } = await autoAssignCredentialsForAddedNodes({
+                    workflowUpdateData,
+                    addedNodeNames: result.addedNodeNames,
+                    projectId: workflowProjectId,
+                }, { user, nodeTypes, credentialsService, aiGatewayService });
+                const validationWarnings = await collectValidationWarnings(workflowUpdateData, existingWorkflow, nodeTypes);
+                const tagIds = await resolveTagIds(result.tagNames, user, tagService);
+                const versionMetadata = (0, version_metadata_1.resolveVersionMetadata)({ versionName, versionDescription }, (0, version_metadata_1.buildUpdateVersionMetadata)({ nodes: existingWorkflow.nodes, connections: existingWorkflow.connections }, { nodes: workflowUpdateData.nodes, connections: workflowUpdateData.connections }));
+                const updatedWorkflow = await workflowService.update(user, workflowUpdateData, workflowId, {
+                    aiBuilderAssisted: hasNonTagOperations,
+                    source: 'n8n-mcp',
+                    versionName: versionMetadata.name,
+                    versionDescription: versionMetadata.description,
+                    ...(tagIds !== undefined ? { tagIds } : {}),
+                });
+                if (autoAssignOutcomes.length > 0) {
+                    const nodeTypesByName = new Map(updatedWorkflow.nodes.map((n) => [n.name, n.type]));
+                    (0, credentials_auto_assign_1.trackAutoassignOutcomes)(telemetry, user.id, 'update_workflow', autoAssignOutcomes, nodeTypesByName, workflowId);
+                }
+                void collaborationService.broadcastWorkflowUpdate(workflowId, user.id).catch(() => { });
+                const baseUrl = urlService.getInstanceBaseUrl();
+                const workflowUrl = `${baseUrl}/workflow/${updatedWorkflow.id}`;
+                telemetryPayload.results = {
+                    success: true,
+                    data: {
+                        workflowId: updatedWorkflow.id,
+                        nodeCount: updatedWorkflow.nodes.length,
+                    },
+                };
+                telemetry.track(mcp_constants_1.USER_CALLED_MCP_TOOL_EVENT, telemetryPayload);
+                const notAppliedCount = countOperationsWithNoEffect(skippedOperations, result.groupOperations);
+                const output = {
                     workflowId: updatedWorkflow.id,
+                    name: updatedWorkflow.name,
                     nodeCount: updatedWorkflow.nodes.length,
-                },
-            };
-            telemetry.track(mcp_constants_1.USER_CALLED_MCP_TOOL_EVENT, telemetryPayload);
-            const notAppliedCount = countOperationsWithNoEffect(skippedOperations, result.groupOperations);
-            const output = {
-                workflowId: updatedWorkflow.id,
-                name: updatedWorkflow.name,
-                nodeCount: updatedWorkflow.nodes.length,
-                url: workflowUrl,
-                appliedOperations: strictOperations.length - notAppliedCount,
-                autoAssignedCredentials: credentialAssignments,
-                validationWarnings,
-                note: skippedHttpNodes.length
-                    ? `HTTP Request nodes (${skippedHttpNodes.join(', ')}) were skipped during credential auto-assignment. Their credentials must be configured manually.`
-                    : undefined,
-                skippedOperations: skippedOperations.length > 0 ? skippedOperations : undefined,
-                removedGroups: removedGroups.length > 0 ? removedGroups : undefined,
-                settings: hasSettingsOperations ? (updatedWorkflow.settings ?? {}) : undefined,
-            };
-            return {
-                content: [{ type: 'text', text: JSON.stringify(output, null, 2) }],
-                structuredContent: output,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            telemetryPayload.results = {
-                success: false,
-                error: errorMessage,
-            };
-            telemetry.track(mcp_constants_1.USER_CALLED_MCP_TOOL_EVENT, telemetryPayload);
-            const output = { error: errorMessage };
-            return {
-                content: [{ type: 'text', text: JSON.stringify(output, null, 2) }],
-                structuredContent: output,
-                isError: true,
-            };
-        }
-    },
-});
+                    url: workflowUrl,
+                    appliedOperations: strictOperations.length - notAppliedCount,
+                    autoAssignedCredentials: credentialAssignments,
+                    validationWarnings,
+                    note: skippedHttpNodes.length
+                        ? `HTTP Request nodes (${skippedHttpNodes.join(', ')}) were skipped during credential auto-assignment. Their credentials must be configured manually.`
+                        : undefined,
+                    skippedOperations: skippedOperations.length > 0 ? skippedOperations : undefined,
+                    removedGroups: removedGroups.length > 0 ? removedGroups : undefined,
+                    settings: hasSettingsOperations
+                        ? (updatedWorkflow.settings ?? {})
+                        : undefined,
+                };
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(output, null, 2) }],
+                    structuredContent: output,
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                telemetryPayload.results = {
+                    success: false,
+                    error: errorMessage,
+                };
+                telemetry.track(mcp_constants_1.USER_CALLED_MCP_TOOL_EVENT, telemetryPayload);
+                const output = { error: errorMessage };
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(output, null, 2) }],
+                    structuredContent: output,
+                    isError: true,
+                };
+            }
+        },
+    };
+};
 exports.createUpdateWorkflowTool = createUpdateWorkflowTool;
 //# sourceMappingURL=update-workflow.tool.js.map