n8n 2.40.5 → 2.41.1

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

@@ -1,3 +1,4 @@
+import type { Logger } from '@n8n/backend-common';
 import type { GlobalConfig } from '@n8n/config';
 import { type User, type SharedWorkflowRepository } from '@n8n/db';
 import { z } from 'zod';
@@ -5,6 +6,7 @@ import type { CollaborationService } from '../../../../collaboration/collaborati
 import type { CredentialsService } from '../../../../credentials/credentials.service';
 import type { SubworkflowPolicyChecker } from '../../../../executions/pre-execution-checks/subworkflow-policy-checker';
 import type { DataTableUserOperations } from '../../../../modules/data-table/data-table-proxy.service';
+import type { McpPostSaveMetricsService } from '../../../../modules/mcp/mcp-post-save-metrics.service';
 import type { NodeTypes } from '../../../../node-types';
 import type { AiGatewayService } from '../../../../services/ai-gateway.service';
 import type { TagService } from '../../../../services/tag.service';
@@ -13,12 +15,13 @@ import type { Telemetry } from '../../../../telemetry';
 import type { WorkflowFinderService } from '../../../../workflows/workflow-finder.service';
 import type { WorkflowPublishedDataService } from '../../../../workflows/workflow-published-data.service';
 import type { WorkflowService } from '../../../../workflows/workflow.service';
+import { type FindUninstalledNodeTypes } from './uninstalled-node-warnings';
 import type { ToolDefinition } from '../../mcp.types';
