n8n 2.40.5 → 2.41.0

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

@@ -23,6 +23,7 @@ exports.extractExecutionResult = extractExecutionResult;
 exports.extractExecutionOutcome = extractExecutionOutcome;
 exports.formatExecutionError = formatExecutionError;
 exports.truncateNodeOutput = truncateNodeOutput;
+exports.redactExecuteNodeResult = redactExecuteNodeResult;
 exports.extractNodeOutput = extractNodeOutput;
 exports.extractExecutionDebugInfo = extractExecutionDebugInfo;
 const ai_utilities_1 = require("@n8n/ai-utilities");
@@ -66,6 +67,7 @@ const mcp_registry_connection_1 = require("../../modules/mcp-registry/mcp-regist
 const mcp_registry_service_1 = require("../../modules/mcp-registry/registry/mcp-registry.service");
 const workflow_dependency_query_service_1 = require("../../modules/workflow-index/workflow-dependency-query.service");
 const node_catalog_1 = require("../../node-catalog");
+const node_execution_1 = require("../../node-execution");
 const node_types_1 = require("../../node-types");
 const check_access_1 = require("../../permissions.ee/check-access");
 const policy_enforcement_service_1 = require("../../policy/policy-enforcement.service");
@@ -87,9 +89,11 @@ const workflow_history_service_1 = require("../../workflows/workflow-history/wor
 const workflow_service_1 = require("../../workflows/workflow.service");
 const workflow_service_ee_1 = require("../../workflows/workflow.service.ee");
 const extract_resolved_node_parameters_1 = require("./extract-resolved-node-parameters");
+const instance_ai_execution_wait_1 = require("./instance-ai-execution-wait");
 const instance_ai_folder_scope_1 = require("./instance-ai-folder-scope");
 const instance_ai_run_pin_data_1 = require("./instance-ai-run-pin-data");
 const instance_ai_settings_service_1 = require("./instance-ai-settings.service");
+const instance_ai_step_run_1 = require("./instance-ai-step-run");
 const instance_context_service_1 = require("./instance-context.service");
 const mcp_1 = require("./mcp");
 const node_definition_resolver_1 = require("./node-definition-resolver");
@@ -173,7 +177,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         });
         return await promise;
     }
-    constructor(logger, globalConfig, workflowService, workflowFinderService, workflowRepository, sharedWorkflowRepository, projectRepository, executionRepository, credentialsService, credentialsFinderService, activeExecutions, workflowRunner, loadNodesAndCredentials, nodeTypes, instanceSettings, dataTableService, dataTableRepository, nodeResourceExplorerService, folderService, projectService, tagService, instanceWriteAccess, settingsService, workflowHistoryService, enterpriseWorkflowService, license, executionPersistence, eventService, roleService, telemetry, aiBuilderTemporaryWorkflowRepository, outboundHttp, aiGatewayService, workflowTemplatesService, collaborationService, policyEnforcementService, nodeCatalogService, evaluationConfigService, llmJudgeProviderRegistry, workflowDependencyQueryService, folderRepository, folderFinderService, instanceContext) {
+    constructor(logger, globalConfig, workflowService, workflowFinderService, workflowRepository, sharedWorkflowRepository, projectRepository, executionRepository, credentialsService, credentialsFinderService, activeExecutions, workflowRunner, loadNodesAndCredentials, nodeTypes, instanceSettings, dataTableService, dataTableRepository, nodeResourceExplorerService, folderService, projectService, tagService, instanceWriteAccess, settingsService, workflowHistoryService, enterpriseWorkflowService, license, executionPersistence, eventService, roleService, telemetry, aiBuilderTemporaryWorkflowRepository, outboundHttp, aiGatewayService, workflowTemplatesService, collaborationService, policyEnforcementService, nodeCatalogService, evaluationConfigService, llmJudgeProviderRegistry, workflowDependencyQueryService, folderRepository, folderFinderService, instanceContext, executeNodeService) {
         this.globalConfig = globalConfig;
         this.workflowService = workflowService;
         this.workflowFinderService = workflowFinderService;
@@ -216,6 +220,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         this.folderRepository = folderRepository;
         this.folderFinderService = folderFinderService;
         this.instanceContext = instanceContext;
+        this.executeNodeService = executeNodeService;
         this.nodesCache = null;
         this.NODES_CACHE_TTL_MS = 5 * 60 * 1000;
         this.webResearchCache = new web_research_1.LRUCache({
@@ -233,7 +238,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         });
     }
     createContext(user, options) {
-        const { searchProxyConfig, pushRef, threadId, projectId, credentialIdAllowlist, shouldBypassCredentialTest, agentId, configEvalsEnabled, mcpConnectionsEnabled, nodeUsageEnabled, conversationHistory, folderExplorationEnabled, modelId, } = options ?? {};
+        const { searchProxyConfig, pushRef, threadId, projectId, credentialIdAllowlist, shouldBypassCredentialTest, agentId, configEvalsEnabled, mcpConnectionsEnabled, nodeUsageEnabled, instanceContextEnabled, conversationHistory, folderExplorationEnabled, modelId, } = options ?? {};
         void this.trackGatewayAvailability();
         const builderDelegateAdapter = this.getBuilderDelegateAdapter();
         const credentialService = this.createCredentialAdapter(user, projectId, credentialIdAllowlist, shouldBypassCredentialTest);
@@ -256,8 +261,11 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                 }
                 : {}),
             mcpService: mcpConnectionsEnabled ? this.createMcpAdapter(user) : undefined,
