@poolzin/pool-bot 2026.2.25 → 2026.2.26

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

@@ -1,5 +1,6 @@
 import { ChannelType } from "@buape/carbon";
 import { resolveAckReaction, resolveHumanDelayConfig } from "../../agents/identity.js";
+import { EmbeddedBlockChunker } from "../../agents/pi-embedded-block-chunker.js";
 import { resolveChunkMode } from "../../auto-reply/chunk.js";
 import { dispatchInboundMessage } from "../../auto-reply/dispatch.js";
 import { formatInboundEnvelope, resolveEnvelopeFormatOptions } from "../../auto-reply/envelope.js";
@@ -10,15 +11,22 @@ import { shouldAckReaction as shouldAckReactionGate } from "../../channels/ack-r
 import { logTypingFailure, logAckFailure } from "../../channels/logging.js";
 import { createReplyPrefixOptions } from "../../channels/reply-prefix.js";
 import { recordInboundSession } from "../../channels/session.js";
+import { createStatusReactionController, DEFAULT_TIMING, } from "../../channels/status-reactions.js";
 import { createTypingCallbacks } from "../../channels/typing.js";
+import { resolveDiscordPreviewStreamMode } from "../../config/discord-preview-streaming.js";
 import { resolveMarkdownTableMode } from "../../config/markdown-tables.js";
 import { readSessionUpdatedAt, resolveStorePath } from "../../config/sessions.js";
 import { danger, logVerbose, shouldLogVerbose } from "../../globals.js";
+import { convertMarkdownTables } from "../../markdown/tables.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 { chunkDiscordTextWithMode } from "../chunk.js";
+import { resolveDiscordDraftStreamingChunking } from "../draft-chunking.js";
+import { createDiscordDraftStream } from "../draft-stream.js";
 import { reactMessageDiscord, removeReactionDiscord } from "../send.js";
+import { editMessageDiscord } from "../send.messages.js";
 import { normalizeDiscordSlug, resolveDiscordOwnerAllowFrom } from "./allow-list.js";
 import { resolveTimestampMs } from "./format.js";
 import { buildDiscordMediaPayload, resolveDiscordMessageText, resolveForwardedMediaList, resolveMediaList, } from "./message-utils.js";
@@ -26,219 +34,13 @@ import { buildDirectLabel, buildGuildLabel, resolveReplyContext } from "./reply-
 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, 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 { 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, boundSessionKey, threadBindings, route, commandAuthorized, } = ctx;
     const mediaList = await resolveMediaList(message, mediaMaxBytes);
     const forwardedMediaList = await resolveForwardedMediaList(message, mediaMaxBytes);
     mediaList.push(...forwardedMediaList);
@@ -264,12 +66,30 @@ export async function processDiscordMessage(ctx) {
             shouldBypassMention,
         }));
     const statusReactionsEnabled = shouldAckReaction();
