@desplega.ai/agent-swarm 1.172.0 → 2.0.0

package/src/tests/chat-sdk-config.test.ts

@@ -0,0 +1,334 @@
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { SlackMock } from "@desplega.ai/slack-mock";
+import { closeDb, initDb, upsertSwarmConfig } from "../be/db";
+import { validateConfigValue } from "../be/swarm-config-guard";
+import {
+  assertNoSlackClash,
+  ChatSdkAdaptersSchema,
+  getChatSdkConfig,
+  readApiUrlOverrides,
+} from "../integrations/chat-sdk/config";
+import { getChatSdkHealth, startChatSdk, stopChatSdk } from "../integrations/chat-sdk/runtime";
+import { snapshotChatSdkEnv } from "./chat-sdk-harness";
+
+const TEST_DB_PATH = "./test-chat-sdk-config.sqlite";
+const restoreEnv = snapshotChatSdkEnv();
+
+async function removeDbFiles(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    await unlink(`${TEST_DB_PATH}${suffix}`).catch(() => {});
+  }
+}
+
+/** The brainstorm's example config, one adapter of each kind. */
+const BRAINSTORM_EXAMPLE = {
+  slack: {
+    botToken: { $config: "SLACK_CHAT_BOT_TOKEN" },
+    signingSecret: { $config: "SLACK_CHAT_SIGNING_SECRET" },
+    mode: "webhook",
+  },
+  discord: {
+    botToken: { $config: "DISCORD_BOT_TOKEN" },
+    publicKey: "abababababababababababababababababababababababababababababababab",
+    applicationId: "1234",
+    respondToChannelIds: ["c1"],
+    respondToGlobalMentions: true,
+  },
+  telegram: {
+    botToken: { $config: "TG_TOKEN" },
+    secretToken: "s3cret-token",
+    mode: "polling",
+    allowedUserIds: ["1", 2],
+  },
+  teams: {
+    appId: "app",
+    appPassword: { $config: "TEAMS_PW" },
+    appType: "SingleTenant",
+    appTenantId: "tenant",
+  },
+};
+
+function setAdapters(value: unknown): void {
+  process.env.CHAT_SDK_ENABLED = "true";
+  process.env.CHAT_SDK_ADAPTERS = JSON.stringify(value);
+}
+
+beforeAll(async () => {
+  await removeDbFiles();
+  initDb(TEST_DB_PATH);
+  await upsertSwarmConfig({
+    scope: "global",
+    key: "TG_TOKEN",
+    value: "tg-token-from-config",
+    isSecret: true,
+  });
+  await upsertSwarmConfig({ scope: "global", key: "TG_SECRET", value: "tg-secret-from-config" });
+});
+
+afterEach(() => {
+  restoreEnv();
+  delete process.env.CHAT_TEST_ENV_ONLY;
+});
+
+afterAll(async () => {
+  closeDb();
+  await removeDbFiles();
+});
+
+describe("ChatSdkAdaptersSchema", () => {
+  test("accepts the brainstorm example", () => {
+    expect(ChatSdkAdaptersSchema.safeParse(BRAINSTORM_EXAMPLE).success).toBe(true);
+  });
+
+  test("rejects a non-object adapter and an unknown adapter name", () => {
+    expect(ChatSdkAdaptersSchema.safeParse({ telegram: "token" }).success).toBe(false);
+    expect(ChatSdkAdaptersSchema.safeParse({ whatsapp: {} }).success).toBe(false);
+  });
+
+  test("defaults telegram mode to webhook, never the SDK's auto", () => {
+    const parsed = ChatSdkAdaptersSchema.parse({ telegram: { botToken: "x" } });
+    expect(parsed.telegram?.mode).toBe("webhook");
+    expect(
+      ChatSdkAdaptersSchema.safeParse({ telegram: { botToken: "x", mode: "auto" } }).success,
+    ).toBe(false);
+  });
+
+  test("slack and teams defaults and mode-dependent required fields", () => {
+    const parsed = ChatSdkAdaptersSchema.parse({
+      slack: { botToken: "x", signingSecret: "s" },
+      teams: { appId: "a", appPassword: "p" },
+    });
+    expect(parsed.slack?.mode).toBe("webhook");
+    expect(parsed.teams?.appType).toBe("MultiTenant");
+    const invalid = [
+      { slack: { botToken: "x" } },
+      { slack: { botToken: "x", mode: "socket" } },
+      { teams: { appId: "a", appPassword: "p", appType: "SingleTenant" } },
+    ];
+    for (const value of invalid) {
+      expect(ChatSdkAdaptersSchema.safeParse(value).success).toBe(false);
+    }
+  });
+
+  test("passes unknown adapter keys through", () => {
+    const parsed = ChatSdkAdaptersSchema.parse({
+      telegram: { botToken: "x", mentionOnReply: true },
+    });
+    expect((parsed.telegram as Record<string, unknown>).mentionOnReply).toBe(true);
+  });
+});
+
+describe("CHAT_SDK_ADAPTERS validator", () => {
+  test("returns an error string for bad JSON", () => {
+    expect(validateConfigValue("CHAT_SDK_ADAPTERS", "{not json")).toContain("not valid JSON");
+  });
+
+  test("rejects operator base URLs, verifiers and unverified webhooks", () => {
+    for (const key of ["apiUrl", "apiBaseUrl", "webhookVerifier", "allowUnverifiedWebhooks"]) {
+      const error = validateConfigValue(
+        "CHAT_SDK_ADAPTERS",
+        JSON.stringify({ telegram: { botToken: "x", [key]: "http://evil.example" } }),
+      );
+      expect(error).toContain(`telegram.${key}`);
+    }
+  });
+
+  test("Discord: typed mention fields, verifier still rejected", () => {
+    const discord = {
+      botToken: "x",
+      publicKey: "abababababababababababababababababababababababababababababababab",
+      applicationId: "1234",
+    };
+    expect(
+      validateConfigValue(
+        "CHAT_SDK_ADAPTERS",
+        JSON.stringify({ discord: { ...discord, mentionRoleIds: ["r1"] } }),
+      ),
+    ).toBeNull();
+    expect(
+      validateConfigValue(
+        "CHAT_SDK_ADAPTERS",
+        JSON.stringify({ discord: { ...discord, mentionRoleIds: "r1" } }),
+      ),
+    ).toContain("discord.mentionRoleIds");
+    expect(
+      validateConfigValue(
+        "CHAT_SDK_ADAPTERS",
+        JSON.stringify({ discord: { ...discord, webhookVerifier: "x" } }),
+      ),
+    ).toContain("discord.webhookVerifier");
+    const badKey = validateConfigValue(
+      "CHAT_SDK_ADAPTERS",
+      JSON.stringify({ discord: { ...discord, publicKey: "abcdef" } }),
+    );
+    expect(badKey).toContain("discord.publicKey");
+    expect(badKey).toContain("64 hex characters");
+  });
+
+  test("accepts a partial entry (a dashboard save with fields still missing)", () => {
+    expect(
+      validateConfigValue("CHAT_SDK_ADAPTERS", JSON.stringify({ discord: { botToken: "x" } })),
+    ).toBeNull();
+    expect(validateConfigValue("CHAT_SDK_ADAPTERS", JSON.stringify({ slack: {} }))).toBeNull();
+    // Formats and forbidden keys still apply to a partial entry.
+    expect(
+      validateConfigValue("CHAT_SDK_ADAPTERS", JSON.stringify({ discord: { publicKey: "nope" } })),
+    ).toContain("64 hex");
+    expect(
+      validateConfigValue("CHAT_SDK_ADAPTERS", JSON.stringify({ telegram: { mode: "auto" } })),
+    ).toContain("telegram.mode");
+  });
+
+  test("accepts a valid value without resolving refs", () => {
+    expect(validateConfigValue("CHAT_SDK_ADAPTERS", JSON.stringify(BRAINSTORM_EXAMPLE))).toBeNull();
+  });
+
+  test("CHAT_SDK_ENABLED is a boolean key", () => {
+    expect(validateConfigValue("CHAT_SDK_ENABLED", "true")).toBeNull();
+    expect(validateConfigValue("CHAT_SDK_ENABLED", "yes please")).not.toBeNull();
+  });
+});
+
+describe("getChatSdkConfig", () => {
+  test("disabled returns no adapters and no error", async () => {
+    process.env.CHAT_SDK_ENABLED = "false";
+    process.env.CHAT_SDK_ADAPTERS = JSON.stringify({ telegram: { botToken: "x" } });
+    expect(await getChatSdkConfig()).toEqual({ enabled: false, adapters: {} });
+  });
+
+  test("resolves refs into functions for botToken and strings for secretToken", async () => {
+    setAdapters({
+      telegram: { botToken: { $config: "TG_TOKEN" }, secretToken: { $config: "TG_SECRET" } },
+    });
+    const config = await getChatSdkConfig();
+    expect(config.error).toBeUndefined();
+    const telegram = config.adapters.telegram!;
+    expect(typeof telegram.botToken).toBe("function");
+    expect(await (telegram.botToken as () => Promise<string>)()).toBe("tg-token-from-config");
+    expect(telegram.secretToken).toBe("tg-secret-from-config");
+    expect(telegram.mode).toBe("webhook");
+    expect(telegram.userName).toBeUndefined();
+  });
+
+  test("rejects reserved keys as $config targets", async () => {
+    for (const key of ["API_KEY", "SECRETS_ENCRYPTION_KEY", "CHAT_SDK_API_URL_OVERRIDES"]) {
+      setAdapters({ telegram: { botToken: { $config: key }, secretToken: "s" } });
+      const config = await getChatSdkConfig();
+      expect(config.adapters).toEqual({});
+      expect(config.error).toBeUndefined();
+      expect(config.incomplete?.telegram).toContain(`reserved key '${key}'`);
+    }
+  });
+
+  test("a ref to an env-only value is reported missing", async () => {
+    process.env.CHAT_TEST_ENV_ONLY = "lives-only-in-env";
+    setAdapters({ telegram: { botToken: { $config: "CHAT_TEST_ENV_ONLY" }, secretToken: "s" } });
+    const config = await getChatSdkConfig();
+    expect(config.adapters).toEqual({});
+    expect(config.error).toBeUndefined();
+    expect(config.incomplete?.telegram).toContain("CHAT_TEST_ENV_ONLY");
+  });
+
+  test("an adapter with a missing required field is incomplete; the others still resolve", async () => {
+    setAdapters({
+      telegram: { botToken: { $config: "TG_TOKEN" }, secretToken: "s" },
+      discord: { botToken: { $config: "TG_TOKEN" } },
+      teams: { appId: "a", appPassword: "p", appType: "SingleTenant" },
+    });
+    const config = await getChatSdkConfig();
+    expect(config.error).toBeUndefined();
+    expect(Object.keys(config.adapters)).toEqual(["telegram"]);
+    expect(config.incomplete?.discord).toBe("CHAT_SDK_ADAPTERS.discord.publicKey: required");
+    expect(config.incomplete?.teams).toBe("CHAT_SDK_ADAPTERS.teams.appTenantId: required");
+  });
+
+  test("enabled: false keeps the entry out of the started adapters, listed as disabled", async () => {
+    setAdapters({
+      telegram: { botToken: { $config: "TG_TOKEN" }, secretToken: "s", enabled: false },
+      discord: { botToken: "x", enabled: false },
+    });
+    const config = await getChatSdkConfig();
+    expect(config.adapters).toEqual({});
+    expect(config.disabled).toEqual(["telegram", "discord"]);
+    // Not validated for completeness while off.
+    expect(config.incomplete).toBeUndefined();
+    const on = { telegram: { botToken: { $config: "TG_TOKEN" }, secretToken: "s", enabled: true } };
+    setAdapters(on);
+    const enabled = await getChatSdkConfig();
+    expect(Object.keys(enabled.adapters)).toEqual(["telegram"]);
+    // The switch is not passed to the adapter factory.
+    expect(enabled.adapters.telegram?.enabled).toBeUndefined();
+  });
+
+  test("a forbidden key or an unknown adapter still fails the whole value", async () => {
+    setAdapters({ telegram: { botToken: "x" }, discord: { apiUrl: "http://evil.example" } });
+    const config = await getChatSdkConfig();
+    expect(config.adapters).toEqual({});
+    expect(config.error).toContain("discord.apiUrl");
+    setAdapters({ telegram: { botToken: "x" }, whatsapp: {} });
+    expect((await getChatSdkConfig()).error).toContain("whatsapp");
+  });
+
+  test("reports invalid JSON and schema errors without throwing", async () => {
+    process.env.CHAT_SDK_ENABLED = "true";
+    process.env.CHAT_SDK_ADAPTERS = "{oops";
+    expect((await getChatSdkConfig()).error).toContain("not valid JSON");
+    setAdapters({ telegram: { botToken: "x", apiUrl: "http://evil.example" } });
+    expect((await getChatSdkConfig()).error).toContain("telegram.apiUrl");
+  });
+});
+
+describe("assertNoSlackClash", () => {
+  test("throws for a slack adapter unless SLACK_DISABLE=true", async () => {
+    setAdapters({ slack: { botToken: "xoxb-1", signingSecret: "sig" } });
+    delete process.env.SLACK_DISABLE;
+    const config = await getChatSdkConfig();
+    expect(() => assertNoSlackClash(config)).toThrow("set SLACK_DISABLE=true");
+    process.env.SLACK_DISABLE = "true";
+    expect(() => assertNoSlackClash(config)).not.toThrow();
+  });
+
+  test("startChatSdk boots a slack entry only with SLACK_DISABLE=true", async () => {
+    const slack = await SlackMock.start({ port: 0 });
+    try {
+      setAdapters({
+        slack: {
+          mode: "webhook",
+          botToken: slack.env.SLACK_BOT_TOKEN,
+          signingSecret: "mock-signing-secret",
+        },
+      });
+      process.env.CHAT_SDK_API_URL_OVERRIDES = JSON.stringify({ slack: slack.env.SLACK_API_URL });
+
+      delete process.env.SLACK_DISABLE;
+      await startChatSdk();
+      expect(getChatSdkHealth()).toEqual({});
+      await stopChatSdk();
+
+      process.env.SLACK_DISABLE = "true";
+      await startChatSdk();
+      expect(getChatSdkHealth().slack?.status).toBe("ok");
+    } finally {
+      await stopChatSdk();
+      await slack.stop();
+    }
+  });
+
+  test("ignores configs without slack", () => {
+    delete process.env.SLACK_DISABLE;
+    expect(() => assertNoSlackClash({ enabled: true, adapters: { telegram: {} } })).not.toThrow();
+  });
+});
+
+describe("readApiUrlOverrides", () => {
+  test("reads known adapters from env JSON and ignores garbage", () => {
+    process.env.CHAT_SDK_API_URL_OVERRIDES = JSON.stringify({
+      telegram: "http://127.0.0.1:1",
+      unknown: "http://x",
+    });
+    expect(readApiUrlOverrides()).toEqual({ telegram: "http://127.0.0.1:1" });
+    process.env.CHAT_SDK_API_URL_OVERRIDES = "not json";
+    expect(readApiUrlOverrides()).toEqual({});
+  });
+});

