@openclaw/discord 2026.5.2 → 2026.5.3-beta.2

package/src/monitor/message-handler.queue.test.ts

@@ -1,496 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { DiscordRetryableInboundError } from "./inbound-dedupe.js";
-import {
-  createDiscordMessageHandler,
-  preflightDiscordMessageMock,
-  processDiscordMessageMock,
-} from "./message-handler.module-test-helpers.js";
-import {
-  createDiscordHandlerParams,
-  createDiscordPreflightContext,
-} from "./message-handler.test-helpers.js";
-
-type SetStatusFn = (patch: Record<string, unknown>) => void;
-function createDeferred<T = void>() {
-  let resolve: (value: T | PromiseLike<T>) => void = () => {};
-  const promise = new Promise<T>((innerResolve) => {
-    resolve = innerResolve;
-  });
-  return { promise, resolve };
-}
-
-async function flushQueueWork(): Promise<void> {
-  for (let i = 0; i < 40; i += 1) {
-    await Promise.resolve();
-  }
-}
-
-function createMessageData(messageId: string, channelId = "ch-1") {
-  return {
-    channel_id: channelId,
-    author: { id: "user-1" },
-    message: {
-      id: messageId,
-      author: { id: "user-1", bot: false },
-      content: "hello",
-      channel_id: channelId,
-      attachments: [{ id: `att-${messageId}` }],
-    },
-  };
-}
-
-function createPreflightContext(channelId = "ch-1") {
-  return {
-    ...createDiscordPreflightContext(channelId),
-    accountId: "default",
-    token: "test-token",
-    textLimit: 2_000,
-    replyToMode: "off" as const,
-    discordConfig: {
-      enabled: true,
-      token: "test-token",
-      groupPolicy: "allowlist" as const,
-    },
-  };
-}
-
-function createHandlerWithDefaultPreflight(overrides?: { setStatus?: SetStatusFn }) {
-  preflightDiscordMessageMock.mockImplementation(async (params: { data: { channel_id: string } }) =>
-    createPreflightContext(params.data.channel_id),
-  );
-  return createDiscordMessageHandler(createDiscordHandlerParams(overrides));
-}
-
-function installDefaultDiscordPreflight() {
-  preflightDiscordMessageMock.mockImplementation(async (params: { data: { channel_id: string } }) =>
-    createPreflightContext(params.data.channel_id),
-  );
-}
-
-async function createLifecycleStopScenario(params: {
-  createHandler: (status: SetStatusFn) => {
-    handler: (data: never, opts: never) => Promise<void>;
-    stop: () => void;
-  };
-}) {
-  preflightDiscordMessageMock.mockImplementation(
-    async (preflightParams: { data: { channel_id: string } }) =>
-      createPreflightContext(preflightParams.data.channel_id),
-  );
-  const runInFlight = createDeferred();
-  processDiscordMessageMock.mockImplementation(async () => {
-    await runInFlight.promise;
-  });
-
-  const setStatus = vi.fn<SetStatusFn>();
-  const { handler, stop } = params.createHandler(setStatus);
-
-  await expect(handler(createMessageData("m-1") as never, {} as never)).resolves.toBeUndefined();
-  await flushQueueWork();
-  expect(processDiscordMessageMock).toHaveBeenCalledTimes(1);
-
-  const callsBeforeStop = setStatus.mock.calls.length;
-  stop();
-
-  return {
-    setStatus,
-    callsBeforeStop,
-    finish: async () => {
-      runInFlight.resolve();
-      await runInFlight.promise;
-      await Promise.resolve();
-    },
-  };
-}
-
-describe("createDiscordMessageHandler queue behavior", () => {
-  it("resets busy counters when the handler is created", () => {
-    preflightDiscordMessageMock.mockReset();
-    processDiscordMessageMock.mockReset();
-
-    const setStatus = vi.fn();
-    createDiscordMessageHandler(createDiscordHandlerParams({ setStatus }));
-
-    expect(setStatus).toHaveBeenCalledWith(
-      expect.objectContaining({
-        activeRuns: 0,
-        busy: false,
-      }),
-    );
-  });
-
-  it("returns immediately and tracks busy status while queued runs execute", async () => {
-    preflightDiscordMessageMock.mockReset();
-    processDiscordMessageMock.mockReset();
-
-    const firstRun = createDeferred();
-    const secondRun = createDeferred();
-    processDiscordMessageMock
-      .mockImplementationOnce(async () => {
-        await firstRun.promise;
-      })
-      .mockImplementationOnce(async () => {
-        await secondRun.promise;
-      });
-    const setStatus = vi.fn();
-    const handler = createHandlerWithDefaultPreflight({ setStatus });
-
-    await expect(handler(createMessageData("m-1") as never, {} as never)).resolves.toBeUndefined();
-
-    await flushQueueWork();
-    expect(processDiscordMessageMock).toHaveBeenCalledTimes(1);
-    expect(setStatus).toHaveBeenCalledWith(
-      expect.objectContaining({
-        activeRuns: 1,
-        busy: true,
-      }),
-    );
-
-    await expect(handler(createMessageData("m-2") as never, {} as never)).resolves.toBeUndefined();
-
-    await flushQueueWork();
-    expect(preflightDiscordMessageMock).toHaveBeenCalledTimes(2);
-    expect(processDiscordMessageMock).toHaveBeenCalledTimes(1);
-
-    firstRun.resolve();
-    await firstRun.promise;
-
-    await flushQueueWork();
-    expect(processDiscordMessageMock).toHaveBeenCalledTimes(2);
-
-    secondRun.resolve();
-    await secondRun.promise;
-
-    await flushQueueWork();
-    expect(setStatus).toHaveBeenLastCalledWith(
-      expect.objectContaining({
-        activeRuns: 0,
-        busy: false,
-      }),
-    );
-  });
-
-  it("drops duplicate inbound message deliveries before they reach preflight", async () => {
-    preflightDiscordMessageMock.mockReset();
-    processDiscordMessageMock.mockReset();
-
-    const handler = createHandlerWithDefaultPreflight();
-    const duplicate = createMessageData("m-dup");
-
-    await expect(handler(duplicate as never, {} as never)).resolves.toBeUndefined();
-    await expect(handler(duplicate as never, {} as never)).resolves.toBeUndefined();
-
-    await flushQueueWork();
-    expect(processDiscordMessageMock).toHaveBeenCalledTimes(1);
-    expect(preflightDiscordMessageMock).toHaveBeenCalledTimes(1);
-  });
-
-  it("retries duplicate deliveries after an explicit retryable worker failure", async () => {
-    preflightDiscordMessageMock.mockReset();
-    processDiscordMessageMock.mockReset();
-
-    processDiscordMessageMock
-      .mockRejectedValueOnce(new DiscordRetryableInboundError("retry me"))
-      .mockResolvedValueOnce(undefined);
-    const params = createDiscordHandlerParams();
-    const handler = createDiscordMessageHandler(params);
-    installDefaultDiscordPreflight();
-    const duplicate = createMessageData("m-retry");
-
-    await expect(handler(duplicate as never, {} as never)).resolves.toBeUndefined();
-    await flushQueueWork();
-    expect(processDiscordMessageMock).toHaveBeenCalledTimes(1);
-    expect(params.runtime.error).toHaveBeenCalledWith(
-      expect.stringContaining("discord message run failed: DiscordRetryableInboundError: retry me"),
-    );
-
-    await expect(handler(duplicate as never, {} as never)).resolves.toBeUndefined();
-    await flushQueueWork();
-    expect(processDiscordMessageMock).toHaveBeenCalledTimes(2);
-    expect(preflightDiscordMessageMock).toHaveBeenCalledTimes(2);
-  });
-
-  it("keeps replay committed after a non-retryable worker failure", async () => {
-    preflightDiscordMessageMock.mockReset();
-    processDiscordMessageMock.mockReset();
-
-    const visibleSideEffect = vi.fn();
-    processDiscordMessageMock.mockImplementationOnce(async () => {
-      visibleSideEffect();
-      throw new Error("post-send failure");
-    });
-    const params = createDiscordHandlerParams();
-    const handler = createDiscordMessageHandler(params);
-    installDefaultDiscordPreflight();
-    const duplicate = createMessageData("m-fail");
-
-    await expect(handler(duplicate as never, {} as never)).resolves.toBeUndefined();
-    await flushQueueWork();
-    expect(processDiscordMessageMock).toHaveBeenCalledTimes(1);
-    expect(params.runtime.error).toHaveBeenCalledWith(
-      expect.stringContaining("discord message run failed: Error: post-send failure"),
-    );
-
-    await expect(handler(duplicate as never, {} as never)).resolves.toBeUndefined();
-    await Promise.resolve();
-
-    expect(processDiscordMessageMock).toHaveBeenCalledTimes(1);
-    expect(preflightDiscordMessageMock).toHaveBeenCalledTimes(1);
-    expect(visibleSideEffect).toHaveBeenCalledTimes(1);
-  });
-
-  it("does not abort long queued runs with a Discord-owned channel timeout", async () => {
-    vi.useFakeTimers();
-    try {
-      preflightDiscordMessageMock.mockReset();
-      processDiscordMessageMock.mockReset();
-
-      const firstRun = createDeferred();
-      const secondRun = createDeferred();
-      const capturedAbortSignals: Array<AbortSignal | undefined> = [];
-      processDiscordMessageMock.mockImplementationOnce(
-        async (ctx: { abortSignal?: AbortSignal }) => {
-          capturedAbortSignals.push(ctx.abortSignal);
-          await firstRun.promise;
-        },
-      );
-      processDiscordMessageMock.mockImplementationOnce(
-        async (ctx: { abortSignal?: AbortSignal }) => {
-          capturedAbortSignals.push(ctx.abortSignal);
-          await secondRun.promise;
-        },
-      );
-      installDefaultDiscordPreflight();
-      const params = createDiscordHandlerParams();
-      const handler = createDiscordMessageHandler(params);
-
-      await expect(
-        handler(createMessageData("m-1") as never, {} as never),
-      ).resolves.toBeUndefined();
-      await expect(
-        handler(createMessageData("m-2") as never, {} as never),
-      ).resolves.toBeUndefined();
-      await flushQueueWork();
-      expect(processDiscordMessageMock).toHaveBeenCalledTimes(1);
-
-      await vi.advanceTimersByTimeAsync(60_000);
-      await flushQueueWork();
-
-      expect(processDiscordMessageMock).toHaveBeenCalledTimes(1);
-      expect(capturedAbortSignals[0]?.aborted).not.toBe(true);
-      expect(params.runtime.error).not.toHaveBeenCalledWith(expect.stringContaining("timed out"));
-
-      firstRun.resolve();
-      await firstRun.promise;
-      await flushQueueWork();
-
-      expect(processDiscordMessageMock).toHaveBeenCalledTimes(2);
-      expect(capturedAbortSignals[1]?.aborted).not.toBe(true);
-
-      secondRun.resolve();
-      await secondRun.promise;
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-
-  it("refreshes run activity while active runs are in progress", async () => {
-    preflightDiscordMessageMock.mockReset();
-    processDiscordMessageMock.mockReset();
-
-    const runInFlight = createDeferred();
-    processDiscordMessageMock.mockImplementation(async () => {
-      await runInFlight.promise;
-    });
-    preflightDiscordMessageMock.mockImplementation(
-      async (params: { data: { channel_id: string } }) =>
-        createPreflightContext(params.data.channel_id),
-    );
-
-    let heartbeatTick: () => void = () => {};
-    let capturedHeartbeat = false;
-    const setIntervalSpy = vi
-      .spyOn(globalThis, "setInterval")
-      .mockImplementation((callback: TimerHandler) => {
-        if (typeof callback === "function") {
-          heartbeatTick = () => {
-            callback();
-          };
-          capturedHeartbeat = true;
-        }
-        return 1 as unknown as ReturnType<typeof setInterval>;
-      });
-    const clearIntervalSpy = vi.spyOn(globalThis, "clearInterval");
-
-    try {
-      const setStatus = vi.fn();
-      const handler = createDiscordMessageHandler(createDiscordHandlerParams({ setStatus }));
-      await expect(
-        handler(createMessageData("m-1") as never, {} as never),
-      ).resolves.toBeUndefined();
-
-      await flushQueueWork();
-      expect(processDiscordMessageMock).toHaveBeenCalledTimes(1);
-
-      expect(capturedHeartbeat).toBe(true);
-      const busyCallsBefore = setStatus.mock.calls.filter(
-        ([patch]) => (patch as { busy?: boolean }).busy === true,
-      ).length;
-
-      heartbeatTick();
-
-      const busyCallsAfter = setStatus.mock.calls.filter(
-        ([patch]) => (patch as { busy?: boolean }).busy === true,
-      ).length;
-      expect(busyCallsAfter).toBeGreaterThan(busyCallsBefore);
-
-      runInFlight.resolve();
-      await runInFlight.promise;
-
-      await flushQueueWork();
-      expect(clearIntervalSpy).toHaveBeenCalled();
-    } finally {
-      setIntervalSpy.mockRestore();
-      clearIntervalSpy.mockRestore();
-    }
-  });
-
-  it("stops status publishing after lifecycle abort", async () => {
-    preflightDiscordMessageMock.mockReset();
-    processDiscordMessageMock.mockReset();
-
-    const { setStatus, callsBeforeStop, finish } = await createLifecycleStopScenario({
-      createHandler: (status) => {
-        const abortController = new AbortController();
-        const handler = createDiscordMessageHandler(
-          createDiscordHandlerParams({ setStatus: status, abortSignal: abortController.signal }),
-        );
-        return { handler, stop: () => abortController.abort() };
-      },
-    });
-
-    await finish();
-    expect(setStatus.mock.calls.length).toBe(callsBeforeStop);
-  });
-
-  it("stops status publishing after handler deactivation", async () => {
-    preflightDiscordMessageMock.mockReset();
-    processDiscordMessageMock.mockReset();
-
-    const { setStatus, callsBeforeStop, finish } = await createLifecycleStopScenario({
-      createHandler: (status) => {
-        const handler = createDiscordMessageHandler(
-          createDiscordHandlerParams({ setStatus: status }),
-        );
-        return { handler, stop: () => handler.deactivate() };
-      },
-    });
-
-    await finish();
-    expect(setStatus.mock.calls.length).toBe(callsBeforeStop);
-  });
-
-  it("skips queued runs that have not started yet after deactivation", async () => {
-    preflightDiscordMessageMock.mockReset();
-    processDiscordMessageMock.mockReset();
-
-    const firstRun = createDeferred();
-    processDiscordMessageMock
-      .mockImplementationOnce(async () => {
-        await firstRun.promise;
-      })
-      .mockImplementationOnce(async () => undefined);
-    preflightDiscordMessageMock.mockImplementation(
-      async (params: { data: { channel_id: string } }) =>
-        createPreflightContext(params.data.channel_id),
-    );
-
-    const handler = createDiscordMessageHandler(createDiscordHandlerParams());
-    await expect(handler(createMessageData("m-1") as never, {} as never)).resolves.toBeUndefined();
-    await flushQueueWork();
-    expect(processDiscordMessageMock).toHaveBeenCalledTimes(1);
-
-    await expect(handler(createMessageData("m-2") as never, {} as never)).resolves.toBeUndefined();
-    handler.deactivate();
-
-    firstRun.resolve();
-    await firstRun.promise;
-    await Promise.resolve();
-
-    expect(processDiscordMessageMock).toHaveBeenCalledTimes(1);
-  });
-
-  it("preserves non-debounced message ordering by awaiting debouncer enqueue", async () => {
-    preflightDiscordMessageMock.mockReset();
-    processDiscordMessageMock.mockReset();
-
-    const firstPreflight = createDeferred();
-    const processedMessageIds: string[] = [];
-
-    preflightDiscordMessageMock.mockImplementation(
-      async (params: { data: { channel_id: string; message?: { id?: string } } }) => {
-        const messageId = params.data.message?.id ?? "unknown";
-        if (messageId === "m-1") {
-          await firstPreflight.promise;
-        }
-        return {
-          ...createPreflightContext(params.data.channel_id),
-          messageId,
-        };
-      },
-    );
-
-    processDiscordMessageMock.mockImplementation(async (ctx: { messageId?: string }) => {
-      processedMessageIds.push(ctx.messageId ?? "unknown");
-    });
-
-    const handler = createDiscordMessageHandler(createDiscordHandlerParams());
-
-    const sequentialDispatch = (async () => {
-      await handler(createMessageData("m-1") as never, {} as never);
-      await handler(createMessageData("m-2") as never, {} as never);
-    })();
-
-    await flushQueueWork();
-    expect(preflightDiscordMessageMock).toHaveBeenCalledTimes(1);
-    await Promise.resolve();
-    expect(preflightDiscordMessageMock).toHaveBeenCalledTimes(1);
-
-    firstPreflight.resolve();
-    await sequentialDispatch;
-
-    await flushQueueWork();
-    expect(processDiscordMessageMock).toHaveBeenCalledTimes(2);
-    expect(processedMessageIds).toEqual(["m-1", "m-2"]);
-  });
-
-  it("recovers queue progress after a run failure without leaving busy state stuck", async () => {
-    preflightDiscordMessageMock.mockReset();
-    processDiscordMessageMock.mockReset();
-
-    const firstRun = createDeferred();
-    processDiscordMessageMock
-      .mockImplementationOnce(async () => {
-        await firstRun.promise;
-        throw new Error("simulated run failure");
-      })
-      .mockImplementationOnce(async () => undefined);
-    preflightDiscordMessageMock.mockImplementation(
-      async (params: { data: { channel_id: string } }) =>
-        createPreflightContext(params.data.channel_id),
-    );
-
-    const setStatus = vi.fn();
-    const handler = createHandlerWithDefaultPreflight({ setStatus });
-
-    await expect(handler(createMessageData("m-1") as never, {} as never)).resolves.toBeUndefined();
-    await expect(handler(createMessageData("m-2") as never, {} as never)).resolves.toBeUndefined();
-
-    firstRun.resolve();
-    await firstRun.promise.catch(() => undefined);
-
-    await flushQueueWork();
-    expect(processDiscordMessageMock).toHaveBeenCalledTimes(2);
-    expect(setStatus).toHaveBeenCalledWith(expect.objectContaining({ activeRuns: 0, busy: false }));
-  });
-});

package/src/monitor/message-handler.routing-preflight.ts

@@ -1,112 +0,0 @@
-import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
-import { resolveDiscordConversationIdentity } from "../conversation-identity.js";
-import type { User } from "../internal/discord.js";
-import type { DiscordMessagePreflightParams } from "./message-handler.preflight.types.js";
-import {
-  buildDiscordRoutePeer,
-  resolveDiscordConversationRoute,
-  resolveDiscordEffectiveRoute,
-  shouldIgnoreStaleDiscordRouteBinding,
-} from "./route-resolution.js";
-
-let conversationRuntimePromise:
-  | Promise<typeof import("openclaw/plugin-sdk/conversation-binding-runtime")>
-  | undefined;
-
-async function loadConversationRuntime() {
-  conversationRuntimePromise ??= import("openclaw/plugin-sdk/conversation-binding-runtime");
-  return await conversationRuntimePromise;
-}
-
-export async function resolveDiscordPreflightRoute(params: {
-  preflight: DiscordMessagePreflightParams;
-  author: User;
-  isDirectMessage: boolean;
-  isGroupDm: boolean;
-  messageChannelId: string;
-  memberRoleIds: string[];
-  earlyThreadParentId?: string;
-}) {
-  const conversationRuntime = await loadConversationRuntime();
-  const route = resolveDiscordConversationRoute({
-    cfg: params.preflight.cfg,
-    accountId: params.preflight.accountId,
-    guildId: params.preflight.data.guild_id ?? undefined,
-    memberRoleIds: params.memberRoleIds,
-    peer: buildDiscordRoutePeer({
-      isDirectMessage: params.isDirectMessage,
-      isGroupDm: params.isGroupDm,
-      directUserId: params.author.id,
-      conversationId: params.messageChannelId,
-    }),
-    parentConversationId: params.earlyThreadParentId,
-  });
-  const bindingConversationId = params.isDirectMessage
-    ? (resolveDiscordConversationIdentity({
-        isDirectMessage: true,
-        userId: params.author.id,
-      }) ?? `user:${params.author.id}`)
-    : params.messageChannelId;
-  let runtimeRoute = conversationRuntime.resolveRuntimeConversationBindingRoute({
-    route,
-    conversation: {
-      channel: "discord",
-      accountId: params.preflight.accountId,
-      conversationId: bindingConversationId,
-      parentConversationId: params.earlyThreadParentId,
-    },
-  });
-  if (
-    shouldIgnoreStaleDiscordRouteBinding({
-      bindingRecord: runtimeRoute.bindingRecord,
-      route,
-    })
-  ) {
-    logVerbose(
-      `discord: ignoring stale route binding for conversation ${bindingConversationId} (${runtimeRoute.bindingRecord?.targetSessionKey} -> ${route.sessionKey})`,
-    );
-    runtimeRoute = {
-      bindingRecord: null,
-      route,
-    };
-  }
-  let threadBinding = runtimeRoute.bindingRecord ?? undefined;
-  const configuredRoute =
-    threadBinding == null
-      ? conversationRuntime.resolveConfiguredBindingRoute({
-          cfg: params.preflight.cfg,
-          route,
-          conversation: {
-            channel: "discord",
-            accountId: params.preflight.accountId,
-            conversationId: params.messageChannelId,
-            parentConversationId: params.earlyThreadParentId,
-          },
-        })
-      : null;
-  const configuredBinding = configuredRoute?.bindingResolution ?? null;
-  if (!threadBinding && configuredBinding) {
-    threadBinding = configuredBinding.record;
-  }
-  const boundSessionKey = conversationRuntime.isPluginOwnedSessionBindingRecord(threadBinding)
-    ? ""
-    : (runtimeRoute.boundSessionKey ?? threadBinding?.targetSessionKey?.trim());
-  const effectiveRoute = runtimeRoute.boundSessionKey
-    ? runtimeRoute.route
-    : resolveDiscordEffectiveRoute({
-        route,
-        boundSessionKey,
-        configuredRoute,
-        matchedBy: "binding.channel",
-      });
-
-  return {
-    conversationRuntime,
-    threadBinding,
-    configuredBinding,
-    boundSessionKey,
-    effectiveRoute,
-    boundAgentId: boundSessionKey ? effectiveRoute.agentId : undefined,
-    baseSessionKey: effectiveRoute.sessionKey,
-  };
-}

package/src/monitor/message-handler.test-harness.ts

@@ -1,99 +0,0 @@
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import type { DiscordMessagePreflightContext } from "./message-handler.preflight.js";
-import { createNoopThreadBindingManager } from "./thread-bindings.js";
-
-export async function createBaseDiscordMessageContext(
-  overrides: Record<string, unknown> = {},
-): Promise<DiscordMessagePreflightContext> {
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-discord-"));
-  const storePath = path.join(dir, "sessions.json");
-  return {
-    cfg: { messages: { ackReaction: "👀" }, session: { store: storePath } },
-    discordConfig: {},
-    accountId: "default",
-    token: "token",
-    runtime: { log: () => {}, error: () => {} },
-    guildHistories: new Map(),
-    historyLimit: 0,
-    mediaMaxBytes: 1024,
-    textLimit: 4000,
-    sender: { label: "user" },
-    replyToMode: "off",
-    ackReactionScope: "group-mentions",
-    groupPolicy: "open",
-    data: { guild: { id: "g1", name: "Guild" } },
-    client: { rest: {} },
-    message: {
-      id: "m1",
-      channelId: "c1",
-      timestamp: new Date().toISOString(),
-      attachments: [],
-    },
-    messageChannelId: "c1",
-    author: {
-      id: "U1",
-      username: "alice",
-      discriminator: "0",
-      globalName: "Alice",
-    },
-    channelInfo: { name: "general" },
-    channelName: "general",
-    isGuildMessage: true,
-    isDirectMessage: false,
-    isGroupDm: false,
-    commandAuthorized: true,
-    baseText: "hi",
-    messageText: "hi",
-    wasMentioned: false,
-    shouldRequireMention: true,
-    canDetectMention: true,
-    effectiveWasMentioned: true,
-    shouldBypassMention: false,
-    threadChannel: null,
-    threadParentId: undefined,
-    threadParentName: undefined,
-    threadParentType: undefined,
-    threadName: undefined,
-    displayChannelSlug: "general",
-    guildInfo: null,
-    guildSlug: "guild",
-    channelConfig: null,
-    baseSessionKey: "agent:main:discord:guild:g1",
-    route: {
-      agentId: "main",
-      channel: "discord",
-      accountId: "default",
-      sessionKey: "agent:main:discord:guild:g1",
-      mainSessionKey: "agent:main:main",
-    },
-    threadBindings: createNoopThreadBindingManager("default"),
-    ...overrides,
-  } as unknown as DiscordMessagePreflightContext;
-}
-
-export function createDiscordDirectMessageContextOverrides(): Record<string, unknown> {
-  return {
-    data: { guild: null },
-    channelInfo: null,
-    channelName: undefined,
-    isGuildMessage: false,
-    isDirectMessage: true,
-    isGroupDm: false,
-    shouldRequireMention: false,
-    canDetectMention: false,
-    effectiveWasMentioned: false,
-    displayChannelSlug: "",
-    guildInfo: null,
-    guildSlug: "",
-    baseSessionKey: "agent:main:discord:direct:u1",
-    route: {
-      agentId: "main",
-      channel: "discord",
-      accountId: "default",
-      sessionKey: "agent:main:discord:direct:u1",
-      mainSessionKey: "agent:main:main",
-    },
-  };
-}