+            executeNodeService: this.executeNodeService
+                ? this.createExecuteNodeAdapter(this.executeNodeService, user, projectId)
+                : undefined,
             conversationHistoryService: conversationHistory,
-            ...(this.instanceContext?.enabled
+            ...(instanceContextEnabled === true && this.instanceContext
                 ? { activityService: this.createActivityAdapter(user, projectId) }
                 : {}),
             webResearchService: this.createWebResearchAdapter(user, searchProxyConfig),
@@ -274,7 +282,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                 : {}),
             ...(builderDelegateAdapter && projectId
                 ? {
-                    builderDelegate: builderDelegateAdapter.createDelegate(user, projectId, new agents_credential_provider_1.AgentsCredentialProvider(this.credentialsService, projectId, user), credentialService, { useEvalModelCatalog: credentialIdAllowlist !== undefined }),
+                    builderDelegate: builderDelegateAdapter.createDelegate(user, projectId, (targetAgentId) => new agents_credential_provider_1.AgentsCredentialProvider(this.credentialsService, projectId, user, targetAgentId), credentialService, { useEvalModelCatalog: credentialIdAllowlist !== undefined }),
                 }
                 : {}),
         };
@@ -303,8 +311,16 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
     }
     async resolveExperimentGates(user) {
         let flags = {};
+        let instanceContextEnabled = false;
         try {
-            flags = await di_1.Container.get(posthog_1.PostHogClient).getFeatureFlags(user);
+            const postHog = di_1.Container.get(posthog_1.PostHogClient);
+            const [userFlags, instanceFlag] = await Promise.allSettled([
+                postHog.getFeatureFlags(user),
+                postHog.getFeatureFlagForInstance(api_types_1.INSTANCE_ACTIVITY_CONTEXT_FLAG),
+            ]);
+            if (userFlags.status === 'fulfilled')
+                flags = userFlags.value;
+            instanceContextEnabled = instanceFlag.status === 'fulfilled' && instanceFlag.value === true;
         }
         catch {
         }
@@ -320,6 +336,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
             folderExplorationEnabled: flags[api_types_1.INSTANCE_AI_FOLDER_EXPLORATION_FLAG] ===
                 api_types_1.INSTANCE_AI_FOLDER_EXPLORATION_ENABLED_VARIANT,
             aiPreferencesEnabled: flags[api_types_1.CONTEXT_PREFERENCES_FLAG] === api_types_1.CONTEXT_PREFERENCES_ENABLED_VARIANT,
+            instanceContextEnabled,
         };
     }
     mcpPreconditionsHold() {
@@ -330,20 +347,20 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         const instanceContext = this.instanceContext;
         if (!instanceContext)
             throw new n8n_workflow_1.UnexpectedError('Instance context service is not available');
+        const scope = {
+            surface: 'conversation',
+            ...(projectId !== undefined ? { projectId } : {}),
+        };
         return {
             list: async (input) => await instanceContext.list({
                 user,
-                ...(projectId !== undefined ? { projectId } : {}),
+                scope,
                 limit: input.limit,
                 ...(input.category !== undefined ? { category: input.category } : {}),
                 ...(input.resourceId !== undefined ? { resourceId: input.resourceId } : {}),
                 ...(input.beforeId !== undefined ? { beforeId: input.beforeId } : {}),
             }),
-            expand: async (id) => await instanceContext.expand({
-                id,
-                user,
-                ...(projectId !== undefined ? { projectId } : {}),
-            }),
+            expand: async (id) => await instanceContext.expand({ id, user, scope }),
         };
     }
     createMcpAdapter(user) {
@@ -384,6 +401,27 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
             listConnections: async () => await this.listMcpRegistryConnections(user),
         };
     }
