@kairos-sdk/core 0.2.0 → 0.3.0

package/dist/mcp-server.cjs

@@ -0,0 +1,1936 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/mcp-server.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_zod = require("zod");
+
+// src/library/file-library.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var import_node_os = require("os");
+
+// src/utils/uuid.ts
+function generateUUID() {
+  return crypto.randomUUID();
+}
+
+// src/utils/thresholds.ts
+var DIRECT_THRESHOLD = 0.92;
+var REFERENCE_THRESHOLD = 0.72;
+function scoreToMode(score) {
+  if (score >= DIRECT_THRESHOLD) return "direct";
+  if (score >= REFERENCE_THRESHOLD) return "reference";
+  return "scratch";
+}
+
+// src/library/scorer.ts
+var WEIGHTS = {
+  tfidf: 0.35,
+  nodeFingerprint: 0.3,
+  outcome: 0.2,
+  deploy: 0.15
+};
+var NODE_KEYWORDS = {
+  slack: ["slack", "slackApi"],
+  email: ["gmail", "sendEmail", "emailSend", "emailReadImap"],
+  webhook: ["webhook", "webhookTrigger"],
+  schedule: ["scheduleTrigger", "cron"],
+  http: ["httpRequest"],
+  sheets: ["googleSheets"],
+  github: ["github", "githubTrigger"],
+  telegram: ["telegram", "telegramTrigger"],
+  ai: ["agent", "openAi", "lmChatOpenAi", "lmChatAnthropic", "chainLlm", "chainSummarization"],
+  memory: ["memoryBufferWindow", "memoryXata", "memoryPostgres"],
+  vector: ["vectorStoreInMemory", "vectorStorePinecone", "vectorStoreQdrant"],
+  database: ["postgres", "mySql", "redis", "mongoDb"],
+  airtable: ["airtable"],
+  notion: ["notion"],
+  s3: ["awsS3"],
+  code: ["code"],
+  merge: ["merge"],
+  switch: ["switch"],
+  if: ["if"],
+  wait: ["wait"],
+  rss: ["rssFeedRead", "rssFeedReadTrigger"],
+  form: ["formTrigger"],
+  set: ["set"],
+  split: ["splitInBatches"],
+  filter: ["filter"],
+  telegram_trigger: ["telegramTrigger"],
+  stripe: ["stripe"]
+};
+function extractQueryFingerprint(description) {
+  const lower = description.toLowerCase();
+  const matches = /* @__PURE__ */ new Set();
+  for (const [keyword, nodeTypes] of Object.entries(NODE_KEYWORDS)) {
+    if (lower.includes(keyword)) {
+      for (const nt of nodeTypes) matches.add(nt);
+    }
+  }
+  if (/\bevery\b|\bdaily\b|\bhourly\b|\bweekly\b|\bmonthly\b|\bcron\b|\bschedule\b|\bat \d/.test(lower)) {
+    matches.add("scheduleTrigger");
+  }
+  if (/\bwebhook\b|\breceive\b.*\bpost\b|\bpost\b.*\brequest\b/.test(lower)) {
+    matches.add("webhook");
+  }
+  if (/\bchat\b|\bchatbot\b|\bconversation\b/.test(lower)) {
+    matches.add("chatTrigger");
+  }
+  if (/\bai\b|\bllm\b|\bgpt\b|\bclaude\b|\bagent\b|\bsummariz/.test(lower)) {
+    matches.add("agent");
+  }
+  return matches;
+}
+function extractWorkflowFingerprint(w) {
+  const fp = /* @__PURE__ */ new Set();
+  for (const node of w.workflow.nodes) {
+    const bare = node.type.split(".").pop() ?? "";
+    fp.add(bare);
+  }
+  return fp;
+}
+function jaccardSimilarity(a, b) {
+  if (a.size === 0 && b.size === 0) return 0;
+  let intersection = 0;
+  for (const item of a) {
+    if (b.has(item)) intersection++;
+  }
+  const union = a.size + b.size - intersection;
+  return union > 0 ? intersection / union : 0;
+}
+function outcomeScore(w) {
+  const stats = w.outcomeStats;
+  if (!stats || stats.totalUses === 0) return 0.5;
+  const passRate = stats.firstTryPasses / stats.totalUses;
+  const avgAttempts = stats.totalAttempts / stats.totalUses;
+  const attemptPenalty = Math.max(0, 1 - (avgAttempts - 1) * 0.3);
+  return passRate * 0.6 + attemptPenalty * 0.4;
+}
+function deployScore(w) {
+  return 1 + Math.log(w.deployCount + 1) * 0.1;
+}
+function hybridScore(queryTokens, queryDescription, workflows, docTokenArrays, idf) {
+  const queryFp = extractQueryFingerprint(queryDescription);
+  const ceiling = queryTokens.reduce((sum, qt) => sum + (idf.get(qt) ?? 0), 0) || 1;
+  return workflows.map((w, i) => {
+    const docTokens = docTokenArrays[i];
+    let tfidfRaw = 0;
+    const docFreq = /* @__PURE__ */ new Map();
+    for (const t of docTokens) {
+      docFreq.set(t, (docFreq.get(t) ?? 0) + 1);
+    }
+    for (const qt of queryTokens) {
+      const tf = docTokens.length > 0 ? (docFreq.get(qt) ?? 0) / docTokens.length : 0;
+      const idfVal = idf.get(qt) ?? 0;
+      tfidfRaw += tf * idfVal;
+    }
+    const tfidf = Math.min(tfidfRaw / ceiling, 1);
+    const workflowFp = extractWorkflowFingerprint(w);
+    const nodeFingerprint = queryFp.size > 0 ? jaccardSimilarity(queryFp, workflowFp) : 0;
+    const outcome = outcomeScore(w);
+    const deploy = Math.min(deployScore(w), 1.5) / 1.5;
+    const score = Math.min(
+      WEIGHTS.tfidf * tfidf + WEIGHTS.nodeFingerprint * nodeFingerprint + WEIGHTS.outcome * outcome + WEIGHTS.deploy * deploy,
+      1
+    );
+    return {
+      workflow: w,
+      score,
+      signals: { tfidf, nodeFingerprint, outcome, deploy }
+    };
+  });
+}
+
+// src/library/cluster.ts
+function getFingerprint(w) {
+  return w.workflow.nodes.map((n) => n.type.split(".").pop() ?? "").sort();
+}
+function fingerprintKey(fp) {
+  return fp.join("|");
+}
+function describePattern(fp) {
+  const triggers = fp.filter((n) => /trigger/i.test(n));
+  const outputs = fp.filter((n) => /slack|gmail|email|telegram|sheets|airtable|notion/i.test(n));
+  const ai = fp.filter((n) => /agent|openai|anthropic|chain|memory/i.test(n));
+  const core = fp.filter((n) => /httpRequest|code|merge|switch|if|set|filter/i.test(n));
+  const parts = [];
+  if (triggers.length > 0) parts.push(triggers[0]);
+  if (ai.length > 0) parts.push("AI");
+  if (core.length > 0) parts.push(core.slice(0, 2).join("+"));
+  if (outputs.length > 0) parts.push(outputs[0]);
+  return parts.length > 0 ? parts.join(" \u2192 ") : fp.slice(0, 3).join(" \u2192 ");
+}
+function clusterWorkflows(workflows) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const w of workflows) {
+    const fp = getFingerprint(w);
+    const key = fingerprintKey(fp);
+    const existing = groups.get(key);
+    if (existing) {
+      existing.push(w);
+    } else {
+      groups.set(key, [w]);
+    }
+  }
+  const clusters = [];
+  for (const [, members] of groups) {
+    if (members.length === 0) continue;
+    const fp = getFingerprint(members[0]);
+    const withStats = members.filter((m) => m.outcomeStats && m.outcomeStats.totalUses > 0);
+    let avgFirstTryPassRate = 0;
+    let avgAttempts = 0;
+    if (withStats.length > 0) {
+      avgFirstTryPassRate = withStats.reduce((sum, m) => {
+        const s = m.outcomeStats;
+        return sum + s.firstTryPasses / s.totalUses;
+      }, 0) / withStats.length;
+      avgAttempts = withStats.reduce((sum, m) => {
+        const s = m.outcomeStats;
+        return sum + s.totalAttempts / s.totalUses;
+      }, 0) / withStats.length;
+    }
+    const ruleCounts = /* @__PURE__ */ new Map();
+    let totalFailureInstances = 0;
+    for (const m of withStats) {
+      const rules = m.outcomeStats.failedRules;
+      for (const [rule, count] of Object.entries(rules)) {
+        const r = parseInt(rule, 10);
+        ruleCounts.set(r, (ruleCounts.get(r) ?? 0) + count);
+        totalFailureInstances += count;
+      }
+    }
+    const commonFailedRules = [...ruleCounts.entries()].map(([rule, count]) => ({
+      rule,
+      frequency: totalFailureInstances > 0 ? count / totalFailureInstances : 0
+    })).filter((r) => r.frequency >= 0.1).sort((a, b) => b.frequency - a.frequency);
+    clusters.push({
+      pattern: describePattern(fp),
+      fingerprint: fp,
+      members,
+      avgFirstTryPassRate,
+      avgAttempts,
+      commonFailedRules
+    });
+  }
+  return clusters.sort((a, b) => b.members.length - a.members.length);
+}
+function rerank(candidates, clusters) {
+  const clusterMap = /* @__PURE__ */ new Map();
+  for (const cluster of clusters) {
+    for (const member of cluster.members) {
+      clusterMap.set(member.id, cluster);
+    }
+  }
+  return candidates.map((c) => {
+    const cluster = clusterMap.get(c.workflow.id);
+    let boost = 0;
+    if (cluster && cluster.avgFirstTryPassRate > 0) {
+      boost = (cluster.avgFirstTryPassRate - 0.5) * 0.1;
+    }
+    if (cluster && cluster.commonFailedRules.length > 0) {
+      boost -= cluster.commonFailedRules.length * 0.02;
+    }
+    return {
+      workflow: c.workflow,
+      score: Math.max(0, Math.min(1, c.score + boost)),
+      ...cluster ? { clusterPattern: cluster.pattern } : {}
+    };
+  }).sort((a, b) => b.score - a.score);
+}
+
+// src/library/file-library.ts
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length > 2);
+}
+function buildSearchCorpus(w) {
+  const nodeTokens = w.workflow.nodes.map((n) => {
+    const bare = n.type.split(".").pop() ?? "";
+    const spaced = bare.replace(/([A-Z])/g, " $1").trim().toLowerCase();
+    return `${bare} ${spaced}`;
+  });
+  return `${w.description} ${w.workflow.name} ${w.tags.join(" ")} ${nodeTokens.join(" ")}`;
+}
+var MAX_LIBRARY_SIZE = 500;
+var FileLibrary = class {
+  dir;
+  workflows = [];
+  initPromise = null;
+  writeQueue = Promise.resolve();
+  constructor(dir) {
+    this.dir = dir ?? (0, import_node_path.join)((0, import_node_os.homedir)(), ".kairos", "library");
+  }
+  async initialize() {
+    if (!this.initPromise) {
+      this.initPromise = this.doInitialize();
+    }
+    return this.initPromise;
+  }
+  async doInitialize() {
+    await (0, import_promises.mkdir)(this.dir, { recursive: true });
+    const indexPath = (0, import_node_path.join)(this.dir, "index.json");
+    try {
+      const raw = await (0, import_promises.readFile)(indexPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (!Array.isArray(parsed)) {
+        this.workflows = [];
+      } else {
+        this.workflows = parsed.filter(
+          (item) => typeof item === "object" && item !== null && typeof item.id === "string" && typeof item.description === "string" && typeof item.workflow === "object" && item.workflow !== null && Array.isArray(item.workflow.nodes)
+        );
+      }
+    } catch {
+      this.workflows = [];
+    }
+  }
+  async search(description, options) {
+    const searchable = this.workflows.filter((w) => w.trustLevel !== "blocked");
+    if (searchable.length === 0) return [];
+    const limit = options?.limit ?? 3;
+    const queryTokens = tokenize(description);
+    if (queryTokens.length === 0) return [];
+    const docTokenArrays = searchable.map((w) => tokenize(buildSearchCorpus(w)));
+    const docTokenSets = docTokenArrays.map((tokens) => new Set(tokens));
+    const docCount = searchable.length;
+    const idf = /* @__PURE__ */ new Map();
+    const allTokens = new Set(queryTokens);
+    for (const token of allTokens) {
+      const docsWithToken = docTokenSets.filter((d) => d.has(token)).length;
+      idf.set(token, Math.log((docCount + 1) / (docsWithToken + 1)) + 1);
+    }
+    const scored = hybridScore(queryTokens, description, searchable, docTokenArrays, idf).filter((m) => m.score > 0).sort((a, b) => b.score - a.score);
+    const clusters = clusterWorkflows(searchable);
+    const reranked = rerank(scored, clusters).slice(0, limit);
+    const results = reranked.map((m) => {
+      return { workflow: m.workflow, score: m.score, mode: scoreToMode(m.score) };
+    });
+    if (results.length > 0) {
+      for (const r of results) {
+        r.workflow.timesRetrieved = (r.workflow.timesRetrieved ?? 0) + 1;
+      }
+      this.persist();
+    }
+    return results;
+  }
+  async save(workflow, metadata) {
+    const id = generateUUID();
+    const failurePatterns = this.deduplicateFailurePatterns(metadata.failurePatterns);
+    const stored = {
+      id,
+      workflow,
+      description: metadata.description,
+      tags: metadata.tags ?? [],
+      platform: metadata.platform ?? "n8n",
+      deployCount: 0,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...failurePatterns?.length ? { failurePatterns } : {},
+      ...metadata.sourceWorkflowIds?.length ? { sourceWorkflowIds: metadata.sourceWorkflowIds } : {},
+      ...metadata.generationMode ? { generationMode: metadata.generationMode } : {},
+      ...metadata.topMatchScore != null ? { topMatchScore: metadata.topMatchScore } : {},
+      ...metadata.generationAttempts != null ? { generationAttempts: metadata.generationAttempts } : {},
+      ...metadata.credentialsNeeded?.length ? { credentialsNeeded: metadata.credentialsNeeded } : {},
+      ...metadata.sourceKind ? { sourceKind: metadata.sourceKind } : {},
+      ...metadata.sourceId ? { sourceId: metadata.sourceId } : {},
+      ...metadata.sourceUrl ? { sourceUrl: metadata.sourceUrl } : {},
+      ...metadata.trustLevel ? { trustLevel: metadata.trustLevel } : {}
+    };
+    this.workflows.push(stored);
+    if (this.workflows.length > MAX_LIBRARY_SIZE) {
+      this.workflows.sort((a, b) => (b.deployCount ?? 1) - (a.deployCount ?? 1));
+      this.workflows = this.workflows.slice(0, MAX_LIBRARY_SIZE);
+    }
+    await this.persist();
+    return id;
+  }
+  async recordDeployment(id) {
+    const w = this.workflows.find((w2) => w2.id === id);
+    if (w) {
+      w.deployCount++;
+      w.lastDeployedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.persist();
+    }
+  }
+  async recordOutcome(id, outcome) {
+    const w = this.workflows.find((w2) => w2.id === id);
+    if (!w) return;
+    if (outcome.mode === "direct") {
+      w.timesUsedAsDirect = (w.timesUsedAsDirect ?? 0) + 1;
+    } else {
+      w.timesUsedAsReference = (w.timesUsedAsReference ?? 0) + 1;
+    }
+    const stats = w.outcomeStats ?? { totalUses: 0, totalAttempts: 0, firstTryPasses: 0, failedRules: {} };
+    stats.totalUses++;
+    stats.totalAttempts += outcome.attempts;
+    if (outcome.firstTryPass) stats.firstTryPasses++;
+    for (const rule of outcome.failedRules) {
+      const key = String(rule);
+      stats.failedRules[key] = (stats.failedRules[key] ?? 0) + 1;
+    }
+    w.outcomeStats = stats;
+    await this.persist();
+  }
+  async drain() {
+    await this.writeQueue;
+  }
+  async get(id) {
+    return this.workflows.find((w) => w.id === id) ?? null;
+  }
+  async list(filters) {
+    let result = this.workflows;
+    if (filters?.platform) {
+      result = result.filter((w) => w.platform === filters.platform);
+    }
+    if (filters?.tags && filters.tags.length > 0) {
+      result = result.filter((w) => filters.tags.some((t) => w.tags.includes(t)));
+    }
+    return result;
+  }
+  deduplicateFailurePatterns(patterns) {
+    if (!patterns?.length) return void 0;
+    const map = /* @__PURE__ */ new Map();
+    for (const fp of patterns) {
+      const existing = map.get(fp.rule);
+      if (existing) {
+        existing.occurrences++;
+      } else {
+        map.set(fp.rule, { rule: fp.rule, message: fp.message, occurrences: 1 });
+      }
+    }
+    return [...map.values()];
+  }
+  persist() {
+    this.writeQueue = this.writeQueue.then(async () => {
+      const indexPath = (0, import_node_path.join)(this.dir, "index.json");
+      const tmpPath = `${indexPath}.tmp`;
+      await (0, import_promises.writeFile)(tmpPath, JSON.stringify(this.workflows, null, 2), "utf-8");
+      await (0, import_promises.rename)(tmpPath, indexPath);
+    });
+    return this.writeQueue;
+  }
+};
+
+// src/validation/registry.ts
+var DEFAULT_REGISTRY = [
+  // Trigger nodes
+  { type: "n8n-nodes-base.manualTrigger", safeTypeVersions: [1], requiredParams: [], isTrigger: true },
+  { type: "n8n-nodes-base.scheduleTrigger", safeTypeVersions: [1, 1.1, 1.2], requiredParams: [], isTrigger: true },
+  { type: "n8n-nodes-base.webhook", safeTypeVersions: [1, 1.1, 2], requiredParams: ["httpMethod", "path"], isTrigger: true },
+  { type: "n8n-nodes-base.formTrigger", safeTypeVersions: [1, 2, 2.1, 2.2], requiredParams: [], isTrigger: true },
+  { type: "n8n-nodes-base.emailReadImap", safeTypeVersions: [2], requiredParams: [], credentialType: "imap", isTrigger: true },
+  { type: "n8n-nodes-base.errorTrigger", safeTypeVersions: [1], requiredParams: [], isTrigger: true },
+  { type: "n8n-nodes-base.executeWorkflowTrigger", safeTypeVersions: [1, 1.1], requiredParams: [], isTrigger: true },
+  { type: "n8n-nodes-base.gmailTrigger", safeTypeVersions: [1, 1.1, 1.2], requiredParams: [], credentialType: "gmailOAuth2", isTrigger: true },
+  { type: "n8n-nodes-base.googleDriveTrigger", safeTypeVersions: [1], requiredParams: [], credentialType: "googleDriveOAuth2Api", isTrigger: true },
+  { type: "n8n-nodes-base.googleSheetsTrigger", safeTypeVersions: [1], requiredParams: [], credentialType: "googleSheetsTriggerOAuth2Api", isTrigger: true },
+  { type: "n8n-nodes-base.slackTrigger", safeTypeVersions: [1], requiredParams: [], credentialType: "slackApi", isTrigger: true },
+  { type: "n8n-nodes-base.telegramTrigger", safeTypeVersions: [1, 1.1, 1.2], requiredParams: [], credentialType: "telegramApi", isTrigger: true },
+  { type: "n8n-nodes-base.githubTrigger", safeTypeVersions: [1], requiredParams: [], credentialType: "githubApi", isTrigger: true },
+  { type: "n8n-nodes-base.stripeTrigger", safeTypeVersions: [1], requiredParams: [], credentialType: "stripeApi", isTrigger: true },
+  { type: "n8n-nodes-base.airtableTrigger", safeTypeVersions: [1], requiredParams: [], credentialType: "airtableTokenApi", isTrigger: true },
+  { type: "n8n-nodes-base.notionTrigger", safeTypeVersions: [1], requiredParams: [], credentialType: "notionApi", isTrigger: true },
+  { type: "@n8n/n8n-nodes-langchain.chatTrigger", safeTypeVersions: [1, 1.1], requiredParams: [], isTrigger: true },
+  // Core logic nodes
+  { type: "n8n-nodes-base.code", safeTypeVersions: [1, 2], requiredParams: [] },
+  { type: "n8n-nodes-base.httpRequest", safeTypeVersions: [1, 2, 3, 4, 4.1, 4.2], requiredParams: ["url"] },
+  { type: "n8n-nodes-base.set", safeTypeVersions: [1, 2, 3, 3.1, 3.2, 3.3, 3.4], requiredParams: [] },
+  { type: "n8n-nodes-base.if", safeTypeVersions: [1, 2, 2.1, 2.2], requiredParams: [] },
+  { type: "n8n-nodes-base.switch", safeTypeVersions: [1, 2, 3, 3.1, 3.2], requiredParams: [] },
+  { type: "n8n-nodes-base.filter", safeTypeVersions: [1, 2, 2.1, 2.2], requiredParams: [] },
+  { type: "n8n-nodes-base.merge", safeTypeVersions: [1, 2, 2.1, 3], requiredParams: [] },
+  { type: "n8n-nodes-base.splitInBatches", safeTypeVersions: [1, 2, 3], requiredParams: [] },
+  { type: "n8n-nodes-base.wait", safeTypeVersions: [1, 1.1], requiredParams: [] },
+  { type: "n8n-nodes-base.executeWorkflow", safeTypeVersions: [1, 1.1, 1.2], requiredParams: [] },
+  { type: "n8n-nodes-base.respondToWebhook", safeTypeVersions: [1, 1.1], requiredParams: [] },
+  { type: "n8n-nodes-base.noOp", safeTypeVersions: [1], requiredParams: [] },
+  { type: "n8n-nodes-base.stopAndError", safeTypeVersions: [1], requiredParams: [] },
+  { type: "n8n-nodes-base.splitOut", safeTypeVersions: [1], requiredParams: [] },
+  { type: "n8n-nodes-base.aggregate", safeTypeVersions: [1], requiredParams: [] },
+  { type: "n8n-nodes-base.stickyNote", safeTypeVersions: [1], requiredParams: [] },
+  // Email / messaging
+  { type: "n8n-nodes-base.emailSend", safeTypeVersions: [1, 2, 2.1], requiredParams: [], credentialType: "smtp" },
+  { type: "n8n-nodes-base.slack", safeTypeVersions: [1, 2, 2.1, 2.2], requiredParams: [], credentialType: "slackOAuth2Api" },
+  { type: "n8n-nodes-base.telegram", safeTypeVersions: [1, 1.1, 1.2], requiredParams: [], credentialType: "telegramApi" },
+  { type: "n8n-nodes-base.discord", safeTypeVersions: [1, 2], requiredParams: [], credentialType: "discordWebhookApi" },
+  // Google
+  { type: "n8n-nodes-base.gmail", safeTypeVersions: [1, 2, 2.1], requiredParams: [], credentialType: "gmailOAuth2" },
+  { type: "n8n-nodes-base.googleSheets", safeTypeVersions: [1, 2, 3, 4, 4.1, 4.2, 4.3, 4.4, 4.5], requiredParams: [], credentialType: "googleSheetsOAuth2Api" },
+  { type: "n8n-nodes-base.googleDrive", safeTypeVersions: [1, 2, 3], requiredParams: [], credentialType: "googleDriveOAuth2Api" },
+  { type: "n8n-nodes-base.googleCalendar", safeTypeVersions: [1, 1.1, 1.2, 1.3], requiredParams: [], credentialType: "googleCalendarOAuth2Api" },
+  // Project management / CRM
+  { type: "n8n-nodes-base.notion", safeTypeVersions: [1, 2, 2.1, 2.2], requiredParams: [], credentialType: "notionApi" },
+  { type: "n8n-nodes-base.airtable", safeTypeVersions: [1, 2, 2.1], requiredParams: [], credentialType: "airtableTokenApi" },
+  { type: "n8n-nodes-base.github", safeTypeVersions: [1, 1.1], requiredParams: [], credentialType: "githubApi" },
+  { type: "n8n-nodes-base.jira", safeTypeVersions: [1], requiredParams: [], credentialType: "jiraSoftwareCloudApi" },
+  { type: "n8n-nodes-base.hubspot", safeTypeVersions: [1, 2, 2.1], requiredParams: [], credentialType: "hubspotOAuth2Api" },
+  // Databases
+  { type: "n8n-nodes-base.postgres", safeTypeVersions: [1, 2, 2.1, 2.2, 2.3, 2.4, 2.5], requiredParams: [], credentialType: "postgres" },
+  { type: "n8n-nodes-base.mySql", safeTypeVersions: [1, 2, 2.1, 2.2, 2.3, 2.4], requiredParams: [], credentialType: "mySql" },
+  { type: "n8n-nodes-base.redis", safeTypeVersions: [1], requiredParams: [], credentialType: "redis" },
+  { type: "n8n-nodes-base.supabase", safeTypeVersions: [1], requiredParams: [], credentialType: "supabaseApi" },
+  // Cloud
+  { type: "n8n-nodes-base.awsS3", safeTypeVersions: [1, 2], requiredParams: [], credentialType: "aws" },
+  // Payment / commerce
+  { type: "n8n-nodes-base.stripe", safeTypeVersions: [1], requiredParams: [], credentialType: "stripeApi" },
+  // AI / LangChain root nodes
+  { type: "@n8n/n8n-nodes-langchain.agent", safeTypeVersions: [1, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9], requiredParams: [] },
+  { type: "@n8n/n8n-nodes-langchain.chainLlm", safeTypeVersions: [1, 1.1, 1.2, 1.3, 1.4, 1.5], requiredParams: [] },
+  { type: "@n8n/n8n-nodes-langchain.chainRetrievalQa", safeTypeVersions: [1, 1.1, 1.2, 1.3, 1.4], requiredParams: [] },
+  { type: "@n8n/n8n-nodes-langchain.openAi", safeTypeVersions: [1, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8], requiredParams: [], credentialType: "openAiApi" },
+  { type: "@n8n/n8n-nodes-langchain.anthropic", safeTypeVersions: [1], requiredParams: [], credentialType: "anthropicApi" },
+  { type: "@n8n/n8n-nodes-langchain.informationExtractor", safeTypeVersions: [1], requiredParams: [] },
+  { type: "@n8n/n8n-nodes-langchain.textClassifier", safeTypeVersions: [1], requiredParams: [] },
+  // AI / LangChain sub-nodes (models)
+  { type: "@n8n/n8n-nodes-langchain.lmChatOpenAi", safeTypeVersions: [1, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7], requiredParams: [], credentialType: "openAiApi" },
+  { type: "@n8n/n8n-nodes-langchain.lmChatAnthropic", safeTypeVersions: [1, 1.1, 1.2, 1.3], requiredParams: [], credentialType: "anthropicApi" },
+  { type: "@n8n/n8n-nodes-langchain.lmChatGoogleGemini", safeTypeVersions: [1], requiredParams: [], credentialType: "googlePalmApi" },
+  // AI / LangChain sub-nodes (memory, tools, etc.)
+  { type: "@n8n/n8n-nodes-langchain.memoryBufferWindow", safeTypeVersions: [1, 1.1, 1.2, 1.3], requiredParams: [] },
+  { type: "@n8n/n8n-nodes-langchain.toolWorkflow", safeTypeVersions: [1, 1.1, 1.2, 1.3], requiredParams: [] },
+  { type: "@n8n/n8n-nodes-langchain.toolCode", safeTypeVersions: [1, 1.1], requiredParams: [] },
+  { type: "@n8n/n8n-nodes-langchain.toolHttpRequest", safeTypeVersions: [1, 1.1], requiredParams: [] },
+  { type: "@n8n/n8n-nodes-langchain.toolCalculator", safeTypeVersions: [1], requiredParams: [] }
+];
+var NodeRegistry = class {
+  byType;
+  constructor(definitions = DEFAULT_REGISTRY) {
+    this.byType = new Map(definitions.map((d) => [d.type, d]));
+  }
+  get(type) {
+    return this.byType.get(type);
+  }
+  isTrigger(type) {
+    return this.byType.get(type)?.isTrigger === true;
+  }
+  isKnown(type) {
+    return this.byType.has(type);
+  }
+  isVersionSafe(type, version) {
+    const def = this.byType.get(type);
+    if (!def) return true;
+    return def.safeTypeVersions.includes(version);
+  }
+  getRequiredParams(type) {
+    return this.byType.get(type)?.requiredParams ?? [];
+  }
+};
+
+// src/providers/n8n/types.ts
+var FORBIDDEN_ON_CREATE = [
+  "id",
+  "createdAt",
+  "updatedAt",
+  "versionId",
+  "meta",
+  "isArchived",
+  "activeVersionId",
+  "activeVersion",
+  "active",
+  "pinData",
+  "triggerCount",
+  "shared",
+  "staticData"
+];
+var FORBIDDEN_ON_UPDATE = FORBIDDEN_ON_CREATE.filter((f) => f !== "id");
+
+// src/validation/validator.ts
+var AI_CONNECTION_TYPES = [
+  "ai_languageModel",
+  "ai_memory",
+  "ai_tool",
+  "ai_outputParser",
+  "ai_embedding",
+  "ai_document",
+  "ai_textSplitter",
+  "ai_retriever",
+  "ai_vectorStore"
+];
+var TRIGGER_TYPE_PATTERNS = [/trigger/i, /Trigger$/];
+var NODE_TYPE_PATTERN = /^(@[a-z0-9-]+\/[a-z0-9-]+\.|n8n-nodes-[a-z0-9-]+\.)[a-zA-Z][a-zA-Z0-9-]+$/;
+var N8nValidator = class {
+  registry;
+  constructor(registry = new NodeRegistry(DEFAULT_REGISTRY)) {
+    this.registry = registry;
+  }
+  validate(workflow) {
+    const issues = [];
+    this.checkRule1(workflow, issues);
+    this.checkRule2(workflow, issues);
+    this.checkRule3(workflow, issues);
+    this.checkRule4(workflow, issues);
+    this.checkRule5(workflow, issues);
+    this.checkRule6(workflow, issues);
+    this.checkRule7(workflow, issues);
+    this.checkRule8(workflow, issues);
+    this.checkRule9(workflow, issues);
+    this.checkRule10(workflow, issues);
+    this.checkRule11(workflow, issues);
+    this.checkRule12(workflow, issues);
+    this.checkRule13(workflow, issues);
+    this.checkRule14(workflow, issues);
+    this.checkRule15(workflow, issues);
+    this.checkRule16(workflow, issues);
+    this.checkRule17(workflow, issues);
+    this.checkRule18(workflow, issues);
+    this.checkRule19(workflow, issues);
+    this.checkRule20(workflow, issues);
+    this.checkRule21(workflow, issues);
+    this.checkRule22(workflow, issues);
+    this.checkRule23(workflow, issues);
+    const errors = issues.filter((i) => i.severity === "error");
+    return { valid: errors.length === 0, issues };
+  }
+  err(issues, rule, message, nodeId) {
+    const issue = { rule, severity: "error", message };
+    if (nodeId !== void 0) issue.nodeId = nodeId;
+    issues.push(issue);
+  }
+  warn(issues, rule, message, nodeId) {
+    const issue = { rule, severity: "warn", message };
+    if (nodeId !== void 0) issue.nodeId = nodeId;
+    issues.push(issue);
+  }
+  isTriggerNode(node) {
+    if (this.registry.isTrigger(node.type)) return true;
+    return TRIGGER_TYPE_PATTERNS.some((p) => p.test(node.type));
+  }
+  // Rule 1: name is a non-empty string
+  checkRule1(w, issues) {
+    if (typeof w.name !== "string" || w.name.trim() === "") {
+      this.err(issues, 1, "Workflow name is required and must be a non-empty string");
+    }
+  }
+  // Rule 2: nodes is an array with at least one element
+  checkRule2(w, issues) {
+    if (!Array.isArray(w.nodes) || w.nodes.length === 0) {
+      this.err(issues, 2, "Workflow must have at least one node");
+    }
+  }
+  // Rule 3: every node has a non-empty id
+  checkRule3(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (typeof node.id !== "string" || node.id.trim() === "") {
+        this.err(issues, 3, `Node "${node.name ?? "unknown"}" is missing a valid id`, node.id);
+      }
+    }
+  }
+  // Rule 4: node ids are unique
+  checkRule4(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    const seen = /* @__PURE__ */ new Set();
+    for (const node of w.nodes) {
+      if (!node.id) continue;
+      if (seen.has(node.id)) {
+        this.err(issues, 4, `Duplicate node id: "${node.id}"`, node.id);
+      }
+      seen.add(node.id);
+    }
+  }
+  // Rule 5: every node has a non-empty type string
+  checkRule5(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (typeof node.type !== "string" || node.type.trim() === "") {
+        this.err(issues, 5, `Node "${node.name ?? node.id}" is missing a type`, node.id);
+      }
+    }
+  }
+  // Rule 6: every node has a positive typeVersion number
+  checkRule6(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (typeof node.typeVersion !== "number" || node.typeVersion <= 0) {
+        this.err(issues, 6, `Node "${node.name}" has invalid typeVersion: ${String(node.typeVersion)}`, node.id);
+      }
+    }
+  }
+  // Rule 7: every node has a valid [x, y] position
+  checkRule7(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      const pos = node.position;
+      if (!Array.isArray(pos) || pos.length !== 2 || typeof pos[0] !== "number" || typeof pos[1] !== "number") {
+        this.err(issues, 7, `Node "${node.name}" has invalid position (must be [x, y])`, node.id);
+      }
+    }
+  }
+  // Rule 8: every node has a non-empty name
+  checkRule8(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (typeof node.name !== "string" || node.name.trim() === "") {
+        this.err(issues, 8, `Node with id "${node.id}" is missing a name`, node.id);
+      }
+    }
+  }
+  // Rule 9: connections is a plain object
+  checkRule9(w, issues) {
+    if (typeof w.connections !== "object" || w.connections === null || Array.isArray(w.connections)) {
+      this.err(issues, 9, "connections must be a plain object (use {} for single-node workflows)");
+    }
+  }
+  // Rule 10: every connection target node name exists in nodes
+  checkRule10(w, issues) {
+    if (!Array.isArray(w.nodes) || typeof w.connections !== "object" || w.connections === null) return;
+    const nodeNames = new Set(w.nodes.map((n) => n.name));
+    for (const [sourceName, outputs] of Object.entries(w.connections)) {
+      if (!nodeNames.has(sourceName)) {
+        this.err(issues, 10, `Connection source "${sourceName}" does not exist in nodes`);
+        continue;
+      }
+      if (typeof outputs !== "object" || outputs === null) continue;
+      for (const portGroup of Object.values(outputs)) {
+        if (!Array.isArray(portGroup)) continue;
+        for (const targets of portGroup) {
+          if (!Array.isArray(targets)) continue;
+          for (const target of targets) {
+            const t = target;
+            if (typeof t?.node === "string" && !nodeNames.has(t.node)) {
+              this.err(issues, 10, `Connection target "${t.node}" does not exist in nodes`);
+            }
+          }
+        }
+      }
+    }
+  }
+  // Rule 11 (WARN): every non-trigger node has at least one incoming connection
+  checkRule11(w, issues) {
+    if (!Array.isArray(w.nodes) || typeof w.connections !== "object" || w.connections === null) return;
+    const reachable = /* @__PURE__ */ new Set();
+    for (const [, outputs] of Object.entries(w.connections)) {
+      if (typeof outputs !== "object" || outputs === null) continue;
+      for (const portGroup of Object.values(outputs)) {
+        if (!Array.isArray(portGroup)) continue;
+        for (const targets of portGroup) {
+          if (!Array.isArray(targets)) continue;
+          for (const target of targets) {
+            const t = target;
+            if (typeof t?.node === "string") reachable.add(t.node);
+          }
+        }
+      }
+    }
+    for (const node of w.nodes) {
+      if (node.type.includes("stickyNote")) continue;
+      if (!this.isTriggerNode(node) && !reachable.has(node.name)) {
+        this.warn(issues, 11, `Node "${node.name}" has no incoming connections and may never execute`, node.id);
+      }
+    }
+  }
+  // Rule 12: forbidden fields absent from workflow root
+  checkRule12(w, issues) {
+    const wObj = w;
+    for (const field of FORBIDDEN_ON_CREATE) {
+      if (field in wObj) {
+        this.err(issues, 12, `Forbidden field "${field}" present in workflow \u2014 remove it before deploying`);
+      }
+    }
+  }
+  // Rule 13: settings, if present, is a plain object
+  checkRule13(w, issues) {
+    if (w.settings !== void 0) {
+      if (typeof w.settings !== "object" || w.settings === null || Array.isArray(w.settings)) {
+        this.err(issues, 13, "workflow.settings must be a plain object");
+      }
+    }
+  }
+  // Rule 14: at least one trigger node is present
+  checkRule14(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    const hasTrigger = w.nodes.some((n) => this.isTriggerNode(n));
+    if (!hasTrigger) {
+      this.err(issues, 14, "Workflow must contain at least one trigger node");
+    }
+  }
+  // Rule 15: node type string matches expected format
+  checkRule15(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (typeof node.type !== "string") continue;
+      if (!NODE_TYPE_PATTERN.test(node.type)) {
+        this.err(issues, 15, `Node "${node.name}" has malformed type string: "${node.type}"`, node.id);
+      }
+    }
+  }
+  // Rule 16: node names are unique within the workflow
+  checkRule16(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    const seen = /* @__PURE__ */ new Set();
+    for (const node of w.nodes) {
+      if (!node.name) continue;
+      if (seen.has(node.name)) {
+        this.err(issues, 16, `Duplicate node name: "${node.name}"`, node.id);
+      }
+      seen.add(node.name);
+    }
+  }
+  // Rule 17: credentials shape — each entry has id and name
+  checkRule17(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (!node.credentials) continue;
+      for (const [credType, credRef] of Object.entries(node.credentials)) {
+        if (typeof credRef !== "object" || credRef === null) {
+          this.err(issues, 17, `Node "${node.name}" credential "${credType}" must be an object with id and name`, node.id);
+          continue;
+        }
+        const ref = credRef;
+        if (typeof ref["id"] !== "string" || ref["id"].trim() === "" || typeof ref["name"] !== "string" || ref["name"].trim() === "") {
+          this.err(issues, 17, `Node "${node.name}" credential "${credType}" must have non-empty string id and name fields`, node.id);
+        }
+      }
+    }
+  }
+  // Rule 18 (ERROR): AI connections must originate from sub-nodes, not the agent/chain root
+  checkRule18(w, issues) {
+    if (typeof w.connections !== "object" || w.connections === null) return;
+    const agentTypes = /* @__PURE__ */ new Set([
+      "@n8n/n8n-nodes-langchain.agent",
+      "@n8n/n8n-nodes-langchain.chainLlm",
+      "@n8n/n8n-nodes-langchain.chainRetrievalQa",
+      "@n8n/n8n-nodes-langchain.chainSummarization"
+    ]);
+    if (!Array.isArray(w.nodes)) return;
+    const nodesByName = new Map(w.nodes.map((n) => [n.name, n]));
+    for (const [sourceName, outputs] of Object.entries(w.connections)) {
+      const sourceNode = nodesByName.get(sourceName);
+      if (!sourceNode) continue;
+      if (!agentTypes.has(sourceNode.type)) continue;
+      if (typeof outputs !== "object" || outputs === null) continue;
+      for (const connType of AI_CONNECTION_TYPES) {
+        if (connType in outputs) {
+          this.err(
+            issues,
+            18,
+            `Node "${sourceName}" uses AI connection type "${connType}" as a SOURCE \u2014 AI sub-nodes should be the source, not the agent/chain root`,
+            sourceNode.id
+          );
+        }
+      }
+    }
+  }
+  // Rule 19 (WARN): typeVersion is within known safe range for registered node types
+  checkRule19(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (typeof node.type !== "string" || typeof node.typeVersion !== "number") continue;
+      if (!this.registry.isVersionSafe(node.type, node.typeVersion)) {
+        this.warn(
+          issues,
+          19,
+          `Node "${node.name}" uses typeVersion ${node.typeVersion} for type "${node.type}" which is not in the known safe list`,
+          node.id
+        );
+      }
+    }
+  }
+  // Rule 20 (WARN): cycle detection — no node should be reachable from itself
+  // Exempts splitInBatches loops which are an intentional n8n pattern
+  checkRule20(w, issues) {
+    if (!Array.isArray(w.nodes) || typeof w.connections !== "object" || w.connections === null) return;
+    const splitBatchNodes = new Set(
+      w.nodes.filter((n) => n.type.includes("splitInBatches")).map((n) => n.name)
+    );
+    const adj = /* @__PURE__ */ new Map();
+    for (const [sourceName, outputs] of Object.entries(w.connections)) {
+      if (typeof outputs !== "object" || outputs === null) continue;
+      const targets = [];
+      for (const portGroup of Object.values(outputs)) {
+        if (!Array.isArray(portGroup)) continue;
+        for (const conns of portGroup) {
+          if (!Array.isArray(conns)) continue;
+          for (const conn of conns) {
+            const t = conn;
+            if (typeof t?.node === "string") {
+              if (splitBatchNodes.has(t.node)) continue;
+              targets.push(t.node);
+            }
+          }
+        }
+      }
+      adj.set(sourceName, targets);
+    }
+    const WHITE = 0, GRAY = 1, BLACK = 2;
+    const color = /* @__PURE__ */ new Map();
+    for (const node of w.nodes) color.set(node.name, WHITE);
+    const dfs = (name) => {
+      color.set(name, GRAY);
+      for (const neighbor of adj.get(name) ?? []) {
+        const c = color.get(neighbor);
+        if (c === GRAY) return true;
+        if (c === WHITE && dfs(neighbor)) return true;
+      }
+      color.set(name, BLACK);
+      return false;
+    };
+    for (const node of w.nodes) {
+      if (color.get(node.name) === WHITE && dfs(node.name)) {
+        this.warn(issues, 20, "Workflow contains a connection cycle \u2014 this may cause infinite loops");
+        return;
+      }
+    }
+  }
+  // Rule 22 (WARN): check requiredParams from registry
+  checkRule22(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (typeof node.type !== "string") continue;
+      const required = this.registry.getRequiredParams(node.type);
+      if (required.length === 0) continue;
+      const params = node.parameters ?? {};
+      for (const param of required) {
+        const value = params[param];
+        if (value === void 0 || value === null || value === "") {
+          this.warn(
+            issues,
+            22,
+            `Node "${node.name}" (${node.type}) is missing required parameter "${param}"`,
+            node.id
+          );
+        }
+      }
+    }
+  }
+  // Rule 23 (WARN): unknown node types not in registry
+  checkRule23(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (typeof node.type !== "string") continue;
+      if (node.type.includes("stickyNote")) continue;
+      if (!NODE_TYPE_PATTERN.test(node.type)) continue;
+      if (!this.registry.isKnown(node.type)) {
+        this.warn(
+          issues,
+          23,
+          `Node "${node.name}" uses unknown type "${node.type}" \u2014 it may not exist in n8n`,
+          node.id
+        );
+      }
+    }
+  }
+  // Rule 21 (WARN): webhook with responseMode="responseNode" must have respondToWebhook node
+  checkRule21(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    const webhooksNeedingResponse = w.nodes.filter((n) => {
+      if (!n.type.includes("webhook")) return false;
+      const params = n.parameters;
+      return params?.responseMode === "responseNode";
+    });
+    if (webhooksNeedingResponse.length === 0) return;
+    const hasRespondNode = w.nodes.some((n) => n.type.includes("respondToWebhook"));
+    if (!hasRespondNode) {
+      for (const wh of webhooksNeedingResponse) {
+        this.warn(
+          issues,
+          21,
+          `Webhook "${wh.name}" uses responseMode "responseNode" but no respondToWebhook node exists in the workflow`,
+          wh.id
+        );
+      }
+    }
+  }
+};
+
+// src/providers/n8n/stripper.ts
+var N8nFieldStripper = class {
+  stripForCreate(workflow) {
+    return this.strip(workflow, FORBIDDEN_ON_CREATE);
+  }
+  stripForUpdate(workflow) {
+    return this.strip(workflow, FORBIDDEN_ON_UPDATE);
+  }
+  strip(workflow, forbidden) {
+    const result = { ...workflow };
+    for (const field of forbidden) {
+      delete result[field];
+    }
+    return result;
+  }
+};
+
+// src/errors/base.ts
+var KairosError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "KairosError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  cause;
+};
+
+// src/errors/api-error.ts
+var ApiError = class extends KairosError {
+  constructor(message, statusCode, cause) {
+    super(message, cause);
+    this.statusCode = statusCode;
+    this.name = "ApiError";
+  }
+  statusCode;
+};
+
+// src/errors/provider-error.ts
+var ProviderError = class extends KairosError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "ProviderError";
+  }
+};
+
+// src/utils/retry.ts
+async function withRetry(fn, maxAttempts, delayMs, shouldRetry) {
+  let lastError;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    if (attempt > 0) {
+      const jitter = Math.random() * delayMs * 0.5;
+      await new Promise((resolve) => setTimeout(resolve, delayMs * 2 ** (attempt - 1) + jitter));
+    }
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (shouldRetry && !shouldRetry(err)) throw err;
+    }
+  }
+  throw lastError;
+}
+function fetchWithTimeout(url, init, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  return fetch(url, { ...init, signal: controller.signal }).finally(() => clearTimeout(timer));
+}
+
+// src/providers/n8n/api-client.ts
+var EXECUTION_LIMIT_CAP = 100;
+var REQUEST_TIMEOUT_MS = 3e4;
+var RETRY_ATTEMPTS = 3;
+var RETRY_DELAY_MS = 1e3;
+var N8nApiClient = class {
+  constructor(baseUrl, apiKey, logger) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+    this.logger = logger;
+  }
+  baseUrl;
+  apiKey;
+  logger;
+  async request(method, path, body) {
+    const url = `${this.baseUrl.replace(/\/$/, "")}/api/v1${path}`;
+    this.logger.debug(`n8n ${method} ${path}`);
+    const isSafe = method === "GET";
+    if (!isSafe) {
+      return this.singleRequest(url, method, path, body);
+    }
+    return withRetry(
+      () => this.singleRequest(url, method, path, body),
+      RETRY_ATTEMPTS,
+      RETRY_DELAY_MS,
+      (err) => err instanceof ProviderError || err instanceof ApiError && err.statusCode === 429
+    );
+  }
+  async singleRequest(url, method, path, body) {
+    let response;
+    try {
+      response = await fetchWithTimeout(url, {
+        method,
+        headers: {
+          "X-N8N-API-KEY": this.apiKey,
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+      }, REQUEST_TIMEOUT_MS);
+    } catch (err) {
+      throw new ProviderError(`Network error calling n8n API: ${path}`, err);
+    }
+    if (!response.ok) {
+      let errorBody;
+      try {
+        errorBody = await response.json();
+      } catch {
+        errorBody = await response.text().catch(() => "");
+      }
+      this.logger.error(`n8n API error ${response.status} on ${method} ${path}`, {
+        status: response.status,
+        body: String(errorBody)
+      });
+      throw new ApiError(
+        `n8n API returned ${response.status} for ${method} ${path}: ${JSON.stringify(errorBody)}`,
+        response.status,
+        errorBody
+      );
+    }
+    if (response.status === 204) return void 0;
+    return response.json();
+  }
+  async createWorkflow(workflow) {
+    return this.request("POST", "/workflows", workflow);
+  }
+  async updateWorkflow(id, workflow) {
+    return this.request("PUT", `/workflows/${id}`, workflow);
+  }
+  async getWorkflow(id) {
+    return this.request("GET", `/workflows/${id}`);
+  }
+  async listWorkflows() {
+    const all = [];
+    let path = "/workflows?limit=250";
+    for (; ; ) {
+      const response = await this.request("GET", path);
+      for (const w of response.data) {
+        all.push({
+          id: w.id,
+          name: w.name,
+          active: w.active,
+          createdAt: w.createdAt,
+          updatedAt: w.updatedAt,
+          ...w.tags !== void 0 ? { tags: w.tags } : {}
+        });
+      }
+      if (!response.nextCursor) break;
+      path = `/workflows?limit=250&cursor=${response.nextCursor}`;
+    }
+    return all;
+  }
+  async deleteWorkflow(id) {
+    await this.request("DELETE", `/workflows/${id}`);
+  }
+  async activateWorkflow(id) {
+    await this.request("POST", `/workflows/${id}/activate`);
+  }
+  async deactivateWorkflow(id) {
+    await this.request("POST", `/workflows/${id}/deactivate`);
+  }
+  async getExecutions(workflowId, filter) {
+    const params = new URLSearchParams();
+    if (workflowId) params.set("workflowId", workflowId);
+    if (filter?.status) params.set("status", filter.status);
+    const limit = Math.min(filter?.limit ?? 20, EXECUTION_LIMIT_CAP);
+    params.set("limit", String(limit));
+    if (filter?.cursor) params.set("cursor", filter.cursor);
+    const qs = params.toString();
+    const response = await this.request("GET", `/executions${qs ? `?${qs}` : ""}`);
+    return response.data.map(this.mapExecution);
+  }
+  async getExecution(id) {
+    const response = await this.request("GET", `/executions/${id}`);
+    return { ...this.mapExecution(response), data: response.data, workflowData: response.workflowData };
+  }
+  async listTags() {
+    const all = [];
+    let path = "/tags?limit=250";
+    for (; ; ) {
+      const response = await this.request("GET", path);
+      for (const t of response.data) {
+        all.push({ id: t.id, name: t.name });
+      }
+      if (!response.nextCursor) break;
+      path = `/tags?limit=250&cursor=${response.nextCursor}`;
+    }
+    return all;
+  }
+  async createTag(name) {
+    const response = await this.request("POST", "/tags", { name });
+    return { id: response.id, name: response.name };
+  }
+  async tagWorkflow(workflowId, tagIds) {
+    await this.request("PUT", `/workflows/${workflowId}/tags`, tagIds.map((id) => ({ id })));
+  }
+  async untagWorkflow(workflowId, tagIds) {
+    const current = await this.getWorkflow(workflowId);
+    const remaining = (current.tags ?? []).filter((t) => !tagIds.includes(t.id)).map((t) => ({ id: t.id }));
+    await this.request("PUT", `/workflows/${workflowId}/tags`, remaining);
+  }
+  mapExecution(e) {
+    return {
+      id: e.id,
+      workflowId: e.workflowId,
+      status: e.status,
+      startedAt: e.startedAt,
+      ...e.stoppedAt !== void 0 ? { stoppedAt: e.stoppedAt } : {},
+      mode: e.mode
+    };
+  }
+};
+
+// src/generation/prompts/v1.ts
+var SYSTEM_PROMPT_V1 = `You are a workflow generation engine for n8n. Your only output is a generate_workflow tool call containing valid n8n workflow JSON. You never respond with prose, explanations, or markdown. If you cannot fulfill the request, set the error field in the tool call.
+
+## HARD RULES \u2014 violating any of these causes immediate deployment failure
+
+### Forbidden fields \u2014 NEVER include these in the workflow object:
+id, active, createdAt, updatedAt, versionId, meta, isArchived, activeVersionId, activeVersion, pinData, triggerCount, shared, staticData
+
+### Required top-level structure:
+{
+  "name": "<descriptive name>",
+  "nodes": [...],
+  "connections": {...},
+  "settings": {
+    "saveExecutionProgress": true,
+    "saveManualExecutions": true,
+    "saveDataErrorExecution": "all",
+    "saveDataSuccessExecution": "all",
+    "executionTimeout": 3600,
+    "timezone": "UTC",
+    "executionOrder": "v1"
+  }
+}
+
+### Node IDs:
+- Every node.id must be a valid UUID v4 (random hex, format: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx)
+- Never reuse IDs, never use sequential fake IDs like "node-1"
+
+### Credentials:
+- Only reference credentials with exact type names (see catalog below)
+- If credential ID is unknown, OMIT the credentials block entirely \u2014 never invent credential IDs
+- Never put API keys or tokens in parameters when a credential type exists
+
+### Node names:
+- All node names must be unique within the workflow
+- Use descriptive names: "Fetch Open Invoices" not "HTTP Request 2"
+
+### Positioning:
+- Trigger node: [250, 300]
+- Each subsequent step: x + 220 minimum
+- Parallel branches: offset y by \xB1150
+- AI sub-nodes: place below their root node (y + 200)
+
+---
+
+## CONNECTION RULES \u2014 the most common source of errors
+
+### Standard connections (main data flow):
+"NodeA": { "main": [ [ { "node": "NodeB", "type": "main", "index": 0 } ] ] }
+
+### AI connections \u2014 CRITICAL: the SUB-NODE is the SOURCE, NOT the agent/chain:
+"OpenAI Chat Model": { "ai_languageModel": [ [ { "node": "AI Agent", "type": "ai_languageModel", "index": 0 } ] ] }
+"Simple Memory":     { "ai_memory":        [ [ { "node": "AI Agent", "type": "ai_memory", "index": 0 } ] ] }
+"Calculator Tool":   { "ai_tool":          [ [ { "node": "AI Agent", "type": "ai_tool", "index": 0 } ] ] }
+
+The AI Agent node does NOT appear in connections as a source for ai_* types.
+Every AI Agent must have at least one ai_languageModel sub-node connected.
+
+### IF node \u2014 two output ports (0 = true, 1 = false):
+"IF Check": { "main": [ [{ "node": "True Path", "type": "main", "index": 0 }], [{ "node": "False Path", "type": "main", "index": 0 }] ] }
+
+### SplitInBatches \u2014 two output ports (0 = done/finished, 1 = loop body per batch):
+Connect output 0 to the node that runs AFTER all batches complete.
+Connect output 1 to the processing chain for each batch. The last node in the chain loops back to SplitInBatches via main input.
+
+### Webhook + RespondToWebhook pattern:
+When webhook responseMode is "responseNode", you MUST include a respondToWebhook node in the flow.
+"Webhook": { "main": [[{ "node": "Process Data", "type": "main", "index": 0 }]] }
+"Process Data": { "main": [[{ "node": "Respond to Webhook", "type": "main", "index": 0 }]] }
+
+### Triggers have no incoming connections.
+### Connection keys are NODE NAMES, never node IDs.
+
+### Nested parameters:
+Node parameters like conditions, assignments, and rule intervals MUST include all required nested fields. Do not leave nested objects empty or partially filled.
+
+---
+
+## NODE CATALOG \u2014 exact type strings and safe typeVersions
+
+### Triggers (always at least one required):
+n8n-nodes-base.manualTrigger          typeVersion: 1       \u2014 testing only
+n8n-nodes-base.scheduleTrigger        typeVersion: 1.2     \u2014 params: rule.interval[{field, ...}]
+n8n-nodes-base.webhook                typeVersion: 2       \u2014 params: httpMethod, path, responseMode
+n8n-nodes-base.formTrigger            typeVersion: 2.2
+n8n-nodes-base.emailReadImap          typeVersion: 2       \u2014 cred: imap
+n8n-nodes-base.errorTrigger           typeVersion: 1
+n8n-nodes-base.executeWorkflowTrigger typeVersion: 1.1
+n8n-nodes-base.gmailTrigger           typeVersion: 1.2     \u2014 cred: gmailOAuth2
+n8n-nodes-base.slackTrigger           typeVersion: 1       \u2014 cred: slackApi
+n8n-nodes-base.telegramTrigger        typeVersion: 1.2     \u2014 cred: telegramApi
+n8n-nodes-base.githubTrigger          typeVersion: 1       \u2014 cred: githubApi
+n8n-nodes-base.airtableTrigger        typeVersion: 1       \u2014 cred: airtableTokenApi
+n8n-nodes-base.notionTrigger          typeVersion: 1       \u2014 cred: notionApi
+@n8n/n8n-nodes-langchain.chatTrigger  typeVersion: 1.1     \u2014 pairs with AI Agent
+
+### Core logic:
+n8n-nodes-base.code                   typeVersion: 2       \u2014 params: mode, jsCode
+n8n-nodes-base.httpRequest            typeVersion: 4.2     \u2014 params: method, url, [sendBody, jsonBody, sendHeaders, headerParameters]
+n8n-nodes-base.set                    typeVersion: 3.4     \u2014 params: assignments.assignments[{id, name, value, type}]
+n8n-nodes-base.if                     typeVersion: 2.2     \u2014 params: conditions.conditions[{id, leftValue, rightValue, operator}], combinator
+n8n-nodes-base.switch                 typeVersion: 3.2     \u2014 multi-branch routing
+n8n-nodes-base.filter                 typeVersion: 2.2     \u2014 params: conditions (same as IF), 1 output
+n8n-nodes-base.merge                  typeVersion: 3       \u2014 modes: append/combine/chooseBranch
+n8n-nodes-base.splitInBatches         typeVersion: 3       \u2014 output 0=done, output 1=loop body
+n8n-nodes-base.wait                   typeVersion: 1.1
+n8n-nodes-base.executeWorkflow        typeVersion: 1.2
+n8n-nodes-base.respondToWebhook       typeVersion: 1.1     \u2014 required when webhook responseMode is "responseNode"
+n8n-nodes-base.noOp                   typeVersion: 1
+n8n-nodes-base.splitOut               typeVersion: 1
+n8n-nodes-base.aggregate              typeVersion: 1
+n8n-nodes-base.stickyNote             typeVersion: 1       \u2014 never connected, canvas annotation only
+
+### Email / messaging:
+n8n-nodes-base.emailSend              typeVersion: 2.1     \u2014 cred: smtp
+n8n-nodes-base.slack                  typeVersion: 2.2     \u2014 cred: slackOAuth2Api \u2014 params: resource, operation, select, channelId{__rl}, text
+n8n-nodes-base.telegram               typeVersion: 1.2     \u2014 cred: telegramApi
+n8n-nodes-base.discord                typeVersion: 2       \u2014 cred: discordWebhookApi
+
+### Google:
+n8n-nodes-base.gmail                  typeVersion: 2.1     \u2014 cred: gmailOAuth2 \u2014 params: resource, operation
+n8n-nodes-base.googleSheets           typeVersion: 4.5     \u2014 cred: googleSheetsOAuth2Api \u2014 params: resource, operation, documentId{__rl}, sheetName{__rl}
+n8n-nodes-base.googleDrive            typeVersion: 3       \u2014 cred: googleDriveOAuth2Api
+n8n-nodes-base.googleCalendar         typeVersion: 1.3     \u2014 cred: googleCalendarOAuth2Api
+
+### Productivity:
+n8n-nodes-base.notion                 typeVersion: 2.2     \u2014 cred: notionApi
+n8n-nodes-base.airtable               typeVersion: 2.1     \u2014 cred: airtableTokenApi
+n8n-nodes-base.github                 typeVersion: 1.1     \u2014 cred: githubApi
+n8n-nodes-base.jira                   typeVersion: 1       \u2014 cred: jiraSoftwareCloudApi
+n8n-nodes-base.hubspot                typeVersion: 2.1     \u2014 cred: hubspotOAuth2Api
+
+### Databases:
+n8n-nodes-base.postgres               typeVersion: 2.5     \u2014 cred: postgres
+n8n-nodes-base.mySql                  typeVersion: 2.4     \u2014 cred: mySql
+n8n-nodes-base.redis                  typeVersion: 1       \u2014 cred: redis
+n8n-nodes-base.supabase               typeVersion: 1       \u2014 cred: supabaseApi
+n8n-nodes-base.awsS3                  typeVersion: 2       \u2014 cred: aws
+
+### AI \u2014 Root nodes (sit on main data flow, receive ai_* connections as TARGETS):
+@n8n/n8n-nodes-langchain.agent        typeVersion: 1.9     \u2014 params: promptType, text (if define), options.systemMessage
+@n8n/n8n-nodes-langchain.chainLlm     typeVersion: 1.5
+@n8n/n8n-nodes-langchain.chainRetrievalQa typeVersion: 1.4
+@n8n/n8n-nodes-langchain.openAi       typeVersion: 1.8     \u2014 cred: openAiApi \u2014 standalone node, calls OpenAI directly without sub-nodes
+@n8n/n8n-nodes-langchain.anthropic    typeVersion: 1       \u2014 cred: anthropicApi \u2014 standalone node, calls Anthropic directly without sub-nodes
+
+### AI \u2014 Sub-nodes (sources of ai_* connections, wire INTO root nodes above):
+@n8n/n8n-nodes-langchain.lmChatOpenAi      typeVersion: 1.7  \u2014 cred: openAiApi       \u2014 ai_languageModel \u2014 use with agent/chain, NOT standalone
+@n8n/n8n-nodes-langchain.lmChatAnthropic   typeVersion: 1.3  \u2014 cred: anthropicApi    \u2014 ai_languageModel \u2014 use with agent/chain, NOT standalone
+@n8n/n8n-nodes-langchain.lmChatGoogleGemini typeVersion: 1   \u2014 cred: googlePalmApi   \u2014 ai_languageModel
+@n8n/n8n-nodes-langchain.memoryBufferWindow typeVersion: 1.3  \u2014                       \u2014 ai_memory
+@n8n/n8n-nodes-langchain.toolWorkflow      typeVersion: 2     \u2014                       \u2014 ai_tool
+@n8n/n8n-nodes-langchain.toolCode          typeVersion: 1.1   \u2014                       \u2014 ai_tool
+@n8n/n8n-nodes-langchain.toolHttpRequest   typeVersion: 1.1   \u2014                       \u2014 ai_tool
+@n8n/n8n-nodes-langchain.toolCalculator    typeVersion: 1     \u2014                       \u2014 ai_tool
+
+### Resource locator (__rl) format (Google / Slack / Notion modern nodes):
+{ "__rl": true, "mode": "id", "value": "ACTUAL_ID" }
+{ "__rl": true, "mode": "name", "value": "#channel-name" }
+
+### App node parameter pattern:
+{ "resource": "message", "operation": "send", ...operation-specific fields }
+
+### Schedule Trigger \u2014 daily at 9am example:
+{ "rule": { "interval": [{ "field": "days", "daysInterval": 1, "triggerAtHour": 9, "triggerAtMinute": 0 }] } }
+Cron: { "rule": { "interval": [{ "field": "cronExpression", "expression": "0 9 * * 1-5" }] } }
+
+---
+
+## PRE-DELIVERY SELF-CHECK (do this before calling the tool):
+1. Every connection source/target name exists in nodes array
+2. No duplicate node names
+3. No duplicate node IDs
+4. No forbidden fields at the workflow root
+5. At least one trigger node present
+6. Every AI Agent has an ai_languageModel sub-node
+7. settings block is complete with executionOrder: "v1"
+
+---
+
+Respond ONLY with a generate_workflow tool call. No prose. No markdown outside the tool call.
+If the request is impossible or unclear, set the error field instead of generating a workflow.`;
+
+// src/generation/prompt-builder.ts
+var RULE_REMEDIES = {
+  1: "Provide a non-empty workflow name string",
+  2: "Include at least one node in the nodes array",
+  3: "Every node must have a unique UUID v4 string as its id field",
+  4: "Ensure all node ids are unique \u2014 no two nodes can share the same id",
+  5: "Every node must have a non-empty type string",
+  6: "Every node must have a positive integer typeVersion",
+  7: "Every node must have a position array of exactly [x, y] numbers",
+  8: "Every node must have a non-empty name string",
+  9: "connections must be a plain object (use {} if no connections)",
+  10: "Every node name in connections (source and target) must exactly match a name in the nodes array",
+  12: "Remove forbidden fields: id, active, createdAt, updatedAt, versionId, meta, tags \u2014 these are server-assigned",
+  14: "Include at least one trigger node (e.g. webhook, scheduleTrigger, manualTrigger)",
+  15: 'Node type strings must be fully qualified: "n8n-nodes-base.httpRequest" not just "httpRequest"',
+  16: "All node names must be unique within the workflow",
+  17: 'Credentials must be an object with non-empty string id and name fields: { id: "placeholder-id", name: "My Credential" }',
+  18: "AI sub-nodes (languageModel, memory, tool) must be the CONNECTION SOURCE pointing TO the agent \u2014 not the reverse",
+  19: "Use known safe typeVersion values for each node type",
+  20: "Remove connection cycles \u2014 ensure no node can reach itself through the connection graph",
+  21: 'When using webhook with responseMode "responseNode", include a respondToWebhook node in the flow',
+  22: "Ensure all required parameters are set for each node type (e.g. webhook needs httpMethod and path)"
+};
+var PromptBuilder = class {
+  build(request, matches, globalFailureRates = []) {
+    const mode = this.resolveMode(matches);
+    const system = this.buildSystem(matches, mode, globalFailureRates);
+    const userMessage = this.buildUserMessage(request, matches, mode);
+    return { system, userMessage, mode, matches };
+  }
+  buildCorrectionMessage(request, matches, allIssues, attempt) {
+    const base = this.buildUserMessage(request, matches, this.resolveMode(matches));
+    return `${base}
+
+IMPORTANT: A previous generation attempt (attempt ${attempt}) failed validation with these issues:
+${allIssues.join("\n")}
+
+Fix ALL of the above issues in your new response. Do not repeat any of these mistakes.`;
+  }
+  resolveMode(matches) {
+    if (matches.length === 0) return "scratch";
+    const top = matches[0];
+    if (!top) return "scratch";
+    return scoreToMode(top.score);
+  }
+  buildSystem(matches, mode, globalFailureRates = []) {
+    const blocks = [
+      {
+        type: "text",
+        text: SYSTEM_PROMPT_V1,
+        cache_control: { type: "ephemeral" }
+      }
+    ];
+    if (mode === "reference" && matches.length > 0) {
+      const refText = matches.slice(0, 3).map((m) => {
+        const nodes = m.workflow.workflow.nodes.map((n) => `  - ${n.name} (${n.type} v${n.typeVersion})`).join("\n");
+        return `Reference workflow: "${m.workflow.description}" (similarity: ${m.score.toFixed(2)})
+Nodes:
+${nodes}`;
+      }).join("\n\n");
+      blocks.push({
+        type: "text",
+        text: `## Similar Workflows From Library (for reference only \u2014 adapt, do not copy verbatim)
+
+${refText}`
+      });
+    }
+    if (mode === "direct" && matches[0]) {
+      const match = matches[0];
+      const json = JSON.stringify(match.workflow.workflow, null, 2);
+      if (json.length > 3e4) {
+        const nodes = match.workflow.workflow.nodes.map((n) => `  - ${n.name} (${n.type} v${n.typeVersion})`).join("\n");
+        blocks.push({
+          type: "text",
+          text: `## Closely Matched Workflow (score: ${match.score.toFixed(2)}) \u2014 too large for full JSON, using reference:
+Nodes:
+${nodes}`
+        });
+      } else {
+        blocks.push({
+          type: "text",
+          text: `## Closely Matched Workflow (score: ${match.score.toFixed(2)}) \u2014 adapt this structure:
+
+${json}`
+        });
+      }
+    }
+    if (mode === "scratch" && matches.length > 0 && matches[0].score >= 0.4) {
+      const hint = matches[0];
+      const nodeTypes = hint.workflow.workflow.nodes.map((n) => n.type.split(".").pop()).join(", ");
+      blocks.push({
+        type: "text",
+        text: `## Weak Structural Hint
+A loosely similar workflow (score: ${hint.score.toFixed(2)}) used these node types: ${nodeTypes}`
+      });
+    }
+    const warnings = this.buildFailureWarnings(matches, globalFailureRates);
+    if (warnings) {
+      blocks.push({ type: "text", text: warnings });
+    }
+    return blocks;
+  }
+  buildFailureWarnings(matches, globalFailureRates) {
+    const lines = [];
+    for (const match of matches) {
+      const patterns = match.workflow.failurePatterns;
+      if (!patterns?.length) continue;
+      for (const fp of patterns) {
+        const remedy = RULE_REMEDIES[fp.rule];
+        const remedyStr = remedy ? ` \u2014 Fix: ${remedy}` : "";
+        lines.push(`- Rule ${fp.rule}: "${fp.message}"${remedyStr} (seen ${fp.occurrences}x in similar workflows)`);
+      }
+    }
+    const highFreqRules = globalFailureRates.filter((r) => r.rate >= 0.15);
+    for (const rule of highFreqRules) {
+      const remedy = RULE_REMEDIES[rule.rule];
+      const remedyStr = remedy ? ` \u2014 Fix: ${remedy}` : "";
+      lines.push(`- Rule ${rule.rule}: "${rule.commonMessage}"${remedyStr} (fails in ${Math.round(rule.rate * 100)}% of all builds)`);
+    }
+    if (lines.length === 0) return null;
+    const unique = [...new Set(lines)];
+    return `## Known Failure Patterns \u2014 AVOID THESE
+
+Previous builds frequently failed the following validation rules. Ensure your output does NOT repeat these mistakes:
+${unique.join("\n")}`;
+  }
+  buildUserMessage(request, _matches, _mode) {
+    const namePart = request.name ? `
+Workflow name: "${request.name}"` : "";
+    return `Build a workflow that: ${request.description}${namePart}`;
+  }
+};
+
+// src/telemetry/reader.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = require("path");
+var import_node_os2 = require("os");
+var TelemetryReader = class {
+  dir;
+  cache = null;
+  cacheTime = 0;
+  constructor(dir) {
+    this.dir = dir ?? (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".kairos", "telemetry");
+  }
+  async getFailureRates(days = 30) {
+    const now = Date.now();
+    if (this.cache && now - this.cacheTime < 5 * 60 * 1e3) {
+      return this.cache;
+    }
+    const events = await this.readRecentEvents(days);
+    const buildSessions = new Set(
+      events.filter((e) => e.eventType === "build_complete" && !e.data.dryRun).map((e) => e.sessionId)
+    );
+    if (buildSessions.size === 0) return [];
+    const ruleSessions = /* @__PURE__ */ new Map();
+    for (const event of events) {
+      if (event.eventType !== "generation_attempt") continue;
+      if (!buildSessions.has(event.sessionId)) continue;
+      const data = event.data;
+      if (data.validationPassed || !data.issues) continue;
+      for (const issue of data.issues) {
+        const entry = ruleSessions.get(issue.rule) ?? { sessions: /* @__PURE__ */ new Set(), messages: /* @__PURE__ */ new Map() };
+        entry.sessions.add(event.sessionId);
+        entry.messages.set(issue.message, (entry.messages.get(issue.message) ?? 0) + 1);
+        ruleSessions.set(issue.rule, entry);
+      }
+    }
+    const rates = [];
+    for (const [rule, entry] of ruleSessions) {
+      let topMessage = "";
+      let topCount = 0;
+      for (const [msg, count] of entry.messages) {
+        if (count > topCount) {
+          topMessage = msg;
+          topCount = count;
+        }
+      }
+      rates.push({
+        rule,
+        failureCount: entry.sessions.size,
+        totalBuilds: buildSessions.size,
+        rate: entry.sessions.size / buildSessions.size,
+        commonMessage: topMessage
+      });
+    }
+    rates.sort((a, b) => b.rate - a.rate);
+    this.cache = rates;
+    this.cacheTime = now;
+    return rates;
+  }
+  async readRecentEvents(days) {
+    let files;
+    try {
+      files = await (0, import_promises2.readdir)(this.dir);
+    } catch {
+      return [];
+    }
+    const cutoff = /* @__PURE__ */ new Date();
+    cutoff.setDate(cutoff.getDate() - days);
+    const cutoffStr = cutoff.toISOString().slice(0, 10);
+    const datePattern = /^\d{4}-\d{2}-\d{2}\.jsonl$/;
+    const recentFiles = files.filter((f) => datePattern.test(f) && f >= cutoffStr).sort();
+    const events = [];
+    for (const file of recentFiles) {
+      try {
+        const content = await (0, import_promises2.readFile)((0, import_node_path2.join)(this.dir, file), "utf-8");
+        for (const line of content.split("\n")) {
+          if (!line.trim()) continue;
+          try {
+            events.push(JSON.parse(line));
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    return events;
+  }
+};
+
+// src/utils/logger.ts
+var nullLogger = {
+  debug() {
+  },
+  info() {
+  },
+  warn() {
+  },
+  error() {
+  }
+};
+
+// src/mcp-server.ts
+var import_node_fs = require("fs");
+var import_node_path3 = require("path");
+var import_node_url = require("url");
+var import_meta = {};
+var __dirname = (0, import_node_path3.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
+var pkg = JSON.parse((0, import_node_fs.readFileSync)((0, import_node_path3.join)(__dirname, "..", "package.json"), "utf-8"));
+var library = new FileLibrary();
+var validator = new N8nValidator();
+var stripper = new N8nFieldStripper();
+var promptBuilder = new PromptBuilder();
+function getTelemetryReader() {
+  try {
+    return new TelemetryReader();
+  } catch {
+    return null;
+  }
+}
+function isAllowed(action) {
+  const key = `KAIROS_MCP_ALLOW_${action.toUpperCase()}`;
+  return process.env[key] === "true";
+}
+function getApiClient() {
+  const baseUrl = process.env["N8N_BASE_URL"];
+  const apiKey = process.env["N8N_API_KEY"];
+  if (!baseUrl || !apiKey) {
+    throw new Error("N8N_BASE_URL and N8N_API_KEY environment variables are required for n8n operations");
+  }
+  return new N8nApiClient(baseUrl, apiKey, nullLogger);
+}
+var server = new import_mcp.McpServer({
+  name: "kairos",
+  version: pkg.version
+});
+server.tool(
+  "kairos_prompt",
+  "Get the specialized n8n workflow generation context. Returns a system prompt with node catalog, connection rules, validation rules, plus library matches and failure patterns for the given description. Feed this to yourself as context, then generate the workflow JSON.",
+  {
+    description: import_zod.z.string().describe("Plain-English description of the workflow to build"),
+    name: import_zod.z.string().optional().describe("Optional workflow name override")
+  },
+  async ({ description, name }) => {
+    await library.initialize();
+    const matches = await library.search(description);
+    const telemetryReader = getTelemetryReader();
+    const failureRates = await telemetryReader?.getFailureRates() ?? [];
+    const request = { description, ...name ? { name } : {} };
+    const built = promptBuilder.build(request, matches, failureRates);
+    const systemText = built.system.map((block) => block.text).join("\n\n---\n\n");
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          mode: built.mode,
+          matchCount: matches.length,
+          topMatchScore: matches[0]?.score ?? null,
+          systemPrompt: systemText,
+          userMessage: built.userMessage,
+          outputFormat: {
+            description: "Generate a JSON object with this exact structure. The workflow field contains the n8n workflow. credentialsNeeded lists services requiring credentials.",
+            schema: {
+              workflow: {
+                name: "string \u2014 descriptive workflow name",
+                nodes: "array \u2014 n8n node objects with id (UUID v4), type, typeVersion, name, position, parameters",
+                connections: "object \u2014 keyed by source node NAME, maps to target nodes",
+                settings: 'object \u2014 include executionOrder: "v1"'
+              },
+              credentialsNeeded: [{
+                service: 'string \u2014 e.g. "Slack"',
+                credentialType: 'string \u2014 e.g. "slackOAuth2Api"',
+                description: "string \u2014 what the user needs to set up"
+              }]
+            }
+          }
+        }, null, 2)
+      }]
+    };
+  }
+);
+server.tool(
+  "kairos_validate",
+  "Validate n8n workflow JSON against 23 structural rules. Returns pass/fail with specific issues. If validation fails, fix the issues and call this again. Errors block deployment; warnings are advisory.",
+  {
+    workflow: import_zod.z.string().describe("The workflow JSON string to validate")
+  },
+  async ({ workflow: workflowStr }) => {
+    let parsed;
+    try {
+      parsed = JSON.parse(workflowStr);
+    } catch (e) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            valid: false,
+            error: `Invalid JSON: ${e instanceof Error ? e.message : String(e)}`
+          }, null, 2)
+        }]
+      };
+    }
+    const result = validator.validate(parsed);
+    const errors = result.issues.filter((i) => i.severity === "error");
+    const warnings = result.issues.filter((i) => i.severity === "warn");
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          valid: result.valid,
+          errorCount: errors.length,
+          warningCount: warnings.length,
+          errors: errors.map((i) => ({
+            rule: i.rule,
+            message: i.message,
+            nodeId: i.nodeId ?? null
+          })),
+          warnings: warnings.map((i) => ({
+            rule: i.rule,
+            message: i.message,
+            nodeId: i.nodeId ?? null
+          })),
+          deployable: errors.length === 0
+        }, null, 2)
+      }]
+    };
+  }
+);
+server.tool(
+  "kairos_deploy",
+  "Deploy a validated workflow to n8n. Pass the workflow JSON that passed kairos_validate. Strips server-assigned fields automatically. Requires N8N_BASE_URL and N8N_API_KEY.",
+  {
+    workflow: import_zod.z.string().describe("The validated workflow JSON string to deploy"),
+    activate: import_zod.z.boolean().default(false).describe("Activate the workflow immediately after deployment")
+  },
+  async ({ workflow: workflowStr, activate }) => {
+    if (!isAllowed("deploy")) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ error: "Deploy is disabled. Set KAIROS_MCP_ALLOW_DEPLOY=true to enable." })
+        }],
+        isError: true
+      };
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(workflowStr);
+    } catch (e) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ error: `Invalid JSON: ${e instanceof Error ? e.message : String(e)}` })
+        }]
+      };
+    }
+    const validation = validator.validate(parsed);
+    const errors = validation.issues.filter((i) => i.severity === "error");
+    if (errors.length > 0) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: "Workflow has validation errors \u2014 fix them before deploying",
+            errors: errors.map((i) => ({ rule: i.rule, message: i.message }))
+          }, null, 2)
+        }]
+      };
+    }
+    const client = getApiClient();
+    const stripped = stripper.stripForCreate(parsed);
+    const response = await client.createWorkflow(stripped);
+    if (activate) {
+      if (!isAllowed("activate")) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              workflowId: response.id,
+              name: response.name,
+              activated: false,
+              warning: "Workflow deployed but activation is disabled. Set KAIROS_MCP_ALLOW_ACTIVATE=true to enable.",
+              url: `${process.env["N8N_BASE_URL"]}/workflow/${response.id}`
+            }, null, 2)
+          }]
+        };
+      }
+      await client.activateWorkflow(response.id);
+    }
+    await library.initialize();
+    await library.save(parsed, {
+      description: parsed.name,
+      generationMode: "scratch",
+      generationAttempts: 1
+    });
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          workflowId: response.id,
+          name: response.name,
+          activated: activate,
+          url: `${process.env["N8N_BASE_URL"]}/workflow/${response.id}`
+        }, null, 2)
+      }]
+    };
+  }
+);
+server.tool(
+  "kairos_search",
+  "Search the local workflow library for similar past builds. Returns matching workflows with scores, useful for finding examples and reusing patterns.",
+  {
+    query: import_zod.z.string().describe("Search query \u2014 a workflow description or keywords"),
+    limit: import_zod.z.number().default(5).describe("Maximum number of results")
+  },
+  async ({ query, limit }) => {
+    await library.initialize();
+    const matches = await library.search(query);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(
+          matches.slice(0, limit).map((m) => ({
+            score: Number(m.score.toFixed(3)),
+            mode: m.mode,
+            description: m.workflow.description,
+            nodeCount: m.workflow.workflow.nodes.length,
+            nodes: m.workflow.workflow.nodes.map((n) => n.name),
+            failurePatterns: m.workflow.failurePatterns ?? []
+          })),
+          null,
+          2
+        )
+      }]
+    };
+  }
+);
+server.tool(
+  "kairos_list",
+  "List all workflows deployed on the connected n8n instance.",
+  {},
+  async () => {
+    const client = getApiClient();
+    const workflows = await client.listWorkflows();
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(workflows, null, 2)
+      }]
+    };
+  }
+);
+server.tool(
+  "kairos_get",
+  "Get the full JSON definition of a specific workflow by ID.",
+  {
+    workflow_id: import_zod.z.string().describe("The n8n workflow ID")
+  },
+  async ({ workflow_id }) => {
+    const client = getApiClient();
+    const workflow = await client.getWorkflow(workflow_id);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(workflow, null, 2)
+      }]
+    };
+  }
+);
+server.tool(
+  "kairos_activate",
+  "Activate a deployed workflow so it starts running on triggers.",
+  {
+    workflow_id: import_zod.z.string().describe("The n8n workflow ID to activate")
+  },
+  async ({ workflow_id }) => {
+    if (!isAllowed("activate")) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ error: "Activate is disabled. Set KAIROS_MCP_ALLOW_ACTIVATE=true to enable." })
+        }],
+        isError: true
+      };
+    }
+    const client = getApiClient();
+    await client.activateWorkflow(workflow_id);
+    return {
+      content: [{
+        type: "text",
+        text: `Activated workflow ${workflow_id}`
+      }]
+    };
+  }
+);
+server.tool(
+  "kairos_deactivate",
+  "Deactivate a running workflow.",
+  {
+    workflow_id: import_zod.z.string().describe("The n8n workflow ID to deactivate")
+  },
+  async ({ workflow_id }) => {
+    const client = getApiClient();
+    await client.deactivateWorkflow(workflow_id);
+    return {
+      content: [{
+        type: "text",
+        text: `Deactivated workflow ${workflow_id}`
+      }]
+    };
+  }
+);
+server.tool(
+  "kairos_delete",
+  "Delete a workflow from n8n. This is irreversible.",
+  {
+    workflow_id: import_zod.z.string().describe("The n8n workflow ID to delete")
+  },
+  async ({ workflow_id }) => {
+    if (!isAllowed("delete")) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ error: "Delete is disabled. Set KAIROS_MCP_ALLOW_DELETE=true to enable." })
+        }],
+        isError: true
+      };
+    }
+    const client = getApiClient();
+    await client.deleteWorkflow(workflow_id);
+    return {
+      content: [{
+        type: "text",
+        text: `Deleted workflow ${workflow_id}`
+      }]
+    };
+  }
+);
+server.tool(
+  "kairos_executions",
+  "List recent executions for a workflow, showing status and timing.",
+  {
+    workflow_id: import_zod.z.string().optional().describe("Filter to a specific workflow ID (omit for all)"),
+    limit: import_zod.z.number().default(20).describe("Maximum number of executions to return")
+  },
+  async ({ workflow_id, limit }) => {
+    const client = getApiClient();
+    const executions = await client.getExecutions(workflow_id, { limit });
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(executions, null, 2)
+      }]
+    };
+  }
+);
+async function main() {
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((err) => {
+  console.error("Kairos MCP server failed to start:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=mcp-server.cjs.map