@desplega.ai/agent-swarm 2.4.4 → 2.5.0

package/src/integrations/chat-sdk/outbound.ts

@@ -1,6 +1,15 @@
+import type { Attachment, FileUpload } from "chat";
 import { scrubSecrets } from "@/utils/secret-scrubber";
 import { workflowEventBus } from "@/workflows/event-bus";
-import { chatMessageLimit, splitChatMessage } from "./limits";
+import { formatFileSize } from "./attachments";
+import {
+  CHAT_FILES_PER_MESSAGE,
+  chatMessageLimit,
+  chatUploadLimit,
+  splitChatMessage,
+  TELEGRAM_PHOTO_LIMIT,
+} from "./limits";
+import { errorMessage } from "./logger";
 import { getChatInstance } from "./runtime";
 import { assertTrustedChatTarget } from "./teams-origin";
 
@@ -39,12 +48,76 @@ export interface ChatPostResult {
   adapter: string;
   threadId: string;
   channelId: string;
-  /** One id per chunk, in send order. */
+  /** One id per chunk and per file message, in send order. */
   messageIds: string[];
+  /** Files that did not reach the thread. The thread got a note naming each one. */
+  unsentFiles: UnsentChatFile[];
+}
+
+/** A file to send after the text. `load` reads its bytes. */
+export interface OutboundChatFile {
+  name: string;
+  mimeType?: string;
+  /** Size known before loading, so an oversized file is never read. */
+  sizeBytes?: number;
+  /** Throws `ChatFileTooLargeError` when the file is larger than `maxBytes`. */
+  load(maxBytes: number): Promise<{ data: Uint8Array; mimeType?: string }>;
+}
+
+export interface UnsentChatFile {
+  name: string;
+  reason: string;
+}
+
+export class ChatFileTooLargeError extends Error {
+  constructor(readonly sizeBytes: number) {
+    super(`file is ${formatFileSize(sizeBytes)}`);
+    this.name = "ChatFileTooLargeError";
+  }
 }
 
 interface PostTarget {
-  post(message: { markdown: string }): Promise<{ id: string; threadId?: string }>;
+  post(message: {
+    markdown: string;
+    files?: FileUpload[];
+    attachments?: Attachment[];
+  }): Promise<{ id: string; threadId?: string }>;
+}
+
+/** A fence opener or closer: up to 3 spaces, then 3+ backticks or tildes. */
+const FENCE_LINE = /^ {0,3}(`{3,}|~{3,})/;
+/**
+ * A `#` run at the start of a line's text (after blockquote, list and task
+ * markers) that CommonMark does not read as a heading: 7+ `#`, or `#` followed
+ * by a character other than whitespace or `#`.
+ */
+const NON_HEADING_HASH =
+  /^( {0,3}(?:>[ \t]?)*[ \t]*(?:(?:[-*+]|\d{1,9}[.)])[ \t]+(?:\[[ xX]\][ \t]+)?)?)(#{7,}|#{1,6}(?=[^\s#]))/;
+
+/**
+ * Telegram renders `{ markdown }` posts with `sendRichMessage`, and Telegram's
+ * own Markdown parser reads a line-leading `#2203` or `#tag` as a heading.
+ * Escape the first `#` of such a line so only CommonMark ATX headings
+ * (`# Title`) stay headings. Fenced code is left as is. The MarkdownV2
+ * fallback parses the escape back to a literal `#`.
+ */
+export function escapeTelegramHashLines(markdown: string): string {
+  let fence: string | undefined;
+  return markdown
+    .split("\n")
+    .map((line) => {
+      const marker = FENCE_LINE.exec(line)?.[1];
+      if (fence) {
+        if (marker && marker[0] === fence[0] && marker.length >= fence.length) fence = undefined;
+        return line;
+      }
+      if (marker) {
+        fence = marker;
+        return line;
+      }
+      return line.replace(NON_HEADING_HASH, "$1\\$2");
+    })
+    .join("\n");
 }
 
 async function postChunks(
@@ -55,17 +128,194 @@ async function postChunks(
   const messageIds: string[] = [];
   let threadId: string | undefined;
   for (const chunk of splitChatMessage(text, chatMessageLimit(adapter))) {
-    const sent = await target.post({ markdown: chunk });
+    const markdown = adapter === "telegram" ? escapeTelegramHashLines(chunk) : chunk;
+    const sent = await target.post({ markdown });
     messageIds.push(sent.id);
     threadId ??= sent.threadId;
   }
   return { messageIds, threadId };
 }
 
+type LoadedFile = { name: string; mimeType: string; data: Buffer };
+
+/** First usable MIME type, else a guess from the file extension. */
+function resolveMimeType(name: string, ...candidates: (string | null | undefined)[]): string {
+  for (const candidate of candidates) {
+    const type = candidate?.split(";")[0]?.trim().toLowerCase();
+    if (type && type !== "application/octet-stream") return type;
+  }
+  return Bun.file(name).type.split(";")[0] ?? "application/octet-stream";
+}
+
+/**
+ * How Telegram shows a file. Only types its media methods take are sent as
+ * photo, video or audio; everything else, and a photo over 10 MB, goes as a
+ * document.
+ */
+export function telegramAttachmentType(mimeType: string, sizeBytes: number): Attachment["type"] {
+  if (
+    (mimeType === "image/jpeg" || mimeType === "image/png") &&
+    sizeBytes <= TELEGRAM_PHOTO_LIMIT
+  ) {
+    return "image";
+  }
+  if (mimeType === "video/mp4") return "video";
+  if (mimeType === "audio/mpeg" || mimeType === "audio/mp4" || mimeType === "audio/x-m4a") {
+    return "audio";
+  }
+  return "file";
+}
+
+/**
+ * Telegram media groups mix photos and videos only; documents and audio group
+ * with their own kind. Other adapters put any files in one message.
+ */
+function fileGroupKey(adapter: string, file: LoadedFile): string {
+  if (adapter !== "telegram") return "files";
+  const type = telegramAttachmentType(file.mimeType, file.data.byteLength);
+  return type === "image" || type === "video" ? "visual" : type;
+}
+
+function fileMessage(adapter: string, files: LoadedFile[]) {
+  // Telegram uploads `files` only as documents; typed `attachments` become
+  // photos, videos and audio. A list of 2 to 10 is sent as one media group.
+  if (adapter === "telegram") {
+    return {
+      markdown: "",
+      attachments: files.map(
+        (file): Attachment => ({
+          type: telegramAttachmentType(file.mimeType, file.data.byteLength),
+          name: file.name,
+          mimeType: file.mimeType,
+          size: file.data.byteLength,
+          data: file.data,
+        }),
+      ),
+    };
+  }
+  return {
+    markdown: "",
+    files: files.map((file) => ({ data: file.data, filename: file.name, mimeType: file.mimeType })),
+  };
+}
+
+function platformName(adapter: string): string {
+  return adapter.charAt(0).toUpperCase() + adapter.slice(1);
+}
+
+/**
+ * Send files as file messages, up to 10 per message, grouped the way the
+ * platform allows. Files are read one by one and a group is sent once full, so
+ * at most one group is held in memory. Never throws: a file that is too large,
+ * cannot be read, or is refused by the platform lands in `unsent`.
+ */
+async function postFiles(
+  adapter: string,
+  target: PostTarget,
+  files: OutboundChatFile[],
+): Promise<{ messageIds: string[]; unsent: UnsentChatFile[] }> {
+  const limit = chatUploadLimit(adapter);
+  const tooLarge = (size: number) =>
+    `${formatFileSize(size)}, over the ${formatFileSize(limit)} upload limit of ${platformName(adapter)}`;
+  const messageIds: string[] = [];
+  const unsent: UnsentChatFile[] = [];
+  const groups = new Map<string, LoadedFile[]>();
+
+  const send = async (group: LoadedFile[]) => {
+    try {
+      const sent = await target.post(fileMessage(adapter, group));
+      messageIds.push(sent.id);
+    } catch (error) {
+      const reason = `refused by ${platformName(adapter)} (${scrubSecrets(errorMessage(error))})`;
+      for (const file of group) unsent.push({ name: file.name, reason });
+    }
+  };
+
+  for (const file of files) {
+    if (file.sizeBytes !== undefined && file.sizeBytes > limit) {
+      unsent.push({ name: file.name, reason: tooLarge(file.sizeBytes) });
+      continue;
+    }
+    let loaded: LoadedFile;
+    try {
+      const { data, mimeType } = await file.load(limit);
+      if (data.byteLength > limit) throw new ChatFileTooLargeError(data.byteLength);
+      loaded = {
+        name: file.name,
+        mimeType: resolveMimeType(file.name, file.mimeType, mimeType),
+        data: Buffer.from(data.buffer, data.byteOffset, data.byteLength),
+      };
+    } catch (error) {
+      unsent.push({
+        name: file.name,
+        reason:
+          error instanceof ChatFileTooLargeError
+            ? tooLarge(error.sizeBytes)
+            : `could not be read (${scrubSecrets(errorMessage(error))})`,
+      });
+      continue;
+    }
+    const key = fileGroupKey(adapter, loaded);
+    const group = [...(groups.get(key) ?? []), loaded];
+    if (group.length === CHAT_FILES_PER_MESSAGE) {
+      groups.delete(key);
+      await send(group);
+    } else {
+      groups.set(key, group);
+    }
+  }
+  for (const group of groups.values()) await send(group);
+  return { messageIds, unsent };
+}
+
+/** Tool-result suffix naming the files that did not go out; empty when all did. */
+export function unsentFilesSummary(unsent: UnsentChatFile[]): string {
+  return unsent.length === 0 ? "" : ` ${formatUnsentFilesNote(unsent)}`;
+}
+
+/** One line of untrusted text: control characters and line breaks become spaces. */
+function singleLine(text: string): string {
+  // biome-ignore lint/suspicious/noControlCharactersInRegex: stripping them is the point
+  return text.replace(/[\u0000-\u001f\u007f\u2028\u2029]+/g, " ").trim();
+}
+
+/** A zero-width space after `@` and `<!` keeps adapters from turning text into mentions. */
+function breakMentions(text: string): string {
+  return text.replace(/@/g, "@\u200b").replace(/<!/g, "<\u200b!");
+}
+
+/**
+ * A file name as a Markdown code span, so it renders literally: no emphasis,
+ * links, or mentions. The fence is one backtick longer than the longest run
+ * inside, and the padding keeps an edge backtick from joining the fence.
+ */
+function codeSpan(text: string): string {
+  const value = breakMentions(singleLine(text)) || "(unnamed)";
+  const longestRun = Math.max(0, ...(value.match(/`+/g) ?? []).map((run) => run.length));
+  const fence = "`".repeat(longestRun + 1);
+  const pad = value.startsWith("`") || value.endsWith("`") ? " " : "";
+  return `${fence}${pad}${value}${pad}${fence}`;
+}
+
+/**
+ * The note posted after the files when some did not go out. File names come
+ * from senders and agents, so they render as code spans and cannot add
+ * formatting or mentions to the bot's message.
+ */
+export function formatUnsentFilesNote(unsent: UnsentChatFile[]): string {
+  const lines = unsent.map(
+    (file) => `- ${codeSpan(file.name)}: ${breakMentions(singleLine(file.reason))}`,
+  );
+  const count = unsent.length === 1 ? "1 file" : `${unsent.length} files`;
+  return [`Could not send ${count}:`, ...lines].join("\n");
+}
+
 /**
  * Post markdown to a Chat SDK thread or channel. Scrubs the text, splits it by
  * the adapter limit, and emits one `chat.message.sent` for the whole message
- * once every chunk was accepted. Throws `ChatAdapterUnavailableError` when the
+ * once every chunk was accepted. `files` go out after the text; a file that
+ * does not reach the thread is named in a note there and in `unsentFiles`,
+ * and does not fail the call. Throws `ChatAdapterUnavailableError` when the
  * adapter is not running, `UntrustedTeamsServiceUrlError` before any send
  * when a Teams id points at a host that is not Bot Framework, and the adapter
  * error when a send fails.
@@ -80,6 +330,7 @@ export async function postChatMessage(args: {
   channelId?: string;
   text: string;
   taskId?: string;
+  files?: OutboundChatFile[];
 }): Promise<ChatPostResult> {
   // Ids come from tools and stored context keys. Check the Teams origin
   // before the adapter sends its token.
@@ -89,28 +340,44 @@ export async function postChatMessage(args: {
   const text = scrubSecrets(args.text);
 
   let result: ChatPostResult;
+  let target: PostTarget;
   if (args.threadId) {
     const thread = chat.thread(args.threadId);
+    target = thread;
     const sent = await postChunks(args.adapter, thread, text);
     result = {
       adapter: args.adapter,
       threadId: thread.id,
       channelId: thread.channelId,
       messageIds: sent.messageIds,
+      unsentFiles: [],
     };
   } else if (args.channelId) {
     const channel = chat.channel(args.channelId);
+    target = channel;
     const sent = await postChunks(args.adapter, channel, text);
     result = {
       adapter: args.adapter,
       threadId: sent.threadId ?? channel.id,
       channelId: channel.id,
       messageIds: sent.messageIds,
+      unsentFiles: [],
     };
   } else {
     throw new Error("postChatMessage needs a threadId or a channelId");
   }
 
+  if (args.files?.length) {
+    const sent = await postFiles(args.adapter, target, args.files);
+    result.messageIds.push(...sent.messageIds);
+    result.unsentFiles = sent.unsent;
+    if (sent.unsent.length > 0) {
+      const note = formatUnsentFilesNote(sent.unsent);
+      const noted = await postChunks(args.adapter, target, scrubSecrets(note));
+      result.messageIds.push(...noted.messageIds);
+    }
+  }
+
   emitChatMessageSent({
     adapter: result.adapter,
     channelId: result.channelId,

package/src/integrations/chat-sdk/relay.ts

@@ -12,6 +12,7 @@ import { scrubSecrets } from "@/utils/secret-scrubber";
 import { workflowEventBus } from "@/workflows/event-bus";
 import { errorMessage } from "./logger";
 import { postChatMessage } from "./outbound";
+import { taskOutputChatFiles } from "./outbound-files";
 import { getChatInstance, getChatSdkHealth } from "./runtime";
 import { sweepExpired } from "./state";
 import { stopTypingKeepalive } from "./typing";
@@ -49,7 +50,8 @@ export function formatChatRelayText(task: AgentTask): string {
  *
  * Delivery is at-least-once: a chunk failure re-posts the earlier chunks on
  * retry, and a crash between the send and `markChatRelayDelivered` re-sends the
- * message.
+ * message. The task's output attachments go after the text; a file that cannot
+ * be sent gets a note in the thread and does not fail the delivery.
  *
  * Once `signal` aborts, no further row is claimed. A send already in flight is
  * not cancelled (`postChatMessage` takes no signal); its row keeps the claim
@@ -99,6 +101,7 @@ export async function processPendingChatRelays(
         threadId: target.threadId,
         text: formatChatRelayText(task),
         taskId: task.id,
+        files: await taskOutputChatFiles(task.id),
       });
       stopTypingKeepalive(target.threadId);
       await markChatRelayDelivered(task.id, now);

package/src/integrations/chat-sdk/router.ts

@@ -83,6 +83,11 @@ export async function deleteChatChannelMapping(
   return deleteKv(CHAT_CHANNELS_NAMESPACE, chatChannelKey(adapter, channelId));
 }
 
+/** True when the text carries a `swarm#<uuid>` or `swarm#all` routing token. */
+export function hasRoutingToken(text: string): boolean {
+  return /swarm#(?:[a-f0-9-]{36}|all)/i.test(text);
+}
+
 /** Remove `swarm#<uuid>` and `swarm#all` routing tokens from task text. */
 export function stripRoutingTokens(text: string): string {
   return text
@@ -91,6 +96,20 @@ export function stripRoutingTokens(text: string): string {
     .trim();
 }
 
+const DEFAULT_OWNER_WINDOW_MINUTES = 15;
+
+/**
+ * Start of the thread-owner window: a thread keeps its owner while the
+ * owner's task is open and for `CHAT_SDK_OWNER_WINDOW_MIN` (default 15,
+ * 0 = only while open) after it ends. Read per call, so a change applies at once.
+ */
+export function chatOwnerWindowStart(now: number = Date.now()): string {
+  const raw = process.env.CHAT_SDK_OWNER_WINDOW_MIN?.trim();
+  const value = raw ? Number(raw) : Number.NaN;
+  const minutes = Number.isFinite(value) && value >= 0 ? value : DEFAULT_OWNER_WINDOW_MINUTES;
+  return new Date(now - minutes * 60_000).toISOString();
+}
+
 async function leadMatch(reachable: Agent[], matchedText: string): Promise<ChatAgentMatch> {
   const lead = reachable.find((agent) => agent.isLead) ?? (await getLeadAgent());
   return { agent: lead, reason: "skill", matchedText };
@@ -99,7 +118,8 @@ async function leadMatch(reachable: Agent[], matchedText: string): Promise<ChatA
 /**
  * Port of `src/slack/router.ts` for Chat SDK threads. Order: `swarm#<uuid>`,
  * `swarm#all`, KV channel mapping (agent, or workflow for a mention or DM), the
- * thread owner (lead when the owner is offline), the lead for a mention or DM.
+ * thread owner (inside its window in a Telegram group; lead when the owner is
+ * offline), the lead for a mention or DM.
  * Returns null when the message is not addressed to the swarm.
  */
 export async function routeChatMessage(
@@ -148,7 +168,13 @@ export async function routeChatMessage(
     );
   }
 
-  const owner = await getAgentWorkingOnContextKey(chatSdkContextKey(ctx.threadId), "chat");
+  // Only a Telegram group expires its owner: one shared conversation, where a
+  // stale owner would catch the next topic. DMs and threads keep theirs.
+  const owner = await getAgentWorkingOnContextKey(
+    chatSdkContextKey(ctx.threadId),
+    "chat",
+    ctx.adapter === "telegram" && !ctx.isDirectMessage ? chatOwnerWindowStart() : undefined,
+  );
   if (owner && (await isAgentReachable(owner))) {
     return {
       kind: "agents",

package/src/integrations/chat-sdk/steering.ts

@@ -14,15 +14,23 @@ export interface ChatThreadSteeringResult {
  * rule as the Slack default (`SLACK_THREAD_STEERING=lead`, queue mode) as
  * constants: `isSteeringEnabled()` is the only switch. Returns null when the
  * caller should buffer the message into a follow-up task instead.
+ *
+ * Only the task's own requester steers it: a steering row carries the task's
+ * attribution, and an undeliverable one is promoted to a follow-up of this
+ * task. `resolveSender` returns the sender's canonical user, undefined when
+ * unknown; it runs only when there is a task to steer.
  */
 export async function requestChatThreadSteering(args: {
   contextKey: string;
   message: string;
+  resolveSender: () => Promise<string | undefined>;
 }): Promise<ChatThreadSteeringResult | null> {
   if (!isSteeringEnabled()) return null;
 
   const task = await getLatestLeadTaskByContextKey(args.contextKey, "chat");
   if (!task || task.status !== "in_progress") return null;
+  const senderUserId = await args.resolveSender();
+  if (senderUserId !== task.requestedByUserId) return null;
 
   try {
     const result = await requestSteering({
@@ -32,6 +40,7 @@ export async function requestChatThreadSteering(args: {
       onUnsupported: "degrade",
       source: "chat",
       createdByKind: "user",
+      createdByUserId: senderUserId,
     });
     return { task, result };
   } catch (error) {

package/src/integrations/chat-sdk/templates.ts

@@ -14,3 +14,17 @@ registerTemplate({
   ],
   category: "system",
 });
+
+registerTemplate({
+  eventType: "chat.message.header",
+  header: "",
+  defaultBody: "[chat] {{chat_facts}}",
+  variables: [
+    {
+      name: "chat_facts",
+      description:
+        "Adapter, chat type and title, forum topic, sender, why the message was taken (addressed) and the replied-to snippet, joined with ' · '",
+    },
+  ],
+  category: "system",
+});

package/src/integrations/chat-sdk/thread-buffer.ts

@@ -1,6 +1,7 @@
 import type { Attachment } from "chat";
 import { type AdditiveBuffer, createAdditiveBuffer } from "@/tasks/additive-buffer";
 import { trackBackground } from "./background";
+import type { ChatAddressedReason, ChatMessageFacts } from "./facts";
 import { flushChatThread } from "./inbound";
 import { stopTypingKeepalive } from "./typing";
 
@@ -14,6 +15,9 @@ export interface ChatBufferedMessage {
   userName?: string;
   botMentioned: boolean;
   isDirectMessage: boolean;
+  /** Why the message was taken; `none` when it is unaddressed. */
+  addressed: ChatAddressedReason;
+  facts: ChatMessageFacts;
   attachments: Attachment[];
 }
 

package/src/mcp-limits.ts

@@ -0,0 +1,20 @@
+/**
+ * Input caps shared by both MCP surfaces (`/mcp` and `/mcp-user`).
+ *
+ * The SDK leaves both bounds off when you build the server yourself
+ * (GHSA-46jr-4wx8-v453): `McpServer` only counts `tools/call` arguments when
+ * `maxToolInputElements` is set, and our HTTP handlers read the request body
+ * themselves, so the transport's own body cap never runs.
+ */
+
+/**
+ * Largest combined number of array elements and object members a single
+ * `tools/call` `arguments` payload may contain. Sized for the largest
+ * legitimate call: `app-rows-create` takes up to 500 rows, which is about
+ * 24,000 elements at 48 fields per row. Script SDK calls go through
+ * `/api/mcp-bridge`, which does not apply it.
+ */
+export const MCP_MAX_TOOL_INPUT_ELEMENTS = 25_000;
+
+/** Largest MCP HTTP request body we read, in bytes. Matches the SDK default (4 MiB). */
+export const MCP_MAX_REQUEST_BODY_BYTES = 4 * 1024 * 1024;

package/src/pages/browser-sdk.ts

@@ -2,7 +2,7 @@
 //
 // Exposes a domain-grouped API on `window.SwarmSDK` (class) and a ready-to-use
 // singleton `window.swarmSdk`. All calls route through the `/@swarm/api/*`
-// proxy, which strips the page-session cookie and forwards to `/api/*` with
+// proxy, which strips the page's own session cookie and forwards to `/api/*` with
 // a server-side bearer and signed page session. Memory operations use the
 // page owner's agent scope. Viewer identity and permissions remain separate.
 // The browser never handles the server bearer.
@@ -30,10 +30,15 @@ class SwarmSDK {
     this.channel = async (name) => (await loadRealtime()).channel(name);
 
     const base = '/@swarm/api';
+    // Each page has its own session cookie. Naming the page tells the proxy
+    // which one to read; the cookie's signed payload must still match it.
+    const pathParts = typeof location === 'undefined' ? [] : location.pathname.split('/');
+    const pageId = pathParts[1] === 'p' && pathParts[2] ? pathParts[2].split('.')[0] : '';
     const call = async (method, path, body) => {
-      const init = { method };
+      const init = { method, headers: {} };
+      if (pageId) init.headers['X-Swarm-Page-Id'] = pageId;
       if (body !== undefined) {
-        init.headers = { 'Content-Type': 'application/json' };
+        init.headers['Content-Type'] = 'application/json';
         init.body = JSON.stringify(body);
       }
       const res = await fetch(base + path, init);

package/src/pages/feedback-overlay.ts

@@ -415,7 +415,7 @@ const FEEDBACK_OVERLAY_JS = `
     return fetch('/@swarm/api/pages/' + encodeURIComponent(pageId) + '/feedback', {
       method: 'POST',
       credentials: 'same-origin',
-      headers: { 'Content-Type': 'application/json' },
+      headers: { 'Content-Type': 'application/json', 'X-Swarm-Page-Id': pageId },
       body: JSON.stringify(payload),
     }).then(function (res) {
       return res.text().then(function (text) {

package/src/providers/acp-targets.ts

@@ -359,7 +359,7 @@ const copilotTargetProfile: AcpTargetProfile = {
   },
 };
 
-/** Qwen Code's `--auth-type` choices (0.25.3). `qwen-oauth` needs a browser, so it is left out. */
+/** Qwen Code's `--auth-type` choices (0.26.0). `qwen-oauth` needs a browser, so it is left out. */
 const QWEN_AUTH_TYPES = ["openai", "openai-responses", "anthropic", "gemini", "vertex-ai"] as const;
 
 // Qwen Code is a Gemini CLI fork: QWEN_SYSTEM_MD replaces its built-in prompt

package/src/providers/amp-adapter.ts

@@ -44,7 +44,7 @@ import type {
  * default; the image installs exactly this version and the per-task settings
  * set `amp.updates.mode: "disabled"`. Bump it deliberately, with a live run.
  */
-export const AMP_PACKAGE = "@ampcode/cli@0.0.1792506219-g025e7e";
+export const AMP_PACKAGE = "@ampcode/cli@0.0.1792670445-ge8d5b3";
 
 /** MCP server name. Amp exposes its tools as `agent_swarm` / `store_progress` (dashes become underscores). */
 const AMP_MCP_SERVER_NAME = "agent-swarm";