@desplega.ai/agent-swarm 1.83.2 → 1.84.1

package/src/tests/agents-list-model-display.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "bun:test";
+import { getAgentModelDisplay } from "../../ui/src/lib/agents-list-model-display";
+
+describe("agents list model display", () => {
+  test("shows configured and last-used models when they diverge", () => {
+    const display = getAgentModelDisplay("claude-opus-4-7", "claude-sonnet-4-6");
+
+    expect(display).toEqual({
+      configured: "claude-opus-4-7",
+      lastUsed: "claude-sonnet-4-6",
+      primary: "claude-opus-4-7",
+      diverged: true,
+    });
+  });
+
+  test("shows one model when configured and last-used match", () => {
+    const display = getAgentModelDisplay("claude-sonnet-4-6", "claude-sonnet-4-6");
+
+    expect(display).toEqual({
+      configured: "claude-sonnet-4-6",
+      lastUsed: "claude-sonnet-4-6",
+      primary: "claude-sonnet-4-6",
+      diverged: false,
+    });
+  });
+
+  test("shows configured model alone before an agent reports a last-used model", () => {
+    const display = getAgentModelDisplay("claude-opus-4-7", null);
+
+    expect(display.primary).toBe("claude-opus-4-7");
+    expect(display.diverged).toBe(false);
+  });
+});

package/src/tests/base-prompt.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test";
+import { afterEach, describe, expect, test } from "bun:test";
 import { type BasePromptArgs, getBasePrompt } from "../prompts/base-prompt";
 import type { ProviderTraits } from "../providers/types";
 
@@ -9,6 +9,39 @@ const minimalArgs: BasePromptArgs = {
   swarmUrl: "swarm.example.com",
 };
 
+const originalSlackDisable = process.env.SLACK_DISABLE;
+const originalSlackBotToken = process.env.SLACK_BOT_TOKEN;
+const originalSlackAppToken = process.env.SLACK_APP_TOKEN;
+
+afterEach(() => {
+  restoreEnv("SLACK_DISABLE", originalSlackDisable);
+  restoreEnv("SLACK_BOT_TOKEN", originalSlackBotToken);
+  restoreEnv("SLACK_APP_TOKEN", originalSlackAppToken);
+});
+
+function restoreEnv(
+  name: "SLACK_DISABLE" | "SLACK_BOT_TOKEN" | "SLACK_APP_TOKEN",
+  value: string | undefined,
+) {
+  if (value === undefined) {
+    delete process.env[name];
+  } else {
+    process.env[name] = value;
+  }
+}
+
+function enableSlackPromptTools() {
+  process.env.SLACK_DISABLE = "false";
+  process.env.SLACK_BOT_TOKEN = "xoxb-test-token";
+  process.env.SLACK_APP_TOKEN = "xapp-test-token";
+}
+
+function disableSlackPromptTools() {
+  process.env.SLACK_DISABLE = "true";
+  delete process.env.SLACK_BOT_TOKEN;
+  delete process.env.SLACK_APP_TOKEN;
+}
+
 // ---------------------------------------------------------------------------
 // Basic fields
 // ---------------------------------------------------------------------------
@@ -533,3 +566,59 @@ describe("getBasePrompt — local providers unaffected", () => {
     expect(result).toContain("/workspace");
   });
 });
+
+describe("getBasePrompt — conditional Slack templates", () => {
+  test("omits Slack tool templates when Slack is disabled", async () => {
+    disableSlackPromptTools();
+
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      role: "lead",
+      slackContext: { channelId: "C123", threadTs: "123.456" },
+    });
+
+    expect(result).not.toMatch(/\bslack-[a-z-]+\b/);
+    expect(result).toContain("Task Routing");
+  });
+
+  test("includes Slack tool template for lead when Slack is enabled", async () => {
+    enableSlackPromptTools();
+
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      role: "lead",
+    });
+
+    expect(result).toContain("#### Slack Tools");
+    expect(result).toContain("slack-reply");
+    expect(result).toContain("slack-read");
+    expect(result).toContain("slack-list-channels");
+  });
+
+  test("includes Slack tool template for worker when Slack is enabled", async () => {
+    enableSlackPromptTools();
+
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      role: "worker",
+    });
+
+    expect(result).toContain("#### Slack Tools");
+    expect(result).toContain("slack-reply");
+    expect(result).toContain("slack-read");
+    expect(result).toContain("slack-list-channels");
+  });
+
+  test("includes worker Slack thread template when Slack is enabled", async () => {
+    enableSlackPromptTools();
+
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      role: "worker",
+      slackContext: { channelId: "C123", threadTs: "123.456" },
+    });
+
+    expect(result).toContain("slack-reply");
+    expect(result).toContain("C123");
+  });
+});