+    createExecuteNodeAdapter(executeNodeService, user, boundProjectId) {
+        const { resolveProjectId } = this.createProjectScopeHelpers(user, boundProjectId);
+        return {
+            execute: async (request) => {
+                this.assertInstanceNotReadOnly('executions');
+                const projectId = await resolveProjectId(['workflow:execute']);
+                const result = await executeNodeService.run(user, {
+                    type: request.type,
+                    version: request.version,
+                    config: {
+                        parameters: request.config.parameters,
+                        credentials: request.config.credentials,
+                    },
+                    input: request.input,
+                    timeoutMs: request.timeoutMs,
+                    projectId,
+                });
+                return redactExecuteNodeResult(result, this.allowSendingParameterValues);
+            },
+        };
+    }
     async listMcpRegistryConnections(user) {
         const connections = await di_1.Container.get(mcp_1.InstanceAiMcpRegistryService).listConnectionsForUser(user);
         return [...new Set(connections.map((connection) => connection.serverSlug))].map((slug) => ({
@@ -1103,10 +1141,11 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                     connections: version.connections,
                     nodeGroups: version.nodeGroups,
                 });
-                await workflowService.update(user, updateData, workflowId, {
+                const updated = await workflowService.update(user, updateData, workflowId, {
                     source: 'n8n-ai',
                 });
                 await notifyWorkflowUpdated(workflowId);
+                return await toWorkflowDetailWithChecksum(updated, { redactParameters });
             },
             ...(this.license.isLicensed('feat:namedVersions')
                 ? {
@@ -1118,7 +1157,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         };
     }
     createExecutionAdapter(user, pushRef, threadId) {
-        const { workflowFinderService, workflowRunner, activeExecutions, executionRepository, nodeTypes, allowSendingParameterValues, roleService, telemetry, logger, globalConfig, } = this;
+        const { workflowFinderService, workflowRunner, activeExecutions, executionRepository, executionPersistence, workflowHistoryService, nodeTypes, allowSendingParameterValues, roleService, telemetry, logger, globalConfig, } = this;
         const assertNotReadOnly = () => this.assertInstanceNotReadOnly('executions');
         const DEFAULT_TIMEOUT_MS = 5 * constants_1.Time.minutes.toMilliseconds;
         const MAX_TIMEOUT_MS = 10 * constants_1.Time.minutes.toMilliseconds;
@@ -1147,7 +1186,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                 };
                 const query = {
                     kind: 'range',
-                    range: { limit: options?.limit ?? 20, lastId: undefined, firstId: undefined },
+                    range: { limit: options?.limit ?? 20 },
                     order: { startedAt: 'DESC' },
                     user,
                     sharingOptions,
@@ -1281,83 +1320,195 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                             });
                         }
                     };
