@poolzin/pool-bot 2026.2.21 → 2026.2.22

package/dist/telegram/bot-message-dispatch.js

@@ -7,43 +7,49 @@ import { clearHistoryEntriesIfEnabled } from "../auto-reply/reply/history.js";
 import { dispatchReplyWithBufferedBlockDispatcher } from "../auto-reply/reply/provider-dispatcher.js";
 import { removeAckReactionAfterReply } from "../channels/ack-reactions.js";
 import { logAckFailure, logTypingFailure } from "../channels/logging.js";
-import { createReplyPrefixContext } from "../channels/reply-prefix.js";
+import { createReplyPrefixOptions } from "../channels/reply-prefix.js";
 import { createTypingCallbacks } from "../channels/typing.js";
 import { resolveMarkdownTableMode } from "../config/markdown-tables.js";
 import { danger, logVerbose } from "../globals.js";
+import { getAgentScopedMediaLocalRoots } from "../media/local-roots.js";
 import { deliverReplies } from "./bot/delivery.js";
 import { resolveTelegramDraftStreamingChunking } from "./draft-chunking.js";
 import { createTelegramDraftStream } from "./draft-stream.js";
+import { editMessageTelegram } from "./send.js";
 import { cacheSticker, describeStickerImage } from "./sticker-cache.js";
 const EMPTY_RESPONSE_FALLBACK = "No response generated. Please try again.";
+/** Minimum chars before sending first streaming message (improves push notification UX) */
+const DRAFT_MIN_INITIAL_CHARS = 30;
 async function resolveStickerVisionSupport(cfg, agentId) {
     try {
         const catalog = await loadModelCatalog({ config: cfg });
         const defaultModel = resolveDefaultModelForAgent({ cfg, agentId });
         const entry = findModelInCatalog(catalog, defaultModel.provider, defaultModel.model);
-        if (!entry)
+        if (!entry) {
             return false;
+        }
         return modelSupportsVision(entry);
     }
     catch {
         return false;
     }
 }
-export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, replyToMode, streamMode, textLimit, telegramCfg, opts, resolveBotTopicsEnabled, }) => {
-    const { ctxPayload, primaryCtx, msg, chatId, isGroup, resolvedThreadId, historyKey, historyLimit, groupHistories, route, skillFilter, sendTyping, sendRecordVoice, ackReactionPromise, reactionApi, removeAckAfterReply, } = context;
-    const isPrivateChat = msg.chat.type === "private";
+export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, replyToMode, streamMode, textLimit, telegramCfg, opts, }) => {
+    const { ctxPayload, msg, chatId, isGroup, threadSpec, historyKey, historyLimit, groupHistories, route, skillFilter, sendTyping, sendRecordVoice, ackReactionPromise, reactionApi, removeAckAfterReply, } = context;
     const draftMaxChars = Math.min(textLimit, 4096);
-    const canStreamDraft = streamMode !== "off" &&
-        isPrivateChat &&
-        typeof resolvedThreadId === "number" &&
-        (await resolveBotTopicsEnabled(primaryCtx));
+    const accountBlockStreamingEnabled = typeof telegramCfg.blockStreaming === "boolean"
+        ? telegramCfg.blockStreaming
+        : cfg.agents?.defaults?.blockStreamingDefault === "on";
+    const canStreamDraft = streamMode !== "off" && !accountBlockStreamingEnabled;
+    const draftReplyToMessageId = replyToMode !== "off" && typeof msg.message_id === "number" ? msg.message_id : undefined;
     const draftStream = canStreamDraft
         ? createTelegramDraftStream({
             api: bot.api,
             chatId,
-            draftId: msg.message_id || Date.now(),
             maxChars: draftMaxChars,
-            messageThreadId: resolvedThreadId,
+            thread: threadSpec,
+            replyToMessageId: draftReplyToMessageId,
+            minInitialChars: DRAFT_MIN_INITIAL_CHARS,
             log: logVerbose,
             warn: logVerbose,
         })
@@ -51,15 +57,30 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
     const draftChunking = draftStream && streamMode === "block"
         ? resolveTelegramDraftStreamingChunking(cfg, route.accountId)
         : undefined;
+    const shouldSplitPreviewMessages = streamMode === "block";
     const draftChunker = draftChunking ? new EmbeddedBlockChunker(draftChunking) : undefined;
+    const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, route.agentId);
     let lastPartialText = "";
     let draftText = "";
