@path58/p58-n8n 0.2.4 → 0.2.6

package/AGENT_INSTALL.md

@@ -232,4 +232,4 @@ Once installed, the user can ask their AI assistant to:
 
 ---
 
-**Package:** `@path58/p58-n8n` | **npm:** https://www.npmjs.com/package/@path58/p58-n8n | **Version:** 0.2.4+
+**Package:** `@path58/p58-n8n` | **npm:** https://www.npmjs.com/package/@path58/p58-n8n | **Version:** 0.2.6+

package/CHANGELOG.md

@@ -5,6 +5,26 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.6] - 2026-03-11
+
+### Added
+
+- **LangChain AI connection type support** — `build_workflow` now automatically detects and wires all 10 LangChain connection types (`ai_languageModel`, `ai_tool`, `ai_memory`, `ai_embedding`, `ai_outputParser`, `ai_document`, `ai_vectorStore`, `ai_textSplitter`, `ai_retriever`, `ai_reranker`) instead of hardcoding all connections as `main`
+- **Sub-node positioning** — LLM models, memory modules, and tools now position below their parent chain/agent node in the n8n UI (same X, Y+200), matching native n8n layout conventions
+- **3-tier connection type resolver** — explicit user override → `connection_rules` catalog lookup (496 AI rules) → `ai_nodes.ai_type` fallback → `main` default
+- **`is_sub_node` metadata coverage** — backfilled from ~45% to 98.4% across all AI nodes in catalog
+
+### Fixed
+
+- LangChain workflows now deploy with correct connection wiring — models appear on diamond ports, not circle ports
+- v0.2.5 was published with stale bundle (did not include LangChain fix); this release rebuilds from fixed source with correct `SERVER_VERSION`
+
+## [0.2.5] - 2026-03-11
+
+### Fixed
+
+- Internal release — npm publish from stale source (superseded by v0.2.6)
+
 ## [0.2.4] - 2026-03-10
 
 ### Added
@@ -130,6 +150,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - npm package published as `@path58/p58-n8n`
 - ESM module support with shebang for direct `npx` execution
 
+[0.2.6]: https://github.com/tsvika58/p58-n8n/releases/tag/v0.2.6
+[0.2.5]: https://github.com/tsvika58/p58-n8n/releases/tag/v0.2.5
 [0.2.4]: https://github.com/tsvika58/p58-n8n/releases/tag/v0.2.4
 [0.2.3]: https://github.com/tsvika58/p58-n8n/releases/tag/v0.2.3
 [0.2.2]: https://github.com/tsvika58/p58-n8n/releases/tag/v0.2.2

package/dist/mcp/server.bundle.cjs