-                    const abortSignal = options?.abortSignal;
-                    if (activeExecutions.has(executionId)) {
-                        let timeoutId;
-                        const timeoutPromise = new Promise((_, reject) => {
-                            timeoutId = setTimeout(() => {
-                                reject(new Error(`Execution timed out after ${timeoutMs}ms`));
-                            }, timeoutMs);
-                        });
-                        let onAbort;
-                        const abortPromise = abortSignal === undefined
-                            ? undefined
-                            : new Promise((_, reject) => {
-                                onAbort = () => {
-                                    const error = new Error(typeof abortSignal.reason === 'string'
-                                        ? abortSignal.reason
-                                        : 'This operation was aborted');
-                                    error.name = 'AbortError';
-                                    reject(error);
-                                };
-                                if (abortSignal.aborted) {
-                                    onAbort();
-                                    return;
-                                }
-                                abortSignal.addEventListener('abort', onAbort, { once: true });
-                            });
-                        try {
-                            await Promise.race([
-                                activeExecutions.getPostExecutePromise(executionId),
-                                timeoutPromise,
-                                ...(abortPromise ? [abortPromise] : []),
-                            ]);
-                            clearTimeout(timeoutId);
-                            if (onAbort)
-                                abortSignal?.removeEventListener('abort', onAbort);
-                        }
-                        catch (error) {
-                            clearTimeout(timeoutId);
-                            if (onAbort)
-                                abortSignal?.removeEventListener('abort', onAbort);
-                            const isTimeout = error instanceof Error && error.message.includes('timed out');
-                            const isAbort = error instanceof Error &&
-                                (error.name === 'AbortError' || abortSignal?.aborted === true);
-                            if (isTimeout || isAbort) {
-                                try {
-                                    activeExecutions.stopExecution(executionId, isAbort
-                                        ? new n8n_workflow_1.ManualExecutionCancelledError(executionId)
-                                        : new n8n_workflow_1.TimeoutExecutionCancelledError(executionId));
-                                }
-                                catch {
-                                }
-                                const result = {
-                                    executionId,
-                                    status: 'error',
-                                    error: isAbort
-                                        ? 'Execution was cancelled'
-                                        : `Execution timed out after ${timeoutMs}ms and was cancelled`,
-                                };
-                                await pruneVerificationPins();
-                                trackBuilderExecutedWorkflow(result.status, result.error);
-                                return result;
-                            }
-                            throw error;
-                        }
+                    const waitOutcome = await (0, instance_ai_execution_wait_1.waitForInstanceAiExecution)({
+                        activeExecutions,
+                        executionId,
+                        timeoutMs,
+                        abortSignal: options?.abortSignal,
+                    });
+                    if (waitOutcome.kind === 'cancelled') {
+                        const result = {
+                            executionId,
+                            status: 'error',
+                            error: waitOutcome.message,
+                        };
+                        await pruneVerificationPins();
+                        trackBuilderExecutedWorkflow(result.status, result.error);
+                        return result;
                     }
                     const { result, telemetryError } = await extractExecutionOutcome(executionId, allowSendingParameterValues, nodeTypes);
                     await pruneVerificationPins(result.executedNodeNames);
                     trackBuilderExecutedWorkflow(result.status, telemetryError);
                     const workflowPinnedNodeNames = Object.keys(workflow.pinData ?? {});
-                    return workflowPinnedNodeNames.length > 0
-                        ? { ...result, workflowPinnedNodeNames }
-                        : result;
+                    const injectedTriggerNodeName = triggerNode &&
+                        (pinDataPlan.mockDataSources.includes('trigger_input') ||
+                            Object.hasOwn(pinDataPlan.verificationPinData, triggerNode.name))
+                        ? triggerNode.name
+                        : undefined;
+                    return {
+                        ...result,
+                        ...(workflowPinnedNodeNames.length > 0 ? { workflowPinnedNodeNames } : {}),
+                        ...(injectedTriggerNodeName ? { injectedTriggerNodeName } : {}),
+                    };
                 }
                 catch (error) {
                     trackBuilderExecutedWorkflow('error', error instanceof Error ? error.message : String(error));
                     throw error;
                 }
             },