+    let hasStreamedMessage = false;
     const updateDraftFromPartial = (text) => {
-        if (!draftStream || !text)
+        if (!draftStream || !text) {
             return;
-        if (text === lastPartialText)
+        }
+        if (text === lastPartialText) {
             return;
+        }
+        // Mark that we've received streaming content (for forceNewMessage decision).
+        hasStreamedMessage = true;
         if (streamMode === "partial") {
+            // Some providers briefly emit a shorter prefix snapshot (for example
+            // "Sure." -> "Sure" -> "Sure."). 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;
@@ -74,8 +95,9 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
             draftText = "";
         }
         lastPartialText = text;
-        if (!delta)
+        if (!delta) {
             return;
+        }
         if (!draftChunker) {
             draftText = text;
             draftStream.update(draftText);
@@ -91,8 +113,9 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
         });
     };
     const flushDraft = async () => {
-        if (!draftStream)
+        if (!draftStream) {
             return;
+        }
         if (draftChunker?.hasBuffered()) {
             draftChunker.drain({
                 force: true,
@@ -101,14 +124,23 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
                 },
             });
             draftChunker.reset();
-            if (draftText)
+            if (draftText) {
                 draftStream.update(draftText);
+            }
         }
         await draftStream.flush();
     };
-    const disableBlockStreaming = Boolean(draftStream) ||
-        (typeof telegramCfg.blockStreaming === "boolean" ? !telegramCfg.blockStreaming : undefined);
-    const prefixContext = createReplyPrefixContext({ cfg, agentId: route.agentId });
+    const disableBlockStreaming = typeof telegramCfg.blockStreaming === "boolean"
+        ? !telegramCfg.blockStreaming
+        : draftStream || streamMode === "off"
+            ? true
+            : undefined;
+    const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
+        cfg,
+        agentId: route.agentId,
+        channel: "telegram",
+        accountId: route.accountId,
+    });
     const tableMode = resolveMarkdownTableMode({
         cfg,
         channel: "telegram",
@@ -167,99 +199,199 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
             }
         }
     }
-    // TODO: pass replyQuoteText to deliverReplies once delivery.ts supports it
-    const _replyQuoteText = ctxPayload.ReplyToIsQuote && ctxPayload.ReplyToBody
+    const replyQuoteText = ctxPayload.ReplyToIsQuote && ctxPayload.ReplyToBody
         ? ctxPayload.ReplyToBody.trim() || undefined
         : undefined;
-    void _replyQuoteText;
     const deliveryState = {
         delivered: false,
+        skippedNonSilent: 0,
     };