package/src/tests/chat-sdk-discord-api.test.ts

@@ -0,0 +1,68 @@
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
+import { fetchDiscordGuilds, resetDiscordGuildsCache } from "../integrations/chat-sdk/discord-api";
+import { snapshotChatSdkEnv } from "./chat-sdk-harness";
+
+const restoreEnv = snapshotChatSdkEnv();
+let server: ReturnType<typeof Bun.serve>;
+let hits: Array<{ auth: string | null; path: string }> = [];
+let respond: () => Response = () => Response.json([]);
+
+beforeAll(() => {
+  server = Bun.serve({
+    port: 0,
+    fetch(request) {
+      const url = new URL(request.url);
+      hits.push({ auth: request.headers.get("authorization"), path: url.pathname });
+      return respond();
+    },
+  });
+  process.env.CHAT_SDK_API_URL_OVERRIDES = JSON.stringify({
+    discord: `http://127.0.0.1:${server.port}`,
+  });
+});
+
+afterEach(() => {
+  hits = [];
+  resetDiscordGuildsCache();
+});
+
+afterAll(() => {
+  server.stop(true);
+  restoreEnv();
+});
+
+describe("fetchDiscordGuilds", () => {
+  test("lists the bot's servers with the Bot authorization header", async () => {
+    respond = () =>
+      Response.json([
+        { id: "1", name: "sheetsql" },
+        { id: "2", name: "test server" },
+      ]);
+    expect(await fetchDiscordGuilds("tok-1")).toEqual({
+      count: 2,
+      names: ["sheetsql", "test server"],
+    });
+    expect(hits).toEqual([{ auth: "Bot tok-1", path: "/users/@me/guilds" }]);
+  });
+
+  test("caches per token for a minute, so the status poll does not hammer Discord", async () => {
+    respond = () => Response.json([]);
+    const now = 1_000_000;
+    expect(await fetchDiscordGuilds("tok-2", now)).toEqual({ count: 0, names: [] });
+    expect(await fetchDiscordGuilds("tok-2", now + 30_000)).toEqual({ count: 0, names: [] });
+    expect(hits).toHaveLength(1);
+    await fetchDiscordGuilds("tok-2", now + 61_000);
+    expect(hits).toHaveLength(2);
+    // Another token is another bot.
+    await fetchDiscordGuilds("tok-3", now + 61_000);
+    expect(hits).toHaveLength(3);
+  });
+
+  test("an HTTP error or a bad body yields undefined, without throwing", async () => {
+    respond = () => new Response("nope", { status: 401 });
+    expect(await fetchDiscordGuilds("tok-4")).toBeUndefined();
+    resetDiscordGuildsCache();
+    respond = () => Response.json({ not: "an array" });
+    expect(await fetchDiscordGuilds("tok-4")).toBeUndefined();
+  });
+});