-declare const buildInputSchema: (canvasGroupsEnabled: boolean) => {
+declare const inputSchema: {
     workflowId: z.ZodString;
     skillsUsed: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     operations: z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<["updateNodeParameters", "setNodeParameter", "addNode", "removeNode", "renameNode", "addConnection", "removeConnection", "setNodeCredential", "setNodePosition", "setNodeDisabled", "setNodeSettings", "setWorkflowMetadata", "setWorkflowSettings", "addTags", "removeTags", "setNodeGroups"]> | z.ZodEnum<["updateNodeParameters", "setNodeParameter", "addNode", "removeNode", "renameNode", "addConnection", "removeConnection", "setNodeCredential", "setNodePosition", "setNodeDisabled", "setNodeSettings", "setWorkflowMetadata", "setWorkflowSettings", "addTags", "removeTags", "setNodeGroups", "addNodeGroup", "removeNodeGroup", "updateNodeGroup"]>;
+        type: z.ZodEnum<["updateNodeParameters", "setNodeParameter", "addNode", "removeNode", "renameNode", "addConnection", "removeConnection", "setNodeCredential", "setNodePosition", "setNodeDisabled", "setNodeSettings", "setWorkflowMetadata", "setWorkflowSettings", "addTags", "removeTags", "setNodeGroups", "addNodeGroup", "removeNodeGroup", "updateNodeGroup"]>;
         nodeName: z.ZodOptional<z.ZodString>;
         node: z.ZodOptional<z.ZodObject<{
             name: z.ZodString;
@@ -156,9 +159,9 @@ declare const buildInputSchema: (canvasGroupsEnabled: boolean) => {
             nodeNames: string[];
             description?: string | undefined;
         }>, "many">>;
-        groupName?: z.ZodOptional<z.ZodString> | undefined;
-        nodeNames?: z.ZodOptional<z.ZodArray<z.ZodString, "many">> | undefined;
-        id?: z.ZodOptional<z.ZodString> | undefined;
+        groupName: z.ZodOptional<z.ZodString>;
+        nodeNames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        id: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         type: "addConnection" | "addNode" | "addNodeGroup" | "addTags" | "removeConnection" | "removeNode" | "removeNodeGroup" | "removeTags" | "renameNode" | "setNodeCredential" | "setNodeDisabled" | "setNodeGroups" | "setNodeParameter" | "setNodePosition" | "setNodeSettings" | "setWorkflowMetadata" | "setWorkflowSettings" | "updateNodeGroup" | "updateNodeParameters";
         nodeName?: string | undefined;
@@ -220,9 +223,9 @@ declare const buildInputSchema: (canvasGroupsEnabled: boolean) => {
             nodeNames: string[];
             description?: string | undefined;
         }[] | undefined;
-        groupName?: unknown;
-        nodeNames?: unknown;
-        id?: unknown;
+        groupName?: string | undefined;
+        nodeNames?: string[] | undefined;
+        id?: string | undefined;
     }, {
         type: "addConnection" | "addNode" | "addNodeGroup" | "addTags" | "removeConnection" | "removeNode" | "removeNodeGroup" | "removeTags" | "renameNode" | "setNodeCredential" | "setNodeDisabled" | "setNodeGroups" | "setNodeParameter" | "setNodePosition" | "setNodeSettings" | "setWorkflowMetadata" | "setWorkflowSettings" | "updateNodeGroup" | "updateNodeParameters";
         nodeName?: string | undefined;
@@ -284,14 +287,15 @@ declare const buildInputSchema: (canvasGroupsEnabled: boolean) => {
             nodeNames: string[];
             description?: string | undefined;
         }[] | undefined;
-        groupName?: unknown;
-        nodeNames?: unknown;
-        id?: unknown;
+        groupName?: string | undefined;
+        nodeNames?: string[] | undefined;
+        id?: string | undefined;
     }>, "many">;
     versionName: z.ZodOptional<z.ZodString>;
     versionDescription: z.ZodOptional<z.ZodString>;
 };
-export declare const createUpdateWorkflowTool: (user: User, workflowFinderService: WorkflowFinderService, workflowService: WorkflowService, urlService: UrlService, telemetry: Telemetry, nodeTypes: NodeTypes, credentialsService: CredentialsService, sharedWorkflowRepository: SharedWorkflowRepository, collaborationService: CollaborationService, dataTableOps: DataTableUserOperations, tagService: TagService, globalConfig: GlobalConfig, subworkflowPolicyChecker: SubworkflowPolicyChecker, workflowPublishedDataService: WorkflowPublishedDataService, aiGatewayService: AiGatewayService, options?: {
-    canvasGroupsEnabled?: boolean;
-}) => ToolDefinition<ReturnType<typeof buildInputSchema>>;
+export declare const createUpdateWorkflowTool: (user: User, workflowFinderService: WorkflowFinderService, workflowService: WorkflowService, urlService: UrlService, telemetry: Telemetry, nodeTypes: NodeTypes, credentialsService: CredentialsService, sharedWorkflowRepository: SharedWorkflowRepository, collaborationService: CollaborationService, dataTableOps: DataTableUserOperations, tagService: TagService, globalConfig: GlobalConfig, subworkflowPolicyChecker: SubworkflowPolicyChecker, workflowPublishedDataService: WorkflowPublishedDataService, aiGatewayService: AiGatewayService, options: {
+    findUninstalledNodeTypes?: FindUninstalledNodeTypes;
+    installToolAvailable?: boolean;
+} | undefined, logger: Logger, postSaveMetrics: McpPostSaveMetricsService) => ToolDefinition<typeof inputSchema>;
 export {};

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

@@ -1,8 +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 isEqual_1 = __importDefault(require("lodash/isEqual"));
 const n8n_workflow_1 = require("n8n-workflow");
 const zod_1 = require("zod");
 const subworkflow_policy_denial_error_1 = require("../../../../errors/subworkflow-policy-denial.error");
@@ -12,14 +16,17 @@ const constants_1 = require("./constants");
 const credential_validation_1 = require("./credential-validation");
 const credentials_auto_assign_1 = require("./credentials-auto-assign");
 const data_table_validation_1 = require("./data-table-validation");
+const error_code_utils_1 = require("./error-code.utils");
 const skills_used_1 = require("./skills-used");
 const top_level_items_warning_1 = require("./top-level-items-warning");
+const uninstalled_node_warnings_1 = require("./uninstalled-node-warnings");
 const version_metadata_1 = require("./version-metadata");
 const workflow_operations_1 = require("./workflow-operations");
 const mcp_constants_1 = require("../../mcp.constants");
 const workflow_validation_utils_1 = require("../workflow-validation.utils");
 const MAX_OPERATIONS_PER_CALL = 100;
-const baseOperationTypes = [
+const normalize = (value) => JSON.parse(JSON.stringify(value ?? null));
+const operationTypes = [
     'updateNodeParameters',
     'setNodeParameter',
     'addNode',
@@ -36,16 +43,28 @@ const baseOperationTypes = [
     'addTags',
     'removeTags',
     'setNodeGroups',
-];
-const gatedGroupOperationTypes = [
     'addNodeGroup',
     'removeNodeGroup',
     'updateNodeGroup',
 ];
-const GATED_GROUP_OP_TYPES = new Set(gatedGroupOperationTypes);
-const buildOperationTypeSchema = (canvasGroupsEnabled) => canvasGroupsEnabled
-    ? zod_1.z.enum([...baseOperationTypes, ...gatedGroupOperationTypes])
-    : zod_1.z.enum(baseOperationTypes);
+const operationTypeSchema = zod_1.z.enum(operationTypes);
+const GRAPH_OPERATION_TYPES = new Set([
+    'addNode',
+    'removeNode',
+    'renameNode',
+    'updateNodeParameters',
+    'setNodeParameter',
+    'addConnection',
+    'removeConnection',
+    'setNodeCredential',
+    'setNodePosition',
+    'setNodeDisabled',
+    'setNodeGroups',
+    'addNodeGroup',
+    'removeNodeGroup',
+    'updateNodeGroup',
+    'setNodeSettings',
+]);
 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({
@@ -76,23 +95,17 @@ const combinedSettingsInputSchema = zod_1.z
     ...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.z
+const operationInputSchema = zod_1.z
     .object({
-    type: buildOperationTypeSchema(canvasGroupsEnabled).describe('Operation type.'),
+    type: operationTypeSchema.describe('Operation type.'),
     nodeName: zod_1.z.string().optional().describe('For node-targeted ops.'),
     node: nodeInputSchema.optional().describe('For addNode.'),
-    parameters: zod_1.z
-        .record(zod_1.z.string(), zod_1.z.unknown())
-        .optional()
-        .describe('For updateNodeParameters.'),
+    parameters: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional().describe('For updateNodeParameters.'),
     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.'),
+    newName: zod_1.z.string().optional().describe('For renameNode or updateNodeGroup.'),
     source: zod_1.z.string().optional().describe('For connection ops.'),
     target: zod_1.z.string().optional().describe('For connection ops.'),
     sourceIndex: zod_1.z
@@ -120,16 +133,12 @@ const buildOperationInputSchema = (canvasGroupsEnabled) => zod_1.z
         .string()
         .max(128)
         .optional()
-        .describe(canvasGroupsEnabled
-        ? 'For setWorkflowMetadata (workflow name) or addNodeGroup (group name).'
-        : 'Only used for setWorkflowMetadata.'),
+        .describe('For setWorkflowMetadata (workflow name) or addNodeGroup (group name).'),
     description: zod_1.z
         .string()
         .max(255)
         .optional()
-        .describe(canvasGroupsEnabled
-        ? 'For setWorkflowMetadata, addNodeGroup, or updateNodeGroup.'
-        : 'Only used for setWorkflowMetadata.'),
+        .describe('For setWorkflowMetadata, addNodeGroup, or updateNodeGroup.'),
     names: zod_1.z.array(zod_1.z.string()).optional().describe('For addTags / removeTags.'),
     nodeGroups: zod_1.z
         .array(zod_1.z.object({
@@ -140,16 +149,12 @@ const buildOperationInputSchema = (canvasGroupsEnabled) => zod_1.z
     }))
         .optional()
         .describe('For setNodeGroups. Replaces all node groups; pass [] to clear. Group members are node names, not ids.'),
-    ...(canvasGroupsEnabled
-        ? {
-            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.z.string().optional().describe('For addNodeGroup; group id, generated if omitted.'),
-        }
-        : {}),
+    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.z.string().optional().describe('For addNodeGroup; group id, generated if omitted.'),
 })
     .strict()
     .describe('Workflow update operation. Provide fields matching type.');
@@ -171,25 +176,18 @@ function parseStrictOperations(operations) {
     throw new Error(`Invalid operations: ${details}`);
 }
 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.';
-    return canvasGroupsEnabled
-        ? `${base} Node-group operations (${NON_FATAL_OPERATION_TYPES_LIST}) are the one exception to "atomically": an invalid one is skipped and reported in skippedOperations instead of aborting the whole update. Separately, if other edits in the batch make an existing group invalid, that group is removed and reported in removedGroups.`
-        : base;
-};
-const buildInputSchema = (canvasGroupsEnabled) => ({
+const TOOL_DESCRIPTION = `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. Node-group operations (${NON_FATAL_OPERATION_TYPES_LIST}) are the one exception to "atomically": an invalid one is skipped and reported in skippedOperations instead of aborting the whole update. Separately, if other edits in the batch make an existing group invalid, that group is removed and reported in removedGroups.`;
+const inputSchema = {
     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))
+        .array(operationInputSchema)
         .min(1)
         .max(MAX_OPERATIONS_PER_CALL)
-        .describe(canvasGroupsEnabled
-        ? `Ordered operations to apply atomically (max ${MAX_OPERATIONS_PER_CALL}). If any op fails, nothing is saved — except node-group operations (${NON_FATAL_OPERATION_TYPES_LIST}): an invalid one is skipped and reported in skippedOperations, while the rest of the batch still saves. An existing group that these ops leave invalid is removed and reported in removedGroups.`
-        : `Ordered operations to apply atomically (max ${MAX_OPERATIONS_PER_CALL}). If any op fails, nothing is saved.`),
+        .describe(`Ordered operations to apply atomically (max ${MAX_OPERATIONS_PER_CALL}). If any op fails, nothing is saved — except node-group operations (${NON_FATAL_OPERATION_TYPES_LIST}): an invalid one is skipped and reported in skippedOperations, while the rest of the batch still saves. An existing group that these ops leave invalid is removed and reported in removedGroups.`),
     versionName: version_metadata_1.versionNameInputSchema.describe('Short summary of what this update changes, shown in the workflow\'s version history (e.g. "Added Slack notification after HTTP request"). Always provide it.'),
     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.z.string().optional(),
     name: zod_1.z.string().optional(),
@@ -220,7 +218,6 @@ const outputSchema = {
     }))
         .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.z.string().optional(),
     skippedOperations: zod_1.z
         .array(zod_1.z.object({
         opIndex: zod_1.z.number(),
@@ -244,6 +241,8 @@ const outputSchema = {
         .string()
         .optional()
         .describe('Error message explaining why the update failed. Present only on failure.'),
+    errorCode: zod_1.z.string().optional().describe('Machine-readable error code.'),
+    note: zod_1.z.string().optional(),
 };
 async function assertErrorWorkflowIsUsable({ errorWorkflowId, parentWorkflowId, user, workflowFinderService, workflowPublishedDataService, useWorkflowPublicationService, nodeTypes, subworkflowPolicyChecker, errorTriggerType, }) {
     if (!errorWorkflowId || errorWorkflowId === 'DEFAULT') {
@@ -366,6 +365,12 @@ function dedupeNamesPreservingCase(names) {
     }
     return result;
 }
+function haveSameTagNames(actualTags, expectedTagNames) {
+    if (!actualTags || !expectedTagNames) {
+        return false;
+    }
+    return (0, isEqual_1.default)(actualTags.map((tag) => tag.name).sort(), dedupeNamesPreservingCase(expectedTagNames).sort());
+}
 function collectTouchedNodes(operations) {
     const touched = new Map();
     const recordTouch = (name, opIndex) => {
@@ -413,24 +418,19 @@ const countOperationsWithNoEffect = (skippedOperations, groupOperations) => {
 };
 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.');
-    }
+function assertOperationsSupported(strictOperations, { tagsDisabled }) {
     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) {
+function resolveNodeGroupViolations(result, nodeTypes) {
     const skippedOperations = [...result.skippedOperations];
     const removedGroups = [];
     const getNodeType = (0, workflow_helpers_1.makeGetNodeTypeForGrouping)(nodeTypes);
-    const violations = canvasGroupsEnabled
-        ? [
-            ...(0, workflow_helpers_1.dropInvalidWorkflowGroups)(result.workflow, getNodeType, (violation) => result.groupOperations[violation.groupId] !== undefined),
-            ...(0, workflow_helpers_1.dropInvalidWorkflowGroups)(result.workflow, getNodeType),
-        ]
-        : [];
+    const violations = [
+        ...(0, workflow_helpers_1.dropInvalidWorkflowGroups)(result.workflow, getNodeType, (violation) => result.groupOperations[violation.groupId] !== undefined),
+        ...(0, workflow_helpers_1.dropInvalidWorkflowGroups)(result.workflow, getNodeType),
+    ];
     for (const violation of violations) {
         const requestedBy = result.groupOperations[violation.groupId];
         if (requestedBy) {
@@ -533,8 +533,7 @@ async function resolveTagIds(tagNames, user, tagService) {
     }
     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 createUpdateWorkflowTool = (user, workflowFinderService, workflowService, urlService, telemetry, nodeTypes, credentialsService, sharedWorkflowRepository, collaborationService, dataTableOps, tagService, globalConfig, subworkflowPolicyChecker, workflowPublishedDataService, aiGatewayService, options = {}, logger, postSaveMetrics) => {
     const settingsGuardDependencies = {
         user,
         nodeTypes,
@@ -546,8 +545,8 @@ const createUpdateWorkflowTool = (user, workflowFinderService, workflowService,
     return {
         name: constants_1.MCP_UPDATE_WORKFLOW_TOOL.toolName,
         config: {
-            description: buildToolDescription(canvasGroupsEnabled),
-            inputSchema: buildInputSchema(canvasGroupsEnabled),
+            description: TOOL_DESCRIPTION,
+            inputSchema,
             outputSchema,
             annotations: {
                 title: constants_1.MCP_UPDATE_WORKFLOW_TOOL.displayTitle,
@@ -566,27 +565,34 @@ const createUpdateWorkflowTool = (user, workflowFinderService, workflowService,
                 versionName,
                 versionDescription,
             });
+            let updateAttempted = false;
+            let hasGraphOps = false;
+            let hasTagOperations = false;
+            let expectedWorkflow = null;
+            let expectedSettings;
+            let expectedTagNames;
+            let existingWorkflow = null;
             try {
                 const strictOperations = parseStrictOperations(operations);
-                const hasTagOperations = strictOperations.some(isTagOperation);
+                hasTagOperations = strictOperations.some(isTagOperation);
                 const hasNonTagOperations = strictOperations.some((op) => !isTagOperation(op));
                 const hasSettingsOperations = strictOperations.some(isSettingsOperation);
+                hasGraphOps = strictOperations.some((op) => GRAPH_OPERATION_TYPES.has(op.type));
                 assertOperationsSupported(strictOperations, {
-                    canvasGroupsEnabled,
                     tagsDisabled: globalConfig.tags.disabled,
                 });
-                const existingWorkflow = await (0, workflow_validation_utils_1.getMcpWorkflow)(workflowId, user, ['workflow:update'], workflowFinderService, { includeTags: hasTagOperations });
+                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 });
+                const result = (0, workflow_operations_1.applyOperations)((0, workflow_operations_1.toWorkflowSlice)(existingWorkflow, { includeTags: hasTagOperations }), strictOperations);
                 if (!result.success) {
                     throw new Error(result.error);
                 }
-                const { skippedOperations, removedGroups, nodeGroupsNeedPersisting } = resolveNodeGroupViolations(result, canvasGroupsEnabled, nodeTypes);
+                const { skippedOperations, removedGroups, nodeGroupsNeedPersisting } = resolveNodeGroupViolations(result, 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);
                 }
-                const invalidToolSourceResponse = (0, connection_structure_check_1.buildInvalidAiToolSourceErrorResponse)({ nodes: result.workflow.nodes, connections: result.workflow.connections }, nodeTypes, (errorMessage) => ({ error: errorMessage }), telemetryPayload, telemetry);
+                const invalidToolSourceResponse = (0, connection_structure_check_1.buildInvalidAiToolSourceErrorResponse)({ nodes: result.workflow.nodes, connections: result.workflow.connections }, nodeTypes, (errorMessage) => ({ error: errorMessage, errorCode: 'INVALID_AI_TOOL_SOURCE' }), telemetryPayload, telemetry);
                 if (invalidToolSourceResponse) {
                     return invalidToolSourceResponse;
                 }
@@ -618,8 +624,22 @@ const createUpdateWorkflowTool = (user, workflowFinderService, workflowService,
                     projectId: workflowProjectId,
                 }, { user, nodeTypes, credentialsService, aiGatewayService });
                 const validationWarnings = await collectValidationWarnings(workflowUpdateData, existingWorkflow, nodeTypes);
+                validationWarnings.push(...(await (0, uninstalled_node_warnings_1.buildUninstalledNodeWarnings)(workflowUpdateData.nodes.filter((node) => result.addedNodeNames.includes(node.name)), options.findUninstalledNodeTypes, options.installToolAvailable)));
                 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 }));
+                expectedWorkflow = {
+                    nodes: workflowUpdateData.nodes,
+                    connections: workflowUpdateData.connections,
+                    ...(workflowUpdateData.nodeGroups !== undefined
+                        ? { nodeGroups: workflowUpdateData.nodeGroups }
+                        : {}),
+                };
+                expectedSettings =
+                    hasSettingsOperations && workflowUpdateData.settings
+                        ? (0, workflow_helpers_1.removeDefaultValues)({ ...(existingWorkflow.settings ?? {}), ...workflowUpdateData.settings }, globalConfig.executions.timeout)
+                        : undefined;
+                expectedTagNames = result.tagNames;
+                updateAttempted = true;
                 const updatedWorkflow = await workflowService.update(user, workflowUpdateData, workflowId, {
                     aiBuilderAssisted: hasNonTagOperations,
                     source: 'n8n-mcp',
@@ -627,25 +647,10 @@ const createUpdateWorkflowTool = (user, workflowFinderService, workflowService,
                     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 ceilingWarning = canvasGroupsEnabled
-                    ? (0, top_level_items_warning_1.topLevelItemsWarning)(updatedWorkflow)
-                    : undefined;
+                const ceilingWarning = (0, top_level_items_warning_1.topLevelItemsWarning)(updatedWorkflow);
                 if (ceilingWarning) {
                     const preExistingUngroupedNodeNames = new Set((0, top_level_items_warning_1.summarizeUngroupedNodeNames)(existingWorkflow));
                     const hasNewlyAddedUngroupedNodeNames = (0, top_level_items_warning_1.summarizeUngroupedNodeNames)(updatedWorkflow).some((name) => !preExistingUngroupedNodeNames.has(name));
@@ -676,6 +681,28 @@ const createUpdateWorkflowTool = (user, workflowFinderService, workflowService,
                         ? (updatedWorkflow.settings ?? {})
                         : undefined,
                 };
+                try {
+                    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(() => { });
+                    telemetryPayload.results = {
+                        success: true,
+                        data: {
+                            workflowId: updatedWorkflow.id,
+                            nodeCount: updatedWorkflow.nodes.length,
+                        },
+                    };
+                    telemetry.track(mcp_constants_1.USER_CALLED_MCP_TOOL_EVENT, telemetryPayload);
+                }
+                catch (sideEffectError) {
+                    logger.error('Post-save side effect failed for update_workflow', {
+                        workflowId: updatedWorkflow.id,
+                        error: sideEffectError,
+                    });
+                    postSaveMetrics.incrementPostSaveFailure('update', sideEffectError);
+                }
                 return {
                     content: [{ type: 'text', text: JSON.stringify(output, null, 2) }],
                     structuredContent: output,
@@ -683,12 +710,98 @@ const createUpdateWorkflowTool = (user, workflowFinderService, workflowService,
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : String(error);
-                telemetryPayload.results = {
-                    success: false,
+                const errorCode = (0, error_code_utils_1.getErrorCode)(error);
+                if (updateAttempted && existingWorkflow) {
+                    let persisted = null;
+                    try {
+                        persisted = await workflowFinderService.findWorkflowForUser(workflowId, user, ['workflow:read'], { includeTags: hasTagOperations });
+                    }
+                    catch (lookupError) {
+                        logger.warn('Post-update verification lookup failed', {
+                            workflowId,
+                            error: lookupError,
+                        });
+                    }
+                    const matchesExpected = persisted &&
+                        expectedWorkflow &&
+                        (0, isEqual_1.default)(normalize(persisted.nodes), normalize(expectedWorkflow.nodes)) &&
+                        (0, isEqual_1.default)(normalize(persisted.connections), normalize(expectedWorkflow.connections)) &&
+                        (expectedWorkflow.nodeGroups === undefined ||
+                            (0, isEqual_1.default)(normalize(persisted.nodeGroups), normalize(expectedWorkflow.nodeGroups)));
+                    const contentChanged = !(0, isEqual_1.default)(normalize(existingWorkflow.nodes), normalize(expectedWorkflow?.nodes)) ||
+                        !(0, isEqual_1.default)(normalize(existingWorkflow.connections), normalize(expectedWorkflow?.connections)) ||
+                        (expectedWorkflow?.nodeGroups !== undefined &&
+                            !(0, isEqual_1.default)(normalize(existingWorkflow.nodeGroups), normalize(expectedWorkflow.nodeGroups)));
+                    const existingUpdatedAt = existingWorkflow.updatedAt
+                        ? new Date(existingWorkflow.updatedAt).getTime()
+                        : undefined;
+                    const persistedUpdatedAt = persisted?.updatedAt
+                        ? new Date(persisted.updatedAt).getTime()
+                        : undefined;
+                    const hasNewerTimestamp = existingUpdatedAt !== undefined &&
+                        persistedUpdatedAt !== undefined &&
+                        persistedUpdatedAt > existingUpdatedAt;
+                    const hasPersistedExpectedSettings = expectedSettings !== undefined &&
+                        persisted &&
+                        (0, isEqual_1.default)(normalize(persisted.settings), normalize(expectedSettings)) &&
+                        !(0, isEqual_1.default)(normalize(existingWorkflow.settings), normalize(expectedSettings));
+                    const wasTouched = Boolean(hasNewerTimestamp || hasPersistedExpectedSettings);
+                    const tagsMatchExpected = !hasTagOperations || haveSameTagNames(persisted?.tags, expectedTagNames);
+                    const recovered = tagsMatchExpected &&
+                        (hasGraphOps
+                            ? Boolean(matchesExpected) && (contentChanged || hasNewerTimestamp)
+                            : wasTouched);
+                    if (persisted && recovered) {
+                        const baseUrl = urlService.getInstanceBaseUrl();
+                        const workflowUrl = `${baseUrl}/workflow/${persisted.id}`;
+                        try {
+                            telemetryPayload.results = {
+                                success: true,
+                                data: {
+                                    workflowId: persisted.id,
+                                    nodeCount: persisted.nodes.length,
+                                    postSaveError: errorMessage,
+                                },
+                            };
+                            telemetry.track(mcp_constants_1.USER_CALLED_MCP_TOOL_EVENT, telemetryPayload);
+                        }
+                        catch (telemetryError) {
+                            logger.error('Post-save telemetry failed for update_workflow (recovery path)', {
+                                workflowId: persisted.id,
+                                error: telemetryError,
+                            });
+                            postSaveMetrics.incrementPostSaveFailure('update', telemetryError);
+                        }
+                        const output = {
+                            workflowId: persisted.id,
+                            name: persisted.name,
+                            nodeCount: persisted.nodes.length,
+                            url: workflowUrl,
+                            note: `Workflow was updated successfully, but a post-save operation failed: ${errorMessage}`,
+                        };
+                        postSaveMetrics.incrementPostSaveFailure('update', error);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(output, null, 2) }],
+                            structuredContent: output,
+                        };
+                    }
+                }
+                try {
+                    telemetryPayload.results = {
+                        success: false,
+                        error: errorMessage,
+                    };
+                    telemetry.track(mcp_constants_1.USER_CALLED_MCP_TOOL_EVENT, telemetryPayload);
+                }
+                catch (telemetryError) {
+                    logger.error('Telemetry failed for update_workflow (error path)', {
+                        error: telemetryError,
+                    });
+                }
+                const output = {
                     error: errorMessage,
+                    errorCode,
                 };
-                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,