package/src/tests/http-users.test.ts

@@ -439,6 +439,26 @@ describe("GET /api/users/unmapped", () => {
     expect(body.unmapped[0]!.count).toBe(5);
     expect(body.unmapped[1]!.externalId).toBe("U_LOW");
   });
+
+  test("default unmapped list includes Kapso sender identities", async () => {
+    const ns = "integration:unmapped:kapso";
+    upsertKv({
+      namespace: ns,
+      key: "34679077777:meta",
+      value: { lastSeenAt: "2026-05-20T00:00:00Z", sampleEventType: "kapso.message.received" },
+      valueType: "json",
+    });
+    upsertKv({ namespace: ns, key: "34679077777:count", value: 1, valueType: "integer" });
+
+    const r = await authedFetch("/api/users/unmapped");
+    expect(r.status).toBe(200);
+    const body = (await r.json()) as {
+      unmapped: Array<{ kind: string; externalId: string }>;
+    };
+    expect(body.unmapped).toContainEqual(
+      expect.objectContaining({ kind: "kapso", externalId: "34679077777" }),
+    );
+  });
 });
 
 describe("POST /api/users/unmapped/:kind/:externalId/resolve", () => {
@@ -482,6 +502,39 @@ describe("POST /api/users/unmapped/:kind/:externalId/resolve", () => {
     expect(user.identities).toContainEqual({ kind: "github", externalId: "ghuser" });
   });
 
+  test("create-new branch supports phone-only Kapso contacts without email", async () => {
+    const ns = "integration:unmapped:kapso";
+    upsertKv({
+      namespace: ns,
+      key: "34679077777:meta",
+      value: { lastSeenAt: "x", sampleEventType: "kapso.message.received" },
+      valueType: "json",
+    });
+    upsertKv({ namespace: ns, key: "34679077777:count", value: 1, valueType: "integer" });
+
+    const r = await authedFetch("/api/users/unmapped/kapso/34679077777/resolve", {
+      method: "POST",
+      body: JSON.stringify({
+        name: "Taras",
+        notes: "WhatsApp: +34 679 077 777 (E.164: 34679077777)",
+      }),
+    });
+    expect(r.status).toBe(200);
+    const { user } = (await r.json()) as {
+      user: {
+        id: string;
+        name: string;
+        email?: string;
+        notes?: string;
+        identities: Array<{ kind: string; externalId: string }>;
+      };
+    };
+    expect(user.name).toBe("Taras");
+    expect(user.email).toBeUndefined();
+    expect(user.notes).toContain("E.164: 34679077777");
+    expect(user.identities).toContainEqual({ kind: "kapso", externalId: "34679077777" });
+  });
+
   test("URL-encoded externalId is decoded — kv rows clear, identity stored decoded", async () => {
     // Mimics an AgentMail/Linear @handle entry that contains `@` (or any
     // URL-reserved char). Kv keys are written by the webhook with the literal

package/src/tests/kapso-client.test.ts

@@ -0,0 +1,94 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { sendKapsoText } from "../integrations/kapso/client";
+
+const originalFetch = globalThis.fetch;
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+function mockFetch(status: number, body: unknown) {
+  globalThis.fetch = (async () =>
+    new Response(JSON.stringify(body), {
+      status,
+      headers: { "Content-Type": "application/json" },
+    })) as typeof fetch;
+}
+
+describe("sendKapsoText", () => {
+  test("success → returns outbound wamid", async () => {
+    let captured: { url: string; body: unknown } | null = null;
+    globalThis.fetch = (async (url: string, init: RequestInit) => {
+      captured = { url, body: JSON.parse(init.body as string) };
+      return new Response(JSON.stringify({ messages: [{ id: "wamid.OUT123" }] }), { status: 200 });
+    }) as typeof fetch;
+
+    const result = await sendKapsoText({
+      apiBaseUrl: "https://api.kapso.ai",
+      apiKey: "k",
+      phoneNumberId: "1035039933036854",
+      to: "34679077777",
+      body: "hola",
+    });
+
+    expect(result.ok).toBe(true);
+    expect(result.messageId).toBe("wamid.OUT123");
+    expect(captured!.url).toBe(
+      "https://api.kapso.ai/meta/whatsapp/v24.0/1035039933036854/messages",
+    );
+    expect(captured!.body).toMatchObject({
+      messaging_product: "whatsapp",
+      to: "34679077777",
+      type: "text",
+      text: { body: "hola", preview_url: false },
+    });
+  });
+
+  test("quote-reply sets context.message_id", async () => {
+    let body: Record<string, unknown> | null = null;
+    globalThis.fetch = (async (_url: string, init: RequestInit) => {
+      body = JSON.parse(init.body as string);
+      return new Response(JSON.stringify({ messages: [{ id: "wamid.R" }] }), { status: 200 });
+    }) as typeof fetch;
+
+    await sendKapsoText({
+      apiBaseUrl: "https://api.kapso.ai",
+      apiKey: "k",
+      phoneNumberId: "p",
+      to: "34679077777",
+      body: "re",
+      contextMessageId: "wamid.IN999",
+    });
+
+    expect(body!.context).toEqual({ message_id: "wamid.IN999" });
+  });
+
+  test("24h-window error (code 131047) → sessionWindowExpired", async () => {
+    mockFetch(400, {
+      error: { code: 131047, message: "Message failed: more than 24 hours since last reply" },
+    });
+    const result = await sendKapsoText({
+      apiBaseUrl: "https://api.kapso.ai",
+      apiKey: "k",
+      phoneNumberId: "p",
+      to: "34679077777",
+      body: "late",
+    });
+    expect(result.ok).toBe(false);
+    expect(result.sessionWindowExpired).toBe(true);
+  });
+
+  test("generic error → not flagged as session-window", async () => {
+    mockFetch(401, { error: { code: 0, message: "Invalid API key" } });
+    const result = await sendKapsoText({
+      apiBaseUrl: "https://api.kapso.ai",
+      apiKey: "bad",
+      phoneNumberId: "p",
+      to: "34679077777",
+      body: "x",
+    });
+    expect(result.ok).toBe(false);
+    expect(result.sessionWindowExpired).toBe(false);
+    expect(result.errorMessage).toContain("Invalid API key");
+  });
+});

package/src/tests/kapso-inbound.test.ts

@@ -0,0 +1,257 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import crypto from "node:crypto";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { closeDb, createAgent, createUser, getKv, getTaskById, initDb } from "../be/db";
+import { findUserByExternalId, linkIdentity } from "../be/users";
+import { handleWebhooks } from "../http/webhooks";
+import { putKapsoNumberMapping } from "../integrations/kapso/config";
+import { routeKapsoInbound } from "../integrations/kapso/inbound";
+
+const TEST_DB_PATH = "./test-kapso-inbound.sqlite";
+const HMAC_SECRET = "kapso-test-hmac-secret";
+
+let agentId: string;
+
+function makePayload(opts: {
+  phoneNumberId: string;
+  messageId?: string;
+  direction?: string;
+  type?: string;
+  text?: string;
+  from?: string;
+  conversationId?: string;
+}) {
+  return {
+    message: {
+      id: opts.messageId ?? `wamid.${Math.random().toString(36).slice(2)}`,
+      from: opts.from ?? "34679077777",
+      type: opts.type ?? "text",
+      text: { body: opts.text ?? "hola" },
+      kapso: { direction: opts.direction ?? "inbound", content: opts.text ?? "hola" },
+    },
+    conversation: {
+      id: opts.conversationId ?? "conv-1",
+      phone_number: opts.from ?? "34679077777",
+      contact_name: "Taras",
+    },
+    phone_number_id: opts.phoneNumberId,
+  };
+}
+
+function sign(secret: string, body: string): string {
+  return crypto.createHmac("sha256", secret).update(body).digest("hex");
+}
+
+/** Minimal fake req/res to drive handleWebhooks without a live server. */
+function fakeReqRes(rawBody: string, headers: Record<string, string>) {
+  const req = {
+    method: "POST",
+    headers,
+    async *[Symbol.asyncIterator]() {
+      yield Buffer.from(rawBody);
+    },
+  } as unknown as IncomingMessage;
+
+  const captured = { status: 0, body: "" };
+  const res = {
+    writeHead(status: number) {
+      captured.status = status;
+      return this;
+    },
+    end(chunk?: string) {
+      if (chunk) captured.body = chunk;
+      return this;
+    },
+  } as unknown as ServerResponse;
+
+  return { req, res, captured };
+}
+
+const KAPSO_PATH = ["api", "integrations", "kapso", "webhook"];
+
+beforeAll(() => {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      require("node:fs").unlinkSync(`${TEST_DB_PATH}${suffix}`);
+    } catch {}
+  }
+  initDb(TEST_DB_PATH);
+  process.env.KAPSO_WEBHOOK_HMAC_SECRET = HMAC_SECRET;
+  const agent = createAgent({ name: "KapsoWorker", isLead: false, status: "idle" });
+  agentId = agent.id;
+});
+
+afterAll(() => {
+  closeDb();
+  delete process.env.KAPSO_WEBHOOK_HMAC_SECRET;
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      require("node:fs").unlinkSync(`${TEST_DB_PATH}${suffix}`);
+    } catch {}
+  }
+});
+
+describe("routeKapsoInbound", () => {
+  test("mapping hit → dispatches a kapso-inbound task to the mapped agent", () => {
+    putKapsoNumberMapping({
+      phoneNumberId: "pn-task",
+      agentId,
+      createdAt: new Date().toISOString(),
+    });
+    const routing = routeKapsoInbound(makePayload({ phoneNumberId: "pn-task" }));
+    expect(routing.kind).toBe("task");
+    if (routing.kind !== "task") throw new Error("expected task");
+    const task = getTaskById(routing.taskId);
+    expect(task).not.toBeNull();
+    expect(task!.taskType).toBe("kapso-inbound");
+    expect(task!.agentId).toBe(agentId);
+    expect(task!.task).toContain("## Source: WhatsApp (Kapso)");
+  });
+
+  test("known Kapso sender → populates requestedByUserId and skips unmapped tracker", () => {
+    putKapsoNumberMapping({
+      phoneNumberId: "pn-known-sender",
+      agentId,
+      createdAt: new Date().toISOString(),
+    });
+    const user = createUser({ name: "Known WhatsApp Sender" });
+    linkIdentity(user.id, "kapso", "34679077778", { kind: "system", id: "test-fixture" });
+
+    const routing = routeKapsoInbound(
+      makePayload({
+        phoneNumberId: "pn-known-sender",
+        messageId: "wamid.KNOWN_SENDER",
+        from: "+34 679 077 778",
+        conversationId: "conv-known-sender",
+      }),
+    );
+
+    expect(routing.kind).toBe("task");
+    if (routing.kind !== "task") throw new Error("expected task");
+    const task = getTaskById(routing.taskId);
+    expect(task!.requestedByUserId).toBe(user.id);
+    expect(getKv("integration:unmapped:kapso", "34679077778:meta")).toBeNull();
+  });
+
+  test("unknown Kapso sender → records unmapped identity and leaves task unowned", () => {
+    putKapsoNumberMapping({
+      phoneNumberId: "pn-unknown-sender",
+      agentId,
+      createdAt: new Date().toISOString(),
+    });
+    expect(findUserByExternalId("kapso", "34679077779")).toBeNull();
+
+    const routing = routeKapsoInbound(
+      makePayload({
+        phoneNumberId: "pn-unknown-sender",
+        messageId: "wamid.UNKNOWN_SENDER",
+        from: "+34 679 077 779",
+        conversationId: "conv-unknown-sender",
+      }),
+    );
+
+    expect(routing.kind).toBe("task");
+    if (routing.kind !== "task") throw new Error("expected task");
+    const task = getTaskById(routing.taskId);
+    expect(task!.requestedByUserId).toBeUndefined();
+
+    const meta = getKv("integration:unmapped:kapso", "34679077779:meta");
+    expect(meta?.valueType).toBe("json");
+    expect(meta?.value).toMatchObject({
+      sampleEventType: "kapso.message.received",
+    });
+    expect(String(meta?.value.sampleContext)).toContain("contact=Taras");
+    expect(String(meta?.value.sampleContext)).toContain("message=wamid.UNKNOWN_SENDER");
+    const count = getKv("integration:unmapped:kapso", "34679077779:count");
+    expect(count?.value).toBe(1);
+  });
+
+  test("no mapping → no_mapping (does not break, no task)", () => {
+    const routing = routeKapsoInbound(makePayload({ phoneNumberId: "pn-unregistered" }));
+    expect(routing.kind).toBe("no_mapping");
+  });
+
+  test("workflow mapping → signals workflow dispatch", () => {
+    putKapsoNumberMapping({
+      phoneNumberId: "pn-wf",
+      workflowId: "11111111-1111-4111-8111-111111111111",
+      createdAt: new Date().toISOString(),
+    });
+    const routing = routeKapsoInbound(makePayload({ phoneNumberId: "pn-wf" }));
+    expect(routing.kind).toBe("workflow");
+    if (routing.kind !== "workflow") throw new Error("expected workflow");
+    expect(routing.workflowId).toBe("11111111-1111-4111-8111-111111111111");
+  });
+
+  test("non-inbound (outbound/status) → skip", () => {
+    const routing = routeKapsoInbound(
+      makePayload({ phoneNumberId: "pn-task", direction: "outbound" }),
+    );
+    expect(routing.kind).toBe("skip");
+  });
+
+  test("duplicate delivery of the same message id → second is deduped", () => {
+    putKapsoNumberMapping({
+      phoneNumberId: "pn-dup",
+      agentId,
+      createdAt: new Date().toISOString(),
+    });
+    const messageId = "wamid.DUPLICATE_TEST";
+    const first = routeKapsoInbound(makePayload({ phoneNumberId: "pn-dup", messageId }));
+    expect(first.kind).toBe("task");
+    const second = routeKapsoInbound(makePayload({ phoneNumberId: "pn-dup", messageId }));
+    expect(second.kind).toBe("duplicate");
+  });
+});
+
+describe("handleWebhooks — Kapso HMAC gate", () => {
+  test("valid HMAC + mapping hit → 200 and task routing", async () => {
+    putKapsoNumberMapping({
+      phoneNumberId: "pn-http",
+      agentId,
+      createdAt: new Date().toISOString(),
+    });
+    const rawBody = JSON.stringify(
+      makePayload({ phoneNumberId: "pn-http", messageId: "wamid.HTTP_OK" }),
+    );
+    const { req, res, captured } = fakeReqRes(rawBody, {
+      "x-webhook-signature": sign(HMAC_SECRET, rawBody),
+    });
+    const handled = await handleWebhooks(req, res, KAPSO_PATH);
+    expect(handled).toBe(true);
+    expect(captured.status).toBe(200);
+    expect(JSON.parse(captured.body)).toMatchObject({ received: true, routing: "task" });
+  });
+
+  test("valid HMAC + no mapping → 200 no_mapping (fallback, does not break)", async () => {
+    const rawBody = JSON.stringify(
+      makePayload({ phoneNumberId: "pn-http-unmapped", messageId: "wamid.HTTP_NOMAP" }),
+    );
+    const { req, res, captured } = fakeReqRes(rawBody, {
+      "x-webhook-signature": sign(HMAC_SECRET, rawBody),
+    });
+    await handleWebhooks(req, res, KAPSO_PATH);
+    expect(captured.status).toBe(200);
+    expect(JSON.parse(captured.body)).toMatchObject({ routing: "no_mapping" });
+  });
+
+  test("invalid HMAC → 401", async () => {
+    const rawBody = JSON.stringify(
+      makePayload({ phoneNumberId: "pn-http", messageId: "wamid.HTTP_BAD" }),
+    );
+    const { req, res, captured } = fakeReqRes(rawBody, {
+      "x-webhook-signature": sign("wrong-secret", rawBody),
+    });
+    await handleWebhooks(req, res, KAPSO_PATH);
+    expect(captured.status).toBe(401);
+  });
+
+  test("missing signature → 401", async () => {
+    const rawBody = JSON.stringify(
+      makePayload({ phoneNumberId: "pn-http", messageId: "wamid.HTTP_NOSIG" }),
+    );
+    const { req, res, captured } = fakeReqRes(rawBody, {});
+    await handleWebhooks(req, res, KAPSO_PATH);
+    expect(captured.status).toBe(401);
+  });
+});

