@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/telegram/bot-handlers.js

@@ -1,8 +1,8 @@
-import { resolveDefaultAgentId } from "../agents/agent-scope.js";
+import { resolveAgentDir, resolveDefaultAgentId } from "../agents/agent-scope.js";
 import { hasControlCommand } from "../auto-reply/command-detection.js";
 import { createInboundDebouncer, resolveInboundDebounceMs, } from "../auto-reply/inbound-debounce.js";
 import { buildCommandsPaginationKeyboard } from "../auto-reply/reply/commands-info.js";
-import { buildModelsProviderData } from "../auto-reply/reply/commands-models.js";
+import { buildModelsProviderData, formatModelsAvailableHeader, } from "../auto-reply/reply/commands-models.js";
 import { resolveStoredModelOverride } from "../auto-reply/reply/model-selection.js";
 import { listSkillCommandsForAgents } from "../auto-reply/skill-commands.js";
 import { buildCommandsMessagePaginated } from "../auto-reply/status.js";
@@ -16,8 +16,8 @@ import { readChannelAllowFromStore } from "../pairing/pairing-store.js";
 import { resolveAgentRoute } from "../routing/resolve-route.js";
 import { resolveThreadSessionKeys } from "../routing/session-key.js";
 import { withTelegramApiErrorLogging } from "./api-logging.js";
-import { firstDefined, isSenderAllowed, normalizeAllowFromWithStore, } from "./bot-access.js";
-import { MEDIA_GROUP_TIMEOUT_MS } from "./bot-updates.js";
+import { isSenderAllowed, normalizeAllowFromWithStore, } from "./bot-access.js";
+import { MEDIA_GROUP_TIMEOUT_MS, } from "./bot-updates.js";
 import { resolveMedia } from "./bot/delivery.js";
 import { buildTelegramGroupPeerId, buildTelegramParentPeer, resolveTelegramForumThreadId, resolveTelegramGroupAllowFromContext, } from "./bot/helpers.js";
 import { evaluateTelegramGroupBaseAccess, evaluateTelegramGroupPolicyAccess, } from "./group-access.js";
@@ -103,7 +103,7 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
             runtime.error?.(danger(`telegram debounce flush failed: ${String(err)}`));
         },
     });