-    const statusReactions = createDiscordStatusReactionController({
+    const discordAdapter = {
+        setReaction: async (emoji) => {
+            await reactMessageDiscord(messageChannelId, message.id, emoji, {
+                rest: client.rest,
+            });
+        },
+        removeReaction: async (emoji) => {
+            await removeReactionDiscord(messageChannelId, message.id, emoji, {
+                rest: client.rest,
+            });
+        },
+    };
+    const statusReactions = createStatusReactionController({
         enabled: statusReactionsEnabled,
-        channelId: messageChannelId,
-        messageId: message.id,
+        adapter: discordAdapter,
         initialEmoji: ackReaction,
-        rest: client.rest,
+        onError: (err) => {
+            logAckFailure({
+                log: logVerbose,
+                channel: "discord",
+                target: `${messageChannelId}/${message.id}`,
+                error: err,
+            });
+        },
     });
     if (statusReactionsEnabled) {
         void statusReactions.setQueued();
@@ -430,7 +250,7 @@ export async function processDiscordMessage(ctx) {
         CommandBody: baseText,
         From: effectiveFrom,
         To: effectiveTo,
-        SessionKey: autoThreadContext?.SessionKey ?? threadKeys.sessionKey,
+        SessionKey: boundSessionKey ?? autoThreadContext?.SessionKey ?? threadKeys.sessionKey,
         AccountId: route.accountId,
         ChatType: isDirectMessage ? "direct" : "channel",
         ConversationLabel: fromLabel,
@@ -452,6 +272,7 @@ export async function processDiscordMessage(ctx) {
         ReplyToBody: replyContext?.body,
         ReplyToSender: replyContext?.sender,
         ParentSessionKey: autoThreadContext?.ParentSessionKey ?? threadKeys.parentSessionKey,
+        MessageThreadId: threadChannel?.id ?? autoThreadContext?.createdThreadId ?? undefined,
         ThreadStarterBody: threadStarterBody,
         ThreadLabel: threadLabel,
         Timestamp: resolveTimestampMs(message.timestamp),
@@ -495,6 +316,7 @@ export async function processDiscordMessage(ctx) {
         channel: "discord",
         accountId,
     });
+    const chunkMode = resolveChunkMode(cfg, "discord", accountId);
     const typingCallbacks = createTypingCallbacks({
         start: () => sendTyping({ client, channelId: typingChannelId }),
         onStartError: (err) => {
@@ -506,10 +328,185 @@ export async function processDiscordMessage(ctx) {
             });
         },
     });
+    // --- Discord draft stream (edit-based preview streaming) ---
+    const discordStreamMode = resolveDiscordPreviewStreamMode(discordConfig);
+    const draftMaxChars = Math.min(textLimit, 2000);
+    const accountBlockStreamingEnabled = typeof discordConfig?.blockStreaming === "boolean"
+        ? discordConfig.blockStreaming
+        : cfg.agents?.defaults?.blockStreamingDefault === "on";
+    const canStreamDraft = discordStreamMode !== "off" && !accountBlockStreamingEnabled;
+    const draftReplyToMessageId = () => replyReference.use();
+    const deliverChannelId = deliverTarget.startsWith("channel:")
+        ? deliverTarget.slice("channel:".length)
+        : messageChannelId;
+    const draftStream = canStreamDraft
+        ? createDiscordDraftStream({
+            rest: client.rest,
+            channelId: deliverChannelId,
+            maxChars: draftMaxChars,
+            replyToMessageId: draftReplyToMessageId,
+            minInitialChars: 30,
+            throttleMs: 1200,
+            log: logVerbose,
+            warn: logVerbose,
+        })
+        : undefined;
+    const draftChunking = draftStream && discordStreamMode === "block"
+        ? resolveDiscordDraftStreamingChunking(cfg, accountId)
+        : undefined;
+    const shouldSplitPreviewMessages = discordStreamMode === "block";
+    const draftChunker = draftChunking ? new EmbeddedBlockChunker(draftChunking) : undefined;
+    let lastPartialText = "";
+    let draftText = "";
+    let hasStreamedMessage = false;
+    let finalizedViaPreviewMessage = false;
+    const resolvePreviewFinalText = (text) => {
+        if (typeof text !== "string") {
+            return undefined;
+        }
+        const formatted = convertMarkdownTables(text, tableMode);
+        const chunks = chunkDiscordTextWithMode(formatted, {
+            maxChars: draftMaxChars,
+            maxLines: discordConfig?.maxLinesPerMessage,
+            chunkMode,
+        });
+        if (!chunks.length && formatted) {
+            chunks.push(formatted);
+        }
+        if (chunks.length !== 1) {
+            return undefined;
+        }
+        const trimmed = chunks[0].trim();
+        if (!trimmed) {
+            return undefined;
+        }
+        const currentPreviewText = discordStreamMode === "block" ? draftText : lastPartialText;
+        if (currentPreviewText &&
+            currentPreviewText.startsWith(trimmed) &&
+            trimmed.length < currentPreviewText.length) {
+            return undefined;
+        }
+        return trimmed;
+    };
+    const updateDraftFromPartial = (text) => {
+        if (!draftStream || !text) {
+            return;
+        }
+        if (text === lastPartialText) {
+            return;
+        }
+        hasStreamedMessage = true;
+        if (discordStreamMode === "partial") {
+            // Keep the longer preview to avoid visible punctuation flicker.
+            if (lastPartialText &&
+                lastPartialText.startsWith(text) &&
+                text.length < lastPartialText.length) {
+                return;
+            }
+            lastPartialText = text;
+            draftStream.update(text);
+            return;
+        }
+        let delta = text;
+        if (text.startsWith(lastPartialText)) {
+            delta = text.slice(lastPartialText.length);
+        }
+        else {
+            // Streaming buffer reset (or non-monotonic stream). Start fresh.
+            draftChunker?.reset();
+            draftText = "";
+        }
+        lastPartialText = text;
+        if (!delta) {
+            return;
+        }
+        if (!draftChunker) {
+            draftText = text;
+            draftStream.update(draftText);
+            return;
+        }
+        draftChunker.append(delta);
+        draftChunker.drain({
+            force: false,
+            emit: (chunk) => {
+                draftText += chunk;
+                draftStream.update(draftText);
+            },
+        });
+    };
+    const flushDraft = async () => {
+        if (!draftStream) {
+            return;
+        }
+        if (draftChunker?.hasBuffered()) {
+            draftChunker.drain({
+                force: true,
+                emit: (chunk) => {
+                    draftText += chunk;
+                },
+            });
+            draftChunker.reset();
+            if (draftText) {
+                draftStream.update(draftText);
+            }
+        }
+        await draftStream.flush();
+    };
+    // When draft streaming is active, suppress block streaming to avoid double-streaming.
+    const disableBlockStreamingForDraft = draftStream ? true : undefined;
     const { dispatcher, replyOptions, markDispatchIdle } = createReplyDispatcherWithTyping({
         ...prefixOptions,
         humanDelay: resolveHumanDelayConfig(cfg, route.agentId),
-        deliver: async (payload) => {
+        deliver: async (payload, info) => {
+            const isFinal = info.kind === "final";
+            if (draftStream && isFinal) {
+                await flushDraft();
+                const hasMedia = Boolean(payload.mediaUrl) || (payload.mediaUrls?.length ?? 0) > 0;
+                const finalText = payload.text;
+                const previewFinalText = resolvePreviewFinalText(finalText);
+                const previewMessageId = draftStream.messageId();
+                // Try to finalize via preview edit (text-only, fits in 2000 chars, not an error)
+                const canFinalizeViaPreviewEdit = !finalizedViaPreviewMessage &&
+                    !hasMedia &&
+                    typeof previewFinalText === "string" &&
+                    typeof previewMessageId === "string" &&
+                    !payload.isError;
+                if (canFinalizeViaPreviewEdit) {
+                    await draftStream.stop();
+                    try {
+                        await editMessageDiscord(deliverChannelId, previewMessageId, { content: previewFinalText }, { rest: client.rest });
+                        finalizedViaPreviewMessage = true;
+                        replyReference.markSent();
+                        return;
+                    }
+                    catch (err) {
+                        logVerbose(`discord: preview final edit failed; falling back to standard send (${String(err)})`);
+                    }
+                }
+                // Check if stop() flushed a message we can edit
+                if (!finalizedViaPreviewMessage) {
+                    await draftStream.stop();
+                    const messageIdAfterStop = draftStream.messageId();
+                    if (typeof messageIdAfterStop === "string" &&
+                        typeof previewFinalText === "string" &&
+                        !hasMedia &&
+                        !payload.isError) {
+                        try {
+                            await editMessageDiscord(deliverChannelId, messageIdAfterStop, { content: previewFinalText }, { rest: client.rest });
+                            finalizedViaPreviewMessage = true;
+                            replyReference.markSent();
+                            return;
+                        }
+                        catch (err) {
+                            logVerbose(`discord: post-stop preview edit failed; falling back to standard send (${String(err)})`);
+                        }
+                    }
+                }
+                // Clear the preview and fall through to standard delivery
+                if (!finalizedViaPreviewMessage) {
+                    await draftStream.clear();
+                }
+            }
             const replyToId = replyReference.use();
             await deliverDiscordReply({
                 replies: [payload],
@@ -519,10 +516,13 @@ export async function processDiscordMessage(ctx) {
                 rest: client.rest,
                 runtime,
                 replyToId,
+                replyToMode,
                 textLimit,
                 maxLinesPerMessage: discordConfig?.maxLinesPerMessage,
                 tableMode,
-                chunkMode: resolveChunkMode(cfg, "discord", accountId),
+                chunkMode,
+                sessionKey: ctxPayload.SessionKey,
+                threadBindings,
             });
             replyReference.markSent();
         },
@@ -544,8 +544,32 @@ export async function processDiscordMessage(ctx) {
             replyOptions: {
                 ...replyOptions,
                 skillFilter: channelConfig?.skills,
-                disableBlockStreaming: typeof discordConfig?.blockStreaming === "boolean"
-                    ? !discordConfig.blockStreaming
+                disableBlockStreaming: disableBlockStreamingForDraft ??
+                    (typeof discordConfig?.blockStreaming === "boolean"
+                        ? !discordConfig.blockStreaming
+                        : undefined),
+                onPartialReply: draftStream ? (payload) => updateDraftFromPartial(payload.text) : undefined,
+                onAssistantMessageStart: draftStream
+                    ? () => {
+                        if (shouldSplitPreviewMessages && hasStreamedMessage) {
+                            logVerbose("discord: calling forceNewMessage() for draft stream");
+                            draftStream.forceNewMessage();
+                        }
+                        lastPartialText = "";
+                        draftText = "";
+                        draftChunker?.reset();
+                    }
+                    : undefined,
+                onReasoningEnd: draftStream
+                    ? () => {
+                        if (shouldSplitPreviewMessages && hasStreamedMessage) {
+                            logVerbose("discord: calling forceNewMessage() for draft stream");
+                            draftStream.forceNewMessage();
+                        }
+                        lastPartialText = "";
+                        draftText = "";
+                        draftChunker?.reset();
+                    }
                     : undefined,
                 onModelSelected,
                 onReasoningStream: async () => {
@@ -562,6 +586,11 @@ export async function processDiscordMessage(ctx) {
         throw err;
     }
     finally {
+        // Must stop() first to flush debounced content before clear() wipes state
+        await draftStream?.stop();
+        if (!finalizedViaPreviewMessage) {
+            await draftStream?.clear();
+        }
         markDispatchIdle();
         if (statusReactionsEnabled) {
             if (dispatchError) {
@@ -572,7 +601,7 @@ export async function processDiscordMessage(ctx) {
             }
             if (removeAckAfterReply) {
                 void (async () => {
-                    await sleep(dispatchError ? DISCORD_STATUS_ERROR_HOLD_MS : DISCORD_STATUS_DONE_HOLD_MS);
+                    await sleep(dispatchError ? DEFAULT_TIMING.errorHoldMs : DEFAULT_TIMING.doneHoldMs);
                     await statusReactions.clear();
                 })();
             }