-    const { queuedFinal, counts } = await dispatchReplyWithBufferedBlockDispatcher({
-        ctx: ctxPayload,
-        cfg,
-        dispatcherOptions: {
-            responsePrefix: prefixContext.responsePrefix,
-            responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
-            deliver: async (payload, info) => {
-                if (info.kind === "final") {
-                    await flushDraft();
-                    draftStream?.stop();
-                }
-                await deliverReplies({
-                    replies: [payload],
-                    chatId: String(chatId),
-                    token: opts.token,
-                    runtime,
-                    bot,
-                    replyToMode,
-                    textLimit,
-                    messageThreadId: resolvedThreadId,
-                    tableMode,
-                    chunkMode,
-                    onVoiceRecording: sendRecordVoice,
-                    linkPreview: telegramCfg.linkPreview,
-                });
-                deliveryState.delivered = true;
-            },
-            onError: (err, info) => {
-                runtime.error?.(danger(`telegram ${info.kind} reply failed: ${String(err)}`));
-            },
-            onReplyStart: createTypingCallbacks({
-                start: sendTyping,
-                onStartError: (err) => {
-                    logTypingFailure({
-                        log: logVerbose,
-                        channel: "telegram",
-                        target: String(chatId),
-                        error: err,
+    let finalizedViaPreviewMessage = false;
+    const clearGroupHistory = () => {
+        if (isGroup && historyKey) {
+            clearHistoryEntriesIfEnabled({ historyMap: groupHistories, historyKey, limit: historyLimit });
+        }
+    };
+    const deliveryBaseOptions = {
+        chatId: String(chatId),
+        token: opts.token,
+        runtime,
+        bot,
+        mediaLocalRoots,
+        replyToMode,
+        textLimit,
+        thread: threadSpec,
+        tableMode,
+        chunkMode,
+        linkPreview: telegramCfg.linkPreview,
+        replyQuoteText,
+    };
+    let queuedFinal = false;
+    try {
+        ({ queuedFinal } = await dispatchReplyWithBufferedBlockDispatcher({
+            ctx: ctxPayload,
+            cfg,
+            dispatcherOptions: {
+                ...prefixOptions,
+                deliver: async (payload, info) => {
+                    if (info.kind === "final") {
+                        await flushDraft();
+                        const hasMedia = Boolean(payload.mediaUrl) || (payload.mediaUrls?.length ?? 0) > 0;
+                        const previewMessageId = draftStream?.messageId();
+                        const finalText = payload.text;
+                        const currentPreviewText = streamMode === "block" ? draftText : lastPartialText;
+                        const previewButtons = payload.channelData?.telegram?.buttons;
+                        let draftStoppedForPreviewEdit = false;
+                        // Skip preview edit for error payloads to avoid overwriting previous content
+                        const canFinalizeViaPreviewEdit = !finalizedViaPreviewMessage &&
+                            !hasMedia &&
+                            typeof finalText === "string" &&
+                            finalText.length > 0 &&
+                            typeof previewMessageId === "number" &&
+                            finalText.length <= draftMaxChars &&
+                            !payload.isError;
+                        if (canFinalizeViaPreviewEdit) {
+                            await draftStream?.stop();
+                            draftStoppedForPreviewEdit = true;
+                            if (currentPreviewText &&
+                                currentPreviewText.startsWith(finalText) &&
+                                finalText.length < currentPreviewText.length) {
+                                // Ignore regressive final edits (e.g., "Okay." -> "Ok"), which
+                                // can appear transiently in some provider streams.
+                                return;
+                            }
+                            try {
+                                await editMessageTelegram(chatId, previewMessageId, finalText, {
+                                    api: bot.api,
+                                    cfg,
+                                    accountId: route.accountId,
+                                    linkPreview: telegramCfg.linkPreview,
+                                    buttons: previewButtons,
+                                });
+                                finalizedViaPreviewMessage = true;
+                                deliveryState.delivered = true;
+                                return;
+                            }
+                            catch (err) {
+                                logVerbose(`telegram: preview final edit failed; falling back to standard send (${String(err)})`);
+                            }
+                        }
+                        if (!hasMedia &&
+                            !payload.isError &&
+                            typeof finalText === "string" &&
+                            finalText.length > draftMaxChars) {
+                            logVerbose(`telegram: preview final too long for edit (${finalText.length} > ${draftMaxChars}); falling back to standard send`);
+                        }
+                        if (!draftStoppedForPreviewEdit) {
+                            await draftStream?.stop();
+                        }
+                        // Check if stop() sent a message (debounce released on isFinal)
+                        // If so, edit that message instead of sending a new one
+                        const messageIdAfterStop = draftStream?.messageId();
+                        if (!finalizedViaPreviewMessage &&
+                            typeof messageIdAfterStop === "number" &&
+                            typeof finalText === "string" &&
+                            finalText.length > 0 &&
+                            finalText.length <= draftMaxChars &&
+                            !hasMedia &&
+                            !payload.isError) {
+                            try {
+                                await editMessageTelegram(chatId, messageIdAfterStop, finalText, {
+                                    api: bot.api,
+                                    cfg,
+                                    accountId: route.accountId,
+                                    linkPreview: telegramCfg.linkPreview,
+                                    buttons: previewButtons,
+                                });
+                                finalizedViaPreviewMessage = true;
+                                deliveryState.delivered = true;
+                                return;
+                            }
+                            catch (err) {
+                                logVerbose(`telegram: post-stop preview edit failed; falling back to standard send (${String(err)})`);
+                            }
+                        }
+                    }
+                    const result = await deliverReplies({
+                        ...deliveryBaseOptions,
+                        replies: [payload],
+                        onVoiceRecording: sendRecordVoice,
                     });
+                    if (result.delivered) {
+                        deliveryState.delivered = true;
+                    }
                 },
-            }).onReplyStart,
-        },
-        replyOptions: {
-            skillFilter,
-            onPartialReply: draftStream ? (payload) => updateDraftFromPartial(payload.text) : undefined,
-            onReasoningStream: draftStream
-                ? (payload) => {
-                    if (payload.text)
-                        draftStream.update(payload.text);
-                }
-                : undefined,
-            disableBlockStreaming,
-            onModelSelected: (ctx) => {
-                prefixContext.onModelSelected(ctx);
+                onSkip: (_payload, info) => {
+                    if (info.reason !== "silent") {
+                        deliveryState.skippedNonSilent += 1;
+                    }
+                },
+                onError: (err, info) => {
+                    runtime.error?.(danger(`telegram ${info.kind} reply failed: ${String(err)}`));
+                },
+                onReplyStart: createTypingCallbacks({
+                    start: sendTyping,
+                    onStartError: (err) => {
+                        logTypingFailure({
+                            log: logVerbose,
+                            channel: "telegram",
+                            target: String(chatId),
+                            error: err,
+                        });
+                    },
+                }).onReplyStart,
             },
-        },
-    });
-    draftStream?.stop();
-    let sentFallback = false;
-    if (!deliveryState.delivered && counts.tool + counts.block + counts.final > 0) {
-        try {
-            await deliverReplies({
-                replies: [{ text: EMPTY_RESPONSE_FALLBACK }],
-                chatId: String(chatId),
-                token: opts.token,
-                runtime,
-                bot,
-                replyToMode,
-                textLimit,
-                messageThreadId: resolvedThreadId,
-                tableMode,
-                chunkMode,
-                linkPreview: telegramCfg.linkPreview,
-            });
-            sentFallback = true;
-        }
-        catch {
-            // Fallback delivery failed; proceed without it
+            replyOptions: {
+                skillFilter,
+                disableBlockStreaming,
+                onPartialReply: draftStream ? (payload) => updateDraftFromPartial(payload.text) : undefined,
+                onAssistantMessageStart: draftStream
+                    ? () => {
+                        // Only split preview bubbles in block mode. In partial mode, keep
+                        // editing one preview message to avoid flooding the chat.
+                        logVerbose(`telegram: onAssistantMessageStart called, hasStreamedMessage=${hasStreamedMessage}`);
+                        if (shouldSplitPreviewMessages && hasStreamedMessage) {
+                            logVerbose(`telegram: calling forceNewMessage()`);
+                            draftStream.forceNewMessage();
+                        }
+                        lastPartialText = "";
+                        draftText = "";
+                        draftChunker?.reset();
+                    }
+                    : undefined,
+                onReasoningEnd: draftStream
+                    ? () => {
+                        // Same policy as assistant-message boundaries: split only in block mode.
+                        if (shouldSplitPreviewMessages && hasStreamedMessage) {
+                            draftStream.forceNewMessage();
+                        }
+                        lastPartialText = "";
+                        draftText = "";
+                        draftChunker?.reset();
+                    }
+                    : undefined,
+                onModelSelected,
+            },
+        }));
+    }
+    finally {
+        // Must stop() first to flush debounced content before clear() wipes state
+        await draftStream?.stop();
+        if (!finalizedViaPreviewMessage) {
+            await draftStream?.clear();
         }
     }
+    let sentFallback = false;
+    if (!deliveryState.delivered && deliveryState.skippedNonSilent > 0) {
+        const result = await deliverReplies({
+            replies: [{ text: EMPTY_RESPONSE_FALLBACK }],
+            ...deliveryBaseOptions,
+        });
+        sentFallback = result.delivered;
+    }
     const hasFinalResponse = queuedFinal || sentFallback;
     if (!hasFinalResponse) {
-        if (isGroup && historyKey) {
-            clearHistoryEntriesIfEnabled({ historyMap: groupHistories, historyKey, limit: historyLimit });
-        }
+        clearGroupHistory();
         return;
     }
     removeAckReactionAfterReply({
@@ -268,8 +400,9 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
         ackReactionValue: ackReactionPromise ? "ack" : null,
         remove: () => reactionApi?.(chatId, msg.message_id ?? 0, []) ?? Promise.resolve(),
         onError: (err) => {
-            if (!msg.message_id)
+            if (!msg.message_id) {
                 return;
+            }
             logAckFailure({
                 log: logVerbose,
                 channel: "telegram",
@@ -278,7 +411,5 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
             });
         },
     });
-    if (isGroup && historyKey) {
-        clearHistoryEntriesIfEnabled({ historyMap: groupHistories, historyKey, limit: historyLimit });
-    }
+    clearGroupHistory();
 };

package/dist/telegram/bot-native-command-menu.js

@@ -60,5 +60,7 @@ export function syncTelegramMenuCommands(params) {
             fn: () => bot.api.setMyCommands(commandsToRegister),
         });
     };
-    void sync().catch(() => { });
+    void sync().catch((err) => {
+        runtime.error?.(`Telegram command sync failed: ${String(err)}`);
+    });
 }