@path58/p58-n8n 0.2.5 → 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

@@ -3014,22 +3014,28 @@ function buildPoolOptions() {
 }
 function createPool(cfg) {
   const timeoutMs = getEnvNumber("DB_STATEMENT_TIMEOUT_MS", 3e4);
+  const isCatalogOnly = !!(process.env.P58_DATABASE_URL || process.env.MCP_DATABASE_URL) && !process.env.N8N_API_KEY;
   const pool = new import_pg.Pool({
     host: cfg.host,
     port: resolvePoolPort(cfg),
     user: cfg.user,
     password: cfg.password,
     database: cfg.database,
-    max: getEnvNumber("VALIDATOR_DB_POOL_MAX", 10),
-    min: getEnvNumber("VALIDATOR_DB_POOL_MIN", 1),
+    // Friends: 3 max (1 active + 2 burst). Full mode: 10.
+    max: getEnvNumber("VALIDATOR_DB_POOL_MAX", isCatalogOnly ? 3 : 10),
+    // Friends: 0 min — don't hold connections when idle. Full mode: 1.
+    min: getEnvNumber("VALIDATOR_DB_POOL_MIN", isCatalogOnly ? 0 : 1),
     // allowExitOnIdle: true — prevents zombie processes when MCP session ends (RAG-4.35.5)
-    idleTimeoutMillis: 6e4,
-    connectionTimeoutMillis: 15e3,
+    // Friends: 30s idle (release fast). Full mode: 60s.
+    idleTimeoutMillis: isCatalogOnly ? 3e4 : 6e4,
+    // Friends: 10s connect timeout (fail fast). Full mode: 15s.
+    connectionTimeoutMillis: isCatalogOnly ? 1e4 : 15e3,
     statement_timeout: timeoutMs,
     options: buildPoolOptions(),
     allowExitOnIdle: true,
-    keepAlive: true,
-    keepAliveInitialDelayMillis: 1e4
+    // Friends: no keepAlive (let connections close naturally). Full mode: keepAlive.
+    keepAlive: !isCatalogOnly,
+    ...isCatalogOnly ? {} : { keepAliveInitialDelayMillis: 1e4 }
   });
   pool.on("error", (err) => {
     console.warn(`[pg-pool] Idle connection error (non-fatal): ${err.message}`);
@@ -3041,6 +3047,24 @@ function getValidatorPool() {
     validatorPool = createPool(getValidatorDbConfig());
   return validatorPool;
 }
+async function warmSingleConnection(pool) {
+  const client = await pool.connect();
+  await client.query("SELECT 1");
+  client.release();
+}
+async function warmValidatorPool() {
+  if (poolWarmed)
+    return;
+  const pool = getValidatorPool();
+  const minConns = getEnvNumber("VALIDATOR_DB_POOL_MIN", 1);
+  try {
+    for (let i = 0; i < minConns; i++)
+      await warmSingleConnection(pool);
+    poolWarmed = true;
+  } catch (error) {
+    console.warn("Validator pool warm-up failed, continuing with lazy connection creation:", error);
+  }
+}
 async function validatorQuery(sql, params = []) {
   const client = await getValidatorPool().connect();
   const onClientError = (err) => {
@@ -3062,7 +3086,7 @@ async function shutdownValidatorPool() {
     validatorPool = null;
   }
 }
-var import_pg, dotenv, path, import_url, import_connection, __filename, __dirname, PROJECT_ROOT, validatorPool;
+var import_pg, dotenv, path, import_url, import_connection, __filename, __dirname, PROJECT_ROOT, validatorPool, poolWarmed;
 var init_validatorPostgresClient = __esm({
   "dist/db/validatorPostgresClient.js"() {
     "use strict";
@@ -3077,6 +3101,7 @@ var init_validatorPostgresClient = __esm({
     dotenv.config({ path: path.resolve(PROJECT_ROOT, ".env.supabase") });
     dotenv.config({ path: path.resolve(PROJECT_ROOT, ".env") });
     validatorPool = null;
+    poolWarmed = false;
   }
 });
 
@@ -3086,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,
@@ -3145,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);
     }
   }
@@ -18436,6 +18461,7 @@ var init_cached_catalog_adapter = __esm({
 // dist/mcp/server.js
 var server_exports = {};
 __export(server_exports, {
+  isServerInitialized: () => isServerInitialized,
   logStartupSummary: () => logStartupSummary
 });
 module.exports = __toCommonJS(server_exports);
@@ -18447,7 +18473,7 @@ var import_types22 = require("@modelcontextprotocol/sdk/types.js");
 var config = {
   // Server identity
   SERVER_NAME: "p58-n8n",
-  SERVER_VERSION: "0.2.3",
+  SERVER_VERSION: "0.2.6",
   // Database configuration (from environment)
   SUPABASE_URL: process.env.SUPABASE_URL,
   SUPABASE_KEY: process.env.SUPABASE_KEY,
@@ -19179,6 +19205,30 @@ async function injectResponseMetadata(sessionId, toolName, response, executionSt
   return instrumented;
 }
 
+// dist/mcp/in-flight-tracker.js
+var inflightCount = 0;
+function incrementInflight() {
+  inflightCount++;
+}
+function decrementInflight() {
+  if (inflightCount > 0)
+    inflightCount--;
+}
+function waitForInflightRequests(timeoutMs) {
+  if (inflightCount === 0)
+    return Promise.resolve();
+  return new Promise((resolve2) => {
+    const deadline = setTimeout(resolve2, timeoutMs);
+    const poll = setInterval(() => {
+      if (inflightCount <= 0) {
+        clearInterval(poll);
+        clearTimeout(deadline);
+        resolve2();
+      }
+    }, 50);
+  });
+}
+
 // dist/validation/l1-structure.js
 async function validateL1Structure(workflowJson) {
   const startTime = performance.now();
@@ -30388,7 +30438,13 @@ var AutoFixerRegistry = class _AutoFixerRegistry {
     }
   }
 };
-var fixerRegistry = new AutoFixerRegistry();
+var _fixerRegistry = null;
+function getFixerRegistry() {
+  if (!_fixerRegistry) {
+    _fixerRegistry = new AutoFixerRegistry();
+  }
+  return _fixerRegistry;
+}
 
 // node_modules/axios/lib/helpers/bind.js
 function bind(fn, thisArg) {
@@ -34886,7 +34942,7 @@ async function runAutofixOnWorkflow(workflowJson, issues) {
   const { applied: credApplied, changelog: credChangelog } = preAssignCredentials(workflow, issues);
   const errorIssues = issues.filter((i) => i.severity === "error");
   const problems = errorIssues.map(issueToValidationProblem);
-  const fixResult = await fixerRegistry.applyFixes(workflow, problems);
+  const fixResult = await getFixerRegistry().applyFixes(workflow, problems);
   const fixChangelog = buildChangelog(fixResult.results);
   return {
     fixedWorkflow: fixResult.workflow,
@@ -35281,10 +35337,10 @@ How it works:
 
 Validation levels:
 - L1: JSON structure, required fields, duplicate node names
-- L2: Node types exist in catalog (1,982 nodes)
-- L3: Credential types valid (654 credentials) \u2014 includes available_credentials lookup
-- L4: Connection patterns exist (6,900 rules)
-- L5: Required parameters configured (35,143 params)
+- L2: Node types exist in catalog (1,545 nodes)
+- L3: Credential types valid (679 credentials) \u2014 includes available_credentials lookup
+- L4: Connection patterns exist (7,642 rules)
+- L5: Required parameters configured (38,005 params)
 - L6: Pattern validation (flow integrity, security, expressions)
 
 Returns detailed issues with severity, location, and suggested fixes.
@@ -35487,7 +35543,7 @@ var getOperationSchemaToolDefinition = {
   name: "get_operation_schema",
   description: `Get parameter requirements for a specific n8n node operation.
 
-Returns the exact required and optional parameters from our 35,143 parameter catalog.
+Returns the exact required and optional parameters from our 38,005 parameter catalog.
 Use this to prevent parameter hallucination when generating n8n workflows.
 
 Examples:
@@ -36573,6 +36629,77 @@ Examples:
   }
 };
 
+// dist/mcp/tools/handlers/shared/n8n-guard.js
+var SETUP_GUIDE_URL = "https://github.com/tsvika58/p58-n8n/blob/main/docs/AGENT_INSTALL.md";
+var OFFLINE_TOOLS = /* @__PURE__ */ new Set([
+  "validate_workflow",
+  "get_operation_schema",
+  "check_parameter",
+  "suggest_fix",
+  "list_operations",
+  "list_nodes",
+  "get_node_info",
+  "find_similar_pattern",
+  "get_session_metrics",
+  "get_credential_schema",
+  "setup_check"
+]);
+function requiresN8nApiKey(toolName) {
+  return !OFFLINE_TOOLS.has(toolName);
+}
+function makeN8nNotConfiguredError() {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          error: `This tool requires n8n connection. Set N8N_API_URL and N8N_API_KEY in your MCP config. See: ${SETUP_GUIDE_URL}`
+        })
+      }
+    ],
+    isError: true
+  };
+}
+function isDbConfigError(error) {
+  const msg = error instanceof Error ? error.message : String(error);
+  return msg.includes("Missing required validator DB environment variable");
+}
+function isDbConnectionError(error) {
+  const msg = error instanceof Error ? error.message : String(error);
+  return msg.includes("ECONNREFUSED") || msg.includes("ETIMEDOUT") || msg.includes("connect ETIMEDOUT") || msg.includes("after calling end on the pool") || msg.includes("Connection terminated") || msg.includes("getaddrinfo ENOTFOUND") || msg.includes("too many connections") || msg.includes("remaining connection slots");
+}
+function makeDbNotConfiguredResponse() {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          error: "DB_NOT_CONFIGURED",
+          message: "Catalog features require P58_DATABASE_URL. Set P58_DATABASE_URL in your MCP config to enable this tool.",
+          setup_guide: SETUP_GUIDE_URL
+        })
+      }
+    ],
+    isError: true
+  };
+}
+function makeDbConnectionErrorResponse() {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          error: "CATALOG_UNREACHABLE",
+          message: "Catalog database is unreachable. Verify your P58_DATABASE_URL is correct and the database server is accessible. If the problem persists, contact Tsvika.",
+          hint: "Check: (1) connection string starts with postgresql://mcp_friend... (2) port is 6543 (transaction pooler) (3) network allows outbound to AWS eu-north-1",
+          setup_guide: SETUP_GUIDE_URL
+        })
+      }
+    ],
+    isError: true
+  };
+}
+
 // dist/mcp/middleware/response-compression.js
 function selectFields(item, fields) {
   const result = {};
@@ -36692,8 +36819,11 @@ async function handleListOperations(args) {
     return toMCPResponse(response);
   } catch (error) {
     const originalError = error instanceof Error ? error : new Error(String(error));
-    const errorResponse = createInternalError(correlationId, originalError);
-    return toMCPResponse(errorResponse);
+    if (isDbConfigError(originalError))
+      return makeDbNotConfiguredResponse();
+    if (isDbConnectionError(originalError))
+      return makeDbConnectionErrorResponse();
+    return toMCPResponse(createInternalError(correlationId, originalError));
   }
 }
 var listOperationsToolDefinition = {
@@ -36790,13 +36920,16 @@ async function handleListNodes(args) {
     return toMCPResponse(response);
   } catch (error) {
     const originalError = error instanceof Error ? error : new Error(String(error));
-    const errorResponse = createInternalError(correlationId, originalError);
-    return toMCPResponse(errorResponse);
+    if (isDbConfigError(originalError))
+      return makeDbNotConfiguredResponse();
+    if (isDbConnectionError(originalError))
+      return makeDbConnectionErrorResponse();
+    return toMCPResponse(createInternalError(correlationId, originalError));
   }
 }
 var listNodesToolDefinition = {
   name: "list_nodes",
-  description: `List all available n8n nodes (1,982 total) with filtering and pagination.
+  description: `List all available n8n nodes (1,545 total) with filtering and pagination.
 
 Use this to discover available nodes before generating workflows. The tool supports:
 - Pagination: Use limit (1-100) and offset for large result sets
@@ -36953,8 +37086,11 @@ async function handleGetNodeInfo(args) {
     return toMCPResponse(response);
   } catch (error) {
     const originalError = error instanceof Error ? error : new Error(String(error));
-    const errorResponse = createInternalError(correlationId, originalError);
-    return toMCPResponse(errorResponse);
+    if (isDbConfigError(originalError))
+      return makeDbNotConfiguredResponse();
+    if (isDbConnectionError(originalError))
+      return makeDbConnectionErrorResponse();
+    return toMCPResponse(createInternalError(correlationId, originalError));
   }
 }
 var getNodeInfoToolDefinition = {
@@ -37042,8 +37178,11 @@ async function handleFindSimilarPattern(args) {
     return toMCPResponse(response);
   } catch (error) {
     const originalError = error instanceof Error ? error : new Error(String(error));
-    const errorResponse = createInternalError(correlationId, originalError);
-    return toMCPResponse(errorResponse);
+    if (isDbConfigError(originalError))
+      return makeDbNotConfiguredResponse();
+    if (isDbConnectionError(originalError))
+      return makeDbConnectionErrorResponse();
+    return toMCPResponse(createInternalError(correlationId, originalError));
   }
 }
 var findSimilarPatternToolDefinition = {
@@ -37240,8 +37379,8 @@ schemas, build_workflow handles validation, autofix, and deployment automaticall
 
 Runs L1-L4 validation before creating:
 - L1: JSON structure, required fields
-- L2: Node types exist in catalog (1,982 nodes)
-- L3: Credential types are valid (654 credentials)
+- L2: Node types exist in catalog (1,545 nodes)
+- L3: Credential types are valid (679 credentials)
 - L4: Connection patterns exist
 
 Refuses creation if any L1-L4 errors are found.
@@ -38612,7 +38751,7 @@ async function validateWorkflowObject(workflow, timeoutMs, label) {
 }
 async function runAutoFix(workflow, validationResult, timeoutMs, toolName) {
   const problems = validationResult.issues.filter((i) => i.severity === "error").map(issueToValidationProblem2);
-  const fixResult = await withTimeout(fixerRegistry.applyFixes(workflow, problems), timeoutMs, `${toolName} autofix`);
+  const fixResult = await withTimeout(getFixerRegistry().applyFixes(workflow, problems), timeoutMs, `${toolName} autofix`);
   return { fixedWorkflow: fixResult.workflow, fixResult };
 }
 async function applyAutoFixIfNeeded(workflow, validationResult, hasErrors, shouldFix, timeoutMs, correlationId, toolName) {
@@ -39259,7 +39398,7 @@ function issueToValidationProblem3(issue) {
 }
 async function runFixStep(workflow, validation, timeoutMs) {
   const problems = validation.issues.filter((i) => i.severity === "error").map(issueToValidationProblem3);
-  const fixResult = await withTimeout(fixerRegistry.applyFixes(workflow, problems), timeoutMs, "server_autofix:fix");
+  const fixResult = await withTimeout(getFixerRegistry().applyFixes(workflow, problems), timeoutMs, "server_autofix:fix");
   return {
     fixedWorkflow: fixResult.workflow,
     fixes: extractAppliedFixes(fixResult)
@@ -41289,6 +41428,10 @@ and what service it connects to \u2014 don't attempt to build with a broken cred
 Part of the generation lifecycle: plan_workflow \u2192 test_credential(s) \u2192 build_workflow.
 NOT needed for editing or updating existing workflows (use update_workflow or partial_update_workflow).
 
+Note: plan_workflow works without n8n (catalog-only mode). To actually deploy
+workflows with build_workflow, N8N_API_KEY and N8N_API_URL must be configured.
+Without n8n, use plan_workflow for research and architecture planning only.
+
 Response modes:
 - "full": All research data within token_budget (default 8,000)
 - "summary" (default): Key fields within token_budget (default 4,000)
@@ -41340,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));
@@ -41399,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;
 }
@@ -41519,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";
@@ -42099,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();
@@ -42290,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)(),
@@ -42312,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;
 }
@@ -42336,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) {
@@ -42398,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}`;
@@ -42501,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) {
@@ -42635,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 {
@@ -42650,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);
@@ -42679,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));
   }
@@ -42733,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"]
         }
@@ -42759,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 {
@@ -42865,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));
 }
@@ -42879,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) {
@@ -42941,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",
@@ -43080,22 +43380,27 @@ 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 });
-    return toMCPResponse(createInternalError(correlationId, error instanceof Error ? error : new Error(String(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();
+    if (isDbConnectionError(originalError))
+      return makeDbConnectionErrorResponse();
+    return toMCPResponse(createInternalError(correlationId, originalError));
   }
 }
 async function handleUnknownType(credentialType, correlationId) {
@@ -43138,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 = `
@@ -43204,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) {
@@ -43228,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)
@@ -43239,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);
@@ -43297,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();
@@ -43477,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) {
@@ -43493,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
@@ -43501,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)
         });
       }
@@ -43513,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,
@@ -43570,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 {
@@ -43594,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) {
@@ -43618,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",
@@ -43641,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);
@@ -43676,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() {
@@ -43735,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) {
@@ -43757,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) {
@@ -43809,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;
@@ -43857,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);
@@ -43994,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];
@@ -44003,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)
@@ -44045,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))));
   }
 }
@@ -44109,40 +44414,8 @@ When values are collected, marks matching factory.gaps entries as resolved for a
   }
 };
 
-// dist/mcp/tools/handlers/shared/n8n-guard.js
-var SETUP_GUIDE_URL = "https://github.com/tsvika58/n8n-workflow-validator/blob/main/docs/AGENT_INSTALL.md";
-var OFFLINE_TOOLS = /* @__PURE__ */ new Set([
-  "validate_workflow",
-  "get_operation_schema",
-  "check_parameter",
-  "suggest_fix",
-  "list_operations",
-  "list_nodes",
-  "get_node_info",
-  "find_similar_pattern",
-  "get_session_metrics",
-  "get_credential_schema",
-  "setup_check"
-]);
-function requiresN8nApiKey(toolName) {
-  return !OFFLINE_TOOLS.has(toolName);
-}
-function makeN8nNotConfiguredError() {
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify({
-          error: `This tool requires n8n connection. Set N8N_API_URL and N8N_API_KEY in your MCP config. See: ${SETUP_GUIDE_URL}`
-        })
-      }
-    ],
-    isError: true
-  };
-}
-
 // dist/mcp/tools/handlers/setup-check.js
-var SETUP_GUIDE_URL2 = "https://github.com/tsvika58/n8n-workflow-validator/blob/main/docs/AGENT_INSTALL.md";
+var SETUP_GUIDE_URL2 = "https://github.com/tsvika58/p58-n8n/blob/main/docs/AGENT_INSTALL.md";
 var N8N_PROBE_TIMEOUT_MS = 2e3;
 var N8N_PROBE_PORTS = [5678, 5679];
 async function probeN8nUrl(url2) {
@@ -44332,13 +44605,18 @@ async function dispatchToolCall(name, args) {
   if (requiresN8nApiKey(name) && !process.env.N8N_API_KEY) {
     return makeN8nNotConfiguredError();
   }
-  if (tool.inputSchema && hasSchema(name)) {
-    const validation = validateToolInput(name, args);
-    if (!validation.success)
-      return createValidationErrorResponse(validation.error);
-    return tool.handler(validation.data);
+  incrementInflight();
+  try {
+    if (tool.inputSchema && hasSchema(name)) {
+      const validation = validateToolInput(name, args);
+      if (!validation.success)
+        return createValidationErrorResponse(validation.error);
+      return await tool.handler(validation.data);
+    }
+    return await tool.handler(args);
+  } finally {
+    decrementInflight();
   }
-  return tool.handler(args);
 }
 async function handleToolCall(name, args, sessionId = "default") {
   const startTime = Date.now();
@@ -44356,7 +44634,9 @@ function registerAllTools() {
     registerTool({ ...entry, inputSchema: toolSchemas[entry.name] });
   }
 }
-registerAllTools();
+
+// dist/mcp/server.js
+init_validatorPostgresClient();
 
 // dist/mcp/middleware/credential-redaction.js
 var MAX_DEPTH = 20;
@@ -44521,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,
@@ -44529,11 +44809,12 @@ var defaultDeps = {
 };
 async function runCleanup(serverName, deps) {
   try {
+    await waitForInflightRequests(5e3);
     await deps.shutdownPool();
     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) {
@@ -44542,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);
   };
@@ -44555,12 +44836,29 @@ 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})`);
   });
 }
 
 // dist/mcp/server.js