package/src/tests/chat-sdk-discord-gateway.test.ts

@@ -0,0 +1,252 @@
+import { afterEach, describe, expect, spyOn, test } from "bun:test";
+import type { WebhookOptions } from "chat";
+import { keepDiscordInfoLine } from "../integrations/chat-sdk/adapters";
+import { drainBackground } from "../integrations/chat-sdk/background";
+import {
+  type DiscordGatewayListener,
+  getDiscordGatewayHealth,
+  startDiscordGateway,
+  stopDiscordGateway,
+} from "../integrations/chat-sdk/discord-gateway";
+import { createScrubbingLogger, withInfoFilter } from "../integrations/chat-sdk/logger";
+
+/**
+ * A stand-in for the Discord adapter. Like the real one, it answers at once
+ * and hands the listener window to `waitUntil`. A window resolves after its
+ * duration or on abort, and never rejects. `innerMs` maps the call index to
+ * the window duration.
+ */
+function stubAdapter(innerMs: number | ((call: number) => number) = 20) {
+  const calls: { durationMs?: number; signal?: AbortSignal }[] = [];
+  const adapter: DiscordGatewayListener = {
+    async startGatewayListener(options: WebhookOptions, durationMs?: number, signal?: AbortSignal) {
+      const ms = typeof innerMs === "function" ? innerMs(calls.length) : innerMs;
+      calls.push({ durationMs, signal });
+      const inner = new Promise<void>((resolve) => {
+        const timer = setTimeout(resolve, ms);
+        signal?.addEventListener(
+          "abort",
+          () => {
+            clearTimeout(timer);
+            resolve();
+          },
+          { once: true },
+        );
+      });
+      options.waitUntil?.(inner);
+      return new Response(JSON.stringify({ status: "listening" }), { status: 200 });
+    },
+  };
+  return { adapter, calls };
+}
+
+/** Resolves on `signal` abort, so an injected sleep never outlives its loop. */
+function onAbort(signal: AbortSignal, resolve: () => void): void {
+  signal.addEventListener("abort", () => resolve(), { once: true });
+}
+
+/** Resolves when `predicate` holds, polling on the event loop (no fixed sleep). */
+async function waitFor(predicate: () => boolean, timeoutMs = 2_000): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (!predicate()) {
+    if (Date.now() > deadline) throw new Error("waitFor timed out");
+    await new Promise((resolve) => setTimeout(resolve, 1));
+  }
+}
+
+afterEach(async () => {
+  stopDiscordGateway();
+  await drainBackground(1_000);
+});
+
+describe("Discord gateway loop", () => {
+  test("re-arms the listener after each window and counts restarts", async () => {
+    const { adapter, calls } = stubAdapter();
+    // Each window looks 30 s long, so no backoff runs.
+    let clock = 0;
+    const now = () => {
+      clock += 30_000;
+      return clock;
+    };
+    const sleeps: number[] = [];
+    startDiscordGateway(adapter, {
+      windowMs: 60_000,
+      now,
+      sleep: (ms, signal) =>
+        new Promise<void>((resolve) => {
+          sleeps.push(ms);
+          onAbort(signal, resolve);
+          resolve();
+        }),
+    });
+
+    await waitFor(() => calls.length >= 3);
+    expect(calls[0]!.durationMs).toBe(60_000);
+    // Each window gets its own signal, not the loop's.
+    expect(calls[0]!.signal).not.toBe(calls[1]!.signal);
+    expect(sleeps).toEqual([]);
+    const health = getDiscordGatewayHealth();
+    expect(health?.state).toBe("running");
+    expect(health?.restarts).toBeGreaterThanOrEqual(2);
+  });
+
+  test("backs off for 30 s when a window ends in under 10 s", async () => {
+    // The first window ends after 20 ms. Later windows only end on abort.
+    const { adapter, calls } = stubAdapter((call) => (call === 0 ? 20 : 60_000));
+    const sleeps: number[] = [];
+    let releaseSleep: (() => void) | undefined;
+    startDiscordGateway(adapter, {
+      sleep: (ms, signal) => {
+        sleeps.push(ms);
+        // Hold the loop in backoff until the test releases it or the loop stops.
+        return new Promise<void>((resolve) => {
+          releaseSleep = resolve;
+          onAbort(signal, resolve);
+        });
+      },
+    });
+
+    await waitFor(() => sleeps.length === 1);
+    expect(sleeps).toEqual([30_000]);
+    expect(calls).toHaveLength(1);
+    expect(getDiscordGatewayHealth()?.state).toBe("backoff");
+
+    releaseSleep?.();
+    await waitFor(() => calls.length === 2);
+    expect(getDiscordGatewayHealth()?.restarts).toBe(1);
+    expect(getDiscordGatewayHealth()?.state).toBe("running");
+  });
+
+  test("stops on abort within one iteration and reports stopped", async () => {
+    // A window far longer than the test: only the abort can end it.
+    const { adapter, calls } = stubAdapter(60_000);
+    startDiscordGateway(adapter, {
+      sleep: (_ms, signal) =>
+        new Promise<void>((resolve) => {
+          onAbort(signal, resolve);
+          resolve();
+        }),
+    });
+    await waitFor(() => calls.length === 1);
+    expect(calls[0]!.signal?.aborted).toBe(false);
+
+    stopDiscordGateway();
+    expect(calls[0]!.signal?.aborted).toBe(true);
+    // The inner window was tracked for the shutdown drain and is closed now.
+    expect(await drainBackground(1_000)).toBe(true);
+    await waitFor(() => getDiscordGatewayHealth()?.state === "stopped", 1_000);
+    expect(calls).toHaveLength(1);
+  });
+
+  test("a listener that refuses to start backs off instead of spinning", async () => {
+    let starts = 0;
+    const adapter: DiscordGatewayListener = {
+      async startGatewayListener() {
+        starts += 1;
+        return new Response("Chat instance not initialized", { status: 500 });
+      },
+    };
+    const sleeps: number[] = [];
+    startDiscordGateway(adapter, {
+      // Yields to the timer queue, as the real 30 s sleep does.
+      sleep: (ms, signal) => {
+        sleeps.push(ms);
+        return new Promise((resolve) => {
+          setTimeout(resolve, 1);
+          onAbort(signal, resolve);
+        });
+      },
+    });
+    await waitFor(() => starts >= 2);
+    expect(sleeps.every((ms) => ms === 30_000)).toBe(true);
+    expect(sleeps.length).toBeGreaterThanOrEqual(1);
+  });
+
+  test("an abort during the real 30 s backoff sleep ends the loop at once", async () => {
+    // Production sleep: windows end after 20 ms, so the loop backs off for 30 s.
+    const { adapter, calls } = stubAdapter(20);
+    startDiscordGateway(adapter);
+    await waitFor(() => getDiscordGatewayHealth()?.state === "backoff");
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    const started = Date.now();
+    stopDiscordGateway();
+    await waitFor(() => getDiscordGatewayHealth()?.state === "stopped", 500);
+    expect(Date.now() - started).toBeLessThan(500);
+    expect(calls).toHaveLength(1);
+  });
+
+  test("stop returns at once and the drain bounds a window that never closes", async () => {
+    let release: (() => void) | undefined;
+    let starts = 0;
+    const adapter: DiscordGatewayListener = {
+      async startGatewayListener(options: WebhookOptions) {
+        starts += 1;
+        // Ignores the abort signal: only `release` ends this window.
+        options.waitUntil?.(
+          new Promise<void>((resolve) => {
+            release = resolve;
+          }),
+        );
+        return new Response("{}", { status: 200 });
+      },
+    };
+    startDiscordGateway(adapter);
+    await waitFor(() => starts === 1);
+
+    const stopStarted = Date.now();
+    stopDiscordGateway();
+    expect(Date.now() - stopStarted).toBeLessThan(500);
+
+    const drainStarted = Date.now();
+    expect(await drainBackground(200)).toBe(false);
+    const drainMs = Date.now() - drainStarted;
+    expect(drainMs).toBeGreaterThanOrEqual(150);
+    expect(drainMs).toBeLessThan(1_000);
+    expect(getDiscordGatewayHealth()?.state).toBe("running");
+
+    // Let the loop exit so later tests see an empty background set.
+    release?.();
+    await waitFor(() => getDiscordGatewayHealth()?.state === "stopped");
+    expect(starts).toBe(1);
+  });
+});
+
+describe("Chat SDK logger", () => {
+  test("the Discord info filter drops noisy lines and keeps the others", () => {
+    const info = spyOn(console, "info").mockImplementation(() => {});
+    try {
+      const logger = withInfoFilter(createScrubbingLogger("discord"), keepDiscordInfoLine);
+      logger.info("Discord Gateway message received", { content: "private guild text" });
+      logger.child("gateway").info("Discord signature verification attempt", { publicKey: "k" });
+      logger.info("Discord Gateway connected", { username: "bot" });
+      expect(info).toHaveBeenCalledTimes(1);
+      expect(info.mock.calls[0]?.[1]).toBe("Discord Gateway connected");
+    } finally {
+      info.mockRestore();
+    }
+  });
+
+  test("warn and error lines pass the filter and carry their cause to the sink", () => {
+    const error = spyOn(console, "error").mockImplementation(() => {});
+    const warn = spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      const issues: string[] = [];
+      const logger = withInfoFilter(
+        createScrubbingLogger("discord", (level, message) => issues.push(`${level}: ${message}`)),
+        () => false,
+      );
+      logger.error("Discord Gateway listener error", { error: "Error [TokenInvalid]: bad" });
+      logger.warn("Discord webhook verifier rejected the request", new Error("nope"));
+      logger.warn("x".repeat(400));
+      expect(issues[0]).toBe("error: Discord Gateway listener error: Error [TokenInvalid]: bad");
+      expect(issues[1]).toBe("warn: Discord webhook verifier rejected the request: Error: nope");
+      expect(issues[2]).toHaveLength("warn: ".length + 300);
+      expect(error).toHaveBeenCalledTimes(1);
+      expect(warn).toHaveBeenCalledTimes(2);
+    } finally {
+      error.mockRestore();
+      warn.mockRestore();
+    }
+  });
+});