@poolzin/pool-bot 2026.2.21 → 2026.2.23

package/dist/discord/monitor/message-handler.process.js

@@ -1,39 +1,256 @@
 import { ChannelType } from "@buape/carbon";
 import { resolveAckReaction, resolveHumanDelayConfig } from "../../agents/identity.js";
-import { removeAckReactionAfterReply, shouldAckReaction as shouldAckReactionGate, } from "../../channels/ack-reactions.js";
-import { logTypingFailure, logAckFailure } from "../../channels/logging.js";
-import { createReplyPrefixContext } from "../../channels/reply-prefix.js";
-import { createTypingCallbacks } from "../../channels/typing.js";
-import { formatInboundEnvelope, formatThreadStarterEnvelope, resolveEnvelopeFormatOptions, } from "../../auto-reply/envelope.js";
+import { resolveChunkMode } from "../../auto-reply/chunk.js";
 import { dispatchInboundMessage } from "../../auto-reply/dispatch.js";
+import { formatInboundEnvelope, resolveEnvelopeFormatOptions } from "../../auto-reply/envelope.js";
 import { buildPendingHistoryContextFromMap, clearHistoryEntriesIfEnabled, } from "../../auto-reply/reply/history.js";
 import { finalizeInboundContext } from "../../auto-reply/reply/inbound-context.js";
 import { createReplyDispatcherWithTyping } from "../../auto-reply/reply/reply-dispatcher.js";
+import { shouldAckReaction as shouldAckReactionGate } from "../../channels/ack-reactions.js";
+import { logTypingFailure, logAckFailure } from "../../channels/logging.js";
+import { createReplyPrefixOptions } from "../../channels/reply-prefix.js";
 import { recordInboundSession } from "../../channels/session.js";
-import { readSessionUpdatedAt, resolveStorePath } from "../../config/sessions.js";
-import { resolveChunkMode } from "../../auto-reply/chunk.js";
+import { createTypingCallbacks } from "../../channels/typing.js";
 import { resolveMarkdownTableMode } from "../../config/markdown-tables.js";
+import { readSessionUpdatedAt, resolveStorePath } from "../../config/sessions.js";
 import { danger, logVerbose, shouldLogVerbose } from "../../globals.js";
 import { buildAgentSessionKey } from "../../routing/resolve-route.js";
 import { resolveThreadSessionKeys } from "../../routing/session-key.js";
+import { buildUntrustedChannelMetadata } from "../../security/channel-metadata.js";
 import { truncateUtf16Safe } from "../../utils.js";
 import { reactMessageDiscord, removeReactionDiscord } from "../send.js";
-import { normalizeDiscordSlug } from "./allow-list.js";
-import { formatDiscordUserTag, resolveTimestampMs } from "./format.js";
-import { buildDiscordMediaPayload, resolveDiscordMessageText, resolveMediaList, } from "./message-utils.js";
+import { normalizeDiscordSlug, resolveDiscordOwnerAllowFrom } from "./allow-list.js";
+import { resolveTimestampMs } from "./format.js";
+import { buildDiscordMediaPayload, resolveDiscordMessageText, resolveForwardedMediaList, resolveMediaList, } from "./message-utils.js";
 import { buildDirectLabel, buildGuildLabel, resolveReplyContext } from "./reply-context.js";
 import { deliverDiscordReply } from "./reply-delivery.js";
 import { resolveDiscordAutoThreadReplyPlan, resolveDiscordThreadStarter } from "./threading.js";
 import { sendTyping } from "./typing.js";