@@ -3111,7 +3111,7 @@ var require_retryUtils = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.retry = retry;
-    exports2.retryDbQuery = retryDbQuery9;
+    exports2.retryDbQuery = retryDbQuery10;
     var logger_1 = require_logger();
     var DEFAULT_OPTIONS = {
       maxRetries: 3,
@@ -3170,7 +3170,7 @@ var require_retryUtils = __commonJS({
       }
       throw lastError || new Error(`${operationName} failed after ${config3.maxRetries} retries`);
     }
-    async function retryDbQuery9(queryFn, maxRetries = DEFAULT_OPTIONS.maxRetries, operationName = "Database query") {
+    async function retryDbQuery10(queryFn, maxRetries = DEFAULT_OPTIONS.maxRetries, operationName = "Database query") {
       return retry(queryFn, { maxRetries }, operationName);
     }
   }
@@ -18473,7 +18473,7 @@ var import_types22 = require("@modelcontextprotocol/sdk/types.js");
 var config = {
   // Server identity
   SERVER_NAME: "p58-n8n",
-  SERVER_VERSION: "0.2.4",
+  SERVER_VERSION: "0.2.6",
   // Database configuration (from environment)
   SUPABASE_URL: process.env.SUPABASE_URL,
   SUPABASE_KEY: process.env.SUPABASE_KEY,
@@ -41483,14 +41483,15 @@ Examples:
 // dist/generation/build/WorkflowBuilder.js
 var import_crypto4 = require("crypto");
 init_validatorPostgresClient();
-var import_retry7 = __toESM(require_retryUtils(), 1);
-var import_logging53 = __toESM(require_logging(), 1);
+var import_retry8 = __toESM(require_retryUtils(), 1);
+var import_logging54 = __toESM(require_logging(), 1);
 
 // dist/generation/build/PositionCalculator.js
 var HORIZONTAL_SPACING = 250;
 var VERTICAL_SPACING = 150;
 var START_X = 250;
 var START_Y = 300;
+var SUB_NODE_Y_OFFSET = 200;
 function findRootNodes(nodeNames, connections) {
   const hasIncoming = new Set(connections.map((c) => c.to));
   const roots = nodeNames.filter((name) => !hasIncoming.has(name));
@@ -41542,14 +41543,45 @@ function assignFallbacks(nodeNames, positions) {
     }
   }
 }
-function calculatePositions(nodeNames, connections) {
+function detectSubNodes(connections, resolvedTypes) {
+  const subNodes = /* @__PURE__ */ new Set();
+  const parentOf = /* @__PURE__ */ new Map();
+  for (const conn of connections) {
+    const connType = resolvedTypes.get(`${conn.from}\u2192${conn.to}`);
+    if (connType && connType !== "main") {
+      subNodes.add(conn.from);
+      parentOf.set(conn.from, conn.to);
+    }
+  }
+  return { subNodes, parentOf };
+}
+function assignSubNodePositions(subNodes, parentOf, positions) {
+  const countPerParent = /* @__PURE__ */ new Map();
+  for (const subNode of subNodes) {
+    const parent = parentOf.get(subNode);
+    if (!parent)
+      continue;
+    const parentPos = positions.get(parent);
+    if (!parentPos)
+      continue;
+    const count = countPerParent.get(parent) ?? 0;
+    positions.set(subNode, [parentPos[0], parentPos[1] + SUB_NODE_Y_OFFSET * (count + 1)]);
+    countPerParent.set(parent, count + 1);
+  }
+}
+function calculatePositions(nodeNames, connections, resolvedTypes) {
   const positions = /* @__PURE__ */ new Map();
   if (nodeNames.length === 0)
     return positions;
-  const roots = findRootNodes(nodeNames, connections);
-  const adjacency = buildAdjacency(connections);
+  const { subNodes, parentOf } = resolvedTypes ? detectSubNodes(connections, resolvedTypes) : { subNodes: /* @__PURE__ */ new Set(), parentOf: /* @__PURE__ */ new Map() };
+  const mainNames = nodeNames.filter((n) => !subNodes.has(n));
+  const mainConns = connections.filter((c) => !subNodes.has(c.from));
+  const roots = findRootNodes(mainNames, mainConns);
+  const adjacency = buildAdjacency(mainConns);
   assignRootPositions(roots, positions);
   bfsAssign(roots, adjacency, positions);
+  assignFallbacks(mainNames, positions);
+  assignSubNodePositions(subNodes, parentOf, positions);
   assignFallbacks(nodeNames, positions);
   return positions;
 }
@@ -41662,6 +41694,117 @@ function getResourceLocatorParams(nodeType) {
   return RESOURCE_LOCATOR_PARAMS[nodeType.toLowerCase()];
 }
 
+// dist/generation/build/connectionTypeResolver.js
+init_validatorPostgresClient();
+var import_retry7 = __toESM(require_retryUtils(), 1);
+var import_logging53 = __toESM(require_logging(), 1);
+var AI_TYPE_TO_CONNECTION_TYPE = {
+  llm: "ai_languageModel",
+  memory: "ai_memory",
+  tool: "ai_tool",
+  embedding: "ai_embedding",
+  output_parser: "ai_outputParser",
+  retriever: "ai_retriever",
+  document_loader: "ai_document",
+  text_splitter: "ai_textSplitter",
+  vector_store: "ai_vectorStore",
+  reranker: "ai_reranker"
+};
+var DEFAULT_CONNECTION_TYPE = "main";
+async function loadConnectionRules2() {
+  const { rows } = await (0, import_retry7.retryDbQuery)(() => validatorQuery(`SELECT LOWER(source_node_type) AS source_node_type,
+              LOWER(target_node_type) AS target_node_type,
+              source_output
+       FROM bluelime.connection_rules
+       WHERE source_output != 'main'
+         AND is_valid = true
+       ORDER BY occurrence_count DESC`), 2, "connectionTypeResolver:loadConnectionRules");
+  return rows;
+}
+async function loadAINodeTypes() {
+  const { rows } = await (0, import_retry7.retryDbQuery)(() => validatorQuery(`SELECT LOWER(n.node_type) AS node_type, ai.ai_type
+       FROM bluelime.ai_nodes ai
+       JOIN bluelime.nodes n ON ai.node_id = n.id
+       WHERE ai.is_sub_node = true
+         AND ai.ai_type IS NOT NULL`), 2, "connectionTypeResolver:loadAINodeTypes");
+  return rows;
+}
+function buildRuleMap(rows) {
+  const map = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = `${row.source_node_type}|${row.target_node_type}`;
+    if (!map.has(key))
+      map.set(key, row.source_output);
+  }
+  return map;
+}
+function buildAITypeMap(rows) {
+  const map = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const connType = AI_TYPE_TO_CONNECTION_TYPE[row.ai_type];
+    if (connType && !map.has(row.node_type))
+      map.set(row.node_type, connType);
+  }
+  return map;
+}
+var ConnectionTypeResolver = class _ConnectionTypeResolver {
+  ruleMap;
+  aiTypeMap;
+  constructor(ruleMap, aiTypeMap) {
+    this.ruleMap = ruleMap;
+    this.aiTypeMap = aiTypeMap;
+  }
+  /**
+   * Factory: load catalog data and return a ready resolver.
+   * Falls back to empty maps (all "main") if DB query fails.
+   */
+  static async create() {
+    try {
+      const [ruleRows, aiNodeRows] = await Promise.all([
+        loadConnectionRules2(),
+        loadAINodeTypes()
+      ]);
+      import_logging53.logger.debug("connectionTypeResolver: loaded catalog", {
+        ruleCount: ruleRows.length,
+        aiNodeCount: aiNodeRows.length
+      });
+      return new _ConnectionTypeResolver(buildRuleMap(ruleRows), buildAITypeMap(aiNodeRows));
+    } catch (err) {
+      import_logging53.logger.warn('connectionTypeResolver: DB load failed, defaulting all connections to "main"', { error: err });
+      return new _ConnectionTypeResolver(/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map());
+    }
+  }
+  /**
+   * Resolve the n8n connection type for a single connection.
+   *
+   * @param explicit - Caller-provided override (e.g., from BuildConnectionSpec.type)
+   * @param sourceNodeType - Lowercased full n8n type of the source node
+   * @param targetNodeType - Lowercased full n8n type of the target node
+   * @returns Resolved connection type string
+   */
+  resolve(explicit, sourceNodeType, targetNodeType) {
+    if (explicit)
+      return explicit;
+    if (sourceNodeType && targetNodeType) {
+      const catalogType = this.ruleMap.get(`${sourceNodeType}|${targetNodeType}`);
+      if (catalogType)
+        return catalogType;
+    }
+    if (sourceNodeType) {
+      const aiType = this.aiTypeMap.get(sourceNodeType);
+      if (aiType)
+        return aiType;
+    }
+    return DEFAULT_CONNECTION_TYPE;
+  }
+};
+function buildNodeTypeMap4(nodes) {
+  const map = /* @__PURE__ */ new Map();
+  for (const node of nodes)
+    map.set(node.name, node.type.toLowerCase());
+  return map;
+}
+
 // dist/generation/build/version-credential-resolver.js
 var FALLBACK_VERSION = 1;
 var UNKNOWN_AUTH_MODE = "unknown";
