@openclaw/discord 2026.3.13 → 2026.5.2-beta.1

package/src/subagent-hooks.test.ts

@@ -1,6 +1,9 @@
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk/discord";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { registerDiscordSubagentHooks } from "./subagent-hooks.js";
+import {
+  getRequiredHookHandler,
+  registerHookHandlersForTest,
+} from "openclaw/plugin-sdk/channel-test-helpers";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
+import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 
 type ThreadBindingRecord = {
   accountId: string;
@@ -12,31 +15,58 @@ type MockResolvedDiscordAccount = {
   config: {
     threadBindings?: {
       enabled?: boolean;
-      spawnSubagentSessions?: boolean;
+      spawnSessions?: boolean;
     };
   };
 };
 
-const hookMocks = vi.hoisted(() => ({
-  resolveDiscordAccount: vi.fn(
-    (params?: { accountId?: string }): MockResolvedDiscordAccount => ({
-      accountId: params?.accountId?.trim() || "default",
+type MockResolveDiscordAccountParams = {
+  cfg?: {
+    channels?: {
+      discord?: {
+        defaultAccount?: string;
+        accounts?: Record<
+          string,
+          { threadBindings?: MockResolvedDiscordAccount["config"]["threadBindings"] }
+        >;
+      };
+    };
+  };
+  accountId?: string;
+};
+
+const hookMocks = vi.hoisted(() => {
+  const resolveDiscordAccountImpl = (
+    params?: MockResolveDiscordAccountParams,
+  ): MockResolvedDiscordAccount => {
+    const accountId =
+      params?.accountId?.trim() || params?.cfg?.channels?.discord?.defaultAccount || "default";
+    return {
+      accountId,
       config: {
-        threadBindings: {
-          spawnSubagentSessions: true,
+        threadBindings: params?.cfg?.channels?.discord?.accounts?.[accountId]?.threadBindings ?? {
+          spawnSessions: true,
         },
       },
-    }),
-  ),
-  autoBindSpawnedDiscordSubagent: vi.fn(
-    async (): Promise<{ threadId: string } | null> => ({ threadId: "thread-1" }),
-  ),
-  listThreadBindingsBySessionKey: vi.fn((_params?: unknown): ThreadBindingRecord[] => []),
-  unbindThreadBindingsBySessionKey: vi.fn(() => []),
-}));
+    };
+  };
+  return {
+    resolveDiscordAccountImpl,
+    resolveDiscordAccount: vi.fn(resolveDiscordAccountImpl),
+    autoBindSpawnedDiscordSubagent: vi.fn(
+      async (): Promise<{ threadId: string } | null> => ({ threadId: "thread-1" }),
+    ),
+    listThreadBindingsBySessionKey: vi.fn((_params?: unknown): ThreadBindingRecord[] => []),
+    unbindThreadBindingsBySessionKey: vi.fn(() => []),
+  };
+});
+
+let registerDiscordSubagentHooks: typeof import("../subagent-hooks-api.js").registerDiscordSubagentHooks;
 
-vi.mock("openclaw/plugin-sdk/discord", () => ({
+vi.mock("./accounts.js", () => ({
   resolveDiscordAccount: hookMocks.resolveDiscordAccount,
+}));
+vi.mock("./monitor/thread-bindings.js", () => ({
   autoBindSpawnedDiscordSubagent: hookMocks.autoBindSpawnedDiscordSubagent,
   listThreadBindingsBySessionKey: hookMocks.listThreadBindingsBySessionKey,
   unbindThreadBindingsBySessionKey: hookMocks.unbindThreadBindingsBySessionKey,
@@ -47,43 +77,27 @@ function registerHandlersForTest(
     channels: {
       discord: {
         threadBindings: {
-          spawnSubagentSessions: true,
+          spawnSessions: true,
         },
       },
     },
   },
 ) {
-  const handlers = new Map<string, (event: unknown, ctx: unknown) => unknown>();
-  const api = {
+  return registerHookHandlersForTest<OpenClawPluginApi>({
     config,
-    on: (hookName: string, handler: (event: unknown, ctx: unknown) => unknown) => {
-      handlers.set(hookName, handler);
-    },
-  } as unknown as OpenClawPluginApi;
-  registerDiscordSubagentHooks(api);
-  return handlers;
-}
-
-function getRequiredHandler(
-  handlers: Map<string, (event: unknown, ctx: unknown) => unknown>,
-  hookName: string,
-): (event: unknown, ctx: unknown) => unknown {
-  const handler = handlers.get(hookName);
-  if (!handler) {
-    throw new Error(`expected ${hookName} hook handler`);
-  }
-  return handler;
+    register: registerDiscordSubagentHooks,
+  });
 }
 
-function resolveSubagentDeliveryTargetForTest(requesterOrigin: {
+async function resolveSubagentDeliveryTargetForTest(requesterOrigin: {
   channel: string;
   accountId: string;
   to: string;
   threadId?: string;
 }) {
   const handlers = registerHandlersForTest();
-  const handler = getRequiredHandler(handlers, "subagent_delivery_target");
-  return handler(
+  const handler = getRequiredHookHandler(handlers, "subagent_delivery_target");
+  return await handler(
     {
       childSessionKey: "agent:main:subagent:child",
       requesterSessionKey: "agent:main:main",
@@ -103,7 +117,7 @@ function createSpawnEvent(overrides?: {
   mode?: string;
   requester?: {
     channel?: string;
-    accountId?: string;
+    accountId?: string | undefined;
     to?: string;
     threadId?: string;
   };
@@ -115,7 +129,7 @@ function createSpawnEvent(overrides?: {
   mode: string;
   requester: {
     channel: string;
-    accountId: string;
+    accountId?: string;
     to: string;
     threadId?: string;
   };
@@ -139,7 +153,7 @@ function createSpawnEvent(overrides?: {
     ...overrides,
     requester: {
       ...base.requester,
-      ...(overrides?.requester ?? {}),
+      ...overrides?.requester,
     },
   };
 }
@@ -156,7 +170,7 @@ async function runSubagentSpawning(
   event = createSpawnEventWithoutThread(),
 ) {
   const handlers = registerHandlersForTest(config);
-  const handler = getRequiredHandler(handlers, "subagent_spawning");
+  const handler = getRequiredHookHandler(handlers, "subagent_spawning");
   return await handler(event, {});
 }
 
@@ -175,37 +189,35 @@ async function expectSubagentSpawningError(params?: {
 }
 
 describe("discord subagent hook handlers", () => {
+  beforeAll(async () => {
+    ({ registerDiscordSubagentHooks } = await import("../subagent-hooks-api.js"));
+  });
+
   beforeEach(() => {
     hookMocks.resolveDiscordAccount.mockClear();
-    hookMocks.resolveDiscordAccount.mockImplementation((params?: { accountId?: string }) => ({
-      accountId: params?.accountId?.trim() || "default",
-      config: {
-        threadBindings: {
-          spawnSubagentSessions: true,
-        },
-      },
-    }));
+    hookMocks.resolveDiscordAccount.mockImplementation(hookMocks.resolveDiscordAccountImpl);
     hookMocks.autoBindSpawnedDiscordSubagent.mockClear();
     hookMocks.listThreadBindingsBySessionKey.mockClear();
     hookMocks.unbindThreadBindingsBySessionKey.mockClear();
   });
 
-  it("registers subagent hooks", () => {
-    const handlers = registerHandlersForTest();
-    expect(handlers.has("subagent_spawning")).toBe(true);
-    expect(handlers.has("subagent_delivery_target")).toBe(true);
-    expect(handlers.has("subagent_spawned")).toBe(false);
-    expect(handlers.has("subagent_ended")).toBe(true);
-  });
-
   it("binds thread routing on subagent_spawning", async () => {
     const handlers = registerHandlersForTest();
-    const handler = getRequiredHandler(handlers, "subagent_spawning");
+    const handler = getRequiredHookHandler(handlers, "subagent_spawning");
 
     const result = await handler(createSpawnEvent(), {});
 
     expect(hookMocks.autoBindSpawnedDiscordSubagent).toHaveBeenCalledTimes(1);
     expect(hookMocks.autoBindSpawnedDiscordSubagent).toHaveBeenCalledWith({
+      cfg: expect.objectContaining({
+        channels: expect.objectContaining({
+          discord: expect.objectContaining({
+            threadBindings: expect.objectContaining({
+              spawnSessions: true,
+            }),
+          }),
+        }),
+      }),
       accountId: "work",
       channel: "discord",
       to: "channel:123",
@@ -224,15 +236,51 @@ describe("discord subagent hook handlers", () => {
         channels: {
           discord: {
             threadBindings: {
-              spawnSubagentSessions: false,
+              spawnSessions: false,
             },
           },
         },
       },
-      errorContains: "spawnSubagentSessions=true",
+      errorContains: "spawnSessions=true",
     });
   });
 
+  it("honors defaultAccount policy when requester omits accountId", async () => {
+    await expectSubagentSpawningError({
+      config: {
+        channels: {
+          discord: {
+            defaultAccount: "work",
+            threadBindings: {
+              spawnSessions: true,
+            },
+            accounts: {
+              work: {
+                threadBindings: {
+                  spawnSessions: false,
+                },
+              },
+            },
+          },
+        },
+      },
+      event: createSpawnEvent({
+        requester: {
+          accountId: undefined,
+          channel: "discord",
+          to: "channel:123",
+          threadId: undefined,
+        },
+      }),
+      errorContains: "spawnSessions=true",
+    });
+    expect(hookMocks.resolveDiscordAccount).toHaveBeenCalledWith(
+      expect.objectContaining({
+        accountId: undefined,
+      }),
+    );
+  });
+
   it("returns error when global thread bindings are disabled", async () => {
     await expectSubagentSpawningError({
       config: {
@@ -244,7 +292,7 @@ describe("discord subagent hook handlers", () => {
         channels: {
           discord: {
             threadBindings: {
-              spawnSubagentSessions: true,
+              spawnSessions: true,
             },
           },
         },
@@ -266,7 +314,7 @@ describe("discord subagent hook handlers", () => {
             work: {
               threadBindings: {
                 enabled: true,
-                spawnSubagentSessions: true,
+                spawnSessions: true,
               },
             },
           },
@@ -278,16 +326,17 @@ describe("discord subagent hook handlers", () => {
     expect(result).toMatchObject({ status: "ok", threadBindingReady: true });
   });
 
-  it("defaults thread-bound subagent spawn to disabled when unset", async () => {
-    await expectSubagentSpawningError({
-      config: {
-        channels: {
-          discord: {
-            threadBindings: {},
-          },
+  it("defaults thread-bound subagent spawn to enabled when unset", async () => {
+    const result = await runSubagentSpawning({
+      channels: {
+        discord: {
+          threadBindings: {},
         },
       },
     });
+
+    expect(hookMocks.autoBindSpawnedDiscordSubagent).toHaveBeenCalledTimes(1);
+    expect(result).toMatchObject({ status: "ok", threadBindingReady: true });
   });
 
   it("no-ops when thread binding is requested on non-discord channel", async () => {
@@ -316,11 +365,11 @@ describe("discord subagent hook handlers", () => {
     expect(errorText).toMatch(/unable to create or bind/i);
   });
 
-  it("unbinds thread routing on subagent_ended", () => {
+  it("unbinds thread routing on subagent_ended", async () => {
     const handlers = registerHandlersForTest();
-    const handler = getRequiredHandler(handlers, "subagent_ended");
+    const handler = getRequiredHookHandler(handlers, "subagent_ended");
 
-    handler(
+    await handler(
       {
         targetSessionKey: "agent:main:subagent:child",
         targetKind: "subagent",
@@ -341,11 +390,11 @@ describe("discord subagent hook handlers", () => {
     });
   });
 
-  it("resolves delivery target from matching bound thread", () => {
+  it("resolves delivery target from matching bound thread", async () => {
     hookMocks.listThreadBindingsBySessionKey.mockReturnValueOnce([
       { accountId: "work", threadId: "777" },
     ]);
-    const result = resolveSubagentDeliveryTargetForTest({
+    const result = await resolveSubagentDeliveryTargetForTest({
       channel: "discord",
       accountId: "work",
       to: "channel:123",
@@ -367,12 +416,12 @@ describe("discord subagent hook handlers", () => {
     });
   });
 
-  it("keeps original routing when delivery target is ambiguous", () => {
+  it("keeps original routing when delivery target is ambiguous", async () => {
     hookMocks.listThreadBindingsBySessionKey.mockReturnValueOnce([
       { accountId: "work", threadId: "777" },
       { accountId: "work", threadId: "888" },
     ]);
-    const result = resolveSubagentDeliveryTargetForTest({
+    const result = await resolveSubagentDeliveryTargetForTest({
       channel: "discord",
       accountId: "work",
       to: "channel:123",