@path58/p58-n8n 0.2.16 → 0.2.17

package/dist/mcp/server.bundle.cjs

@@ -22145,6 +22145,7 @@ __export(n8n_api_adapter_exports, {
   deleteCredential: () => deleteCredential,
   deleteExecution: () => deleteExecution,
   deleteWorkflow: () => deleteWorkflow,
+  executeWorkflowViaRest: () => executeWorkflowViaRest,
   extractNodeDebugData: () => extractNodeDebugData,
   getCredentialWithData: () => getCredentialWithData,
   getExecution: () => getExecution,
@@ -22332,6 +22333,34 @@ async function activateWorkflow(config2, workflowId) {
     throw buildN8nError(error);
   }
 }
+async function executeWorkflowViaRest(config2, workflowId, workflowData) {
+  const email = process.env.N8N_USER_EMAIL;
+  const password = process.env.N8N_USER_PASSWORD;
+  if (!email || !password) {
+    throw new Error("N8N_USER_EMAIL and N8N_USER_PASSWORD are required for REST workflow execution");
+  }
+  const restBaseUrl = deriveInstanceBaseUrl(config2.baseUrl);
+  const cookie = await getRestSessionCookieWith(restBaseUrl, email, password);
+  const cfHeaders = {};
+  if (process.env.CF_ACCESS_CLIENT_ID && process.env.CF_ACCESS_CLIENT_SECRET) {
+    cfHeaders["CF-Access-Client-Id"] = process.env.CF_ACCESS_CLIENT_ID;
+    cfHeaders["CF-Access-Client-Secret"] = process.env.CF_ACCESS_CLIENT_SECRET;
+  }
+  const requestBody = workflowData && typeof workflowData === "object" && !Array.isArray(workflowData) ? { workflowData: { ...workflowData, id: workflowId } } : workflowData ? { workflowData } : {};
+  try {
+    const res = await axios_default.post(`${restBaseUrl}/rest/workflows/${workflowId}/run`, requestBody, {
+      timeout: config2.timeoutMs ?? 3e4,
+      headers: {
+        Cookie: cookie,
+        "Content-Type": "application/json",
+        ...cfHeaders
+      }
+    });
+    return res.data?.data ?? {};
+  } catch (error) {
+    throw buildN8nError(error);
+  }
+}
 async function deactivateWorkflow(config2, workflowId) {
   const client = createN8nHttpClient(config2);
   try {
@@ -41626,6 +41655,11 @@ async function buildNodeInfoResponse(nodeType, includeSections) {
     response.best_practices = node.best_practices ?? null;
     response.common_errors = node.common_errors ?? null;
     response.node_role = node.node_role ?? null;
+  } else {
+    const configHints = node.best_practices?.configuration;
+    if (Array.isArray(configHints) && configHints.length > 0) {
+      response.best_practices = { configuration: configHints };
+    }
   }
   if (nodeType === "n8n-nodes-base.code") {
     response.coding_reference = CODE_NODE_REFERENCE;
@@ -41740,14 +41774,15 @@ Returns:
 - properties: Node-level configuration properties (optional)
 - config_examples: Real-world configuration examples from validated workflows (optional)
 - version_info: Available type versions for this node (optional)
-- enrichment: best_practices (structured JSON), common_errors (structured JSON), node_role (string) \u2014 opt-in only, not included by default
+- enrichment: best_practices (structured JSON), common_errors (structured JSON), node_role (string) \u2014 best_practices.configuration is auto-included when non-empty; full enrichment is opt-in
 - agent_card: summary, primary_use_case, node_class, discovery_paths, search_triggers \u2014 opt-in only
 - ai_metadata: AI/LangChain node specialization \u2014 ai_type, supported_models, vendor, input/output types, chain_patterns, capabilities \u2014 opt-in only, returns null for non-AI nodes
 - docs: documentation facts with source references (fact_type, fact text, confidence, page_title, source_url) \u2014 opt-in only, returns empty array for nodes without doc coverage
 
 Use the 'include' parameter to request only specific sections for efficiency.
 If 'include' is omitted, default sections are returned (operations, credentials, properties, config_examples, version_info).
-The 'enrichment', 'agent_card', 'ai_metadata', and 'docs' sections are opt-in \u2014 request them explicitly when you need node intelligence context.
+best_practices.configuration is automatically included when non-empty \u2014 no opt-in needed for configuration hints.
+The 'enrichment' (full), 'agent_card', 'ai_metadata', and 'docs' sections are opt-in \u2014 request them explicitly when you need node intelligence context.
 
 Examples:
 - { "node_type": "n8n-nodes-base.httpRequest" } \u2192 Default sections (no enrichment)
@@ -41967,13 +42002,12 @@ Returns workflow_id and URL on success.`,
 
 // dist/mcp/tools/handlers/execute-workflow.js
 init_n8n_api_adapter();
-var import_node_crypto2 = require("node:crypto");
+var import_node_crypto = require("node:crypto");
 init_timeout();
 var import_logging34 = __toESM(require_logging(), 1);
 
 // dist/mcp/tools/handlers/test-workflow.js
 init_n8n_api_adapter();
-var import_node_crypto = require("node:crypto");
 init_timeout();
 var import_logging33 = __toESM(require_logging(), 1);
 init_adapters2();
@@ -41999,6 +42033,7 @@ var CREDENTIAL_HINTS = {
 var WEBHOOK_NOT_READY_HINT = "Webhook endpoint initialization delay \u2014 the workflow is deployed. Call test_workflow directly to retry the test.";
 var WEBHOOK_CONFLICT_HINT = "Webhook URL conflict \u2014 another workflow is using the same webhook path. Call list_workflows to find the conflicting workflow, then either delete_workflow the old one or use partial_update_workflow to change this webhook path. Do NOT use Bash.";
 var SCHEMA_FORMAT_HINT = "Input format error in operations payload. Check that array fields are arrays and string fields are strings. Review partial_update_workflow schema before retrying.";
+var MISSING_CREDENTIAL_TYPE_HINT = "Required credential type not available in n8n. Call list_credentials to check what credential types exist. If the required type is missing, call get_node_info on the failing node to check alternative auth modes (e.g. Service Account instead of OAuth2). If no compatible credential type exists, call build_workflow to rebuild using a webhook trigger or a node that uses an available credential type. Do NOT loop on partial_update_workflow \u2014 switch approach instead.";
 function toMessage(error) {
   if (!error)
     return "";
@@ -42053,6 +42088,9 @@ function isExecutionTimeout(msg) {
 function isUnknownNode(msg) {
   return msg.includes("unknown node") || msg.includes("node type") && msg.includes("not found") || msg.includes("node type missing") || msg.includes("import error") || msg.includes("not a known node") || msg.includes("node not found");
 }
+function isMissingCredentialType(msg) {
+  return msg.includes("missing required credential") || msg.includes("no credentials found for");
+}
 function isValidationError(msg) {
   return msg.includes("validation") || msg.includes("schema mismatch") || msg.includes("missing required") || msg.includes("missing field") || msg.includes("invalid parameter") || msg.includes("required property") || msg.includes("configuration issue") || // "N nodes have configuration issues" (n8n publish error)
   msg.includes("missing or invalid required");
@@ -42085,6 +42123,8 @@ function classifyFailure(error, context = {}) {
     return classify("config_error", context, context.nodeType);
   if (isSchemaError(msg))
     return classify("partial_fix_possible", context, void 0, SCHEMA_FORMAT_HINT);
+  if (isMissingCredentialType(msg))
+    return classify("credential_error", context, void 0, MISSING_CREDENTIAL_TYPE_HINT);
   if (isValidationError(msg))
     return classify("partial_fix_possible", context);
   if (isMultipleFailures(msg))
@@ -42291,15 +42331,6 @@ async function fetchWebhookExecution(apiConfig, workflowId) {
     return EMPTY_EXECUTION_DATA;
   }
 }
-function annotateCloneDebug(debug) {
-  const hasErrors = Object.values(debug).some((v) => v?.status === "error" || v?.status === "failed");
-  if (!hasErrors)
-    return debug;
-  return {
-    ...debug,
-    _clone_test_note: "IMPORTANT: Node errors in this debug data are CLONE ARTIFACTS. The clone uses shared credentials which may not work identically. The overall test PASSED \u2014 do NOT fix these node-level errors."
-  };
-}
 function extractExecutedNodeNames(execution) {
   const runData = execution?.data?.resultData?.runData;
   if (!runData || typeof runData !== "object")
@@ -42454,10 +42485,6 @@ async function executeWebhookTrigger(workflow, payload, timeoutMs, apiConfig) {
     }
   }
 }
-var CLONE_TRIGGER_KEYWORDS = ["trigger", "webhook", "cron", "schedule", "polling"];
-var WEBHOOK_INITIAL_WAIT_MS = 3e3;
-var WEBHOOK_MAX_ATTEMPTS = 5;
-var WEBHOOK_RETRY_DELAYS_MS = [1e3, 2e3, 4e3, 8e3];
 var RATE_LIMIT_MAX_RETRIES = 3;
 var RATE_LIMIT_RETRY_DELAYS_MS = [2e3, 4e3, 8e3];
 function isRateLimitError(error) {
@@ -42477,214 +42504,66 @@ function buildRateLimitedResult(triggerType, webhookPath) {
     next_step: "Credential is temporarily throttled. Do not debug with Bash. Wait 30s and retry test_workflow."
   };
 }
-async function retryCloneWebhookOn429(webhookPath, testPayload) {
-  for (let retry = 0; retry < RATE_LIMIT_MAX_RETRIES; retry++) {
-    const delay = RATE_LIMIT_RETRY_DELAYS_MS[retry];
-    import_logging33.logger.info("test_workflow: clone 429 retry", { attempt: retry + 1, delay, webhookPath });
-    await new Promise((r) => setTimeout(r, delay));
-    try {
-      await postWebhook(buildN8nHostUrl(), webhookPath, testPayload, 15e3);
-      return "success";
-    } catch (retryErr) {
-      if (!isRateLimitError(retryErr))
-        return "success";
-    }
-  }
-  return "exhausted";
-}
-function extractCredentialIds(nodes) {
-  const ids = /* @__PURE__ */ new Set();
-  for (const node of nodes) {
-    if (!node.credentials || typeof node.credentials !== "object")
-      continue;
-    for (const cred of Object.values(node.credentials)) {
-      const id = cred?.id;
-      if (typeof id === "string" && id)
-        ids.add(id);
-    }
-  }
-  return [...ids];
-}
-function extractCredentialNames(nodes) {
-  const names = [];
-  for (const node of nodes) {
-    if (!node.credentials || typeof node.credentials !== "object")
-      continue;
-    for (const [credType, cred] of Object.entries(node.credentials)) {
-      const name = cred?.name;
-      names.push(typeof name === "string" && name ? `${name} (${credType})` : credType);
-    }
-  }
-  return [...new Set(names)];
-}
-async function testViaClone(workflow, triggerType, testPayload, timeoutMs, apiConfig) {
-  const hasR2W = await hasRespondToWebhookNode(workflow);
-  if (hasR2W) {
-    return {
-      execution_id: null,
-      status: "error",
-      trigger_type: triggerType,
-      result_summary: "Cannot test via clone: workflow contains a Respond to Webhook node. Test this workflow using test_workflow with a direct webhook POST.",
-      next_step: "This workflow has a Respond to Webhook node. Call test_workflow directly \u2014 it handles the response mode correctly.",
-      failure_type: "config_error",
-      recovery_hint: "Node configuration error. Review the workflow structure \u2014 Respond to Webhook nodes require direct webhook testing."
-    };
-  }
-  const nodes = workflow.nodes ?? [];
-  const triggerNode = nodes.find((n) => {
-    const type = String(n?.type ?? "").toLowerCase();
-    return CLONE_TRIGGER_KEYWORDS.some((kw) => type.includes(kw));
-  });
-  const triggerName = triggerNode?.name ?? "Manual Trigger";
-  const triggerPosition = triggerNode?.position ?? [250, 300];
-  const webhookPath = `test-clone-${(0, import_node_crypto.randomUUID)().slice(0, 8)}`;
-  const cloneNodes = nodes.map((node) => {
-    if (node.name === triggerName) {
-      return {
-        parameters: { path: webhookPath, httpMethod: "POST", options: {} },
-        id: node.id ?? "webhook-clone",
-        name: "Webhook",
-        type: "n8n-nodes-base.webhook",
-        typeVersion: 2,
-        position: triggerPosition,
-        webhookId: (0, import_node_crypto.randomUUID)()
-      };
-    }
-    return node;
-  });
-  const connections = { ...workflow.connections ?? {} };
-  if (triggerName !== "Webhook" && connections[triggerName]) {
-    connections["Webhook"] = connections[triggerName];
-    delete connections[triggerName];
-  }
-  const cloneStartMs = Date.now();
+async function testViaDirectExecution(workflow, triggerType, _testPayload, timeoutMs, apiConfig) {
   const { calculateAdaptiveTimeout: calculateAdaptiveTimeout2 } = await Promise.resolve().then(() => (init_timeout(), timeout_exports));
   const adaptiveTimeout = calculateAdaptiveTimeout2(workflow);
   const effectiveTimeout = Math.max(timeoutMs, adaptiveTimeout);
   if (effectiveTimeout > timeoutMs) {
-    import_logging33.logger.info("test_workflow: adaptive timeout (clone)", {
+    import_logging33.logger.info("test_workflow: adaptive timeout (direct)", {
       workflowId: workflow.id,
       requested: timeoutMs,
       adaptive: adaptiveTimeout,
       effective: effectiveTimeout
     });
   }
-  let cloneId = null;
   try {
-    const createResult = await createWorkflow(apiConfig, `_tmp-test-${workflow.id}`, {
-      nodes: cloneNodes,
-      connections,
-      settings: workflow.settings ?? { executionOrder: "v1" }
-    });
-    cloneId = createResult.id;
-    const credentialIds = extractCredentialIds(nodes);
-    await shareCredentialsWithWorkflow(apiConfig, credentialIds, cloneId);
-    const activateResult = await activateWorkflow(apiConfig, cloneId);
-    if (!activateResult.active) {
-      const credNames = extractCredentialNames(nodes);
-      const credDetail = credNames.length > 0 ? ` Required credentials: ${credNames.join(", ")}.` : "";
+    const persistedWorkflow = await getWorkflow(apiConfig, workflow.id);
+    const runResult = await executeWorkflowViaRest(apiConfig, workflow.id, persistedWorkflow);
+    const executionId = runResult.executionId ?? runResult.id ?? null;
+    if (!executionId) {
       return {
         execution_id: null,
         status: "error",
         trigger_type: triggerType,
-        result_summary: `Test clone could not be activated.${credDetail} Verify these credentials are configured and valid in n8n Settings \u2192 Credentials.`,
-        next_step: credNames.length > 0 ? `Check that credentials (${credNames.join(", ")}) are valid in n8n Settings \u2192 Credentials, then retry.` : "Check n8n Settings \u2192 Credentials and verify all required credentials are configured.",
-        failure_type: "credential_error",
-        recovery_hint: "Authentication failed. Call list_credentials to verify credential exists and is correct type."
-      };
-    }
-    await new Promise((r) => setTimeout(r, WEBHOOK_INITIAL_WAIT_MS));
-    let webhookRegistrationFailed = false;
-    let rateLimitExhausted = false;
-    for (let attempt = 0; attempt < WEBHOOK_MAX_ATTEMPTS; attempt++) {
-      try {
-        if (attempt > 0)
-          await new Promise((r) => setTimeout(r, WEBHOOK_RETRY_DELAYS_MS[attempt - 1]));
-        await postWebhook(buildN8nHostUrl(), webhookPath, testPayload, 15e3);
-        break;
-      } catch (webhookErr) {
-        const errMsg = webhookErr instanceof Error ? webhookErr.message : String(webhookErr);
-        const is404 = errMsg.includes("404") || errMsg.includes("not found");
-        const isTimeout = errMsg.includes("timeout");
-        if (isTimeout)
-          break;
-        if (is404 && attempt < WEBHOOK_MAX_ATTEMPTS - 1) {
-          import_logging33.logger.debug("test_workflow: webhook 404, retrying activation race", { attempt, webhookPath });
-          continue;
-        }
-        if (is404) {
-          webhookRegistrationFailed = true;
-          break;
-        }
-        if (isRateLimitError(webhookErr)) {
-          const rlResult = await retryCloneWebhookOn429(webhookPath, testPayload);
-          if (rlResult === "exhausted") {
-            rateLimitExhausted = true;
-            break;
-          }
-          if (rlResult === "success")
-            break;
-        }
-        throw webhookErr;
-      }
-    }
-    if (rateLimitExhausted) {
-      return buildRateLimitedResult(triggerType, webhookPath);
-    }
-    if (webhookRegistrationFailed) {
-      return {
-        execution_id: null,
-        status: "error",
-        trigger_type: triggerType,
-        result_summary: `Clone webhook "POST ${webhookPath}" failed to register after 5 retries (~18s). n8n may be under heavy load from concurrent processes.`,
-        next_step: "Clone webhook failed to register after retries. Do NOT use Bash to retry manually. Report workflow as built-but-untested and stop.",
-        failure_type: "config_error",
-        recovery_hint: "Unclassified error. Review error message. Consider get_node_info for the failing node."
+        result_summary: "Direct REST execution did not return an execution ID.",
+        next_step: "Retry test_workflow once. If the workflow still does not return an execution ID, stop and inspect the n8n instance.",
+        failure_type: "execution_timeout",
+        recovery_hint: "Internal REST execution did not return an execution ID. Retry test_workflow once; avoid rebuilding unless the workflow structure is clearly wrong."
       };
     }
-    await new Promise((r) => setTimeout(r, 1e3));
-    const SAFETY_CAP_MS = 6e5;
-    const safetyDeadline = Date.now() + SAFETY_CAP_MS;
-    import_logging33.logger.info("test_workflow: polling for clone execution (state-driven)", {
+    const safetyDeadline = Date.now() + effectiveTimeout;
+    import_logging33.logger.info("test_workflow: polling for direct execution via REST run", {
       workflowId: workflow.id,
-      cloneId,
-      safetyCap: "10min"
+      executionId,
+      safetyCapMs: effectiveTimeout
     });
-    let runningExecId = null;
-    let latestExecId = null;
-    let cloneExecFailed = false;
+    let executionFailed = false;
     let nodeDebug;
     while (Date.now() < safetyDeadline) {
-      const execList = await listExecutions(apiConfig, { workflowId: cloneId, limit: 1 });
-      const latest = execList.executions[0];
-      if (latest?.id) {
-        runningExecId = latest.id;
-        const fullExec = await getExecution(apiConfig, latest.id, true);
-        if (fullExec.finished || fullExec.status === "error" || fullExec.status === "success") {
-          latestExecId = latest.id;
-          cloneExecFailed = fullExec.status === "error";
-          nodeDebug = extractNodeDebugData(fullExec);
-          break;
-        }
+      const fullExec = await getExecution(apiConfig, executionId, true);
+      if (fullExec.finished || fullExec.status === "error" || fullExec.status === "success") {
+        executionFailed = fullExec.status === "error";
+        nodeDebug = extractNodeDebugData(fullExec);
+        break;
       }
       await new Promise((r) => setTimeout(r, 1e3));
     }
-    if (runningExecId && !latestExecId) {
+    if (!nodeDebug && Date.now() >= safetyDeadline) {
       try {
-        await deleteExecution(apiConfig, runningExecId);
-        import_logging33.logger.warn("test_workflow: cancelled execution at safety cap (10min)", {
+        await deleteExecution(apiConfig, executionId);
+        import_logging33.logger.warn("test_workflow: cancelled direct execution at safety cap", {
           workflowId: workflow.id,
-          executionId: runningExecId
+          executionId
         });
       } catch (cancelErr) {
-        import_logging33.logger.warn("test_workflow: failed to cancel execution", {
+        import_logging33.logger.warn("test_workflow: failed to cancel direct execution", {
           workflowId: workflow.id,
-          executionId: runningExecId,
+          executionId,
           error: cancelErr
         });
       }
     }
-    if (latestExecId && cloneExecFailed && nodeDebug) {
+    if (executionFailed && nodeDebug) {
       const failedEntry = Object.entries(nodeDebug).find(([_, v]) => v?.status === "error");
       if (failedEntry) {
         const [nodeName, nodeData] = failedEntry;
@@ -42692,75 +42571,57 @@ async function testViaClone(workflow, triggerType, testPayload, timeoutMs, apiCo
         const nodeErrMsg = errInfo?.message ?? "Unknown error";
         const taxonomy = classifyFailure(errInfo ?? nodeErrMsg, { nodeName, httpCode: errInfo?.httpCode });
         return {
-          execution_id: latestExecId,
+          execution_id: executionId,
           status: "execution_error",
           trigger_type: triggerType,
           failed_node: nodeName,
           node_error: nodeErrMsg,
           node_error_description: errInfo?.description,
-          result_summary: `Clone test execution FAILED at node "${nodeName}": ${nodeErrMsg}`,
-          next_step: `Fix the "${nodeName}" node configuration in the original workflow (${workflow.id}), then retry test_workflow.`,
+          result_summary: `Workflow execution FAILED at node "${nodeName}": ${nodeErrMsg}`,
+          next_step: `Fix the "${nodeName}" node configuration in workflow ${workflow.id}, then retry test_workflow.`,
           ...taxonomy
         };
       }
     }
-    if (latestExecId && !cloneExecFailed) {
-      try {
-        await activateWorkflow(apiConfig, workflow.id);
-        import_logging33.logger.info("test_workflow: original activated after clone success", { originalId: workflow.id });
-      } catch {
-      }
+    if (!nodeDebug) {
+      return {
+        execution_id: executionId,
+        status: "error",
+        trigger_type: triggerType,
+        result_summary: `Workflow execution did not complete within timeout for workflow ${workflow.id}.`,
+        next_step: "Retry test_workflow once. If the workflow still times out, inspect the instance or run manually in n8n.",
+        failure_type: "execution_timeout",
+        recovery_hint: "Execution timed out before reaching a terminal state. Retry test_workflow once; avoid rebuilding unless the workflow structure is clearly wrong."
+      };
     }
-    const annotatedDebug = latestExecId && nodeDebug ? annotateCloneDebug(nodeDebug) : nodeDebug;
     return {
-      execution_id: latestExecId,
-      status: latestExecId ? "success" : "error",
+      execution_id: executionId,
+      status: "success",
       trigger_type: triggerType,
-      result_summary: latestExecId ? `Workflow tested via temporary clone (${triggerType} trigger cannot be executed directly \u2014 a webhook clone was used to test the workflow logic). Original workflow (${workflow.id}) is now active.` : `Clone execution did not complete within timeout. The workflow uses a ${triggerType} trigger which was tested via temporary webhook clone. Original workflow (${workflow.id}) was not modified.`,
-      next_step: latestExecId ? "Test passed. The workflow is working correctly and active. No further changes needed. Do NOT call get_execution_result \u2014 the test clone has been cleaned up." : `Clone timed out. Check if the workflow logic is correct, then call activate_workflow with workflow_id "${workflow.id}".`,
-      raw_result: annotatedDebug ? { node_debug: annotatedDebug } : void 0,
-      ...!latestExecId ? { failure_type: "execution_timeout", recovery_hint: "Execution timed out. Use get_execution_result to check status. Workflow may be too slow or waiting for external input." } : {}
+      result_summary: `Workflow tested successfully via direct REST execution on workflow ${workflow.id}.`,
+      next_step: "Test passed. The workflow is working correctly. No further changes needed.",
+      raw_result: nodeDebug ? { node_debug: nodeDebug } : void 0
     };
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
+    import_logging33.logger.warn("test_workflow: direct execution failed", {
+      workflowId: workflow.id,
+      error: errMsg
+    });
     return {
       execution_id: null,
       status: "error",
       trigger_type: triggerType,
-      result_summary: `Clone test failed: ${errMsg}. Original workflow (${workflow.id}) was not modified.`,
+      result_summary: `Direct workflow execution failed: ${errMsg}.`,
       ...classifyFailure(err, {})
     };
-  } finally {
-    if (cloneId) {
-      try {
-        await deleteWorkflow(apiConfig, cloneId);
-      } catch {
-      }
-    }
   }
 }
-function buildGuidanceResult(triggerType) {
-  const messages = {
-    manual: "Activate the workflow, then trigger it manually in the n8n UI.",
-    schedule: "Clone-based testing is disabled. Use execute_workflow to test schedule workflows on demand via clone-and-execute.",
-    polling: "Clone-based testing is disabled. Use execute_workflow to test polling workflows on demand via clone-and-execute.",
-    webhook: ""
-  };
-  return {
-    execution_id: null,
-    status: "guidance",
-    trigger_type: triggerType,
-    result_summary: messages[triggerType]
-  };
-}
 async function routeTestExecution(workflow, triggerType, testPayload, timeoutMs, apiConfig) {
   if (triggerType === "webhook") {
     return executeWebhookTrigger(workflow, testPayload, timeoutMs, apiConfig);
   }
-  if (process.env.CLONE_EXECUTION_ENABLED === "false") {
-    return buildGuidanceResult(triggerType);
-  }
-  return testViaClone(workflow, triggerType, testPayload, timeoutMs, apiConfig);
+  return testViaDirectExecution(workflow, triggerType, testPayload, timeoutMs, apiConfig);
 }
 var activeTests = /* @__PURE__ */ new Set();
 function buildConcurrentTestError(workflowId) {
@@ -42837,7 +42698,7 @@ and deactivates afterward. No need to construct URLs or use curl.
 
 Example: test_workflow({ workflow_id: "abc123", test_payload: { name: "Test", email: "test@example.com" } })
 
-**Schedule/manual/polling:** These triggers cannot be executed directly via API. The tool automatically creates a temporary webhook clone of the workflow to test the logic, then cleans up. The original workflow is NOT modified. Timeout adapts to workflow complexity.
+**Schedule/manual/polling:** The tool executes the saved workflow directly via n8n's internal REST run path and polls the real execution. This tests the actual workflow with minimal overhead.
 
 Returns: { execution_id, status, trigger_type, result_summary, http_status, webhook_response, execution_time_ms, nodes_executed, failed_node, node_error, node_error_description }
 When status is "execution_error": the webhook POST succeeded (HTTP 2xx) but the workflow execution failed. failed_node contains the node name, node_error the error message. Fix the node and retry.
@@ -42878,7 +42739,7 @@ Follow the recovery_hint instead of using Bash commands.`,
 
 // dist/mcp/tools/handlers/execute-workflow.js
 var DEFAULT_POLL_INTERVAL_MS = 500;
-var CLONE_TRIGGER_KEYWORDS2 = ["trigger", "webhook", "cron", "schedule", "polling"];
+var CLONE_TRIGGER_KEYWORDS = ["trigger", "webhook", "cron", "schedule", "polling"];
 function buildApiConfig3(timeoutMs) {
   return {
     baseUrl: process.env.N8N_API_URL ?? process.env.N8N_API_BASE_URL ?? "http://localhost:5678/api/v1",
@@ -42912,7 +42773,7 @@ function findTriggerNodeType(workflow) {
   const nodes = workflow.nodes ?? [];
   const trigger = nodes.find((n) => {
     const type = String(n?.type ?? "").toLowerCase();
-    return CLONE_TRIGGER_KEYWORDS2.some((kw) => type.includes(kw));
+    return CLONE_TRIGGER_KEYWORDS.some((kw) => type.includes(kw));
   });
   return trigger ? String(trigger.type ?? "") : null;
 }
@@ -43053,11 +42914,11 @@ function buildCloneWorkflow(original) {
   const nodes = original.nodes ?? [];
   const triggerNode = nodes.find((n) => {
     const type = String(n?.type ?? "").toLowerCase();
-    return CLONE_TRIGGER_KEYWORDS2.some((kw) => type.includes(kw));
+    return CLONE_TRIGGER_KEYWORDS.some((kw) => type.includes(kw));
   });
   const triggerName = triggerNode?.name ?? "Manual Trigger";
   const triggerPosition = triggerNode?.position ?? [250, 300];
-  const webhookPath = `clone-exec-${(0, import_node_crypto2.randomUUID)().slice(0, 8)}`;
+  const webhookPath = `clone-exec-${(0, import_node_crypto.randomUUID)().slice(0, 8)}`;
   const cloneNodes = nodes.map((node) => {
     if (node.name === triggerName) {
       return {
@@ -43071,7 +42932,7 @@ function buildCloneWorkflow(original) {
         type: "n8n-nodes-base.webhook",
         typeVersion: 2,
         position: triggerPosition,
-        webhookId: (0, import_node_crypto2.randomUUID)()
+        webhookId: (0, import_node_crypto.randomUUID)()
       };
     }
     return node;
@@ -50624,7 +50485,6 @@ function substituteDeprecatedAiNodes(nodes, connections) {
 
 // dist/mcp/tools/handlers/build-workflow.js
 init_n8n_api_adapter();
-var import_node_crypto3 = require("node:crypto");
 init_timeout();
 var import_logging67 = __toESM(require_logging(), 1);
 
@@ -51815,10 +51675,20 @@ var SKIP_NODE_TYPE_PATTERNS = [
 function isSkipNode(nodeType) {
   return SKIP_NODE_TYPE_PATTERNS.some((p) => nodeType.toLowerCase() === p.toLowerCase());
 }
+var CREDENTIAL_TYPE_ALIASES = {
+  // googleCalendarOAuth2Api: removed — real OAuth2 credential now provisioned
+  googleSheetsOAuth2Api: ["googleApi"],
+  googleDriveOAuth2Api: ["googleApi"],
+  googleDocsOAuth2Api: ["googleApi"],
+  googleAnalyticsOAuth2Api: ["googleApi"],
+  googleTasksOAuth2Api: ["googleApi"],
+  googleGmailOAuth2Api: ["googleApi"]
+};
 async function buildWirePlan(nodes, credentialCache) {
   const bundle = await initPublicCatalogBundle();
   const plans = [];
   const ambiguous = [];
+  const unwired = [];
   for (const node of nodes) {
     if (hasCredentials(node))
       continue;
@@ -51831,7 +51701,22 @@ async function buildWirePlan(nodes, credentialCache) {
     const credType = required[0].credential_type;
     const candidates = credentialCache.filter((c) => c.type === credType || c.type.toLowerCase() === credType.toLowerCase());
     if (candidates.length === 0) {
-      import_logging66.logger.debug("credential-auto-wire: no match for type", { node: node.name, credType });
+      const aliases = CREDENTIAL_TYPE_ALIASES[credType] ?? [];
+      let wiredViaAlias = false;
+      for (const aliasType of aliases) {
+        const aliasCandidates = credentialCache.filter((c) => c.type === aliasType);
+        if (aliasCandidates.length > 0) {
+          const picked2 = pickBestCredential(aliasCandidates, node.type);
+          plans.push({ nodeName: node.name, credentialType: aliasType, credential: picked2 });
+          import_logging66.logger.debug("credential-auto-wire: wired via alias", { node: node.name, credType, aliasType });
+          wiredViaAlias = true;
+          break;
+        }
+      }
+      if (!wiredViaAlias) {
+        import_logging66.logger.debug("credential-auto-wire: no match for type or aliases", { node: node.name, credType });
+        unwired.push({ node: node.name, required_type: credType });
+      }
       continue;
     }
     if (candidates.length === 1) {
@@ -51851,7 +51736,7 @@ async function buildWirePlan(nodes, credentialCache) {
       });
     }
   }
-  return { plans, ambiguous };
+  return { plans, ambiguous, unwired };
 }
 async function patchWorkflowCredentials(workflowId, config2, plans) {
   const workflow = await getWorkflow(config2, workflowId);
@@ -51875,9 +51760,9 @@ async function autoWireCredentials2(workflowId, deployedNodes, config2) {
   try {
     const credentialCache = await getPreloadedCredentials();
     if (credentialCache.length === 0) {
-      return { wired: [], ambiguous: [] };
+      return { wired: [], ambiguous: [], unwired: [] };
     }
-    const { plans, ambiguous } = await buildWirePlan(deployedNodes, credentialCache);
+    const { plans, ambiguous, unwired } = await buildWirePlan(deployedNodes, credentialCache);
     if (plans.length > 0) {
       await patchWorkflowCredentials(workflowId, config2, plans);
       import_logging66.logger.info("credential-auto-wire: wired credentials", {
@@ -51891,13 +51776,13 @@ async function autoWireCredentials2(workflowId, deployedNodes, config2) {
       credential: p.credential.name,
       type: p.credentialType
     }));
-    return { wired, ambiguous };
+    return { wired, ambiguous, unwired };
   } catch (err) {
     import_logging66.logger.warn("credential-auto-wire: failed (non-fatal), continuing without wiring", {
       workflowId,
       error: err instanceof Error ? err.message : String(err)
     });
-    return { wired: [], ambiguous: [] };
+    return { wired: [], ambiguous: [], unwired: [] };
   }
 }
 
@@ -51931,13 +51816,28 @@ function buildUnfixableIssues(validation) {
 }
 async function executeWebhookTest(path3, payload, timeoutMs, start) {
   try {
-    const out = await withTimeout(postWebhookTest(buildN8nHostUrl(), path3, payload ?? {}, timeoutMs), timeoutMs, "build_workflow:test");
+    const out = await withTimeout(postWebhookDetailed(buildN8nHostUrl(), path3, payload ?? {}, timeoutMs), timeoutMs, "build_workflow:test");
     return { success: true, output: out, duration_ms: Math.round(performance.now() - start), method: "webhook_inline" };
   } catch (err) {
     return { success: false, error: err instanceof Error ? err.message : String(err), duration_ms: Math.round(performance.now() - start), method: "webhook_inline" };
   }
 }
-var BUILD_CLONE_TRIGGER_KEYWORDS = ["trigger", "webhook", "cron", "schedule", "polling"];
+function buildCloneLifecycleSummary(startMs, telemetry) {
+  const summary = {};
+  if (telemetry.clone_created_at)
+    summary.clone_create_ms = telemetry.clone_created_at - startMs;
+  if (telemetry.clone_activated_at)
+    summary.clone_activate_ms = telemetry.clone_activated_at - startMs;
+  if (telemetry.clone_publish_ready_at)
+    summary.clone_publish_ready_ms = telemetry.clone_publish_ready_at - startMs;
+  if (telemetry.webhook_fired_at)
+    summary.webhook_fire_ms = telemetry.webhook_fired_at - startMs;
+  if (telemetry.first_poll_at)
+    summary.first_poll_ms = telemetry.first_poll_at - startMs;
+  if (telemetry.first_execution_seen_at)
+    summary.first_execution_seen_ms = telemetry.first_execution_seen_at - startMs;
+  return summary;
+}
 function buildCloneApiConfig(timeoutMs) {
   return {
     baseUrl: process.env.N8N_TEST_API_URL ?? process.env.N8N_API_URL ?? process.env.N8N_API_BASE_URL ?? "http://localhost:5678/api/v1",
@@ -51945,116 +51845,68 @@ function buildCloneApiConfig(timeoutMs) {
     timeoutMs
   };
 }
-function buildCloneSpec(nodes, connections, settings) {
-  const triggerNode = nodes.find((n) => {
-    const type = String(n?.type ?? "").toLowerCase();
-    return BUILD_CLONE_TRIGGER_KEYWORDS.some((kw) => type.includes(kw));
-  });
-  const triggerName = triggerNode?.name ?? "Manual Trigger";
-  const webhookPath = `build-test-${(0, import_node_crypto3.randomUUID)().slice(0, 8)}`;
-  const cloneNodes = nodes.map((node) => node.name === triggerName ? { parameters: { path: webhookPath, httpMethod: "POST", options: {} }, id: node.id ?? "webhook-clone", name: "Webhook", type: "n8n-nodes-base.webhook", typeVersion: 2, position: node.position ?? [250, 300], webhookId: (0, import_node_crypto3.randomUUID)() } : node);
-  const cloneConnections = { ...connections };
-  if (triggerName !== "Webhook" && cloneConnections[triggerName]) {
-    cloneConnections["Webhook"] = cloneConnections[triggerName];
-    delete cloneConnections[triggerName];
-  }
-  return { cloneNodes, cloneConnections, webhookPath };
-}
-async function postCloneWebhook(webhookPath, payload) {
-  for (let attempt = 0; attempt < 3; attempt++) {
-    try {
-      if (attempt > 0)
-        await new Promise((r) => setTimeout(r, 1e3 * attempt));
-      await postWebhook(buildN8nHostUrl(), webhookPath, payload, 15e3);
-      return;
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      if (msg.includes("timeout"))
-        return;
-      if (!msg.includes("404") || attempt === 2)
-        throw err;
-    }
-  }
-}
-async function pollCloneExecution(config2, cloneId, budgetMs) {
+async function pollDirectExecution(config2, executionId, budgetMs, telemetry, start) {
   const deadline = Date.now() + budgetMs;
   while (Date.now() < deadline) {
-    const list = await listExecutions(config2, { workflowId: cloneId, limit: 1 });
-    const latest = list.executions[0];
-    if (latest?.id) {
-      const full = await getExecution(config2, latest.id, true);
-      if (full.finished || full.status === "error" || full.status === "crashed") {
-        const hasError = full.status === "error" || full.status === "crashed" || full.error != null;
-        return { execId: latest.id, execStatus: hasError ? "error" : "success", nodeDebug: extractNodeDebugData(full) };
-      }
+    if (!telemetry.first_poll_at)
+      telemetry.first_poll_at = Date.now();
+    const full = await getExecution(config2, executionId, true);
+    if (!telemetry.first_execution_seen_at) {
+      telemetry.first_execution_seen_at = Date.now();
+      import_logging67.logger.info("build_workflow: direct execution became visible", {
+        executionId,
+        ...buildCloneLifecycleSummary(start, telemetry)
+      });
+    }
+    if (full.finished || full.status === "error" || full.status === "crashed" || full.status === "success") {
+      const hasError = full.status === "error" || full.status === "crashed" || full.error != null;
+      return { execId: executionId, execStatus: hasError ? "error" : "success", nodeDebug: extractNodeDebugData(full) };
     }
     await new Promise((r) => setTimeout(r, 500));
   }
   return { execId: null, execStatus: "timeout" };
 }
-async function runCloneExecution(config2, cloneId, webhookPath, testPayload, effectiveTimeout, start) {
-  const activated = await activateWorkflow(config2, cloneId);
-  if (!activated.active) {
-    return { success: false, error: "Clone could not be activated \u2014 check credentials", duration_ms: Math.round(performance.now() - start), method: "clone_and_execute" };
+async function runDirectExecution(config2, workflowId, persistedWorkflow, effectiveTimeout, start) {
+  const telemetry = { clone_created_at: Date.now() };
+  const runResult = await executeWorkflowViaRest(config2, workflowId, persistedWorkflow);
+  telemetry.webhook_fired_at = Date.now();
+  const executionId = runResult.executionId ?? runResult.id ?? null;
+  if (!executionId) {
+    return {
+      success: false,
+      error: "Direct execution did not return an execution ID via REST run",
+      duration_ms: Math.round(performance.now() - start),
+      method: "direct_execute"
+    };
   }
-  await new Promise((r) => setTimeout(r, 3e3));
-  const payload = testPayload ?? { test: true };
-  await postCloneWebhook(webhookPath, payload);
-  await new Promise((r) => setTimeout(r, 1500));
   const remaining = Math.max(effectiveTimeout - (performance.now() - start), 500);
-  const { execId, execStatus, nodeDebug } = await pollCloneExecution(config2, cloneId, remaining);
+  const { execId, execStatus, nodeDebug } = await pollDirectExecution(config2, executionId, remaining, telemetry, start);
   return {
     success: execStatus === "success",
-    output: execId ? `Clone test ${execStatus}` : "Clone test timed out",
+    output: execId ? `Direct test ${execStatus}` : "Direct test timed out",
+    error: execStatus === "timeout" ? "Direct execution timed out before reaching a terminal state" : void 0,
     duration_ms: Math.round(performance.now() - start),
     execution_id: execId ?? void 0,
     node_debug: nodeDebug,
-    method: "clone_and_execute"
+    method: "direct_execute"
   };
 }
-async function executeCloneTest(workflowId, testPayload, timeoutMs) {
+async function executeDirectTriggerTest(workflowId, timeoutMs) {
   const start = performance.now();
   const config2 = buildCloneApiConfig(timeoutMs);
   const workflow = await getWorkflow(config2, workflowId);
-  const nodes = workflow.nodes ?? [];
-  const hasR2W = await hasRespondToWebhookNode(workflow);
-  if (hasR2W) {
-    return {
-      success: false,
-      error: "Cannot test via clone: workflow contains a Respond to Webhook node. Use direct webhook POST (test_workflow) instead.",
-      duration_ms: Math.round(performance.now() - start),
-      method: "clone_and_execute"
-    };
-  }
-  const connections = workflow.connections ?? {};
-  const { cloneNodes, cloneConnections, webhookPath } = buildCloneSpec(nodes, connections, workflow.settings);
   const { calculateAdaptiveTimeout: calculateAdaptiveTimeout2 } = await Promise.resolve().then(() => (init_timeout(), timeout_exports));
   const adaptiveTimeout = calculateAdaptiveTimeout2(workflow);
   const effectiveTimeout = Math.max(timeoutMs, adaptiveTimeout);
-  let cloneId = null;
   try {
-    const created = await createWorkflow(config2, `_tmp-build-test-${workflowId}`, {
-      nodes: cloneNodes,
-      connections: cloneConnections,
-      settings: workflow.settings ?? { executionOrder: "v1" }
-    });
-    cloneId = created.id;
-    return await runCloneExecution(config2, cloneId, webhookPath, testPayload, effectiveTimeout, start);
+    return await runDirectExecution(config2, workflowId, workflow, effectiveTimeout, start);
   } catch (err) {
-    return { success: false, error: `Clone test failed: ${err.message}`, duration_ms: Math.round(performance.now() - start), method: "clone_and_execute" };
-  } finally {
-    if (cloneId) {
-      try {
-        await deactivateWorkflow(config2, cloneId).catch(() => {
-        });
-      } catch {
-      }
-      try {
-        await deleteWorkflow(config2, cloneId).catch(() => {
-        });
-      } catch {
-      }
-    }
+    return {
+      success: false,
+      error: `Direct test failed: ${err.message}`,
+      duration_ms: Math.round(performance.now() - start),
+      method: "direct_execute"
+    };
   }
 }
 async function retryWebhookTest(path3, testPayload, timeoutMs, start) {
@@ -52093,12 +51945,12 @@ async function runTestStep(workflow, workflowId, testPayload, timeoutMs) {
         import_logging67.logger.info("build_workflow: Respond to Webhook detected, retrying direct POST (no clone)", { workflowId });
         return retryWebhookTest(path3, testPayload, timeoutMs, start);
       }
-      import_logging67.logger.info("build_workflow: webhook 404, falling back to clone-and-execute", { workflowId });
-      return executeCloneTest(workflowId, testPayload, timeoutMs);
+      import_logging67.logger.info("build_workflow: webhook 404, retrying direct POST with backoff", { workflowId });
+      return retryWebhookTest(path3, testPayload, timeoutMs, start);
     }
     return testResult;
   }
-  return executeCloneTest(workflowId, testPayload, timeoutMs);
+  return executeDirectTriggerTest(workflowId, timeoutMs);
 }
 async function deployWorkflow2(workflow, activate, timeoutMs) {
   const config2 = buildApiConfig10(timeoutMs);
@@ -52563,13 +52415,10 @@ function buildRichResponseFields(result, cleanedArgs, exec) {
     };
   } else if (exec?.tested && !exec.success) {
     parts.push(`Test: \u274C failed \u2014 ${exec.error ?? "unknown error"}`);
-    const taxonomy = classifyFailure(exec.error ?? "", {});
     result.test_result = {
       status: "error",
       execution_id: exec.execution_id,
-      duration_ms: exec.duration_ms,
-      failure_type: taxonomy.failure_type,
-      recovery_hint: taxonomy.recovery_hint
+      duration_ms: exec.duration_ms
     };
   } else {
     result.test_result = { status: "skipped" };
@@ -52900,11 +52749,9 @@ async function handleBuildWorkflowStandard(args, correlationId, startTime) {
         result.next_step = `Workflow deployed and tested successfully (${exec.method}). Ready for production use.`;
       } else if (exec?.tested && !exec.success) {
         const taxonomy = classifyFailure(exec.error ?? "", {});
-        const retryHint = hasWebhookTrigger ? `Call test_workflow with workflow_id "${wfId}" and test_payload: {\u2026} to retry with a custom webhook payload.` : `Call execute_workflow with workflow_id "${wfId}" to retry after fixing.`;
+        const retryHint = exec.error?.includes("no execution became visible") || exec.error?.includes("did not return an execution ID") ? `Call test_workflow with workflow_id "${wfId}" to retry once the n8n instance is responsive.` : hasWebhookTrigger ? `Call test_workflow with workflow_id "${wfId}" and test_payload: {\u2026} to retry with a custom webhook payload.` : `Call execute_workflow with workflow_id "${wfId}" to retry after fixing.`;
         const failureCtx = taxonomy.failure_type !== "config_error" ? `${taxonomy.recovery_hint} ` : "";
         result.next_step = `Workflow deployed but test FAILED [${taxonomy.failure_type}]: ${exec.error ?? "unknown error"}. ${failureCtx}${retryHint}`;
-        result.failure_type = taxonomy.failure_type;
-        result.recovery_hint = taxonomy.recovery_hint;
       } else if (hasWebhookTrigger) {
         result.next_step = `If you have not yet tested this workflow, call test_workflow with workflow_id "${wfId}" and test_payload: { /* your webhook JSON */ }. If test_workflow already returned test_passed=true and you have NOT called partial_update_workflow since, the workflow is complete \u2014 call activate_workflow. Do NOT use Bash/curl \u2014 test_workflow handles activation, URL resolution, and response capture automatically.`;
       } else {
@@ -52946,11 +52793,6 @@ CRITICAL RULES:
 Pipeline: assemble \u2192 validate (L1-L6 + 33 fixers) \u2192 deploy to n8n.
 Returns: workflow_id, workflow_url, validation changelog, optional test result.
 
-When test_result.status is "error", the response also includes:
-- failure_type: one of "config_error", "credential_error", "rate_limited", "execution_timeout", "partial_fix_possible", "rebuild_required"
-- recovery_hint: specific guidance on what to do next
-Follow the recovery_hint instead of using Bash commands.
-
 Examples:
 - Fused: { description: "Send a Telegram message when a new Gmail arrives" }
 - Schedule: { name: "Daily Slack", nodes: [{name: "Schedule", type: "n8n-nodes-base.scheduleTrigger", parameters: {rule: {interval: [{field: "cronExpression", expression: "0 8 * * *"}]}}}, {name: "Slack", type: "n8n-nodes-base.slack", operation: "postMessage", credential_id: "abc"}], connections: [{from: "Schedule", to: "Slack"}] }
@@ -54324,7 +54166,7 @@ connection problems.`,
 var import_node_fs2 = require("node:fs");
 var import_node_os2 = require("node:os");
 var import_node_path2 = require("node:path");
-var import_node_crypto4 = require("node:crypto");
+var import_node_crypto2 = require("node:crypto");
 var import_logging73 = __toESM(require_logging(), 1);
 init_p58_config();
 var API_BASE_URL2 = "https://p58-n8n.path58.com";
@@ -54352,7 +54194,7 @@ async function callValidateEndpoint(token) {
 function writeConfigAtomic(cfg) {
   const configDir = (0, import_node_path2.dirname)(ACTIVATE_CONFIG_FILE);
   (0, import_node_fs2.mkdirSync)(configDir, { recursive: true });
-  const tmpFile = (0, import_node_path2.join)((0, import_node_os2.tmpdir)(), `p58-config-${(0, import_node_crypto4.randomUUID)()}.json`);
+  const tmpFile = (0, import_node_path2.join)((0, import_node_os2.tmpdir)(), `p58-config-${(0, import_node_crypto2.randomUUID)()}.json`);
   (0, import_node_fs2.writeFileSync)(tmpFile, JSON.stringify(cfg, null, 2), { mode: 384 });
   (0, import_node_fs2.renameSync)(tmpFile, ACTIVATE_CONFIG_FILE);
 }