@agentdocumentformat/cli 0.7.2

package/dist/chunks/chunk-SLUKGXKH.mjs

@@ -0,0 +1,68 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  createTheme
+} from "./chunk-EYX2YLJW.mjs";
+
+// src/main/tui/commands/builtin/themes.ts
+var ADF_DARK = { ...createTheme({ mono: !1, env: {} }).color }, ADF_LIGHT = {
+  text: "#2B2925",
+  muted: "#6B6456",
+  dim: "#A39C8E",
+  accent: "#A8641A",
+  live: "#1F7A70",
+  loop: "#6A4BB0",
+  user: "#A8641A",
+  assistant: "#2B2925",
+  thinking: "#8A8476",
+  tool: "#2F6DA8",
+  success: "#3F7F3A",
+  warn: "#9A6A00",
+  error: "#B83232",
+  info: "#2F6DA8",
+  border: "#C9C2B2",
+  borderFocus: "#A8641A",
+  selectionFg: "#FFFDF7",
+  selectionBg: "#A8641A",
+  surface: "#EFEADF",
+  overlay: "#F7F3EA"
+}, ADF_CONTRAST = {
+  ...ADF_DARK,
+  text: "#F2EEE4",
+  muted: "#C4BDAE",
+  dim: "#8C8577",
+  border: "#7A7466",
+  thinking: "#A8A294"
+}, THEMES = [
+  { name: "adf", label: "ADF dark", description: "Ink & parchment on a dark terminal (default)", colors: ADF_DARK },
+  { name: "adf-light", label: "ADF light", description: "Ink on paper, for light terminal backgrounds", colors: ADF_LIGHT },
+  { name: "adf-contrast", label: "ADF high contrast", description: "Brighter text and borders on dark backgrounds", colors: ADF_CONTRAST },
+  { name: "adf-mono", label: "Mono", description: "No color (like NO_COLOR): bold and inverse carry emphasis", colors: void 0 }
+], ALIASES = { dark: "adf", default: "adf", light: "adf-light", contrast: "adf-contrast", mono: "adf-mono", "no-color": "adf-mono" };
+function findTheme(name) {
+  let wanted = name.trim().toLowerCase();
+  return THEMES.find((t) => t.name === (ALIASES[wanted] ?? wanted));
+}
+function nextThemeName(current) {
+  let at = THEMES.findIndex((t) => t.name === current);
+  return THEMES[(at + 1) % THEMES.length].name;
+}
+var MONO_COLORS = Object.fromEntries(Object.keys(ADF_DARK).map((k) => [k, void 0]));
+function applyTheme(theme, choice) {
+  theme.name = choice.name, theme.mono = choice.colors === void 0, theme.color = { ...choice.colors ?? MONO_COLORS };
+}
+function themeNames() {
+  return THEMES.map((t) => t.name);
+}
+
+export {
+  THEMES,
+  findTheme,
+  nextThemeName,
+  applyTheme,
+  themeNames
+};

package/dist/chunks/chunk-TMT32MXT.mjs

