n8n 2.41.2 → 2.42.0

package/dist/webhooks/webhook-helpers.js

@@ -41,6 +41,8 @@ exports.handleHostedChatResponse = handleHostedChatResponse;
 exports.getWorkflowWebhooks = getWorkflowWebhooks;
 exports.autoDetectResponseMode = autoDetectResponseMode;
 exports.setupResponseNodePromise = setupResponseNodePromise;
+exports.invokeWebhook = invokeWebhook;
+exports.handleImmediateWebhookResponse = handleImmediateWebhookResponse;
 exports.prepareExecutionData = prepareExecutionData;
 exports.executeWebhook = executeWebhook;
 exports._privateGetWebhookErrorMessage = _privateGetWebhookErrorMessage;
@@ -48,6 +50,8 @@ const backend_common_1 = require("@n8n/backend-common");
 const config_1 = require("@n8n/config");
 const db_1 = require("@n8n/db");
 const di_1 = require("@n8n/di");
+const ensure_error_1 = require("@n8n/utils/errors/ensure-error");
+const is_record_1 = require("@n8n/utils/is-record");
 const deferred_promise_1 = require("@n8n/utils/promise/deferred-promise");
 const merge_1 = __importDefault(require("lodash/merge"));
 const n8n_core_1 = require("n8n-core");
