@kairos-sdk/core 0.2.1 → 0.3.1

package/dist/chunk-KQSNT3HZ.js

@@ -0,0 +1,809 @@
+import {
+  KairosError,
+  N8nApiClient,
+  N8nFieldStripper,
+  N8nValidator,
+  PromptBuilder,
+  TelemetryReader,
+  generateUUID,
+  nullLogger,
+  scoreToMode
+} from "./chunk-RYGYNOR6.js";
+
+// 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 recordOutcome(_id, _outcome) {
+  }
+  async get(_id) {
+    return null;
+  }
+  async list(_filters) {
+    return [];
+  }
+};
+
+// 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/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/telemetry/collector.ts
+import { appendFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+
+// src/telemetry/types.ts
+var TELEMETRY_SCHEMA_VERSION = 2;
+
+// src/telemetry/collector.ts
+var TelemetryCollector = class {
+  dir;
+  sessionId;
+  dirReady = null;
+  constructor(dir) {
+    this.dir = dir ?? join(homedir(), ".kairos", "telemetry");
+    this.sessionId = generateUUID();
+  }
+  async emit(eventType, data) {
+    const event = {
+      schemaVersion: TELEMETRY_SCHEMA_VERSION,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      sessionId: this.sessionId,
+      eventType,
+      data
+    };
+    if (!this.dirReady) {
+      this.dirReady = mkdir(this.dir, { recursive: true }).then(() => {
+      });
+    }
+    await this.dirReady;
+    const filename = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10) + ".jsonl";
+    const filepath = join(this.dir, filename);
+    await appendFile(filepath, JSON.stringify(event) + "\n", "utf-8");
+  }
+};
+
+// src/client.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// 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: []
+  }
+};
+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, globalFailureRates = []) {
+    const attemptMetadata = [];
+    let lastErrors = [];
+    let attempts = 0;
+    const built = this.promptBuilder.build(request, matches, globalFailureRates);
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+      attempts = attempt;
+      const temperature = attempt === MAX_ATTEMPTS ? FINAL_TEMPERATURE : BASE_TEMPERATURE;
+      let userMessage;
+      if (attempt === 1) {
+        userMessage = built.userMessage;
+        this.logger.debug("WorkflowDesigner: attempt 1", { description: request.description });
+      } else {
+        const issueLines = lastErrors.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: lastErrors.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: validation.issues
+      });
+      if (validation.valid) {
+        return { workflow: parsed.workflow, credentialsNeeded: parsed.credentialsNeeded, attempts, attemptMetadata };
+      }
+      lastErrors = errors;
+      this.logger.warn(`WorkflowDesigner: validation failed on attempt ${attempt}`, {
+        errorCount: errors.length
+      });
+    }
+    const finalIssues = attemptMetadata.at(-1)?.issues ?? lastErrors;
+    throw new ValidationError(
+      `Workflow failed validation after ${MAX_ATTEMPTS} attempts`,
+      finalIssues
+    );
+  }
+  async callClaude(system, userMessage, temperature) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 12e4);
+    try {
+      return await this.anthropic.messages.create(
+        {
+          model: this.model,
+          max_tokens: 8192,
+          temperature,
+          system: system.map((b) => ({ type: b.type, text: b.text, ...b.cache_control ? { cache_control: b.cache_control } : {} })),
+          messages: [{ role: "user", content: userMessage }],
+          tools: [GENERATE_WORKFLOW_TOOL],
+          tool_choice: { type: "tool", name: "generate_workflow" }
+        },
+        { signal: controller.signal }
+      );
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      throw new GenerationError(`Anthropic API call failed: ${detail}`, err);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  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/client.ts
+var DEFAULT_MODEL = "claude-sonnet-4-6";
+var Kairos = class {
+  provider;
+  designer;
+  validator;
+  library;
+  logger;
+  telemetry;
+  telemetryReader;
+  model;
+  saveQueue = Promise.resolve(null);
+  constructor(options) {
+    const logger = options.logger ?? nullLogger;
+    this.model = options.model ?? DEFAULT_MODEL;
+    if (options.n8nBaseUrl && options.n8nApiKey) {
+      try {
+        new URL(options.n8nBaseUrl);
+      } catch {
+        throw new GuardError(`Invalid n8nBaseUrl: "${options.n8nBaseUrl}" \u2014 must be a valid URL`);
+      }
+      const apiClient = new N8nApiClient(options.n8nBaseUrl, options.n8nApiKey, logger);
+      const stripper = new N8nFieldStripper();
+      this.provider = new N8nProvider(apiClient, stripper);
+    } else {
+      this.provider = null;
+    }
+    const anthropic = new Anthropic({ apiKey: options.anthropicApiKey });
+    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();
+      this.telemetryReader = new TelemetryReader();
+    } else if (typeof options.telemetry === "string") {
+      this.telemetry = new TelemetryCollector(options.telemetry);
+      this.telemetryReader = new TelemetryReader(options.telemetry);
+    } else {
+      this.telemetry = null;
+      this.telemetryReader = null;
+    }
+  }
+  requireProvider() {
+    if (!this.provider) {
+      throw new GuardError("n8nBaseUrl and n8nApiKey are required for this operation \u2014 set them in the Kairos constructor, or use { dryRun: true } for generation-only mode");
+    }
+    return this.provider;
+  }
+  validateDescription(description) {
+    if (!description || description.trim().length === 0) {
+      throw new GuardError("Description is required and must be non-empty");
+    }
+  }
+  async build(description, options) {
+    this.validateDescription(description);
+    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);
+    if (matches.length > 0) {
+      const top = matches[0];
+      this.logger.info(`Library: ${matches.length} match(es), top="${top.workflow.description.slice(0, 50)}" score=${top.score.toFixed(2)} mode=${top.mode}`);
+    } else {
+      this.logger.info("Library: no matches (scratch mode)");
+    }
+    const globalFailureRates = await this.telemetryReader?.getFailureRates() ?? [];
+    if (globalFailureRates.length > 0) {
+      const highFreq = globalFailureRates.filter((r) => r.rate >= 0.15);
+      if (highFreq.length > 0) {
+        this.logger.info(`Telemetry: ${highFreq.length} high-frequency failure rule(s) will be warned about`);
+      }
+    }
+    const designResult = await this.designer.design(
+      { description, ...options?.name ? { name: options.name } : {} },
+      matches,
+      globalFailureRates
+    );
+    await this.emitAttemptTelemetry(description, designResult);
+    const workflow = options?.name ? { ...designResult.workflow, name: options.name } : designResult.workflow;
+    this.saveToLibrary(workflow, description, designResult, matches);
+    if (options?.dryRun) {
+      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 {
+        workflowId: null,
+        name: workflow.name,
+        workflow,
+        credentialsNeeded: designResult.credentialsNeeded,
+        activationRequired: true,
+        generationAttempts: designResult.attempts,
+        dryRun: true
+      };
+    }
+    const provider = this.requireProvider();
+    const deployed = await provider.deploy(workflow);
+    this.recordDeploy();
+    if (options?.activate) {
+      await provider.activate(deployed.workflowId);
+    }
+    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 {
+      workflowId: deployed.workflowId,
+      name: deployed.name,
+      workflow,
+      credentialsNeeded: designResult.credentialsNeeded,
+      activationRequired: !options?.activate,
+      generationAttempts: designResult.attempts,
+      dryRun: false
+    };
+  }
+  async replace(id, description) {
+    this.validateDescription(description);
+    this.logger.info("Kairos.update", { id, description });
+    const buildStart = Date.now();
+    await this.telemetry?.emit("build_start", {
+      description,
+      model: this.model,
+      dryRun: false
+    });
+    await this.library.initialize();
+    const matches = await this.library.search(description);
+    const globalFailureRates = await this.telemetryReader?.getFailureRates() ?? [];
+    const designResult = await this.designer.design({ description }, matches, globalFailureRates);
+    await this.emitAttemptTelemetry(description, designResult);
+    const provider = this.requireProvider();
+    const deployed = await provider.update(id, designResult.workflow);
+    this.saveToLibrary(designResult.workflow, description, designResult, matches);
+    this.recordDeploy();
+    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 {
+      workflowId: deployed.workflowId,
+      name: deployed.name,
+      workflow: designResult.workflow,
+      credentialsNeeded: designResult.credentialsNeeded,
+      activationRequired: true,
+      generationAttempts: designResult.attempts,
+      dryRun: false
+    };
+  }
+  async drain() {
+    await this.saveQueue.catch(() => {
+    });
+  }
+  async emitAttemptTelemetry(description, designResult) {
+    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 }))
+      });
+    }
+  }
+  recordDeploy() {
+    this.saveQueue = this.saveQueue.then(async (savedId) => {
+      if (savedId) {
+        await this.library.recordDeployment(savedId);
+      }
+      return savedId;
+    }).catch((err) => {
+      this.logger.warn("Failed to record deployment (non-fatal)", { err: String(err) });
+      return null;
+    });
+  }
+  saveToLibrary(workflow, description, designResult, matches) {
+    const failedAttempts = designResult.attemptMetadata.filter((m) => !m.validationPassed);
+    const failurePatterns = failedAttempts.flatMap(
+      (m) => m.issues.map((i) => ({ rule: i.rule, message: i.message }))
+    );
+    const topMatch = matches[0];
+    const generationMode = topMatch ? scoreToMode(topMatch.score) : "scratch";
+    const autoTags = Array.from(new Set(
+      workflow.nodes.flatMap((n) => {
+        const bare = n.type.split(".").pop() ?? "";
+        const tags = [bare];
+        if (n.type.includes("Trigger") || n.type.includes("trigger")) tags.push(`trigger:${bare}`);
+        if (n.type.includes("langchain")) tags.push("ai");
+        return tags;
+      })
+    ));
+    const metadata = {
+      description,
+      generationMode,
+      generationAttempts: designResult.attempts
+    };
+    if (autoTags.length > 0) metadata.tags = autoTags;
+    if (failurePatterns.length > 0) metadata.failurePatterns = failurePatterns;
+    if (matches.length > 0) metadata.sourceWorkflowIds = matches.map((m) => m.workflow.id);
+    if (topMatch) metadata.topMatchScore = topMatch.score;
+    if (designResult.credentialsNeeded.length > 0) metadata.credentialsNeeded = designResult.credentialsNeeded;
+    const firstTryPass = designResult.attemptMetadata.length > 0 && designResult.attemptMetadata[0].validationPassed;
+    const failedRules = Array.from(new Set(
+      designResult.attemptMetadata.filter((m) => !m.validationPassed).flatMap((m) => m.issues.map((i) => i.rule))
+    ));
+    this.saveQueue = this.saveQueue.then(async () => {
+      const savedId = await this.library.save(workflow, metadata);
+      for (const match of matches) {
+        if (match.mode === "direct" || match.mode === "reference") {
+          await this.library.recordOutcome(match.workflow.id, {
+            attempts: designResult.attempts,
+            firstTryPass,
+            failedRules,
+            mode: match.mode
+          });
+        }
+      }
+      return savedId;
+    }).catch((err) => {
+      this.logger.warn("Failed to save workflow to library (non-fatal)", { err: String(err) });
+      return null;
+    });
+  }
+  async get(id) {
+    return this.requireProvider().get(id);
+  }
+  async list() {
+    return this.requireProvider().list();
+  }
+  async activate(id) {
+    await this.requireProvider().activate(id);
+  }
+  async deactivate(id) {
+    await this.requireProvider().deactivate(id);
+  }
+  async delete(id, options) {
+    await this.requireProvider().delete(id, options);
+  }
+  async executions(workflowId, filter) {
+    return this.requireProvider().executions(workflowId, filter);
+  }
+  async execution(id) {
+    return this.requireProvider().execution(id);
+  }
+  async listTags() {
+    return this.requireProvider().listTags();
+  }
+  async createTag(name) {
+    return this.requireProvider().createTag(name);
+  }
+  async tag(workflowId, tagIds) {
+    await this.requireProvider().tag(workflowId, tagIds);
+  }
+  async untag(workflowId, tagIds) {
+    await this.requireProvider().untag(workflowId, tagIds);
+  }
+};
+
+// src/templates/safety.ts
+var BLOCKED_NODE_TYPES = /* @__PURE__ */ new Set([
+  "n8n-nodes-base.code",
+  "n8n-nodes-base.executeCommand",
+  "n8n-nodes-base.ssh"
+]);
+var REVIEW_NODE_TYPES = /* @__PURE__ */ new Set([
+  "n8n-nodes-base.httpRequest"
+]);
+var SECRET_PATTERNS = [
+  /sk-[a-zA-Z0-9]{20,}/,
+  /ghp_[a-zA-Z0-9]{36}/,
+  /xoxb-[0-9]+-[0-9]+-[a-zA-Z0-9]+/,
+  /AIza[a-zA-Z0-9_-]{35}/,
+  /AKIA[A-Z0-9]{16}/
+];
+function assessTemplateSafety(workflow) {
+  const reasons = [];
+  let worst = "safe";
+  const escalate = (level, reason) => {
+    reasons.push(reason);
+    if (level === "blocked") worst = "blocked";
+    else if (level === "review" && worst === "safe") worst = "review";
+  };
+  for (const node of workflow.nodes) {
+    if (BLOCKED_NODE_TYPES.has(node.type)) {
+      escalate("blocked", `Contains ${node.type} node "${node.name}"`);
+    }
+    if (REVIEW_NODE_TYPES.has(node.type)) {
+      escalate("review", `Contains ${node.type} node "${node.name}"`);
+    }
+    const paramStr = JSON.stringify(node.parameters);
+    for (const pattern of SECRET_PATTERNS) {
+      if (pattern.test(paramStr)) {
+        escalate("blocked", `Node "${node.name}" parameters contain a hardcoded secret`);
+        break;
+      }
+    }
+  }
+  return { trustLevel: worst, reasons };
+}
+
+// src/templates/syncer.ts
+var N8N_TEMPLATE_API = "https://api.n8n.io/api/templates";
+var PAGE_SIZE = 50;
+var DELAY_BETWEEN_FETCHES_MS = 200;
+var DEFAULT_SETTINGS = {
+  executionOrder: "v1",
+  saveManualExecutions: true,
+  timezone: "UTC"
+};
+var TemplateSyncer = class {
+  constructor(library, logger) {
+    this.library = library;
+    this.validator = new N8nValidator();
+    this.logger = logger;
+  }
+  library;
+  validator;
+  logger;
+  async sync(options) {
+    const maxTemplates = options?.maxTemplates ?? 500;
+    await this.library.initialize();
+    const existing = await this.library.list();
+    const existingSourceIds = new Set(
+      existing.filter((w) => w.sourceKind === "n8n-template" && w.sourceId).map((w) => w.sourceId)
+    );
+    const progress = {
+      total: 0,
+      processed: 0,
+      saved: 0,
+      skippedPaid: 0,
+      skippedDuplicate: 0,
+      blocked: 0,
+      reviewed: 0
+    };
+    const templateIds = await this.fetchTemplateIds(maxTemplates, progress);
+    for (const id of templateIds) {
+      if (existingSourceIds.has(String(id))) {
+        progress.skippedDuplicate++;
+        progress.processed++;
+        options?.onProgress?.(progress);
+        continue;
+      }
+      try {
+        await this.processTemplate(id, progress);
+      } catch (err) {
+        this.logger.warn(`Failed to process template ${id}`, { err: String(err) });
+      }
+      progress.processed++;
+      options?.onProgress?.(progress);
+      await new Promise((resolve) => setTimeout(resolve, DELAY_BETWEEN_FETCHES_MS));
+    }
+    return progress;
+  }
+  async fetchTemplateIds(max, progress) {
+    const ids = [];
+    let page = 1;
+    while (ids.length < max) {
+      const url = `${N8N_TEMPLATE_API}/search?page=${page}&rows=${PAGE_SIZE}`;
+      const response = await fetch(url);
+      if (!response.ok) break;
+      const data = await response.json();
+      progress.total = Math.min(data.totalWorkflows, max);
+      for (const template of data.workflows) {
+        if (ids.length >= max) break;
+        if (template.price && template.price > 0) {
+          progress.skippedPaid++;
+          continue;
+        }
+        ids.push(template.id);
+      }
+      if (data.workflows.length < PAGE_SIZE) break;
+      page++;
+      await new Promise((resolve) => setTimeout(resolve, DELAY_BETWEEN_FETCHES_MS));
+    }
+    return ids;
+  }
+  async processTemplate(id, progress) {
+    const url = `${N8N_TEMPLATE_API}/workflows/${id}`;
+    const response = await fetch(url);
+    if (!response.ok) return;
+    const data = await response.json();
+    const templateMeta = data.workflow;
+    const rawWorkflow = templateMeta.workflow;
+    if (!rawWorkflow?.nodes?.length) return;
+    const workflow = {
+      name: templateMeta.name,
+      nodes: rawWorkflow.nodes.filter((n) => n.type && n.name),
+      connections: rawWorkflow.connections,
+      settings: rawWorkflow.settings ? { executionOrder: "v1", ...rawWorkflow.settings } : { ...DEFAULT_SETTINGS }
+    };
+    const validation = this.validator.validate(workflow);
+    const validationErrors = validation.issues.filter((i) => i.severity === "error");
+    if (validationErrors.length > 0) {
+      progress.blocked++;
+      this.logger.debug(`Template ${id} blocked: ${validationErrors.length} validation errors`);
+      return;
+    }
+    const safety = assessTemplateSafety(workflow);
+    if (safety.trustLevel === "blocked") {
+      progress.blocked++;
+      this.logger.debug(`Template ${id} blocked: ${safety.reasons.join(", ")}`);
+      return;
+    }
+    if (safety.trustLevel === "review") {
+      progress.reviewed++;
+    }
+    const description = this.cleanDescription(templateMeta.description);
+    const autoTags = Array.from(new Set(
+      workflow.nodes.flatMap((n) => {
+        const bare = n.type.split(".").pop() ?? "";
+        const tags = [bare];
+        if (n.type.includes("Trigger") || n.type.includes("trigger")) tags.push(`trigger:${bare}`);
+        if (n.type.includes("langchain")) tags.push("ai");
+        return tags;
+      })
+    ));
+    const metadata = {
+      description,
+      tags: autoTags,
+      sourceKind: "n8n-template",
+      sourceId: String(id),
+      sourceUrl: `https://n8n.io/workflows/${id}`,
+      trustLevel: safety.trustLevel
+    };
+    await this.library.save(workflow, metadata);
+    progress.saved++;
+    this.logger.debug(`Template ${id} saved: "${templateMeta.name}" (${safety.trustLevel})`);
+  }
+  cleanDescription(raw) {
+    return raw.replace(/#{1,6}\s*/g, "").replace(/\*{1,2}([^*]+)\*{1,2}/g, "$1").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\n{3,}/g, "\n\n").trim().slice(0, 500);
+  }
+};
+
+export {
+  NullLibrary,
+  GuardError,
+  N8nProvider,
+  GenerationError,
+  ResponseParseError,
+  ValidationError,
+  TelemetryCollector,
+  Kairos,
+  TemplateSyncer
+};
+//# sourceMappingURL=chunk-KQSNT3HZ.js.map