@@ -0,0 +1,419 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  classifyRedirectTarget,
+  parseBracedExpansion,
+  unsupportedDevTargetMessage
+} from "./chunk-5W7KES6P.mjs";
+import {
+  resolveWithDefault
+} from "./chunk-HPVFJYXR.mjs";
+import {
+  EXIT,
+  enforceToolGate,
+  err,
+  evaluateCommand,
+  evaluateToolNames,
+  getCommand,
+  notifyToolCallObservers,
+  shellReadFile
+} from "./chunk-7MTRVW2U.mjs";
+
+// src/main/tools/shell/executor/pipeline-executor.ts
+function vfsPath(p) {
+  return p === "." || p === "./" || p === "/" ? "" : p.replace(/^\.\//, "").replace(/^\//, "");
+}
+var MAX_SHELL_DEPTH = 50;
+async function guardCommand(cmd, ctx) {
+  let gate = ctx.gate;
+  if (!gate) return { blocked: null, observed: [] };
+  let evalr = evaluateCommand(cmd, ctx.config), blocked = await enforceToolGate(evalr, gate, ctx.config, gate.command ?? cmd.name);
+  return { blocked, observed: blocked ? [] : evalr.intercepted };
+}
+async function executeNode(node, stdin, ctx) {
+  if (ctx.signal?.aborted)
+    return err("shell: aborted", 130);
+  if (node.kind === "pipeline")
+    return executePipeline(node, stdin, ctx);
+  let sequence = [];
+  {
+    let op = null, cur = node;
+    for (; cur.kind === "chain"; )
+      sequence.push({ op, pipeline: cur.left }), op = cur.operator, cur = cur.right;
+    sequence.push({ op, pipeline: cur });
+  }
+  let combine = (left, right) => {
+    let media = [...left.media ?? [], ...right.media ?? []], endTurn = left.end_turn || right.end_turn, targetState = right.target_state ?? left.target_state;
+    return {
+      exit_code: right.exit_code,
+      stdout: left.stdout && right.stdout ? left.stdout + `
+` + right.stdout : left.stdout || right.stdout,
+      stderr: left.stderr && right.stderr ? left.stderr + `
+` + right.stderr : left.stderr || right.stderr,
+      ...media.length > 0 ? { media } : {},
+      ...endTurn ? { end_turn: !0 } : {},
+      ...targetState ? { target_state: targetState } : {}
+    };
+  }, acc = null, lastExit = 0, nextStdin = stdin;
+  for (let { op, pipeline } of sequence) {
+    if (ctx.signal?.aborted)
+      return err("shell: aborted", 130);
+    if (op === "&&" && lastExit !== 0 || op === "||" && lastExit === 0) continue;
+    let result = await executePipeline(pipeline, nextStdin, ctx);
+    nextStdin = "", lastExit = result.exit_code, acc = acc ? combine(acc, result) : result;
+  }
+  return acc ?? { exit_code: 0, stdout: "", stderr: "" };
+}
+async function executePipeline(pipeline, initialStdin, ctx) {
+  if (pipeline.stages.length === 0)
+    return { exit_code: 0, stdout: "", stderr: "" };
+  let currentStdin = initialStdin, lastResult = { exit_code: 0, stdout: "", stderr: "" }, media = [], endTurn = !1, targetState, finish = (result) => ({
+    ...result,
+    ...media.length > 0 ? { media } : {},
+    ...endTurn ? { end_turn: !0 } : {},
+    ...targetState ? { target_state: targetState } : {}
+  });
+  for (let cmd of pipeline.stages) {
+    if (ctx.signal?.aborted)
+      return err("shell: aborted", 130);
+    if (lastResult = await executeCommand(cmd, currentStdin, ctx), ctx.env.setLastExitCode(lastResult.exit_code), lastResult.media && media.push(...lastResult.media), lastResult.end_turn && (endTurn = !0, targetState = lastResult.target_state ?? targetState), PIPELINE_FATAL_CODES.has(lastResult.exit_code) && lastResult.stderr !== "")
+      return finish(lastResult);
+    currentStdin = lastResult.stdout;
+  }
+  return finish(lastResult);
+}
+var PIPELINE_FATAL_CODES = /* @__PURE__ */ new Set([124, 126, 127, 130]), RESERVED_CONTROL_WORDS = /* @__PURE__ */ new Set([
+  "for",
+  "while",
+  "until",
+  "if",
+  "then",
+  "else",
+  "elif",
+  "fi",
+  "do",
+  "done",
+  "case",
+  "esac",
+  "select",
+  "function"
+]);
+async function executeCommand(cmd, stdin, ctx) {
+  let name = cmd.name, liveConfig = ctx.getConfig ?? ctx.gate?.getConfig;
+  if (liveConfig && (ctx = { ...ctx, config: liveConfig() }), RESERVED_CONTROL_WORDS.has(name))
+    return err(`${name}: control flow is not supported in adf_shell \u2014 use xargs, or a .js script for loops`, 2);
+  let firstArg = cmd.args[0];
+  if (firstArg?.type === "literal" && (firstArg.value === "-h" || firstArg.value === "--help")) {
+    let helpHandler = getCommand(name);
+    if (helpHandler)
+      return { exit_code: 0, stdout: helpHandler.helpText, stderr: "" };
+  }
+  let { blocked, observed } = await guardCommand(cmd, ctx);
+  if (blocked) return applyGateFailureRedirects(blocked, cmd, ctx);
+  let observe = (result2) => (observed.length > 0 && ctx.gate && notifyToolCallObservers(observed, ctx.gate, ctx.config, ctx.gate.command ?? cmd.name), result2);
+  if (cmd.assignments?.length) {
+    let vars = {};
+    for (let a of cmd.assignments) {
+      let parts = await Promise.all(a.value.map((p) => resolveArg(p, ctx)));
+      vars[a.name] = parts.join("");
+    }
+    if (!name) {
+      for (let [k, v] of Object.entries(vars)) ctx.env.export(k, v);
+      return { exit_code: 0, stdout: "", stderr: "" };
+    }
+    ctx = { ...ctx, env: ctx.env.withOverlay(vars) };
+  }
+  let redirects = [];
+  for (let r of cmd.redirects) {
+    if (r.type === "dup" || r.type === "discard") {
+      redirects.push(r);
+      continue;
+    }
+    let target = r.target;
+    if (target === void 0 && r.targetNode && (target = await resolveArg(r.targetNode, ctx)), target === void 0) continue;
+    let special = classifyRedirectTarget(target);
+    if (special === "null") {
+      redirects.push({ type: "discard", fd: r.type === "in" ? 0 : r.fd ?? 1 });
+      continue;
+    }
+    if (special)
+      return err(`${name}: ${unsupportedDevTargetMessage(special)}`, 2);
+    redirects.push({ ...r, target });
+  }
+  for (let r of redirects) {
+    if (r.type === "in" && r.target !== void 0) {
+      let [redirectContent, redirectErr] = await shellReadFile(ctx.toolRegistry, ctx.workspace, vfsPath(r.target));
+      if (redirectErr)
+        return err(`${name}: ${redirectErr}`);
+      stdin = redirectContent;
+    }
+    r.type === "discard" && r.fd === 0 && (stdin = "");
+  }
+  cmd.heredoc && (stdin = cmd.heredoc.quoted ? cmd.heredoc.content : expandHeredocVars(cmd.heredoc.content, ctx.env));
+  let resolvedArgs = await resolveArgs(cmd.args, ctx);
+  if (resolvedArgs.length > 0 && (resolvedArgs[0] === "-h" || resolvedArgs[0] === "--help")) {
+    let handler2 = getCommand(name);
+    if (handler2)
+      return { exit_code: 0, stdout: handler2.helpText, stderr: "" };
+  }
+  if (name === "echo") {
+    let args = resolvedArgs, interpretEscapes = !1, noTrailingNewline = !1;
+    for (; args.length > 0 && (args[0] === "-e" || args[0] === "-n" || args[0] === "-en" || args[0] === "-ne"); )
+      args[0].includes("e") && (interpretEscapes = !0), args[0].includes("n") && (noTrailingNewline = !0), args = args.slice(1);
+    let output = args.join(" ");
+    return interpretEscapes && (output = output.replace(/\\n/g, `
+`).replace(/\\t/g, "	").replace(/\\r/g, "\r").replace(/\\\\/g, "\\")), noTrailingNewline || (output += `
+`), observe(await applyRedirects({ exit_code: 0, stdout: output, stderr: "" }, redirects, ctx));
+  }
+  if (name.startsWith("./") || name.startsWith("/")) {
+    let handler2 = getCommand("./");
+    if (handler2) {
+      let cmdCtx2 = buildCommandContext([name, ...resolvedArgs], stdin, ctx, handler2.valueFlags), result2 = await handler2.execute(cmdCtx2);
+      return observe(await applyRedirects(result2, redirects, ctx));
+    }
+    return err(`${name}: command not found`, EXIT.NOT_FOUND);
+  }
+  let handler = getCommand(name);
+  if (!handler)
+    return err(`${name}: command not found`, EXIT.NOT_FOUND);
+  let cmdCtx = buildCommandContext(resolvedArgs, stdin, ctx, handler.valueFlags), result = await handler.execute(cmdCtx);
+  return observe(await applyRedirects(result, redirects, ctx));
+}
+async function resolveArgs(args, ctx) {
+  let result = [];
+  for (let arg of args) {
+    if (arg.type === "literal" && hasGlobChars(arg.value)) {
+      result.push(...expandGlob(arg.value, ctx));
+      continue;
+    }
+    result.push(await resolveArg(arg, ctx));
+  }
+  return result;
+}
+async function resolveArg(arg, ctx) {
+  switch (arg.type) {
+    case "literal":
+      return arg.value;
+    case "variable":
+      return resolveWithDefault(ctx.env, arg.name, arg.op, arg.word);
+    case "substitution":
+      return (await executePipeline(arg.pipeline, "", ctx)).stdout.replace(/\n$/, "");
+    case "quoted":
+      return (await Promise.all(arg.parts.map((p) => resolveArg(p, ctx)))).join("");
+  }
+}
+function expandHeredocVars(content, env) {
+  return content.replace(
+    /\\\$|\$\{([^}]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)|\$\?/g,
+    (m, braced, name) => {
+      if (m === "\\$") return "$";
+      if (m === "$?") return env.resolve("?");
+      if (braced !== void 0) {
+        let exp = parseBracedExpansion(braced);
+        return resolveWithDefault(env, exp.name, exp.op, exp.word);
+      }
+      return env.resolve(name);
+    }
+  );
+}
+function hasGlobChars(s) {
+  return /[*?]/.test(s) || /\[.+\]/.test(s);
+}
+function globToRegExp(pattern) {
+  let re = "^";
+  for (let i = 0; i < pattern.length; i++) {
+    let c = pattern[i];
+    if (c === "*")
+      re += "[^/]*";
+    else if (c === "?")
+      re += "[^/]";
+    else if (c === "[") {
+      let j = i + 1;
+      for ((pattern[j] === "!" || pattern[j] === "^") && j++, pattern[j] === "]" && j++; j < pattern.length && pattern[j] !== "]"; ) j++;
+      if (j >= pattern.length) {
+        re += "\\[";
+        continue;
+      }
+      let cls = pattern.slice(i + 1, j);
+      cls.startsWith("!") && (cls = "^" + cls.slice(1)), re += "[" + cls.replace(/\\/g, "\\\\") + "]", i = j;
+    } else
+      re += c.replace(/[.+^${}()|\\]/g, "\\$&");
+  }
+  return new RegExp(re + "$");
+}
+function expandGlob(pattern, ctx) {
+  if (typeof ctx.workspace.listFiles != "function") return [pattern];
+  let paths;
+  try {
+    paths = ctx.workspace.listFiles().map((f) => f.path);
+  } catch {
+    return [pattern];
+  }
+  let candidates = /* @__PURE__ */ new Set();
+  for (let p of paths) {
+    candidates.add(p);
+    let idx = p.indexOf("/");
+    for (; idx !== -1; )
+      candidates.add(p.slice(0, idx)), idx = p.indexOf("/", idx + 1);
+  }
+  let regex = globToRegExp(vfsPath(pattern)), matches = [...candidates].filter((c) => regex.test(c)).sort().map((m) => m.startsWith("-") ? "./" + m : m);
+  return matches.length > 0 ? matches : [pattern];
+}
+function buildCommandContext(resolvedArgs, stdin, ctx, valueFlags) {
+  let args = [], flags = {}, i = 0;
+  for (; i < resolvedArgs.length; ) {
+    let a = resolvedArgs[i];
+    if (a === "--") {
+      for (let j = i + 1; j < resolvedArgs.length; j++)
+        args.push(resolvedArgs[j]);
+      break;
+    } else if (a.startsWith("--")) {
+      let key = a.slice(2), eqIdx = key.indexOf("=");
+      if (eqIdx !== -1) {
+        let eqVal = key.slice(eqIdx + 1);
+        key = key.slice(0, eqIdx), eqVal ? (flags[key] = eqVal, i++) : i + 1 < resolvedArgs.length && !resolvedArgs[i + 1].startsWith("-") ? (flags[key] = resolvedArgs[i + 1], i += 2) : (flags[key] = !0, i++);
+      } else if (i + 1 < resolvedArgs.length && !resolvedArgs[i + 1].startsWith("-")) {
+        let val = resolvedArgs[i + 1], existing = flags[key];
+        existing !== void 0 ? Array.isArray(existing) ? existing.push(val) : typeof existing == "string" && (flags[key] = [existing, val]) : flags[key] = val, i += 2;
+      } else
+        flags[key] = !0, i++;
+    } else if (a.startsWith("-") && a.length >= 2 && a[1] !== "-")
+      if (a.length === 2) {
+        let key = a.slice(1);
+        if (valueFlags?.has(key) && i + 1 < resolvedArgs.length && !resolvedArgs[i + 1].startsWith("-")) {
+          let val = resolvedArgs[i + 1], existing = flags[key];
+          existing !== void 0 ? Array.isArray(existing) ? existing.push(val) : typeof existing == "string" && (flags[key] = [existing, val]) : flags[key] = val, i += 2;
+        } else
+          flags[key] = !0, i++;
+      } else if (valueFlags?.has(a[1]))
+        flags[a[1]] = a.slice(2), i++;
+      else {
+        for (let c = 1; c < a.length; c++)
+          flags[a[c]] = !0;
+        i++;
+      }
+    else
+      args.push(a), i++;
+  }
+  return {
+    stdin,
+    args,
+    flags,
+    rawArgs: resolvedArgs,
+    workspace: ctx.workspace,
+    toolRegistry: ctx.toolRegistry,
+    config: ctx.config,
+    env: ctx.env,
+    gate: ctx.gate,
+    authorized: ctx.gate?.authorized,
+    signal: ctx.signal,
+    depth: ctx.depth
+  };
+}
+function staticResolveTarget(node, env) {
+  switch (node.type) {
+    case "literal":
+      return node.value;
+    case "variable":
+      return resolveWithDefault(env, node.name, node.op, node.word);
+    case "quoted": {
+      let out = "";
+      for (let p of node.parts) {
+        let s = staticResolveTarget(p, env);
+        if (s === null) return null;
+        out += s;
+      }
+      return out;
+    }
+    case "substitution":
+      return null;
+  }
+}
+async function applyGateFailureRedirects(blocked, cmd, ctx) {
+  if (cmd.redirects.length === 0) return blocked;
+  let notes = [], redirects = [];
+  for (let r of cmd.redirects) {
+    if (r.type === "in") continue;
+    if (r.type === "dup" || r.type === "discard") {
+      redirects.push(r);
+      continue;
+    }
+    let target = r.target;
+    if (target === void 0 && r.targetNode) {
+      let resolved = staticResolveTarget(r.targetNode, ctx.env);
+      if (resolved === null) {
+        notes.push("adf_shell: note: redirect target with command substitution was not resolved for the refused command; error kept on stderr");
+        continue;
+      }
+      target = resolved;
+    }
+    if (target === void 0) continue;
+    let special = classifyRedirectTarget(target);
+    if (special === "null") {
+      redirects.push({ type: "discard", fd: r.fd ?? 1 });
+      continue;
+    }
+    if (special) {
+      notes.push(`adf_shell: note: ${unsupportedDevTargetMessage(special)}; error kept on stderr`);
+      continue;
+    }
+    redirects.push({ ...r, target });
+  }
+  let isFileRedirect = (r) => (r.type === "out" || r.type === "append") && r.target !== void 0, observeWrite = [];
+  if (redirects.some(isFileRedirect) && !ctx.gate?.authorized) {
+    let ev = Array.isArray(ctx.config.tools) ? evaluateToolNames(["fs_write"], ctx.config) : { disabled: [], approvalRequired: [], intercepted: [], resolvedTools: [] };
+    if (ev.disabled.length > 0 || ev.approvalRequired.length > 0) {
+      for (let i = redirects.length - 1; i >= 0; i--)
+        isFileRedirect(redirects[i]) && redirects.splice(i, 1);
+      notes.push("adf_shell: note: file redirect not honored (fs_write is not permitted); error kept on stderr");
+    } else
+      observeWrite = ev.intercepted;
+  }
+  let res = await applyRedirects(blocked, redirects, ctx);
+  if (observeWrite.length > 0 && ctx.gate && notifyToolCallObservers(observeWrite, ctx.gate, ctx.config, ctx.gate.command ?? cmd.name), notes.length === 0) return res;
+  let noteText = notes.join(`
+`);
+  return { ...res, stderr: res.stderr ? `${res.stderr}
+${noteText}` : noteText };
+}
+async function applyRedirects(result, redirects, ctx) {
+  let res = result;
+  for (let r of redirects)
+    if (r.type === "dup") {
+      if (r.fd === 2 && r.targetFd === 1) {
+        let sep = res.stdout && !res.stdout.endsWith(`
+`) && res.stderr ? `
+` : "";
+        res = { ...res, stdout: res.stdout + sep + res.stderr, stderr: "" };
+      } else if (r.fd === 1 && r.targetFd === 2) {
+        let sep = res.stderr && !res.stderr.endsWith(`
+`) && res.stdout ? `
+` : "";
+        res = { ...res, stderr: res.stderr + sep + res.stdout, stdout: "" };
+      }
+    }
+  for (let r of redirects) {
+    if (r.type === "discard") {
+      r.fd === 2 ? res = { ...res, stderr: "" } : r.fd !== 0 && (res = { ...res, stdout: "" });
+      continue;
+    }
+    if ((r.type === "out" || r.type === "append") && r.target !== void 0) {
+      let content = r.fd === 2 ? res.stderr : res.stdout;
+      await ctx.toolRegistry.executeTool("fs_write", {
+        mode: r.type === "append" ? "append" : "write",
+        path: vfsPath(r.target),
+        content
+      }, ctx.workspace), res = r.fd === 2 ? { ...res, stderr: "" } : { ...res, stdout: "" };
+    }
+  }
+  return res;
+}
+
+export {
+  MAX_SHELL_DEPTH,
+  executeNode
+};

package/dist/chunks/chunk-UYY5M2PB.mjs

@@ -0,0 +1,151 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  __export
+} from "./chunk-M2RX3S2T.mjs";
+
+// src/shared/constants/adapter-registry.ts
+var adapter_registry_exports = {};
+__export(adapter_registry_exports, {
+  ADAPTER_REGISTRY: () => ADAPTER_REGISTRY,
+  findAdapterRegistryEntry: () => findAdapterRegistryEntry,
+  findAdapterRegistryEntryByPackage: () => findAdapterRegistryEntryByPackage,
+  getEnabledAgentAdapterConfig: () => getEnabledAgentAdapterConfig,
+  withBuiltInAdapterRegistrations: () => withBuiltInAdapterRegistrations
+});
+var MESSAGING_GUIDE_URL = "https://github.com/christianbalevski/adf/blob/main/docs/guides/messaging.md", ADAPTER_REGISTRY = [
+  {
+    type: "telegram",
+    displayName: "Telegram",
+    builtIn: !0,
+    description: "Receive and send Telegram messages via a bot token",
+    tagline: "A bot in your DMs and groups. One token from BotFather.",
+    iconKey: "telegram",
+    requiredEnvKeys: ["TELEGRAM_BOT_TOKEN"],
+    credentials: [
+      { key: "TELEGRAM_BOT_TOKEN", label: "Bot token", required: !0, placeholder: "123456789:AA\u2026", hint: "From @BotFather after /newbot." }
+    ],
+    setupSteps: [
+      { text: 'Open @BotFather in Telegram and send /newbot. Pick a name and a username ending in "bot".', url: "https://t.me/BotFather" },
+      { text: "Copy the token BotFather replies with and paste it below." },
+      { text: "Message your bot once so it can see you. For groups, add the bot and mention it." }
+    ],
+    docsUrl: `${MESSAGING_GUIDE_URL}#telegram-adapter`,
+    verified: !0
+  },
+  {
+    type: "email",
+    displayName: "Email",
+    builtIn: !0,
+    description: "Send and receive email via IMAP/SMTP",
+    tagline: "Any mailbox with IMAP and SMTP. Gmail, iCloud, Outlook, Fastmail, self-hosted.",
+    iconKey: "email",
+    requiredEnvKeys: ["EMAIL_USERNAME", "EMAIL_PASSWORD"],
+    credentials: [
+      { key: "EMAIL_USERNAME", label: "Email address", required: !0, placeholder: "agent@example.com", hint: "Servers are detected from the domain. Custom hosts go in the agent config." },
+      { key: "EMAIL_PASSWORD", label: "App password", required: !0, placeholder: "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022", hint: "An app-specific password, not the account password." }
+    ],
+    setupSteps: [
+      { text: "Turn on two-factor authentication for the mailbox. Most providers require it for app passwords." },
+      { text: "Create an app-specific password in the provider's security settings (Gmail: myaccount.google.com/apppasswords).", url: "https://myaccount.google.com/apppasswords" },
+      { text: "Enter the full address and that app password below. IMAP and SMTP hosts are detected from the domain." }
+    ],
+    docsUrl: `${MESSAGING_GUIDE_URL}#email-adapter`,
+    verified: !0
+  },
+  {
+    type: "discord",
+    displayName: "Discord",
+    builtIn: !0,
+    description: "Receive and send Discord messages via a bot token (DMs, guilds, /<botname> slash command)",
+    tagline: "A bot in servers and DMs, with an optional slash command.",
+    iconKey: "discord",
+    requiredEnvKeys: ["DISCORD_BOT_TOKEN"],
+    optionalEnvKeys: ["DISCORD_APPLICATION_ID"],
+    credentials: [
+      { key: "DISCORD_BOT_TOKEN", label: "Bot token", required: !0, placeholder: "MTA\u2026", hint: "Bot page \u2192 Reset Token. Discord shows it once." },
+      { key: "DISCORD_APPLICATION_ID", label: "Application ID", required: !1, placeholder: "1234567890", hint: "Optional. Registers a /<botname> slash command." }
+    ],
+    setupSteps: [
+      { text: "Create an application in the Discord Developer Portal.", url: "https://discord.com/developers/applications" },
+      { text: "On the Bot page click Reset Token and copy it. Under Privileged Gateway Intents turn on Message Content Intent and save." },
+      { text: 'Invite the bot with the "bot" and "applications.commands" scopes and permission to view channels, read history, send messages, and attach files.' }
+    ],
+    docsUrl: `${MESSAGING_GUIDE_URL}#discord-adapter`,
+    verified: !0
+  },
+  {
+    type: "slack",
+    displayName: "Slack",
+    builtIn: !0,
+    description: "Receive and send Slack messages via Socket Mode (app token + bot token, no public endpoint)",
+    tagline: "Socket Mode: no public URL. Two tokens from api.slack.com.",
+    iconKey: "slack",
+    requiredEnvKeys: ["SLACK_APP_TOKEN", "SLACK_BOT_TOKEN"],
+    credentials: [
+      { key: "SLACK_APP_TOKEN", label: "App-level token", required: !0, placeholder: "xapp-\u2026", hint: "Socket Mode page. Needs the connections:write scope." },
+      { key: "SLACK_BOT_TOKEN", label: "Bot user OAuth token", required: !0, placeholder: "xoxb-\u2026", hint: "Install App page, after installing to the workspace." }
+    ],
+    setupSteps: [
+      { text: "Create a Slack app from scratch and pick the workspace.", url: "https://api.slack.com/apps" },
+      { text: "Socket Mode page: enable it and copy the xapp- token." },
+      { text: "Event Subscriptions: enable events and subscribe the bot to message.channels, message.groups, message.im, message.mpim. Without these the socket connects but stays silent." },
+      { text: "OAuth & Permissions: add chat:write, im:write, users:read, channels:read, groups:read, im:read, mpim:read, files:read, files:write. App Home: enable the Messages tab." },
+      { text: "Install (or reinstall) the app and copy the xoxb- bot token. Invite the bot to each channel it should read." }
+    ],
+    docsUrl: `${MESSAGING_GUIDE_URL}#slack-adapter`,
+    verified: !0
+  },
+  {
+    type: "whatsapp",
+    displayName: "WhatsApp",
+    builtIn: !0,
+    description: "Personal WhatsApp account via multi-device pairing \u2014 scan a QR code, no tokens. Unofficial protocol; use a non-critical account.",
+    tagline: "Pair a personal account by QR. Unofficial protocol, use a spare number.",
+    iconKey: "whatsapp",
+    requiredEnvKeys: [],
+    credentials: [],
+    setupSteps: [
+      { text: "Connect an agent below. No credentials are needed." },
+      { text: "Start the agent. The adapter writes a pairing QR to imported/whatsapp/pairing-qr.png in the agent's files and notes it in the channel log." },
+      { text: "On the phone open WhatsApp \u2192 Linked Devices \u2192 Link a device and scan it. The QR refreshes every minute until paired." }
+    ],
+    docsUrl: `${MESSAGING_GUIDE_URL}#whatsapp-adapter`,
+    verified: !0
+  }
+], BUILT_IN_ADAPTER_REGISTRATIONS = ADAPTER_REGISTRY.filter((entry) => entry.builtIn).map((entry) => ({
+  id: entry.type,
+  type: entry.type,
+  managed: !1
+}));
+function withBuiltInAdapterRegistrations(registrations) {
+  let builtInsByType = new Map(BUILT_IN_ADAPTER_REGISTRATIONS.map((entry) => [entry.type, entry])), seenTypes = /* @__PURE__ */ new Set(), merged = [];
+  for (let registration of registrations ?? []) {
+    let builtIn = builtInsByType.get(registration.type);
+    merged.push(builtIn ? { ...builtIn, ...registration } : { ...registration }), seenTypes.add(registration.type);
+  }
+  for (let builtIn of BUILT_IN_ADAPTER_REGISTRATIONS)
+    seenTypes.has(builtIn.type) || merged.push({ ...builtIn });
+  return merged;
+}
+function findAdapterRegistryEntry(type) {
+  return ADAPTER_REGISTRY.find((e) => e.type === type);
+}
+function findAdapterRegistryEntryByPackage(npmPackage) {
+  return ADAPTER_REGISTRY.find((e) => e.npmPackage === npmPackage);
+}
+function getEnabledAgentAdapterConfig(adapters, type) {
+  let config = adapters?.[type];
+  return config?.enabled === !0 ? config : null;
+}
+
+export {
+  withBuiltInAdapterRegistrations,
+  findAdapterRegistryEntry,
+  getEnabledAgentAdapterConfig,
+  adapter_registry_exports
+};