@@ -42242,7 +42385,7 @@ function buildPlaceholders(count) {
 async function queryTypeVersions(nodeTypes) {
   const normalized = nodeTypes.map((t) => t.toLowerCase());
   const placeholders = buildPlaceholders(normalized.length);
-  const { rows } = await (0, import_retry7.retryDbQuery)(() => validatorQuery(`SELECT node_type, default_version, supported_versions FROM bluelime.nodes WHERE LOWER(node_type) IN (${placeholders})`, normalized), 3, "build_workflow_typeversion_batch");
+  const { rows } = await (0, import_retry8.retryDbQuery)(() => validatorQuery(`SELECT node_type, default_version, supported_versions FROM bluelime.nodes WHERE LOWER(node_type) IN (${placeholders})`, normalized), 3, "build_workflow_typeversion_batch");
   const groups = /* @__PURE__ */ new Map();
   for (const row of rows) {
     const key = row.node_type.toLowerCase();
@@ -42433,7 +42576,7 @@ function findTerminalNodes(nodes, connections) {
 function buildNodeBase(spec, position, typeVersion, casingMap) {
   const correctedType = resolveNodeTypeCasing(spec.type, casingMap);
   if (correctedType !== spec.type) {
-    import_logging53.logger.debug("build_workflow: corrected node type casing", { original: spec.type, corrected: correctedType, nodeName: spec.name });
+    import_logging54.logger.debug("build_workflow: corrected node type casing", { original: spec.type, corrected: correctedType, nodeName: spec.name });
   }
   return {
     id: (0, import_crypto4.randomUUID)(),
@@ -42455,20 +42598,20 @@ function assembleNode(spec, position, typeVersion, credential, isTerminal, casin
     node.continueOnFail = true;
   return node;
 }
-function assembleConnections(connections) {
+function assembleConnections(connections, nodeTypeMap, resolver) {
   const result = {};
   for (const conn of connections) {
+    const sourceType = nodeTypeMap.get(conn.from);
+    const targetType = nodeTypeMap.get(conn.to);
+    const connType = resolver.resolve(conn.type, sourceType, targetType);
     if (!result[conn.from])
-      result[conn.from] = { main: [] };
+      result[conn.from] = {};
+    if (!result[conn.from][connType])
+      result[conn.from][connType] = [];
     const outputIdx = conn.from_output ?? 0;
-    while (result[conn.from].main.length <= outputIdx) {
-      result[conn.from].main.push([]);
-    }
-    result[conn.from].main[outputIdx].push({
-      node: conn.to,
-      type: "main",
-      index: conn.to_input ?? 0
-    });
+    while (result[conn.from][connType].length <= outputIdx)
+      result[conn.from][connType].push([]);
+    result[conn.from][connType][outputIdx].push({ node: conn.to, type: connType, index: conn.to_input ?? 0 });
   }
   return result;
 }
@@ -42479,36 +42622,49 @@ async function resolveCatalogData(input) {
   const uniqueTypes = [...new Set(input.nodes.map((n) => n.type))];
   const [typeResult, credentialMap] = await Promise.all([
     queryTypeVersions(uniqueTypes).catch((err) => {
-      import_logging53.logger.warn("WorkflowBuilder: typeVersion lookup failed, using defaults", { error: err });
+      import_logging54.logger.warn("WorkflowBuilder: typeVersion lookup failed, using defaults", { error: err });
       return { versions: /* @__PURE__ */ new Map(), casingMap: /* @__PURE__ */ new Map() };
     }),
     resolveAllCredentials(input.nodes)
   ]);
   return { versionMap: typeResult.versions, casingMap: typeResult.casingMap, credentialMap };
 }
-function buildNodeList(nodes, connections, versionMap, casingMap, credentialMap) {
-  const autoPositions = calculatePositions(nodes.map((n) => n.name), connections);
+function computeResolvedTypes(connections, nodeTypeMap, resolver) {
+  const map = /* @__PURE__ */ new Map();
+  for (const conn of connections) {
+    const connType = resolver.resolve(conn.type, nodeTypeMap.get(conn.from), nodeTypeMap.get(conn.to));
+    map.set(`${conn.from}\u2192${conn.to}`, connType);
+  }
+  return map;
+}
+function buildNodeList(nodes, connections, versionMap, casingMap, credentialMap, nodeTypeMap, resolver) {
+  const resolvedTypes = computeResolvedTypes(connections, nodeTypeMap, resolver);
+  const autoPositions = calculatePositions(nodes.map((n) => n.name), connections, resolvedTypes);
   const terminalNodes = findTerminalNodes(nodes, connections);
   return nodes.map((spec) => {
     const resolved = resolveNodeVersion(spec, versionMap, credentialMap);
-    import_logging53.logger.debug("build_workflow: typeVersion resolved", { nodeType: spec.type, nodeName: spec.name, ...resolved });
+    import_logging54.logger.debug("build_workflow: typeVersion resolved", { nodeType: spec.type, nodeName: spec.name, ...resolved });
     return assembleNode(spec, getNodePosition(spec, autoPositions), resolved.typeVersion, credentialMap.get(spec.name), terminalNodes.has(spec.name), casingMap);
   });
 }
 async function assembleWorkflow(input) {
-  const { versionMap, casingMap, credentialMap } = await resolveCatalogData(input);
-  const nodes = buildNodeList(input.nodes, input.connections, versionMap, casingMap, credentialMap);
+  const [{ versionMap, casingMap, credentialMap }, resolver] = await Promise.all([
+    resolveCatalogData(input),
+    ConnectionTypeResolver.create()
+  ]);
+  const nodeTypeMap = buildNodeTypeMap4(input.nodes);
+  const nodes = buildNodeList(input.nodes, input.connections, versionMap, casingMap, credentialMap, nodeTypeMap, resolver);
   return {
     name: input.name,
     nodes,
-    connections: assembleConnections(input.connections),
+    connections: assembleConnections(input.connections, nodeTypeMap, resolver),
     settings: {},
     staticData: null
   };
 }
 
 // dist/generation/build/SubWorkflowBuilder.js
-var import_logging54 = __toESM(require_logging(), 1);
+var import_logging55 = __toESM(require_logging(), 1);
 var EXECUTE_WORKFLOW_TYPE = "n8n-nodes-base.executeWorkflow";
 var PLACEHOLDER = "{{SUB_WORKFLOW_ID}}";
 function findExecuteWorkflowNodes(nodes) {
@@ -42541,17 +42697,17 @@ async function buildSubWorkflows(parentSpec, buildSingle) {
   }
   const builtSubWorkflows = [];
   for (const subSpec of parentSpec.sub_workflows) {
-    import_logging54.logger.info("SubWorkflowBuilder: building sub-workflow", { name: subSpec.name });
+    import_logging55.logger.info("SubWorkflowBuilder: building sub-workflow", { name: subSpec.name });
     const { workflow_id, workflow_url } = await buildSingle(subSpec);
     builtSubWorkflows.push({ name: subSpec.name, workflow_id, workflow_url });
-    import_logging54.logger.info("SubWorkflowBuilder: sub-workflow built", { name: subSpec.name, workflow_id });
+    import_logging55.logger.info("SubWorkflowBuilder: sub-workflow built", { name: subSpec.name, workflow_id });
   }
   const wiredSpec = wireSubWorkflowIds(parentSpec, builtSubWorkflows);
   return { wiredSpec, builtSubWorkflows };
 }
 
 // dist/mcp/tools/handlers/build-workflow.js
-var import_logging55 = __toESM(require_logging(), 1);
+var import_logging56 = __toESM(require_logging(), 1);
 function buildWorkflowUrl(workflowId) {
   const apiBase = process.env.N8N_API_BASE_URL ?? "http://localhost:5678/api/v1";
   return `${apiBase.replace("/api/v1", "")}/workflow/${workflowId}`;
@@ -42644,7 +42800,7 @@ function buildSuccessPayload(args, result, builtSubWorkflows, workflowId, testRe
 async function buildSuccessResponse2(args, result, builtSubWorkflows, timeoutMs, startTime) {
   const workflowId = result.serverResponse.id;
   const testResult = args.test !== false ? await runTestStep(result.finalWorkflow, workflowId, args.test_payload, timeoutMs) : void 0;
-  import_logging55.logger.info("build_workflow: complete", { workflowId, fixes: result.fixesApplied.length });
+  import_logging56.logger.info("build_workflow: complete", { workflowId, fixes: result.fixesApplied.length });
   return buildSuccessPayload(args, result, builtSubWorkflows, workflowId, testResult, startTime);
 }
 async function executeBuildPipeline(args, timeoutMs, correlationId, startTime) {
@@ -42778,7 +42934,7 @@ function stripExtraWebhookTriggers(args) {
   const webhookNames = new Set(webhookNodes.map((n) => n.name));
   const cleanedNodes = args.nodes.filter((n) => !webhookNames.has(n.name));
   const cleanedConnections = args.connections?.filter((c) => !webhookNames.has(c.from) && !webhookNames.has(c.to));
-  import_logging55.logger.info("build_workflow: stripped webhook triggers from schedule workflow", {
+  import_logging56.logger.info("build_workflow: stripped webhook triggers from schedule workflow", {
     removed: [...webhookNames]
   });
   return {
@@ -42793,7 +42949,7 @@ async function handleBuildWorkflow(args) {
   const correlationId = generateCorrelationId();
   const startTime = performance.now();
   const timeoutMs = normalizeTimeout();
-  import_logging55.logger.debug("build_workflow: starting", { correlationId, workflowName: args.name });
+  import_logging56.logger.debug("build_workflow: starting", { correlationId, workflowName: args.name });
   try {
     const { cleaned: triggerCleaned, warnings: triggerWarnings } = await substituteUnavailableTriggers(args);
     const { cleaned, warning: webhookWarning } = stripExtraWebhookTriggers(triggerCleaned);
@@ -42822,7 +42978,7 @@ async function handleBuildWorkflow(args) {
   } catch (error) {
     if (isTimeoutError(error))
       return toMCPResponse(createTimeoutError(correlationId, "build_workflow"));
-    import_logging55.logger.error("build_workflow: unexpected error", { correlationId, error });
+    import_logging56.logger.error("build_workflow: unexpected error", { correlationId, error });
     const e = error instanceof Error ? error : new Error(String(error));
     return toMCPResponse(createInternalError(correlationId, e));
   }
@@ -42876,14 +43032,15 @@ Examples:
       },
       connections: {
         type: "array",
-        description: "Node connections",
+        description: "Node connections. For LangChain/AI nodes the connection type is auto-detected from the catalog \u2014 no need to set `type` manually. Use `type` only to override auto-detection.",
         items: {
           type: "object",
           properties: {
             from: { type: "string", description: "Source node name" },
             to: { type: "string", description: "Target node name" },
             from_output: { type: "number", description: "Output port index (default 0)" },
-            to_input: { type: "number", description: "Input port index (default 0)" }
+            to_input: { type: "number", description: "Input port index (default 0)" },
+            type: { type: "string", description: 'Connection type override (e.g., "ai_languageModel", "ai_tool", "ai_memory"). Auto-resolved from catalog if omitted.' }
           },
           required: ["from", "to"]
         }
@@ -42902,7 +43059,7 @@ Examples:
 };
 
 // dist/mcp/tools/handlers/list-credentials.js
-var import_logging56 = __toESM(require_logging(), 1);
+var import_logging57 = __toESM(require_logging(), 1);
 init_validatorPostgresClient();
 function buildApiConfig14(timeoutMs) {
   return {
@@ -43008,10 +43165,10 @@ function handleListError2(error, correlationId) {
   }
   const statusCode = error?.statusCode;
   if (statusCode === 401 || statusCode === 403) {
-    import_logging56.logger.warn("list_credentials: auth error", { correlationId, statusCode });
+    import_logging57.logger.warn("list_credentials: auth error", { correlationId, statusCode });
     return toMCPResponse(createSuccessResponse({ success: false, error: "Authentication failed" }, correlationId, { duration_ms: 0 }));
   }
-  import_logging56.logger.error("list_credentials: unexpected error", { correlationId, error });
+  import_logging57.logger.error("list_credentials: unexpected error", { correlationId, error });
   const originalError = error instanceof Error ? error : new Error(String(error));
   return toMCPResponse(createInternalError(correlationId, originalError));
 }
@@ -43022,13 +43179,13 @@ async function handleListCredentials(args) {
   const correlationId = generateCorrelationId();
   const startTime = performance.now();
   const timeoutMs = normalizeTimeout();
-  import_logging56.logger.debug("list_credentials: starting", { correlationId, options: args });
+  import_logging57.logger.debug("list_credentials: starting", { correlationId, options: args });
   try {
     const result = await fetchRawCredentials(args, timeoutMs);
     const { credentials: filtered, neededCredentialTypes } = await applyForNodesFilter(result.credentials, args.forNodes);
     const enriched = await enrichWithNodeTypes(filtered);
     const final = args.includeSchema ? await enrichWithSchema(enriched) : enriched;
-    import_logging56.logger.info("list_credentials: retrieved", { correlationId, count: final.length });
+    import_logging57.logger.info("list_credentials: retrieved", { correlationId, count: final.length });
     const data = buildResponseData(final, neededCredentialTypes);
     return toMCPResponse(createSuccessResponse(data, correlationId, { duration_ms: Math.round(performance.now() - startTime) }));
   } catch (error) {
@@ -43084,7 +43241,7 @@ listing which credential types need to be created.`,
 };
 
 // dist/mcp/tools/handlers/get-credential-schema.js
-var import_logging57 = __toESM(require_logging(), 1);
+var import_logging58 = __toESM(require_logging(), 1);
 init_validatorPostgresClient();
 var SENSITIVE_PATTERNS = /* @__PURE__ */ new Set([
   "apikey",
@@ -43223,21 +43380,21 @@ function buildResult(credentialType, rows, compatibleNodes) {
 function buildSchemaResponse(credentialType, rows, nodes, correlationId, startTime) {
   const data = buildResult(credentialType, rows, nodes);
   const duration_ms = Math.round(performance.now() - startTime);
-  import_logging57.logger.info("get_credential_schema: found", { correlationId, credential_type: credentialType, fieldCount: rows.length });
+  import_logging58.logger.info("get_credential_schema: found", { correlationId, credential_type: credentialType, fieldCount: rows.length });
   return toMCPResponse(createSuccessResponse(data, correlationId, { duration_ms }));
 }
 async function handleGetCredentialSchema(args) {
   const correlationId = generateCorrelationId();
   const startTime = performance.now();
   const { credential_type } = args;
-  import_logging57.logger.debug("get_credential_schema: starting", { correlationId, credential_type });
+  import_logging58.logger.debug("get_credential_schema: starting", { correlationId, credential_type });
   try {
     const [rows, nodes] = await Promise.all([fetchSchemaRows(credential_type), fetchCompatibleNodes(credential_type)]);
     if (rows.length === 0)
       return handleUnknownType(credential_type, correlationId);
     return buildSchemaResponse(credential_type, rows, nodes, correlationId, startTime);
   } catch (error) {
-    import_logging57.logger.error("get_credential_schema: unexpected error", { correlationId, error });
+    import_logging58.logger.error("get_credential_schema: unexpected error", { correlationId, error });
     const originalError = error instanceof Error ? error : new Error(String(error));
     if (isDbConfigError(originalError))
       return makeDbNotConfiguredResponse();
@@ -43286,7 +43443,7 @@ Example usage:
 };
 
 // dist/mcp/tools/handlers/create-credential.js
-var import_logging58 = __toESM(require_logging(), 1);
+var import_logging59 = __toESM(require_logging(), 1);
 init_validatorPostgresClient();
 var DEFAULT_TIMEOUT_MS2 = 1e4;
 var FIELDS_SQL = `
@@ -43352,11 +43509,11 @@ function buildCreateError(error, correlationId) {
   const statusCode = error?.statusCode;
   const message = error instanceof Error ? error.message : String(error);
   if (statusCode === 401 || statusCode === 403) {
-    import_logging58.logger.warn("create_credential: auth error", { correlationId, statusCode });
+    import_logging59.logger.warn("create_credential: auth error", { correlationId, statusCode });
     const data = { success: false, error: "AUTH_ERROR", message: "Authentication failed. Check N8N_API_KEY." };
     return toMCPResponse(createSuccessResponse(data, correlationId, { duration_ms: 0 }));
   }
-  import_logging58.logger.error("create_credential: unexpected error", { correlationId, error });
+  import_logging59.logger.error("create_credential: unexpected error", { correlationId, error });
   return toMCPResponse(createInternalError(correlationId, error instanceof Error ? error : new Error(message)));
 }
 function buildExistsResponse(existing, correlationId) {
@@ -43376,7 +43533,7 @@ async function handleCreateCredential(args) {
   const correlationId = generateCorrelationId();
   const startTime = performance.now();
   const { credential_type, name, data } = args;
-  import_logging58.logger.debug("create_credential: starting", { correlationId, credential_type, name });
+  import_logging59.logger.debug("create_credential: starting", { correlationId, credential_type, name });
   try {
     const fields = await fetchCredentialFields(credential_type);
     if (fields.length === 0)
@@ -43387,13 +43544,13 @@ async function handleCreateCredential(args) {
     const config3 = buildApiConfig15();
     const existing = await findExistingCredential(config3, credential_type, name);
     if (existing) {
-      import_logging58.logger.warn("create_credential: duplicate blocked", { correlationId, existing_id: existing.id, credential_type, name });
+      import_logging59.logger.warn("create_credential: duplicate blocked", { correlationId, existing_id: existing.id, credential_type, name });
       return buildExistsResponse(existing, correlationId);
     }
     const result = await createCredential(config3, { name, type: credential_type, data });
     clearCredentialCache();
     const duration_ms = Math.round(performance.now() - startTime);
-    import_logging58.logger.info("create_credential: created", { correlationId, id: result.id, credential_type, name });
+    import_logging59.logger.info("create_credential: created", { correlationId, id: result.id, credential_type, name });
     return buildCreateSuccessResponse(result, correlationId, duration_ms);
   } catch (error) {
     return buildCreateError(error, correlationId);
@@ -43445,7 +43602,7 @@ Example usage:
 
 // dist/mcp/tools/handlers/test-credential.js
 var net = __toESM(require("net"), 1);
-var import_logging59 = __toESM(require_logging(), 1);
+var import_logging60 = __toESM(require_logging(), 1);
 var PROBE_TIMEOUT_MS = 5e3;
 var RATE_LIMIT_MS = 3e4;
 var lastTestTimestamps = /* @__PURE__ */ new Map();
@@ -43625,7 +43782,7 @@ function buildProbeError(error, correlationId) {
     const data = { supported: true, valid: false, message: "Credential not found. Check the credential ID." };
     return toMCPResponse(createSuccessResponse(data, correlationId, { duration_ms: 0 }));
   }
-  import_logging59.logger.error("test_credential: unexpected error", { correlationId, error });
+  import_logging60.logger.error("test_credential: unexpected error", { correlationId, error });
   return toMCPResponse(createInternalError(correlationId, error instanceof Error ? error : new Error(String(error))));
 }
 async function handleTestCredential(args) {
@@ -43641,7 +43798,7 @@ async function handleTestCredential(args) {
     recordTestTimestamp(credential_id);
     try {
       const n8nResult = await testCredentialViaN8n(config3, credential_id, credential.name, credential.type, credential.data, restCreds);
-      import_logging59.logger.info("test_credential: n8n built-in test", {
+      import_logging60.logger.info("test_credential: n8n built-in test", {
         correlationId,
         type: credential.type,
         valid: n8nResult.valid
@@ -43649,9 +43806,9 @@ async function handleTestCredential(args) {
       return buildProbeResponse(n8nResult, correlationId);
     } catch (n8nTestError) {
       if (n8nTestError?.code === "NEEDS_N8N_LOGIN") {
-        import_logging59.logger.debug("test_credential: n8n test unavailable, falling back to HTTP probes");
+        import_logging60.logger.debug("test_credential: n8n test unavailable, falling back to HTTP probes");
       } else {
-        import_logging59.logger.warn("test_credential: n8n test failed, falling back to HTTP probes", {
+        import_logging60.logger.warn("test_credential: n8n test failed, falling back to HTTP probes", {
           error: n8nTestError instanceof Error ? n8nTestError.message : String(n8nTestError)
         });
       }
@@ -43661,10 +43818,10 @@ async function handleTestCredential(args) {
       return buildUnsupportedResponse(credential.type, correlationId);
     const hasBlankValues = Object.values(credential.data).some((v) => typeof v === "string" && v.includes("__n8n_BLANK_VALUE_"));
     if (hasBlankValues) {
-      import_logging59.logger.warn("test_credential: credential data contains encrypted placeholders, probe may be unreliable");
+      import_logging60.logger.warn("test_credential: credential data contains encrypted placeholders, probe may be unreliable");
     }
     const result = await probe(credential.data);
-    import_logging59.logger.info("test_credential: HTTP probe fallback", {
+    import_logging60.logger.info("test_credential: HTTP probe fallback", {
       correlationId,
       type: credential.type,
       valid: result.valid,
@@ -43718,7 +43875,7 @@ Use list_credentials to find credential IDs.`,
 };
 
 // dist/mcp/tools/handlers/update-credential.js
-var import_logging60 = __toESM(require_logging(), 1);
+var import_logging61 = __toESM(require_logging(), 1);
 var DEFAULT_TIMEOUT_MS3 = 1e4;
 function buildApiConfig17() {
   return {
@@ -43742,16 +43899,16 @@ function buildUpdateError(error, correlationId) {
   const statusCode = error?.statusCode;
   const message = error instanceof Error ? error.message : String(error);
   if (statusCode === 404) {
-    import_logging60.logger.warn("update_credential: not found", { correlationId, statusCode });
+    import_logging61.logger.warn("update_credential: not found", { correlationId, statusCode });
     const data = { success: false, error: "NOT_FOUND", message: "Credential not found. Use list_credentials to find valid IDs." };
     return toMCPResponse(createSuccessResponse(data, correlationId, { duration_ms: 0 }));
   }
   if (statusCode === 401 || statusCode === 403) {
-    import_logging60.logger.warn("update_credential: auth error", { correlationId, statusCode });
+    import_logging61.logger.warn("update_credential: auth error", { correlationId, statusCode });
     const data = { success: false, error: "AUTH_ERROR", message: "Authentication failed. Check N8N_API_KEY." };
     return toMCPResponse(createSuccessResponse(data, correlationId, { duration_ms: 0 }));
   }
-  import_logging60.logger.error("update_credential: unexpected error", { correlationId, error });
+  import_logging61.logger.error("update_credential: unexpected error", { correlationId, error });
   return toMCPResponse(createInternalError(correlationId, error instanceof Error ? error : new Error(message)));
 }
 async function buildUpdatePayload(config3, args) {
@@ -43766,9 +43923,9 @@ function buildUpdateSuccessResponse2(result, correlationId, duration_ms) {
 async function handleUpdateCredential(args) {
   const correlationId = generateCorrelationId();
   const startTime = performance.now();
-  import_logging60.logger.debug("update_credential: starting", { correlationId, credential_id: args.credential_id });
+  import_logging61.logger.debug("update_credential: starting", { correlationId, credential_id: args.credential_id });
   if (args.data && Object.keys(args.data).length > 0) {
-    import_logging60.logger.warn("update_credential: rejected data write attempt", { correlationId, credential_id: args.credential_id });
+    import_logging61.logger.warn("update_credential: rejected data write attempt", { correlationId, credential_id: args.credential_id });
     const data = {
       success: false,
       error: "DATA_WRITE_DENIED",
@@ -43789,7 +43946,7 @@ async function handleUpdateCredential(args) {
     const payload = await buildUpdatePayload(config3, { ...args, data: void 0 });
     const result = await updateCredential(config3, args.credential_id, payload);
     invalidate();
-    import_logging60.logger.info("update_credential: updated (name only)", { correlationId, id: result.id });
+    import_logging61.logger.info("update_credential: updated (name only)", { correlationId, id: result.id });
     return buildUpdateSuccessResponse2(result, correlationId, Math.round(performance.now() - startTime));
   } catch (error) {
     return buildUpdateError(error, correlationId);
@@ -43824,7 +43981,7 @@ On not found: returns NOT_FOUND error with guidance.`,
 };
 
 // dist/mcp/tools/handlers/delete-credential.js
-var import_logging61 = __toESM(require_logging(), 1);
+var import_logging62 = __toESM(require_logging(), 1);
 var DEFAULT_TIMEOUT_MS4 = 1e4;
 var MAX_WORKFLOWS_TO_SCAN = 100;
 function buildApiConfig18() {
@@ -43883,18 +44040,18 @@ function buildDeleteError(error, correlationId) {
   const statusCode = error?.statusCode;
   const message = error instanceof Error ? error.message : String(error);
   if (statusCode === 401 || statusCode === 403) {
-    import_logging61.logger.warn("delete_credential: auth error", { correlationId, statusCode });
+    import_logging62.logger.warn("delete_credential: auth error", { correlationId, statusCode });
     const data = { success: false, error: "AUTH_ERROR", message: "Authentication failed. Check N8N_API_KEY." };
     return toMCPResponse(createSuccessResponse(data, correlationId, { duration_ms: 0 }));
   }
-  import_logging61.logger.error("delete_credential: unexpected error", { correlationId, error });
+  import_logging62.logger.error("delete_credential: unexpected error", { correlationId, error });
   return toMCPResponse(createInternalError(correlationId, error instanceof Error ? error : new Error(message)));
 }
 async function checkAndWarnDependents(config3, credential_id, correlationId) {
   const dependentWorkflows = await findDependentWorkflows(config3, credential_id);
   if (dependentWorkflows.length === 0)
     return null;
-  import_logging61.logger.warn("delete_credential: dependent workflows found", { correlationId, credential_id, count: dependentWorkflows.length });
+  import_logging62.logger.warn("delete_credential: dependent workflows found", { correlationId, credential_id, count: dependentWorkflows.length });
   return buildDependentWarningResponse(credential_id, dependentWorkflows, correlationId);
 }
 async function executeDelete(config3, credential_id, force, correlationId, startTime) {
@@ -43905,14 +44062,14 @@ async function executeDelete(config3, credential_id, force, correlationId, start
   }
   await deleteCredential(config3, credential_id);
   invalidate();
-  import_logging61.logger.info("delete_credential: deleted", { correlationId, credential_id, force });
+  import_logging62.logger.info("delete_credential: deleted", { correlationId, credential_id, force });
   return buildDeleteSuccessResponse(credential_id, correlationId, Math.round(performance.now() - startTime));
 }
 async function handleDeleteCredential(args) {
   const correlationId = generateCorrelationId();
   const startTime = performance.now();
   const { credential_id, force = false } = args;
-  import_logging61.logger.debug("delete_credential: starting", { correlationId, credential_id, force });
+  import_logging62.logger.debug("delete_credential: starting", { correlationId, credential_id, force });
   try {
     return await executeDelete(buildApiConfig18(), credential_id, force, correlationId, startTime);
   } catch (error) {
@@ -43957,12 +44114,12 @@ On auth error: returns AUTH_ERROR with guidance.`,
 };
 
 // dist/mcp/tools/handlers/collect-config.js
-var import_logging63 = __toESM(require_logging(), 1);
+var import_logging64 = __toESM(require_logging(), 1);
 init_validatorPostgresClient();
-var import_retry8 = __toESM(require_retryUtils(), 1);
+var import_retry9 = __toESM(require_retryUtils(), 1);
 
 // dist/mcp/session/config-cache.js
-var import_logging62 = __toESM(require_logging(), 1);
+var import_logging63 = __toESM(require_logging(), 1);
 var CONFIG_CACHE_TTL_MS = 30 * 60 * 1e3;
 var CONFIG_CACHE_MAX_ENTRIES = 500;
 var cacheState2 = null;
@@ -44005,12 +44162,12 @@ function set(key, value) {
     stored_at: Date.now(),
     expires_at: Date.now() + CONFIG_CACHE_TTL_MS
   });
-  import_logging62.logger.debug("config-cache: stored value", { key });
+  import_logging63.logger.debug("config-cache: stored value", { key });
 }
 function clearConfigCache() {
   cacheState2 = null;
   warming = null;
-  import_logging62.logger.debug("config-cache: cleared");
+  import_logging63.logger.debug("config-cache: cleared");
 }
 function getSuggestion(configType, nodeType, parameterName) {
   const serviceId = extractServiceId(nodeType);
@@ -44142,7 +44299,7 @@ function buildConfigValues(answered) {
   return result;
 }
 async function markGapsResolved(gapType, nodeType, notes) {
-  await (0, import_retry8.retryDbQuery)(() => validatorQuery(RESOLVE_GAPS_SQL, [gapType, nodeType, notes]), 3, "collect_config_resolve_gaps");
+  await (0, import_retry9.retryDbQuery)(() => validatorQuery(RESOLVE_GAPS_SQL, [gapType, nodeType, notes]), 3, "collect_config_resolve_gaps");
 }
 async function resolveOneGap(req) {
   const gapType = CATEGORY_TO_GAP_TYPE[req.configType];
@@ -44151,7 +44308,7 @@ async function resolveOneGap(req) {
   try {
     await markGapsResolved(gapType, req.nodeType, `Resolved via collect_config: ${req.parameterName}`);
   } catch (error) {
-    import_logging63.logger.warn("collect_config: gap resolution failed (non-fatal)", {
+    import_logging64.logger.warn("collect_config: gap resolution failed (non-fatal)", {
       nodeType: req.nodeType,
       gapType,
       error: error instanceof Error ? error.message : String(error)
@@ -44193,14 +44350,14 @@ async function executeCollect(args) {
 async function handleCollectConfig(args) {
   const correlationId = generateCorrelationId();
   const startTime = performance.now();
-  import_logging63.logger.debug("collect_config: starting", { correlationId });
+  import_logging64.logger.debug("collect_config: starting", { correlationId });
   try {
     const { output, logMeta } = await executeCollect(args);
     const duration_ms = Math.round(performance.now() - startTime);
-    import_logging63.logger.info("collect_config: completed", { correlationId, ...logMeta });
+    import_logging64.logger.info("collect_config: completed", { correlationId, ...logMeta });
     return toMCPResponse(createSuccessResponse(output, correlationId, { duration_ms }));
   } catch (error) {
-    import_logging63.logger.error("collect_config: failed", { correlationId, error });
+    import_logging64.logger.error("collect_config: failed", { correlationId, error });
     return toMCPResponse(createInternalError(correlationId, error instanceof Error ? error : new Error(String(error))));
   }
 }
@@ -44644,7 +44801,7 @@ function redactMCPResponse(response) {
 
 // dist/mcp/server-lifecycle.js
 init_validatorPostgresClient();
-var import_logging64 = __toESM(require_logging(), 1);
+var import_logging65 = __toESM(require_logging(), 1);
 var defaultDeps = {
   shutdownPool: shutdownValidatorPool,
   clearCache: clearCredentialCache,
@@ -44657,7 +44814,7 @@ async function runCleanup(serverName, deps) {
     deps.clearCache();
     deps.clearConfigCache?.();
   } catch (err) {
-    import_logging64.logger.error(`[${serverName}] Error during shutdown:`, err);
+    import_logging65.logger.error(`[${serverName}] Error during shutdown:`, err);
   }
 }
 function createShutdownHandler(serverName, deps = defaultDeps) {
@@ -44666,7 +44823,7 @@ function createShutdownHandler(serverName, deps = defaultDeps) {
     if (isShuttingDown)
       return;
     isShuttingDown = true;
-    import_logging64.logger.info(`[${serverName}] Received ${signal}, shutting down...`);
+    import_logging65.logger.info(`[${serverName}] Received ${signal}, shutting down...`);
     await runCleanup(serverName, deps);
     process.exit(0);
   };
@@ -44679,7 +44836,7 @@ function registerShutdownHandlers(serverName, deps) {
   process.stdin.on("end", () => void shutdown("stdin-close"));
   process.stdin.on("close", () => void shutdown("stdin-close"));
   process.on("exit", (code) => {
-    import_logging64.logger.debug(`[${serverName}] Process exiting (code ${code})`);
+    import_logging65.logger.debug(`[${serverName}] Process exiting (code ${code})`);
   });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@path58/p58-n8n",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "The smartest and fastest n8n MCP server — validate, fix, and discover workflows inside your LLM",
   "keywords": [
     "mcp",