@openclaw/discord 2026.3.13 → 2026.5.2-beta.1

package/src/outbound-adapter.ts

@@ -0,0 +1,291 @@
+import {
+  type ChannelOutboundAdapter,
+  createAttachedChannelResultAdapter,
+} from "openclaw/plugin-sdk/channel-send-result";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
+import type { OutboundIdentity } from "openclaw/plugin-sdk/outbound-runtime";
+import { resolveOutboundSendDep } from "openclaw/plugin-sdk/outbound-send-deps";
+import {
+  normalizeOptionalString,
+  normalizeOptionalStringifiedId,
+} from "openclaw/plugin-sdk/text-runtime";
+import { chunkDiscordTextWithMode } from "./chunk.js";
+import { withDiscordDeliveryRetry } from "./delivery-retry.js";
+import { isLikelyDiscordVideoMedia } from "./media-detection.js";
+import type { ThreadBindingRecord } from "./monitor/thread-bindings.js";
+import { normalizeDiscordOutboundTarget } from "./normalize.js";
+import { normalizeDiscordApprovalPayload } from "./outbound-approval.js";
+import { buildDiscordPresentationPayload } from "./outbound-components.js";
+import { sendDiscordOutboundPayload } from "./outbound-payload.js";
+import {
+  loadDiscordSendRuntime,
+  resolveDiscordFormattingOptions,
+  resolveDiscordOutboundTarget,
+  type DiscordSendFn,
+  type DiscordVoiceSendFn,
+} from "./outbound-send-context.js";
+
+export const DISCORD_TEXT_CHUNK_LIMIT = 2000;
+const DISCORD_INTERNAL_RUNTIME_SCAFFOLDING_BLOCK_RE =
+  /<\s*(system-reminder|previous_response)\b[^>]*>[\s\S]*?<\s*\/\s*\1\s*>/gi;
+const DISCORD_INTERNAL_RUNTIME_SCAFFOLDING_SELF_CLOSING_RE =
+  /<\s*(?:system-reminder|previous_response)\b[^>]*\/\s*>/gi;
+const DISCORD_INTERNAL_RUNTIME_SCAFFOLDING_TAG_RE =
+  /<\s*\/?\s*(?:system-reminder|previous_response)\b[^>]*>/gi;
+
+function stripDiscordInternalRuntimeScaffolding(text: string): string {
+  return text
+    .replace(DISCORD_INTERNAL_RUNTIME_SCAFFOLDING_BLOCK_RE, "")
+    .replace(DISCORD_INTERNAL_RUNTIME_SCAFFOLDING_SELF_CLOSING_RE, "")
+    .replace(DISCORD_INTERNAL_RUNTIME_SCAFFOLDING_TAG_RE, "");
+}
+
+type DiscordThreadBindingsModule = typeof import("./monitor/thread-bindings.js");
+
+let discordThreadBindingsPromise: Promise<DiscordThreadBindingsModule> | undefined;
+
+function loadDiscordThreadBindings(): Promise<DiscordThreadBindingsModule> {
+  discordThreadBindingsPromise ??= import("./monitor/thread-bindings.js");
+  return discordThreadBindingsPromise;
+}
+
+function resolveDiscordWebhookIdentity(params: {
+  identity?: OutboundIdentity;
+  binding: ThreadBindingRecord;
+}): { username?: string; avatarUrl?: string } {
+  const usernameRaw = normalizeOptionalString(params.identity?.name);
+  const fallbackUsername = normalizeOptionalString(params.binding.label) ?? params.binding.agentId;
+  const username = (usernameRaw || fallbackUsername || "").slice(0, 80) || undefined;
+  const avatarUrl = normalizeOptionalString(params.identity?.avatarUrl);
+  return { username, avatarUrl };
+}
+
+async function maybeSendDiscordWebhookText(params: {
+  cfg: OpenClawConfig;
+  text: string;
+  threadId?: string | number | null;
+  accountId?: string | null;
+  identity?: OutboundIdentity;
+  replyToId?: string | null;
+}): Promise<{ messageId: string; channelId: string } | null> {
+  if (params.threadId == null) {
+    return null;
+  }
+  const threadId = normalizeOptionalStringifiedId(params.threadId) ?? "";
+  if (!threadId) {
+    return null;
+  }
+  const { getThreadBindingManager } = await loadDiscordThreadBindings();
+  const manager = getThreadBindingManager(params.accountId ?? undefined);
+  if (!manager) {
+    return null;
+  }
+  const binding = manager.getByThreadId(threadId);
+  if (!binding?.webhookId || !binding?.webhookToken) {
+    return null;
+  }
+  const persona = resolveDiscordWebhookIdentity({
+    identity: params.identity,
+    binding,
+  });
+  const { sendWebhookMessageDiscord } = await loadDiscordSendRuntime();
+  const result = await sendWebhookMessageDiscord(params.text, {
+    webhookId: binding.webhookId,
+    webhookToken: binding.webhookToken,
+    accountId: binding.accountId,
+    threadId: binding.threadId,
+    cfg: params.cfg,
+    replyTo: params.replyToId ?? undefined,
+    username: persona.username,
+    avatarUrl: persona.avatarUrl,
+  });
+  return result;
+}
+
+export const discordOutbound: ChannelOutboundAdapter = {
+  deliveryMode: "direct",
+  chunker: (text, limit, ctx) =>
+    chunkDiscordTextWithMode(text, {
+      maxChars: limit,
+      maxLines: ctx?.formatting?.maxLinesPerMessage,
+    }),
+  textChunkLimit: DISCORD_TEXT_CHUNK_LIMIT,
+  sanitizeText: ({ text }) => stripDiscordInternalRuntimeScaffolding(text),
+  pollMaxOptions: 10,
+  normalizePayload: ({ payload }) => normalizeDiscordApprovalPayload(payload),
+  presentationCapabilities: {
+    supported: true,
+    buttons: true,
+    selects: true,
+    context: true,
+    divider: true,
+  },
+  renderPresentation: async ({ payload, presentation }) => {
+    return await buildDiscordPresentationPayload({
+      payload,
+      presentation,
+    });
+  },
+  resolveTarget: ({ to, allowFrom }) => normalizeDiscordOutboundTarget(to, allowFrom),
+  sendPayload: async (ctx) =>
+    await sendDiscordOutboundPayload({
+      ctx,
+      fallbackAdapter: discordOutbound,
+    }),
+  ...createAttachedChannelResultAdapter({
+    channel: "discord",
+    sendText: async ({
+      cfg,
+      to,
+      text,
+      accountId,
+      deps,
+      replyToId,
+      threadId,
+      identity,
+      silent,
+      formatting,
+    }) => {
+      if (!silent) {
+        const webhookResult = await maybeSendDiscordWebhookText({
+          cfg,
+          text,
+          threadId,
+          accountId,
+          identity,
+          replyToId,
+        }).catch(() => null);
+        if (webhookResult) {
+          return webhookResult;
+        }
+      }
+      const send =
+        resolveOutboundSendDep<DiscordSendFn>(deps, "discord") ??
+        (await loadDiscordSendRuntime()).sendMessageDiscord;
+      return await withDiscordDeliveryRetry({
+        cfg,
+        accountId,
+        fn: async () =>
+          await send(resolveDiscordOutboundTarget({ to, threadId }), text, {
+            verbose: false,
+            replyTo: replyToId ?? undefined,
+            accountId: accountId ?? undefined,
+            silent: silent ?? undefined,
+            cfg,
+            ...resolveDiscordFormattingOptions({ formatting }),
+          }),
+      });
+    },
+    sendMedia: async ({
+      cfg,
+      to,
+      text,
+      mediaUrl,
+      audioAsVoice,
+      mediaAccess,
+      mediaLocalRoots,
+      mediaReadFile,
+      accountId,
+      deps,
+      replyToId,
+      threadId,
+      silent,
+      formatting,
+    }) => {
+      const send =
+        resolveOutboundSendDep<DiscordSendFn>(deps, "discord") ??
+        (await loadDiscordSendRuntime()).sendMessageDiscord;
+      const target = resolveDiscordOutboundTarget({ to, threadId });
+      const formattingOptions = resolveDiscordFormattingOptions({ formatting });
+      if (audioAsVoice && mediaUrl) {
+        const sendVoice =
+          resolveOutboundSendDep<DiscordVoiceSendFn>(deps, "discordVoice") ??
+          (await loadDiscordSendRuntime()).sendVoiceMessageDiscord;
+        return await withDiscordDeliveryRetry({
+          cfg,
+          accountId,
+          fn: async () =>
+            await sendVoice(target, mediaUrl, {
+              cfg,
+              replyTo: replyToId ?? undefined,
+              accountId: accountId ?? undefined,
+              silent: silent ?? undefined,
+            }),
+        });
+      }
+      if (text.trim() && mediaUrl && isLikelyDiscordVideoMedia(mediaUrl)) {
+        await withDiscordDeliveryRetry({
+          cfg,
+          accountId,
+          fn: async () =>
+            await send(target, text, {
+              verbose: false,
+              replyTo: replyToId ?? undefined,
+              accountId: accountId ?? undefined,
+              silent: silent ?? undefined,
+              cfg,
+              ...formattingOptions,
+            }),
+        });
+        return await withDiscordDeliveryRetry({
+          cfg,
+          accountId,
+          fn: async () =>
+            await send(target, "", {
+              verbose: false,
+              mediaUrl,
+              mediaAccess,
+              mediaLocalRoots,
+              mediaReadFile,
+              accountId: accountId ?? undefined,
+              silent: silent ?? undefined,
+              cfg,
+              ...formattingOptions,
+            }),
+        });
+      }
+      return await withDiscordDeliveryRetry({
+        cfg,
+        accountId,
+        fn: async () =>
+          await send(target, text, {
+            verbose: false,
+            mediaUrl,
+            mediaAccess,
+            mediaLocalRoots,
+            mediaReadFile,
+            replyTo: replyToId ?? undefined,
+            accountId: accountId ?? undefined,
+            silent: silent ?? undefined,
+            cfg,
+            ...formattingOptions,
+          }),
+      });
+    },
+    sendPoll: async ({ cfg, to, poll, accountId, threadId, silent }) =>
+      await withDiscordDeliveryRetry({
+        cfg,
+        accountId,
+        fn: async () =>
+          await (
+            await loadDiscordSendRuntime()
+          ).sendPollDiscord(resolveDiscordOutboundTarget({ to, threadId }), poll, {
+            accountId: accountId ?? undefined,
+            silent: silent ?? undefined,
+            cfg,
+          }),
+      }),
+  }),
+  afterDeliverPayload: async ({ target }) => {
+    const threadId = normalizeOptionalStringifiedId(target.threadId);
+    if (!threadId) {
+      return;
+    }
+    const { getThreadBindingManager } = await loadDiscordThreadBindings();
+    const manager = getThreadBindingManager(target.accountId ?? undefined);
+    if (!manager?.getByThreadId(threadId)) {
+      return;
+    }
+    manager.touchThread({ threadId });
+  },
+};