+const DISCORD_STATUS_THINKING_EMOJI = "🧠";
+const DISCORD_STATUS_TOOL_EMOJI = "🛠️";
+const DISCORD_STATUS_CODING_EMOJI = "💻";
+const DISCORD_STATUS_WEB_EMOJI = "🌐";
+const DISCORD_STATUS_DONE_EMOJI = "✅";
+const DISCORD_STATUS_ERROR_EMOJI = "❌";
+const DISCORD_STATUS_STALL_SOFT_EMOJI = "⏳";
+const DISCORD_STATUS_STALL_HARD_EMOJI = "⚠️";
+const DISCORD_STATUS_DONE_HOLD_MS = 1500;
+const DISCORD_STATUS_ERROR_HOLD_MS = 2500;
+const DISCORD_STATUS_DEBOUNCE_MS = 700;
+const DISCORD_STATUS_STALL_SOFT_MS = 10_000;
+const DISCORD_STATUS_STALL_HARD_MS = 30_000;
+const CODING_STATUS_TOOL_TOKENS = [
+    "exec",
+    "process",
+    "read",
+    "write",
+    "edit",
+    "session_status",
+    "bash",
+];
+const WEB_STATUS_TOOL_TOKENS = ["web_search", "web-search", "web_fetch", "web-fetch", "browser"];
+function resolveToolStatusEmoji(toolName) {
+    const normalized = toolName?.trim().toLowerCase() ?? "";
+    if (!normalized) {
+        return DISCORD_STATUS_TOOL_EMOJI;
+    }
+    if (WEB_STATUS_TOOL_TOKENS.some((token) => normalized.includes(token))) {
+        return DISCORD_STATUS_WEB_EMOJI;
+    }
+    if (CODING_STATUS_TOOL_TOKENS.some((token) => normalized.includes(token))) {
+        return DISCORD_STATUS_CODING_EMOJI;
+    }
+    return DISCORD_STATUS_TOOL_EMOJI;
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function createDiscordStatusReactionController(params) {
+    let activeEmoji = null;
+    let chain = Promise.resolve();
+    let pendingEmoji = null;
+    let pendingTimer = null;
+    let finished = false;
+    let softStallTimer = null;
+    let hardStallTimer = null;
+    const enqueue = (work) => {
+        chain = chain.then(work).catch((err) => {
+            logAckFailure({
+                log: logVerbose,
+                channel: "discord",
+                target: `${params.channelId}/${params.messageId}`,
+                error: err,
+            });
+        });
+        return chain;
+    };
+    const clearStallTimers = () => {
+        if (softStallTimer) {
+            clearTimeout(softStallTimer);
+            softStallTimer = null;
+        }
+        if (hardStallTimer) {
+            clearTimeout(hardStallTimer);
+            hardStallTimer = null;
+        }
+    };
+    const clearPendingDebounce = () => {
+        if (pendingTimer) {
+            clearTimeout(pendingTimer);
+            pendingTimer = null;
+        }
+        pendingEmoji = null;
+    };
+    const applyEmoji = (emoji) => enqueue(async () => {
+        if (!params.enabled || !emoji || activeEmoji === emoji) {
+            return;
+        }
+        const previousEmoji = activeEmoji;
+        await reactMessageDiscord(params.channelId, params.messageId, emoji, {
+            rest: params.rest,
+        });
+        activeEmoji = emoji;
+        if (previousEmoji && previousEmoji !== emoji) {
+            await removeReactionDiscord(params.channelId, params.messageId, previousEmoji, {
+                rest: params.rest,
+            });
+        }
+    });
+    const requestEmoji = (emoji, options) => {
+        if (!params.enabled || !emoji) {
+            return Promise.resolve();
+        }
+        if (options?.immediate) {
+            clearPendingDebounce();
+            return applyEmoji(emoji);
+        }
+        pendingEmoji = emoji;
+        if (pendingTimer) {
+            clearTimeout(pendingTimer);
+        }
+        pendingTimer = setTimeout(() => {
+            pendingTimer = null;
+            const emojiToApply = pendingEmoji;
+            pendingEmoji = null;
+            if (!emojiToApply || emojiToApply === activeEmoji) {
+                return;
+            }
+            void applyEmoji(emojiToApply);
+        }, DISCORD_STATUS_DEBOUNCE_MS);
+        return Promise.resolve();
+    };
+    const scheduleStallTimers = () => {
+        if (!params.enabled || finished) {
+            return;
+        }
+        clearStallTimers();
+        softStallTimer = setTimeout(() => {
+            if (finished) {
+                return;
+            }
+            void requestEmoji(DISCORD_STATUS_STALL_SOFT_EMOJI, { immediate: true });
+        }, DISCORD_STATUS_STALL_SOFT_MS);
+        hardStallTimer = setTimeout(() => {
+            if (finished) {
+                return;
+            }
+            void requestEmoji(DISCORD_STATUS_STALL_HARD_EMOJI, { immediate: true });
+        }, DISCORD_STATUS_STALL_HARD_MS);
+    };
+    const setPhase = (emoji) => {
+        if (!params.enabled || finished) {
+            return Promise.resolve();
+        }
+        scheduleStallTimers();
+        return requestEmoji(emoji);
+    };
+    const setTerminal = async (emoji) => {
+        if (!params.enabled) {
+            return;
+        }
+        finished = true;
+        clearStallTimers();
+        await requestEmoji(emoji, { immediate: true });
+    };
+    const clear = async () => {
+        if (!params.enabled) {
+            return;
+        }
+        finished = true;
+        clearStallTimers();
+        clearPendingDebounce();
+        await enqueue(async () => {
+            const cleanupCandidates = new Set([
+                params.initialEmoji,
+                activeEmoji ?? "",
+                DISCORD_STATUS_THINKING_EMOJI,
+                DISCORD_STATUS_TOOL_EMOJI,
+                DISCORD_STATUS_CODING_EMOJI,
+                DISCORD_STATUS_WEB_EMOJI,
+                DISCORD_STATUS_DONE_EMOJI,
+                DISCORD_STATUS_ERROR_EMOJI,
+                DISCORD_STATUS_STALL_SOFT_EMOJI,
+                DISCORD_STATUS_STALL_HARD_EMOJI,
+            ]);
+            activeEmoji = null;
+            for (const emoji of cleanupCandidates) {
+                if (!emoji) {
+                    continue;
+                }
+                try {
+                    await removeReactionDiscord(params.channelId, params.messageId, emoji, {
+                        rest: params.rest,
+                    });
+                }
+                catch (err) {
+                    logAckFailure({
+                        log: logVerbose,
+                        channel: "discord",
+                        target: `${params.channelId}/${params.messageId}`,
+                        error: err,
+                    });
+                }
+            }
+        });
+    };
+    const restoreInitial = async () => {
+        if (!params.enabled) {
+            return;
+        }
+        finished = true;
+        clearStallTimers();
+        clearPendingDebounce();
+        await requestEmoji(params.initialEmoji, { immediate: true });
+    };
+    return {
+        setQueued: () => {
+            scheduleStallTimers();
+            return requestEmoji(params.initialEmoji, { immediate: true });
+        },
+        setThinking: () => setPhase(DISCORD_STATUS_THINKING_EMOJI),
+        setTool: (toolName) => setPhase(resolveToolStatusEmoji(toolName)),
+        setDone: () => setTerminal(DISCORD_STATUS_DONE_EMOJI),
+        setError: () => setTerminal(DISCORD_STATUS_ERROR_EMOJI),
+        clear,
+        restoreInitial,
+    };
+}
 export async function processDiscordMessage(ctx) {
-    const { cfg, discordConfig, accountId, token, runtime, guildHistories, historyLimit, mediaMaxBytes, textLimit, replyToMode, ackReactionScope, message, author, data, client, channelInfo, channelName, isGuildMessage, isDirectMessage, isGroupDm, baseText, messageText, shouldRequireMention, canDetectMention, effectiveWasMentioned, shouldBypassMention, threadChannel, threadParentId, threadParentName, threadParentType, threadName, displayChannelSlug, guildInfo, guildSlug, channelConfig, baseSessionKey, route, commandAuthorized, } = ctx;
+    const { cfg, discordConfig, accountId, token, runtime, guildHistories, historyLimit, mediaMaxBytes, textLimit, replyToMode, ackReactionScope, message, author, sender, data, client, channelInfo, channelName, messageChannelId, isGuildMessage, isDirectMessage, isGroupDm, baseText, messageText, shouldRequireMention, canDetectMention, effectiveWasMentioned, shouldBypassMention, threadChannel, threadParentId, threadParentName, threadParentType, threadName, displayChannelSlug, guildInfo, guildSlug, channelConfig, baseSessionKey, route, commandAuthorized, } = ctx;
     const mediaList = await resolveMediaList(message, mediaMaxBytes);
+    const forwardedMediaList = await resolveForwardedMediaList(message, mediaMaxBytes);
+    mediaList.push(...forwardedMediaList);
     const text = messageText;
     if (!text) {
         logVerbose(`discord: drop message ${message.id} (empty content)`);
         return;
     }
-    const ackReaction = resolveAckReaction(cfg, route.agentId);
+    const ackReaction = resolveAckReaction(cfg, route.agentId, {
+        channel: "discord",
+        accountId,
+    });
     const removeAckAfterReply = cfg.messages?.removeAckAfterReply ?? false;
     const shouldAckReaction = () => Boolean(ackReaction &&
         shouldAckReactionGate({
@@ -46,26 +263,25 @@ export async function processDiscordMessage(ctx) {
             effectiveWasMentioned,
             shouldBypassMention,
         }));
-    const ackReactionPromise = shouldAckReaction()
-        ? reactMessageDiscord(message.channelId, message.id, ackReaction, {
-            rest: client.rest,
-        }).then(() => true, (err) => {
-            logVerbose(`discord react failed for channel ${message.channelId}: ${String(err)}`);
-            return false;
-        })
-        : null;
+    const statusReactionsEnabled = shouldAckReaction();
+    const statusReactions = createDiscordStatusReactionController({
+        enabled: statusReactionsEnabled,
+        channelId: messageChannelId,
+        messageId: message.id,
+        initialEmoji: ackReaction,
+        rest: client.rest,
+    });
+    if (statusReactionsEnabled) {
+        void statusReactions.setQueued();
+    }
     const fromLabel = isDirectMessage
         ? buildDirectLabel(author)
         : buildGuildLabel({
             guild: data.guild ?? undefined,
-            channelName: channelName ?? message.channelId,
-            channelId: message.channelId,
+            channelName: channelName ?? messageChannelId,
+            channelId: messageChannelId,
         });
-    const senderTag = formatDiscordUserTag(author);
-    const senderDisplay = data.member?.nickname ?? author.globalName ?? author.username;
-    const senderLabel = senderDisplay && senderTag && senderDisplay !== senderTag
-        ? `${senderDisplay} (${senderTag})`
-        : (senderDisplay ?? senderTag ?? author.id);
+    const senderLabel = sender.label;
     const isForumParent = threadParentType === ChannelType.GuildForum || threadParentType === ChannelType.GuildMedia;
     const forumParentSlug = isForumParent && threadParentName ? normalizeDiscordSlug(threadParentName) : "";
     const threadChannelId = threadChannel?.id;
@@ -73,12 +289,27 @@ export async function processDiscordMessage(ctx) {
     const forumContextLine = isForumStarter ? `[Forum parent: #${forumParentSlug}]` : null;
     const groupChannel = isGuildMessage && displayChannelSlug ? `#${displayChannelSlug}` : undefined;
     const groupSubject = isDirectMessage ? undefined : groupChannel;
-    const channelDescription = channelInfo?.topic?.trim();
-    const systemPromptParts = [
-        channelDescription ? `Channel topic: ${channelDescription}` : null,
-        channelConfig?.systemPrompt?.trim() || null,
-    ].filter((entry) => Boolean(entry));
+    const untrustedChannelMetadata = isGuildMessage
+        ? buildUntrustedChannelMetadata({
+            source: "discord",
+            label: "Discord channel topic",
+            entries: [channelInfo?.topic],
+        })
+        : undefined;
+    const senderName = sender.isPluralKit
+        ? (sender.name ?? author.username)
+        : (data.member?.nickname ?? author.globalName ?? author.username);
+    const senderUsername = sender.isPluralKit
+        ? (sender.tag ?? sender.name ?? author.username)
+        : author.username;
+    const senderTag = sender.tag;
+    const systemPromptParts = [channelConfig?.systemPrompt?.trim() || null].filter((entry) => Boolean(entry));
     const groupSystemPrompt = systemPromptParts.length > 0 ? systemPromptParts.join("\n\n") : undefined;
+    const ownerAllowFrom = resolveDiscordOwnerAllowFrom({
+        channelConfig,
+        guildInfo,
+        sender: { id: sender.id, name: sender.name, tag: sender.tag },
+    });
     const storePath = resolveStorePath(cfg.session?.store, {
         agentId: route.agentId,
     });
@@ -101,26 +332,21 @@ export async function processDiscordMessage(ctx) {
     if (shouldIncludeChannelHistory) {
         combinedBody = buildPendingHistoryContextFromMap({
             historyMap: guildHistories,
-            historyKey: message.channelId,
+            historyKey: messageChannelId,
             limit: historyLimit,
             currentMessage: combinedBody,
             formatEntry: (entry) => formatInboundEnvelope({
                 channel: "Discord",
                 from: fromLabel,
                 timestamp: entry.timestamp,
-                body: `${entry.body} [id:${entry.messageId ?? "unknown"} channel:${message.channelId}]`,
+                body: `${entry.body} [id:${entry.messageId ?? "unknown"} channel:${messageChannelId}]`,
                 chatType: "channel",
                 senderLabel: entry.sender,
                 envelope: envelopeOptions,
             }),
         });
     }
-    const replyContext = resolveReplyContext(message, resolveDiscordMessageText, {
-        envelope: envelopeOptions,
-    });
-    if (replyContext) {
-        combinedBody = `[Replied message - for context]\n${replyContext}\n\n${combinedBody}`;
-    }
+    const replyContext = resolveReplyContext(message, resolveDiscordMessageText);
     if (forumContextLine) {
         combinedBody = `${combinedBody}\n${forumContextLine}`;
     }
@@ -128,22 +354,19 @@ export async function processDiscordMessage(ctx) {
     let threadLabel;
     let parentSessionKey;
     if (threadChannel) {
-        const starter = await resolveDiscordThreadStarter({
-            channel: threadChannel,
-            client,
-            parentId: threadParentId,
-            parentType: threadParentType,
-            resolveTimestampMs,
-        });
-        if (starter?.text) {
-            const starterEnvelope = formatThreadStarterEnvelope({
-                channel: "Discord",
-                author: starter.author,
-                timestamp: starter.timestamp,
-                body: starter.text,
-                envelope: envelopeOptions,
+        const includeThreadStarter = channelConfig?.includeThreadStarter !== false;
+        if (includeThreadStarter) {
+            const starter = await resolveDiscordThreadStarter({
+                channel: threadChannel,
+                client,
+                parentId: threadParentId,
+                parentType: threadParentType,
+                resolveTimestampMs,
             });
-            threadStarterBody = starterEnvelope;
+            if (starter?.text) {
+                // Keep thread starter as raw text; metadata is provided out-of-band in the system prompt.
+                threadStarterBody = starter.text;
+            }
         }
         const parentName = threadParentName ?? "parent";
         threadLabel = threadName
@@ -160,16 +383,18 @@ export async function processDiscordMessage(ctx) {
     const mediaPayload = buildDiscordMediaPayload(mediaList);
     const threadKeys = resolveThreadSessionKeys({
         baseSessionKey,
-        threadId: threadChannel ? message.channelId : undefined,
+        threadId: threadChannel ? messageChannelId : undefined,
         parentSessionKey,
         useSuffix: false,
     });
     const replyPlan = await resolveDiscordAutoThreadReplyPlan({
         client,
         message,
+        messageChannelId,
         isGuildMessage,
         channelConfig,
         threadChannel,
+        channelType: channelInfo?.type,
         baseText: baseText ?? "",
         combinedBody,
         replyToMode,
@@ -182,14 +407,25 @@ export async function processDiscordMessage(ctx) {
     const autoThreadContext = replyPlan.autoThreadContext;
     const effectiveFrom = isDirectMessage
         ? `discord:${author.id}`
-        : (autoThreadContext?.From ?? `discord:channel:${message.channelId}`);
+        : (autoThreadContext?.From ?? `discord:channel:${messageChannelId}`);
     const effectiveTo = autoThreadContext?.To ?? replyTarget;
     if (!effectiveTo) {
         runtime.error?.(danger("discord: missing reply target"));
         return;
     }
+    // Keep DM routes user-addressed so follow-up sends resolve direct session keys.
+    const lastRouteTo = isDirectMessage ? `user:${author.id}` : effectiveTo;
+    const inboundHistory = shouldIncludeChannelHistory && historyLimit > 0
+        ? (guildHistories.get(messageChannelId) ?? []).map((entry) => ({
+            sender: entry.sender,
+            body: entry.body,
+            timestamp: entry.timestamp,
+        }))
+        : undefined;
     const ctxPayload = finalizeInboundContext({
         Body: combinedBody,
+        BodyForAgent: baseText ?? text,
+        InboundHistory: inboundHistory,
         RawBody: baseText,
         CommandBody: baseText,
         From: effectiveFrom,
@@ -198,18 +434,23 @@ export async function processDiscordMessage(ctx) {
         AccountId: route.accountId,
         ChatType: isDirectMessage ? "direct" : "channel",
         ConversationLabel: fromLabel,
-        SenderName: data.member?.nickname ?? author.globalName ?? author.username,
-        SenderId: author.id,
-        SenderUsername: author.username,
-        SenderTag: formatDiscordUserTag(author),
+        SenderName: senderName,
+        SenderId: sender.id,
+        SenderUsername: senderUsername,
+        SenderTag: senderTag,
         GroupSubject: groupSubject,
         GroupChannel: groupChannel,
+        UntrustedContext: untrustedChannelMetadata ? [untrustedChannelMetadata] : undefined,
         GroupSystemPrompt: isGuildMessage ? groupSystemPrompt : undefined,
         GroupSpace: isGuildMessage ? (guildInfo?.id ?? guildSlug) || undefined : undefined,
+        OwnerAllowFrom: ownerAllowFrom,
         Provider: "discord",
         Surface: "discord",
         WasMentioned: effectiveWasMentioned,
         MessageSid: message.id,
+        ReplyToId: replyContext?.id,
+        ReplyToBody: replyContext?.body,
+        ReplyToSender: replyContext?.sender,
         ParentSessionKey: autoThreadContext?.ParentSessionKey ?? threadKeys.parentSessionKey,
         ThreadStarterBody: threadStarterBody,
         ThreadLabel: threadLabel,
@@ -221,38 +462,52 @@ export async function processDiscordMessage(ctx) {
         OriginatingChannel: "discord",
         OriginatingTo: autoThreadContext?.OriginatingTo ?? replyTarget,
     });
+    const persistedSessionKey = ctxPayload.SessionKey ?? route.sessionKey;
     await recordInboundSession({
         storePath,
-        sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+        sessionKey: persistedSessionKey,
         ctx: ctxPayload,
-        updateLastRoute: isDirectMessage
-            ? {
-                sessionKey: route.mainSessionKey,
-                channel: "discord",
-                to: `user:${author.id}`,
-                accountId: route.accountId,
-            }
-            : undefined,
+        updateLastRoute: {
+            sessionKey: persistedSessionKey,
+            channel: "discord",
+            to: lastRouteTo,
+            accountId: route.accountId,
+        },
         onRecordError: (err) => {
             logVerbose(`discord: failed updating session meta: ${String(err)}`);
         },
     });
     if (shouldLogVerbose()) {
         const preview = truncateUtf16Safe(combinedBody, 200).replace(/\n/g, "\\n");
-        logVerbose(`discord inbound: channel=${message.channelId} deliver=${deliverTarget} from=${ctxPayload.From} preview="${preview}"`);
+        logVerbose(`discord inbound: channel=${messageChannelId} deliver=${deliverTarget} from=${ctxPayload.From} preview="${preview}"`);
     }
     const typingChannelId = deliverTarget.startsWith("channel:")
         ? deliverTarget.slice("channel:".length)
-        : message.channelId;
-    const prefixContext = createReplyPrefixContext({ cfg, agentId: route.agentId });
+        : messageChannelId;
+    const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
+        cfg,
+        agentId: route.agentId,
+        channel: "discord",
+        accountId: route.accountId,
+    });
     const tableMode = resolveMarkdownTableMode({
         cfg,
         channel: "discord",
         accountId,
     });
+    const typingCallbacks = createTypingCallbacks({
+        start: () => sendTyping({ client, channelId: typingChannelId }),
+        onStartError: (err) => {
+            logTypingFailure({
+                log: logVerbose,
+                channel: "discord",
+                target: typingChannelId,
+                error: err,
+            });
+        },
+    });
     const { dispatcher, replyOptions, markDispatchIdle } = createReplyDispatcherWithTyping({
-        responsePrefix: prefixContext.responsePrefix,
-        responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
+        ...prefixOptions,
         humanDelay: resolveHumanDelayConfig(cfg, route.agentId),
         deliver: async (payload) => {
             const replyToId = replyReference.use();
@@ -274,70 +529,76 @@ export async function processDiscordMessage(ctx) {
         onError: (err, info) => {
             runtime.error?.(danger(`discord ${info.kind} reply failed: ${String(err)}`));
         },
-        onReplyStart: createTypingCallbacks({
-            start: () => sendTyping({ client, channelId: typingChannelId }),
-            onStartError: (err) => {
-                logTypingFailure({
-                    log: logVerbose,
-                    channel: "discord",
-                    target: typingChannelId,
-                    error: err,
-                });
-            },
-        }).onReplyStart,
-    });
-    const { queuedFinal, counts } = await dispatchInboundMessage({
-        ctx: ctxPayload,
-        cfg,
-        dispatcher,
-        replyOptions: {
-            ...replyOptions,
-            skillFilter: channelConfig?.skills,
-            disableBlockStreaming: typeof discordConfig?.blockStreaming === "boolean"
-                ? !discordConfig.blockStreaming
-                : undefined,
-            onModelSelected: (ctx) => {
-                prefixContext.onModelSelected(ctx);
-            },
+        onReplyStart: async () => {
+            await typingCallbacks.onReplyStart();
+            await statusReactions.setThinking();
         },
     });
-    markDispatchIdle();
-    if (!queuedFinal) {
+    let dispatchResult = null;
+    let dispatchError = false;
+    try {
+        dispatchResult = await dispatchInboundMessage({
+            ctx: ctxPayload,
+            cfg,
+            dispatcher,
+            replyOptions: {
+                ...replyOptions,
+                skillFilter: channelConfig?.skills,
+                disableBlockStreaming: typeof discordConfig?.blockStreaming === "boolean"
+                    ? !discordConfig.blockStreaming
+                    : undefined,
+                onModelSelected,
+                onReasoningStream: async () => {
+                    await statusReactions.setThinking();
+                },
+                onToolStart: async (payload) => {
+                    await statusReactions.setTool(payload.name);
+                },
+            },
+        });
+    }
+    catch (err) {
+        dispatchError = true;
+        throw err;
+    }
+    finally {
+        markDispatchIdle();
+        if (statusReactionsEnabled) {
+            if (dispatchError) {
+                await statusReactions.setError();
+            }
+            else {
+                await statusReactions.setDone();
+            }
+            if (removeAckAfterReply) {
+                void (async () => {
+                    await sleep(dispatchError ? DISCORD_STATUS_ERROR_HOLD_MS : DISCORD_STATUS_DONE_HOLD_MS);
+                    await statusReactions.clear();
+                })();
+            }
+            else {
+                void statusReactions.restoreInitial();
+            }
+        }
+    }
+    if (!dispatchResult?.queuedFinal) {
         if (isGuildMessage) {
             clearHistoryEntriesIfEnabled({
                 historyMap: guildHistories,
-                historyKey: message.channelId,
+                historyKey: messageChannelId,
                 limit: historyLimit,
             });
         }
         return;
     }
     if (shouldLogVerbose()) {
-        const finalCount = counts.final;
+        const finalCount = dispatchResult.counts.final;
         logVerbose(`discord: delivered ${finalCount} reply${finalCount === 1 ? "" : "ies"} to ${replyTarget}`);
     }
-    removeAckReactionAfterReply({
-        removeAfterReply: removeAckAfterReply,
-        ackReactionPromise,
-        ackReactionValue: ackReaction,
-        remove: async () => {
-            await removeReactionDiscord(message.channelId, message.id, ackReaction, {
-                rest: client.rest,
-            });
-        },
-        onError: (err) => {
-            logAckFailure({
-                log: logVerbose,
-                channel: "discord",
-                target: `${message.channelId}/${message.id}`,
-                error: err,
-            });
-        },
-    });
     if (isGuildMessage) {
         clearHistoryEntriesIfEnabled({
             historyMap: guildHistories,
-            historyKey: message.channelId,
+            historyKey: messageChannelId,
             limit: historyLimit,
         });
     }