+            async runStep(workflowId, nodeName, options) {
+                assertNotReadOnly();
+                const workflow = await workflowFinderService.findWorkflowForUser(workflowId, user, [
+                    'workflow:execute',
+                ]);
+                if (!workflow) {
+                    throw new instance_ai_1.WorkflowNotFoundError(workflowId);
+                }
+                let nodes = workflow.nodes ?? [];
+                let connections = workflow.connections ?? {};
+                const versionId = options?.versionId;
+                if (versionId !== undefined && versionId !== workflow.versionId) {
+                    const version = await workflowHistoryService.getVersion(user, workflowId, versionId);
+                    nodes = version.nodes ?? [];
+                    connections = version.connections ?? {};
+                }
+                const target = nodes.find((node) => node.name === nodeName);
+                if (!target) {
+                    throw new n8n_workflow_1.UserError(`The workflow has no node named "${nodeName}". Use workflows(action="get-as-code") to see the node names.`);
+                }
+                if (target.disabled) {
+                    throw new n8n_workflow_1.UserError(`Node "${nodeName}" is disabled. Enable it before you run it.`);
+                }
+                let priorRunData;
+                let reusedFromExecutionId;
+                if (options?.reuseExecutionId !== undefined) {
+                    const execution = await assertExecutionAccess(options.reuseExecutionId);
+                    if (execution.workflowId !== workflowId) {
+                        throw new n8n_workflow_1.UserError(`Execution ${options.reuseExecutionId} belongs to a different workflow.`);
+                    }
+                    const stored = await executionPersistence.findSingleExecution(options.reuseExecutionId, {
+                        includeData: true,
+                        unflattenData: true,
+                    });
+                    priorRunData = stored?.data?.resultData?.runData;
+                    reusedFromExecutionId = options.reuseExecutionId;
+                }
+                const plan = (0, instance_ai_step_run_1.planStepRun)({
+                    nodes,
+                    connections,
+                    targetName: nodeName,
+                    mockItems: options?.mockInput ? (0, instance_ai_step_run_1.toExecutionItems)(options.mockInput) : undefined,
+                    priorRunData,
+                });
+                const stepPinData = (0, instance_ai_step_run_1.pinDataForStepRun)(workflow.pinData, {
+                    targetName: nodeName,
+                    mockedNodeNames: plan.mockedNodeNames,
+                });
+                const timeoutMs = Math.min(options?.timeout ?? DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS);
+                const runData = {
+                    executionMode: 'manual',
+                    workflowData: {
+                        ...workflow,
+                        nodes,
+                        connections,
+                        settings: {
+                            ...workflow.settings,
+                            saveManualExecutions: true,
+                            saveDataSuccessExecution: 'all',
+                            saveDataErrorExecution: 'all',
+                            executionTimeout: Math.ceil(timeoutMs / 1000),
+                        },
+                    },
+                    userId: user.id,
+                    pushRef,
+                    destinationNode: { nodeName, mode: 'inclusive' },
+                    pinData: stepPinData,
+                    runData: plan.runData,
+                    dirtyNodeNames: plan.dirtyNodeNames,
+                    source: 'instance_ai',
+                };
+                if ((0, n8n_workflow_1.isTriggerNodeType)(target.type)) {
+                    runData.triggerToStartFrom = { name: nodeName };
+                }
+                const offloadingManualExecutionsInQueueMode = globalConfig.executions?.mode === 'queue' &&
+                    process.env.OFFLOAD_MANUAL_EXECUTIONS_TO_WORKERS === 'true';
+                if (offloadingManualExecutionsInQueueMode) {
+                    runData.executionData = (0, n8n_workflow_1.createRunExecutionData)({
+                        startData: { destinationNode: runData.destinationNode },
+                        resultData: { pinData: stepPinData, runData: plan.runData ?? null },
+                        manualData: {
+                            userId: user.id,
+                            dirtyNodeNames: plan.dirtyNodeNames,
+                            triggerToStartFrom: runData.triggerToStartFrom,
+                            source: 'instance_ai',
+                        },
+                        executionData: null,
+                    });
+                }
+                const trackStepRun = (status, error) => {
+                    if (!threadId)
+                        return;
+                    telemetry.track('Builder executed workflow', {
+                        user_id: user.id,
+                        thread_id: threadId,
+                        workflow_id: workflowId,
+                        executed_by: 'ai',
+                        pinned_node_count: Object.keys(stepPinData ?? {}).length,
+                        exec_type: 'step',
+                        input_mode: plan.inputMode,
+                        status,
+                        ...(error ? { error: (0, telemetry_1.redactTelemetryText)(error) } : {}),
+                    });
+                };
+                const offeredForReplay = priorRunData
+                    ? Object.keys(priorRunData).filter((name) => name !== nodeName)
+                    : [];
+                const describe = (result) => {
+                    const inRunData = new Set(result.executedNodeNames ?? []);
+                    const replayedNodeNames = offeredForReplay.filter((name) => inRunData.has(name));
+                    const notExecutedHere = new Set([...plan.mockedNodeNames, ...replayedNodeNames]);
+                    return {
+                        ...result,
+                        ...(result.executedNodeNames
+                            ? {
+                                executedNodeNames: result.executedNodeNames.filter((name) => !notExecutedHere.has(name)),
+                            }
+                            : {}),
+                        nodeName,
+                        inputMode: plan.inputMode,
+                        mockedNodeNames: plan.mockedNodeNames,
+                        ...(replayedNodeNames.length > 0 ? { replayedNodeNames } : {}),
+                        ...(reusedFromExecutionId ? { reusedFromExecutionId } : {}),
+                        ...(Object.keys(stepPinData ?? {}).length > 0
+                            ? { workflowPinnedNodeNames: Object.keys(stepPinData ?? {}) }
+                            : {}),
+                    };
+                };
+                try {
+                    const executionId = await workflowRunner.run(runData);
+                    const waitOutcome = await (0, instance_ai_execution_wait_1.waitForInstanceAiExecution)({
+                        activeExecutions,
+                        executionId,
+                        timeoutMs,
+                        abortSignal: options?.abortSignal,
+                    });
+                    if (waitOutcome.kind === 'cancelled') {
+                        trackStepRun('error', waitOutcome.message);
+                        return describe({
+                            executionId,
+                            status: 'error',
+                            error: waitOutcome.message,
+                        });
+                    }
+                    const { result, telemetryError } = await extractExecutionOutcome(executionId, allowSendingParameterValues, nodeTypes);
+                    trackStepRun(result.status, telemetryError);
+                    return describe(result);
+                }
+                catch (error) {
+                    trackStepRun('error', error instanceof Error ? error.message : String(error));
+                    throw error;
+                }
+            },
             async getStatus(executionId) {
                 await assertExecutionAccess(executionId);
                 const isRunning = activeExecutions.has(executionId);
@@ -1437,7 +1588,12 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                         projectId: boundProjectId,
                     });
                     const filtered = options?.type ? scoped.filter((c) => c.type === options.type) : scoped;
