@memgrafter/flatagents 0.8.0

package/dist/index.js

@@ -0,0 +1,1700 @@
+"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, {
+  CheckpointManager: () => CheckpointManager,
+  CompositeHooks: () => CompositeHooks,
+  DefaultExecution: () => DefaultExecution,
+  FlatAgent: () => FlatAgent,
+  FlatMachine: () => FlatMachine,
+  LocalFileBackend: () => LocalFileBackend,
+  LocalFileLock: () => LocalFileLock,
+  MCPToolProvider: () => MCPToolProvider,
+  MDAPVotingExecution: () => MDAPVotingExecution,
+  MemoryBackend: () => MemoryBackend,
+  MockLLMBackend: () => MockLLMBackend,
+  NoOpLock: () => NoOpLock,
+  ParallelExecution: () => ParallelExecution,
+  ProfileManager: () => ProfileManager,
+  RetryExecution: () => RetryExecution,
+  VercelAIBackend: () => VercelAIBackend,
+  WebhookHooks: () => WebhookHooks,
+  evaluate: () => evaluate,
+  getExecutionType: () => getExecutionType,
+  inMemoryResultBackend: () => inMemoryResultBackend,
+  resolveModelConfig: () => resolveModelConfig,
+  setTemplateAllowlist: () => setTemplateAllowlist
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/flatagent.ts
+var yaml2 = __toESM(require("yaml"));
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+
+// src/mcp.ts
+var import_client = require("@modelcontextprotocol/sdk/client/index.js");
+var import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
+var MCPToolProvider = class {
+  constructor() {
+    this.clients = /* @__PURE__ */ new Map();
+  }
+  async connect(servers) {
+    if (!servers || typeof servers !== "object") {
+      return;
+    }
+    for (const [name, server] of Object.entries(servers)) {
+      if (!name || !server || typeof server !== "object") {
+        continue;
+      }
+      const command = typeof server.command === "string" ? server.command.trim() : "";
+      if (!command) {
+        continue;
+      }
+      try {
+        const transport = new import_stdio.StdioClientTransport({
+          command,
+          args: server.args || [],
+          env: server.env
+        });
+        const client = new import_client.Client({ name, version: "1.0.0" });
+        await client.connect(transport);
+        this.clients.set(name, client);
+      } catch {
+      }
+    }
+  }
+  async listTools(filter) {
+    const tools = [];
+    for (const [serverName, client] of this.clients) {
+      const { tools: serverTools } = await client.listTools();
+      for (const tool of serverTools) {
+        const name = `${serverName}:${tool.name}`;
+        if (this.matchesFilter(name, filter)) tools.push({ ...tool, name });
+      }
+    }
+    return tools;
+  }
+  async callTool(name, args) {
+    const [server, tool] = name.split(":");
+    const client = this.clients.get(server);
+    if (!client) {
+      throw new Error(`MCP server '${server}' not found`);
+    }
+    return client.callTool({ name: tool, arguments: args });
+  }
+  matchesFilter(name, filter) {
+    if (filter?.deny?.some((p) => this.match(name, p))) return false;
+    if (filter?.allow && !filter.allow.some((p) => this.match(name, p))) return false;
+    return true;
+  }
+  match(name, pattern) {
+    if (pattern.includes("*")) {
+      return new RegExp(pattern.replace(/\*/g, ".*")).test(name);
+    }
+    return name === pattern;
+  }
+};
+
+// src/llm/vercel.ts
+var import_ai = require("ai");
+var import_openai = require("@ai-sdk/openai");
+var import_anthropic = require("@ai-sdk/anthropic");
+var import_cerebras = require("@ai-sdk/cerebras");
+var import_openai_compatible = require("@ai-sdk/openai-compatible");
+var PROVIDER_BASE_URLS = {
+  cerebras: "https://api.cerebras.ai/v1",
+  groq: "https://api.groq.com/openai/v1",
+  together: "https://api.together.xyz/v1",
+  fireworks: "https://api.fireworks.ai/inference/v1",
+  deepseek: "https://api.deepseek.com/v1",
+  mistral: "https://api.mistral.ai/v1",
+  perplexity: "https://api.perplexity.ai"
+};
+var VercelAIBackend = class {
+  constructor(config) {
+    this.totalCost = 0;
+    this.totalApiCalls = 0;
+    this.model = this.createModel(config);
+  }
+  createModel(config) {
+    const { provider = "openai", name: modelName, apiKey, baseURL } = config;
+    const providerLower = provider.toLowerCase();
+    const providerUpper = provider.toUpperCase();
+    const resolvedApiKey = apiKey ?? process.env[`${providerUpper}_API_KEY`];
+    const resolvedBaseURL = baseURL ?? process.env[`${providerUpper}_BASE_URL`] ?? PROVIDER_BASE_URLS[providerLower];
+    if (providerLower === "openai") {
+      const openai = (0, import_openai.createOpenAI)({ apiKey: resolvedApiKey });
+      return openai.chat(modelName);
+    }
+    if (providerLower === "anthropic") {
+      const anthropic = (0, import_anthropic.createAnthropic)({ apiKey: resolvedApiKey });
+      return anthropic(modelName);
+    }
+    if (providerLower === "cerebras") {
+      const cerebras = (0, import_cerebras.createCerebras)({ apiKey: resolvedApiKey });
+      return cerebras(modelName);
+    }
+    if (!resolvedBaseURL) {
+      throw new Error(
+        `Unknown provider "${provider}". Set ${providerUpper}_BASE_URL environment variable.`
+      );
+    }
+    const compatible = (0, import_openai_compatible.createOpenAICompatible)({
+      name: providerLower,
+      baseURL: resolvedBaseURL,
+      headers: {
+        Authorization: `Bearer ${resolvedApiKey}`
+      }
+    });
+    return compatible(modelName);
+  }
+  async call(messages, options) {
+    const response = await this.callRaw(messages, options);
+    return response.text;
+  }
+  async callRaw(messages, options) {
+    this.totalApiCalls++;
+    const systemMessage = messages.find((m) => m.role === "system");
+    const userMessage = messages.find((m) => m.role === "user");
+    const generateParams = {
+      model: this.model,
+      system: systemMessage?.content,
+      prompt: userMessage?.content
+    };
+    if (options?.temperature !== void 0) generateParams.temperature = options.temperature;
+    if (options?.max_tokens !== void 0) generateParams.maxTokens = options.max_tokens;
+    if (options?.top_p !== void 0) generateParams.topP = options.top_p;
+    if (options?.frequency_penalty !== void 0) generateParams.frequencyPenalty = options.frequency_penalty;
+    if (options?.presence_penalty !== void 0) generateParams.presencePenalty = options.presence_penalty;
+    const response = await (0, import_ai.generateText)(generateParams);
+    return response;
+  }
+};
+
+// src/llm/mock.ts
+var MockLLMBackend = class {
+  /**
+   * Create a mock backend with predefined responses.
+   *
+   * @param responses - Array of responses to return in order
+   * @param defaultResponse - Response to use when responses are exhausted
+   */
+  constructor(responses = [], defaultResponse = { content: '{"result": "mock"}' }) {
+    this.totalCost = 0;
+    this.totalApiCalls = 0;
+    this.responseIndex = 0;
+    this.responses = responses;
+    this.defaultResponse = defaultResponse;
+  }
+  async call(messages, options) {
+    this.totalApiCalls++;
+    if (this.responseIndex < this.responses.length) {
+      return this.responses[this.responseIndex++].content;
+    }
+    return this.defaultResponse.content;
+  }
+  async callRaw(messages, options) {
+    this.totalApiCalls++;
+    const response = this.responseIndex < this.responses.length ? this.responses[this.responseIndex++] : this.defaultResponse;
+    return response?.raw ?? { text: response?.content };
+  }
+  /**
+   * Reset the response index to start from the beginning.
+   */
+  reset() {
+    this.responseIndex = 0;
+    this.totalApiCalls = 0;
+    this.totalCost = 0;
+  }
+  /**
+   * Add responses to the queue.
+   */
+  addResponses(responses) {
+    this.responses.push(...responses);
+  }
+};
+
+// src/profiles.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var import_yaml = __toESM(require("yaml"));
+var profileManagerCache = /* @__PURE__ */ new Map();
+var ProfileManager = class _ProfileManager {
+  constructor(profilesFile) {
+    this.profiles = {};
+    this.profilesFile = profilesFile;
+    if (profilesFile) {
+      this.loadProfiles(profilesFile);
+    }
+  }
+  /**
+   * Get or create a ProfileManager for a directory.
+   * Caches instances by directory to avoid re-reading profiles.yml.
+   */
+  static getInstance(configDir) {
+    if (!profileManagerCache.has(configDir)) {
+      const profilesPath = (0, import_path.join)(configDir, "profiles.yml");
+      if ((0, import_fs.existsSync)(profilesPath)) {
+        profileManagerCache.set(configDir, new _ProfileManager(profilesPath));
+      } else {
+        profileManagerCache.set(configDir, new _ProfileManager());
+      }
+    }
+    return profileManagerCache.get(configDir);
+  }
+  /**
+   * Clear cached ProfileManager instances.
+   */
+  static clearCache() {
+    profileManagerCache.clear();
+  }
+  loadProfiles(profilesFile) {
+    if (!(0, import_fs.existsSync)(profilesFile)) {
+      return;
+    }
+    const content = (0, import_fs.readFileSync)(profilesFile, "utf-8");
+    const config = import_yaml.default.parse(content);
+    if ("spec" in config && config.spec !== "flatprofiles") {
+      throw new Error(
+        `Invalid profiles spec: expected 'flatprofiles', got '${config.spec}'`
+      );
+    }
+    const data = "data" in config ? config.data : config;
+    this.profiles = data.model_profiles ?? {};
+    this.defaultProfile = data.default;
+    this.overrideProfile = data.override;
+  }
+  /**
+   * Get a profile by name.
+   */
+  getProfile(name) {
+    return this.profiles[name];
+  }
+  /**
+   * Get all loaded profiles.
+   */
+  getProfiles() {
+    return this.profiles;
+  }
+  /**
+   * Get the default profile name.
+   */
+  getDefaultProfile() {
+    return this.defaultProfile;
+  }
+  /**
+   * Get the override profile name.
+   */
+  getOverrideProfile() {
+    return this.overrideProfile;
+  }
+  /**
+   * Resolve the final model configuration.
+   *
+   * Resolution order:
+   * 1. Start with default profile (if set)
+   * 2. Apply named profile (if agentModelConfig is string or has 'profile' key)
+   * 3. Merge inline overrides (if agentModelConfig is dict)
+   * 4. Apply override profile (trumps all)
+   *
+   * @param agentModelConfig - Agent's model config (string, object, or undefined)
+   * @returns Fully resolved model configuration
+   * @throws Error if a referenced profile is not found
+   */
+  resolveModelConfig(agentModelConfig) {
+    const result = {};
+    if (this.defaultProfile) {
+      const defaultCfg = this.getProfile(this.defaultProfile);
+      if (defaultCfg) {
+        Object.assign(result, defaultCfg);
+      } else {
+        console.warn(`Default profile '${this.defaultProfile}' not found`);
+      }
+    }
+    if (typeof agentModelConfig === "string") {
+      const profileCfg = this.getProfile(agentModelConfig);
+      if (profileCfg) {
+        Object.assign(result, profileCfg);
+      } else {
+        throw new Error(`Model profile '${agentModelConfig}' not found`);
+      }
+    } else if (typeof agentModelConfig === "object" && agentModelConfig) {
+      const profileName = agentModelConfig.profile;
+      if (profileName) {
+        const profileCfg = this.getProfile(profileName);
+        if (profileCfg) {
+          Object.assign(result, profileCfg);
+        } else {
+          throw new Error(`Model profile '${profileName}' not found`);
+        }
+      }
+      const { profile, ...inlineOverrides } = agentModelConfig;
+      for (const [key, value] of Object.entries(inlineOverrides)) {
+        if (value !== void 0 && value !== null) {
+          result[key] = value;
+        }
+      }
+    }
+    if (this.overrideProfile) {
+      const overrideCfg = this.getProfile(this.overrideProfile);
+      if (overrideCfg) {
+        Object.assign(result, overrideCfg);
+      } else {
+        console.warn(`Override profile '${this.overrideProfile}' not found`);
+      }
+    }
+    return result;
+  }
+};
+function resolveModelConfig(agentModelConfig, configDir, profilesFile) {
+  const manager = profilesFile ? new ProfileManager(profilesFile) : ProfileManager.getInstance(configDir);
+  return manager.resolveModelConfig(agentModelConfig);
+}
+
+// src/templating.ts
+var nunjucks = __toESM(require("nunjucks"));
+
+// src/template_allowlist.ts
+var currentAllowlist = null;
+var warned = /* @__PURE__ */ new Set();
+function setTemplateAllowlist(allowlist) {
+  currentAllowlist = allowlist ?? null;
+}
+function warnOnce(key, message) {
+  if (warned.has(key)) return;
+  warned.add(key);
+  console.warn(message);
+}
+function warnTemplateAllowlist(template, source) {
+  if (!currentAllowlist) return;
+  const filterAllow = new Set(currentAllowlist.filters ?? []);
+  const tagAllow = new Set(currentAllowlist.tags ?? []);
+  const patterns = (currentAllowlist.patterns ?? []).map((pattern) => new RegExp(pattern, "g"));
+  for (const regex of patterns) {
+    if (regex.test(template)) {
+      warnOnce(
+        `${source}:pattern:${regex.source}`,
+        `[flatagents] template allowlist warning (${source}): pattern "${regex.source}" not allowed`
+      );
+    }
+  }
+  const tagMatches = template.matchAll(/{%\s*([A-Za-z_][\w-]*)/g);
+  for (const match of tagMatches) {
+    const tag = match[1];
+    if (tagAllow.size && !tagAllow.has(tag)) {
+      warnOnce(
+        `${source}:tag:${tag}`,
+        `[flatagents] template allowlist warning (${source}): tag "${tag}" not allowed`
+      );
+    }
+  }
+  const filterMatches = template.matchAll(/\|\s*([A-Za-z_][\w-]*)/g);
+  for (const match of filterMatches) {
+    const filter = match[1];
+    if (filterAllow.size && !filterAllow.has(filter)) {
+      warnOnce(
+        `${source}:filter:${filter}`,
+        `[flatagents] template allowlist warning (${source}): filter "${filter}" not allowed`
+      );
+    }
+  }
+}
+
+// src/templating.ts
+var nunjucksEnv = new nunjucks.Environment(void 0, { autoescape: false });
+nunjucksEnv.addFilter("tojson", (value) => JSON.stringify(value));
+function renderTemplate(template, vars, source = "template") {
+  warnTemplateAllowlist(template, source);
+  return nunjucksEnv.renderString(template, vars);
+}
+
+// src/flatagent.ts
+var FlatAgent = class {
+  /**
+   * Create a FlatAgent.
+   *
+   * @param configOrOptions - Config path, config object, or AgentOptions
+   */
+  constructor(configOrOptions) {
+    let configPath;
+    if (configOrOptions && typeof configOrOptions === "object" && "config" in configOrOptions && !("spec" in configOrOptions)) {
+      const options = configOrOptions;
+      if (typeof options.config === "string") {
+        configPath = options.config;
+        this.config = yaml2.parse((0, import_fs2.readFileSync)(options.config, "utf-8"));
+      } else {
+        this.config = options.config;
+      }
+      this.llmBackend = options.llmBackend;
+      this.configDir = options.configDir ?? (configPath ? (0, import_path2.dirname)(configPath) : process.cwd());
+      this.profilesFile = options.profilesFile;
+    } else if (typeof configOrOptions === "string") {
+      configPath = configOrOptions;
+      this.config = yaml2.parse((0, import_fs2.readFileSync)(configOrOptions, "utf-8"));
+      this.configDir = (0, import_path2.dirname)(configOrOptions);
+    } else {
+      this.config = configOrOptions;
+      this.configDir = process.cwd();
+    }
+    const configData = this.config && typeof this.config === "object" ? this.config.data : void 0;
+    if (configData?.expression_engine === "cel") {
+      throw new Error("expression_engine 'cel' is not supported in the JS SDK yet");
+    }
+    if (configData?.model) {
+      this.resolvedModelConfig = resolveModelConfig(
+        configData.model,
+        this.configDir,
+        this.profilesFile
+      );
+    } else {
+      this.resolvedModelConfig = { name: "" };
+    }
+  }
+  /**
+   * Get or create the LLM backend.
+   */
+  getBackend() {
+    if (!this.llmBackend) {
+      this.llmBackend = new VercelAIBackend({
+        provider: this.resolvedModelConfig.provider ?? "openai",
+        name: this.resolvedModelConfig.name,
+        baseURL: this.resolvedModelConfig.base_url
+      });
+    }
+    return this.llmBackend;
+  }
+  async call(input) {
+    if (this.config.data.mcp && !this.mcpProvider) {
+      this.mcpProvider = new MCPToolProvider();
+      await this.mcpProvider.connect(this.config.data.mcp.servers);
+    }
+    const tools = this.mcpProvider ? await this.mcpProvider.listTools(this.config.data.mcp?.tool_filter) : [];
+    const toolsPrompt = this.config.data.mcp?.tool_prompt ? renderTemplate(this.config.data.mcp.tool_prompt, { tools }, "flatagent.tool_prompt") : "";
+    const templateVars = { input, tools, tools_prompt: toolsPrompt, model: this.resolvedModelConfig };
+    const system = renderTemplate(this.config.data.system, templateVars, "flatagent.system");
+    let user = renderTemplate(this.config.data.user, templateVars, "flatagent.user");
+    if (this.config.data.instruction_suffix) {
+      user = `${user}
+
+${this.config.data.instruction_suffix}`;
+    }
+    const messages = [
+      { role: "system", content: system },
+      { role: "user", content: user }
+    ];
+    const backend = this.getBackend();
+    const text = await backend.call(messages, {
+      temperature: this.resolvedModelConfig.temperature,
+      max_tokens: this.resolvedModelConfig.max_tokens,
+      top_p: this.resolvedModelConfig.top_p,
+      top_k: this.resolvedModelConfig.top_k,
+      frequency_penalty: this.resolvedModelConfig.frequency_penalty,
+      presence_penalty: this.resolvedModelConfig.presence_penalty,
+      seed: this.resolvedModelConfig.seed
+    });
+    const output = this.extractOutput(text);
+    return { content: text, output };
+  }
+  extractOutput(text) {
+    const match = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    const json = match ? match[1].trim() : text.trim();
+    try {
+      const parsed = JSON.parse(json);
+      if (this.config.data.output && parsed !== null && typeof parsed !== "object") {
+        const fields = Object.keys(this.config.data.output);
+        if (fields.length === 1) {
+          return { [fields[0]]: parsed };
+        }
+      }
+      return parsed;
+    } catch {
+      if (this.config.data.output) {
+        const fields = Object.keys(this.config.data.output);
+        if (fields.length === 1) {
+          const strictMatch = json.trim().match(/^"([^"]*)"$/);
+          if (strictMatch) {
+            return { [fields[0]]: strictMatch[1] };
+          }
+          const lenientMatch = json.match(/"([^"]+)"/);
+          if (lenientMatch) {
+            return { [fields[0]]: lenientMatch[1] };
+          }
+          if (json.trim()) {
+            return { [fields[0]]: json.trim() };
+          }
+        }
+      }
+      return { content: text };
+    }
+  }
+};
+
+// src/flatmachine.ts
+var yaml3 = __toESM(require("yaml"));
+var import_fs5 = require("fs");
+var import_path5 = require("path");
+var import_node_crypto = require("crypto");
+
+// src/execution.ts
+var DefaultExecution = class {
+  async execute(fn) {
+    return fn();
+  }
+};
+var RetryExecution = class {
+  constructor(backoffs = [2, 8, 16, 35], jitter = 0.1) {
+    this.backoffs = backoffs;
+    this.jitter = jitter;
+  }
+  async execute(fn) {
+    let lastError;
+    for (let i = 0; i <= this.backoffs.length; i++) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastError = err;
+        if (i < this.backoffs.length) {
+          const delay = this.backoffs[i] * (1 + this.jitter * (Math.random() * 2 - 1));
+          await new Promise((r) => setTimeout(r, delay * 1e3));
+        }
+      }
+    }
+    throw lastError;
+  }
+};
+var ParallelExecution = class {
+  constructor(nSamples = 3) {
+    this.nSamples = nSamples;
+  }
+  async execute(fn) {
+    const tasks = Array.from({ length: this.nSamples }, () => fn());
+    const results = await Promise.allSettled(tasks);
+    const valid = results.filter((r) => r.status === "fulfilled").map((r) => r.value);
+    if (!valid.length) {
+      throw new Error("Parallel execution produced no successful results");
+    }
+    return { results: valid, count: valid.length };
+  }
+};
+var MDAPVotingExecution = class {
+  constructor(kMargin = 3, maxCandidates = 10) {
+    this.kMargin = kMargin;
+    this.maxCandidates = maxCandidates;
+  }
+  async execute(fn) {
+    const votes = /* @__PURE__ */ new Map();
+    let samples = 0;
+    while (samples < this.maxCandidates) {
+      const value = await fn();
+      const key = JSON.stringify(value ?? null);
+      const entry = votes.get(key) ?? { value, count: 0 };
+      entry.count += 1;
+      votes.set(key, entry);
+      samples += 1;
+      const sorted = [...votes.values()].sort((a, b) => b.count - a.count);
+      const leader = sorted[0];
+      const runnerUp = sorted[1];
+      if (leader && leader.count - (runnerUp?.count ?? 0) >= this.kMargin) {
+        return leader.value;
+      }
+    }
+    const winner = [...votes.values()].sort((a, b) => b.count - a.count)[0];
+    return winner?.value;
+  }
+};
+function getExecutionType(config) {
+  if (config?.type === "retry") return new RetryExecution(config.backoffs, config.jitter);
+  if (config?.type === "parallel") return new ParallelExecution(config.n_samples ?? 3);
+  if (config?.type === "mdap_voting") return new MDAPVotingExecution(config.k_margin ?? 3, config.max_candidates ?? 10);
+  return new DefaultExecution();
+}
+
+// src/expression.ts
+function evaluate(expr, ctx) {
+  const trimmed = expr.trim();
+  if (!trimmed) {
+    throw new Error("Empty expression");
+  }
+  const parser = new ExpressionParser(trimmed);
+  const result = parser.parse(ctx);
+  return result;
+}
+var ExpressionParser = class {
+  constructor(expr) {
+    this.tokens = [];
+    this.pos = 0;
+    this.tokens = this.tokenize(expr);
+  }
+  tokenize(expr) {
+    const tokens = [];
+    let current = "";
+    let inString = false;
+    let stringChar = "";
+    for (let i = 0; i < expr.length; i++) {
+      const char = expr[i];
+      if ((char === '"' || char === "'") && !inString) {
+        if (current) tokens.push(current);
+        current = char;
+        inString = true;
+        stringChar = char;
+        continue;
+      }
+      if (inString) {
+        current += char;
+        if (char === stringChar) {
+          tokens.push(current);
+          current = "";
+          inString = false;
+        }
+        continue;
+      }
+      const char2 = expr.slice(i, i + 2);
+      if (char2 === "==" || char2 === "!=" || char2 === "<=" || char2 === ">=") {
+        if (current) tokens.push(current);
+        tokens.push(char2);
+        current = "";
+        i++;
+      } else if ("<>()".includes(char)) {
+        if (current) tokens.push(current);
+        tokens.push(char);
+        current = "";
+      } else if (" 	\n".includes(char)) {
+        if (current) tokens.push(current);
+        current = "";
+      } else {
+        current += char;
+      }
+    }
+    if (current) tokens.push(current);
+    return tokens;
+  }
+  peek() {
+    return this.tokens[this.pos];
+  }
+  consume() {
+    return this.tokens[this.pos++];
+  }
+  parse(ctx) {
+    const result = this.parseExpression(ctx);
+    if (this.pos < this.tokens.length) {
+      throw new Error(`Unexpected token: ${this.tokens[this.pos]}`);
+    }
+    return result;
+  }
+  parseExpression(ctx) {
+    return this.parseOr(ctx);
+  }
+  parseOr(ctx) {
+    let left = this.parseAnd(ctx);
+    while (this.peek() === "or") {
+      this.consume();
+      const right = this.parseAnd(ctx);
+      left = left || right;
+    }
+    return left;
+  }
+  parseAnd(ctx) {
+    let left = this.parseNot(ctx);
+    while (this.peek() === "and") {
+      this.consume();
+      const right = this.parseNot(ctx);
+      left = left && right;
+    }
+    return left;
+  }
+  parseNot(ctx) {
+    if (this.peek() === "not") {
+      this.consume();
+      return !this.parseComparison(ctx);
+    }
+    return this.parseComparison(ctx);
+  }
+  parseComparison(ctx) {
+    const left = this.parsePrimary(ctx);
+    const op = this.peek();
+    if (op && ["==", "!=", "<", "<=", ">", ">="].includes(op)) {
+      this.consume();
+      const right = this.parsePrimary(ctx);
+      switch (op) {
+        case "==":
+          return left === right;
+        case "!=":
+          return left !== right;
+        case "<":
+          return left < right;
+        case "<=":
+          return left <= right;
+        case ">":
+          return left > right;
+        case ">=":
+          return left >= right;
+        default:
+          throw new Error(`Unknown operator: ${op}`);
+      }
+    }
+    return left;
+  }
+  parsePrimary(ctx) {
+    const token = this.consume();
+    if (token === void 0) {
+      throw new Error("Unexpected end of expression");
+    }
+    if (token === ")") {
+      throw new Error("Unexpected token: )");
+    }
+    if (token === "(") {
+      const value = this.parseExpression(ctx);
+      if (this.consume() !== ")") {
+        throw new Error("Expected closing parenthesis");
+      }
+      return value;
+    }
+    if (token.startsWith('"') && token.endsWith('"') || token.startsWith("'") && token.endsWith("'")) {
+      return token.slice(1, -1);
+    }
+    if (token === "true") return true;
+    if (token === "false") return false;
+    if (token === "null") return null;
+    if (!isNaN(Number(token))) {
+      return Number(token);
+    }
+    if (token.includes(".")) {
+      const parts = token.split(".");
+      let obj = ctx;
+      for (const part of parts) {
+        if (obj && typeof obj === "object" && part in obj) {
+          obj = obj[part];
+        } else {
+          return void 0;
+        }
+      }
+      return obj;
+    }
+    return ctx[token];
+  }
+};
+
+// src/persistence.ts
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+var MemoryBackend = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+  }
+  async save(key, snapshot) {
+    this.store.set(key, snapshot);
+  }
+  async load(key) {
+    return this.store.get(key) ?? null;
+  }
+  async delete(key) {
+    this.store.delete(key);
+  }
+  async list(prefix) {
+    return [...this.store.keys()].filter((k) => k.startsWith(prefix)).sort();
+  }
+};
+var LocalFileBackend = class {
+  constructor(dir = ".checkpoints") {
+    this.dir = dir;
+  }
+  async ensureDir(path) {
+    try {
+      await import_fs3.promises.mkdir((0, import_path3.dirname)(path), { recursive: true });
+    } catch (error) {
+    }
+  }
+  getPath(key) {
+    return (0, import_path3.join)(this.dir, `${key}.json`);
+  }
+  async save(key, snapshot) {
+    const path = this.getPath(key);
+    await this.ensureDir(path);
+    const tempPath = `${path}.tmp`;
+    await import_fs3.promises.writeFile(tempPath, JSON.stringify(snapshot, null, 2));
+    await import_fs3.promises.rename(tempPath, path);
+  }
+  async load(key) {
+    try {
+      const path = this.getPath(key);
+      const data = await import_fs3.promises.readFile(path, "utf-8");
+      return JSON.parse(data);
+    } catch (error) {
+      return null;
+    }
+  }
+  async delete(key) {
+    try {
+      const path = this.getPath(key);
+      await import_fs3.promises.unlink(path);
+    } catch (error) {
+    }
+  }
+  async list(prefix) {
+    try {
+      const files = await import_fs3.promises.readdir(this.dir, { recursive: true });
+      return files.filter((file) => file.endsWith(".json")).map((file) => file.replace(".json", "")).filter((key) => key.startsWith(prefix)).sort();
+    } catch (error) {
+      return [];
+    }
+  }
+};
+var CheckpointManager = class {
+  constructor(backend) {
+    this.backend = backend;
+  }
+  async checkpoint(snapshot) {
+    const key = `${snapshot.execution_id}/step_${String(snapshot.step).padStart(6, "0")}`;
+    await this.backend.save(key, snapshot);
+  }
+  async restore(executionId) {
+    const keys = await this.backend.list(executionId);
+    if (!keys.length) return null;
+    const sortedKeys = keys.sort((a, b) => {
+      const stepA = parseInt(a.split("_")[1] || "0");
+      const stepB = parseInt(b.split("_")[1] || "0");
+      return stepA - stepB;
+    });
+    return this.backend.load(sortedKeys[sortedKeys.length - 1]);
+  }
+};
+
+// src/results.ts
+var TimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+var store = /* @__PURE__ */ new Map();
+var waiters = /* @__PURE__ */ new Map();
+var addWaiter = (uri, waiter) => {
+  const current = waiters.get(uri) ?? /* @__PURE__ */ new Set();
+  current.add(waiter);
+  waiters.set(uri, current);
+};
+var removeWaiter = (uri, waiter) => {
+  const current = waiters.get(uri);
+  if (!current) return;
+  current.delete(waiter);
+  if (current.size === 0) waiters.delete(uri);
+};
+var notifyWaiters = (uri, data) => {
+  const current = waiters.get(uri);
+  if (!current) return;
+  for (const waiter of current) {
+    if (waiter.timeoutId) clearTimeout(waiter.timeoutId);
+    waiter.resolve(data);
+  }
+  waiters.delete(uri);
+};
+var inMemoryResultBackend = {
+  async write(uri, data) {
+    store.set(uri, data);
+    notifyWaiters(uri, data);
+  },
+  async read(uri, opts) {
+    if (!opts?.block) {
+      return store.get(uri);
+    }
+    if (store.has(uri)) {
+      return store.get(uri);
+    }
+    return new Promise((resolve2, reject) => {
+      const waiter = { resolve: resolve2, reject };
+      addWaiter(uri, waiter);
+      if (opts.timeout !== void 0) {
+        waiter.timeoutId = setTimeout(() => {
+          removeWaiter(uri, waiter);
+          reject(new TimeoutError(`Timed out waiting for ${uri}`));
+        }, opts.timeout);
+      }
+    });
+  },
+  async exists(uri) {
+    return store.has(uri);
+  },
+  async delete(uri) {
+    store.delete(uri);
+  }
+};
+
+// src/locking.ts
+var import_fs4 = require("fs");
+var import_path4 = require("path");
+var NoOpLock = class {
+  async acquire(key) {
+    return true;
+  }
+  async release(key) {
+  }
+};
+var LocalFileLock = class {
+  constructor(lockDir = ".locks") {
+    this.handles = /* @__PURE__ */ new Map();
+    this.lockDir = lockDir;
+  }
+  getLockPath(key) {
+    const safeKey = key.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return (0, import_path4.join)(this.lockDir, `${safeKey}.lock`);
+  }
+  async ensureDir() {
+    try {
+      await import_fs4.promises.mkdir(this.lockDir, { recursive: true });
+    } catch (error) {
+    }
+  }
+  async acquire(key) {
+    await this.ensureDir();
+    const lockPath = this.getLockPath(key);
+    try {
+      const handle = await import_fs4.promises.open(lockPath, "wx");
+      await handle.write(JSON.stringify({
+        pid: process.pid,
+        key,
+        acquired_at: (/* @__PURE__ */ new Date()).toISOString()
+      }));
+      this.handles.set(key, handle);
+      return true;
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async release(key) {
+    const handle = this.handles.get(key);
+    const lockPath = this.getLockPath(key);
+    if (handle) {
+      await handle.close();
+      this.handles.delete(key);
+    }
+    try {
+      await import_fs4.promises.unlink(lockPath);
+    } catch (error) {
+    }
+  }
+};
+
+// src/flatmachine.ts
+var FlatMachine = class _FlatMachine {
+  constructor(options) {
+    this.executionId = (0, import_node_crypto.randomUUID)();
+    this.agents = /* @__PURE__ */ new Map();
+    this.context = {};
+    this.input = {};
+    this.checkpointEvents = /* @__PURE__ */ new Set();
+    this.pendingLaunches = [];
+    this.currentStep = 0;
+    this.config = typeof options.config === "string" ? yaml3.parse((0, import_fs5.readFileSync)(options.config, "utf-8")) : options.config;
+    this.hooks = options.hooks;
+    this.configDir = options.configDir ?? process.cwd();
+    this.profilesFile = this.resolveProfilesFile(options.profilesFile);
+    this.executionId = options.executionId ?? this.executionId;
+    this.parentExecutionId = options.parentExecutionId;
+    const backendConfig = this.config.data.settings?.backends;
+    this.resultBackend = options.resultBackend ?? this.createResultBackend(backendConfig);
+    this.executionLock = options.executionLock ?? this.createExecutionLock(backendConfig);
+    if (options.persistence) {
+      this.checkpointManager = new CheckpointManager(options.persistence);
+    } else if (this.config.data.persistence?.enabled) {
+      const backend = this.createPersistenceBackend(this.config.data.persistence);
+      this.checkpointManager = new CheckpointManager(backend);
+    } else if (backendConfig?.persistence) {
+      const backend = this.createSettingsPersistenceBackend(backendConfig.persistence);
+      this.checkpointManager = new CheckpointManager(backend);
+    }
+    if (this.checkpointManager) {
+      const configEvents = this.config.data.persistence?.checkpoint_on;
+      const events = configEvents?.length ? configEvents : ["execute"];
+      this.checkpointEvents = new Set(events);
+    }
+  }
+  async execute(input, resumeSnapshot) {
+    if (this.config.data.expression_engine === "cel") {
+      throw new Error("expression_engine 'cel' is not supported in the JS SDK yet");
+    }
+    const lockKey = resumeSnapshot?.execution_id ?? this.executionId;
+    const lockAcquired = await this.executionLock.acquire(lockKey);
+    if (!lockAcquired) {
+      throw new Error(`Execution ${lockKey} is already running`);
+    }
+    try {
+      return await this.executeInternal(input, resumeSnapshot);
+    } finally {
+      await this.executionLock.release(lockKey);
+    }
+  }
+  async executeInternal(input, resumeSnapshot) {
+    let state;
+    let steps;
+    if (resumeSnapshot) {
+      this.executionId = resumeSnapshot.execution_id;
+      this.parentExecutionId = resumeSnapshot.parent_execution_id;
+      this.context = resumeSnapshot.context;
+      state = resumeSnapshot.current_state;
+      steps = resumeSnapshot.step;
+      this.pendingLaunches = resumeSnapshot.pending_launches ?? [];
+      if (this.pendingLaunches.length) {
+        await this.resumePendingLaunches();
+      }
+    } else {
+      this.input = input ?? {};
+      this.context = this.render(this.config.data.context ?? {}, { input: this.input });
+      this.context = await this.hooks?.onMachineStart?.(this.context) ?? this.context;
+      state = this.findInitialState();
+      steps = 0;
+      this.pendingLaunches = [];
+      if (this.shouldCheckpoint("machine_start")) {
+        await this.checkpoint(state, steps, "machine_start");
+      }
+    }
+    const maxSteps = this.config.data.settings?.max_steps ?? 100;
+    while (steps++ < maxSteps) {
+      const def = this.config.data.states[state];
+      this.currentState = state;
+      this.currentStep = steps;
+      this.context = await this.hooks?.onStateEnter?.(state, this.context) ?? this.context;
+      if (this.shouldCheckpoint("execute")) {
+        await this.checkpoint(state, steps, "execute");
+      }
+      if (def.type === "final") {
+        const output2 = this.render(def.output ?? {}, { context: this.context, input: this.input });
+        await this.resultBackend?.write(`flatagents://${this.executionId}/result`, output2);
+        if (this.shouldCheckpoint("machine_end")) {
+          await this.checkpoint(state, steps, "machine_end", output2);
+        }
+        return await this.hooks?.onMachineEnd?.(this.context, output2) ?? output2;
+      }
+      let output;
+      const executor = getExecutionType(def.execution);
+      try {
+        if (def.action) {
+          const actionResult = await this.hooks?.onAction?.(def.action, this.context);
+          if (actionResult !== void 0) {
+            this.context = actionResult;
+            output = actionResult;
+          }
+        }
+        if (def.agent) {
+          output = await executor.execute(() => this.executeAgent(def));
+        } else if (def.machine) {
+          output = await this.executeMachine(def);
+        }
+      } catch (err) {
+        this.context.last_error = err.message;
+        this.context.last_error_type = err.name || err.constructor?.name;
+        const recovery = await this.hooks?.onError?.(state, err, this.context);
+        if (recovery) {
+          state = recovery;
+          continue;
+        }
+        if (def.on_error) {
+          if (typeof def.on_error === "string") {
+            state = def.on_error;
+            continue;
+          }
+          const errorKey = this.context.last_error_type;
+          const nextState = def.on_error[errorKey] ?? def.on_error.default;
+          if (nextState) {
+            state = nextState;
+            continue;
+          }
+        }
+        throw err;
+      }
+      if (def.output_to_context) {
+        Object.assign(this.context, this.render(def.output_to_context, { context: this.context, input: this.input, output }));
+      }
+      if (def.launch) await this.launchMachines(def);
+      output = await this.hooks?.onStateExit?.(state, this.context, output) ?? output;
+      const next = this.evaluateTransitions(def, output);
+      state = await this.hooks?.onTransition?.(state, next, this.context) ?? next;
+    }
+    throw new Error("Max steps exceeded");
+  }
+  async resume(executionId) {
+    const snapshot = await this.checkpointManager?.restore(executionId);
+    if (!snapshot) throw new Error(`No checkpoint for ${executionId}`);
+    return this.execute(void 0, snapshot);
+  }
+  findInitialState() {
+    for (const [name, state] of Object.entries(this.config.data.states)) {
+      if (state.type === "initial") return name;
+    }
+    return Object.keys(this.config.data.states)[0];
+  }
+  async executeAgent(def) {
+    let agent = this.agents.get(def.agent);
+    if (!agent) {
+      const agentRef = this.config.data.agents?.[def.agent] ?? def.agent;
+      agent = this.createAgent(agentRef);
+      this.agents.set(def.agent, agent);
+    }
+    const input = this.render(def.input ?? {}, { context: this.context, input: this.input });
+    const result = await agent.call(input);
+    return result.output;
+  }
+  async executeMachine(def) {
+    const machineDefs = Array.isArray(def.machine) ? def.machine : [def.machine];
+    const mode = def.mode ?? "settled";
+    const timeoutMs = def.timeout && def.timeout > 0 ? def.timeout * 1e3 : void 0;
+    if (def.foreach) {
+      const items = this.render({ items: def.foreach }, { context: this.context, input: this.input }).items;
+      const varName = def.as ?? "item";
+      const tasks = items.map(async (item, index) => {
+        const input2 = this.render(def.input ?? {}, { context: this.context, input: this.input, [varName]: item });
+        const result = await this.invokeMachineSingle(machineDefs[0], input2, timeoutMs);
+        const keyValue = def.key ? this.render(def.key, { context: this.context, input: this.input, [varName]: item, output: result }) : void 0;
+        return { index, key: keyValue, result };
+      });
+      const output = await this.awaitWithMode(tasks, mode);
+      if (mode === "any") {
+        const picked = output;
+        if (def.key) return { [String(picked.key)]: picked.result };
+        return picked.result;
+      }
+      const settled = output;
+      if (def.key) {
+        const keyed = {};
+        for (const entry of settled) {
+          keyed[String(entry.key)] = entry.result;
+        }
+        return keyed;
+      }
+      const ordered = new Array(items.length);
+      for (const entry of settled) {
+        ordered[entry.index] = entry.result;
+      }
+      return ordered;
+    }
+    if (machineDefs.length > 1 || machineDefs.length === 1 && typeof machineDefs[0] === "object" && "name" in machineDefs[0]) {
+      const tasks = machineDefs.map(async (entry) => {
+        const name = this.getMachineName(entry);
+        const baseInput = this.render(def.input ?? {}, { context: this.context, input: this.input });
+        const entryInput = typeof entry === "string" ? {} : this.render(entry.input ?? {}, { context: this.context, input: this.input });
+        const mergedInput = { ...baseInput, ...entryInput };
+        const result = await this.invokeMachineSingle(entry, mergedInput, timeoutMs);
+        return { name, result };
+      });
+      const output = await this.awaitWithMode(tasks, mode);
+      if (mode === "any") {
+        const picked = output;
+        return { [picked.name]: picked.result };
+      }
+      const settled = output;
+      return settled.reduce((acc, entry) => {
+        acc[entry.name] = entry.result;
+        return acc;
+      }, {});
+    }
+    const input = this.render(def.input ?? {}, { context: this.context, input: this.input });
+    return this.invokeMachineSingle(machineDefs[0], input, timeoutMs);
+  }
+  async launchMachines(def) {
+    const machines = Array.isArray(def.launch) ? def.launch : [def.launch];
+    const input = this.render(def.launch_input ?? {}, { context: this.context, input: this.input });
+    await Promise.all(machines.map((machineRef) => this.launchFireAndForget(machineRef, input)));
+  }
+  evaluateTransitions(def, output) {
+    if (!def.transitions?.length) throw new Error("No transitions defined");
+    for (const t of def.transitions) {
+      if (!t.condition || evaluate(t.condition, { context: this.context, input: this.input, output })) {
+        return t.to;
+      }
+    }
+    throw new Error("No matching transition");
+  }
+  async checkpoint(state, step, event, output) {
+    if (!this.checkpointManager) return;
+    await this.checkpointManager.checkpoint({
+      execution_id: this.executionId,
+      machine_name: this.config.data.name ?? "unnamed",
+      spec_version: this.config.spec_version ?? "0.4.0",
+      current_state: state,
+      context: this.context,
+      step,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      event,
+      output,
+      parent_execution_id: this.parentExecutionId,
+      pending_launches: this.pendingLaunches.length ? this.pendingLaunches : void 0
+    });
+  }
+  render(template, vars) {
+    if (typeof template === "string") {
+      const directValue = this.renderDirectValue(template, vars);
+      if (directValue !== void 0) return directValue;
+      const rendered = renderTemplate(template, vars, "flatmachine");
+      try {
+        return JSON.parse(rendered);
+      } catch {
+        return rendered;
+      }
+    }
+    if (Array.isArray(template)) return template.map((t) => this.render(t, vars));
+    if (typeof template === "object" && template !== null) {
+      return Object.fromEntries(Object.entries(template).map(([k, v]) => [k, this.render(v, vars)]));
+    }
+    return template;
+  }
+  renderDirectValue(template, vars) {
+    const match = template.match(/^\s*{{\s*([^}]+)\s*}}\s*$/);
+    if (!match) return void 0;
+    const expr = match[1].trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z0-9_]+)*$/.test(expr)) return void 0;
+    return this.resolvePath(vars, expr);
+  }
+  resolvePath(vars, expr) {
+    return expr.split(".").reduce((obj, part) => obj ? obj[part] : void 0, vars);
+  }
+  shouldCheckpoint(event) {
+    return this.checkpointManager ? this.checkpointEvents.has(event) : false;
+  }
+  createResultBackend(config) {
+    if (!config?.results || config.results === "memory") return inMemoryResultBackend;
+    throw new Error(`Unsupported result backend: ${config.results}`);
+  }
+  createExecutionLock(config) {
+    if (!config?.locking || config.locking === "none") return new NoOpLock();
+    if (config.locking === "local") return new LocalFileLock();
+    throw new Error(`Unsupported execution lock backend: ${config.locking}`);
+  }
+  createSettingsPersistenceBackend(setting) {
+    if (setting === "memory") return new MemoryBackend();
+    if (setting === "local") return new LocalFileBackend();
+    throw new Error(`Unsupported persistence backend: ${setting}`);
+  }
+  createPersistenceBackend(config) {
+    if (config.backend === "memory") return new MemoryBackend();
+    if (config.backend === "local") return new LocalFileBackend();
+    throw new Error(`Unsupported persistence backend: ${config.backend}`);
+  }
+  createAgent(agentRef) {
+    if (agentRef && typeof agentRef === "object") {
+      if (agentRef.spec === "flatagent" && agentRef.data) {
+        return new FlatAgent({ config: agentRef, profilesFile: this.profilesFile });
+      }
+      if (agentRef.path) {
+        return new FlatAgent({
+          config: `${this.configDir}/${agentRef.path}`,
+          profilesFile: this.profilesFile
+        });
+      }
+    }
+    return new FlatAgent({
+      config: `${this.configDir}/${agentRef}`,
+      profilesFile: this.profilesFile
+    });
+  }
+  createMachine(machineRef, overrides) {
+    const resolved = this.resolveMachineConfig(machineRef);
+    return new _FlatMachine({
+      config: resolved.config,
+      configDir: resolved.configDir,
+      resultBackend: this.resultBackend,
+      hooks: this.hooks,
+      executionId: overrides?.executionId,
+      parentExecutionId: overrides?.parentExecutionId,
+      profilesFile: this.profilesFile
+    });
+  }
+  resolveMachineConfig(machineRef) {
+    if (typeof machineRef === "object" && machineRef) {
+      if ("spec" in machineRef && "data" in machineRef) {
+        return { config: machineRef, configDir: this.configDir };
+      }
+      if ("path" in machineRef && machineRef.path) {
+        return this.resolveMachinePath(String(machineRef.path));
+      }
+      if ("inline" in machineRef && machineRef.inline) {
+        return { config: machineRef.inline, configDir: this.configDir };
+      }
+      if ("name" in machineRef) {
+        return this.resolveMachineConfig(machineRef.name);
+      }
+    }
+    const name = String(machineRef);
+    const entry = this.config.data.machines?.[name];
+    if (entry && typeof entry === "object") {
+      if ("path" in entry && entry.path) {
+        return this.resolveMachinePath(String(entry.path));
+      }
+      if ("inline" in entry && entry.inline) {
+        return { config: entry.inline, configDir: this.configDir };
+      }
+      if ("spec" in entry && "data" in entry) {
+        return { config: entry, configDir: this.configDir };
+      }
+    }
+    if (typeof entry === "string") {
+      return this.resolveMachinePath(entry);
+    }
+    return this.resolveMachinePath(name);
+  }
+  resolveMachinePath(pathRef) {
+    const resolved = (0, import_path5.resolve)(this.configDir, pathRef);
+    return { config: resolved, configDir: (0, import_path5.dirname)(resolved) };
+  }
+  resolveProfilesFile(explicitPath) {
+    const configProfiles = this.config?.data?.profiles;
+    if (typeof configProfiles === "string" && configProfiles.trim().length > 0) {
+      return (0, import_path5.resolve)(this.configDir, configProfiles);
+    }
+    const discovered = (0, import_path5.resolve)(this.configDir, "profiles.yml");
+    if ((0, import_fs5.existsSync)(discovered)) return discovered;
+    return explicitPath;
+  }
+  getMachineName(machineRef) {
+    if (typeof machineRef === "string") return machineRef;
+    if (machineRef?.name) return String(machineRef.name);
+    if (machineRef?.path) return String(machineRef.path);
+    if (machineRef?.inline?.data?.name) return String(machineRef.inline.data.name);
+    if (machineRef?.spec === "flatmachine" && machineRef.data?.name) return String(machineRef.data.name);
+    return "machine";
+  }
+  makeResultUri(executionId) {
+    return `flatagents://${executionId}/result`;
+  }
+  async addPendingLaunch(executionId, machine, input) {
+    this.pendingLaunches.push({ execution_id: executionId, machine, input, launched: false });
+    if (this.currentState && this.shouldCheckpoint("execute")) {
+      await this.checkpoint(this.currentState, this.currentStep, "execute");
+    }
+  }
+  markLaunched(executionId) {
+    for (const intent of this.pendingLaunches) {
+      if (intent.execution_id === executionId) {
+        intent.launched = true;
+        return;
+      }
+    }
+  }
+  clearPendingLaunch(executionId) {
+    this.pendingLaunches = this.pendingLaunches.filter((intent) => intent.execution_id !== executionId);
+  }
+  async resumePendingLaunches() {
+    if (!this.resultBackend) return;
+    for (const intent of this.pendingLaunches) {
+      if (intent.launched) continue;
+      const uri = this.makeResultUri(intent.execution_id);
+      const exists = await this.resultBackend.exists(uri);
+      if (exists) continue;
+      const launchPromise = this.launchAndWrite(intent.machine, intent.execution_id, intent.input);
+      this.markLaunched(intent.execution_id);
+      launchPromise.then(() => this.clearPendingLaunch(intent.execution_id)).catch(() => {
+      });
+    }
+  }
+  async launchAndWrite(machineRef, executionId, input) {
+    const machine = this.createMachine(machineRef, {
+      executionId,
+      parentExecutionId: this.executionId
+    });
+    try {
+      const result = await machine.execute(input);
+      if (this.resultBackend) {
+        await this.resultBackend.write(this.makeResultUri(executionId), result);
+      }
+      return result;
+    } catch (err) {
+      if (this.resultBackend) {
+        const error = err;
+        await this.resultBackend.write(this.makeResultUri(executionId), {
+          _error: error.message,
+          _error_type: error.name || error.constructor?.name
+        });
+      }
+      throw err;
+    }
+  }
+  normalizeMachineResult(result) {
+    if (result && typeof result === "object" && "_error" in result) {
+      const error = new Error(String(result._error ?? "Machine execution failed"));
+      error.name = String(result._error_type ?? "Error");
+      throw error;
+    }
+    return result;
+  }
+  async invokeMachineSingle(machineRef, input, timeoutMs) {
+    const childId = (0, import_node_crypto.randomUUID)();
+    const machineName = this.getMachineName(machineRef);
+    await this.addPendingLaunch(childId, machineName, input);
+    const launchPromise = this.launchAndWrite(machineRef, childId, input);
+    let shouldClear = false;
+    try {
+      if (!this.resultBackend) {
+        const result2 = await launchPromise;
+        shouldClear = true;
+        return result2;
+      }
+      const result = await this.resultBackend.read(this.makeResultUri(childId), {
+        block: true,
+        timeout: timeoutMs
+      });
+      shouldClear = true;
+      return this.normalizeMachineResult(result);
+    } catch (err) {
+      if (err.name !== "TimeoutError") {
+        shouldClear = true;
+      }
+      throw err;
+    } finally {
+      this.markLaunched(childId);
+      if (shouldClear) {
+        this.clearPendingLaunch(childId);
+      }
+      launchPromise.catch(() => {
+      });
+    }
+  }
+  async launchFireAndForget(machineRef, input) {
+    const childId = (0, import_node_crypto.randomUUID)();
+    const machineName = this.getMachineName(machineRef);
+    await this.addPendingLaunch(childId, machineName, input);
+    const launchPromise = this.launchAndWrite(machineRef, childId, input);
+    this.markLaunched(childId);
+    launchPromise.then(() => this.clearPendingLaunch(childId)).catch(() => {
+    });
+  }
+  async awaitWithMode(tasks, mode, timeoutMs) {
+    if (tasks.length === 0) {
+      return mode === "any" ? void 0 : [];
+    }
+    const runner = mode === "any" ? this.firstCompleted(tasks) : Promise.all(tasks);
+    if (!timeoutMs) return runner;
+    return this.withTimeout(runner, timeoutMs);
+  }
+  async firstCompleted(tasks) {
+    return new Promise((resolve2, reject) => {
+      let pending = tasks.length;
+      let settled = false;
+      const errors = [];
+      for (const task of tasks) {
+        task.then((value) => {
+          if (settled) return;
+          settled = true;
+          resolve2(value);
+        }).catch((err) => {
+          errors.push(err);
+          pending -= 1;
+          if (pending === 0 && !settled) {
+            reject(errors[0]);
+          }
+        });
+      }
+    });
+  }
+  withTimeout(promise, timeoutMs) {
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => reject(new Error("Operation timed out")), timeoutMs);
+      promise.then((value) => {
+        clearTimeout(timer);
+        resolve2(value);
+      }).catch((err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+    });
+  }
+  pickFirstKeyedResult(results) {
+    const firstKey = Object.keys(results)[0];
+    if (!firstKey) return {};
+    return { [firstKey]: results[firstKey] };
+  }
+};
+
+// src/hooks.ts
+var WebhookHooks = class {
+  constructor(url) {
+    this.url = url;
+  }
+  async send(event, data) {
+    try {
+      const body = JSON.stringify({ event, ...data, timestamp: (/* @__PURE__ */ new Date()).toISOString() }, (key, value) => {
+        if (typeof value === "object" && value !== null) {
+          const seen = /* @__PURE__ */ new WeakSet();
+          return JSON.parse(JSON.stringify(value, (k, v) => {
+            if (typeof v === "object" && v !== null) {
+              if (seen.has(v)) return "[Circular]";
+              seen.add(v);
+            }
+            return v;
+          }));
+        }
+        return value;
+      });
+      await fetch(this.url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body
+      });
+    } catch {
+    }
+  }
+  async onMachineStart(context) {
+    await this.send("machine_start", { context });
+    return context;
+  }
+  async onMachineEnd(context, output) {
+    await this.send("machine_end", { context, output });
+    return output;
+  }
+  async onStateEnter(state, context) {
+    await this.send("state_enter", { state, context });
+    return context;
+  }
+  async onStateExit(state, context, output) {
+    await this.send("state_exit", { state, context, output });
+    return output;
+  }
+  async onAction(action, context) {
+    await this.send("action", { action, context });
+    return context;
+  }
+};
+var CompositeHooks = class {
+  constructor(hooks) {
+    this.hooks = hooks;
+  }
+  async onMachineStart(context) {
+    let result = context;
+    for (const hook of this.hooks) {
+      if (hook.onMachineStart) {
+        try {
+          result = await hook.onMachineStart(result);
+        } catch {
+        }
+      }
+    }
+    return result;
+  }
+  async onMachineEnd(context, output) {
+    let result = output;
+    for (const hook of this.hooks) {
+      if (hook.onMachineEnd) {
+        try {
+          result = await hook.onMachineEnd(context, result);
+        } catch {
+        }
+      }
+    }
+    return result;
+  }
+  async onStateEnter(state, context) {
+    let result = context;
+    for (const hook of this.hooks) {
+      if (hook.onStateEnter) {
+        try {
+          result = await hook.onStateEnter(state, result);
+        } catch {
+        }
+      }
+    }
+    return result;
+  }
+  async onStateExit(state, context, output) {
+    let result = output;
+    for (const hook of this.hooks) {
+      if (hook.onStateExit) {
+        try {
+          result = await hook.onStateExit(state, context, result);
+        } catch {
+        }
+      }
+    }
+    return result;
+  }
+  async onTransition(from, to, context) {
+    let result = to;
+    for (const hook of this.hooks) {
+      if (hook.onTransition) {
+        try {
+          result = await hook.onTransition(from, result, context);
+        } catch {
+        }
+      }
+    }
+    return result;
+  }
+  async onError(state, error, context) {
+    let result = null;
+    for (const hook of this.hooks) {
+      if (hook.onError) {
+        try {
+          const hookResult = await hook.onError(state, error, context);
+          if (hookResult !== null) result = hookResult;
+        } catch {
+        }
+      }
+    }
+    return result;
+  }
+  async onAction(action, context) {
+    let result = context;
+    for (const hook of this.hooks) {
+      if (hook.onAction) {
+        try {
+          result = await hook.onAction(action, result);
+        } catch {
+        }
+      }
+    }
+    return result;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CheckpointManager,
+  CompositeHooks,
+  DefaultExecution,
+  FlatAgent,
+  FlatMachine,
+  LocalFileBackend,
+  LocalFileLock,
+  MCPToolProvider,
+  MDAPVotingExecution,
+  MemoryBackend,
+  MockLLMBackend,
+  NoOpLock,
+  ParallelExecution,
+  ProfileManager,
+  RetryExecution,
+  VercelAIBackend,
+  WebhookHooks,
+  evaluate,
+  getExecutionType,
+  inMemoryResultBackend,
+  resolveModelConfig,
+  setTemplateAllowlist
+});