@kodelyth/discord 2026.5.42 → 2026.6.2

package/src/monitor/message-handler.process.ts

@@ -1,1027 +0,0 @@
-import path from "node:path";
-import { MessageFlags } from "discord-api-types/v10";
-import {
-  formatReasoningMessage,
-  resolveAckReaction,
-  resolveHumanDelayConfig,
-} from "klaw/plugin-sdk/agent-runtime";
-import {
-  createStatusReactionController,
-  DEFAULT_TIMING,
-  logAckFailure,
-  logTypingFailure,
-  shouldAckReaction as shouldAckReactionGate,
-} from "klaw/plugin-sdk/channel-feedback";
-import {
-  createChannelMessageReplyPipeline,
-  defineFinalizableLivePreviewAdapter,
-  deliverWithFinalizableLivePreviewAdapter,
-  resolveChannelMessageSourceReplyDeliveryMode,
-} from "klaw/plugin-sdk/channel-message";
-import {
-  buildChannelProgressDraftLine,
-  buildChannelProgressDraftLineForEntry,
-  resolveChannelStreamingBlockEnabled,
-  resolveTranscriptBackedChannelFinalText,
-} from "klaw/plugin-sdk/channel-streaming";
-import { recordInboundSession } from "klaw/plugin-sdk/conversation-runtime";
-import {
-  hasFinalInboundReplyDispatch,
-  recordChannelBotPairLoopAndCheckSuppression,
-  runPreparedInboundReplyTurn,
-} from "klaw/plugin-sdk/inbound-reply-dispatch";
-import { resolveMarkdownTableMode } from "klaw/plugin-sdk/markdown-table-runtime";
-import { getAgentScopedMediaLocalRoots } from "klaw/plugin-sdk/media-runtime";
-import { resolveChunkMode } from "klaw/plugin-sdk/reply-chunking";
-import type { ReplyPayload } from "klaw/plugin-sdk/reply-dispatch-runtime";
-import { createChannelHistoryWindow } from "klaw/plugin-sdk/reply-history";
-import {
-  buildTtsSupplementMediaPayload,
-  getReplyPayloadTtsSupplement,
-  resolveSendableOutboundReplyParts,
-} from "klaw/plugin-sdk/reply-payload";
-import { danger, logVerbose, shouldLogVerbose } from "klaw/plugin-sdk/runtime-env";
-import {
-  loadSessionStore,
-  readLatestAssistantTextFromSessionTranscript,
-  resolveAndPersistSessionFile,
-  resolveSessionStoreEntry,
-  resolveStorePath,
-} from "klaw/plugin-sdk/session-store-runtime";
-import { resolveDiscordMaxLinesPerMessage } from "../accounts.js";
-import { createDiscordRestClient } from "../client.js";
-import { beginDiscordInboundEventDeliveryCorrelation } from "../inbound-event-delivery.js";
-import { removeReactionDiscord } from "../send.js";
-import { editMessageDiscord } from "../send.messages.js";
-import { resolveDiscordTargetChannelId } from "../send.shared.js";
-import { resolveDiscordChannelId } from "../targets.js";
-import {
-  createDiscordAckReactionAdapter,
-  createDiscordAckReactionContext,
-  queueInitialDiscordAckReaction,
-} from "./ack-reactions.js";
-import { buildDiscordMessageProcessContext } from "./message-handler.context.js";
-import { createDiscordDraftPreviewController } from "./message-handler.draft-preview.js";
-import type { DiscordMessagePreflightContext } from "./message-handler.preflight.js";
-import { resolveForwardedMediaList, resolveMediaList } from "./message-utils.js";
-import { deliverDiscordReply } from "./reply-delivery.js";
-import {
-  DISCORD_ATTACHMENT_IDLE_TIMEOUT_MS,
-  DISCORD_ATTACHMENT_TOTAL_TIMEOUT_MS,
-} from "./timeouts.js";
-import { sendTyping } from "./typing.js";
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-
-const DISCORD_TYPING_MAX_DURATION_MS = 20 * 60_000;
-let replyRuntimePromise: Promise<typeof import("klaw/plugin-sdk/reply-runtime")> | undefined;
-
-async function loadReplyRuntime() {
-  replyRuntimePromise ??= import("klaw/plugin-sdk/reply-runtime");
-  return await replyRuntimePromise;
-}
-
-function isProcessAborted(abortSignal?: AbortSignal): boolean {
-  return Boolean(abortSignal?.aborted);
-}
-
-function formatDiscordReplyDeliveryFailure(params: {
-  kind: string;
-  err: unknown;
-  target: string;
-  sessionKey?: string;
-}) {
-  const context = [
-    `target=${params.target}`,
-    params.sessionKey ? `session=${params.sessionKey}` : undefined,
-  ]
-    .filter(Boolean)
-    .join(" ");
-  return `discord ${params.kind} reply failed (${context}): ${String(params.err)}`;
-}
-
-type DiscordMessageProcessObserver = {
-  onFinalReplyStart?: () => void;
-  onFinalReplyDelivered?: () => void;
-  onReplyPlanResolved?: (params: { createdThreadId?: string; sessionKey?: string }) => void;
-};
-
-type ToolStartPayload = {
-  name?: string;
-  phase?: string;
-  args?: Record<string, unknown>;
-  detailMode?: "explain" | "raw";
-};
-
-function readToolStringArg(args: Record<string, unknown>, key: string): string | undefined {
-  const value = args[key];
-  return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-
-function readToolBooleanArg(args: Record<string, unknown>, key: string): boolean {
-  return args[key] === true;
-}
-
-export async function processDiscordMessage(
-  ctx: DiscordMessagePreflightContext,
-  observer?: DiscordMessageProcessObserver,
-) {
-  const dispatchStartedAt = Date.now();
-  const {
-    cfg,
-    discordConfig,
-    accountId,
-    token,
-    runtime,
-    guildHistories,
-    historyLimit,
-    mediaMaxBytes,
-    textLimit,
-    replyToMode,
-    ackReactionScope,
-    message,
-    messageChannelId,
-    isGuildMessage,
-    isDirectMessage,
-    isGroupDm,
-    messageText,
-    shouldRequireMention,
-    canDetectMention,
-    effectiveWasMentioned,
-    shouldBypassMention,
-    channelConfig,
-    threadBindings,
-    route,
-    discordRestFetch,
-    abortSignal,
-    botLoopProtection,
-  } = ctx;
-  if (isProcessAborted(abortSignal)) {
-    return;
-  }
-  if (botLoopProtection) {
-    const botLoopResult = recordChannelBotPairLoopAndCheckSuppression(botLoopProtection);
-    if (botLoopResult.suppressed) {
-      logVerbose(
-        `discord: bot-to-bot loop detected before dispatch setup, suppressing for ${Math.max(0, Math.ceil((botLoopResult.cooldownUntilMs - Date.now()) / 1000))}s`,
-      );
-      return;
-    }
-  }
-
-  const ssrfPolicy = cfg.browser?.ssrfPolicy;
-  const mediaResolveOptions = {
-    fetchImpl: discordRestFetch,
-    ssrfPolicy,
-    readIdleTimeoutMs: DISCORD_ATTACHMENT_IDLE_TIMEOUT_MS,
-    totalTimeoutMs: DISCORD_ATTACHMENT_TOTAL_TIMEOUT_MS,
-    abortSignal,
-  };
-  const mediaList = await resolveMediaList(message, mediaMaxBytes, mediaResolveOptions);
-  if (isProcessAborted(abortSignal)) {
-    return;
-  }
-  const forwardedMediaList = await resolveForwardedMediaList(
-    message,
-    mediaMaxBytes,
-    mediaResolveOptions,
-  );
-  if (isProcessAborted(abortSignal)) {
-    return;
-  }
-  mediaList.push(...forwardedMediaList);
-  const text = messageText;
-  if (!text) {
-    logVerbose("discord: drop message " + message.id + " (empty content)");
-    return;
-  }
-
-  const boundThreadId = ctx.threadBinding?.conversation?.conversationId?.trim();
-  if (boundThreadId && typeof threadBindings.touchThread === "function") {
-    threadBindings.touchThread({ threadId: boundThreadId });
-  }
-  const { createReplyDispatcherWithTyping, dispatchInboundMessage, settleReplyDispatcher } =
-    await loadReplyRuntime();
-  const sourceReplyDeliveryMode = resolveChannelMessageSourceReplyDeliveryMode({
-    cfg,
-    ctx: {
-      ChatType: isDirectMessage
-        ? "direct"
-        : isGroupDm
-          ? "group"
-          : isGuildMessage
-            ? "channel"
-            : undefined,
-      InboundEventKind: ctx.inboundEventKind,
-    },
-  });
-  const sourceRepliesAreToolOnly = sourceReplyDeliveryMode === "message_tool_only";
-  const ackReaction = resolveAckReaction(cfg, route.agentId, {
-    channel: "discord",
-    accountId,
-  });
-  const removeAckAfterReply = cfg.messages?.removeAckAfterReply ?? false;
-  const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, route.agentId);
-  const isRoomEvent = ctx.inboundEventKind === "room_event";
-  const shouldAckReaction = () =>
-    Boolean(
-      !isRoomEvent &&
-      ackReaction &&
-      shouldAckReactionGate({
-        scope: ackReactionScope,
-        isDirect: isDirectMessage,
-        isGroup: isGuildMessage || isGroupDm,
-        isMentionableGroup: isGuildMessage,
-        requireMention: shouldRequireMention,
-        canDetectMention,
-        effectiveWasMentioned,
-        shouldBypassMention,
-      }),
-    );
-  const shouldSendAckReaction = shouldAckReaction();
-  const statusReactionsExplicitlyEnabled = cfg.messages?.statusReactions?.enabled === true;
-  const statusReactionsEnabled =
-    !isRoomEvent &&
-    shouldSendAckReaction &&
-    cfg.messages?.statusReactions?.enabled !== false &&
-    (!sourceRepliesAreToolOnly || statusReactionsExplicitlyEnabled);
-  const feedbackRest = createDiscordRestClient({
-    cfg,
-    token,
-    accountId,
-  }).rest;
-  const deliveryRest = createDiscordRestClient({
-    cfg,
-    token,
-    accountId,
-  }).rest;
-  // Discord outbound helpers expect the internal REST client shape explicitly.
-  const ackReactionContext = createDiscordAckReactionContext({
-    rest: feedbackRest,
-    cfg,
-    accountId,
-  });
-  const discordAdapter = createDiscordAckReactionAdapter({
-    channelId: messageChannelId,
-    messageId: message.id,
-    reactionContext: ackReactionContext,
-  });
-  let statusReactionTarget = `${messageChannelId}/${message.id}`;
-  let statusReactionsActive = statusReactionsEnabled;
-  let statusReactions = createStatusReactionController({
-    enabled: statusReactionsEnabled,
-    adapter: discordAdapter,
-    initialEmoji: ackReaction,
-    emojis: cfg.messages?.statusReactions?.emojis,
-    timing: cfg.messages?.statusReactions?.timing,
-    onError: (err) => {
-      logAckFailure({
-        log: logVerbose,
-        channel: "discord",
-        target: statusReactionTarget,
-        error: err,
-      });
-    },
-  });
-  const resolveTrackedReactionChannelId = async (
-    args: Record<string, unknown>,
-  ): Promise<string> => {
-    const target =
-      readToolStringArg(args, "channelId") ??
-      readToolStringArg(args, "channel_id") ??
-      readToolStringArg(args, "to");
-    if (!target) {
-      return messageChannelId;
-    }
-    try {
-      return resolveDiscordChannelId(target);
-    } catch {
-      return (
-        await resolveDiscordTargetChannelId(target, {
-          cfg,
-          token,
-          accountId,
-        })
-      ).channelId;
-    }
-  };
-  const maybeBindStatusReactionsToToolReaction = async (payload: ToolStartPayload) => {
-    if (
-      sourceRepliesAreToolOnly ||
-      cfg.messages?.statusReactions?.enabled === false ||
-      payload.phase !== "start" ||
-      payload.name !== "message" ||
-      !payload.args
-    ) {
-      return;
-    }
-    const args = payload.args;
-    const action = readToolStringArg(args, "action")?.toLowerCase();
-    if (action !== "react") {
-      return;
-    }
-    const shouldTrack =
-      readToolBooleanArg(args, "trackToolCalls") || readToolBooleanArg(args, "track_tool_calls");
-    if (!shouldTrack) {
-      return;
-    }
-    const emoji = readToolStringArg(args, "emoji");
-    const remove = readToolBooleanArg(args, "remove");
-    if (!emoji || remove) {
-      return;
-    }
-    const trackedMessageId =
-      readToolStringArg(args, "messageId") ?? readToolStringArg(args, "message_id") ?? message.id;
-    let trackedChannelId: string;
-    try {
-      trackedChannelId = await resolveTrackedReactionChannelId(args);
-    } catch (err) {
-      logAckFailure({
-        log: logVerbose,
-        channel: "discord",
-        target: `${readToolStringArg(args, "to") ?? readToolStringArg(args, "channelId") ?? messageChannelId}/${trackedMessageId}`,
-        error: err,
-      });
-      return;
-    }
-    statusReactionTarget = `${trackedChannelId}/${trackedMessageId}`;
-    if (statusReactionsActive) {
-      void statusReactions.clear();
-    }
-    const trackedAdapter = createDiscordAckReactionAdapter({
-      channelId: trackedChannelId,
-      messageId: trackedMessageId,
-      reactionContext: ackReactionContext,
-    });
-    statusReactions = createStatusReactionController({
-      enabled: true,
-      adapter: trackedAdapter,
-      initialEmoji: emoji,
-      emojis: cfg.messages?.statusReactions?.emojis,
-      timing: cfg.messages?.statusReactions?.timing,
-      onError: (err) => {
-        logAckFailure({
-          log: logVerbose,
-          channel: "discord",
-          target: statusReactionTarget,
-          error: err,
-        });
-      },
-    });
-    statusReactionsActive = true;
-    void statusReactions.setQueued();
-  };
-  queueInitialDiscordAckReaction({
-    enabled: statusReactionsEnabled,
-    shouldSendAckReaction,
-    ackReaction,
-    statusReactions,
-    reactionAdapter: discordAdapter,
-    target: `${messageChannelId}/${message.id}`,
-  });
-  const processContext = await buildDiscordMessageProcessContext({
-    ctx,
-    text,
-    mediaList,
-  });
-  if (!processContext) {
-    return;
-  }
-  const {
-    ctxPayload,
-    persistedSessionKey,
-    turn,
-    replyPlan,
-    deliverTarget,
-    replyTarget,
-    replyReference,
-  } = processContext;
-  observer?.onReplyPlanResolved?.({
-    createdThreadId: replyPlan.createdThreadId,
-    sessionKey: persistedSessionKey,
-  });
-
-  const typingChannelId = deliverTarget.startsWith("channel:")
-    ? deliverTarget.slice("channel:".length)
-    : messageChannelId;
-
-  const { onModelSelected, ...replyPipeline } = createChannelMessageReplyPipeline({
-    cfg,
-    agentId: route.agentId,
-    channel: "discord",
-    accountId: route.accountId,
-    typing: {
-      start: () => sendTyping({ rest: feedbackRest, channelId: typingChannelId }),
-      onStartError: (err) => {
-        logTypingFailure({
-          log: logVerbose,
-          channel: "discord",
-          target: typingChannelId,
-          error: err,
-        });
-      },
-      // Long tool-heavy runs are expected on Discord; keep heartbeats alive.
-      maxDurationMs: DISCORD_TYPING_MAX_DURATION_MS,
-    },
-  });
-  const tableMode = resolveMarkdownTableMode({
-    cfg,
-    channel: "discord",
-    accountId,
-  });
-  const maxLinesPerMessage = resolveDiscordMaxLinesPerMessage({
-    cfg,
-    discordConfig,
-    accountId,
-  });
-  const chunkMode = resolveChunkMode(cfg, "discord", accountId);
-  const clearGroupHistory = () => {
-    if (isDirectMessage) {
-      return;
-    }
-    createChannelHistoryWindow({ historyMap: guildHistories }).clear({
-      historyKey: messageChannelId,
-      limit: historyLimit,
-    });
-  };
-  const beginDeliveryCorrelation = () =>
-    isRoomEvent
-      ? beginDiscordInboundEventDeliveryCorrelation(
-          ctxPayload.SessionKey,
-          {
-            outboundTo: messageChannelId,
-            outboundAccountId: route.accountId,
-            markInboundEventDelivered: clearGroupHistory,
-          },
-          { inboundEventKind: ctxPayload.InboundEventKind },
-        )
-      : () => {};
-  const endDiscordInboundEventDeliveryCorrelation = beginDeliveryCorrelation();
-  const resolveCurrentTurnTranscriptFinalText = async (): Promise<string | undefined> => {
-    const sessionKey = ctxPayload.SessionKey;
-    if (!sessionKey) {
-      return undefined;
-    }
-    try {
-      const storePath = resolveStorePath(cfg.session?.store, { agentId: route.agentId });
-      const store = loadSessionStore(storePath, { clone: false });
-      const sessionEntry = resolveSessionStoreEntry({ store, sessionKey }).existing;
-      if (!sessionEntry?.sessionId) {
-        return undefined;
-      }
-      const { sessionFile } = await resolveAndPersistSessionFile({
-        sessionId: sessionEntry.sessionId,
-        sessionKey,
-        sessionStore: store,
-        storePath,
-        sessionEntry,
-        agentId: route.agentId,
-        sessionsDir: path.dirname(storePath),
-      });
-      const latest = await readLatestAssistantTextFromSessionTranscript(sessionFile);
-      if (!latest?.timestamp || latest.timestamp < dispatchStartedAt) {
-        return undefined;
-      }
-      return latest.text;
-    } catch (err) {
-      logVerbose(`discord transcript final candidate lookup failed: ${String(err)}`);
-      return undefined;
-    }
-  };
-
-  const deliverChannelId = deliverTarget.startsWith("channel:")
-    ? deliverTarget.slice("channel:".length)
-    : messageChannelId;
-  const draftPreview = createDiscordDraftPreviewController({
-    cfg,
-    discordConfig,
-    accountId,
-    sourceRepliesAreToolOnly,
-    textLimit,
-    deliveryRest,
-    deliverChannelId,
-    replyReference,
-    tableMode,
-    maxLinesPerMessage,
-    chunkMode,
-    log: logVerbose,
-  });
-  const finalPreviewFlags =
-    (discordConfig?.suppressEmbeds ?? true) ? MessageFlags.SuppressEmbeds : undefined;
-  let finalReplyStartNotified = false;
-  const notifyFinalReplyStart = () => {
-    if (finalReplyStartNotified) {
-      return;
-    }
-    finalReplyStartNotified = true;
-    observer?.onFinalReplyStart?.();
-  };
-
-  const { dispatcher, replyOptions, markDispatchIdle, markRunComplete } =
-    createReplyDispatcherWithTyping({
-      ...replyPipeline,
-      humanDelay: resolveHumanDelayConfig(cfg, route.agentId),
-      deliver: async (payload: ReplyPayload, info) => {
-        if (isProcessAborted(abortSignal)) {
-          return;
-        }
-        const isFinal = info.kind === "final";
-        if (payload.isReasoning) {
-          // Reasoning/thinking payloads should not be delivered to Discord.
-          return;
-        }
-        const finalText =
-          isFinal && typeof payload.text === "string"
-            ? await resolveTranscriptBackedChannelFinalText({
-                finalText: payload.text,
-                resolveCandidateText: resolveCurrentTurnTranscriptFinalText,
-              })
-            : payload.text;
-        const effectivePayload =
-          finalText !== payload.text ? { ...payload, text: finalText } : payload;
-        const draftStream = draftPreview.draftStream;
-        if (draftStream && draftPreview.isProgressMode && info.kind === "block") {
-          const reply = resolveSendableOutboundReplyParts(effectivePayload);
-          if (!reply.hasMedia && !payload.isError) {
-            return;
-          }
-        }
-        if (
-          draftStream &&
-          isFinal &&
-          (!draftPreview.isProgressMode || draftPreview.hasProgressDraftStarted)
-        ) {
-          const reply = resolveSendableOutboundReplyParts(effectivePayload);
-          const hasMedia = reply.hasMedia;
-          const ttsSupplement = getReplyPayloadTtsSupplement(effectivePayload);
-          const previewSourceText = finalText ?? ttsSupplement?.spokenText;
-          const previewFinalText = draftPreview.resolvePreviewFinalText(previewSourceText);
-          const previewReplyToId = replyReference.peek();
-          const hasExplicitReplyDirective =
-            Boolean(effectivePayload.replyToTag || effectivePayload.replyToCurrent) ||
-            (typeof previewSourceText === "string" &&
-              /\[\[\s*reply_to(?:_current|\s*:)/i.test(previewSourceText));
-
-          const result = await deliverWithFinalizableLivePreviewAdapter({
-            kind: info.kind,
-            payload: effectivePayload,
-            adapter: defineFinalizableLivePreviewAdapter({
-              draft: {
-                flush: () => draftPreview.flush(),
-                clear: () => draftStream.clear(),
-                discardPending: () => draftStream.discardPending(),
-                seal: () => draftStream.seal(),
-                id: draftStream.messageId,
-              },
-              buildFinalEdit: () => {
-                if (
-                  draftPreview.finalizedViaPreviewMessage ||
-                  (hasMedia && !ttsSupplement) ||
-                  typeof previewFinalText !== "string" ||
-                  hasExplicitReplyDirective ||
-                  payload.isError
-                ) {
-                  return undefined;
-                }
-                return {
-                  content: previewFinalText,
-                  ...(finalPreviewFlags ? { flags: finalPreviewFlags } : {}),
-                };
-              },
-              editFinal: async (previewMessageId, edit) => {
-                if (isProcessAborted(abortSignal)) {
-                  throw new Error("process aborted");
-                }
-                notifyFinalReplyStart();
-                await editMessageDiscord(deliverChannelId, previewMessageId, edit, {
-                  cfg,
-                  accountId,
-                  rest: deliveryRest,
-                });
-              },
-              onPreviewFinalized: () => {
-                draftPreview.markFinalReplyDelivered();
-                draftPreview.markPreviewFinalized();
-                replyReference.markSent();
-                observer?.onFinalReplyDelivered?.();
-              },
-              buildSupplementalPayload: () =>
-                ttsSupplement ? buildTtsSupplementMediaPayload(effectivePayload) : undefined,
-              deliverSupplemental: async (supplementalPayload) => {
-                if (isProcessAborted(abortSignal)) {
-                  return false;
-                }
-                const supplementalReplyToId =
-                  previewReplyToId ??
-                  replyReference.peek() ??
-                  (replyToMode === "all"
-                    ? typeof message.id === "string" && message.id
-                      ? message.id
-                      : ctxPayload.MessageSid
-                    : undefined);
-                await deliverDiscordReply({
-                  cfg,
-                  replies: [supplementalPayload],
-                  target: deliverTarget,
-                  token,
-                  accountId,
-                  rest: deliveryRest,
-                  runtime,
-                  replyToId: supplementalReplyToId,
-                  replyToMode,
-                  textLimit,
-                  maxLinesPerMessage,
-                  tableMode,
-                  chunkMode,
-                  sessionKey: ctxPayload.SessionKey,
-                  threadBindings,
-                  mediaLocalRoots,
-                  kind: info.kind,
-                });
-                return true;
-              },
-              logPreviewEditFailure: (err) => {
-                logVerbose(
-                  `discord: preview final edit failed; falling back to standard send (${String(err)})`,
-                );
-              },
-            }),
-            deliverNormally: async () => {
-              if (isProcessAborted(abortSignal)) {
-                return false;
-              }
-              const fallbackPayload =
-                ttsSupplement &&
-                ttsSupplement.visibleTextAlreadyDelivered !== true &&
-                !effectivePayload.text?.trim()
-                  ? { ...effectivePayload, text: ttsSupplement.spokenText }
-                  : effectivePayload;
-              const replyToId = replyReference.use();
-              notifyFinalReplyStart();
-              await deliverDiscordReply({
-                cfg,
-                replies: [fallbackPayload],
-                target: deliverTarget,
-                token,
-                accountId,
-                rest: deliveryRest,
-                runtime,
-                replyToId,
-                replyToMode,
-                textLimit,
-                maxLinesPerMessage,
-                tableMode,
-                chunkMode,
-                sessionKey: ctxPayload.SessionKey,
-                threadBindings,
-                mediaLocalRoots,
-                kind: info.kind,
-              });
-              return true;
-            },
-            onNormalDelivered: () => {
-              draftPreview.markFinalReplyDelivered();
-              replyReference.markSent();
-              observer?.onFinalReplyDelivered?.();
-            },
-          });
-          if (result.kind !== "normal-skipped") {
-            return;
-          }
-        }
-        if (isProcessAborted(abortSignal)) {
-          return;
-        }
-
-        const replyToId = replyReference.use();
-        if (isFinal) {
-          notifyFinalReplyStart();
-        }
-        await deliverDiscordReply({
-          cfg,
-          replies: [effectivePayload],
-          target: deliverTarget,
-          token,
-          accountId,
-          rest: deliveryRest,
-          runtime,
-          replyToId,
-          replyToMode,
-          textLimit,
-          maxLinesPerMessage,
-          tableMode,
-          chunkMode,
-          sessionKey: ctxPayload.SessionKey,
-          threadBindings,
-          mediaLocalRoots,
-          kind: info.kind,
-        });
-        replyReference.markSent();
-        if (isFinal) {
-          observer?.onFinalReplyDelivered?.();
-        }
-      },
-      onError: (err, info) => {
-        runtime.error?.(
-          danger(
-            formatDiscordReplyDeliveryFailure({
-              kind: info.kind,
-              err,
-              target: deliverTarget,
-              sessionKey: ctxPayload.SessionKey,
-            }),
-          ),
-        );
-      },
-      onReplyStart: async () => {
-        if (isProcessAborted(abortSignal)) {
-          return;
-        }
-        await replyPipeline.typingCallbacks?.onReplyStart();
-        await statusReactions.setThinking();
-      },
-    });
-
-  const resolvedBlockStreamingEnabled = resolveChannelStreamingBlockEnabled(discordConfig);
-  let dispatchResult: Awaited<ReturnType<typeof dispatchInboundMessage>> | null = null;
-  let dispatchError = false;
-  let dispatchAborted = false;
-  let dispatchSettledBeforeStart = false;
-  const settleDispatchBeforeStart = async () => {
-    dispatchSettledBeforeStart = true;
-    await settleReplyDispatcher({
-      dispatcher,
-      onSettled: () => {
-        markRunComplete();
-        markDispatchIdle();
-      },
-    });
-  };
-  try {
-    if (isProcessAborted(abortSignal)) {
-      dispatchAborted = true;
-      await settleDispatchBeforeStart();
-      return;
-    }
-    const preparedResult = await runPreparedInboundReplyTurn({
-      channel: "discord",
-      accountId: route.accountId,
-      routeSessionKey: persistedSessionKey,
-      storePath: turn.storePath,
-      ctxPayload,
-      recordInboundSession,
-      record: turn.record,
-      history: isRoomEvent
-        ? undefined
-        : {
-            isGroup: isGuildMessage,
-            historyKey: messageChannelId,
-            historyMap: guildHistories,
-            limit: historyLimit,
-          },
-      onPreDispatchFailure: settleDispatchBeforeStart,
-      runDispatch: async () =>
-        await dispatchInboundMessage({
-          ctx: ctxPayload,
-          cfg,
-          dispatcher,
-          replyOptions: {
-            ...replyOptions,
-            abortSignal,
-            skillFilter: channelConfig?.skills,
-            sourceReplyDeliveryMode,
-            queuedDeliveryCorrelations: isRoomEvent
-              ? [{ begin: beginDeliveryCorrelation }]
-              : undefined,
-            suppressTyping: isRoomEvent ? true : undefined,
-            allowProgressCallbacksWhenSourceDeliverySuppressed:
-              sourceRepliesAreToolOnly && draftPreview.draftStream && draftPreview.isProgressMode
-                ? true
-                : undefined,
-            disableBlockStreaming: sourceRepliesAreToolOnly
-              ? true
-              : (draftPreview.disableBlockStreamingForDraft ??
-                (typeof resolvedBlockStreamingEnabled === "boolean"
-                  ? !resolvedBlockStreamingEnabled
-                  : undefined)),
-            onPartialReply:
-              draftPreview.draftStream && !draftPreview.isProgressMode
-                ? (payload) => draftPreview.updateFromPartial(payload.text)
-                : undefined,
-            onAssistantMessageStart: draftPreview.draftStream
-              ? () => draftPreview.handleAssistantMessageBoundary()
-              : undefined,
-            onReasoningEnd: draftPreview.draftStream
-              ? () => draftPreview.handleAssistantMessageBoundary()
-              : undefined,
-            onModelSelected,
-            suppressDefaultToolProgressMessages: draftPreview.suppressDefaultToolProgressMessages
-              ? true
-              : undefined,
-            onReasoningStream: async (payload) => {
-              await statusReactions.setThinking();
-              const formattedText = payload?.text
-                ? formatReasoningMessage(payload.text)
-                : undefined;
-              await draftPreview.pushReasoningProgress(formattedText);
-            },
-            onToolStart: async (payload) => {
-              if (isProcessAborted(abortSignal)) {
-                return;
-              }
-              await maybeBindStatusReactionsToToolReaction(payload);
-              await statusReactions.setTool(payload.name);
-              await draftPreview.pushToolProgress(
-                buildChannelProgressDraftLineForEntry(
-                  discordConfig,
-                  {
-                    event: "tool",
-                    name: payload.name,
-                    phase: payload.phase,
-                    args: payload.args,
-                  },
-                  payload.detailMode ? { detailMode: payload.detailMode } : undefined,
-                ),
-                { toolName: payload.name },
-              );
-            },
-            onItemEvent: async (payload) => {
-              await draftPreview.pushToolProgress(
-                buildChannelProgressDraftLineForEntry(discordConfig, {
-                  event: "item",
-                  itemId: payload.itemId,
-                  itemKind: payload.kind,
-                  title: payload.title,
-                  name: payload.name,
-                  phase: payload.phase,
-                  status: payload.status,
-                  summary: payload.summary,
-                  progressText: payload.progressText,
-                  meta: payload.meta,
-                }),
-              );
-            },
-            onPlanUpdate: async (payload) => {
-              if (payload.phase !== "update") {
-                return;
-              }
-              await draftPreview.pushToolProgress(
-                buildChannelProgressDraftLine({
-                  event: "plan",
-                  phase: payload.phase,
-                  title: payload.title,
-                  explanation: payload.explanation,
-                  steps: payload.steps,
-                }),
-              );
-            },
-            onApprovalEvent: async (payload) => {
-              if (payload.phase !== "requested") {
-                return;
-              }
-              await draftPreview.pushToolProgress(
-                buildChannelProgressDraftLine({
-                  event: "approval",
-                  phase: payload.phase,
-                  title: payload.title,
-                  command: payload.command,
-                  reason: payload.reason,
-                  message: payload.message,
-                }),
-              );
-            },
-            onCommandOutput: async (payload) => {
-              if (payload.phase !== "end") {
-                return;
-              }
-              await draftPreview.pushToolProgress(
-                buildChannelProgressDraftLine({
-                  event: "command-output",
-                  phase: payload.phase,
-                  title: payload.title,
-                  name: payload.name,
-                  status: payload.status,
-                  exitCode: payload.exitCode,
-                }),
-              );
-            },
-            onPatchSummary: async (payload) => {
-              if (payload.phase !== "end") {
-                return;
-              }
-              await draftPreview.pushToolProgress(
-                buildChannelProgressDraftLine({
-                  event: "patch",
-                  phase: payload.phase,
-                  title: payload.title,
-                  name: payload.name,
-                  added: payload.added,
-                  modified: payload.modified,
-                  deleted: payload.deleted,
-                  summary: payload.summary,
-                }),
-              );
-            },
-            onCompactionStart: async () => {
-              if (isProcessAborted(abortSignal)) {
-                return;
-              }
-              await statusReactions.setCompacting();
-            },
-            onCompactionEnd: async () => {
-              if (isProcessAborted(abortSignal)) {
-                return;
-              }
-              statusReactions.cancelPending();
-              await statusReactions.setThinking();
-            },
-          },
-        }),
-    });
-    if (!preparedResult.dispatched) {
-      return;
-    }
-    dispatchResult = preparedResult.dispatchResult;
-    if (isProcessAborted(abortSignal)) {
-      dispatchAborted = true;
-      return;
-    }
-  } catch (err) {
-    if (isProcessAborted(abortSignal)) {
-      dispatchAborted = true;
-      return;
-    }
-    dispatchError = true;
-    throw err;
-  } finally {
-    endDiscordInboundEventDeliveryCorrelation();
-    try {
-      await draftPreview.cleanup();
-    } finally {
-      if (!dispatchSettledBeforeStart) {
-        markRunComplete();
-        markDispatchIdle();
-      }
-    }
-    const finalDeliveryFailed = (dispatchResult?.failedCounts?.final ?? 0) > 0;
-    if (statusReactionsActive) {
-      if (dispatchAborted) {
-        if (removeAckAfterReply) {
-          void statusReactions.clear();
-        } else {
-          void statusReactions.restoreInitial();
-        }
-      } else {
-        if (dispatchError || finalDeliveryFailed) {
-          await statusReactions.setError();
-        } else {
-          await statusReactions.setDone();
-        }
-        if (removeAckAfterReply) {
-          void (async () => {
-            await sleep(
-              dispatchError || finalDeliveryFailed
-                ? DEFAULT_TIMING.errorHoldMs
-                : DEFAULT_TIMING.doneHoldMs,
-            );
-            await statusReactions.clear();
-          })();
-        } else {
-          void statusReactions.restoreInitial();
-        }
-      }
-    } else if (shouldSendAckReaction && ackReaction && removeAckAfterReply) {
-      void removeReactionDiscord(
-        messageChannelId,
-        message.id,
-        ackReaction,
-        ackReactionContext,
-      ).catch((err: unknown) => {
-        logAckFailure({
-          log: logVerbose,
-          channel: "discord",
-          target: `${messageChannelId}/${message.id}`,
-          error: err,
-        });
-      });
-    }
-  }
-  if (dispatchAborted) {
-    return;
-  }
-
-  const finalDispatchResult = dispatchResult;
-  if (!finalDispatchResult || !hasFinalInboundReplyDispatch(finalDispatchResult)) {
-    return;
-  }
-  if (shouldLogVerbose()) {
-    const finalCount = finalDispatchResult.counts.final;
-    logVerbose(
-      `discord: delivered ${finalCount} reply${finalCount === 1 ? "" : "ies"} to ${replyTarget}`,
-    );
-  }
-}