fix: n8n_executions reads AI sub-node data and every run of a node (v2.80.1) (#1058)

* fix: n8n_executions never reads ai_* connection data for AI Agent sub-nodes

The execution processor (preview/summary/filtered/full/error modes)
only inspected run.data.main when extracting node input/output data.
Regular nodes connect via `main`, but LangChain AI Agent sub-nodes
(Chat Model, Output Parser, Tool, Memory, Embeddings, etc.) connect to
their parent Agent via special ai_* connection types instead
(ai_languageModel, ai_outputParser, ai_tool, ai_memory, ...). Their
task data lives at run.data.ai_languageModel etc., so every mode
silently returned itemsInput: 0, itemsOutput: 0, data.output: [] for
these nodes regardless of flags.

Also fixes includeInputData, which read a nonexistent `inputData`
field on the run - n8n actually stores this as `inputOverride`, keyed
by connection type the same way `data` is. This made includeInputData
a no-op for every node type, not only AI sub-nodes.

Both files now merge over every connection-type key present (main and
any ai_*) rather than hardcoding `main`, mirroring the same fix
pattern already used elsewhere in this repo for disconnected-node
detection (dynamic iteration over connection types instead of a fixed
list).

Verified against a live n8n Cloud execution with Chat Model, Output
Parser, Tool, and Memory sub-nodes: all four now report correct
itemsInput/itemsOutput/data across preview, summary, filtered, full,
and error modes.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
(cherry picked from commit 6191e99)

* fix: execution processor only returned the first run's data per node

Node-level summary counts (itemsInput/itemsOutput) already summed
across every run of a node - countItems() correctly loops over the
whole runData array. But the code building the actual returned
data.output/data.input arrays only ever read nodeData[0], the first
run. A node invoked more than once within a single execution (most
commonly an AI Agent's Chat Model: once to decide to call a tool,
again to produce the final answer) has one runData entry per
invocation, so every invocation after the first was silently dropped
from the response while still being counted in the totals.

Concretely: itemsOutput: 2 but data.output containing only 1 item -
and it was always the first, least useful one (the short
"I'll call a tool" turn), never the second (the actual answer,
sometimes truncated by a max_tokens ceiling).

Both execution-processor.ts and error-execution-processor.ts had this
pattern in multiple places (data extraction, item counts for preview/
execution-path, and error detection). Fixed by merging across every
run of a node - by branch/port index, in run order - instead of
reading index 0, so itemsLimit truncation now behaves as "first N
items across all invocations" rather than "first N items of the first
invocation only". Error detection was extended the same way: an error
on a later run (not just the first) is no longer invisible.

Verified against a live n8n Cloud execution with a multi-turn Chat
Model: the previously-hidden second generation (truncated at
finish_reason: length, 800 completion tokens) now returns correctly
across full/summary/filtered modes. Also surfaced a genuine,
previously-invisible error on a middle run of an Output Parser node
that error mode had never reported before this fix.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
(cherry picked from commit d227b54)

* fix: merge execution run data by connection type and bound inputs

Follow-ups on #965 after review:
- share the runData helpers between the two processors (src/services/execution-run-data.ts)
- merge branches keyed by connection type and port, so runs that populate different
  types (main, ai_tool) no longer collapse into one index; null ports stay null
- append with a loop instead of push(...items): a 150k-item branch overflowed the call stack
- merge only up to the item limit in summary/filtered mode; totals come from the counts
- apply the item limit to inputs too and report inputMetadata, since AI sub-nodes carry
  whole prompts in inputOverride
- preview reports the last failing run's error like the other modes; executionTime is the
  sum across runs

Conceived by Romuald Członkowski - www.aiadvisors.pl/en

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RQmLW2QcubiwyuemrLs62d

* chore: release 2.80.1

Conceived by Romuald Członkowski - www.aiadvisors.pl/en

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RQmLW2QcubiwyuemrLs62d

---------

Co-authored-by: JohanDuque <johand.duque@gmail.com>
Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>

Author: 3 people

CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.80.1] - 2026-09-03
+
+### Fixed
+
+- **`n8n_executions` now returns the data of AI Agent sub-nodes and of every run of a node** ([#965](https://github.com/czlonkowski/n8n-mcp/pull/965)). The execution processors read only `runData[node][0].data.main`, so a Chat Model, Tool, Memory or Output Parser node, whose task data lives under `ai_*` connection types, showed no items, and a node invoked more than once in an execution (an agent's model, called once per tool round) lost every run after the first. Items are now merged across runs, keyed by connection type and output port, so a node whose runs populate different types keeps them apart, and a port n8n recorded as `null` stays `null`. The last failing run's error is reported in every mode, `executionTime` is the sum across runs, and `preview` mode reads the first item without merging. In `summary` and `filtered` modes only as many items as the limit are merged, and inputs (`includeInputData`), which for AI sub-nodes carry whole prompts, are truncated with the same limit and described by a new `inputMetadata` field. The error processor reads the same helpers, so `error` mode's upstream context and execution path include AI sub-nodes too.
+
 ## [2.80.0] - 2026-09-03
 
 ### Fixed

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-mcp",
-  "version": "2.80.0",
+  "version": "2.80.1",
   "description": "Integration between n8n workflow automation and Model Context Protocol (MCP)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-mcp-runtime",
-  "version": "2.80.0",
+  "version": "2.80.1",
   "description": "n8n MCP Server Runtime Dependencies Only",
   "private": true,
   "dependencies": {

package.runtime.json

@@ -40,7 +40,7 @@ export const n8nExecutionsDoc: ToolDocumentation = {
       id: { type: 'string', required: false, description: 'Execution ID. Required for action=delete; for action=get, omitting it lists executions instead' },
       mode: { type: 'string', required: false, description: 'For action=get: "preview", "summary" (default), "filtered", "full", "error"' },
       nodeNames: { type: 'array', required: false, description: 'For action=get with mode=filtered: Filter to specific nodes by name' },
-      itemsLimit: { type: 'number', required: false, description: 'For action=get with mode=filtered: Items per node (0=structure, 2=default, -1=unlimited)' },
+      itemsLimit: { type: 'number', required: false, description: 'For action=get with mode=summary or filtered: Items per node (0=structure, 2=default, -1=unlimited); applies to input data too when includeInputData is set' },
       includeInputData: { type: 'boolean', required: false, description: 'For action=get: Include input data in addition to output (default: false)' },
       errorItemsLimit: { type: 'number', required: false, description: 'For action=get with mode=error: Sample items from upstream (default: 2, max: 100)' },
       includeStackTrace: { type: 'boolean', required: false, description: 'For action=get with mode=error: Include full stack trace (default: false, shows truncated)' },

src/mcp/tool-docs/workflow_management/n8n-executions.ts

@@ -18,6 +18,14 @@ import {
   ErrorSuggestion,
 } from '../types/n8n-api';
 import { logger } from '../utils/logger';
+import {
+  countRunItems,
+  getRunError,
+  latestStartTime,
+  hasRunOutputData,
+  sampleRunItems,
+  totalExecutionTime,
+} from './execution-run-data';
 
 /**
  * Options for error processing
@@ -132,7 +140,7 @@ function extractPrimaryError(
 
   // Also check runData for node-level errors
   const nodeRunData = runData[nodeName];
-  const nodeError = nodeRunData?.[0]?.error;
+  const nodeError = getRunError(nodeRunData);
 
   const stackTrace = (error?.stack || nodeError?.stack) as string | undefined;
 
@@ -177,12 +185,13 @@ function extractUpstreamContext(
     .filter(([name, data]) => {
       if (name === errorNodeName) return false;
       const runs = data as any[];
-      return runs?.[0]?.data?.main?.[0]?.length > 0 && !runs?.[0]?.error;
+      return countRunItems(runs) > 0 && !getRunError(runs);
     })
     .map(([name, data]) => ({
       name,
-      executionTime: (data as any[])?.[0]?.executionTime || 0,
-      startTime: (data as any[])?.[0]?.startTime || 0
+      executionTime: totalExecutionTime(data) ?? 0,
+      // The most recent run decides recency for a node that ran more than once
+      startTime: latestStartTime(data)
     }))
     .sort((a, b) => b.startTime - a.startTime);
 
@@ -252,9 +261,10 @@ function extractNodeOutput(
   itemsLimit: number
 ): ErrorAnalysis['upstreamContext'] | undefined {
   const nodeData = runData[nodeName];
-  if (!nodeData?.[0]?.data?.main?.[0]) return undefined;
+  if (!hasRunOutputData(nodeData)) return undefined;
 
-  const items = nodeData[0].data.main[0];
+  // Merge only the samples; the count covers every port and comes from a pass that copies nothing.
+  const items = sampleRunItems(nodeData, Math.max(itemsLimit, 1));
 
   // Sanitize sample items to remove sensitive data
   const rawSamples = items.slice(0, itemsLimit);
@@ -263,7 +273,7 @@ function extractNodeOutput(
   return {
     nodeName,
     nodeType: '', // Will be enriched if workflow available
-    itemCount: items.length,
+    itemCount: countRunItems(nodeData),
     sampleItems: sanitizedSamples,
     dataStructure: extractStructure(items[0])
   };
@@ -287,14 +297,14 @@ function buildExecutionPath(
     for (const nodeName of upstreamNodes) {
       const nodeData = runData[nodeName];
       const runs = nodeData as any[] | undefined;
-      const hasError = runs?.[0]?.error;
-      const itemCount = runs?.[0]?.data?.main?.[0]?.length || 0;
+      const hasError = getRunError(runs);
+      const itemCount = countRunItems(runs);
 
       path.push({
         nodeName,
         status: hasError ? 'error' : (runs ? 'success' : 'skipped'),
         itemCount,
-        executionTime: runs?.[0]?.executionTime
+        executionTime: totalExecutionTime(runs)
       });
     }
 
@@ -304,24 +314,24 @@ function buildExecutionPath(
       nodeName: errorNodeName,
       status: 'error',
       itemCount: 0,
-      executionTime: errorNodeData?.[0]?.executionTime
+      executionTime: totalExecutionTime(errorNodeData)
     });
   } else {
     // Without workflow, list all executed nodes by execution order (best effort)
     const nodesByTime = Object.entries(runData)
       .map(([name, data]) => ({
         name,
         data: data as any[],
-        startTime: (data as any[])?.[0]?.startTime || 0
+        startTime: latestStartTime(data)
       }))
       .sort((a, b) => a.startTime - b.startTime);
 
     for (const { name, data } of nodesByTime) {
       path.push({
         nodeName: name,
-        status: data?.[0]?.error ? 'error' : 'success',
-        itemCount: data?.[0]?.data?.main?.[0]?.length || 0,
-        executionTime: data?.[0]?.executionTime
+        status: getRunError(data) ? 'error' : 'success',
+        itemCount: countRunItems(data),
+        executionTime: totalExecutionTime(data)
       });
     }
   }
@@ -342,7 +352,7 @@ function findAdditionalErrors(
     if (nodeName === primaryErrorNode) continue;
 
     const runs = data as any[];
-    const error = runs?.[0]?.error;
+    const error = getRunError(runs);
     if (error) {
       additional.push({
         nodeName,

src/services/error-execution-processor.ts

@@ -25,6 +25,14 @@ import {
 } from '../types/n8n-api';
 import { logger } from '../utils/logger';
 import { processErrorExecution } from './error-execution-processor';
+import {
+  extractConnectionBranches,
+  firstRunItem,
+  getRunError,
+  mergeRunBranches,
+  totalExecutionTime,
+  type RunBranch,
+} from './execution-run-data';
 
 /**
  * Size estimation and threshold constants
@@ -116,15 +124,11 @@ function countItems(nodeData: unknown): { input: number; output: number } {
   }
 
   for (const run of nodeData) {
-    if (run?.data?.main) {
-      const mainData = run.data.main;
-      if (Array.isArray(mainData)) {
-        for (const output of mainData) {
-          if (Array.isArray(output)) {
-            counts.output += output.length;
-          }
-        }
-      }
+    for (const output of extractConnectionBranches(run?.data)) {
+      counts.output += output?.length ?? 0;
+    }
+    for (const input of extractConnectionBranches(run?.inputOverride)) {
+      counts.input += input?.length ?? 0;
     }
   }
 
@@ -167,14 +171,11 @@ export function generatePreview(execution: Execution): {
     const nodeData = runData[nodeName];
     const itemCounts = countItems(nodeData);
 
-    // Extract structure from first run's first output item
+    // Structure of the first output item any run produced
     let dataStructure: Record<string, unknown> = {};
-    if (Array.isArray(nodeData) && nodeData.length > 0) {
-      const firstRun = nodeData[0];
-      const firstItem = firstRun?.data?.main?.[0]?.[0];
-      if (firstItem) {
-        dataStructure = extractStructure(firstItem) as Record<string, unknown>;
-      }
+    const firstItem = firstRunItem(nodeData);
+    if (firstItem) {
+      dataStructure = extractStructure(firstItem) as Record<string, unknown>;
     }
 
     const nodeSize = estimateDataSize(nodeData);
@@ -186,15 +187,10 @@ export function generatePreview(execution: Execution): {
       estimatedSizeKB: nodeSize,
     };
 
-    // Check for errors
-    if (Array.isArray(nodeData)) {
-      for (const run of nodeData) {
-        if (run.error) {
-          nodePreview.status = 'error';
-          nodePreview.error = extractErrorMessage(run.error);
-          break;
-        }
-      }
+    const runError = getRunError(nodeData);
+    if (runError) {
+      nodePreview.status = 'error';
+      nodePreview.error = extractErrorMessage(runError);
     }
 
     preview.nodes[nodeName] = nodePreview;
@@ -256,33 +252,38 @@ function generateRecommendation(
  * Truncate items array with metadata
  */
 function truncateItems(
-  items: unknown[][],
-  limit: number
+  items: RunBranch[],
+  limit: number,
+  knownTotal?: number
 ): {
-  truncated: unknown[][];
+  truncated: RunBranch[];
   metadata: { totalItems: number; itemsShown: number; truncated: boolean };
 } {
   if (!Array.isArray(items) || items.length === 0) {
     return {
       truncated: items || [],
       metadata: {
-        totalItems: 0,
+        totalItems: knownTotal ?? 0,
         itemsShown: 0,
-        truncated: false,
+        truncated: (knownTotal ?? 0) > 0,
       },
     };
   }
 
-  let totalItems = 0;
-  for (const output of items) {
-    if (Array.isArray(output)) {
-      totalItems += output.length;
+  // `knownTotal` lets the caller pass branches merged only up to the limit.
+  let totalItems = knownTotal ?? 0;
+  if (knownTotal === undefined) {
+    for (const output of items) {
+      if (Array.isArray(output)) {
+        totalItems += output.length;
+      }
     }
   }
 
   // Special case: limit = 0 means structure only
   if (limit === 0) {
     const structureOnly = items.map(output => {
+      if (output === null) return null;
       if (!Array.isArray(output) || output.length === 0) {
         return [];
       }
@@ -294,7 +295,7 @@ function truncateItems(
       metadata: {
         totalItems,
         itemsShown: 0,
-        truncated: true,
+        truncated: totalItems > 0,
       },
     };
   }
@@ -312,7 +313,7 @@ function truncateItems(
   }
 
   // Apply limit
-  const result: unknown[][] = [];
+  const result: RunBranch[] = [];
   let itemsShown = 0;
 
   for (const output of items) {
@@ -460,42 +461,40 @@ export function filterExecutionData(
       continue;
     }
 
-    // Get first run data
-    const firstRun = nodeData[0];
+    // Every field aggregates across all runs of the node.
     const itemCounts = countItems(nodeData);
     totalItems += itemCounts.output;
 
     const nodeResult: FilteredNodeData = {
-      executionTime: firstRun.executionTime,
+      executionTime: totalExecutionTime(nodeData),
       itemsInput: itemCounts.input,
       itemsOutput: itemCounts.output,
       status: 'success',
     };
 
-    // Check for errors
-    if (firstRun.error) {
+    const runError = getRunError(nodeData);
+    if (runError) {
       nodeResult.status = 'error';
-      nodeResult.error = extractErrorMessage(firstRun.error);
+      nodeResult.error = extractErrorMessage(runError);
     }
 
-    // Handle full mode - include all data
+    // Merge only as many items per branch as will be shown; the counts above supply the totals.
+    // Structure-only (limit 0) still needs the first item of each branch.
+    const maxPerBranch = mode === 'full' || itemsLimit < 0 ? -1 : Math.max(itemsLimit, 1);
+    const outputData = mergeRunBranches(nodeData, 'data', maxPerBranch);
+
     if (mode === 'full') {
       nodeResult.data = {
-        output: firstRun.data?.main || [],
+        output: outputData,
         metadata: {
           totalItems: itemCounts.output,
           itemsShown: itemCounts.output,
           truncated: false,
         },
       };
-
-      if (includeInputData && firstRun.inputData) {
-        nodeResult.data.input = firstRun.inputData;
-      }
     } else {
-      // Summary or filtered mode - apply limits
-      const outputData = firstRun.data?.main || [];
-      const { truncated, metadata } = truncateItems(outputData, itemsLimit);
+      // Summary or filtered mode - apply item limits
+      const { truncated, metadata } = truncateItems(outputData, itemsLimit, itemCounts.output);
 
       if (metadata.truncated) {
         hasMoreData = true;
@@ -505,9 +504,19 @@ export function filterExecutionData(
         output: truncated,
         metadata,
       };
+    }
 
-      if (includeInputData && firstRun.inputData) {
-        nodeResult.data.input = firstRun.inputData;
+    if (includeInputData && itemCounts.input > 0) {
+      const inputData = mergeRunBranches(nodeData, 'inputOverride', maxPerBranch);
+      if (mode === 'full') {
+        nodeResult.data.input = inputData;
+      } else {
+        const { truncated, metadata } = truncateItems(inputData, itemsLimit, itemCounts.input);
+        if (metadata.truncated) {
+          hasMoreData = true;
+        }
+        nodeResult.data.input = truncated;
+        nodeResult.data.inputMetadata = metadata;
       }
     }