@desplega.ai/agent-swarm 2.4.3 → 2.4.5

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,40 @@ 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 }>;
 }
 
 async function postChunks(
@@ -62,10 +99,186 @@ async function postChunks(
   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 +293,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 +303,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-adapter.ts

@@ -1,15 +1,21 @@
+// `/unstable` keeps the full ACP v1 surface the 1.x default import carried:
+// turn `usage` on the prompt response is unstable, and the stable entrypoint
+// does not type it. Both entrypoints speak ACP v1 on the wire.
 import {
-  type Client,
-  ClientSideConnection,
+  client as acpClient,
+  type ClientContext,
   type McpServer,
+  methods,
   ndJsonStream,
   PROTOCOL_VERSION,
   type RequestPermissionRequest,
   type RequestPermissionResponse,
   type SessionConfigOption,
   type SessionNotification,
+  type SetSessionConfigOptionRequest,
+  type SetSessionConfigOptionResponse,
   type Usage,
-} from "@agentclientprotocol/sdk";
+} from "@agentclientprotocol/sdk/unstable";
 import pkg from "../../package.json";
 import type { AcpSessionConfigOption } from "../types";
 import { mintAcpSessionToken, revokeAcpSessionToken } from "../utils/acp-session-token";
@@ -154,7 +160,7 @@ function boundedAcpLogScalar(value: unknown): unknown {
   return typeof value === "string" ? value.slice(0, 500) : value;
 }
 
-class SwarmAcpClient implements Client {
+class SwarmAcpClient {
   /** Latest cumulative USD cost the target reported for the session. */
   reportedCostUsd: number | null = null;
 
@@ -199,7 +205,7 @@ class ACPSession implements ProviderSession {
   private ephemeralTokenId: string | null = null;
 
   constructor(
-    private readonly connection: ClientSideConnection,
+    private readonly agent: ClientContext,
     private readonly client: SwarmAcpClient,
     private readonly process: Bun.Subprocess<"pipe", "pipe", "pipe">,
     private readonly config: ProviderSessionConfig,
@@ -234,7 +240,7 @@ class ACPSession implements ProviderSession {
     if (this.aborted) return;
     this.aborted = true;
     try {
-      await this.connection.cancel({ sessionId: this.sessionId });
+      await this.agent.notify(methods.agent.session.cancel, { sessionId: this.sessionId });
       await Promise.race([this.completionPromise, Bun.sleep(ACP_CANCEL_SETTLE_MS)]);
     } catch (err) {
       this.emit({
@@ -282,7 +288,7 @@ class ACPSession implements ProviderSession {
   private async runPrompt(): Promise<void> {
     let result: ProviderResult;
     try {
-      const response = await this.connection.prompt({
+      const response = await this.agent.request(methods.agent.session.prompt, {
         sessionId: this.sessionId,
         prompt: [{ type: "text", text: this.config.prompt }],
       });
@@ -441,11 +447,16 @@ export class ACPAdapter implements ProviderAdapter {
       else preSessionEvents.push(event);
     }, target);
     const stream = ndJsonStream(fileSinkWritableStream(proc.stdin), proc.stdout);
-    const connection = new ClientSideConnection(() => client, stream);
+    const agent = acpClient()
+      .onRequest(methods.client.session.requestPermission, ({ params }) =>
+        client.requestPermission(params),
+      )
+      .onNotification(methods.client.session.update, ({ params }) => client.sessionUpdate(params))
+      .connect(stream).agent;
 
     let ephemeralToken: { tokenId: string; plaintext: string } | null = null;
     try {
-      await connection.initialize({
+      await agent.request(methods.agent.initialize, {
         protocolVersion: PROTOCOL_VERSION,
         clientInfo: { name: "agent-swarm", version: pkg.version },
         clientCapabilities: { session: { configOptions: { boolean: {} } } },
@@ -473,7 +484,7 @@ export class ACPAdapter implements ProviderAdapter {
       // shape for an ACP agent with no network route to the swarm API. Gated on
       // `mcpCapabilities.acp` and UNSTABLE; not adopted here.
       const sessionMeta = target.sessionMeta?.(config);
-      const newSession = await connection.newSession({
+      const newSession = await agent.request(methods.agent.session.new, {
         ...(sessionMeta ? { _meta: sessionMeta } : {}),
         cwd: config.cwd,
         mcpServers: [
@@ -491,13 +502,16 @@ export class ACPAdapter implements ProviderAdapter {
         ],
       });
       const configOptions = await applyConfiguredOptions(
-        connection,
+        {
+          setSessionConfigOption: (params) =>
+            agent.request(methods.agent.session.setConfigOption, params),
+        },
         newSession.sessionId,
         newSession.configOptions ?? [],
         target.configuredOptions(config),
       );
       session = new ACPSession(
-        connection,
+        agent,
         client,
         proc,
         config,
@@ -537,8 +551,14 @@ export class ACPAdapter implements ProviderAdapter {
   }
 }
 
+export interface AcpConfigOptionSetter {
+  setSessionConfigOption(
+    params: SetSessionConfigOptionRequest,
+  ): Promise<SetSessionConfigOptionResponse>;
+}
+
 export async function applyConfiguredOptions(
-  connection: Pick<ClientSideConnection, "setSessionConfigOption">,
+  connection: AcpConfigOptionSetter,
   sessionId: string,
   advertised: SessionConfigOption[],
   configured: Record<string, string | boolean>,

package/src/providers/acp-swarm-events.ts

@@ -3,7 +3,7 @@ import type {
   SessionNotification,
   SessionUpdate,
   ToolCallUpdate,
-} from "@agentclientprotocol/sdk";
+} from "@agentclientprotocol/sdk/unstable";
 import type { ProviderEvent } from "./types";
 
 function contentToText(content: ContentBlock): string {

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.1792470027-g8c393d";
+export const AMP_PACKAGE = "@ampcode/cli@0.0.1792584044-g15483c";
 
 /** MCP server name. Amp exposes its tools as `agent_swarm` / `store_progress` (dashes become underscores). */
 const AMP_MCP_SERVER_NAME = "agent-swarm";