n8n 2.28.4 → 2.29.1

package/dist/modules/instance-ai/instance-ai.adapter.service.js

@@ -62,7 +62,7 @@ const config_1 = require("@n8n/config");
 const constants_1 = require("@n8n/constants");
 const extract_resolved_node_parameters_1 = require("./extract-resolved-node-parameters");
 const instance_ai_settings_service_1 = require("./instance-ai-settings.service");
-const trigger_run_data_1 = require("./trigger-run-data");
+const instance_ai_run_pin_data_1 = require("./instance-ai-run-pin-data");
 const node_definition_resolver_1 = require("./node-definition-resolver");
 const web_research_1 = require("./web-research");
 const db_1 = require("@n8n/db");
@@ -430,7 +430,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                     nodes: nodes,
                     connections: json.connections,
                     settings,
-                    pinData: sdkPinDataToRuntime(json.pinData),
+                    pinData: (0, instance_ai_run_pin_data_1.sdkPinDataToRuntime)(json.pinData),
                     nodeGroups: sdkNodeGroupsToRuntime(json.nodeGroups),
                 });
                 let updated;
@@ -495,7 +495,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                     nodes: nodes,
                     connections: json.connections,
                     settings,
-                    pinData: sdkPinDataToRuntime(json.pinData),
+                    pinData: (0, instance_ai_run_pin_data_1.sdkPinDataToRuntime)(json.pinData),
                     nodeGroups: sdkNodeGroupsToRuntime(json.nodeGroups),
                 });
                 let updated;
@@ -673,49 +673,29 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                     userId: user.id,
                     pushRef,
                 };