package/src/outbound-approval.ts

@@ -0,0 +1,29 @@
+function hasApprovalChannelData(payload: { channelData?: unknown }): boolean {
+  const channelData = payload.channelData;
+  if (!channelData || typeof channelData !== "object" || Array.isArray(channelData)) {
+    return false;
+  }
+  return Boolean((channelData as { execApproval?: unknown }).execApproval);
+}
+
+function neutralizeDiscordApprovalMentions(value: string): string {
+  return value
+    .replace(/@everyone/gi, "@\u200beveryone")
+    .replace(/@here/gi, "@\u200bhere")
+    .replace(/<@/g, "<@\u200b")
+    .replace(/<#/g, "<#\u200b");
+}
+
+export function normalizeDiscordApprovalPayload<
+  T extends {
+    text?: string;
+    channelData?: unknown;
+  },
+>(payload: T): T {
+  return hasApprovalChannelData(payload) && payload.text
+    ? {
+        ...payload,
+        text: neutralizeDiscordApprovalMentions(payload.text),
+      }
+    : payload;
+}

package/src/outbound-components.ts

@@ -0,0 +1,81 @@
+import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk/channel-send-result";
+import { readDiscordComponentSpec, type DiscordComponentMessageSpec } from "./components.js";
+
+type DiscordComponentSendFn = typeof import("./send.components.js").sendDiscordComponentMessage;
+type DiscordSharedInteractiveModule = typeof import("./shared-interactive.js");
+type OutboundPayload = Parameters<NonNullable<ChannelOutboundAdapter["sendPayload"]>>[0]["payload"];
+
+let discordComponentSendPromise: Promise<DiscordComponentSendFn> | undefined;
+let discordSharedInteractivePromise: Promise<DiscordSharedInteractiveModule> | undefined;
+
+export async function sendDiscordComponentMessageLazy(
+  ...args: Parameters<DiscordComponentSendFn>
+): ReturnType<DiscordComponentSendFn> {
+  discordComponentSendPromise ??= import("./send.components.js").then(
+    (module) => module.sendDiscordComponentMessage,
+  );
+  return await (
+    await discordComponentSendPromise
+  )(...args);
+}
+
+function loadDiscordSharedInteractive(): Promise<DiscordSharedInteractiveModule> {
+  discordSharedInteractivePromise ??= import("./shared-interactive.js");
+  return discordSharedInteractivePromise;
+}
+
+function addPayloadTextFallback(
+  spec: DiscordComponentMessageSpec,
+  payload: Pick<OutboundPayload, "text">,
+): DiscordComponentMessageSpec {
+  return spec.text
+    ? spec
+    : {
+        ...spec,
+        text: payload.text?.trim() ? payload.text : undefined,
+      };
+}
+
+export async function buildDiscordPresentationPayload(params: {
+  payload: Parameters<NonNullable<ChannelOutboundAdapter["renderPresentation"]>>[0]["payload"];
+  presentation: Parameters<
+    NonNullable<ChannelOutboundAdapter["renderPresentation"]>
+  >[0]["presentation"];
+}): Promise<typeof params.payload | null> {
+  const componentSpec = (await loadDiscordSharedInteractive()).buildDiscordPresentationComponents(
+    params.presentation,
+  );
+  if (!componentSpec) {
+    return null;
+  }
+  return {
+    ...params.payload,
+    channelData: {
+      ...params.payload.channelData,
+      discord: {
+        ...(params.payload.channelData?.discord as Record<string, unknown> | undefined),
+        presentationComponents: componentSpec,
+      },
+    },
+  };
+}
+
+export async function resolveDiscordComponentSpec(
+  payload: OutboundPayload,
+): Promise<DiscordComponentMessageSpec | undefined> {
+  const discordData = payload.channelData?.discord as
+    | { components?: unknown; presentationComponents?: DiscordComponentMessageSpec }
+    | undefined;
+  const rawComponentSpec =
+    discordData?.presentationComponents ?? readDiscordComponentSpec(discordData?.components);
+  if (rawComponentSpec) {
+    return addPayloadTextFallback(rawComponentSpec, payload);
+  }
+  if (!payload.interactive) {
+    return undefined;
+  }
+  const interactiveSpec = (await loadDiscordSharedInteractive()).buildDiscordInteractiveComponents(
+    payload.interactive,
+  );
+  return interactiveSpec ? addPayloadTextFallback(interactiveSpec, payload) : undefined;
+}

package/src/outbound-payload.contract.test.ts

@@ -0,0 +1,38 @@
+import {
+  installChannelOutboundPayloadContractSuite,
+  primeChannelOutboundSendMock,
+  type OutboundPayloadHarnessParams,
+} from "openclaw/plugin-sdk/channel-contract-testing";
+import { describe, vi } from "vitest";
+import { discordOutbound } from "./outbound-adapter.js";
+
+function createDiscordHarness(params: OutboundPayloadHarnessParams) {
+  const sendDiscord = vi.fn();
+  primeChannelOutboundSendMock(
+    sendDiscord,
+    { messageId: "dc-1", channelId: "123456" },
+    params.sendResults,
+  );
+  const ctx = {
+    cfg: {},
+    to: "channel:123456",
+    text: "",
+    payload: params.payload,
+    deps: {
+      sendDiscord,
+    },
+  };
+  return {
+    run: async () => await discordOutbound.sendPayload!(ctx),
+    sendMock: sendDiscord,
+    to: ctx.to,
+  };
+}
+
+describe("Discord outbound payload contract", () => {
+  installChannelOutboundPayloadContractSuite({
+    channel: "discord",
+    chunking: { mode: "split", longTextLength: 3000, maxChunkLength: 2000 },
+    createHarness: createDiscordHarness,
+  });
+});

package/src/outbound-payload.ts

@@ -0,0 +1,134 @@
+import {
+  attachChannelToResult,
+  type ChannelOutboundAdapter,
+} from "openclaw/plugin-sdk/channel-send-result";
+import {
+  resolvePayloadMediaUrls,
+  sendPayloadMediaSequenceOrFallback,
+  sendTextMediaPayload,
+} from "openclaw/plugin-sdk/reply-payload";
+import { normalizeDiscordApprovalPayload } from "./outbound-approval.js";
+import {
+  resolveDiscordComponentSpec,
+  sendDiscordComponentMessageLazy,
+} from "./outbound-components.js";
+import { createDiscordPayloadSendContext } from "./outbound-send-context.js";
+
+export async function sendDiscordOutboundPayload(params: {
+  ctx: Parameters<NonNullable<ChannelOutboundAdapter["sendPayload"]>>[0];
+  fallbackAdapter: ChannelOutboundAdapter;
+}): Promise<Awaited<ReturnType<NonNullable<ChannelOutboundAdapter["sendPayload"]>>>> {
+  const ctx = params.ctx;
+  const payload = normalizeDiscordApprovalPayload({
+    ...ctx.payload,
+    text: ctx.payload.text ?? "",
+  });
+  const mediaUrls = resolvePayloadMediaUrls(payload);
+  const sendContext = await createDiscordPayloadSendContext(ctx);
+
+  if (payload.audioAsVoice && mediaUrls.length > 0) {
+    let lastResult = await sendContext.withRetry(
+      async () =>
+        await sendContext.sendVoice(sendContext.target, mediaUrls[0], {
+          cfg: ctx.cfg,
+          replyTo: sendContext.resolveReplyTo(),
+          accountId: ctx.accountId ?? undefined,
+          silent: ctx.silent ?? undefined,
+        }),
+    );
+    if (payload.text?.trim()) {
+      lastResult = await sendContext.withRetry(
+        async () =>
+          await sendContext.send(sendContext.target, payload.text, {
+            verbose: false,
+            replyTo: sendContext.resolveReplyTo(),
+            accountId: ctx.accountId ?? undefined,
+            silent: ctx.silent ?? undefined,
+            cfg: ctx.cfg,
+            ...sendContext.formatting,
+          }),
+      );
+    }
+    for (const mediaUrl of mediaUrls.slice(1)) {
+      lastResult = await sendContext.withRetry(
+        async () =>
+          await sendContext.send(sendContext.target, "", {
+            verbose: false,
+            mediaUrl,
+            mediaAccess: ctx.mediaAccess,
+            mediaLocalRoots: ctx.mediaLocalRoots,
+            mediaReadFile: ctx.mediaReadFile,
+            replyTo: sendContext.resolveReplyTo(),
+            accountId: ctx.accountId ?? undefined,
+            silent: ctx.silent ?? undefined,
+            cfg: ctx.cfg,
+            ...sendContext.formatting,
+          }),
+      );
+    }
+    return attachChannelToResult("discord", lastResult);
+  }
+
+  const componentSpec = await resolveDiscordComponentSpec(payload);
+  if (!componentSpec) {
+    return await sendTextMediaPayload({
+      channel: "discord",
+      ctx: {
+        ...ctx,
+        payload,
+      },
+      adapter: params.fallbackAdapter,
+    });
+  }
+
+  const result = await sendPayloadMediaSequenceOrFallback({
+    text: payload.text ?? "",
+    mediaUrls,
+    fallbackResult: { messageId: "", channelId: sendContext.target },
+    sendNoMedia: async () =>
+      await sendContext.withRetry(
+        async () =>
+          await sendDiscordComponentMessageLazy(sendContext.target, componentSpec, {
+            replyTo: sendContext.resolveReplyTo(),
+            accountId: ctx.accountId ?? undefined,
+            silent: ctx.silent ?? undefined,
+            cfg: ctx.cfg,
+            ...sendContext.formatting,
+          }),
+      ),
+    send: async ({ text, mediaUrl, isFirst }) => {
+      if (isFirst) {
+        return await sendContext.withRetry(
+          async () =>
+            await sendDiscordComponentMessageLazy(sendContext.target, componentSpec, {
+              mediaUrl,
+              mediaAccess: ctx.mediaAccess,
+              mediaLocalRoots: ctx.mediaLocalRoots,
+              mediaReadFile: ctx.mediaReadFile,
+              replyTo: sendContext.resolveReplyTo(),
+              accountId: ctx.accountId ?? undefined,
+              silent: ctx.silent ?? undefined,
+              cfg: ctx.cfg,
+              ...sendContext.formatting,
+            }),
+        );
+      }
+      return await sendContext.withRetry(
+        async () =>
+          await sendContext.send(sendContext.target, text, {
+            verbose: false,
+            mediaUrl,
+            mediaAccess: ctx.mediaAccess,
+            mediaLocalRoots: ctx.mediaLocalRoots,
+            mediaReadFile: ctx.mediaReadFile,
+            replyTo: sendContext.resolveReplyTo(),
+            accountId: ctx.accountId ?? undefined,
+            silent: ctx.silent ?? undefined,
+            cfg: ctx.cfg,
+            ...sendContext.formatting,
+          }),
+      );
+    },
+  });
+  return attachChannelToResult("discord", result);
+}

package/src/outbound-send-context.ts

@@ -0,0 +1,92 @@
+import type { OpenClawConfig, ReplyToMode } from "openclaw/plugin-sdk/config-types";
+import { createReplyToFanout, type ReplyToResolution } from "openclaw/plugin-sdk/outbound-runtime";
+import {
+  resolveOutboundSendDep,
+  type OutboundSendDeps,
+} from "openclaw/plugin-sdk/outbound-send-deps";
+import { normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/text-runtime";
+import { withDiscordDeliveryRetry } from "./delivery-retry.js";
+
+type DiscordSendRuntime = typeof import("./send.js");
+
+export type DiscordSendFn = DiscordSendRuntime["sendMessageDiscord"];
+export type DiscordVoiceSendFn = DiscordSendRuntime["sendVoiceMessageDiscord"];
+type DiscordFormattingOptions = {
+  textLimit?: number;
+  maxLinesPerMessage?: number;
+  tableMode?: NonNullable<Parameters<DiscordSendFn>[2]>["tableMode"];
+  chunkMode?: NonNullable<Parameters<DiscordSendFn>[2]>["chunkMode"];
+};
+
+let discordSendRuntimePromise: Promise<DiscordSendRuntime> | undefined;
+
+export async function loadDiscordSendRuntime(): Promise<DiscordSendRuntime> {
+  discordSendRuntimePromise ??= import("./send.js");
+  return await discordSendRuntimePromise;
+}
+
+export function resolveDiscordOutboundTarget(params: {
+  to: string;
+  threadId?: string | number | null;
+}): string {
+  if (params.threadId == null) {
+    return params.to;
+  }
+  const threadId = normalizeOptionalStringifiedId(params.threadId) ?? "";
+  if (!threadId) {
+    return params.to;
+  }
+  return `channel:${threadId}`;
+}
+
+export function resolveDiscordFormattingOptions(ctx: {
+  formatting?: DiscordFormattingOptions;
+}): DiscordFormattingOptions {
+  const formatting = ctx.formatting;
+  return {
+    textLimit: formatting?.textLimit,
+    maxLinesPerMessage: formatting?.maxLinesPerMessage,
+    tableMode: formatting?.tableMode,
+    chunkMode: formatting?.chunkMode,
+  };
+}
+
+export async function createDiscordPayloadSendContext(ctx: {
+  cfg: OpenClawConfig;
+  to: string;
+  accountId?: string | null;
+  deps?: OutboundSendDeps;
+  replyToId?: string | null;
+  replyToIdSource?: ReplyToResolution["source"];
+  replyToMode?: ReplyToMode;
+  formatting?: DiscordFormattingOptions;
+  threadId?: string | number | null;
+}): Promise<{
+  target: string;
+  formatting: DiscordFormattingOptions;
+  resolveReplyTo: () => string | undefined;
+  send: DiscordSendFn;
+  sendVoice: DiscordVoiceSendFn;
+  withRetry: <T>(fn: () => Promise<T>) => Promise<T>;
+}> {
+  const runtime = await loadDiscordSendRuntime();
+  return {
+    target: resolveDiscordOutboundTarget({ to: ctx.to, threadId: ctx.threadId }),
+    formatting: resolveDiscordFormattingOptions(ctx),
+    resolveReplyTo: createReplyToFanout({
+      replyToId: ctx.replyToId,
+      replyToIdSource: ctx.replyToIdSource,
+      replyToMode: ctx.replyToMode,
+    }),
+    send: resolveOutboundSendDep<DiscordSendFn>(ctx.deps, "discord") ?? runtime.sendMessageDiscord,
+    sendVoice:
+      resolveOutboundSendDep<DiscordVoiceSendFn>(ctx.deps, "discordVoice") ??
+      runtime.sendVoiceMessageDiscord,
+    withRetry: async (fn) =>
+      await withDiscordDeliveryRetry({
+        cfg: ctx.cfg,
+        accountId: ctx.accountId,
+        fn,
+      }),
+  };
+}

package/src/outbound-session-route.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import { resolveDiscordOutboundSessionRoute } from "./outbound-session-route.js";
+
+describe("resolveDiscordOutboundSessionRoute", () => {
+  it("keeps explicit delivery thread ids without adding a session suffix", () => {
+    const route = resolveDiscordOutboundSessionRoute({
+      cfg: {},
+      agentId: "main",
+      target: "channel:123",
+      threadId: "thread-1",
+    });
+
+    expect(route).toMatchObject({
+      sessionKey: "agent:main:discord:channel:123",
+      baseSessionKey: "agent:main:discord:channel:123",
+      threadId: "thread-1",
+    });
+  });
+
+  it("does not promote replyToId into Discord delivery thread metadata", () => {
+    const route = resolveDiscordOutboundSessionRoute({
+      cfg: {},
+      agentId: "main",
+      target: "channel:123",
+      replyToId: "message-1",
+    });
+
+    expect(route).toMatchObject({
+      sessionKey: "agent:main:discord:channel:123",
+      baseSessionKey: "agent:main:discord:channel:123",
+    });
+    expect(route?.threadId).toBeUndefined();
+  });
+});