-var SETUP_GUIDE_URL3 = "https://github.com/tsvika58/n8n-workflow-validator/blob/main/docs/AGENT_INSTALL.md";
+var SETUP_GUIDE_URL3 = "https://github.com/tsvika58/p58-n8n/blob/main/docs/AGENT_INSTALL.md";
+var _serverInitialized = false;
+function isServerInitialized() {
+  return _serverInitialized;
+}
+function buildInitializingResponse() {
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        error: "SERVER_INITIALIZING",
+        message: "Server is still loading. Please retry in a moment.",
+        retryAfterMs: 2e3
+      })
+    }],
+    isError: true
+  };
+}
 function logStartupSummary(n8nConnected) {
   const apiKey = process.env.N8N_API_KEY;
   const n8nUrl = process.env.N8N_API_URL ?? process.env.N8N_API_BASE_URL ?? "http://localhost:5678/api/v1";
@@ -44605,6 +44903,9 @@ function toCallToolResult(response) {
 server.setRequestHandler(import_types22.CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
   try {
+    if (!_serverInitialized) {
+      return toCallToolResult(buildInitializingResponse());
+    }
     const response = await handleToolCall(name, args ?? {});
     return toCallToolResult(redactMCPResponse(response));
   } catch (error) {
@@ -44614,13 +44915,25 @@ server.setRequestHandler(import_types22.CallToolRequestSchema, async (request) =
 });
 async function main() {
   const transport = new import_stdio.StdioServerTransport();
+  const startMs = Date.now();
   await server.connect(transport);
+  console.error(`[INIT] MCP handshake complete in ${Date.now() - startMs}ms`);
+  registerAllTools();
+  _serverInitialized = true;
   const toolCount = getRegisteredTools().length;
-  console.error(`${config.SERVER_NAME} v${config.SERVER_VERSION} running on stdio (${toolCount} tools registered)`);
+  console.error(`[INIT] ${toolCount} tools registered in ${Date.now() - startMs}ms`);
   logStartupSummary(Boolean(process.env.N8N_API_KEY));
   registerShutdownHandlers(config.SERVER_NAME);
   void warmCredentialCache().catch(() => {
   });
+  if (process.env.P58_DATABASE_URL || process.env.MCP_DATABASE_URL) {
+    void warmValidatorPool().then(() => {
+      console.error("catalog: connected \u2713");
+    }).catch((err) => {
+      console.error(`catalog: WARNING \u2014 connection failed: ${err.message}`);
+      console.error("catalog: tools will retry on first use, but check P58_DATABASE_URL if errors persist");
+    });
+  }
 }
 main().catch((error) => {
   console.error("Server failed to start:", error);
@@ -44628,6 +44941,7 @@ main().catch((error) => {
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  isServerInitialized,
   logStartupSummary
 });
 /*! Bundled license information:

package/package.json

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