@kairos-sdk/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1456 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ApiError: () => ApiError,
+  DEFAULT_REGISTRY: () => DEFAULT_REGISTRY,
+  FileLibrary: () => FileLibrary,
+  GenerationError: () => GenerationError,
+  GuardError: () => GuardError,
+  Kairos: () => Kairos,
+  KairosError: () => KairosError,
+  N8nApiClient: () => N8nApiClient,
+  N8nFieldStripper: () => N8nFieldStripper,
+  N8nProvider: () => N8nProvider,
+  N8nValidator: () => N8nValidator,
+  NodeRegistry: () => NodeRegistry,
+  NullLibrary: () => NullLibrary,
+  ProviderError: () => ProviderError,
+  ResponseParseError: () => ResponseParseError,
+  TelemetryCollector: () => TelemetryCollector,
+  ValidationError: () => ValidationError,
+  nullLogger: () => nullLogger
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_sdk = __toESM(require("@anthropic-ai/sdk"), 1);
+
+// src/utils/uuid.ts
+function generateUUID() {
+  return crypto.randomUUID();
+}
+
+// src/library/null-library.ts
+var NullLibrary = class {
+  async initialize() {
+  }
+  async search(_description, _options) {
+    return [];
+  }
+  async save(_workflow, _metadata) {
+    return generateUUID();
+  }
+  async recordDeployment(_id) {
+  }
+  async get(_id) {
+    return null;
+  }
+  async list(_filters) {
+    return [];
+  }
+};
+
+// src/errors/base.ts
+var KairosError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "KairosError";
+  }
+  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/providers/n8n/api-client.ts
+var EXECUTION_LIMIT_CAP = 100;
+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}`);
+    let response;
+    try {
+      response = await fetch(url, {
+        method,
+        headers: {
+          "X-N8N-API-KEY": this.apiKey,
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+      });
+    } 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 response = await this.request("GET", "/workflows?limit=250");
+    return response.data.map((w) => ({
+      id: w.id,
+      name: w.name,
+      active: w.active,
+      createdAt: w.createdAt,
+      updatedAt: w.updatedAt,
+      ...w.tags !== void 0 ? { tags: w.tags } : {}
+    }));
+  }
+  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 response = await this.request("GET", "/tags");
+    return response.data.map((t) => ({ id: t.id, name: t.name }));
+  }
+  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/providers/n8n/types.ts
+var FORBIDDEN_ON_CREATE = [
+  "id",
+  "createdAt",
+  "updatedAt",
+  "versionId",
+  "meta",
+  "isArchived",
+  "activeVersionId",
+  "activeVersion",
+  "active",
+  "pinData",
+  "triggerCount",
+  "shared"
+];
+var FORBIDDEN_ON_UPDATE = FORBIDDEN_ON_CREATE.filter((f) => f !== "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/guard-error.ts
+var GuardError = class extends KairosError {
+  constructor(message) {
+    super(message);
+    this.name = "GuardError";
+  }
+};
+
+// src/providers/n8n/provider.ts
+var N8nProvider = class {
+  constructor(client, stripper) {
+    this.client = client;
+    this.stripper = stripper;
+  }
+  client;
+  stripper;
+  platform = "n8n";
+  async deploy(workflow) {
+    const stripped = this.stripper.stripForCreate(workflow);
+    const response = await this.client.createWorkflow(stripped);
+    return { workflowId: response.id, name: response.name };
+  }
+  async update(id, workflow) {
+    const stripped = this.stripper.stripForUpdate(workflow);
+    const response = await this.client.updateWorkflow(id, stripped);
+    return { workflowId: response.id, name: response.name };
+  }
+  async get(id) {
+    const response = await this.client.getWorkflow(id);
+    return {
+      name: response.name,
+      nodes: response.nodes,
+      connections: response.connections,
+      ...response.settings !== void 0 ? { settings: response.settings } : {},
+      ...response.tags !== void 0 ? { tags: response.tags } : {}
+    };
+  }
+  async list() {
+    return this.client.listWorkflows();
+  }
+  async activate(id) {
+    await this.client.activateWorkflow(id);
+  }
+  async deactivate(id) {
+    await this.client.deactivateWorkflow(id);
+  }
+  async delete(id, options) {
+    if (options.confirm !== true) {
+      throw new GuardError("delete() requires { confirm: true } to prevent accidental deletion");
+    }
+    await this.client.deleteWorkflow(id);
+  }
+  async executions(workflowId, filter) {
+    return this.client.getExecutions(workflowId, filter);
+  }
+  async execution(id) {
+    return this.client.getExecution(id);
+  }
+  async listTags() {
+    return this.client.listTags();
+  }
+  async createTag(name) {
+    return this.client.createTag(name);
+  }
+  async tag(workflowId, tagIds) {
+    await this.client.tagWorkflow(workflowId, tagIds);
+  }
+  async untag(workflowId, tagIds) {
+    await this.client.untagWorkflow(workflowId, tagIds);
+  }
+};
+
+// 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.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: [] }
+];
+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;
+  }
+  isVersionSafe(type, version) {
+    const def = this.byType.get(type);
+    if (!def) return true;
+    return def.safeTypeVersions.includes(version);
+  }
+};
+
+// 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);
+    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 (!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 (WARN): AI connections 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.warn(
+            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
+        );
+      }
+    }
+  }
+};
+
+// src/errors/generation-error.ts
+var GenerationError = class extends KairosError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "GenerationError";
+  }
+};
+
+// src/errors/response-parse-error.ts
+var ResponseParseError = class extends KairosError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "ResponseParseError";
+  }
+};
+
+// src/errors/validation-error.ts
+var ValidationError = class extends KairosError {
+  constructor(message, issues) {
+    super(message);
+    this.issues = issues;
+    this.name = "ValidationError";
+  }
+  issues;
+};
+
+// 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": "America/New_York",
+    "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 }] ] }
+
+### Triggers have no incoming connections.
+### Connection keys are NODE NAMES, never node IDs.
+
+---
+
+## 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):
+@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
+@n8n/n8n-nodes-langchain.anthropic    typeVersion: 1       \u2014 cred: anthropicApi
+
+### AI \u2014 Sub-nodes (sources of ai_* connections):
+@n8n/n8n-nodes-langchain.lmChatOpenAi      typeVersion: 1.7  \u2014 cred: openAiApi       \u2014 ai_languageModel
+@n8n/n8n-nodes-langchain.lmChatAnthropic   typeVersion: 1.3  \u2014 cred: anthropicApi    \u2014 ai_languageModel
+@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 PromptBuilder = class {
+  build(request, matches) {
+    const mode = this.resolveMode(matches);
+    const system = this.buildSystem(matches, mode);
+    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";
+    if (top.score >= 0.92) return "direct";
+    if (top.score >= 0.72) return "reference";
+    return "scratch";
+  }
+  buildSystem(matches, mode) {
+    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];
+      blocks.push({
+        type: "text",
+        text: `## Closely Matched Workflow (score: ${match.score.toFixed(2)}) \u2014 adapt this structure:
+
+${JSON.stringify(match.workflow.workflow, null, 2)}`
+      });
+    }
+    return blocks;
+  }
+  buildUserMessage(request, _matches, _mode) {
+    const namePart = request.name ? `
+Workflow name: "${request.name}"` : "";
+    return `Build a workflow that: ${request.description}${namePart}`;
+  }
+};
+
+// src/generation/designer.ts
+var MAX_ATTEMPTS = 3;
+var BASE_TEMPERATURE = 0.2;
+var FINAL_TEMPERATURE = 0.1;
+var GENERATE_WORKFLOW_TOOL = {
+  name: "generate_workflow",
+  description: "Generate a valid n8n workflow JSON object",
+  input_schema: {
+    type: "object",
+    properties: {
+      workflow: {
+        type: "object",
+        description: "The complete n8n workflow object",
+        properties: {
+          name: { type: "string" },
+          nodes: { type: "array" },
+          connections: { type: "object" },
+          settings: { type: "object" }
+        },
+        required: ["name", "nodes", "connections"]
+      },
+      credentialsNeeded: {
+        type: "array",
+        description: "List of credentials the user must configure before activating",
+        items: {
+          type: "object",
+          properties: {
+            service: { type: "string" },
+            credentialType: { type: "string" },
+            description: { type: "string" }
+          },
+          required: ["service", "credentialType", "description"]
+        }
+      },
+      error: {
+        type: "string",
+        description: "Set this if the request cannot be fulfilled \u2014 explain why"
+      }
+    },
+    required: ["workflow"]
+  }
+};
+var WorkflowDesigner = class {
+  constructor(anthropic, model, logger) {
+    this.anthropic = anthropic;
+    this.model = model;
+    this.logger = logger;
+    this.validator = new N8nValidator();
+    this.promptBuilder = new PromptBuilder();
+  }
+  anthropic;
+  model;
+  logger;
+  validator;
+  promptBuilder;
+  async design(request, matches) {
+    const allIssues = [];
+    const attemptMetadata = [];
+    let attempts = 0;
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+      attempts = attempt;
+      const temperature = attempt === MAX_ATTEMPTS ? FINAL_TEMPERATURE : BASE_TEMPERATURE;
+      const built = this.promptBuilder.build(request, matches);
+      let userMessage;
+      if (attempt === 1) {
+        userMessage = built.userMessage;
+        this.logger.debug("WorkflowDesigner: attempt 1", { description: request.description });
+      } else {
+        const issueLines = allIssues.map(
+          (i) => `- [Rule ${i.rule}] ${i.message}${i.nodeId ? ` (node: ${i.nodeId})` : ""}`
+        );
+        userMessage = this.promptBuilder.buildCorrectionMessage(request, matches, issueLines, attempt - 1);
+        this.logger.debug(`WorkflowDesigner: correction attempt ${attempt}`, { issueCount: allIssues.length });
+      }
+      const start = Date.now();
+      const message = await this.callClaude(built.system, userMessage, temperature);
+      const durationMs = Date.now() - start;
+      const parsed = this.extractToolUse(message);
+      if (parsed.error) {
+        throw new GenerationError(`Claude declined to generate workflow: ${parsed.error}`);
+      }
+      const validation = this.validator.validate(parsed.workflow);
+      const errors = validation.issues.filter((i) => i.severity === "error");
+      attemptMetadata.push({
+        attempt,
+        temperature,
+        durationMs,
+        tokensInput: message.usage.input_tokens,
+        tokensOutput: message.usage.output_tokens,
+        validationPassed: validation.valid,
+        issues: errors
+      });
+      if (validation.valid) {
+        return { workflow: parsed.workflow, credentialsNeeded: parsed.credentialsNeeded, attempts, attemptMetadata };
+      }
+      allIssues.push(...errors);
+      this.logger.warn(`WorkflowDesigner: validation failed on attempt ${attempt}`, {
+        newErrors: errors.length,
+        totalErrors: allIssues.length
+      });
+    }
+    throw new ValidationError(
+      `Workflow failed validation after ${MAX_ATTEMPTS} attempts (${allIssues.length} total errors)`,
+      allIssues
+    );
+  }
+  async callClaude(system, userMessage, temperature) {
+    try {
+      return await this.anthropic.messages.create({
+        model: this.model,
+        max_tokens: 8192,
+        temperature,
+        system,
+        messages: [{ role: "user", content: userMessage }],
+        tools: [GENERATE_WORKFLOW_TOOL],
+        tool_choice: { type: "tool", name: "generate_workflow" }
+      });
+    } catch (err) {
+      throw new GenerationError("Anthropic API call failed", err);
+    }
+  }
+  extractToolUse(message) {
+    const toolUseBlock = message.content.find(
+      (block) => block.type === "tool_use"
+    );
+    if (!toolUseBlock) {
+      throw new ResponseParseError(
+        "Claude response contained no tool_use block \u2014 forced tool_choice failed unexpectedly"
+      );
+    }
+    const input = toolUseBlock.input;
+    if (typeof input["error"] === "string") {
+      return {
+        workflow: { name: "", nodes: [], connections: {} },
+        credentialsNeeded: [],
+        error: input["error"]
+      };
+    }
+    if (!input["workflow"] || typeof input["workflow"] !== "object") {
+      throw new ResponseParseError("generate_workflow tool call missing workflow field");
+    }
+    const workflow = input["workflow"];
+    const credentialsNeeded = input["credentialsNeeded"] ?? [];
+    return { workflow, credentialsNeeded };
+  }
+};
+
+// src/telemetry/collector.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var import_node_os = require("os");
+var TelemetryCollector = class {
+  dir;
+  sessionId;
+  constructor(dir) {
+    this.dir = dir ?? (0, import_node_path.join)((0, import_node_os.homedir)(), ".kairos", "telemetry");
+    this.sessionId = generateUUID();
+  }
+  async emit(eventType, data) {
+    const event = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      sessionId: this.sessionId,
+      eventType,
+      data
+    };
+    await (0, import_promises.mkdir)(this.dir, { recursive: true });
+    const filename = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10) + ".jsonl";
+    const filepath = (0, import_node_path.join)(this.dir, filename);
+    await (0, import_promises.appendFile)(filepath, JSON.stringify(event) + "\n", "utf-8");
+  }
+};
+
+// src/utils/logger.ts
+var nullLogger = {
+  debug() {
+  },
+  info() {
+  },
+  warn() {
+  },
+  error() {
+  }
+};
+
+// src/client.ts
+var DEFAULT_MODEL = "claude-sonnet-4-6";
+var Kairos = class {
+  provider;
+  designer;
+  validator;
+  library;
+  logger;
+  telemetry;
+  model;
+  constructor(options) {
+    const logger = options.logger ?? nullLogger;
+    this.model = options.model ?? DEFAULT_MODEL;
+    const anthropic = new import_sdk.default({ apiKey: options.anthropicApiKey });
+    const apiClient = new N8nApiClient(options.n8nBaseUrl, options.n8nApiKey, logger);
+    const stripper = new N8nFieldStripper();
+    this.provider = new N8nProvider(apiClient, stripper);
+    this.designer = new WorkflowDesigner(anthropic, this.model, logger);
+    this.validator = new N8nValidator();
+    this.library = options.library ?? new NullLibrary();
+    this.logger = logger;
+    if (options.telemetry === true) {
+      this.telemetry = new TelemetryCollector();
+    } else if (typeof options.telemetry === "string") {
+      this.telemetry = new TelemetryCollector(options.telemetry);
+    } else {
+      this.telemetry = null;
+    }
+  }
+  async build(description, options) {
+    this.logger.info("Kairos.build", { description, dryRun: options?.dryRun });
+    const buildStart = Date.now();
+    await this.telemetry?.emit("build_start", {
+      description,
+      model: this.model,
+      dryRun: options?.dryRun ?? false
+    });
+    await this.library.initialize();
+    const matches = await this.library.search(description);
+    const designResult = await this.designer.design(
+      { description, ...options?.name ? { name: options.name } : {} },
+      matches
+    );
+    for (const meta of designResult.attemptMetadata) {
+      await this.telemetry?.emit("generation_attempt", {
+        description,
+        attempt: meta.attempt,
+        temperature: meta.temperature,
+        durationMs: meta.durationMs,
+        tokensInput: meta.tokensInput,
+        tokensOutput: meta.tokensOutput,
+        validationPassed: meta.validationPassed,
+        issueCount: meta.issues.length,
+        issues: meta.issues.map((i) => ({ rule: i.rule, message: i.message }))
+      });
+    }
+    const workflow = options?.name ? { ...designResult.workflow, name: options.name } : designResult.workflow;
+    if (options?.dryRun) {
+      const result2 = {
+        workflowId: null,
+        name: workflow.name,
+        credentialsNeeded: designResult.credentialsNeeded,
+        activationRequired: true,
+        generationAttempts: designResult.attempts,
+        dryRun: true
+      };
+      const totalTokensInput2 = designResult.attemptMetadata.reduce((s, m) => s + m.tokensInput, 0);
+      const totalTokensOutput2 = designResult.attemptMetadata.reduce((s, m) => s + m.tokensOutput, 0);
+      await this.telemetry?.emit("build_complete", {
+        description,
+        success: true,
+        totalAttempts: designResult.attempts,
+        totalDurationMs: Date.now() - buildStart,
+        totalTokensInput: totalTokensInput2,
+        totalTokensOutput: totalTokensOutput2,
+        workflowName: workflow.name,
+        workflowId: null,
+        dryRun: true,
+        credentialsNeeded: designResult.credentialsNeeded.length
+      });
+      return result2;
+    }
+    const deployed = await this.provider.deploy(workflow);
+    this.library.save(workflow, { description }).catch((err) => {
+      this.logger.warn("Failed to save workflow to library (non-fatal)", { err: String(err) });
+    });
+    if (options?.activate) {
+      await this.provider.activate(deployed.workflowId);
+    }
+    const result = {
+      workflowId: deployed.workflowId,
+      name: deployed.name,
+      credentialsNeeded: designResult.credentialsNeeded,
+      activationRequired: !options?.activate,
+      generationAttempts: designResult.attempts,
+      dryRun: false
+    };
+    const totalTokensInput = designResult.attemptMetadata.reduce((s, m) => s + m.tokensInput, 0);
+    const totalTokensOutput = designResult.attemptMetadata.reduce((s, m) => s + m.tokensOutput, 0);
+    await this.telemetry?.emit("build_complete", {
+      description,
+      success: true,
+      totalAttempts: designResult.attempts,
+      totalDurationMs: Date.now() - buildStart,
+      totalTokensInput,
+      totalTokensOutput,
+      workflowName: deployed.name,
+      workflowId: deployed.workflowId,
+      dryRun: false,
+      credentialsNeeded: designResult.credentialsNeeded.length
+    });
+    return result;
+  }
+  async update(id, description) {
+    this.logger.info("Kairos.update", { id, description });
+    const matches = await this.library.search(description);
+    const designResult = await this.designer.design({ description }, matches);
+    const deployed = await this.provider.update(id, designResult.workflow);
+    return {
+      workflowId: deployed.workflowId,
+      name: deployed.name,
+      credentialsNeeded: designResult.credentialsNeeded,
+      activationRequired: true,
+      generationAttempts: designResult.attempts,
+      dryRun: false
+    };
+  }
+  async get(id) {
+    return this.provider.get(id);
+  }
+  async list() {
+    return this.provider.list();
+  }
+  async activate(id) {
+    await this.provider.activate(id);
+  }
+  async deactivate(id) {
+    await this.provider.deactivate(id);
+  }
+  async delete(id, options) {
+    await this.provider.delete(id, options);
+  }
+  async executions(workflowId, filter) {
+    return this.provider.executions(workflowId, filter);
+  }
+  async execution(id) {
+    return this.provider.execution(id);
+  }
+  async listTags() {
+    return this.provider.listTags();
+  }
+  async createTag(name) {
+    return this.provider.createTag(name);
+  }
+  async tag(workflowId, tagIds) {
+    await this.provider.tag(workflowId, tagIds);
+  }
+  async untag(workflowId, tagIds) {
+    await this.provider.untag(workflowId, tagIds);
+  }
+};
+
+// src/library/file-library.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = require("path");
+var import_node_os2 = require("os");
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length > 2);
+}
+function computeTfIdf(queryTokens, docTokens, idf) {
+  if (docTokens.length === 0) return 0;
+  let score = 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 = (docFreq.get(qt) ?? 0) / docTokens.length;
+    const idfVal = idf.get(qt) ?? 0;
+    score += tf * idfVal;
+  }
+  return score;
+}
+var FileLibrary = class {
+  dir;
+  workflows = [];
+  initialized = false;
+  constructor(dir) {
+    this.dir = dir ?? (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".kairos", "library");
+  }
+  async initialize() {
+    if (this.initialized) return;
+    await (0, import_promises2.mkdir)(this.dir, { recursive: true });
+    const indexPath = (0, import_node_path2.join)(this.dir, "index.json");
+    try {
+      const raw = await (0, import_promises2.readFile)(indexPath, "utf-8");
+      this.workflows = JSON.parse(raw);
+    } catch {
+      this.workflows = [];
+    }
+    this.initialized = true;
+  }
+  async search(description, options) {
+    if (this.workflows.length === 0) return [];
+    const limit = options?.limit ?? 3;
+    const queryTokens = tokenize(description);
+    if (queryTokens.length === 0) return [];
+    const docTokenSets = this.workflows.map(
+      (w) => tokenize(`${w.description} ${w.workflow.name} ${w.tags.join(" ")}`)
+    );
+    const docCount = this.workflows.length;
+    const idf = /* @__PURE__ */ new Map();
+    const allTokens = new Set(queryTokens);
+    for (const token of allTokens) {
+      const docsWithToken = docTokenSets.filter((d) => d.includes(token)).length;
+      idf.set(token, Math.log((docCount + 1) / (docsWithToken + 1)) + 1);
+    }
+    const scored = this.workflows.map((w, i) => ({
+      workflow: w,
+      score: computeTfIdf(queryTokens, docTokenSets[i], idf)
+    })).filter((m) => m.score > 0).sort((a, b) => b.score - a.score).slice(0, limit);
+    return scored.map((m) => ({
+      workflow: m.workflow,
+      score: m.score,
+      mode: m.score > 0.5 ? "direct" : "reference"
+    }));
+  }
+  async save(workflow, metadata) {
+    const id = generateUUID();
+    const stored = {
+      id,
+      workflow,
+      description: metadata.description,
+      tags: metadata.tags ?? [],
+      platform: metadata.platform ?? "n8n",
+      deployCount: 1,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.workflows.push(stored);
+    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 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;
+  }
+  async persist() {
+    const indexPath = (0, import_node_path2.join)(this.dir, "index.json");
+    await (0, import_promises2.writeFile)(indexPath, JSON.stringify(this.workflows, null, 2), "utf-8");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiError,
+  DEFAULT_REGISTRY,
+  FileLibrary,
+  GenerationError,
+  GuardError,
+  Kairos,
+  KairosError,
+  N8nApiClient,
+  N8nFieldStripper,
+  N8nProvider,
+  N8nValidator,
+  NodeRegistry,
+  NullLibrary,
+  ProviderError,
+  ResponseParseError,
+  TelemetryCollector,
+  ValidationError,
+  nullLogger
+});
+//# sourceMappingURL=index.cjs.map