@kodelyth/discord 2026.5.42 → 2026.6.1

package/src/outbound-adapter.ts

@@ -1,326 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,208 +0,0 @@
-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);
-}