@desplega.ai/agent-swarm 2.4.4 → 2.4.5

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/apps-card-grid.test.ts

@@ -0,0 +1,197 @@
+import { describe, expect, test } from "bun:test";
+import { parseAppDefinition } from "../apps/definition";
+
+/**
+ * Validator coverage for `CardGrid` and the Table column `format` template.
+ * Pure `parseAppDefinition` calls — no DB, no HTTP — mirroring
+ * `apps-catalog-additions.test.ts`.
+ */
+
+type Element = { type: string; props?: Record<string, unknown>; children?: string[] };
+
+function appWith(elements: Record<string, Element>) {
+  return {
+    models: {
+      doc: {
+        columns: {
+          title: { kind: "string", required: true },
+          author: { kind: "string" },
+          cover: { kind: "string" },
+          status: { kind: "enum", enum: ["draft", "published"], default: "draft" },
+        },
+      },
+    },
+    queries: {
+      docs: { model: "doc" },
+      docById: { model: "doc", filter: { id: { $param: "doc" } } },
+    },
+    pages: {
+      main: { title: "Main", root: "root", elements },
+      detail: {
+        title: "Detail",
+        params: { doc: { kind: "string" }, position: { kind: "number" } },
+        root: "detailRoot",
+        elements: { detailRoot: { type: "Text", props: { content: "Detail" } } },
+      },
+    },
+    defaultPage: "main",
+  };
+}
+
+async function issuesFor(input: unknown) {
+  const parsed = await parseAppDefinition(input);
+  return parsed.success ? [] : parsed.issues;
+}
+
+const el = (id: string) => `pages.main.elements.${id}`;
+
+function cardGrid(props: Record<string, unknown>) {
+  return appWith({
+    root: { type: "Stack", props: {}, children: ["cards"] },
+    cards: {
+      type: "CardGrid",
+      props: {
+        data: { $state: "/queries/docs/data" },
+        loading: { $state: "/queries/docs/loading" },
+        error: { $state: "/queries/docs/error" },
+        titleKey: "title",
+        ...props,
+      },
+    },
+  });
+}
+
+const navigateToDetail = [
+  { action: "app.navigate", params: { page: "detail", params: { doc: { $row: "id" } } } },
+];
+
+describe("CardGrid", () => {
+  test("onClick running app.navigate to a declared page with $row params passes", async () => {
+    const issues = await issuesFor(
+      cardGrid({
+        imageKey: "cover",
+        fields: [
+          { key: "author" },
+          { key: "createdAt", kind: "date" },
+          { key: "status", kind: "badge", tones: { published: "success" } },
+        ],
+        columns: { base: 1, md: 2, lg: 4 },
+        emptyMessage: "No documents yet",
+        onClick: navigateToDetail,
+      }),
+    );
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("$row and $rowIndex are accepted inside the onClick chain", async () => {
+    const issues = await issuesFor(
+      cardGrid({
+        onClick: [
+          { action: "app.refresh", params: { query: "docs" } },
+          {
+            action: "app.navigate",
+            params: {
+              page: "detail",
+              params: { doc: { $row: "id" }, position: { $rowIndex: true } },
+            },
+          },
+        ],
+      }),
+    );
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("$row outside the onClick chain is rejected", async () => {
+    const issues = await issuesFor(cardGrid({ emptyMessage: { $row: "title" } }));
+    expect(issues).toContainEqual({
+      path: `${el("cards")}.props.emptyMessage`,
+      message: "$row, $rowIndex, $form, and $chain bindings are only allowed in action params",
+    });
+  });
+
+  test("onClick naming an unknown action fails", async () => {
+    const issues = await issuesFor(cardGrid({ onClick: [{ action: "app.nope", params: {} }] }));
+    expect(issues).toContainEqual({
+      path: `${el("cards")}.props.onClick.0.action`,
+      message: 'unknown action type "app.nope"',
+    });
+  });
+
+  test("onClick navigating to an undeclared page fails", async () => {
+    const issues = await issuesFor(
+      cardGrid({ onClick: [{ action: "app.navigate", params: { page: "nope" } }] }),
+    );
+    expect(issues).toContainEqual({
+      path: `${el("cards")}.props.onClick.0.params.page`,
+      message: 'unknown page "nope"',
+    });
+  });
+
+  test("titleKey is required", async () => {
+    const copy = cardGrid({});
+    delete copy.pages.main.elements.cards!.props!.titleKey;
+    const issues = await issuesFor(copy);
+    expect(issues.some((i) => i.path.startsWith(`${el("cards")}.props`))).toBe(true);
+  });
+
+  test("data bound to a $state path passes", async () => {
+    const issues = await issuesFor(
+      appWith({
+        root: { type: "Stack", props: {}, children: ["cards"] },
+        cards: {
+          type: "CardGrid",
+          props: { data: { $state: "/queries/docs/data" }, titleKey: "title" },
+        },
+      }),
+    );
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("an unknown field kind is rejected", async () => {
+    const issues = await issuesFor(cardGrid({ fields: [{ key: "author", kind: "status" }] }));
+    expect(issues.some((i) => i.path.startsWith(`${el("cards")}.props.fields.0.kind`))).toBe(true);
+  });
+});
+
+describe("Table column format", () => {
+  test("a column with a {{field}} format template passes", async () => {
+    const issues = await issuesFor(
+      appWith({
+        root: { type: "Stack", props: {}, children: ["table"] },
+        table: {
+          type: "Table",
+          props: {
+            data: { $state: "/queries/docs/data" },
+            columns: [
+              { key: "title", label: "Document", format: "{{title}} ({{status}})" },
+              { key: "author" },
+            ],
+          },
+        },
+      }),
+    );
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("format must be a string", async () => {
+    const issues = await issuesFor(
+      appWith({
+        root: { type: "Stack", props: {}, children: ["table"] },
+        table: {
+          type: "Table",
+          props: {
+            data: { $state: "/queries/docs/data" },
+            columns: [{ key: "title", format: 42 }],
+          },
+        },
+      }),
+    );
+    expect(issues.some((i) => i.path.startsWith(`${el("table")}.props.columns.0.format`))).toBe(
+      true,
+    );
+  });
+});

package/src/tests/apps-catalog-additions.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, test } from "bun:test";
+import { parseAppDefinition } from "../apps/definition";
+
+/**
+ * Validator coverage for the small catalog additions: `NumberInput`, Select
+ * `defaultValue`, and `fill` on Stack / Split. Pure `parseAppDefinition`
+ * calls — no DB, no HTTP — mirroring `apps-catalog-inputs.test.ts`.
+ */
+
+type Element = { type: string; props?: Record<string, unknown>; children?: string[] };
+
+function appWith(elements: Record<string, Element>) {
+  return {
+    models: {},
+    pages: { main: { title: "Main", root: "root", elements } },
+    defaultPage: "main",
+  };
+}
+
+async function issuesFor(input: unknown) {
+  const parsed = await parseAppDefinition(input);
+  return parsed.success ? [] : parsed.issues;
+}
+
+const el = (id: string) => `pages.main.elements.${id}`;
+
+describe("NumberInput", () => {
+  test("a NumberInput's /ui/<id>/value read by a bound Text validates", async () => {
+    const issues = await issuesFor(
+      appWith({
+        root: { type: "Stack", props: {}, children: ["width", "echo"] },
+        width: {
+          type: "NumberInput",
+          props: { id: "x", label: "Width", placeholder: "px", min: 1, max: 4096 },
+        },
+        echo: { type: "Text", props: { content: { $state: "/ui/x/value" } } },
+      }),
+    );
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("a /ui/<id>/value read with no UI control of that id is rejected", async () => {
+    const issues = await issuesFor(
+      appWith({
+        root: { type: "Stack", props: {}, children: ["echo"] },
+        echo: { type: "Text", props: { content: { $state: "/ui/x/value" } } },
+      }),
+    );
+    expect(issues).toContainEqual({
+      path: `${el("echo")}.props.content`,
+      message: 'state reference targets unknown UI control "x"',
+    });
+  });
+
+  test("id is required and min/max must be numbers", async () => {
+    const missingId = await issuesFor(
+      appWith({
+        root: { type: "Stack", props: {}, children: ["width"] },
+        width: { type: "NumberInput", props: { label: "Width" } },
+      }),
+    );
+    expect(missingId.map((issue) => issue.path)).toContain(`${el("width")}.props.id`);
+
+    const badBounds = await issuesFor(
+      appWith({
+        root: { type: "Stack", props: {}, children: ["width"] },
+        width: { type: "NumberInput", props: { id: "x", min: "1", max: "10" } },
+      }),
+    );
+    const paths = badBounds.map((issue) => issue.path);
+    expect(paths).toContain(`${el("width")}.props.min`);
+    expect(paths).toContain(`${el("width")}.props.max`);
+  });
+});
+
+describe("Select defaultValue", () => {
+  const select = (props: Record<string, unknown>) =>
+    appWith({
+      root: { type: "Stack", props: {}, children: ["device", "echo"] },
+      device: {
+        type: "Select",
+        props: { id: "device", options: ["phone", "tablet", "desktop"], ...props },
+      },
+      echo: { type: "Text", props: { content: { $state: "/ui/device/value" } } },
+    });
+
+  test("a Select with defaultValue validates", async () => {
+    const issues = await issuesFor(select({ defaultValue: "tablet" }));
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("defaultValue must be a string", async () => {
+    const paths = (await issuesFor(select({ defaultValue: 2 }))).map((issue) => issue.path);
+    expect(paths).toContain(`${el("device")}.props.defaultValue`);
+  });
+});
+
+describe("Stack and Split fill", () => {
+  const layout = (stackFill: unknown, splitFill: unknown) =>
+    appWith({
+      root: { type: "Stack", props: { fill: stackFill }, children: ["split"] },
+      split: { type: "Split", props: { fill: splitFill, ratio: "1-1" }, children: ["a", "b"] },
+      a: { type: "Text", props: { content: "left" } },
+      b: { type: "Text", props: { content: "right" } },
+    });
+
+  test("fill: true validates on both", async () => {
+    const issues = await issuesFor(layout(true, true));
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("fill must be a boolean", async () => {
+    const paths = (await issuesFor(layout("yes", 1))).map((issue) => issue.path);
+    expect(paths).toContain(`${el("root")}.props.fill`);
+    expect(paths).toContain(`${el("split")}.props.fill`);
+  });
+});