-    const resolveTelegramSessionModel = (params) => {
+    const resolveTelegramSessionState = (params) => {
         const resolvedThreadId = params.resolvedThreadId ??
             resolveTelegramForumThreadId({
                 isForum: params.isForum,
@@ -142,17 +142,29 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
             sessionKey,
         });
         if (storedOverride) {
-            return storedOverride.provider
-                ? `${storedOverride.provider}/${storedOverride.model}`
-                : storedOverride.model;
+            return {
+                agentId: route.agentId,
+                sessionEntry: entry,
+                model: storedOverride.provider
+                    ? `${storedOverride.provider}/${storedOverride.model}`
+                    : storedOverride.model,
+            };
         }
         const provider = entry?.modelProvider?.trim();
         const model = entry?.model?.trim();
         if (provider && model) {
-            return `${provider}/${model}`;
+            return {
+                agentId: route.agentId,
+                sessionEntry: entry,
+                model: `${provider}/${model}`,
+            };
         }
         const modelCfg = cfg.agents?.defaults?.model;
-        return typeof modelCfg === "string" ? modelCfg : modelCfg?.primary;
+        return {
+            agentId: route.agentId,
+            sessionEntry: entry,
+            model: typeof modelCfg === "string" ? modelCfg : modelCfg?.primary,
+        };
     };
     const processMediaGroup = async (entry) => {
         try {
@@ -385,7 +397,7 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
     const processInboundMessage = async (params) => {
         const { ctx, msg, chatId, resolvedThreadId, storeAllowFrom, sendOversizeWarning, oversizeLogMessage, } = params;
         // Text fragment handling - Telegram splits long pastes into multiple inbound messages (~4096 chars).
-        // We buffer “near-limit” messages and append immediately-following parts.
+        // We buffer "near-limit" messages and append immediately-following parts.
         const text = typeof msg.text === "string" ? msg.text : undefined;
         const isCommandLike = (text ?? "").trim().startsWith("/");
         if (text && !isCommandLike) {
@@ -585,17 +597,19 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
             const groupAllowContext = await resolveTelegramGroupAllowFromContext({
                 chatId,
                 accountId,
+                dmPolicy: telegramCfg.dmPolicy ?? "pairing",
                 isForum,
                 messageThreadId,
                 groupAllowFrom,
                 resolveTelegramGroupConfig,
             });
             const { resolvedThreadId, storeAllowFrom, groupConfig, topicConfig, effectiveGroupAllow, hasGroupAllowOverride, } = groupAllowContext;
+            const dmPolicy = telegramCfg.dmPolicy ?? "pairing";
             const effectiveDmAllow = normalizeAllowFromWithStore({
                 allowFrom: telegramCfg.allowFrom,
                 storeAllowFrom,
+                dmPolicy,
             });
-            const dmPolicy = telegramCfg.dmPolicy ?? "pairing";
             const senderId = callback.from?.id ? String(callback.from.id) : "";
             const senderUsername = callback.from?.username ?? "";
             if (shouldSkipGroupMessage({
@@ -719,13 +733,14 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
                     const totalPages = calculateTotalPages(models.length, pageSize);
                     const safePage = Math.max(1, Math.min(page, totalPages));
                     // Resolve current model from session (prefer overrides)
-                    const currentModel = resolveTelegramSessionModel({
+                    const sessionState = resolveTelegramSessionState({
                         chatId,
                         isGroup,
                         isForum,
                         messageThreadId,
                         resolvedThreadId,
                     });
+                    const currentModel = sessionState.model;
                     const buttons = buildModelsKeyboard({
                         provider,
                         models,
@@ -734,7 +749,13 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
                         totalPages,
                         pageSize,
                     });
-                    const text = `Models (${provider}) — ${models.length} available`;
+                    const text = formatModelsAvailableHeader({
+                        provider,
+                        total: models.length,
+                        cfg,
+                        agentDir: resolveAgentDir(cfg, sessionState.agentId),
+                        sessionEntry: sessionState.sessionEntry,
+                    });
                     await editMessageWithButtons(text, buttons);
                     return;
                 }
@@ -811,37 +832,32 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
             runtime.error?.(danger(`[telegram] Group migration handler failed: ${String(err)}`));
         }
     });
-    bot.on("message", async (ctx) => {
+    const handleInboundMessageLike = async (event) => {
         try {
-            const msg = ctx.message;
-            if (!msg) {
+            if (shouldSkipUpdate(event.ctxForDedupe)) {
                 return;
             }
-            if (shouldSkipUpdate(ctx)) {
-                return;
-            }
-            const chatId = msg.chat.id;
-            const isGroup = msg.chat.type === "group" || msg.chat.type === "supergroup";
-            const messageThreadId = msg.message_thread_id;
-            const isForum = msg.chat.is_forum === true;
             const groupAllowContext = await resolveTelegramGroupAllowFromContext({
-                chatId,
+                chatId: event.chatId,
                 accountId,
-                isForum,
-                messageThreadId,
+                dmPolicy: telegramCfg.dmPolicy ?? "pairing",
+                isForum: event.isForum,
+                messageThreadId: event.messageThreadId,
                 groupAllowFrom,
                 resolveTelegramGroupConfig,
             });
             const { resolvedThreadId, storeAllowFrom, groupConfig, topicConfig, effectiveGroupAllow, hasGroupAllowOverride, } = groupAllowContext;
-            const senderId = msg.from?.id != null ? String(msg.from.id) : "";
-            const senderUsername = msg.from?.username ?? "";
+            if (event.requireConfiguredGroup && (!groupConfig || groupConfig.enabled === false)) {
+                logVerbose(`Blocked telegram channel ${event.chatId} (channel disabled)`);
+                return;
+            }
             if (shouldSkipGroupMessage({
-                isGroup,
-                chatId,
-                chatTitle: msg.chat.title,
+                isGroup: event.isGroup,
+                chatId: event.chatId,
+                chatTitle: event.msg.chat.title,
                 resolvedThreadId,
-                senderId,
-                senderUsername,
+                senderId: event.senderId,
+                senderUsername: event.senderUsername,
                 effectiveGroupAllow,
                 hasGroupAllowOverride,
                 groupConfig,
@@ -850,131 +866,87 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
                 return;
             }
             await processInboundMessage({
-                ctx,
-                msg,
-                chatId,
+                ctx: event.ctx,
+                msg: event.msg,
+                chatId: event.chatId,
                 resolvedThreadId,
                 storeAllowFrom,
-                sendOversizeWarning: true,
-                oversizeLogMessage: "media exceeds size limit",
+                sendOversizeWarning: event.sendOversizeWarning,
+                oversizeLogMessage: event.oversizeLogMessage,
             });
         }
         catch (err) {
-            runtime.error?.(danger(`handler failed: ${String(err)}`));
+            runtime.error?.(danger(`${event.errorMessage}: ${String(err)}`));
         }
+    };
+    bot.on("message", async (ctx) => {
+        const msg = ctx.message;
+        if (!msg) {
+            return;
+        }
+        await handleInboundMessageLike({
+            ctxForDedupe: ctx,
+            ctx: buildSyntheticContext(ctx, msg),
+            msg,
+            chatId: msg.chat.id,
+            isGroup: msg.chat.type === "group" || msg.chat.type === "supergroup",
+            isForum: msg.chat.is_forum === true,
+            messageThreadId: msg.message_thread_id,
+            senderId: msg.from?.id != null ? String(msg.from.id) : "",
+            senderUsername: msg.from?.username ?? "",
+            requireConfiguredGroup: false,
+            sendOversizeWarning: true,
+            oversizeLogMessage: "media exceeds size limit",
+            errorMessage: "handler failed",
+        });
     });
     // Handle channel posts — enables bot-to-bot communication via Telegram channels.
     // Telegram bots cannot see other bot messages in groups, but CAN in channels.
     // This handler normalizes channel_post updates into the standard message pipeline.
     bot.on("channel_post", async (ctx) => {
-        try {
-            const post = ctx.channelPost;
-            if (!post) {
-                return;
-            }
-            // Deduplication check — same as the regular message handler
-            if (shouldSkipUpdate(ctx)) {
-                return;
-            }
-            const chatId = post.chat.id;
-            // Use the full group allow-from context for access control (same as message handler)
-            const groupAllowContext = await resolveTelegramGroupAllowFromContext({
-                chatId,
-                accountId,
-                isForum: false,
-                messageThreadId: undefined,
-                groupAllowFrom,
-                resolveTelegramGroupConfig,
-            });
-            const { storeAllowFrom, groupConfig, effectiveGroupAllow, hasGroupAllowOverride } = groupAllowContext;
-            // Check group allowlist (channels use the same groups config)
-            const groupAllowlist = resolveGroupPolicy(chatId);
-            if (groupAllowlist.allowlistEnabled && !groupAllowlist.allowed) {
-                return;
-            }
-            if (!groupConfig || groupConfig.enabled === false) {
-                logVerbose(`Blocked telegram channel ${chatId} (channel disabled)`);
-                return;
-            }
-            // Group policy filtering (same as message handler)
-            const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
-            const groupPolicy = firstDefined(groupConfig?.groupPolicy, telegramCfg.groupPolicy, defaultGroupPolicy, "open");
-            if (groupPolicy === "disabled") {
-                logVerbose(`Blocked telegram channel message (groupPolicy: disabled)`);
-                return;
-            }
-            if (hasGroupAllowOverride) {
-                const senderId = post.sender_chat?.id ?? post.from?.id;
-                const senderUsername = post.sender_chat?.username ?? post.from?.username ?? "";
-                const allowed = senderId != null &&
-                    isSenderAllowed({
-                        allow: effectiveGroupAllow,
-                        senderId: String(senderId),
-                        senderUsername,
-                    });
-                if (!allowed) {
-                    logVerbose(`Blocked telegram channel sender ${senderId ?? "unknown"} (group allowFrom override)`);
-                    return;
-                }
-            }
-            if (groupPolicy === "allowlist") {
-                const senderId = post.sender_chat?.id ?? post.from?.id;
-                if (senderId == null) {
-                    logVerbose(`Blocked telegram channel message (no sender ID, groupPolicy: allowlist)`);
-                    return;
-                }
-                if (!effectiveGroupAllow.hasEntries) {
-                    logVerbose("Blocked telegram channel message (groupPolicy: allowlist, no allowlist entries)");
-                    return;
-                }
-                const senderUsername = post.sender_chat?.username ?? post.from?.username ?? "";
-                if (!isSenderAllowed({
-                    allow: effectiveGroupAllow,
-                    senderId: String(senderId),
-                    senderUsername,
-                })) {
-                    logVerbose(`Blocked telegram channel message from ${senderId} (groupPolicy: allowlist)`);
-                    return;
-                }
-            }
-            // Build a synthetic `from` field since channel posts may not have one.
-            // Use sender_chat (the bot/user that posted) if available.
-            const syntheticFrom = post.sender_chat
-                ? {
-                    id: post.sender_chat.id,
-                    is_bot: true,
-                    first_name: post.sender_chat.title || "Channel",
-                    username: post.sender_chat.username,
-                }
-                : {
-                    id: chatId,
-                    is_bot: true,
-                    first_name: post.chat.title || "Channel",
-                    username: post.chat.username,
-                };
-            const syntheticMsg = {
-                ...post,
-                from: post.from ?? syntheticFrom,
-                chat: {
-                    ...post.chat,
-                    type: "supergroup",
-                },
-            };
-            const syntheticCtx = Object.create(ctx, {
-                message: { value: syntheticMsg, writable: true, enumerable: true },
-            });
-            await processInboundMessage({
-                ctx: syntheticCtx,
-                msg: syntheticMsg,
-                chatId,
-                resolvedThreadId: undefined,
-                storeAllowFrom,
-                sendOversizeWarning: false,
-                oversizeLogMessage: "channel post media exceeds size limit",
-            });
-        }
-        catch (err) {
-            runtime.error?.(danger(`channel_post handler failed: ${String(err)}`));
+        const post = ctx.channelPost;
+        if (!post) {
+            return;
         }
+        const chatId = post.chat.id;
+        const syntheticFrom = post.sender_chat
+            ? {
+                id: post.sender_chat.id,
+                is_bot: true,
+                first_name: post.sender_chat.title || "Channel",
+                username: post.sender_chat.username,
+            }
+            : {
+                id: chatId,
+                is_bot: true,
+                first_name: post.chat.title || "Channel",
+                username: post.chat.username,
+            };
+        const syntheticMsg = {
+            ...post,
+            from: post.from ?? syntheticFrom,
+            chat: {
+                ...post.chat,
+                type: "supergroup",
+            },
+        };
+        await handleInboundMessageLike({
+            ctxForDedupe: ctx,
+            ctx: buildSyntheticContext(ctx, syntheticMsg),
+            msg: syntheticMsg,
+            chatId,
+            isGroup: true,
+            isForum: false,
+            senderId: post.sender_chat?.id != null
+                ? String(post.sender_chat.id)
+                : post.from?.id != null
+                    ? String(post.from.id)
+                    : "",
+            senderUsername: post.sender_chat?.username ?? post.from?.username ?? "",
+            requireConfiguredGroup: true,
+            sendOversizeWarning: false,
+            oversizeLogMessage: "channel post media exceeds size limit",
+            errorMessage: "channel_post handler failed",
+        });
     });
 };

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

@@ -13,6 +13,7 @@ import { formatLocationText, toLocationContext } from "../channels/location.js";
 import { logInboundDrop } from "../channels/logging.js";
 import { resolveMentionGatingWithBypass } from "../channels/mention-gating.js";
 import { recordInboundSession } from "../channels/session.js";
+import { createStatusReactionController, } from "../channels/status-reactions.js";
 import { loadConfig } from "../config/config.js";
 import { readSessionUpdatedAt, resolveStorePath } from "../config/sessions.js";
 import { logVerbose, shouldLogVerbose } from "../globals.js";
@@ -25,6 +26,7 @@ import { withTelegramApiErrorLogging } from "./api-logging.js";
 import { firstDefined, isSenderAllowed, normalizeAllowFromWithStore, resolveSenderAllowMatch, } from "./bot-access.js";
 import { buildGroupLabel, buildSenderLabel, buildSenderName, buildTelegramGroupFrom, buildTelegramGroupPeerId, buildTelegramParentPeer, buildTypingThreadParams, resolveTelegramMediaPlaceholder, expandTextLinks, normalizeForwardedContext, describeReplyTarget, extractTelegramLocation, hasBotMention, resolveTelegramThreadSpec, } from "./bot/helpers.js";
 import { evaluateTelegramGroupBaseAccess } from "./group-access.js";
+import { buildTelegramStatusReactionVariants, resolveTelegramAllowedEmojiReactions, resolveTelegramReactionVariant, resolveTelegramStatusReactionEmojis, } from "./status-reaction-variants.js";
 async function resolveStickerVisionSupport(params) {
     try {
         const catalog = await loadModelCatalog({ config: params.cfg });
@@ -82,11 +84,12 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
         : null;
     const sessionKey = threadKeys?.sessionKey ?? baseSessionKey;
     const mentionRegexes = buildMentionRegexes(cfg, route.agentId);
-    const effectiveDmAllow = normalizeAllowFromWithStore({ allowFrom, storeAllowFrom });
+    const effectiveDmAllow = normalizeAllowFromWithStore({ allowFrom, storeAllowFrom, dmPolicy });
     const groupAllowOverride = firstDefined(topicConfig?.allowFrom, groupConfig?.allowFrom);
     const effectiveGroupAllow = normalizeAllowFromWithStore({
         allowFrom: groupAllowOverride ?? groupAllowFrom,
         storeAllowFrom,
+        dmPolicy,
     });
     const hasGroupAllowOverride = typeof groupAllowOverride !== "undefined";
     const senderId = msg.from?.id ? String(msg.from.id) : "";
@@ -363,15 +366,70 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
         }));
     const api = bot.api;
     const reactionApi = typeof api.setMessageReaction === "function" ? api.setMessageReaction.bind(api) : null;
-    const ackReactionPromise = shouldAckReaction() && msg.message_id && reactionApi
-        ? withTelegramApiErrorLogging({
-            operation: "setMessageReaction",
-            fn: () => reactionApi(chatId, msg.message_id, [{ type: "emoji", emoji: ackReaction }]),
-        }).then(() => true, (err) => {
-            logVerbose(`telegram react failed for chat ${chatId}: ${String(err)}`);
-            return false;
+    const getChatApi = typeof api.getChat === "function" ? api.getChat.bind(api) : null;
+    // Status Reactions controller (lifecycle reactions)
+    const statusReactionsConfig = cfg.messages?.statusReactions;
+    const statusReactionsEnabled = statusReactionsConfig?.enabled === true && Boolean(reactionApi) && shouldAckReaction();
+    const resolvedStatusReactionEmojis = resolveTelegramStatusReactionEmojis({
+        initialEmoji: ackReaction,
+        overrides: statusReactionsConfig?.emojis,
+    });
+    const statusReactionVariantsByEmoji = buildTelegramStatusReactionVariants(resolvedStatusReactionEmojis);
+    let allowedStatusReactionEmojisPromise = null;
+    const statusReactionController = statusReactionsEnabled && msg.message_id
+        ? createStatusReactionController({
+            enabled: true,
+            adapter: {
+                setReaction: async (emoji) => {
+                    if (reactionApi) {
+                        if (!allowedStatusReactionEmojisPromise) {
+                            allowedStatusReactionEmojisPromise = resolveTelegramAllowedEmojiReactions({
+                                chat: msg.chat,
+                                chatId,
+                                getChat: getChatApi ?? undefined,
+                            }).catch((err) => {
+                                logVerbose(`telegram status-reaction available_reactions lookup failed for chat ${chatId}: ${String(err)}`);
+                                return null;
+                            });
+                        }
+                        const allowedStatusReactionEmojis = await allowedStatusReactionEmojisPromise;
+                        const resolvedEmoji = resolveTelegramReactionVariant({
+                            requestedEmoji: emoji,
+                            variantsByRequestedEmoji: statusReactionVariantsByEmoji,
+                            allowedEmojiReactions: allowedStatusReactionEmojis,
+                        });
+                        if (!resolvedEmoji) {
+                            return;
+                        }
+                        await reactionApi(chatId, msg.message_id, [
+                            { type: "emoji", emoji: resolvedEmoji },
+                        ]);
+                    }
+                },
+                // Telegram replaces atomically — no removeReaction needed
+            },
+            initialEmoji: ackReaction,
+            emojis: resolvedStatusReactionEmojis,
+            timing: statusReactionsConfig?.timing,
+            onError: (err) => {
+                logVerbose(`telegram status-reaction error for chat ${chatId}: ${String(err)}`);
+            },
         })
         : null;
+    // When status reactions are enabled, setQueued() replaces the simple ack reaction
+    const ackReactionPromise = statusReactionController
+        ? shouldAckReaction()
+            ? Promise.resolve(statusReactionController.setQueued()).then(() => true, () => false)
+            : null
+        : shouldAckReaction() && msg.message_id && reactionApi
+            ? withTelegramApiErrorLogging({
+                operation: "setMessageReaction",
+                fn: () => reactionApi(chatId, msg.message_id, [{ type: "emoji", emoji: ackReaction }]),
+            }).then(() => true, (err) => {
+                logVerbose(`telegram react failed for chat ${chatId}: ${String(err)}`);
+                return false;
+            })
+            : null;
     const replyTarget = describeReplyTarget(msg);
     const forwardOrigin = normalizeForwardedContext(msg);
     const replySuffix = replyTarget
@@ -514,7 +572,7 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
             ? {
                 sessionKey: route.mainSessionKey,
                 channel: "telegram",
-                to: String(chatId),
+                to: `telegram:${chatId}`,
                 accountId: route.accountId,
                 // Preserve DM topic threadId for replies (fixes #8891)
                 threadId: dmThreadId != null ? String(dmThreadId) : undefined,
@@ -557,6 +615,7 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
         ackReactionPromise,
         reactionApi,
         removeAckAfterReply,
+        statusReactionController,
         accountId: account.accountId,
     };
 };