@@ -63,12 +67,14 @@ const internal_server_error_1 = require("../errors/response-errors/internal-serv
 const not_found_error_1 = require("../errors/response-errors/not-found.error");
 const unsupported_media_type_error_1 = require("../errors/response-errors/unsupported-media-type.error");
 const event_service_1 = require("../events/event.service");
+const execution_id_1 = require("../executions/execution-id");
 const middlewares_1 = require("../middlewares");
 const webhook_response_relay_1 = require("../scaling/webhook-response-relay");
 const oauth_token_verifier_proxy_service_1 = require("../services/oauth-token-verifier-proxy.service");
 const oauth2_flow_proxy_service_1 = require("../services/oauth2-flow-proxy.service");
 const ownership_service_1 = require("../services/ownership.service");
 const protected_resource_registry_1 = require("../services/protected-resource.registry");
+const engine_v2_webhook_responder_service_1 = require("../services/engine-v2-webhook-responder.service");
 const workflow_statistics_service_1 = require("../services/workflow-statistics.service");
 const wait_tracker_1 = require("../wait-tracker");
 const constants_2 = require("../webhooks/constants");
@@ -82,6 +88,7 @@ const WorkflowHelpers = __importStar(require("../workflow-helpers"));
 const workflow_runner_1 = require("../workflow-runner");
 const engine_v2_webhooks_1 = require("./engine-v2-webhooks");
 const webhook_response_headers_1 = require("./webhook-response-headers");
+const webhook_responder_1 = require("./webhook-responder");
 const webhook_service_1 = require("./webhook.service");
 const SUPPORTED_RESPONSE_MODES = new Set([
     'onReceived',
@@ -162,13 +169,12 @@ async function prepareMcpQueueExecution(workflowStartNode, req, webhookResultDat
     });
     return true;
 }
-function handleHostedChatResponse(res, responseMode, didSendResponse, executionId, resumeToken) {
-    if (responseMode === 'hostedChat' && !didSendResponse) {
-        res.send({ executionStarted: true, executionId, resumeToken });
-        process.nextTick(() => res.end());
-        return true;
-    }
-    return didSendResponse;
+function handleHostedChatResponse(res, responseMode, executionId, responder, resumeToken) {
+    if (responseMode !== 'hostedChat' || responder.hasResponded)
+        return;
+    res.send({ executionStarted: true, executionId, resumeToken });
+    process.nextTick(() => res.end());
+    responder.respondWithNoResponse();
 }
 function getWorkflowWebhooks(workflow, additionalData, destinationNode, ignoreRestartWebhooks = false) {
     const returnData = [];
@@ -206,27 +212,18 @@ function isEnabledFormPageNode(node) {
     return node.type === n8n_workflow_1.WAIT_NODE_TYPE && node.parameters.resume === 'form';
 }
 function autoDetectResponseMode(workflowStartNode, workflow, method) {
-    if (workflowStartNode.type === n8n_workflow_1.FORM_TRIGGER_NODE_TYPE && method === 'POST') {
-        const connectedNodes = workflow.getChildNodes(workflowStartNode.name);
-        for (const nodeName of connectedNodes) {
-            const node = workflow.nodes[nodeName];
-            if (isEnabledFormPageNode(node)) {
-                return 'formPage';
-            }
-        }
-    }
+    const hasChildMatching = (predicate) => workflow
+        .getChildNodes(workflowStartNode.name)
+        .some((nodeName) => predicate(workflow.nodes[nodeName]));
+    const isFormTriggerPost = workflowStartNode.type === n8n_workflow_1.FORM_TRIGGER_NODE_TYPE && method === 'POST';
+    if (isFormTriggerPost && hasChildMatching(isEnabledFormPageNode))
+        return 'formPage';
     const chatResponseMode = getChatResponseMode(workflowStartNode, method);
     if (chatResponseMode)
         return chatResponseMode;
-    if (workflowStartNode.type === n8n_workflow_1.FORM_NODE_TYPE && method === 'POST') {
-        const connectedNodes = workflow.getChildNodes(workflowStartNode.name);
-        for (const nodeName of connectedNodes) {
-            const node = workflow.nodes[nodeName];
-            if (node.type === n8n_workflow_1.FORM_NODE_TYPE && !node.disabled) {
-                return 'formPage';
-            }
-        }
-    }
+    const isFormPost = workflowStartNode.type === n8n_workflow_1.FORM_NODE_TYPE && method === 'POST';
+    if (isFormPost && hasChildMatching((node) => node.type === n8n_workflow_1.FORM_NODE_TYPE && !node.disabled))
+        return 'formPage';
     if (workflowStartNode.type === n8n_workflow_1.WAIT_NODE_TYPE && workflowStartNode.parameters.resume !== 'form') {
         return undefined;
     }
@@ -234,15 +231,9 @@ function autoDetectResponseMode(workflowStartNode, workflow, method) {
         workflowStartNode.parameters.operation === 'completion') {
         return 'onReceived';
     }
-    if ([n8n_workflow_1.FORM_NODE_TYPE, n8n_workflow_1.WAIT_NODE_TYPE].includes(workflowStartNode.type) && method === 'POST') {
-        const connectedNodes = workflow.getChildNodes(workflowStartNode.name);
-        for (const nodeName of connectedNodes) {
-            const node = workflow.nodes[nodeName];
-            if (isEnabledFormPageNode(node)) {
-                return 'responseNode';
-            }
-        }
-    }
+    const isFormOrWaitPost = [n8n_workflow_1.FORM_NODE_TYPE, n8n_workflow_1.WAIT_NODE_TYPE].includes(workflowStartNode.type) && method === 'POST';
+    if (isFormOrWaitPost && hasChildMatching(isEnabledFormPageNode))
+        return 'responseNode';
     return undefined;
 }
 const handleFormRedirectionCase = (data, workflowStartNode) => {
@@ -272,12 +263,11 @@ const handleFormRedirectionCase = (data, workflowStartNode) => {
 exports.handleFormRedirectionCase = handleFormRedirectionCase;
 const { formDataFileSizeMax } = di_1.Container.get(config_1.GlobalConfig).endpoints;
 const parseFormData = (0, webhook_form_data_1.createMultiFormDataParser)(formDataFileSizeMax);
-function setupResponseNodePromise(responsePromise, res, responseCallback, workflowStartNode, executionId, workflow) {
-    void responsePromise.promise
-        .then(async (response) => {
-        if (response === constants_2.EXECUTION_ENDED_WITHOUT_RESPONSE) {
-            return;
-        }
+function isHttpFullResponse(response) {
+    return ((0, is_record_1.isRecord)(response) && (0, is_record_1.isRecord)(response.headers) && typeof response.statusCode === 'number');
+}
+async function sendResponseNodeResponse(response, res, responder, workflowStartNode, executionId, workflow) {
+    try {
         const binaryData = response.body?.binaryData;
         if (binaryData?.id) {
             if (response.statusCode) {
@@ -297,7 +287,7 @@ function setupResponseNodePromise(responsePromise, res, responseCallback, workfl
                     executionId,
                 });
             }
-            responseCallback(null, { noWebhookResponse: true });
+            responder.respondWithNoResponse();
         }
         else if (Buffer.isBuffer(response.body)) {
             if (response.statusCode) {
@@ -306,7 +296,7 @@ function setupResponseNodePromise(responsePromise, res, responseCallback, workfl
             webhook_response_headers_1.WebhookResponseHeaders.fromObject(response.headers).applyToResponse(res);
             (0, webhook_response_headers_1.applySandboxCSP)(res);
             res.end(response.body);
-            responseCallback(null, { noWebhookResponse: true });
+            responder.respondWithNoResponse();
         }
         else {
             let data = {
@@ -315,20 +305,92 @@ function setupResponseNodePromise(responsePromise, res, responseCallback, workfl
                 responseCode: response.statusCode,
             };
             data = (0, exports.handleFormRedirectionCase)(data, workflowStartNode);
-            responseCallback(null, data);
+            responder.respondWith(data);
         }
         process.nextTick(() => res.end());
+    }
+    catch (e) {
+        const error = (0, ensure_error_1.ensureError)(e);
+        di_1.Container.get(n8n_core_1.ErrorReporter).error(error);
+        di_1.Container.get(backend_common_1.Logger).error(`Error with Webhook-Response for execution "${executionId}": "${error.message}"`, { executionId, workflowId: workflow.id });
+        responder.respondWithError(error);
+    }
+}
+function setupResponseNodePromise(responsePromise, res, responder, workflowStartNode, executionId, workflow) {
+    void responsePromise.promise
+        .then(async (response) => {
+        if (response === constants_2.EXECUTION_ENDED_WITHOUT_RESPONSE) {
+            return;
+        }
+        await sendResponseNodeResponse(response, res, responder, workflowStartNode, executionId, workflow);
     })
-        .catch(async (error) => {
+        .catch(async (e) => {
+        const error = (0, ensure_error_1.ensureError)(e);
         di_1.Container.get(n8n_core_1.ErrorReporter).error(error);
         di_1.Container.get(backend_common_1.Logger).error(`Error with Webhook-Response for execution "${executionId}": "${error.message}"`, { executionId, workflowId: workflow.id });
-        responseCallback(error, {});
+        responder.respondWithError(error);
     });
 }
 function shouldEstablishTriggerIdentity(workflowStartNode) {
     return (workflowStartNode.type === n8n_workflow_1.WEBHOOK_NODE_TYPE &&
         workflowStartNode.parameters?.authentication === 'n8nOAuth2');
 }
+async function invokeWebhook({ workflow, webhookData, workflowStartNode, additionalData, executionMode, runExecutionData, webhookType, responder, }) {
+    try {
+        const webhookResultData = await di_1.Container.get(webhook_service_1.WebhookService).runWebhook(workflow, webhookData, workflowStartNode, additionalData, executionMode, runExecutionData ?? null);
+        di_1.Container.get(workflow_statistics_service_1.WorkflowStatisticsService).emit('nodeFetchedData', {
+            workflowId: workflow.id,
+            node: workflowStartNode,
+        });
+        return { webhookResultData, runExecutionDataChanges: {} };
+    }
+    catch (e) {
+        const error = (0, ensure_error_1.ensureError)(e);
+        const errorMessage = _privateGetWebhookErrorMessage(error, webhookType);
+        di_1.Container.get(n8n_core_1.ErrorReporter).error(error, {
+            extra: {
+                nodeName: workflowStartNode.name,
+                nodeType: workflowStartNode.type,
+                nodeVersion: workflowStartNode.typeVersion,
+                workflowId: workflow.id,
+            },
+        });
+        responder.respondWithError(new n8n_workflow_1.UnexpectedError(errorMessage));
+        return {
+            runExecutionDataChanges: {
+                resultData: {
+                    runData: {},
+                    lastNodeExecuted: workflowStartNode.name,
+                    error: {
+                        ...error,
+                        message: error.message,
+                        stack: error.stack,
+                    },
+                },
+            },
+            webhookResultData: {
+                noWebhookResponse: true,
+                workflowData: [[{ json: {} }]],
+            },
+        };
+    }
+}
+function handleImmediateWebhookResponse({ webhookResultData, responseCode, responder, }) {
+    if (webhookResultData.noWebhookResponse === true && !responder.hasResponded) {
+        responder.respondWithNoResponse();
+    }
+    if (webhookResultData.workflowData !== undefined)
+        return true;
+    if (!responder.hasResponded) {
+        responder.respondWith({
+            data: webhookResultData.webhookResponse !== undefined
+                ? webhookResultData.webhookResponse
+                : { message: 'Webhook call received' },
+            responseCode,
+        });
+    }
+    return false;
+}
 function reconcileSeededExecutionStack(workflowStartNode, runExecutionData, nodeExecutionStack) {
     const executionData = runExecutionData?.executionData;
     if (!executionData?.nodeExecutionStack)
@@ -398,34 +460,14 @@ function toWebhookUser(user) {
         lastName: user.lastName,
     };
 }
-async function executeWebhook(workflow, webhookData, workflowData, workflowStartNode, executionMode, pushRef, runExecutionData, executionId, req, res, responseCallback, destinationNode, options) {
-    const nodeType = workflow.nodeTypes.getByNameAndVersion(workflowStartNode.type, workflowStartNode.typeVersion);
-    const additionalKeys = {
-        $executionId: executionId,
-    };
-    const context = new webhook_execution_context_1.WebhookExecutionContext(workflow, workflowStartNode, webhookData, executionMode, additionalKeys);
-    let project;
-    try {
-        project = await di_1.Container.get(ownership_service_1.OwnershipService).getWorkflowProjectCached(workflowData.id);
-    }
-    catch (error) {
-        throw new not_found_error_1.NotFoundError('Cannot find workflow');
-    }
-    const additionalData = await WorkflowExecuteAdditionalData.getBase({
-        projectId: project?.id,
-    });
-    if (options?.encryptedRunnerIdentity) {
-        additionalData.encryptedRunnerIdentity = options.encryptedRunnerIdentity;
+async function prepareWebhookAdditionalData({ workflow, workflowStartNode, executionMode, executionId, projectId, req, res, encryptedRunnerIdentity, getRunExecutionData, }) {
+    const additionalData = await WorkflowExecuteAdditionalData.getBase({ projectId });
+    if (encryptedRunnerIdentity) {
+        additionalData.encryptedRunnerIdentity = encryptedRunnerIdentity;
     }
     if (executionId) {
         additionalData.executionId = executionId;
     }
-    const { responseMode, responseCode, responseData, checkAllMainOutputs, responsePropertyName, responseContentType, responseBinaryPropertyName, } = evaluateResponseOptions(context, req);
-    if (!SUPPORTED_RESPONSE_MODES.has(responseMode)) {
-        const errorMessage = `The response mode '${responseMode}' is not valid!`;
-        responseCallback(new n8n_workflow_1.UnexpectedError(errorMessage), {});
-        throw new internal_server_error_1.InternalServerError(errorMessage);
-    }
     additionalData.httpRequest = req;
     additionalData.httpResponse = res;
     const authService = di_1.Container.get(auth_service_1.AuthService);
@@ -439,9 +481,11 @@ async function executeWebhook(workflow, webhookData, workflowData, workflowStart
             return undefined;
         return toWebhookUser(user);
     };
-    additionalData.beginN8nOAuth2Flow = async (resourceUrl, metadata) => await di_1.Container.get(oauth2_flow_proxy_service_1.OAuth2FlowProxy).begin(resourceUrl, metadata);
-    additionalData.completeN8nOAuth2Flow = async (code, state) => await di_1.Container.get(oauth2_flow_proxy_service_1.OAuth2FlowProxy).complete(code, state);
-    additionalData.refreshN8nOAuth2Flow = async (refreshToken, resourceUrl) => await di_1.Container.get(oauth2_flow_proxy_service_1.OAuth2FlowProxy).refreshVirtualClientToken(refreshToken, resourceUrl);
+    const oauth2FlowProxy = di_1.Container.get(oauth2_flow_proxy_service_1.OAuth2FlowProxy);
+    additionalData.beginN8nOAuth2Flow = oauth2FlowProxy.begin.bind(oauth2FlowProxy);
+    additionalData.completeN8nOAuth2Flow = oauth2FlowProxy.complete.bind(oauth2FlowProxy);
+    additionalData.refreshN8nOAuth2Flow =
+        oauth2FlowProxy.refreshVirtualClientToken.bind(oauth2FlowProxy);
     let admittedBy;
     additionalData.validateN8nOAuth2Token = async (token, resourceUrl) => {
         const oauthTokenVerifierProxy = di_1.Container.get(oauth_token_verifier_proxy_service_1.OAuthTokenVerifierProxy);
@@ -466,6 +510,7 @@ async function executeWebhook(workflow, webhookData, workflowData, workflowStart
             di_1.Container.get(backend_common_1.Logger).warn('Established a trigger identity without a resource grant; this run will depend on the protected resource still resolving', { workflowId: workflow.id, resource });
         }
         additionalData.encryptedRunnerIdentity = await di_1.Container.get(n8n_core_1.ExecutionContextService).buildTriggerIdentityCredentials(token, resource, grant, subject);
+        const runExecutionData = getRunExecutionData();
         if (runExecutionData) {
             await (0, n8n_core_1.establishExecutionContext)(workflow, runExecutionData, additionalData, executionMode);
         }
@@ -475,6 +520,7 @@ async function executeWebhook(workflow, webhookData, workflowData, workflowStart
         if (!credentialCheckProxy || !workflow.id) {
             return undefined;
         }
+        const runExecutionData = getRunExecutionData();
         const executionContext = runExecutionData?.executionData?.runtimeData ??
             (additionalData.encryptedRunnerIdentity
                 ? {
@@ -496,13 +542,45 @@ async function executeWebhook(workflow, webhookData, workflowData, workflowStart
             rootNodes,
         });
     };
-    let didSendResponse = false;
+    return additionalData;
+}
+async function executeWebhook(workflow, webhookData, workflowData, workflowStartNode, executionMode, pushRef, runExecutionData, executionId, req, res, responseCallback, destinationNode, options) {
+    const responder = new webhook_responder_1.WebhookResponder(responseCallback);
+    const nodeType = workflow.nodeTypes.getByNameAndVersion(workflowStartNode.type, workflowStartNode.typeVersion);
+    const additionalKeys = {
+        $executionId: executionId,
+    };
+    const context = new webhook_execution_context_1.WebhookExecutionContext(workflow, workflowStartNode, webhookData, executionMode, additionalKeys);
+    let project;
+    try {
+        project = await di_1.Container.get(ownership_service_1.OwnershipService).getWorkflowProjectCached(workflowData.id);
+    }
+    catch {
+        throw new not_found_error_1.NotFoundError('Cannot find workflow');
+    }
+    const additionalData = await prepareWebhookAdditionalData({
+        workflow,
+        workflowStartNode,
+        executionMode,
+        executionId,
+        projectId: project?.id,
+        req,
+        res,
+        encryptedRunnerIdentity: options?.encryptedRunnerIdentity,
+        getRunExecutionData: () => runExecutionData,
+    });
+    const { responseMode, responseCode, responseData, checkAllMainOutputs, responsePropertyName, responseContentType, responseBinaryPropertyName, } = evaluateResponseOptions(context, req);
+    if (!SUPPORTED_RESPONSE_MODES.has(responseMode)) {
+        const errorMessage = `The response mode '${responseMode}' is not valid!`;
+        responder.respondWithError(new n8n_workflow_1.UnexpectedError(errorMessage));
+        throw new internal_server_error_1.InternalServerError(errorMessage);
+    }
     let routesToEngineV2 = false;
+    let pendingEngineV2Response;
     let runExecutionDataMerge = {};
     const engineV2Webhooks = di_1.Container.get(engine_v2_webhooks_1.EngineV2Webhooks);
     let cleanupMultipartFiles;
     try {
-        let webhookResultData;
         routesToEngineV2 = engineV2Webhooks.handles(workflowData, executionMode);
         if (routesToEngineV2) {
             engineV2Webhooks.assertSupported({ workflowStartNode, responseMode, executionId });
@@ -538,44 +616,18 @@ async function executeWebhook(workflow, webhookData, workflowData, workflowStart
                             : {}),
                     });
         }
-        try {
-            webhookResultData = await di_1.Container.get(webhook_service_1.WebhookService).runWebhook(workflow, webhookData, workflowStartNode, additionalData, executionMode, runExecutionData ?? null);
-            di_1.Container.get(workflow_statistics_service_1.WorkflowStatisticsService).emit('nodeFetchedData', {
-                workflowId: workflow.id,
-                node: workflowStartNode,
-            });
-        }
-        catch (err) {
-            const webhookType = ['formTrigger', 'form'].includes(nodeType.description.name)
-                ? 'Form'
-                : 'Webhook';
-            const errorMessage = _privateGetWebhookErrorMessage(err, webhookType);
-            di_1.Container.get(n8n_core_1.ErrorReporter).error(err, {
-                extra: {
-                    nodeName: workflowStartNode.name,
-                    nodeType: workflowStartNode.type,
-                    nodeVersion: workflowStartNode.typeVersion,
-                    workflowId: workflow.id,
-                },
-            });
-            responseCallback(new n8n_workflow_1.UnexpectedError(errorMessage), {});
-            didSendResponse = true;
-            runExecutionDataMerge = {
-                resultData: {
-                    runData: {},
-                    lastNodeExecuted: workflowStartNode.name,
-                    error: {
-                        ...err,
-                        message: err.message,
-                        stack: err.stack,
-                    },
-                },
-            };
-            webhookResultData = {
-                noWebhookResponse: true,
-                workflowData: [[{ json: {} }]],
-            };
-        }
+        const invocationResult = await invokeWebhook({
+            workflow,
+            webhookData,
+            workflowStartNode,
+            additionalData,
+            executionMode,
+            runExecutionData,
+            webhookType: ['formTrigger', 'form'].includes(nodeType.description.name) ? 'Form' : 'Webhook',
+            responder,
+        });
+        const { webhookResultData } = invocationResult;
+        runExecutionDataMerge = invocationResult.runExecutionDataChanges;
         if (cleanupMultipartFiles && webhookResultData.webhookResponse instanceof node_stream_1.Readable) {
             deferCleanupUntilStreamEnds(webhookResultData.webhookResponse, res, cleanupMultipartFiles);
         }
@@ -587,49 +639,28 @@ async function executeWebhook(workflow, webhookData, workflowData, workflowStart
         if (!res.headersSent && responseHeaders) {
             responseHeaders.applyToResponse(res);
         }
-        if (webhookResultData.noWebhookResponse === true && !didSendResponse) {
-            responseCallback(null, {
-                noWebhookResponse: true,
-            });
-            didSendResponse = true;
-        }
-        if (webhookResultData.workflowData === undefined) {
-            if (webhookResultData.webhookResponse !== undefined) {
-                if (!didSendResponse) {
-                    responseCallback(null, {
-                        data: webhookResultData.webhookResponse,
-                        responseCode,
-                    });
-                    didSendResponse = true;
-                }
-            }
-            else {
-                if (!didSendResponse) {
-                    responseCallback(null, {
-                        data: {
-                            message: 'Webhook call received',
-                        },
-                        responseCode,
-                    });
-                    didSendResponse = true;
-                }
-            }
+        const shouldContinueWorkflowExecution = handleImmediateWebhookResponse({
+            webhookResultData,
+            responseCode,
+            responder,
+        });
+        if (!shouldContinueWorkflowExecution)
             return;
-        }
         if (routesToEngineV2)
             engineV2Webhooks.assertPayloadSupported(webhookResultData);
-        if (!didSendResponse && !res.headersSent && shouldEstablishTriggerIdentity(workflowStartNode)) {
+        if (!responder.hasResponded &&
+            !res.headersSent &&
+            shouldEstablishTriggerIdentity(workflowStartNode)) {
             const credentialGate = await additionalData.checkTriggerCredentialStatus?.();
             if (credentialGate && !credentialGate.readyToExecute) {
-                responseCallback(null, {
+                responder.respondWith({
                     data: credentialGate,
                     responseCode: 428,
                 });
-                didSendResponse = true;
                 return;
             }
         }
-        const shouldDeferOnReceivedResponse = responseMode === 'onReceived' && !didSendResponse;
+        const shouldDeferOnReceivedResponse = responseMode === 'onReceived' && !responder.hasResponded;
         const { runExecutionData: preparedRunExecutionData, pinData } = prepareExecutionData(executionMode, workflowStartNode, webhookResultData, runExecutionData, runExecutionDataMerge, destinationNode, executionId, workflowData, webhookData.userId);
         runExecutionData = preparedRunExecutionData;
         const runData = {
@@ -651,21 +682,26 @@ async function executeWebhook(workflow, webhookData, workflowData, workflowStart
         if (didPublishMcpRelay)
             return undefined;
         let responsePromise;
-        if (responseMode === 'responseNode') {
+        if (responseMode === 'responseNode' && !routesToEngineV2) {
             responsePromise = (0, deferred_promise_1.createDeferredPromise)();
             void responsePromise.promise.then((response) => {
                 if (response !== constants_2.EXECUTION_ENDED_WITHOUT_RESPONSE)
-                    didSendResponse = true;
+                    responder.markResponded();
             }, () => {
-                didSendResponse = true;
+                responder.markResponded();
             });
-            setupResponseNodePromise(responsePromise, res, responseCallback, workflowStartNode, executionId, workflow);
+            setupResponseNodePromise(responsePromise, res, responder, workflowStartNode, executionId, workflow);
         }
         if (responseMode === 'streaming') {
             di_1.Container.get(backend_common_1.Logger).debug(`Execution of workflow "${workflow.name}" from with ID ${executionId} is set to streaming`, { executionId });
             runData.httpResponse = res;
             runData.streamingEnabled = true;
-            didSendResponse = true;
+            responder.markResponded();
+        }
+        if (routesToEngineV2 && responseMode !== 'onReceived') {
+            const engineExecutionId = (0, execution_id_1.createExecutionIdV2)();
+            pendingEngineV2Response = await di_1.Container.get(engine_v2_webhook_responder_service_1.EngineV2WebhookResponder).waitForResponse(engineExecutionId, responseMode === 'responseNode');
+            runData.engineExecutionId = engineExecutionId;
         }
         const traceparent = req.headers.traceparent;
         if (typeof traceparent === 'string' &&
@@ -676,7 +712,7 @@ async function executeWebhook(workflow, webhookData, workflowData, workflowStart
                 tracestate: typeof tracestate === 'string' && tracestate.length <= 512 ? tracestate : undefined,
             };
         }
-        executionId = await di_1.Container.get(workflow_runner_1.WorkflowRunner).run(runData, true, !didSendResponse && !shouldDeferOnReceivedResponse, executionId ? { executionId, expectedStatus: 'waiting' } : undefined, responsePromise);
+        executionId = await di_1.Container.get(workflow_runner_1.WorkflowRunner).run(runData, true, !responder.hasResponded && !shouldDeferOnReceivedResponse, executionId ? { executionId, expectedStatus: 'waiting' } : undefined, responsePromise);
         if (!routesToEngineV2) {
             di_1.Container.get(active_executions_1.ActiveExecutions).setResponseMode(executionId, responseMode);
         }
@@ -691,8 +727,7 @@ async function executeWebhook(workflow, webhookData, workflowData, workflowStart
             const evaluatedResponseData = context.evaluateComplexWebhookDescriptionExpression('responseData', undefined, 'firstEntryJson');
             const responseBody = (0, webhook_on_received_response_extractor_1.extractWebhookOnReceivedResponse)(evaluatedResponseData, webhookResultData);
             const webhookResponse = (0, webhook_response_1.createStaticResponse)(responseBody, responseCode, responseHeaders);
-            responseCallback(null, webhookResponse);
-            didSendResponse = true;
+            responder.respondWith(webhookResponse);
         }
         di_1.Container.get(event_service_1.EventService).emit('workflow-executed', {
             workflowId: workflowData.id,
@@ -702,21 +737,69 @@ async function executeWebhook(workflow, webhookData, workflowData, workflowStart
             projectName: project.name,
             source: 'webhook',
         });
-        if (responseMode === 'formPage' && !didSendResponse) {
+        if (responseMode === 'formPage' && !responder.hasResponded) {
             const formUrl = new URL(`${additionalData.formWaitingBaseUrl}/${executionId}`);
             if (runExecutionData.resumeToken) {
                 formUrl.searchParams.set(n8n_core_1.WAITING_TOKEN_QUERY_PARAM, runExecutionData.resumeToken);
             }
             res.send({ formWaitingUrl: formUrl.toString() });
             process.nextTick(() => res.end());
-            didSendResponse = true;
+            responder.respondWithNoResponse();
         }
-        didSendResponse = handleHostedChatResponse(res, responseMode, didSendResponse, executionId, runExecutionData?.resumeToken);
+        handleHostedChatResponse(res, responseMode, executionId, responder, runExecutionData?.resumeToken);
         di_1.Container.get(backend_common_1.Logger).debug(`Started execution of workflow "${workflow.name}" from webhook with execution ID ${executionId}`, { executionId });
-        if (routesToEngineV2)
+        if (routesToEngineV2 && responseMode === 'onReceived')
             return executionId;
-        const activeExecutions = di_1.Container.get(active_executions_1.ActiveExecutions);
-        const executePromise = activeExecutions.getPostExecutePromise(executionId);
+        const waitForDataPlaneRun = async (waiting) => {
+            try {
+                const outcome = await waiting.settled;
+                if (outcome.status === 'response') {
+                    if (!isHttpFullResponse(outcome.response)) {
+                        throw new n8n_workflow_1.UnexpectedError('Engine v2 produced an invalid webhook response');
+                    }
+                    responder.markResponded();
+                    await sendResponseNodeResponse(outcome.response, res, responder, workflowStartNode, executionId, workflow);
+                    return undefined;
+                }
+                if (outcome.status === 'completed' || outcome.status === 'failed') {
+                    if (outcome.status === 'completed' && responseMode === 'responseNode') {
+                        responder.respondWith({ data: undefined, responseCode });
+                        return undefined;
+                    }
+                    return await engineV2Webhooks.toRun(outcome, executionMode);
+                }
+                const isUndeliverable = outcome.status === 'undeliverable';
+                const errorResponse = isUndeliverable
+                    ? {
+                        logMessage: 'Could not deliver an engine v2 webhook response',
+                        responseMessage: outcome.error.message,
+                        responseCode: 500,
+                    }
+                    : {
+                        logMessage: 'No answer arrived for an engine v2 webhook run',
+                        responseMessage: 'The workflow did not answer in time',
+                        responseCode: 504,
+                    };
+                di_1.Container.get(backend_common_1.Logger).warn(errorResponse.logMessage, {
+                    executionId,
+                    workflowId: workflowData.id,
+                    ...(isUndeliverable ? { error: outcome.error } : {}),
+                });
+                if (!responder.hasResponded) {
+                    responder.respondWith({
+                        data: { message: errorResponse.responseMessage },
+                        responseCode: errorResponse.responseCode,
+                    });
+                }
+                return undefined;
+            }
+            finally {
+                waiting.release();
+            }
+        };
+        const executePromise = pendingEngineV2Response
+            ? waitForDataPlaneRun(pendingEngineV2Response)
+            : di_1.Container.get(active_executions_1.ActiveExecutions).getPostExecutePromise(executionId);
         const { parentExecution } = runExecutionData;
         if (WorkflowHelpers.shouldRestartParentExecution(parentExecution)) {
             void di_1.Container.get(wait_tracker_1.WaitTracker).resumeParentExecution(parentExecution, executePromise, {
@@ -724,18 +807,17 @@ async function executeWebhook(workflow, webhookData, workflowData, workflowStart
                 workflowId: workflowData.id,
             });
         }
-        if (!didSendResponse) {
+        if (!responder.hasResponded) {
             executePromise
                 .then(async (runData) => {
                 if (runData === undefined) {
-                    if (!didSendResponse) {
-                        responseCallback(null, {
+                    if (!responder.hasResponded) {
+                        responder.respondWith({
                             data: {
                                 message: 'Workflow executed successfully but no data was returned',
                             },
                             responseCode,
                         });
-                        didSendResponse = true;
                     }
                     return undefined;
                 }
@@ -744,71 +826,67 @@ async function executeWebhook(workflow, webhookData, workflowData, workflowStart
                 }
                 const lastNodeTaskData = WorkflowHelpers.getLastExecutedNodeData(runData);
                 if (runData.data.resultData.error || lastNodeTaskData?.error !== undefined) {
-                    if (!didSendResponse) {
+                    if (!responder.hasResponded) {
                         di_1.Container.get(backend_common_1.Logger).warn('Webhook execution failed before a response was sent', {
                             executionId,
                             workflowId: workflowData.id,
                             responseMode,
                             lastNodeExecuted: runData.data.resultData.lastNodeExecuted,
                         });
-                        responseCallback(null, {
+                        responder.respondWith({
                             data: {
                                 message: 'Error in workflow',
                             },
                             responseCode: 500,
                         });
                     }
-                    didSendResponse = true;
                     return runData;
                 }
                 if (responseMode === 'responseNode' && responsePromise) {
                     await Promise.allSettled([responsePromise.promise]);
-                    if (!didSendResponse) {
-                        responseCallback(null, { data: undefined, responseCode });
-                        didSendResponse = true;
+                    if (!responder.hasResponded) {
+                        responder.respondWith({ data: undefined, responseCode });
                     }
                     return undefined;
                 }
                 if (lastNodeTaskData === undefined) {
-                    if (!didSendResponse) {
-                        responseCallback(null, {
+                    if (!responder.hasResponded) {
+                        responder.respondWith({
                             data: {
                                 message: 'Workflow executed successfully but the last node did not return any data',
                             },
                             responseCode,
                         });
                     }
-                    didSendResponse = true;
                     return runData;
                 }
-                if (didSendResponse) {
+                if (responder.hasResponded) {
                     return runData;
                 }
                 const result = await (0, webhook_last_node_response_extractor_1.extractWebhookLastNodeResponse)(responseData, lastNodeTaskData, checkAllMainOutputs, { responsePropertyName, responseContentType, responseBinaryPropertyName });
                 if (!result.ok) {
-                    responseCallback(result.error, {});
-                    didSendResponse = true;
+                    responder.respondWithError(result.error);
                     return runData;
                 }
                 const response = result.result;
                 if (response.contentType) {
                     responseHeaders.set('content-type', response.contentType);
                 }
-                responseCallback(null, response.type === 'static'
+                responder.respondWith(response.type === 'static'
                     ? (0, webhook_response_1.createStaticResponse)(response.body, responseCode, responseHeaders)
                     : (0, webhook_response_1.createStreamResponse)(response.stream, responseCode, responseHeaders));
-                didSendResponse = true;
                 return runData;
             })
                 .catch((e) => {
-                di_1.Container.get(n8n_core_1.ErrorReporter).error(e, { executionId });
-                if (!didSendResponse) {
-                    responseCallback(new n8n_workflow_1.OperationalError('There was a problem executing the workflow', {
-                        cause: e,
-                    }), {});
+                const error = (0, ensure_error_1.ensureError)(e);
+                di_1.Container.get(n8n_core_1.ErrorReporter).error(error, { executionId });
+                if (!responder.hasResponded) {
+                    responder.respondWithError(new n8n_workflow_1.OperationalError('There was a problem executing the workflow', {
+                        cause: error,
+                    }));
                 }
-                const internalServerError = new internal_server_error_1.InternalServerError(e.message, e);
-                if (e instanceof n8n_workflow_1.ExecutionCancelledError)
+                const internalServerError = new internal_server_error_1.InternalServerError(error.message, error);
+                if (error instanceof n8n_workflow_1.ExecutionCancelledError)
                     internalServerError.level = 'warning';
                 throw internalServerError;
             });
@@ -816,20 +894,24 @@ async function executeWebhook(workflow, webhookData, workflowData, workflowStart
         return executionId;
     }
     catch (e) {
-        let error;
-        if (e instanceof response_error_1.ResponseError && e.httpStatusCode < 500) {
-            error = e;
+        pendingEngineV2Response?.release();
+        const error = (0, ensure_error_1.ensureError)(e);
+        let responseError;
+        if (error instanceof response_error_1.ResponseError && error.httpStatusCode < 500) {
+            responseError = error;
         }
-        else if (routesToEngineV2 && e instanceof n8n_workflow_1.UserError) {
-            error = new bad_request_error_1.BadRequestError(e.message);
+        else if (routesToEngineV2 && error instanceof n8n_workflow_1.UserError) {
+            responseError = new bad_request_error_1.BadRequestError(error.message);
         }
         else {
-            di_1.Container.get(n8n_core_1.ErrorReporter).error(e, { executionId });
-            error = new n8n_workflow_1.OperationalError('There was a problem executing the workflow', { cause: e });
+            di_1.Container.get(n8n_core_1.ErrorReporter).error(error, { executionId });
+            responseError = new n8n_workflow_1.OperationalError('There was a problem executing the workflow', {
+                cause: error,
+            });
         }
-        if (didSendResponse)
-            throw error;
-        responseCallback(error, {});
+        if (responder.hasResponded)
+            throw responseError;
+        responder.respondWithError(responseError);
         return;
     }
     finally {
@@ -906,12 +988,12 @@ function evaluateResponseHeaders(context) {
     }
     return headers;
 }
-function _privateGetWebhookErrorMessage(err, webhookType) {
-    if (err instanceof n8n_workflow_1.NodeOperationError && err.type === 'manual-form-test') {
-        return err.message;
+function _privateGetWebhookErrorMessage(error, webhookType) {
+    if (error instanceof n8n_workflow_1.NodeOperationError && error.type === 'manual-form-test') {
+        return error.message;
     }
-    if (err instanceof n8n_workflow_1.WorkflowConfigurationError) {
-        return err.message;
+    if (error instanceof n8n_workflow_1.WorkflowConfigurationError) {
+        return error.message;
     }
     return `Workflow ${webhookType} Error: Workflow could not be started!`;
 }