n8n-decanter 0.11.1 → 0.11.2

package/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.11.2] - 2026-10-21
+
+### Fixed
+
+- **`test --scenario` and `test --execution` work again on n8n 2.34 and
+  newer** ([#327](https://github.com/buttjer/n8n-decanter/issues/327)). The run
+  succeeded on the instance, but decanter then stopped with `Tool get_execution
+  not found` and compared nothing. n8n 2.34 renamed that MCP tool to
+  `get_workflow_execution`, and renamed two more that decanter uses:
+  `search_executions` (behind `preflight`'s `history` check, which quietly
+  fell back to the REST API or skipped) and `prepare_test_pin_data` (behind
+  `scenario create --scaffold`, which quietly produced fills without schemas).
+  decanter now asks for the new name and falls back to the old one, so older n8n
+  keeps working too.
+
 ## [0.11.1] - 2026-09-10
 
 ### Added

package/dist/lib/mcp.mjs

@@ -33,6 +33,63 @@ export class McpToolError extends Error {
 export function isUnavailableInMcp(err) {
     return err instanceof Error && /not available in MCP/i.test(err.message);
 }
+/**
+ * The tools decanter calls that n8n RENAMED, current name first. n8n 2.34.0
+ * renamed them (n8n-io/n8n#34347) and kept no alias, so each name works on
+ * one side of that release only: the old one fails "Tool get_execution not
+ * found" on 2.34+ (#327), the new one fails the same way on everything older.
+ * Source-verified 2026-10-21: old names on n8n@2.33.7, new names from
+ * n8n@2.34.0 through n8n@2.44.5. Every other tool decanter calls kept its name.
+ */
+export const MCP_TOOL = {
+    getExecution: ["get_workflow_execution", "get_execution"],
+    searchExecutions: ["search_workflow_executions", "search_executions"],
+    preparePinData: ["prepare_workflow_pin_data", "prepare_test_pin_data"],
+};
+/**
+ * The SDK's unknown-tool answer names the tool, so the match is per name: a
+ * real tool's own "… not found" (an execution, a node) never reads as this.
+ * Covers both carriers — a JSON-RPC error and an `isError` result.
+ */
+function isToolNotFound(err, name) {
+    return err instanceof Error && new RegExp(`\\bTool ${name} not found\\b`).test(err.message);
+}
+/** Per client, the name each renamed tool answered to — one probe per process, not per call. */
+const resolvedToolName = new WeakMap();
+/**
+ * Call a renamed tool by whichever of its names this n8n knows. Probing beats
+ * `tools/list` here: a server only ever lacks one of the names, and a probe
+ * that misses costs exactly the one round-trip a listing would. A name is
+ * remembered once the tool itself answered — a result, or its own `isError`
+ * (`McpToolError`). A transport failure, a 429 that outlasted the backoff or
+ * any other JSON-RPC error proves nothing about the name, so it is not
+ * remembered: caching it would send every later call in a multi-ref run to a
+ * name an older n8n does not have.
+ */
+export async function callToolByAnyName(mcp, names, args) {
+    const cache = resolvedToolName.get(mcp) ?? new Map();
+    resolvedToolName.set(mcp, cache);
+    const known = cache.get(names[0]);
+    if (known !== undefined)
+        return mcp.callTool(known, args);
+    let lastErr;
+    for (const name of names) {
+        try {
+            const out = await mcp.callTool(name, args);
+            cache.set(names[0], name);
+            return out;
+        }
+        catch (err) {
+            if (!isToolNotFound(err, name)) {
+                if (err instanceof McpToolError)
+                    cache.set(names[0], name);
+                throw err;
+            }
+            lastErr = err;
+        }
+    }
+    throw lastErr;
+}
 /**
  * Strictly local — the path `init` mints into and every rotation rewrites.
  * `readAuthFilePath` is the read-side counterpart, which may resolve elsewhere.
@@ -739,25 +796,26 @@ export async function updateWorkflow(mcp, id, operations) {
 }
 /** Ask n8n for the per-node output schemas of the nodes a test run must pin (read-only). */
 export async function prepareTestPinData(mcp, id) {
-    return mcp.callTool("prepare_test_pin_data", { workflowId: id });
+    return callToolByAnyName(mcp, MCP_TOOL.preparePinData, { workflowId: id });
 }
 /**
  * Recent executions of a workflow — **metadata only** (status/timing, no run
- * data; `readOnlyHint`/`idempotentHint`), over MCP `search_executions` (n8n
- * ≥ ~2.30, shape source-verified 2026-07-22). The health signal behind
+ * data; `readOnlyHint`/`idempotentHint`), over MCP `search_workflow_executions`
+ * (`search_executions` on n8n ~2.30–2.33; shape source-verified 2026-07-22,
+ * unchanged through 2.44.5 bar an added `nextCursor`). The health signal behind
  * `preflight`'s `history` check. The tool doesn't guarantee an order — the
  * caller sorts/interprets. Throws (in-band `error` or an MCP `isError`) when the
  * server lacks the tool or refuses access, so the caller can fall back to the
  * REST executions API.
  */
 export async function searchExecutions(mcp, { workflowId, status, limit }) {
-    const res = await mcp.callTool("search_executions", {
+    const res = await callToolByAnyName(mcp, MCP_TOOL.searchExecutions, {
         ...(workflowId !== undefined && { workflowId }),
         ...(status !== undefined && { status }),
         ...(limit !== undefined && { limit }),
     });
     if (res.error !== undefined)
-        throw new McpToolError("search_executions", res.error);
+        throw new McpToolError(MCP_TOOL.searchExecutions[0], res.error);
     return res.data ?? [];
 }
 /**

package/dist/lib/preflight.mjs

@@ -311,9 +311,9 @@ export async function runPreflight(ctx) {
                     skip(id, "sync", "workflow not available in MCP", ENABLE_MCP_HINT);
                 }
             }
-            // history: production-run health. MCP search_executions preferred; REST
-            // listExecutions (no run data) fallback; neither → skip. Never fails —
-            // the draft isn't guilty of the live workflow's past.
+            // history: production-run health. MCP search_workflow_executions
+            // preferred; REST listExecutions (no run data) fallback; neither → skip.
+            // Never fails — the draft isn't guilty of the live workflow's past.
             await run("history", "sync", async () => historyCheck(ctx));
         }
     }
@@ -485,8 +485,8 @@ async function historyCheck(ctx) {
         }
     }
     if (rows === undefined) {
-        const reason = ctx.restAvailable ? "search_executions unavailable and the REST executions probe failed" : "no MCP search_executions and no N8N_API_KEY for the REST fallback";
-        return { status: "skip", message: reason, reason, unlock: "upgrade n8n for search_executions, or set N8N_API_KEY" };
+        const reason = ctx.restAvailable ? "MCP execution search unavailable and the REST executions probe failed" : "no MCP execution search and no N8N_API_KEY for the REST fallback";
+        return { status: "skip", message: reason, reason, unlock: "upgrade n8n for MCP execution search, or set N8N_API_KEY" };
     }
     if (rows.length === 0)
         return { status: "info", message: "no recent production runs" };

package/dist/lib/testrun.mjs

@@ -9,7 +9,7 @@
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { EXECUTIONS_DIR } from "./executions.mjs";
-import { getWorkflowDetails, updateWorkflow } from "./mcp.mjs";
+import { callToolByAnyName, getWorkflowDetails, MCP_TOOL, updateWorkflow } from "./mcp.mjs";
 import { createPrompt } from "./prompt.mjs";
 import { buildNodeCode, pushWorkflow } from "./push.mjs";
 import { readState, writeState } from "./state.mjs";
@@ -284,7 +284,7 @@ export async function runTest(mcp, config, dir, id, { ref, source, trigger }, lo
     const diffs = [];
     let coverage;
     if (result.executionId !== null && result.status === "success") {
-        const execution = await mcp.callTool("get_execution", {
+        const execution = await callToolByAnyName(mcp, MCP_TOOL.getExecution, {
             workflowId: id,
             executionId: result.executionId,
             includeData: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-decanter",
-  "version": "0.11.1",
+  "version": "0.11.2",
   "description": "The toolkit for building code-heavy n8n workflows — agent-first, MCP-native",
   "keywords": [
     "n8n",
@@ -59,7 +59,7 @@
     "luxon": "^3.7.2"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.5.11",
+    "@biomejs/biome": "2.5.15",
     "@types/jmespath": "^0.15.2",
     "@types/luxon": "^3.7.2",
     "@types/node": "^26.1.1",

package/template/AGENTS.md.example

@@ -632,7 +632,7 @@ n8n-decanter preflight "<workflow>" --simulate --scenario <slug>    # replay the
 ```
 
 Add `--scaffold` to `scenario create` to annotate each gap with its **output
-schema** (from n8n's read-only `prepare_test_pin_data`) — a `--scaffold` with no
+schema** (from n8n's read-only `prepare_workflow_pin_data`) — a `--scaffold` with no
 `--execution` builds a from-scratch set where *every* pinnable node is a fill
 entry. Provenance is tracked per node: `capture` (real, diff-asserted),
 `authored` (hand-filled), `scaffolded` (schema-guided). A run on a scenario with