@kodelyth/discord 2026.5.39 → 2026.5.42

package/src/outbound-adapter.ts

@@ -0,0 +1,326 @@
+import {
+  type ChannelOutboundAdapter,
+  createAttachedChannelResultAdapter,
+} from "klaw/plugin-sdk/channel-send-result";
+import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
+import type { OutboundIdentity } from "klaw/plugin-sdk/outbound-runtime";
+import { resolveOutboundSendDep } from "klaw/plugin-sdk/outbound-send-deps";
+import {
+  normalizeOptionalString,
+  normalizeOptionalStringifiedId,
+} from "klaw/plugin-sdk/string-coerce-runtime";
+import { chunkDiscordTextWithMode } from "./chunk.js";
+import { withDiscordDeliveryRetry } from "./delivery-retry.js";
+import { notifyDiscordInboundEventOutboundPayloadSuccess } from "./inbound-event-delivery.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: KlawConfig;
+  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,
+    limits: {
+      actions: {
+        maxActions: 25,
+        maxActionsPerRow: 5,
+        maxRows: 5,
+        maxLabelLength: 80,
+      },
+      selects: {
+        maxOptions: 25,
+        maxLabelLength: 100,
+        maxValueBytes: 100,
+      },
+      text: {
+        maxLength: DISCORD_TEXT_CHUNK_LIMIT,
+        encoding: "characters",
+        markdownDialect: "discord-markdown",
+      },
+    },
+  },
+  deliveryCapabilities: {
+    durableFinal: {
+      text: true,
+      media: true,
+      payload: true,
+      silent: true,
+      replyTo: true,
+      thread: true,
+      messageSendingHooks: 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, payload }) => {
+    notifyDiscordInboundEventOutboundPayloadSuccess({
+      payload,
+      to: resolveDiscordOutboundTarget({ to: target.to, threadId: target.threadId }),
+      accountId: target.accountId,
+    });
+    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,86 @@
+import type { ChannelOutboundAdapter } from "klaw/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 ??
+    (discordData?.components &&
+    typeof discordData.components === "object" &&
+    !Array.isArray(discordData.components)
+      ? readDiscordComponentSpec(discordData.components)
+      : null);
+  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,49 @@
+import {
+  installChannelOutboundPayloadContractSuite,
+  primeChannelOutboundSendMock,
+  type OutboundPayloadHarnessParams,
+} from "klaw/plugin-sdk/channel-contract-testing";
+import { describe, vi } from "vitest";
+import { discordOutbound } from "./outbound-adapter.js";
+
+type DiscordSendPayload = NonNullable<typeof discordOutbound.sendPayload>;
+
+function requireDiscordSendPayload(): DiscordSendPayload {
+  const sendPayload = discordOutbound.sendPayload;
+  if (!sendPayload) {
+    throw new Error("Expected Discord outbound sendPayload");
+  }
+  return sendPayload;
+}
+
+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,
+    },
+  };
+  const sendPayload = requireDiscordSendPayload();
+  return {
+    run: async () => await 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,208 @@
+import {
+  attachChannelToResult,
+  type ChannelOutboundAdapter,
+} from "klaw/plugin-sdk/channel-send-result";
+import {
+  resolvePayloadMediaUrls,
+  sendPayloadMediaSequenceOrFallback,
+  sendTextMediaPayload,
+} from "klaw/plugin-sdk/reply-payload";
+import { normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
+import { normalizeDiscordApprovalPayload } from "./outbound-approval.js";
+import {
+  resolveDiscordComponentSpec,
+  sendDiscordComponentMessageLazy,
+} from "./outbound-components.js";
+import { createDiscordPayloadSendContext } from "./outbound-send-context.js";
+import { createDiscordSendReceipt } from "./send.receipt.js";
+import type { DiscordSendComponents, DiscordSendEmbeds } from "./send.shared.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) {
+    const discordData =
+      payload.channelData?.discord &&
+      typeof payload.channelData.discord === "object" &&
+      !Array.isArray(payload.channelData.discord)
+        ? (payload.channelData.discord as Record<string, unknown>)
+        : {};
+    const nativeComponents = Array.isArray(discordData.components)
+      ? (discordData.components as DiscordSendComponents)
+      : undefined;
+    const embeds = Array.isArray(discordData.embeds)
+      ? (discordData.embeds as DiscordSendEmbeds)
+      : undefined;
+    const filename = normalizeOptionalString(discordData.filename);
+    if (nativeComponents || embeds?.length || filename) {
+      const result = await sendPayloadMediaSequenceOrFallback({
+        text: payload.text ?? "",
+        mediaUrls,
+        fallbackResult: {
+          messageId: "",
+          channelId: sendContext.target,
+          receipt: createDiscordSendReceipt({
+            platformMessageIds: [],
+            channelId: sendContext.target,
+            kind: "unknown",
+          }),
+        },
+        sendNoMedia: async () =>
+          await sendContext.withRetry(
+            async () =>
+              await sendContext.send(sendContext.target, payload.text ?? "", {
+                verbose: false,
+                components: nativeComponents,
+                embeds,
+                filename,
+                replyTo: sendContext.resolveReplyTo(),
+                accountId: ctx.accountId ?? undefined,
+                silent: ctx.silent ?? undefined,
+                cfg: ctx.cfg,
+                ...sendContext.formatting,
+              }),
+          ),
+        send: async ({ text, mediaUrl, isFirst }) =>
+          await sendContext.withRetry(
+            async () =>
+              await sendContext.send(sendContext.target, text, {
+                verbose: false,
+                mediaUrl,
+                mediaAccess: ctx.mediaAccess,
+                mediaLocalRoots: ctx.mediaLocalRoots,
+                mediaReadFile: ctx.mediaReadFile,
+                components: isFirst ? nativeComponents : undefined,
+                embeds: isFirst ? embeds : undefined,
+                filename: isFirst ? filename : undefined,
+                replyTo: sendContext.resolveReplyTo(),
+                accountId: ctx.accountId ?? undefined,
+                silent: ctx.silent ?? undefined,
+                cfg: ctx.cfg,
+                ...sendContext.formatting,
+              }),
+          ),
+      });
+      return attachChannelToResult("discord", result);
+    }
+    return await sendTextMediaPayload({
+      channel: "discord",
+      ctx: {
+        ...ctx,
+        payload,
+      },
+      adapter: params.fallbackAdapter,
+    });
+  }
+
+  const result = await sendPayloadMediaSequenceOrFallback({
+    text: payload.text ?? "",
+    mediaUrls,
+    fallbackResult: {
+      messageId: "",
+      channelId: sendContext.target,
+      receipt: createDiscordSendReceipt({
+        platformMessageIds: [],
+        channelId: sendContext.target,
+        kind: "unknown",
+      }),
+    },
+    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);
+}