@poolzin/pool-bot 2026.1.39 → 2026.2.1

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

@@ -11,6 +11,7 @@ import { formatLocationText, toLocationContext } from "../channels/location.js";
 import { recordInboundSession } from "../channels/session.js";
 import { formatCliCommand } from "../cli/command-format.js";
 import { readSessionUpdatedAt, resolveStorePath } from "../config/sessions.js";
+import { loadConfig } from "../config/config.js";
 import { logVerbose, shouldLogVerbose } from "../globals.js";
 import { recordChannelActivity } from "../infra/channel-activity.js";
 import { resolveAgentRoute } from "../routing/resolve-route.js";
@@ -20,7 +21,7 @@ import { resolveMentionGatingWithBypass } from "../channels/mention-gating.js";
 import { resolveControlCommandGate } from "../channels/command-gating.js";
 import { logInboundDrop } from "../channels/logging.js";
 import { withTelegramApiErrorLogging } from "./api-logging.js";
-import { buildGroupLabel, buildSenderLabel, buildSenderName, buildTelegramGroupFrom, buildTelegramGroupPeerId, buildTypingThreadParams, expandTextLinks, normalizeForwardedContext, describeReplyTarget, extractTelegramLocation, hasBotMention, resolveTelegramForumThreadId, } from "./bot/helpers.js";
+import { buildGroupLabel, buildSenderLabel, buildSenderName, buildTelegramGroupFrom, buildTelegramGroupPeerId, buildTelegramParentPeer, buildTypingThreadParams, expandTextLinks, normalizeForwardedContext, describeReplyTarget, extractTelegramLocation, hasBotMention, resolveTelegramThreadSpec, } from "./bot/helpers.js";
 import { firstDefined, isSenderAllowed, normalizeAllowFromWithStore, resolveSenderAllowMatch, } from "./bot-access.js";
 import { upsertTelegramPairingRequest } from "./pairing-store.js";
 async function resolveStickerVisionSupport(params) {
@@ -50,23 +51,28 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
     const isGroup = msg.chat.type === "group" || msg.chat.type === "supergroup";
     const messageThreadId = msg.message_thread_id;
     const isForum = msg.chat.is_forum === true;
-    const resolvedThreadId = resolveTelegramForumThreadId({
+    const threadSpec = resolveTelegramThreadSpec({
+        isGroup,
         isForum,
         messageThreadId,
     });
+    const resolvedThreadId = threadSpec.scope === "forum" ? threadSpec.id : undefined;
+    const replyThreadId = threadSpec.id;
     const { groupConfig, topicConfig } = resolveTelegramGroupConfig(chatId, resolvedThreadId);
     const peerId = isGroup ? buildTelegramGroupPeerId(chatId, resolvedThreadId) : String(chatId);
+    const parentPeer = buildTelegramParentPeer({ isGroup, resolvedThreadId, chatId });
     const route = resolveAgentRoute({
-        cfg,
+        cfg: loadConfig(),
         channel: "telegram",
         accountId: account.accountId,
         peer: {
             kind: isGroup ? "group" : "dm",
             id: peerId,
         },
+        parentPeer,
     });
     const baseSessionKey = route.sessionKey;
-    const dmThreadId = !isGroup ? resolvedThreadId : undefined;
+    const dmThreadId = threadSpec.scope === "dm" ? threadSpec.id : undefined;
     const threadKeys = dmThreadId != null
         ? resolveThreadSessionKeys({ baseSessionKey, threadId: String(dmThreadId) })
         : null;
@@ -90,14 +96,14 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
     const sendTyping = async () => {
         await withTelegramApiErrorLogging({
             operation: "sendChatAction",
-            fn: () => bot.api.sendChatAction(chatId, "typing", buildTypingThreadParams(resolvedThreadId)),
+            fn: () => bot.api.sendChatAction(chatId, "typing", buildTypingThreadParams(replyThreadId)),
         });
     };
     const sendRecordVoice = async () => {
         try {
             await withTelegramApiErrorLogging({
                 operation: "sendChatAction",
-                fn: () => bot.api.sendChatAction(chatId, "record_voice", buildTypingThreadParams(resolvedThreadId)),
+                fn: () => bot.api.sendChatAction(chatId, "record_voice", buildTypingThreadParams(replyThreadId)),
             });
         }
         catch (err) {
@@ -109,7 +115,8 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
         if (dmPolicy === "disabled")
             return null;
         if (dmPolicy !== "open") {
-            const candidate = String(chatId);
+            const senderUserId = msg.from?.id != null ? String(msg.from.id) : null;
+            const candidate = senderUserId ?? String(chatId);
             const senderUsername = msg.from?.username ?? "";
             const allowMatch = resolveSenderAllowMatch({
                 allow: effectiveDmAllow,
@@ -131,7 +138,8 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
                         });
                         if (created) {
                             logger.info({
-                                chatId: candidate,
+                                chatId: String(chatId),
+                                senderUserId: senderUserId ?? undefined,
                                 username: from?.username,
                                 firstName: from?.first_name,
                                 lastName: from?.last_name,
@@ -141,7 +149,7 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
                             await withTelegramApiErrorLogging({
                                 operation: "sendMessage",
                                 fn: () => bot.api.sendMessage(chatId, [
-                                    "Moltbot: access not configured.",
+                                    "Poolbot: access not configured.",
                                     "",
                                     `Your Telegram user id: ${telegramUserId}`,
                                     "",
@@ -201,6 +209,8 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
         placeholder = "<media:image>";
     else if (msg.video)
         placeholder = "<media:video>";
+    else if (msg.video_note)
+        placeholder = "<media:video>";
     else if (msg.audio || msg.voice)
         placeholder = "<media:audio>";
     else if (msg.document)
@@ -326,7 +336,9 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
     const replyTarget = describeReplyTarget(msg);
     const forwardOrigin = normalizeForwardedContext(msg);
     const replySuffix = replyTarget
-        ? `\n\n[Replying to ${replyTarget.sender}${replyTarget.id ? ` id:${replyTarget.id}` : ""}]\n${replyTarget.body}\n[/Replying]`
+        ? replyTarget.kind === "quote"
+            ? `\n\n[Quoting ${replyTarget.sender}${replyTarget.id ? ` id:${replyTarget.id}` : ""}]\n"${replyTarget.body}"\n[/Quoting]`
+            : `\n\n[Replying to ${replyTarget.sender}${replyTarget.id ? ` id:${replyTarget.id}` : ""}]\n${replyTarget.body}\n[/Replying]`
         : "";
     const forwardPrefix = forwardOrigin
         ? `[Forwarded from ${forwardOrigin.from}${forwardOrigin.date ? ` at ${new Date(forwardOrigin.date * 1000).toISOString()}` : ""}]\n`
@@ -383,9 +395,17 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
     ].filter((entry) => Boolean(entry));
     const groupSystemPrompt = systemPromptParts.length > 0 ? systemPromptParts.join("\n\n") : undefined;
     const commandBody = normalizeCommandBody(rawBody, { botUsername });
+    const inboundHistory = isGroup && historyKey && historyLimit > 0
+        ? (groupHistories.get(historyKey) ?? []).map((entry) => ({
+            sender: entry.sender,
+            body: entry.body,
+            timestamp: entry.timestamp,
+        }))
+        : undefined;
     const ctxPayload = finalizeInboundContext({
         Body: combinedBody,
         RawBody: rawBody,
+        BodyForAgent: bodyText,
         CommandBody: commandBody,
         From: isGroup ? buildTelegramGroupFrom(chatId, resolvedThreadId) : `telegram:${chatId}`,
         To: `telegram:${chatId}`,
@@ -404,12 +424,15 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
         ReplyToId: replyTarget?.id,
         ReplyToBody: replyTarget?.body,
         ReplyToSender: replyTarget?.sender,
+        ReplyToIsQuote: replyTarget?.kind === "quote" ? true : undefined,
         ForwardedFrom: forwardOrigin?.from,
         ForwardedFromType: forwardOrigin?.fromType,
         ForwardedFromId: forwardOrigin?.fromId,
         ForwardedFromUsername: forwardOrigin?.fromUsername,
         ForwardedFromTitle: forwardOrigin?.fromTitle,
         ForwardedFromSignature: forwardOrigin?.fromSignature,
+        ForwardedFromChatType: forwardOrigin?.fromChatType,
+        ForwardedFromMessageId: forwardOrigin?.fromMessageId,
         ForwardedDate: forwardOrigin?.date ? forwardOrigin.date * 1000 : undefined,
         Timestamp: msg.date ? msg.date * 1000 : undefined,
         WasMentioned: isGroup ? effectiveWasMentioned : undefined,
@@ -435,7 +458,8 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
         Sticker: allMedia[0]?.stickerMetadata,
         ...(locationData ? toLocationContext(locationData) : undefined),
         CommandAuthorized: commandAuthorized,
-        MessageThreadId: resolvedThreadId,
+        InboundHistory: inboundHistory,
+        MessageThreadId: threadSpec.id,
         IsForum: isForum,
         // Originating channel for reply routing.
         OriginatingChannel: "telegram",
@@ -451,6 +475,7 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
                 channel: "telegram",
                 to: String(chatId),
                 accountId: route.accountId,
+                threadId: dmThreadId != null ? String(dmThreadId) : undefined,
             }
             : undefined,
         onRecordError: (err) => {
@@ -477,6 +502,8 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
         chatId,
         isGroup,
         resolvedThreadId,
+        threadSpec,
+        replyThreadId,
         isForum,
         historyKey,
         historyLimit,

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

@@ -1,7 +1,7 @@
-// @ts-nocheck
-import { EmbeddedBlockChunker } from "../agents/pi-embedded-block-chunker.js";
+import { resolveAgentDir } from "../agents/agent-scope.js";
 import { findModelInCatalog, loadModelCatalog, modelSupportsVision, } from "../agents/model-catalog.js";
 import { resolveDefaultModelForAgent } from "../agents/model-selection.js";
+import { EmbeddedBlockChunker } from "../agents/pi-embedded-block-chunker.js";
 import { resolveChunkMode } from "../auto-reply/chunk.js";
 import { clearHistoryEntriesIfEnabled } from "../auto-reply/reply/history.js";
 import { dispatchReplyWithBufferedBlockDispatcher } from "../auto-reply/reply/provider-dispatcher.js";
@@ -9,13 +9,13 @@ import { removeAckReactionAfterReply } from "../channels/ack-reactions.js";
 import { logAckFailure, logTypingFailure } from "../channels/logging.js";
 import { createReplyPrefixContext } from "../channels/reply-prefix.js";
 import { createTypingCallbacks } from "../channels/typing.js";
-import { danger, logVerbose } from "../globals.js";
 import { resolveMarkdownTableMode } from "../config/markdown-tables.js";
+import { danger, logVerbose } from "../globals.js";
 import { deliverReplies } from "./bot/delivery.js";
 import { resolveTelegramDraftStreamingChunking } from "./draft-chunking.js";
 import { createTelegramDraftStream } from "./draft-stream.js";
 import { cacheSticker, describeStickerImage } from "./sticker-cache.js";
-import { resolveAgentDir } from "../agents/agent-scope.js";
+const EMPTY_RESPONSE_FALLBACK = "No response generated. Please try again.";
 async function resolveStickerVisionSupport(cfg, agentId) {
     try {
         const catalog = await loadModelCatalog({ config: cfg });
@@ -118,7 +118,7 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
     // Handle uncached stickers: get a dedicated vision description before dispatch
     // This ensures we cache a raw description rather than a conversational response
     const sticker = ctxPayload.Sticker;
-    if (sticker?.fileUniqueId && ctxPayload.MediaPath) {
+    if (sticker?.fileId && sticker.fileUniqueId && ctxPayload.MediaPath) {
         const agentDir = resolveAgentDir(cfg, route.agentId);
         const stickerSupportsVision = await resolveStickerVisionSupport(cfg, route.agentId);
         let description = sticker.cachedDescription ?? null;
@@ -150,18 +150,28 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
                 ctxPayload.MediaTypes = undefined;
             }
             // Cache the description for future encounters
-            cacheSticker({
-                fileId: sticker.fileId,
-                fileUniqueId: sticker.fileUniqueId,
-                emoji: sticker.emoji,
-                setName: sticker.setName,
-                description,
-                cachedAt: new Date().toISOString(),
-                receivedFrom: ctxPayload.From,
-            });
-            logVerbose(`telegram: cached sticker description for ${sticker.fileUniqueId}`);
+            if (sticker.fileId) {
+                cacheSticker({
+                    fileId: sticker.fileId,
+                    fileUniqueId: sticker.fileUniqueId,
+                    emoji: sticker.emoji,
+                    setName: sticker.setName,
+                    description,
+                    cachedAt: new Date().toISOString(),
+                    receivedFrom: ctxPayload.From,
+                });
+                logVerbose(`telegram: cached sticker description for ${sticker.fileUniqueId}`);
+            }
+            else {
+                logVerbose(`telegram: skipped sticker cache (missing fileId)`);
+            }
         }
     }
+    // TODO: pass replyQuoteText to deliverReplies once delivery.ts supports it
+    const _replyQuoteText = ctxPayload.ReplyToIsQuote && ctxPayload.ReplyToBody
+        ? ctxPayload.ReplyToBody.trim() || undefined
+        : undefined;
+    void _replyQuoteText;
     const { queuedFinal } = await dispatchReplyWithBufferedBlockDispatcher({
         ctx: ctxPayload,
         cfg,
@@ -219,7 +229,30 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
         },
     });
     draftStream?.stop();
+    let sentFallback = false;
     if (!queuedFinal) {
+        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
+        }
+    }
+    const hasFinalResponse = queuedFinal || sentFallback;
+    if (!hasFinalResponse) {
         if (isGroup && historyKey) {
             clearHistoryEntriesIfEnabled({ historyMap: groupHistories, historyKey, limit: historyLimit });
         }

package/dist/telegram/bot-native-commands.js

@@ -1,23 +1,23 @@
-import { resolveEffectiveMessagesConfig } from "../agents/identity.js";
 import { resolveChunkMode } from "../auto-reply/chunk.js";
 import { buildCommandTextFromArgs, findCommandByNativeName, listNativeCommandSpecs, listNativeCommandSpecsForConfig, parseCommandArgs, resolveCommandArgMenu, } from "../auto-reply/commands-registry.js";
-import { listSkillCommandsForAgents } from "../auto-reply/skill-commands.js";
-import { resolveTelegramCustomCommands } from "../config/telegram-custom-commands.js";
-import { dispatchReplyWithBufferedBlockDispatcher } from "../auto-reply/reply/provider-dispatcher.js";
 import { finalizeInboundContext } from "../auto-reply/reply/inbound-context.js";
-import { danger, logVerbose } from "../globals.js";
+import { dispatchReplyWithBufferedBlockDispatcher } from "../auto-reply/reply/provider-dispatcher.js";
+import { listSkillCommandsForAgents } from "../auto-reply/skill-commands.js";
+import { resolveCommandAuthorizedFromAuthorizers } from "../channels/command-gating.js";
+import { createReplyPrefixContext } from "../channels/reply-prefix.js";
 import { resolveMarkdownTableMode } from "../config/markdown-tables.js";
-import { withTelegramApiErrorLogging } from "./api-logging.js";
+import { resolveTelegramCustomCommands } from "../config/telegram-custom-commands.js";
 import { normalizeTelegramCommandName, TELEGRAM_COMMAND_NAME_PATTERN, } from "../config/telegram-custom-commands.js";
+import { danger, logVerbose } from "../globals.js";
+import { readChannelAllowFromStore } from "../pairing/pairing-store.js";
+import { executePluginCommand, getPluginCommandSpecs, matchPluginCommand, } from "../plugins/commands.js";
 import { resolveAgentRoute } from "../routing/resolve-route.js";
 import { resolveThreadSessionKeys } from "../routing/session-key.js";
-import { resolveCommandAuthorizedFromAuthorizers } from "../channels/command-gating.js";
-import { executePluginCommand, getPluginCommandSpecs, matchPluginCommand, } from "../plugins/commands.js";
+import { withTelegramApiErrorLogging } from "./api-logging.js";
+import { firstDefined, isSenderAllowed, normalizeAllowFromWithStore } from "./bot-access.js";
 import { deliverReplies } from "./bot/delivery.js";
+import { buildTelegramThreadParams, buildSenderName, buildTelegramGroupFrom, buildTelegramGroupPeerId, resolveTelegramForumThreadId, } from "./bot/helpers.js";
 import { buildInlineKeyboard } from "./send.js";
-import { buildSenderName, buildTelegramGroupFrom, buildTelegramGroupPeerId, resolveTelegramForumThreadId, } from "./bot/helpers.js";
-import { firstDefined, isSenderAllowed, normalizeAllowFromWithStore } from "./bot-access.js";
-import { readTelegramAllowFromStore } from "./pairing-store.js";
 async function resolveTelegramCommandAuth(params) {
     const { msg, bot, cfg, telegramCfg, allowFrom, groupAllowFrom, useAccessGroups, resolveGroupPolicy, resolveTelegramGroupConfig, requireAuth, } = params;
     const chatId = msg.chat.id;
@@ -28,7 +28,7 @@ async function resolveTelegramCommandAuth(params) {
         isForum,
         messageThreadId,
     });
-    const storeAllowFrom = await readTelegramAllowFromStore().catch(() => []);
+    const storeAllowFrom = await readChannelAllowFromStore("telegram").catch(() => []);
     const { groupConfig, topicConfig } = resolveTelegramGroupConfig(chatId, resolvedThreadId);
     const groupAllowOverride = firstDefined(topicConfig?.allowFrom, groupConfig?.allowFrom);
     const effectiveGroupAllow = normalizeAllowFromWithStore({
@@ -69,7 +69,7 @@ async function resolveTelegramCommandAuth(params) {
     }
     if (isGroup && useAccessGroups) {
         const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
-        const groupPolicy = telegramCfg.groupPolicy ?? defaultGroupPolicy ?? "open";
+        const groupPolicy = firstDefined(topicConfig?.groupPolicy, groupConfig?.groupPolicy, telegramCfg.groupPolicy, defaultGroupPolicy, "open");
         if (groupPolicy === "disabled") {
             await withTelegramApiErrorLogging({
                 operation: "sendMessage",
@@ -134,7 +134,13 @@ async function resolveTelegramCommandAuth(params) {
     };
 }
 export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, telegramCfg, allowFrom, groupAllowFrom, replyToMode, textLimit, useAccessGroups, nativeEnabled, nativeSkillsEnabled, nativeDisabledExplicit, resolveGroupPolicy, resolveTelegramGroupConfig, shouldSkipUpdate, opts, }) => {
-    const skillCommands = nativeEnabled && nativeSkillsEnabled ? listSkillCommandsForAgents({ cfg }) : [];
+    const boundRoute = nativeEnabled && nativeSkillsEnabled
+        ? resolveAgentRoute({ cfg, channel: "telegram", accountId })
+        : null;
+    const boundAgentIds = boundRoute && boundRoute.matchedBy.startsWith("binding.") ? [boundRoute.agentId] : null;
+    const skillCommands = nativeEnabled && nativeSkillsEnabled
+        ? listSkillCommandsForAgents(boundAgentIds ? { cfg, agentIds: boundAgentIds } : { cfg })
+        : [];
     const nativeCommands = nativeEnabled
         ? listNativeCommandSpecsForConfig(cfg, { skillCommands, provider: "telegram" })
         : [];
@@ -180,7 +186,7 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
         existingCommands.add(normalized);
         pluginCommands.push({ command: normalized, description });
     }
-    const allCommands = [
+    const allCommandsFull = [
         ...nativeCommands.map((command) => ({
             command: command.name,
             description: command.description,
@@ -188,12 +194,39 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
         ...pluginCommands,
         ...customCommands,
     ];
-    if (allCommands.length > 0) {
-        void withTelegramApiErrorLogging({
-            operation: "setMyCommands",
+    // Telegram Bot API limits commands to 100 per scope.
+    // Truncate with a warning rather than failing with BOT_COMMANDS_TOO_MUCH.
+    const TELEGRAM_MAX_COMMANDS = 100;
+    if (allCommandsFull.length > TELEGRAM_MAX_COMMANDS) {
+        runtime.log?.(`telegram: truncating ${allCommandsFull.length} commands to ${TELEGRAM_MAX_COMMANDS} (Telegram Bot API limit)`);
+    }
+    const allCommands = allCommandsFull.slice(0, TELEGRAM_MAX_COMMANDS);
+    // Clear stale commands before registering new ones to prevent
+    // leftover commands from deleted skills persisting across restarts.
+    // Chain delete → set so a late-resolving delete cannot wipe newly registered commands.
+    const registerCommands = () => {
+        if (allCommands.length > 0) {
+            withTelegramApiErrorLogging({
+                operation: "setMyCommands",
+                runtime,
+                fn: () => bot.api.setMyCommands(allCommands),
+            }).catch(() => { });
+        }
+    };
+    if (typeof bot.api.deleteMyCommands === "function") {
+        withTelegramApiErrorLogging({
+            operation: "deleteMyCommands",
             runtime,
-            fn: () => bot.api.setMyCommands(allCommands),
-        }).catch(() => { });
+            fn: () => bot.api.deleteMyCommands(),
+        })
+            .catch(() => { })
+            .then(registerCommands)
+            .catch(() => { });
+    }
+    else {
+        registerCommands();
+    }
+    if (allCommands.length > 0) {
         if (typeof bot.command !== "function") {
             logVerbose("telegram: bot.command unavailable; skipping native handlers");
         }
@@ -201,10 +234,12 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
             for (const command of nativeCommands) {
                 bot.command(command.name, async (ctx) => {
                     const msg = ctx.message;
-                    if (!msg)
+                    if (!msg) {
                         return;
-                    if (shouldSkipUpdate(ctx))
+                    }
+                    if (shouldSkipUpdate(ctx)) {
                         return;
+                    }
                     const auth = await resolveTelegramCommandAuth({
                         msg,
                         bot,
@@ -217,9 +252,12 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                         resolveTelegramGroupConfig,
                         requireAuth: true,
                     });
-                    if (!auth)
+                    if (!auth) {
                         return;
+                    }
                     const { chatId, isGroup, isForum, resolvedThreadId, senderId, senderUsername, groupConfig, topicConfig, commandAuthorized, } = auth;
+                    const messageThreadId = msg.message_thread_id;
+                    const threadParams = buildTelegramThreadParams(resolvedThreadId) ?? {};
                     const commandDefinition = findCommandByNativeName(command.name, "telegram");
                     const rawText = ctx.match?.trim() ?? "";
                     const commandArgs = commandDefinition
@@ -261,7 +299,7 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                             runtime,
                             fn: () => bot.api.sendMessage(chatId, title, {
                                 ...(replyMarkup ? { reply_markup: replyMarkup } : {}),
-                                ...(resolvedThreadId != null ? { message_thread_id: resolvedThreadId } : {}),
+                                ...threadParams,
                             }),
                         });
                         return;
@@ -276,9 +314,13 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                         },
                     });
                     const baseSessionKey = route.sessionKey;
-                    const dmThreadId = !isGroup ? resolvedThreadId : undefined;
+                    // DMs: use raw messageThreadId for thread sessions (not resolvedThreadId which is for forums)
+                    const dmThreadId = !isGroup ? messageThreadId : undefined;
                     const threadKeys = dmThreadId != null
-                        ? resolveThreadSessionKeys({ baseSessionKey, threadId: String(dmThreadId) })
+                        ? resolveThreadSessionKeys({
+                            baseSessionKey,
+                            threadId: String(dmThreadId),
+                        })
                         : null;
                     const sessionKey = threadKeys?.sessionKey ?? baseSessionKey;
                     const tableMode = resolveMarkdownTableMode({
@@ -299,6 +341,7 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                         : (buildSenderName(msg) ?? String(senderId || chatId));
                     const ctxPayload = finalizeInboundContext({
                         Body: prompt,
+                        BodyForAgent: prompt,
                         RawBody: prompt,
                         CommandBody: prompt,
                         CommandArgs: commandArgs,
@@ -318,6 +361,7 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                         CommandAuthorized: commandAuthorized,
                         CommandSource: "native",
                         SessionKey: `telegram:slash:${senderId || chatId}`,
+                        AccountId: route.accountId,
                         CommandTargetSessionKey: sessionKey,
                         MessageThreadId: resolvedThreadId,
                         IsForum: isForum,
@@ -329,12 +373,16 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                         ? !telegramCfg.blockStreaming
                         : undefined;
                     const chunkMode = resolveChunkMode(cfg, "telegram", route.accountId);
+                    const { onModelSelected, ...prefixOptions } = createReplyPrefixContext({
+                        cfg,
+                        agentId: route.agentId,
+                    });
                     await dispatchReplyWithBufferedBlockDispatcher({
                         ctx: ctxPayload,
                         cfg,
                         dispatcherOptions: {
-                            responsePrefix: resolveEffectiveMessagesConfig(cfg, route.agentId).responsePrefix,
-                            deliver: async (payload) => {
+                            ...prefixOptions,
+                            deliver: async (payload, _info) => {
                                 await deliverReplies({
                                     replies: [payload],
                                     chatId: String(chatId),
@@ -356,6 +404,7 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                         replyOptions: {
                             skillFilter,
                             disableBlockStreaming,
+                            onModelSelected,
                         },
                     });
                 });
@@ -393,7 +442,11 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                     });
                     if (!auth)
                         return;
-                    const { resolvedThreadId, senderId, commandAuthorized } = auth;
+                    const { resolvedThreadId, senderId, commandAuthorized, isGroup } = auth;
+                    const from = isGroup
+                        ? buildTelegramGroupFrom(chatId, resolvedThreadId)
+                        : `telegram:${chatId}`;
+                    const to = `telegram:${chatId}`;
                     const result = await executePluginCommand({
                         command: match.command,
                         args: match.args,
@@ -402,6 +455,10 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                         isAuthorizedSender: commandAuthorized,
                         commandBody,
                         config: cfg,
+                        from,
+                        to,
+                        accountId,
+                        messageThreadId: resolvedThreadId,
                     });
                     const tableMode = resolveMarkdownTableMode({
                         cfg,

package/dist/telegram/bot.js

@@ -17,9 +17,8 @@ import { enqueueSystemEvent } from "../infra/system-events.js";
 import { getChildLogger } from "../logging.js";
 import { withTelegramApiErrorLogging } from "./api-logging.js";
 import { resolveAgentRoute } from "../routing/resolve-route.js";
-import { resolveThreadSessionKeys } from "../routing/session-key.js";
 import { resolveTelegramAccount } from "./accounts.js";
-import { buildTelegramGroupPeerId, resolveTelegramForumThreadId, resolveTelegramStreamMode, } from "./bot/helpers.js";
+import { buildTelegramGroupPeerId, buildTelegramParentPeer, resolveTelegramForumThreadId, resolveTelegramStreamMode, } from "./bot/helpers.js";
 import { registerTelegramHandlers } from "./bot-handlers.js";
 import { createTelegramMessageProcessor } from "./bot-message.js";
 import { registerTelegramNativeCommands } from "./bot-native-commands.js";
@@ -45,11 +44,12 @@ export function getTelegramSequentialKey(ctx) {
             return `telegram:${chatId}:control`;
         return "telegram:control";
     }
+    const isGroup = msg?.chat?.type === "group" || msg?.chat?.type === "supergroup";
+    const messageThreadId = msg?.message_thread_id;
     const isForum = msg?.chat?.is_forum;
-    const threadId = resolveTelegramForumThreadId({
-        isForum,
-        messageThreadId: msg?.message_thread_id,
-    });
+    const threadId = isGroup
+        ? resolveTelegramForumThreadId({ isForum, messageThreadId })
+        : messageThreadId;
     if (typeof chatId === "number") {
         return threadId != null ? `telegram:${chatId}:topic:${threadId}` : `telegram:${chatId}`;
     }
@@ -73,14 +73,15 @@ export function createTelegramBot(opts) {
         network: telegramCfg.network,
     });
     const shouldProvideFetch = Boolean(fetchImpl);
+    // grammY's ApiClientOptions types still track `node-fetch` types; Node 22+ global fetch
+    // (undici) is structurally compatible at runtime but not assignable in TS.
+    const fetchForClient = fetchImpl;
     const timeoutSeconds = typeof telegramCfg?.timeoutSeconds === "number" && Number.isFinite(telegramCfg.timeoutSeconds)
         ? Math.max(1, Math.floor(telegramCfg.timeoutSeconds))
         : undefined;
     const client = shouldProvideFetch || timeoutSeconds
         ? {
-            ...(shouldProvideFetch && fetchImpl
-                ? { fetch: fetchImpl }
-                : {}),
+            ...(shouldProvideFetch && fetchImpl ? { fetch: fetchForClient } : {}),
             ...(timeoutSeconds ? { timeoutSeconds } : {}),
         }
         : undefined;
@@ -193,19 +194,22 @@ export function createTelegramBot(opts) {
     const logger = getChildLogger({ module: "telegram-auto-reply" });
     let botHasTopicsEnabled;
     const resolveBotTopicsEnabled = async (ctx) => {
-        const fromCtx = ctx?.me;
-        if (typeof fromCtx?.has_topics_enabled === "boolean") {
-            botHasTopicsEnabled = fromCtx.has_topics_enabled;
+        if (typeof ctx?.me?.has_topics_enabled === "boolean") {
+            botHasTopicsEnabled = ctx.me.has_topics_enabled;
             return botHasTopicsEnabled;
         }
         if (typeof botHasTopicsEnabled === "boolean")
             return botHasTopicsEnabled;
+        if (typeof bot.api.getMe !== "function") {
+            botHasTopicsEnabled = false;
+            return botHasTopicsEnabled;
+        }
         try {
-            const me = (await withTelegramApiErrorLogging({
+            const me = await withTelegramApiErrorLogging({
                 operation: "getMe",
                 runtime,
                 fn: () => bot.api.getMe(),
-            }));
+            });
             botHasTopicsEnabled = Boolean(me?.has_topics_enabled);
         }
         catch (err) {
@@ -340,28 +344,25 @@ export function createTelegramBot(opts) {
                 senderLabel = `id:${user.id}`;
             }
             senderLabel = senderLabel || "unknown";
-            // Extract forum thread info (similar to message processing)
-            const messageThreadId = reaction.message_thread_id;
-            const isForum = reaction.chat.is_forum === true;
-            const resolvedThreadId = resolveTelegramForumThreadId({
-                isForum,
-                messageThreadId,
-            });
-            // Resolve agent route for session
+            // Reactions target a specific message_id; the Telegram Bot API does not include
+            // message_thread_id on MessageReactionUpdated, so we route to the chat-level
+            // session (forum topic routing is not available for reactions).
             const isGroup = reaction.chat.type === "group" || reaction.chat.type === "supergroup";
+            const isForum = reaction.chat.is_forum === true;
+            const resolvedThreadId = isForum
+                ? resolveTelegramForumThreadId({ isForum, messageThreadId: undefined })
+                : undefined;
             const peerId = isGroup ? buildTelegramGroupPeerId(chatId, resolvedThreadId) : String(chatId);
+            const parentPeer = buildTelegramParentPeer({ isGroup, resolvedThreadId, chatId });
+            // Fresh config for bindings lookup; other routing inputs are payload-derived.
             const route = resolveAgentRoute({
-                cfg,
+                cfg: loadConfig(),
                 channel: "telegram",
                 accountId: account.accountId,
                 peer: { kind: isGroup ? "group" : "dm", id: peerId },
+                parentPeer,
             });
-            const baseSessionKey = route.sessionKey;
-            const dmThreadId = !isGroup ? resolvedThreadId : undefined;
-            const threadKeys = dmThreadId != null
-                ? resolveThreadSessionKeys({ baseSessionKey, threadId: String(dmThreadId) })
-                : null;
-            const sessionKey = threadKeys?.sessionKey ?? baseSessionKey;
+            const sessionKey = route.sessionKey;
             // Enqueue system event for each added reaction
             for (const r of addedReactions) {
                 const emoji = r.emoji;