-                    return filtered.map((c) => ({ id: c.id, name: c.name, type: c.type }));
+                    return filtered.map((c) => ({
+                        id: c.id,
+                        name: c.name,
+                        type: c.type,
+                        description: c.description,
+                    }));
                 }
                 if (options?.workflowId || options?.projectId) {
                     const scoped = options.workflowId
@@ -1452,6 +1608,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                         id: c.id,
                         name: c.name,
                         type: c.type,
+                        description: c.description,
                     }));
                 }
                 const credentials = await credentialsService.getMany(user, {
@@ -1464,6 +1621,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                     id: c.id,
                     name: c.name,
                     type: c.type,
+                    description: c.description,
                 }));
             },
             async get(credentialId) {
@@ -1472,6 +1630,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                     id: credential.id,
                     name: credential.name,
                     type: credential.type,
+                    description: credential.description,
                 };
             },
             async delete(credentialId) {
@@ -2201,6 +2360,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                             name: String(o.name),
                             value: o.value,
                         })),
+                        ...(p.displayOptions ? { displayOptions: p.displayOptions } : {}),
                     })),
                     credentials: desc.credentials?.map((c) => ({
                         name: c.name,
@@ -2506,7 +2666,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
 exports.InstanceAiAdapterService = InstanceAiAdapterService;
 exports.InstanceAiAdapterService = InstanceAiAdapterService = __decorate([
     (0, di_1.Service)(),
-    __metadata("design:paramtypes", [backend_common_1.Logger, config_1.GlobalConfig, workflow_service_1.WorkflowService, workflow_finder_service_1.WorkflowFinderService, db_1.WorkflowRepository, db_1.SharedWorkflowRepository, db_1.ProjectRepository, db_1.ExecutionRepository, credentials_service_1.CredentialsService, credentials_finder_service_1.CredentialsFinderService, active_executions_1.ActiveExecutions, workflow_runner_1.WorkflowRunner, load_nodes_and_credentials_1.LoadNodesAndCredentials, node_types_1.NodeTypes, n8n_core_1.InstanceSettings, data_table_service_1.DataTableService, data_table_repository_1.DataTableRepository, node_resource_explorer_service_1.NodeResourceExplorerService, folder_service_1.FolderService, project_service_ee_1.ProjectService, tag_service_1.TagService, instance_write_access_service_1.InstanceWriteAccessService, instance_ai_settings_service_1.InstanceAiSettingsService, workflow_history_service_1.WorkflowHistoryService, workflow_service_ee_1.EnterpriseWorkflowService, license_1.License, execution_persistence_1.ExecutionPersistence, event_service_1.EventService, role_service_1.RoleService, telemetry_2.Telemetry, db_1.AiBuilderTemporaryWorkflowRepository, backend_network_1.OutboundHttp, ai_gateway_service_1.AiGatewayService, workflow_templates_service_1.WorkflowTemplatesService, collaboration_service_1.CollaborationService, policy_enforcement_service_1.PolicyEnforcementService, node_catalog_1.NodeCatalogService, evaluation_config_service_1.EvaluationConfigService, llm_judge_provider_registry_1.LlmJudgeProviderRegistry, workflow_dependency_query_service_1.WorkflowDependencyQueryService, db_1.FolderRepository, folder_finder_service_1.FolderFinderService, instance_context_service_1.InstanceContextService])
+    __metadata("design:paramtypes", [backend_common_1.Logger, config_1.GlobalConfig, workflow_service_1.WorkflowService, workflow_finder_service_1.WorkflowFinderService, db_1.WorkflowRepository, db_1.SharedWorkflowRepository, db_1.ProjectRepository, db_1.ExecutionRepository, credentials_service_1.CredentialsService, credentials_finder_service_1.CredentialsFinderService, active_executions_1.ActiveExecutions, workflow_runner_1.WorkflowRunner, load_nodes_and_credentials_1.LoadNodesAndCredentials, node_types_1.NodeTypes, n8n_core_1.InstanceSettings, data_table_service_1.DataTableService, data_table_repository_1.DataTableRepository, node_resource_explorer_service_1.NodeResourceExplorerService, folder_service_1.FolderService, project_service_ee_1.ProjectService, tag_service_1.TagService, instance_write_access_service_1.InstanceWriteAccessService, instance_ai_settings_service_1.InstanceAiSettingsService, workflow_history_service_1.WorkflowHistoryService, workflow_service_ee_1.EnterpriseWorkflowService, license_1.License, execution_persistence_1.ExecutionPersistence, event_service_1.EventService, role_service_1.RoleService, telemetry_2.Telemetry, db_1.AiBuilderTemporaryWorkflowRepository, backend_network_1.OutboundHttp, ai_gateway_service_1.AiGatewayService, workflow_templates_service_1.WorkflowTemplatesService, collaboration_service_1.CollaborationService, policy_enforcement_service_1.PolicyEnforcementService, node_catalog_1.NodeCatalogService, evaluation_config_service_1.EvaluationConfigService, llm_judge_provider_registry_1.LlmJudgeProviderRegistry, workflow_dependency_query_service_1.WorkflowDependencyQueryService, db_1.FolderRepository, folder_finder_service_1.FolderFinderService, instance_context_service_1.InstanceContextService, node_execution_1.ExecuteNodeService])
 ], InstanceAiAdapterService);
 const MAX_RESULT_CHARS = 20_000;
 const MAX_NODE_OUTPUT_CHARS = 1_000;
@@ -2805,24 +2965,77 @@ function formatExecutionError(error, includeUpstreamDetails) {
 }
 const MAX_NODE_OUTPUT_BYTES = 5_000;
 function truncateNodeOutput(items) {
-    const serialized = JSON.stringify(items);
-    if (serialized.length <= MAX_NODE_OUTPUT_BYTES)
+    const truncated = capItemsBySerializedSize(items, MAX_NODE_OUTPUT_BYTES);
+    if (truncated === items)
+        return items;
+    return {
+        items: truncated,
+        truncated: true,
+        totalItems: items.length,
+        shownItems: truncated.length,
+        message: `Output truncated: showing ${truncated.length} of ${items.length} items. Use get-node-output to retrieve full data for this node.`,
+    };
+}
+function capItemsBySerializedSize(items, maxBytes) {
+    if (JSON.stringify(items).length <= maxBytes)
         return items;
-    const truncated = [];
+    const kept = [];
     let size = 2;
     for (const item of items) {
         const itemStr = JSON.stringify(item);
-        if (size + itemStr.length + 2 > MAX_NODE_OUTPUT_BYTES)
+        if (size + itemStr.length + 2 > maxBytes)
             break;
-        truncated.push(item);
+        kept.push(item);
         size += itemStr.length + 1;
     }
+    return kept;
+}
+const EXECUTE_NODE_DETAILS_SUPPRESSED = '(upstream error details suppressed by the instance AI privacy setting; ask the user to share the node error from the UI)';
+function redactExecuteNodeResult(result, allowSendingParameterValues) {
+    if (result.status === 'error') {
+        const { message, description, nodeErrorType } = result.error;
+        const cappedDescription = description && description.length > MAX_ERROR_CHARS
+            ? `${description.slice(0, MAX_ERROR_CHARS)}…`
+            : description;
+        return {
+            status: 'error',
+            error: {
+                message,
+                description: allowSendingParameterValues
+                    ? cappedDescription
+                    : description
+                        ? EXECUTE_NODE_DETAILS_SUPPRESSED
+                        : undefined,
+                nodeErrorType,
+            },
+        };
+    }
+    if (!allowSendingParameterValues) {
+        return {
+            status: 'success',
+            output: '',
+            outputSuppressed: 'The node executed successfully, but its output items are suppressed by the instance AI privacy setting.',
+        };
+    }
+    let totalItems = 0;
+    let shownItems = 0;
+    const kept = result.output.map((branch) => {
+        totalItems += branch.length;
+        const keptBranch = capItemsBySerializedSize(branch, MAX_NODE_OUTPUT_BYTES);
+        shownItems += keptBranch.length;
+        return keptBranch;
+    });
+    const output = (0, instance_ai_1.wrapUntrustedData)(JSON.stringify(kept, null, 2), 'execution-output');
+    if (shownItems === totalItems)
+        return { status: 'success', output };
     return {
-        items: truncated,
-        truncated: true,
-        totalItems: items.length,
-        shownItems: truncated.length,
-        message: `Output truncated: showing ${truncated.length} of ${items.length} items. Use get-node-output to retrieve full data for this node.`,
+        status: 'success',
+        output,
+        truncated: {
+            totalItems,
+            shownItems,
+            message: `Output truncated: showing ${shownItems} of ${totalItems} items. Re-run with fewer input items or a narrower operation to see more.`,
+        },
     };
 }
 const MAX_ITEM_CHARS = 50_000;