package/src/tests/kv-page-proxy.test.ts

@@ -52,6 +52,7 @@ beforeAll(async () => {
       ...process.env,
       PORT: String(TEST_PORT),
       DATABASE_PATH: TEST_DB_PATH,
+      AGENT_SWARM_API_KEY: API_KEY,
       API_KEY,
       PAGE_SESSION_SECRET: PAGE_SECRET,
       MCP_BASE_URL: `http://127.0.0.1:${TEST_PORT}`,

package/src/tests/pagination-metrics.test.ts

@@ -47,6 +47,8 @@ describe("pagination metrics", () => {
   });
 
   test("getTasksCount is filter-aware and independent of limit/offset", () => {
+    const totalBefore = getTasksCount();
+
     for (let i = 0; i < 7; i++) {
       createTaskExtended(`alpha task ${i}`, { tags: ["alpha"] });
     }
@@ -66,7 +68,7 @@ describe("pagination metrics", () => {
     expect(getTasksCount({ tags: ["alpha"], limit: 2, offset: 0 })).toBe(7);
 
     // The unfiltered count covers every task created above.
-    expect(getTasksCount()).toBe(10);
+    expect(getTasksCount() - totalBefore).toBe(10);
   });
 
   test("getTasksCount filter-aware on search", () => {
@@ -123,9 +125,7 @@ describe("pagination metrics", () => {
     expect(countSessions({ source: ["slack"] }) - slackBefore).toBe(2);
     expect(countSessions({ source: ["mcp", "slack"] }) - bothBefore).toBe(7);
     // q filter narrows on top of source.
-    expect(countSessions({ source: ["slack"], q: "slack session" })).toBe(
-      countSessions({ source: ["slack"] }),
-    );
+    expect(countSessions({ source: ["slack"], q: "slack session" }) - slackBefore).toBe(2);
     expect(countSessions({ q: "no-such-session-marker-zzz" })).toBe(0);
   });
 

package/src/tests/prompt-template-session.test.ts

@@ -54,11 +54,12 @@ describe("Session templates — registration", () => {
     await ensureTemplatesRegistered();
   });
 
-  test("all 13 system templates are registered", () => {
+  test("all 14 system templates are registered", () => {
     const systemTemplates = [
       "system.agent.role",
       "system.agent.register",
       "system.agent.lead",
+      "system.agent.slack",
       "system.agent.worker",
       "system.agent.worker.slack",
       "system.agent.filesystem",
@@ -89,10 +90,10 @@ describe("Session templates — registration", () => {
     }
   });
 
-  test("total of 18 session/system templates registered", () => {
+  test("total of 19 session/system templates registered", () => {
     const all = getAllTemplateDefinitions();
     const sessionSystem = all.filter((d) => d.category === "system" || d.category === "session");
-    expect(sessionSystem.length).toBe(18);
+    expect(sessionSystem.length).toBe(19);
   });
 });
 
@@ -150,6 +151,15 @@ describe("Session templates — individual resolution", () => {
     const result = resolveTemplate("system.agent.lead", {});
     expect(result.text).toContain("CRITICAL: You are a coordinator");
     expect(result.text).toContain("coordinator");
+    expect(result.text).not.toContain("slack-reply");
+  });
+
+  test("system.agent.slack contains Slack tool guidance", () => {
+    const result = resolveTemplate("system.agent.slack", {});
+    expect(result.text).toContain("Slack Tools");
+    expect(result.text).toContain("slack-reply");
+    expect(result.text).toContain("slack-read");
+    expect(result.text).toContain("slack-list-channels");
   });
 
   test("system.agent.worker contains worker tools", () => {