-                const workflowPinData = workflow.pinData ?? {};
-                const overridePinData = options?.pinData
-                    ? (sdkPinDataToRuntime(options.pinData) ?? {})
-                    : {};
-                const basePinData = { ...workflowPinData, ...overridePinData };
-                const mockDataSources = [];
-                if (inputData && triggerNode) {
-                    mockDataSources.push('trigger_input');
-                }
-                if (Object.keys(overridePinData).length > 0) {
-                    mockDataSources.push('verification_pin_data');
-                }
-                if (Object.keys(workflowPinData).length > 0) {
-                    mockDataSources.push('workflow_pin_data');
-                }
-                if (inputData && triggerNode) {
-                    const triggerPinData = getPinDataForTrigger(triggerNode, inputData);
-                    const mergedPinData = { ...basePinData, ...triggerPinData };
-                    const triggerItems = triggerPinData[triggerNode.name];
-                    runData.startNodes = [{ name: triggerNode.name, sourceData: null }];
-                    runData.pinData = mergedPinData;
-                    runData.executionData = (0, trigger_run_data_1.createTriggerExecutionData)({
-                        triggerNode,
-                        pinData: mergedPinData,
-                        triggerItems,
-                    });
+                const pinDataPlan = (0, instance_ai_run_pin_data_1.buildInstanceAiRunPinDataPlan)({
+                    workflowPinData: workflow.pinData ?? {},
+                    verificationPinData: options?.verificationPinData,
+                    inputData,
+                    triggerNode,
+                });
+                if (pinDataPlan.startNodeName) {
+                    runData.startNodes = [{ name: pinDataPlan.startNodeName, sourceData: null }];
                 }
                 else if (triggerNode) {
                     runData.triggerToStartFrom = { name: triggerNode.name };
-                    const pinData = Object.keys(basePinData).length > 0 ? basePinData : undefined;
-                    if (pinData) {
-                        runData.pinData = pinData;
-                    }
-                    runData.executionData = (0, trigger_run_data_1.createTriggerExecutionData)({ triggerNode, pinData });
                 }
-                else if (Object.keys(basePinData).length > 0) {
-                    runData.pinData = basePinData;
+                if (pinDataPlan.runPinData) {
+                    runData.pinData = pinDataPlan.runPinData;
+                }
+                if (pinDataPlan.triggerExecutionData) {
+                    runData.executionData = pinDataPlan.triggerExecutionData;
                 }
                 runData.source = 'instance_ai';
                 runData.telemetryMetadata = {
-                    mockDataSources,
+                    mockDataSources: pinDataPlan.mockDataSources,
                 };
-                const trackBuilderExecutedWorkflow = (status) => {
+                const trackBuilderExecutedWorkflow = (status, error) => {
                     if (!threadId)
                         return;
                     telemetry.track('Builder executed workflow', {
@@ -725,70 +705,71 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                         pinned_node_count: Object.keys(runData.pinData ?? {}).length,
                         exec_type: runData.executionMode,
                         status,
+                        ...(error ? { error } : {}),
                     });
                 };
-                const executionId = await workflowRunner.run(runData);
-                const timeoutMs = Math.min(options?.timeout ?? DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS);
-                if (activeExecutions.has(executionId)) {
-                    let timeoutId;
-                    const timeoutPromise = new Promise((_, reject) => {
-                        timeoutId = setTimeout(() => {
-                            reject(new Error(`Execution timed out after ${timeoutMs}ms`));
-                        }, timeoutMs);
-                    });
-                    try {
-                        await Promise.race([
-                            activeExecutions.getPostExecutePromise(executionId),
-                            timeoutPromise,
-                        ]);
-                        clearTimeout(timeoutId);
-                    }
-                    catch (error) {
-                        clearTimeout(timeoutId);
-                        if (error instanceof Error && error.message.includes('timed out')) {
-                            try {
-                                activeExecutions.stopExecution(executionId, new n8n_workflow_1.TimeoutExecutionCancelledError(executionId));
-                            }
-                            catch {
-                            }
-                            const result = {
+                try {
+                    const executionId = await workflowRunner.run(runData);
+                    const pruneVerificationPins = async (executedNodeNames) => {
+                        try {
+                            await (0, instance_ai_run_pin_data_1.pruneUnreachedVerificationPinData)({
                                 executionId,
-                                status: 'error',
-                                error: `Execution timed out after ${timeoutMs}ms and was cancelled`,
-                            };
-                            trackBuilderExecutedWorkflow(result.status);
-                            return result;
+                                verificationPinData: pinDataPlan.verificationPinData,
+                                nonVerificationPinData: pinDataPlan.nonVerificationPinData,
+                                executedNodeNames,
+                            });
                         }
-                        throw error;
-                    }
-                }
-                if (options?.simulation && Object.keys(options.simulation).length > 0) {
-                    try {
-                        const execution = await executionRepository.findSingleExecution(executionId, {
-                            includeData: true,
-                            unflattenData: true,
+                        catch (error) {
+                            logger.warn('Failed to prune verification pin data from execution', {
+                                executionId,
+                                error: error instanceof Error ? error.message : String(error),
+                            });
+                        }
+                    };
+                    const timeoutMs = Math.min(options?.timeout ?? DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS);
+                    if (activeExecutions.has(executionId)) {
+                        let timeoutId;
+                        const timeoutPromise = new Promise((_, reject) => {
+                            timeoutId = setTimeout(() => {
+                                reject(new Error(`Execution timed out after ${timeoutMs}ms`));
+                            }, timeoutMs);
                         });
-                        if (execution?.data) {
-                            const runData = execution.data.resultData.runData ?? {};
-                            const simulation = Object.fromEntries(Object.entries(options.simulation).filter(([nodeName]) => Object.hasOwn(runData, nodeName)));
-                            if (Object.keys(simulation).length > 0) {
-                                execution.data.resultData.simulation = simulation;
-                                await executionRepository.updateExistingExecution(executionId, {
-                                    data: execution.data,
-                                });
+                        try {
+                            await Promise.race([
+                                activeExecutions.getPostExecutePromise(executionId),
+                                timeoutPromise,
+                            ]);
+                            clearTimeout(timeoutId);
+                        }
+                        catch (error) {
+                            clearTimeout(timeoutId);
+                            if (error instanceof Error && error.message.includes('timed out')) {
+                                try {
+                                    activeExecutions.stopExecution(executionId, new n8n_workflow_1.TimeoutExecutionCancelledError(executionId));
+                                }
+                                catch {
+                                }
+                                const result = {
+                                    executionId,
+                                    status: 'error',
+                                    error: `Execution timed out after ${timeoutMs}ms and was cancelled`,
+                                };
+                                await pruneVerificationPins();
+                                trackBuilderExecutedWorkflow(result.status, result.error);
+                                return result;
                             }
+                            throw error;
                         }
                     }
-                    catch (error) {
-                        logger.warn('Failed to persist simulation metadata on execution', {
-                            executionId,
-                            error: error instanceof Error ? error.message : String(error),
-                        });
-                    }
+                    const result = await extractExecutionResult(executionId, allowSendingParameterValues);
+                    await pruneVerificationPins(result.executedNodeNames);
+                    trackBuilderExecutedWorkflow(result.status, result.error);
+                    return result;
+                }
+                catch (error) {
+                    trackBuilderExecutedWorkflow('error', error instanceof Error ? error.message : String(error));
+                    throw error;
                 }
-                const result = await extractExecutionResult(executionId, allowSendingParameterValues);
-                trackBuilderExecutedWorkflow(result.status);
-                return result;
             },
             async getStatus(executionId) {
                 await assertExecutionAccess(executionId);
@@ -1245,7 +1226,9 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         const searchCacheRef = this.searchCache;
         const settingsService = this.settingsService;
         const { outboundHttp, ssrfProtectionService } = this;
-        const sharedTransport = outboundHttp.transport({ ssrf: ssrfProtectionService });
+        const sharedTransport = outboundHttp.transport({
+            ssrf: this.ssrfProtectionService,
+        });
         const userId = user.id;
         let resolvedSearchMethod;
         let searchResolved = false;
@@ -1498,7 +1481,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                 if (registryNode) {
                     const builderHint = registryNode.builderHint?.searchHint;
                     return {
-                        content: (0, synthesize_type_def_1.synthesizeMcpRegistryTypeDef)(registryNode),
+                        content: (0, synthesize_type_def_1.synthesizeNodeTypeDef)(registryNode),
                         ...(builderHint ? { builderHint } : {}),
                     };
                 }
@@ -2041,95 +2024,6 @@ function getExecutionModeForTrigger(node) {
             return 'manual';
     }
 }
-function validateInputDataShape(node, inputData) {
-    if (node.type === n8n_workflow_1.FORM_TRIGGER_NODE_TYPE) {
-        const formFieldsValue = inputData.formFields;
-        const looksWrapped = typeof formFieldsValue === 'object' && formFieldsValue !== null;
-        if (looksWrapped) {
-            throw new Error('verify-built-workflow: inputData for a Form Trigger must be a flat field map ' +
-                '(e.g. {name: "Alice", email: "a@b.c"}), NOT wrapped in `formFields`. ' +
-                'The production Form Trigger emits fields directly on $json, so downstream ' +
-                'expressions like $json.name are correct. Re-run with the flat shape.');
-        }
-    }
-}
-function getPinDataForTrigger(node, inputData) {
-    validateInputDataShape(node, inputData);
-    switch (node.type) {
-        case n8n_workflow_1.CHAT_TRIGGER_NODE_TYPE:
-            return {
-                [node.name]: [
-                    {
-                        json: {
-                            sessionId: `instance-ai-${Date.now()}`,
-                            action: 'sendMessage',
-                            chatInput: typeof inputData.chatInput === 'string'
-                                ? inputData.chatInput
-                                : JSON.stringify(inputData),
-                        },
-                    },
-                ],
-            };
-        case n8n_workflow_1.FORM_TRIGGER_NODE_TYPE:
-            return {
-                [node.name]: [
-                    {
-                        json: {
-                            submittedAt: new Date().toISOString(),
-                            formMode: 'instanceAi',
-                            ...inputData,
-                        },
-                    },
-                ],
-            };
-        case n8n_workflow_1.WEBHOOK_NODE_TYPE: {
-            const envelopeKeys = new Set(['body', 'headers', 'query']);
-            const inputKeys = Object.keys(inputData);
-            const looksLikeEnvelope = inputKeys.length > 0 &&
-                inputKeys.every((k) => envelopeKeys.has(k)) &&
-                typeof inputData.body === 'object' &&
-                inputData.body !== null;
-            const body = looksLikeEnvelope ? inputData.body : inputData;
-            const headers = looksLikeEnvelope && typeof inputData.headers === 'object' && inputData.headers !== null
-                ? inputData.headers
-                : {};
-            const query = looksLikeEnvelope && typeof inputData.query === 'object' && inputData.query !== null
-                ? inputData.query
-                : {};
-            return {
-                [node.name]: [
-                    {
-                        json: { headers, query, body },
-                    },
-                ],
-            };
-        }
-        case n8n_workflow_1.SCHEDULE_TRIGGER_NODE_TYPE: {
-            const now = new Date();
-            return {
-                [node.name]: [
-                    {
-                        json: {
-                            timestamp: now.toISOString(),
-                            'Readable date': now.toLocaleString(),
-                            'Day of week': now.toLocaleDateString('en-US', { weekday: 'long' }),
-                            Year: String(now.getFullYear()),
-                            Month: now.toLocaleDateString('en-US', { month: 'long' }),
-                            'Day of month': String(now.getDate()).padStart(2, '0'),
-                            Hour: String(now.getHours()).padStart(2, '0'),
-                            Minute: String(now.getMinutes()).padStart(2, '0'),
-                            Second: String(now.getSeconds()).padStart(2, '0'),
-                        },
-                    },
-                ],
-            };
-        }
-        default:
-            return {
-                [node.name]: [{ json: inputData }],
-            };
-    }
-}
 async function extractExecutionDebugInfo(executionId, includeOutputData = true, nodeTypes) {
     const execution = await di_1.Container.get(execution_persistence_1.ExecutionPersistence).findSingleExecution(executionId, {
         includeData: true,
@@ -2209,15 +2103,6 @@ async function extractExecutionDebugInfo(executionId, includeOutputData = true,
         nodeTrace,
     };
 }
-function sdkPinDataToRuntime(pinData) {
-    const result = {};
-    if (!pinData)
-        return result;
-    for (const [nodeName, items] of Object.entries(pinData)) {
-        result[nodeName] = items.map((item) => ({ json: (item ?? {}) }));
-    }
-    return result;
-}
 function sdkNodeGroupsToRuntime(nodeGroups) {
     return nodeGroups ?? [];
 }