@desplega.ai/agent-swarm 2.4.3 → 2.4.5

package/src/scripts-runtime/types/swarm-extension.d.ts

@@ -67,6 +67,7 @@ declare module "swarm-extension" {
     sourceTaskId?: string | undefined;
     outputSchema?: Record<string, unknown> | undefined;
     inheritParentOutputSchema?: boolean | undefined;
+    inheritParentRequester?: boolean | undefined;
     inheritParentRoutingAffinity?: boolean | undefined;
     inheritParentFollowUpConfig?: boolean | undefined;
     followUpConfig?:
@@ -485,8 +486,15 @@ declare module "swarm-extension" {
     userName?: string;
     /** The buffered messages, joined. */
     text: string;
+    /** True for an @mention and for a reply to one of the bot's messages. */
     botMentioned: boolean;
     isDirectMessage: boolean;
+    /** Platform chat type, such as Telegram `private`, `group`, `supergroup` or `channel`. */
+    chatType?: string;
+    /** Set for a Telegram supergroup with topics. */
+    isForum?: boolean;
+    /** A buffered message replies to one of the bot's own messages. */
+    replyToBot: boolean;
     /** Set when earlier swarm tasks exist in this thread. */
     threadContext?: {
       adapter: string;

package/src/scripts-runtime/types/swarm-sdk.d.ts

@@ -35,6 +35,8 @@ declare module "swarm-sdk" {
     routingNote?: string;
     tags?: string[];
     priority?: number;
+    /** Task IDs that must complete before this task starts. */
+    dependsOn?: string[];
     offerMode?: boolean;
     dir?: string;
     vcsRepo?: string;

package/src/server-user.ts

@@ -4,6 +4,7 @@ import * as z from "zod";
 import pkg from "../package.json";
 import { enqueueAdmissionRow } from "./be/rbac-audit";
 import { getUserGrant } from "./be/rbac-roles";
+import { MCP_MAX_TOOL_INPUT_ELEMENTS } from "./mcp-limits";
 import {
   type AdmissionRbac,
   decideToolAdmission,
@@ -107,6 +108,7 @@ export function createUserServer(user: User): McpServer {
       capabilities: {
         logging: {},
       },
+      maxToolInputElements: MCP_MAX_TOOL_INPUT_ELEMENTS,
     },
   );
 

package/src/server.ts

@@ -7,6 +7,7 @@ import { isSteeringEnabled } from "./be/steering";
 import { registerGithubTaskReactions } from "./github/task-reactions";
 import { loadGlobalConfigsIntoEnv } from "./http/core";
 import { isChatSdkEnabled } from "./integrations/chat-sdk/config";
+import { MCP_MAX_TOOL_INPUT_ELEMENTS } from "./mcp-limits";
 import { resolveTemplate } from "./prompts/resolver";
 import { isRbacEnabled } from "./rbac";
 import { getSlackConfiguration } from "./slack/config";
@@ -450,6 +451,7 @@ export async function createServer(
       capabilities: {
         logging: {},
       },
+      maxToolInputElements: MCP_MAX_TOOL_INPUT_ELEMENTS,
     },
   );
 

package/src/slack/assistant.ts

@@ -204,13 +204,13 @@ export function createAssistant(): Assistant {
         // Fetch shared files before the task text is final: a file that can't be
         // downloaded is flagged in it.
         if (files?.length) await safeSetStatus("Downloading attachments...");
-        await using inbound = await fetchSlackFiles(client, files);
+        await using inbound = await fetchSlackFiles(client, files, { transcribe: true });
         // Any in-body `<@U…>` mention the requester typed is rewritten via
         // the identity primitive before it reaches agent-visible task text —
         // never a raw Slack ID. Bot-mention routing checks above use the
         // raw `messageText`, not this rendered copy.
         const renderedMessageText = await rewriteSlackMentions(
-          buildEffectiveText(messageText, inbound.files, inbound.failed),
+          buildEffectiveText(messageText, inbound.files, inbound.failed, inbound.notes),
           cachedBotUserId ?? undefined,
         );
 

package/src/slack/files.ts

@@ -22,6 +22,8 @@ export interface SlackFile {
   title?: string;
   mimetype: string;
   filetype: string;
+  /** `slack_audio` on a voice clip recorded in Slack. */
+  subtype?: string;
   size: number;
   url_private: string;
   url_private_download: string;

package/src/slack/handlers.ts

@@ -702,8 +702,8 @@ export function registerMessageHandler(app: App): void {
         return ignoreSlackInbound("rate_limited");
       }
 
-      await using inbound = await fetchSlackFiles(client, msg.files);
-      const taskText = buildEffectiveText(msg.text, inbound.files, inbound.failed);
+      await using inbound = await fetchSlackFiles(client, msg.files, { transcribe: true });
+      const taskText = buildEffectiveText(msg.text, inbound.files, inbound.failed, inbound.notes);
       const taskDescription = isImplicitMention
         ? taskText
         : extractTaskFromMessage(taskText, botUserId);
@@ -778,9 +778,9 @@ export function registerMessageHandler(app: App): void {
     }
 
     // Extract task description (the text plus a `[File: …]` line per attachment)
-    await using inbound = await fetchSlackFiles(client, msg.files);
+    await using inbound = await fetchSlackFiles(client, msg.files, { transcribe: true });
     const taskDescription = extractTaskFromMessage(
-      buildEffectiveText(msg.text, inbound.files, inbound.failed),
+      buildEffectiveText(msg.text, inbound.files, inbound.failed, inbound.notes),
       botUserId,
     );
     if (!taskDescription) {

package/src/slack/inbound-files.ts

@@ -13,6 +13,8 @@
  * could not be attached — never dropped silently. A download failure is
  * also flagged on that line; a storage failure happens after the text is
  * written, so it shows up only in the reply and in the missing attachment.
+ * Audio files (voice clips) a user shares get their transcript on the next
+ * line when transcription is configured, and keep the audio attached.
  */
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
@@ -27,6 +29,7 @@ import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
 import type { AgentTask, CreateTaskOptions, TaskAttachment } from "../types";
 import { scrubSecrets } from "../utils/secret-scrubber";
 import { taskAttachmentFetchCommand } from "../utils/task-attachment-links";
+import { transcribeAudioNotes } from "../utils/transcription";
 import { getFileInfo, type SlackFile } from "./files";
 import { noteSlackInboundSideEffect } from "./inbound-dispatch";
 // Side-effect import: registers all Slack event templates in the in-memory registry
@@ -73,6 +76,8 @@ export type InboundSlackFiles = {
   files: SlackFile[];
   fetched: FetchedSlackFile[];
   failed: SlackFileFailure[];
+  /** Task-text note per audio file id (a transcript), filled when fetched with `transcribe`. */
+  notes?: Map<string, string>;
   /** Deletes the downloaded copies; hold the batch with `await using`. */
   [Symbol.asyncDispose](): Promise<void>;
 };
@@ -96,9 +101,14 @@ export function formatFileSize(bytes: number): string {
  * Build a text representation of file attachments for inclusion in messages.
  * Each file is formatted as: [File: filename.ext (mimetype, size) id=FILE_ID],
  * followed by `(not attached: <reason>)` when the file never made it into the
- * task's attachments.
+ * task's attachments, and by the file's note (a voice-clip transcript) on the
+ * next line.
  */
-export function buildAttachmentText(files: SlackFile[], failed: SlackFileFailure[] = []): string {
+export function buildAttachmentText(
+  files: SlackFile[],
+  failed: SlackFileFailure[] = [],
+  notes: Map<string, string> = new Map(),
+): string {
   const reasons = new Map(failed.map((f) => [f.file.id, f.reason]));
   return files
     .map((f) => {
@@ -106,7 +116,8 @@ export function buildAttachmentText(files: SlackFile[], failed: SlackFileFailure
       const size = typeof f.size === "number" ? formatFileSize(f.size) : "unknown size";
       const line = `[File: ${f.name ?? f.id} (${f.mimetype ?? "unknown type"}, ${size}) id=${f.id}]`;
       const reason = reasons.get(f.id);
-      return reason ? `${line} (not attached: ${reason})` : line;
+      const note = notes.get(f.id);
+      return [reason ? `${line} (not attached: ${reason})` : line, note].filter(Boolean).join("\n");
     })
     .join("\n");
 }
@@ -121,15 +132,16 @@ export function buildEffectiveText(
   text: string | undefined,
   files?: SlackFile[],
   failed?: SlackFileFailure[],
+  notes?: Map<string, string>,
 ): string {
   const hasText = !!text?.trim();
   const hasFiles = files && files.length > 0;
 
   if (hasText && hasFiles) {
-    return `${text}\n\n${buildAttachmentText(files, failed)}`;
+    return `${text}\n\n${buildAttachmentText(files, failed, notes)}`;
   }
   if (hasFiles) {
-    return buildAttachmentText(files, failed);
+    return buildAttachmentText(files, failed, notes);
   }
   return text || "";
 }
@@ -147,11 +159,14 @@ export function bufferedFileFailures(files: SlackFile[] | undefined): SlackFileF
  * Download every file on a Slack message with the bot token, each to its own
  * temp file. Never throws: a file that can't be fetched lands in `failed` with
  * a reason the user and the agent can read. Hold the result with `await using`
- * so the temp files go away with it.
+ * so the temp files go away with it. With `transcribe`, every downloaded audio
+ * file also gets a `notes` entry: its transcript, the failure, or a line saying
+ * no provider is configured.
  */
 export async function fetchSlackFiles(
   client: WebClient,
   files: SlackFile[] | undefined,
+  options: { transcribe?: boolean } = {},
 ): Promise<InboundSlackFiles> {
   let dir: string | undefined;
   const result: InboundSlackFiles = {
@@ -182,9 +197,27 @@ export async function fetchSlackFiles(
       result.fetched.push({ file, ...outcome });
     }
   }
+  if (options.transcribe) {
+    result.notes = await transcribeAudioNotes(
+      result.fetched
+        .filter(({ file }) => isSlackAudio(file))
+        .map(({ file, path }) => ({
+          key: file.id,
+          name: file.name ?? file.id,
+          data: Bun.file(path),
+          mimeType: file.mimetype,
+        })),
+      "[Slack]",
+    );
+  }
   return result;
 }
 
+/** An audio file, or a voice clip recorded in Slack (its MIME type can read `video/…`). */
+function isSlackAudio(file: SlackFile): boolean {
+  return file.subtype === "slack_audio" || Boolean(file.mimetype?.startsWith("audio/"));
+}
+
 /** Does the start of an HTML response read like Slack's sign-in page? */
 function looksLikeSignIn(head: Uint8Array[]): boolean {
   const joined = new Uint8Array(head.reduce((total, part) => total + part.byteLength, 0));

package/src/slack/thread-buffer.ts

@@ -177,7 +177,7 @@ async function slackFlush(
   const app = getSlackApp();
   const files = items.flatMap((item) => item.files ?? []);
   await using inbound = app
-    ? await fetchSlackFiles(app.client, files)
+    ? await fetchSlackFiles(app.client, files, { transcribe: true })
     : {
         files,
         fetched: [],
@@ -196,6 +196,7 @@ async function slackFlush(
           item.text,
           item.files?.map((file) => resolvedFiles.get(file.id) ?? file),
           inbound.failed,
+          inbound.notes,
         ),
       )
       .join("\n---\n"),

package/src/tasks/task-terminal-effects.ts

@@ -16,7 +16,7 @@
  */
 
 import { getSessionLogsByTaskId } from "@/be/db";
-import { getEmbeddingProvider, getMemoryStore } from "@/be/memory";
+import { indexMemoryContent, taskCompletionMemoryKey } from "@/be/memory/index-content";
 import { getRetrievalsForTask } from "@/be/memory/raters/retrieval";
 import { runServerRaters } from "@/be/memory/raters/run-server-raters";
 import { shouldPersistTaskCompletionMemory } from "@/memory/automatic-task-gate";
@@ -55,21 +55,22 @@ export async function runTaskTerminalEffects(args: {
         // Skip indexing if there's truly no content
         if (taskContent.length < 30) return;
 
-        const store = getMemoryStore();
-        const provider = getEmbeddingProvider();
-
-        const memory = await store.store({
+        // Same path as memory-store: chunk, store, and embed each chunk, so a
+        // long output never meets the embedding model's input cap. The per-task
+        // key makes the chunks one document, like a keyed manual memory, and a
+        // repeat write for the task replaces that document atomically.
+        const key = taskCompletionMemoryKey(taskId);
+        await indexMemoryContent({
           agentId: agentId ?? null,
           content: taskContent,
           name: `Task: ${safeTask.slice(0, 80)}`,
           scope: "agent",
           source: "task_completion",
           sourceTaskId: taskId,
+          key,
+          intent: "task completion memory",
+          replaceExisting: true,
         });
-        const embedding = await provider.embed(taskContent);
-        if (embedding) {
-          await store.updateEmbedding(memory.id, embedding, provider.name);
-        }
 
         // Auto-promote high-value completions to swarm memory (P3)
         const shouldShareWithSwarm =
@@ -80,24 +81,27 @@ export async function runTaskTerminalEffects(args: {
 
         if (shouldShareWithSwarm) {
           try {
-            const swarmMemory = await store.store({
+            await indexMemoryContent({
               agentId: agentId ?? null,
-              scope: "swarm",
-              name: `Shared: ${safeTask.slice(0, 80)}`,
               content: `Task completed by agent ${agentId}:\n\n${taskContent}`,
+              name: `Shared: ${safeTask.slice(0, 80)}`,
+              scope: "swarm",
               source: "task_completion",
               sourceTaskId: taskId,
+              key,
+              intent: "task completion memory",
+              replaceExisting: true,
             });
-            const swarmEmbedding = await provider.embed(taskContent);
-            if (swarmEmbedding) {
-              await store.updateEmbedding(swarmMemory.id, swarmEmbedding, provider.name);
-            }
           } catch {
             // Non-blocking — swarm memory promotion failure is not critical
           }
         }
-      } catch {
+      } catch (err) {
         // Non-blocking — task completion memory failure should not affect task status
+        console.error(
+          "[task-terminal-effects] task completion memory write failed:",
+          scrubSecrets(err instanceof Error ? err.message : String(err)),
+        );
       }
     })().catch((err) =>
       console.error(

package/src/tests/acp-adapter.test.ts

@@ -3,7 +3,7 @@ import { chmodSync, existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
 import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { Usage } from "@agentclientprotocol/sdk";
+import type { Usage } from "@agentclientprotocol/sdk/unstable";
 import { normalizeSessionLogs } from "../../apps/ui/src/logs-parser";
 import {
   closeDb,
@@ -29,6 +29,7 @@ import {
   resolveAcpTarget,
 } from "../providers/acp-targets";
 import type { ProviderEvent, ProviderSessionConfig } from "../providers/types";
+import { ACP_SDK_PATH, serveFakeAcpAgent } from "./acp-fake-agent";
 import { listenOnFreePort } from "./test-net";
 
 const tmpDirs: string[] = [];
@@ -148,16 +149,11 @@ describe("ACPAdapter", () => {
   }) => {
     const cwd = makeTempDir();
     const agentPath = join(cwd, "fake-acp-agent.ts");
-    const sdkPath = join(process.cwd(), "node_modules/@agentclientprotocol/sdk/dist/acp.js");
     await Bun.write(
       agentPath,
       `
 import { Readable, Writable } from "node:stream";
-import {
-  AgentSideConnection,
-  PROTOCOL_VERSION,
-  ndJsonStream,
-} from "${sdkPath}";
+import { PROTOCOL_VERSION, agent, methods, ndJsonStream } from "${ACP_SDK_PATH}";
 
 class FakeAgent {
   constructor(connection) {
@@ -313,10 +309,7 @@ class FakeAgent {
   async cancel() {}
 }
 
-const input = Writable.toWeb(process.stdout);
-const output = Readable.toWeb(process.stdin);
-const stream = ndJsonStream(input, output);
-new AgentSideConnection((connection) => new FakeAgent(connection), stream);
+${serveFakeAcpAgent("FakeAgent")}
 `,
     );
 
@@ -952,7 +945,6 @@ new AgentSideConnection((connection) => new FakeAgent(connection), stream);
     const binDir = makeTempDir();
     const captureFile = join(binDir, "capture.json");
     const agentPath = join(binDir, "fake-copilot-acp.ts");
-    const sdkPath = join(process.cwd(), "node_modules/@agentclientprotocol/sdk/dist/acp.js");
     const repoAgentsMd = "# Repo rules\nKeep this file as is.\n";
     await Bun.write(join(cwd, "AGENTS.md"), repoAgentsMd);
     await Bun.write(
@@ -961,7 +953,7 @@ new AgentSideConnection((connection) => new FakeAgent(connection), stream);
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { Readable, Writable } from "node:stream";
-import { AgentSideConnection, PROTOCOL_VERSION, ndJsonStream } from "${sdkPath}";
+import { PROTOCOL_VERSION, agent, methods, ndJsonStream } from "${ACP_SDK_PATH}";
 class FakeCopilot {
   constructor(connection) { this.connection = connection; }
   async initialize() {
@@ -986,8 +978,7 @@ class FakeCopilot {
   }
   async cancel() {}
 }
-const stream = ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
-new AgentSideConnection((connection) => new FakeCopilot(connection), stream);
+${serveFakeAcpAgent("FakeCopilot")}
 `,
     );
     const copilotStub = join(binDir, "copilot");
@@ -1191,7 +1182,6 @@ new AgentSideConnection((connection) => new FakeCopilot(connection), stream);
   test("completes before the revoke response and logs a failed revocation", async () => {
     const cwd = makeTempDir();
     const agentPath = join(cwd, "fake-acp-ephem-agent.ts");
-    const sdkPath = join(process.cwd(), "node_modules/@agentclientprotocol/sdk/dist/acp.js");
 
     const captureFile = join(cwd, "captured-auth.txt");
 
@@ -1199,7 +1189,7 @@ new AgentSideConnection((connection) => new FakeCopilot(connection), stream);
       agentPath,
       `
 import { Readable, Writable } from "node:stream";
-import { AgentSideConnection, PROTOCOL_VERSION, ndJsonStream } from "${sdkPath}";
+import { PROTOCOL_VERSION, agent, methods, ndJsonStream } from "${ACP_SDK_PATH}";
 class FakeAgent {
   constructor(connection) { this.connection = connection; }
   async initialize() {
@@ -1223,8 +1213,7 @@ class FakeAgent {
   }
   async cancel() {}
 }
-const stream = ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
-new AgentSideConnection((connection) => new FakeAgent(connection), stream);
+${serveFakeAcpAgent("FakeAgent")}
 `,
     );
 
@@ -1361,12 +1350,11 @@ new AgentSideConnection((connection) => new FakeAgent(connection), stream);
   ])("$name", async ({ costs, totalCostUsd, costSource }) => {
     const cwd = makeTempDir();
     const agentPath = join(cwd, "fake-acp-cost-agent.ts");
-    const sdkPath = join(process.cwd(), "node_modules/@agentclientprotocol/sdk/dist/acp.js");
     await Bun.write(
       agentPath,
       `
 import { Readable, Writable } from "node:stream";
-import { AgentSideConnection, PROTOCOL_VERSION, ndJsonStream } from "${sdkPath}";
+import { PROTOCOL_VERSION, agent, methods, ndJsonStream } from "${ACP_SDK_PATH}";
 class FakeAgent {
   constructor(connection) { this.connection = connection; }
   async initialize() {
@@ -1384,8 +1372,7 @@ class FakeAgent {
   }
   async cancel() {}
 }
-const stream = ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
-new AgentSideConnection((connection) => new FakeAgent(connection), stream);
+${serveFakeAcpAgent("FakeAgent")}
 `,
     );
     const { close: closeTokenStub, apiUrl } = await startTokenStubServer(

package/src/tests/acp-fake-agent.ts

@@ -0,0 +1,36 @@
+import { join } from "node:path";
+
+// Fake ACP targets run from temp dirs, so they import the SDK by path. The
+// unstable v1 entry point lets them return turn `usage` like OpenCode does.
+export const ACP_SDK_PATH = join(
+  process.cwd(),
+  "node_modules/@agentclientprotocol/sdk/dist/v1/unstable/acp.js",
+);
+
+/**
+ * Script tail that serves a fake agent class over stdio with the SDK's agent
+ * app API. The class implements the ACP agent methods and gets
+ * `{ sessionUpdate }` to notify the client. The script must import `agent`,
+ * `methods`, and `ndJsonStream` from ACP_SDK_PATH, and `Readable`/`Writable`
+ * from node:stream.
+ */
+export function serveFakeAcpAgent(className: string): string {
+  return `
+const fake = new ${className}({
+  sessionUpdate: (params) => connection.client.notify(methods.client.session.update, params),
+});
+const app = agent()
+  .onRequest(methods.agent.initialize, ({ params }) => fake.initialize(params))
+  .onRequest(methods.agent.session.new, ({ params }) => fake.newSession(params))
+  .onRequest(methods.agent.session.prompt, ({ params }) => fake.prompt(params))
+  .onNotification(methods.agent.session.cancel, ({ params }) => fake.cancel(params));
+if (fake.setSessionConfigOption) {
+  app.onRequest(methods.agent.session.setConfigOption, ({ params }) =>
+    fake.setSessionConfigOption(params),
+  );
+}
+const connection = app.connect(
+  ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin)),
+);
+`;
+}

package/src/tests/acp-swarm-events.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import type { SessionNotification } from "@agentclientprotocol/sdk";
+import type { SessionNotification } from "@agentclientprotocol/sdk/unstable";
 import { acpReportedCostUsd, translateAcpSessionNotification } from "../providers/acp-swarm-events";
 
 function notification(update: SessionNotification["update"]): SessionNotification {