@poolzin/pool-bot 2026.2.21 → 2026.2.23

package/dist/telegram/bot-handlers.js

@@ -1,55 +1,83 @@
-// @ts-nocheck
+import { 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 { resolveStoredModelOverride } from "../auto-reply/reply/model-selection.js";
-import { buildCommandsMessagePaginated } from "../auto-reply/status.js";
 import { listSkillCommandsForAgents } from "../auto-reply/skill-commands.js";
-import { resolveDefaultAgentId } from "../agents/agent-scope.js";
+import { buildCommandsMessagePaginated } from "../auto-reply/status.js";
+import { resolveChannelConfigWrites } from "../channels/plugins/config-writes.js";
 import { loadConfig } from "../config/config.js";
+import { writeConfigFile } from "../config/io.js";
 import { loadSessionStore, resolveStorePath } from "../config/sessions.js";
+import { danger, logVerbose, warn } from "../globals.js";
+import { enqueueSystemEvent } from "../infra/system-events.js";
+import { readChannelAllowFromStore } from "../pairing/pairing-store.js";
 import { resolveAgentRoute } from "../routing/resolve-route.js";
 import { resolveThreadSessionKeys } from "../routing/session-key.js";
-import { writeConfigFile } from "../config/io.js";
-import { danger, logVerbose, warn } from "../globals.js";
-import { resolveMedia } from "./bot/delivery.js";
 import { withTelegramApiErrorLogging } from "./api-logging.js";
-import { buildTelegramGroupPeerId, buildTelegramParentPeer, resolveTelegramForumThreadId, } from "./bot/helpers.js";
-import { firstDefined, isSenderAllowed, normalizeAllowFromWithStore } from "./bot-access.js";
+import { firstDefined, 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";
 import { migrateTelegramGroupConfig } from "./group-migration.js";
 import { resolveTelegramInlineButtonsScope } from "./inline-buttons.js";
-import { readTelegramAllowFromStore } from "./pairing-store.js";
-import { resolveChannelConfigWrites } from "../channels/plugins/config-writes.js";
 import { buildModelsKeyboard, buildProviderKeyboard, calculateTotalPages, getModelsPageSize, parseModelCallbackData, } from "./model-buttons.js";
 import { buildInlineKeyboard } from "./send.js";
+import { wasSentByBot } from "./sent-message-cache.js";
 export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, mediaMaxBytes, telegramCfg, groupAllowFrom, resolveGroupPolicy, resolveTelegramGroupConfig, shouldSkipUpdate, processMessage, logger, }) => {
+    const DEFAULT_TEXT_FRAGMENT_MAX_GAP_MS = 1500;
     const TELEGRAM_TEXT_FRAGMENT_START_THRESHOLD_CHARS = 4000;
-    const TELEGRAM_TEXT_FRAGMENT_MAX_GAP_MS = 1500;
+    const TELEGRAM_TEXT_FRAGMENT_MAX_GAP_MS = typeof opts.testTimings?.textFragmentGapMs === "number" &&
+        Number.isFinite(opts.testTimings.textFragmentGapMs)
+        ? Math.max(10, Math.floor(opts.testTimings.textFragmentGapMs))
+        : DEFAULT_TEXT_FRAGMENT_MAX_GAP_MS;
     const TELEGRAM_TEXT_FRAGMENT_MAX_ID_GAP = 1;
     const TELEGRAM_TEXT_FRAGMENT_MAX_PARTS = 12;
     const TELEGRAM_TEXT_FRAGMENT_MAX_TOTAL_CHARS = 50_000;
+    const mediaGroupTimeoutMs = typeof opts.testTimings?.mediaGroupFlushMs === "number" &&
+        Number.isFinite(opts.testTimings.mediaGroupFlushMs)
+        ? Math.max(10, Math.floor(opts.testTimings.mediaGroupFlushMs))
+        : MEDIA_GROUP_TIMEOUT_MS;
     const mediaGroupBuffer = new Map();
     let mediaGroupProcessing = Promise.resolve();
     const textFragmentBuffer = new Map();
     let textFragmentProcessing = Promise.resolve();
     const debounceMs = resolveInboundDebounceMs({ cfg, channel: "telegram" });
+    const buildSyntheticTextMessage = (params) => ({
+        ...params.base,
+        ...(params.from ? { from: params.from } : {}),
+        text: params.text,
+        caption: undefined,
+        caption_entities: undefined,
+        entities: undefined,
+        ...(params.date != null ? { date: params.date } : {}),
+    });
+    const buildSyntheticContext = (ctx, message) => {
+        const getFile = typeof ctx.getFile === "function"
+            ? ctx.getFile.bind(ctx)
+            : async () => ({});
+        return { message, me: ctx.me, getFile };
+    };
     const inboundDebouncer = createInboundDebouncer({
         debounceMs,
         buildKey: (entry) => entry.debounceKey,
         shouldDebounce: (entry) => {
-            if (entry.allMedia.length > 0)
+            if (entry.allMedia.length > 0) {
                 return false;
+            }
             const text = entry.msg.text ?? entry.msg.caption ?? "";
-            if (!text.trim())
+            if (!text.trim()) {
                 return false;
+            }
             return !hasControlCommand(text, cfg, { botUsername: entry.botUsername });
         },
         onFlush: async (entries) => {
             const last = entries.at(-1);
-            if (!last)
+            if (!last) {
                 return;
+            }
             if (entries.length === 1) {
                 await processMessage(last.ctx, last.allMedia, last.storeAllowFrom);
                 return;
@@ -58,21 +86,18 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
                 .map((entry) => entry.msg.text ?? entry.msg.caption ?? "")
                 .filter(Boolean)
                 .join("\n");
-            if (!combinedText.trim())
+            if (!combinedText.trim()) {
                 return;
+            }
             const first = entries[0];
             const baseCtx = first.ctx;
-            const getFile = typeof baseCtx.getFile === "function" ? baseCtx.getFile.bind(baseCtx) : async () => ({});
-            const syntheticMessage = {
-                ...first.msg,
+            const syntheticMessage = buildSyntheticTextMessage({
+                base: first.msg,
                 text: combinedText,
-                caption: undefined,
-                caption_entities: undefined,
-                entities: undefined,
                 date: last.msg.date ?? first.msg.date,
-            };
+            });
             const messageIdOverride = last.msg.message_id ? String(last.msg.message_id) : undefined;
-            await processMessage({ message: syntheticMessage, me: baseCtx.me, getFile }, [], first.storeAllowFrom, messageIdOverride ? { messageIdOverride } : undefined);
+            await processMessage(buildSyntheticContext(baseCtx, syntheticMessage), [], first.storeAllowFrom, messageIdOverride ? { messageIdOverride } : undefined);
         },
         onError: (err) => {
             runtime.error?.(danger(`telegram debounce flush failed: ${String(err)}`));
@@ -97,7 +122,7 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
             channel: "telegram",
             accountId,
             peer: {
-                kind: params.isGroup ? "group" : "dm",
+                kind: params.isGroup ? "group" : "direct",
                 id: peerId,
             },
             parentPeer,
@@ -145,7 +170,7 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
                     });
                 }
             }
-            const storeAllowFrom = await readTelegramAllowFromStore().catch(() => []);
+            const storeAllowFrom = await loadStoreAllowFrom();
             await processMessage(primaryEntry.ctx, allMedia, storeAllowFrom);
         }
         catch (err) {
@@ -157,82 +182,415 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
             entry.messages.sort((a, b) => a.msg.message_id - b.msg.message_id);
             const first = entry.messages[0];
             const last = entry.messages.at(-1);
-            if (!first || !last)
+            if (!first || !last) {
                 return;
+            }
             const combinedText = entry.messages.map((m) => m.msg.text ?? "").join("");
-            if (!combinedText.trim())
+            if (!combinedText.trim()) {
                 return;
-            const syntheticMessage = {
-                ...first.msg,
+            }
+            const syntheticMessage = buildSyntheticTextMessage({
+                base: first.msg,
                 text: combinedText,
-                caption: undefined,
-                caption_entities: undefined,
-                entities: undefined,
                 date: last.msg.date ?? first.msg.date,
-            };
-            const storeAllowFrom = await readTelegramAllowFromStore().catch(() => []);
+            });
+            const storeAllowFrom = await loadStoreAllowFrom();
             const baseCtx = first.ctx;
-            const getFile = typeof baseCtx.getFile === "function" ? baseCtx.getFile.bind(baseCtx) : async () => ({});
-            await processMessage({ message: syntheticMessage, me: baseCtx.me, getFile }, [], storeAllowFrom, { messageIdOverride: String(last.msg.message_id) });
+            await processMessage(buildSyntheticContext(baseCtx, syntheticMessage), [], storeAllowFrom, {
+                messageIdOverride: String(last.msg.message_id),
+            });
         }
         catch (err) {
             runtime.error?.(danger(`text fragment handler failed: ${String(err)}`));
         }
     };
+    const queueTextFragmentFlush = async (entry) => {
+        textFragmentProcessing = textFragmentProcessing
+            .then(async () => {
+            await flushTextFragments(entry);
+        })
+            .catch(() => undefined);
+        await textFragmentProcessing;
+    };
+    const runTextFragmentFlush = async (entry) => {
+        textFragmentBuffer.delete(entry.key);
+        await queueTextFragmentFlush(entry);
+    };
     const scheduleTextFragmentFlush = (entry) => {
         clearTimeout(entry.timer);
         entry.timer = setTimeout(async () => {
-            textFragmentBuffer.delete(entry.key);
-            textFragmentProcessing = textFragmentProcessing
-                .then(async () => {
-                await flushTextFragments(entry);
-            })
-                .catch(() => undefined);
-            await textFragmentProcessing;
+            await runTextFragmentFlush(entry);
         }, TELEGRAM_TEXT_FRAGMENT_MAX_GAP_MS);
     };
+    const loadStoreAllowFrom = async () => readChannelAllowFromStore("telegram", process.env, accountId).catch(() => []);
+    const isAllowlistAuthorized = (allow, senderId, senderUsername) => allow.hasWildcard ||
+        (allow.hasEntries &&
+            isSenderAllowed({
+                allow,
+                senderId,
+                senderUsername,
+            }));
+    const shouldSkipGroupMessage = (params) => {
+        const { isGroup, chatId, chatTitle, resolvedThreadId, senderId, senderUsername, effectiveGroupAllow, hasGroupAllowOverride, groupConfig, topicConfig, } = params;
+        const baseAccess = evaluateTelegramGroupBaseAccess({
+            isGroup,
+            groupConfig,
+            topicConfig,
+            hasGroupAllowOverride,
+            effectiveGroupAllow,
+            senderId,
+            senderUsername,
+            enforceAllowOverride: true,
+            requireSenderForAllowOverride: true,
+        });
+        if (!baseAccess.allowed) {
+            if (baseAccess.reason === "group-disabled") {
+                logVerbose(`Blocked telegram group ${chatId} (group disabled)`);
+                return true;
+            }
+            if (baseAccess.reason === "topic-disabled") {
+                logVerbose(`Blocked telegram topic ${chatId} (${resolvedThreadId ?? "unknown"}) (topic disabled)`);
+                return true;
+            }
+            logVerbose(`Blocked telegram group sender ${senderId || "unknown"} (group allowFrom override)`);
+            return true;
+        }
+        if (!isGroup) {
+            return false;
+        }
+        const policyAccess = evaluateTelegramGroupPolicyAccess({
+            isGroup,
+            chatId,
+            cfg,
+            telegramCfg,
+            topicConfig,
+            groupConfig,
+            effectiveGroupAllow,
+            senderId,
+            senderUsername,
+            resolveGroupPolicy,
+            enforcePolicy: true,
+            useTopicAndGroupOverrides: true,
+            enforceAllowlistAuthorization: true,
+            allowEmptyAllowlistEntries: false,
+            requireSenderForAllowlistAuthorization: true,
+            checkChatAllowlist: true,
+        });
+        if (!policyAccess.allowed) {
+            if (policyAccess.reason === "group-policy-disabled") {
+                logVerbose("Blocked telegram group message (groupPolicy: disabled)");
+                return true;
+            }
+            if (policyAccess.reason === "group-policy-allowlist-no-sender") {
+                logVerbose("Blocked telegram group message (no sender ID, groupPolicy: allowlist)");
+                return true;
+            }
+            if (policyAccess.reason === "group-policy-allowlist-empty") {
+                logVerbose("Blocked telegram group message (groupPolicy: allowlist, no group allowlist entries)");
+                return true;
+            }
+            if (policyAccess.reason === "group-policy-allowlist-unauthorized") {
+                logVerbose(`Blocked telegram group message from ${senderId} (groupPolicy: allowlist)`);
+                return true;
+            }
+            logger.info({ chatId, title: chatTitle, reason: "not-allowed" }, "skipping group message");
+            return true;
+        }
+        return false;
+    };
+    // Handle emoji reactions to messages.
+    bot.on("message_reaction", async (ctx) => {
+        try {
+            const reaction = ctx.messageReaction;
+            if (!reaction) {
+                return;
+            }
+            if (shouldSkipUpdate(ctx)) {
+                return;
+            }
+            const chatId = reaction.chat.id;
+            const messageId = reaction.message_id;
+            const user = reaction.user;
+            // Resolve reaction notification mode (default: "own").
+            const reactionMode = telegramCfg.reactionNotifications ?? "own";
+            if (reactionMode === "off") {
+                return;
+            }
+            if (user?.is_bot) {
+                return;
+            }
+            if (reactionMode === "own" && !wasSentByBot(chatId, messageId)) {
+                return;
+            }
+            // Detect added reactions.
+            const oldEmojis = new Set(reaction.old_reaction
+                .filter((r) => r.type === "emoji")
+                .map((r) => r.emoji));
+            const addedReactions = reaction.new_reaction
+                .filter((r) => r.type === "emoji")
+                .filter((r) => !oldEmojis.has(r.emoji));
+            if (addedReactions.length === 0) {
+                return;
+            }
+            // Build sender label.
+            const senderName = user
+                ? [user.first_name, user.last_name].filter(Boolean).join(" ").trim() || user.username
+                : undefined;
+            const senderUsername = user?.username ? `@${user.username}` : undefined;
+            let senderLabel = senderName;
+            if (senderName && senderUsername) {
+                senderLabel = `${senderName} (${senderUsername})`;
+            }
+            else if (!senderName && senderUsername) {
+                senderLabel = senderUsername;
+            }
+            if (!senderLabel && user?.id) {
+                senderLabel = `id:${user.id}`;
+            }
+            senderLabel = senderLabel || "unknown";
+            // 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: loadConfig(),
+                channel: "telegram",
+                accountId,
+                peer: { kind: isGroup ? "group" : "direct", id: peerId },
+                parentPeer,
+            });
+            const sessionKey = route.sessionKey;
+            // Enqueue system event for each added reaction.
+            for (const r of addedReactions) {
+                const emoji = r.emoji;
+                const text = `Telegram reaction added: ${emoji} by ${senderLabel} on msg ${messageId}`;
+                enqueueSystemEvent(text, {
+                    sessionKey,
+                    contextKey: `telegram:reaction:add:${chatId}:${messageId}:${user?.id ?? "anon"}:${emoji}`,
+                });
+                logVerbose(`telegram: reaction event enqueued: ${text}`);
+            }
+        }
+        catch (err) {
+            runtime.error?.(danger(`telegram reaction handler failed: ${String(err)}`));
+        }
+    });
+    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.
+        const text = typeof msg.text === "string" ? msg.text : undefined;
+        const isCommandLike = (text ?? "").trim().startsWith("/");
+        if (text && !isCommandLike) {
+            const nowMs = Date.now();
+            const senderId = msg.from?.id != null ? String(msg.from.id) : "unknown";
+            const key = `text:${chatId}:${resolvedThreadId ?? "main"}:${senderId}`;
+            const existing = textFragmentBuffer.get(key);
+            if (existing) {
+                const last = existing.messages.at(-1);
+                const lastMsgId = last?.msg.message_id;
+                const lastReceivedAtMs = last?.receivedAtMs ?? nowMs;
+                const idGap = typeof lastMsgId === "number" ? msg.message_id - lastMsgId : Infinity;
+                const timeGapMs = nowMs - lastReceivedAtMs;
+                const canAppend = idGap > 0 &&
+                    idGap <= TELEGRAM_TEXT_FRAGMENT_MAX_ID_GAP &&
+                    timeGapMs >= 0 &&
+                    timeGapMs <= TELEGRAM_TEXT_FRAGMENT_MAX_GAP_MS;
+                if (canAppend) {
+                    const currentTotalChars = existing.messages.reduce((sum, m) => sum + (m.msg.text?.length ?? 0), 0);
+                    const nextTotalChars = currentTotalChars + text.length;
+                    if (existing.messages.length + 1 <= TELEGRAM_TEXT_FRAGMENT_MAX_PARTS &&
+                        nextTotalChars <= TELEGRAM_TEXT_FRAGMENT_MAX_TOTAL_CHARS) {
+                        existing.messages.push({ msg, ctx, receivedAtMs: nowMs });
+                        scheduleTextFragmentFlush(existing);
+                        return;
+                    }
+                }
+                // Not appendable (or limits exceeded): flush buffered entry first, then continue normally.
+                clearTimeout(existing.timer);
+                textFragmentBuffer.delete(key);
+                textFragmentProcessing = textFragmentProcessing
+                    .then(async () => {
+                    await flushTextFragments(existing);
+                })
+                    .catch(() => undefined);
+                await textFragmentProcessing;
+            }
+            const shouldStart = text.length >= TELEGRAM_TEXT_FRAGMENT_START_THRESHOLD_CHARS;
+            if (shouldStart) {
+                const entry = {
+                    key,
+                    messages: [{ msg, ctx, receivedAtMs: nowMs }],
+                    timer: setTimeout(() => { }, TELEGRAM_TEXT_FRAGMENT_MAX_GAP_MS),
+                };
+                textFragmentBuffer.set(key, entry);
+                scheduleTextFragmentFlush(entry);
+                return;
+            }
+        }
+        // Media group handling - buffer multi-image messages
+        const mediaGroupId = msg.media_group_id;
+        if (mediaGroupId) {
+            const existing = mediaGroupBuffer.get(mediaGroupId);
+            if (existing) {
+                clearTimeout(existing.timer);
+                existing.messages.push({ msg, ctx });
+                existing.timer = setTimeout(async () => {
+                    mediaGroupBuffer.delete(mediaGroupId);
+                    mediaGroupProcessing = mediaGroupProcessing
+                        .then(async () => {
+                        await processMediaGroup(existing);
+                    })
+                        .catch(() => undefined);
+                    await mediaGroupProcessing;
+                }, mediaGroupTimeoutMs);
+            }
+            else {
+                const entry = {
+                    messages: [{ msg, ctx }],
+                    timer: setTimeout(async () => {
+                        mediaGroupBuffer.delete(mediaGroupId);
+                        mediaGroupProcessing = mediaGroupProcessing
+                            .then(async () => {
+                            await processMediaGroup(entry);
+                        })
+                            .catch(() => undefined);
+                        await mediaGroupProcessing;
+                    }, mediaGroupTimeoutMs),
+                };
+                mediaGroupBuffer.set(mediaGroupId, entry);
+            }
+            return;
+        }
+        let media = null;
+        try {
+            media = await resolveMedia(ctx, mediaMaxBytes, opts.token, opts.proxyFetch);
+        }
+        catch (mediaErr) {
+            const errMsg = String(mediaErr);
+            if (errMsg.includes("exceeds") && errMsg.includes("MB limit")) {
+                if (sendOversizeWarning) {
+                    const limitMb = Math.round(mediaMaxBytes / (1024 * 1024));
+                    await withTelegramApiErrorLogging({
+                        operation: "sendMessage",
+                        runtime,
+                        fn: () => bot.api.sendMessage(chatId, `⚠️ File too large. Maximum size is ${limitMb}MB.`, {
+                            reply_to_message_id: msg.message_id,
+                        }),
+                    }).catch(() => { });
+                }
+                logger.warn({ chatId, error: errMsg }, oversizeLogMessage);
+                return;
+            }
+            throw mediaErr;
+        }
+        // Skip sticker-only messages where the sticker was skipped (animated/video)
+        // These have no media and no text content to process.
+        const hasText = Boolean((msg.text ?? msg.caption ?? "").trim());
+        if (msg.sticker && !media && !hasText) {
+            logVerbose("telegram: skipping sticker-only message (unsupported sticker type)");
+            return;
+        }
+        const allMedia = media
+            ? [
+                {
+                    path: media.path,
+                    contentType: media.contentType,
+                    stickerMetadata: media.stickerMetadata,
+                },
+            ]
+            : [];
+        const senderId = msg.from?.id ? String(msg.from.id) : "";
+        const conversationKey = resolvedThreadId != null ? `${chatId}:topic:${resolvedThreadId}` : String(chatId);
+        const debounceKey = senderId
+            ? `telegram:${accountId ?? "default"}:${conversationKey}:${senderId}`
+            : null;
+        await inboundDebouncer.enqueue({
+            ctx,
+            msg,
+            allMedia,
+            storeAllowFrom,
+            debounceKey,
+            botUsername: ctx.me?.username,
+        });
+    };
     bot.on("callback_query", async (ctx) => {
         const callback = ctx.callbackQuery;
-        if (!callback)
+        if (!callback) {
             return;
-        if (shouldSkipUpdate(ctx))
+        }
+        if (shouldSkipUpdate(ctx)) {
             return;
+        }
+        const answerCallbackQuery = typeof ctx.answerCallbackQuery === "function"
+            ? () => ctx.answerCallbackQuery()
+            : () => bot.api.answerCallbackQuery(callback.id);
         // Answer immediately to prevent Telegram from retrying while we process
         await withTelegramApiErrorLogging({
             operation: "answerCallbackQuery",
             runtime,
-            fn: () => bot.api.answerCallbackQuery(callback.id),
+            fn: answerCallbackQuery,
         }).catch(() => { });
         try {
             const data = (callback.data ?? "").trim();
             const callbackMessage = callback.message;
-            if (!data || !callbackMessage)
+            if (!data || !callbackMessage) {
                 return;
+            }
+            const editCallbackMessage = async (text, params) => {
+                const editTextFn = ctx.editMessageText;
+                if (typeof editTextFn === "function") {
+                    return await ctx.editMessageText(text, params);
+                }
+                return await bot.api.editMessageText(callbackMessage.chat.id, callbackMessage.message_id, text, params);
+            };
+            const deleteCallbackMessage = async () => {
+                const deleteFn = ctx.deleteMessage;
+                if (typeof deleteFn === "function") {
+                    return await ctx.deleteMessage();
+                }
+                return await bot.api.deleteMessage(callbackMessage.chat.id, callbackMessage.message_id);
+            };
+            const replyToCallbackChat = async (text, params) => {
+                const replyFn = ctx.reply;
+                if (typeof replyFn === "function") {
+                    return await ctx.reply(text, params);
+                }
+                return await bot.api.sendMessage(callbackMessage.chat.id, text, params);
+            };
             const inlineButtonsScope = resolveTelegramInlineButtonsScope({
                 cfg,
                 accountId,
             });
-            if (inlineButtonsScope === "off")
+            if (inlineButtonsScope === "off") {
                 return;
+            }
             const chatId = callbackMessage.chat.id;
             const isGroup = callbackMessage.chat.type === "group" || callbackMessage.chat.type === "supergroup";
-            if (inlineButtonsScope === "dm" && isGroup)
+            if (inlineButtonsScope === "dm" && isGroup) {
                 return;
-            if (inlineButtonsScope === "group" && !isGroup)
+            }
+            if (inlineButtonsScope === "group" && !isGroup) {
                 return;
+            }
             const messageThreadId = callbackMessage.message_thread_id;
             const isForum = callbackMessage.chat.is_forum === true;
-            const resolvedThreadId = resolveTelegramForumThreadId({
+            const groupAllowContext = await resolveTelegramGroupAllowFromContext({
+                chatId,
+                accountId,
                 isForum,
                 messageThreadId,
+                groupAllowFrom,
+                resolveTelegramGroupConfig,
             });
-            const { groupConfig, topicConfig } = resolveTelegramGroupConfig(chatId, resolvedThreadId);
-            const storeAllowFrom = await readTelegramAllowFromStore().catch(() => []);
-            const groupAllowOverride = firstDefined(topicConfig?.allowFrom, groupConfig?.allowFrom);
-            const effectiveGroupAllow = normalizeAllowFromWithStore({
-                allowFrom: groupAllowOverride ?? groupAllowFrom,
-                storeAllowFrom,
-            });
+            const { resolvedThreadId, storeAllowFrom, groupConfig, topicConfig, effectiveGroupAllow, hasGroupAllowOverride, } = groupAllowContext;
             const effectiveDmAllow = normalizeAllowFromWithStore({
                 allowFrom: telegramCfg.allowFrom,
                 storeAllowFrom,
@@ -240,93 +598,49 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
             const dmPolicy = telegramCfg.dmPolicy ?? "pairing";
             const senderId = callback.from?.id ? String(callback.from.id) : "";
             const senderUsername = callback.from?.username ?? "";
-            if (isGroup) {
-                if (groupConfig?.enabled === false) {
-                    logVerbose(`Blocked telegram group ${chatId} (group disabled)`);
-                    return;
-                }
-                if (topicConfig?.enabled === false) {
-                    logVerbose(`Blocked telegram topic ${chatId} (${resolvedThreadId ?? "unknown"}) (topic disabled)`);
-                    return;
-                }
-                if (typeof groupAllowOverride !== "undefined") {
-                    const allowed = senderId &&
-                        isSenderAllowed({
-                            allow: effectiveGroupAllow,
-                            senderId,
-                            senderUsername,
-                        });
-                    if (!allowed) {
-                        logVerbose(`Blocked telegram group sender ${senderId || "unknown"} (group allowFrom override)`);
-                        return;
-                    }
-                }
-                const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
-                const groupPolicy = firstDefined(topicConfig?.groupPolicy, groupConfig?.groupPolicy, telegramCfg.groupPolicy, defaultGroupPolicy, "open");
-                if (groupPolicy === "disabled") {
-                    logVerbose(`Blocked telegram group message (groupPolicy: disabled)`);
-                    return;
-                }
-                if (groupPolicy === "allowlist") {
-                    if (!senderId) {
-                        logVerbose(`Blocked telegram group message (no sender ID, groupPolicy: allowlist)`);
-                        return;
-                    }
-                    if (!effectiveGroupAllow.hasEntries) {
-                        logVerbose("Blocked telegram group message (groupPolicy: allowlist, no group allowlist entries)");
-                        return;
-                    }
-                    if (!isSenderAllowed({
-                        allow: effectiveGroupAllow,
-                        senderId,
-                        senderUsername,
-                    })) {
-                        logVerbose(`Blocked telegram group message from ${senderId} (groupPolicy: allowlist)`);
-                        return;
-                    }
-                }
-                const groupAllowlist = resolveGroupPolicy(chatId);
-                if (groupAllowlist.allowlistEnabled && !groupAllowlist.allowed) {
-                    logger.info({ chatId, title: callbackMessage.chat.title, reason: "not-allowed" }, "skipping group message");
-                    return;
-                }
+            if (shouldSkipGroupMessage({
+                isGroup,
+                chatId,
+                chatTitle: callbackMessage.chat.title,
+                resolvedThreadId,
+                senderId,
+                senderUsername,
+                effectiveGroupAllow,
+                hasGroupAllowOverride,
+                groupConfig,
+                topicConfig,
+            })) {
+                return;
             }
             if (inlineButtonsScope === "allowlist") {
                 if (!isGroup) {
-                    if (dmPolicy === "disabled")
+                    if (dmPolicy === "disabled") {
                         return;
+                    }
                     if (dmPolicy !== "open") {
-                        const allowed = effectiveDmAllow.hasWildcard ||
-                            (effectiveDmAllow.hasEntries &&
-                                isSenderAllowed({
-                                    allow: effectiveDmAllow,
-                                    senderId,
-                                    senderUsername,
-                                }));
-                        if (!allowed)
+                        const allowed = isAllowlistAuthorized(effectiveDmAllow, senderId, senderUsername);
+                        if (!allowed) {
                             return;
+                        }
                     }
                 }
                 else {
-                    const allowed = effectiveGroupAllow.hasWildcard ||
-                        (effectiveGroupAllow.hasEntries &&
-                            isSenderAllowed({
-                                allow: effectiveGroupAllow,
-                                senderId,
-                                senderUsername,
-                            }));
-                    if (!allowed)
+                    const allowed = isAllowlistAuthorized(effectiveGroupAllow, senderId, senderUsername);
+                    if (!allowed) {
                         return;
+                    }
                 }
             }
             const paginationMatch = data.match(/^commands_page_(\d+|noop)(?::(.+))?$/);
             if (paginationMatch) {
                 const pageValue = paginationMatch[1];
-                if (pageValue === "noop")
+                if (pageValue === "noop") {
                     return;
+                }
                 const page = Number.parseInt(pageValue, 10);
-                if (Number.isNaN(page) || page < 1)
+                if (Number.isNaN(page) || page < 1) {
                     return;
+                }
                 const agentId = paginationMatch[2]?.trim() || resolveDefaultAgentId(cfg) || undefined;
                 const skillCommands = listSkillCommandsForAgents({
                     cfg,
@@ -340,7 +654,7 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
                     ? buildInlineKeyboard(buildCommandsPaginationKeyboard(result.currentPage, result.totalPages, agentId))
                     : undefined;
                 try {
-                    await bot.api.editMessageText(callbackMessage.chat.id, callbackMessage.message_id, result.text, keyboard ? { reply_markup: keyboard } : undefined);
+                    await editCallbackMessage(result.text, keyboard ? { reply_markup: keyboard } : undefined);
                 }
                 catch (editErr) {
                     const errStr = String(editErr);
@@ -358,11 +672,18 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
                 const editMessageWithButtons = async (text, buttons) => {
                     const keyboard = buildInlineKeyboard(buttons);
                     try {
-                        await bot.api.editMessageText(callbackMessage.chat.id, callbackMessage.message_id, text, keyboard ? { reply_markup: keyboard } : undefined);
+                        await editCallbackMessage(text, keyboard ? { reply_markup: keyboard } : undefined);
                     }
                     catch (editErr) {
                         const errStr = String(editErr);
-                        if (!errStr.includes("message is not modified")) {
+                        if (errStr.includes("no text in the message")) {
+                            try {
+                                await deleteCallbackMessage();
+                            }
+                            catch { }
+                            await replyToCallbackChat(text, keyboard ? { reply_markup: keyboard } : undefined);
+                        }
+                        else if (!errStr.includes("message is not modified")) {
                             throw editErr;
                         }
                     }
@@ -384,6 +705,7 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
                     const { provider, page } = modelCallback;
                     const modelSet = byProvider.get(provider);
                     if (!modelSet || modelSet.size === 0) {
+                        // Provider not found or no models - show providers list
                         const providerInfos = providers.map((p) => ({
                             id: p,
                             count: byProvider.get(p)?.size ?? 0,
@@ -396,6 +718,7 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
                     const pageSize = getModelsPageSize();
                     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({
                         chatId,
                         isGroup,
@@ -417,16 +740,13 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
                 }
                 if (modelCallback.type === "select") {
                     const { provider, model } = modelCallback;
-                    const syntheticMessage = {
-                        ...callbackMessage,
+                    // Process model selection as a synthetic message with /model command
+                    const syntheticMessage = buildSyntheticTextMessage({
+                        base: callbackMessage,
                         from: callback.from,
                         text: `/model ${provider}/${model}`,
-                        caption: undefined,
-                        caption_entities: undefined,
-                        entities: undefined,
-                    };
-                    const getFile = typeof ctx.getFile === "function" ? ctx.getFile.bind(ctx) : async () => ({});
-                    await processMessage({ message: syntheticMessage, me: ctx.me, getFile }, [], storeAllowFrom, {
+                    });
+                    await processMessage(buildSyntheticContext(ctx, syntheticMessage), [], storeAllowFrom, {
                         forceWasMentioned: true,
                         messageIdOverride: callback.id,
                     });
@@ -434,16 +754,12 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
                 }
                 return;
             }
-            const syntheticMessage = {
-                ...callbackMessage,
+            const syntheticMessage = buildSyntheticTextMessage({
+                base: callbackMessage,
                 from: callback.from,
                 text: data,
-                caption: undefined,
-                caption_entities: undefined,
-                entities: undefined,
-            };
-            const getFile = typeof ctx.getFile === "function" ? ctx.getFile.bind(ctx) : async () => ({});
-            await processMessage({ message: syntheticMessage, me: ctx.me, getFile }, [], storeAllowFrom, {
+            });
+            await processMessage(buildSyntheticContext(ctx, syntheticMessage), [], storeAllowFrom, {
                 forceWasMentioned: true,
                 messageIdOverride: callback.id,
             });
@@ -456,10 +772,12 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
     bot.on("message:migrate_to_chat_id", async (ctx) => {
         try {
             const msg = ctx.message;
-            if (!msg?.migrate_to_chat_id)
+            if (!msg?.migrate_to_chat_id) {
                 return;
-            if (shouldSkipUpdate(ctx))
+            }
+            if (shouldSkipUpdate(ctx)) {
                 return;
+            }
             const oldChatId = String(msg.chat.id);
             const newChatId = String(msg.migrate_to_chat_id);
             const chatTitle = msg.chat.title ?? "Unknown";
@@ -496,224 +814,167 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
     bot.on("message", async (ctx) => {
         try {
             const msg = ctx.message;
-            if (!msg)
+            if (!msg) {
                 return;
-            if (shouldSkipUpdate(ctx))
+            }
+            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 resolvedThreadId = resolveTelegramForumThreadId({
+            const groupAllowContext = await resolveTelegramGroupAllowFromContext({
+                chatId,
+                accountId,
                 isForum,
                 messageThreadId,
+                groupAllowFrom,
+                resolveTelegramGroupConfig,
             });
-            const storeAllowFrom = await readTelegramAllowFromStore().catch(() => []);
-            const { groupConfig, topicConfig } = resolveTelegramGroupConfig(chatId, resolvedThreadId);
-            const groupAllowOverride = firstDefined(topicConfig?.allowFrom, groupConfig?.allowFrom);
-            const effectiveGroupAllow = normalizeAllowFromWithStore({
-                allowFrom: groupAllowOverride ?? groupAllowFrom,
+            const { resolvedThreadId, storeAllowFrom, groupConfig, topicConfig, effectiveGroupAllow, hasGroupAllowOverride, } = groupAllowContext;
+            const senderId = msg.from?.id != null ? String(msg.from.id) : "";
+            const senderUsername = msg.from?.username ?? "";
+            if (shouldSkipGroupMessage({
+                isGroup,
+                chatId,
+                chatTitle: msg.chat.title,
+                resolvedThreadId,
+                senderId,
+                senderUsername,
+                effectiveGroupAllow,
+                hasGroupAllowOverride,
+                groupConfig,
+                topicConfig,
+            })) {
+                return;
+            }
+            await processInboundMessage({
+                ctx,
+                msg,
+                chatId,
+                resolvedThreadId,
                 storeAllowFrom,
+                sendOversizeWarning: true,
+                oversizeLogMessage: "media exceeds size limit",
             });
-            const hasGroupAllowOverride = typeof groupAllowOverride !== "undefined";
-            if (isGroup) {
-                if (groupConfig?.enabled === false) {
-                    logVerbose(`Blocked telegram group ${chatId} (group disabled)`);
-                    return;
-                }
-                if (topicConfig?.enabled === false) {
-                    logVerbose(`Blocked telegram topic ${chatId} (${resolvedThreadId ?? "unknown"}) (topic disabled)`);
-                    return;
-                }
-                if (hasGroupAllowOverride) {
-                    const senderId = msg.from?.id;
-                    const senderUsername = msg.from?.username ?? "";
-                    const allowed = senderId != null &&
-                        isSenderAllowed({
-                            allow: effectiveGroupAllow,
-                            senderId: String(senderId),
-                            senderUsername,
-                        });
-                    if (!allowed) {
-                        logVerbose(`Blocked telegram group sender ${senderId ?? "unknown"} (group allowFrom override)`);
-                        return;
-                    }
-                }
-                // Group policy filtering: controls how group messages are handled
-                // - "open": groups bypass allowFrom, only mention-gating applies
-                // - "disabled": block all group messages entirely
-                // - "allowlist": only allow group messages from senders in groupAllowFrom/allowFrom
-                const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
-                const groupPolicy = firstDefined(topicConfig?.groupPolicy, groupConfig?.groupPolicy, telegramCfg.groupPolicy, defaultGroupPolicy, "open");
-                if (groupPolicy === "disabled") {
-                    logVerbose(`Blocked telegram group message (groupPolicy: disabled)`);
-                    return;
-                }
-                if (groupPolicy === "allowlist") {
-                    // For allowlist mode, the sender (msg.from.id) must be in allowFrom
-                    const senderId = msg.from?.id;
-                    if (senderId == null) {
-                        logVerbose(`Blocked telegram group message (no sender ID, groupPolicy: allowlist)`);
-                        return;
-                    }
-                    if (!effectiveGroupAllow.hasEntries) {
-                        logVerbose("Blocked telegram group message (groupPolicy: allowlist, no group allowlist entries)");
-                        return;
-                    }
-                    const senderUsername = msg.from?.username ?? "";
-                    if (!isSenderAllowed({
+        }
+        catch (err) {
+            runtime.error?.(danger(`handler failed: ${String(err)}`));
+        }
+    });
+    // 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,
-                    })) {
-                        logVerbose(`Blocked telegram group message from ${senderId} (groupPolicy: allowlist)`);
-                        return;
-                    }
-                }
-                // Group allowlist based on configured group IDs.
-                const groupAllowlist = resolveGroupPolicy(chatId);
-                if (groupAllowlist.allowlistEnabled && !groupAllowlist.allowed) {
-                    logger.info({ chatId, title: msg.chat.title, reason: "not-allowed" }, "skipping group message");
+                    });
+                if (!allowed) {
+                    logVerbose(`Blocked telegram channel sender ${senderId ?? "unknown"} (group allowFrom override)`);
                     return;
                 }
             }
-            // Text fragment handling - Telegram splits long pastes into multiple inbound messages (~4096 chars).
-            // 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) {
-                const nowMs = Date.now();
-                const senderId = msg.from?.id != null ? String(msg.from.id) : "unknown";
-                const key = `text:${chatId}:${resolvedThreadId ?? "main"}:${senderId}`;
-                const existing = textFragmentBuffer.get(key);
-                if (existing) {
-                    const last = existing.messages.at(-1);
-                    const lastMsgId = last?.msg.message_id;
-                    const lastReceivedAtMs = last?.receivedAtMs ?? nowMs;
-                    const idGap = typeof lastMsgId === "number" ? msg.message_id - lastMsgId : Infinity;
-                    const timeGapMs = nowMs - lastReceivedAtMs;
-                    const canAppend = idGap > 0 &&
-                        idGap <= TELEGRAM_TEXT_FRAGMENT_MAX_ID_GAP &&
-                        timeGapMs >= 0 &&
-                        timeGapMs <= TELEGRAM_TEXT_FRAGMENT_MAX_GAP_MS;
-                    if (canAppend) {
-                        const currentTotalChars = existing.messages.reduce((sum, m) => sum + (m.msg.text?.length ?? 0), 0);
-                        const nextTotalChars = currentTotalChars + text.length;
-                        if (existing.messages.length + 1 <= TELEGRAM_TEXT_FRAGMENT_MAX_PARTS &&
-                            nextTotalChars <= TELEGRAM_TEXT_FRAGMENT_MAX_TOTAL_CHARS) {
-                            existing.messages.push({ msg, ctx, receivedAtMs: nowMs });
-                            scheduleTextFragmentFlush(existing);
-                            return;
-                        }
-                    }
-                    // Not appendable (or limits exceeded): flush buffered entry first, then continue normally.
-                    clearTimeout(existing.timer);
-                    textFragmentBuffer.delete(key);
-                    textFragmentProcessing = textFragmentProcessing
-                        .then(async () => {
-                        await flushTextFragments(existing);
-                    })
-                        .catch(() => undefined);
-                    await textFragmentProcessing;
-                }
-                const shouldStart = text.length >= TELEGRAM_TEXT_FRAGMENT_START_THRESHOLD_CHARS;
-                if (shouldStart) {
-                    const entry = {
-                        key,
-                        messages: [{ msg, ctx, receivedAtMs: nowMs }],
-                        timer: setTimeout(() => { }, TELEGRAM_TEXT_FRAGMENT_MAX_GAP_MS),
-                    };
-                    textFragmentBuffer.set(key, entry);
-                    scheduleTextFragmentFlush(entry);
+            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;
                 }
-            }
-            // Media group handling - buffer multi-image messages
-            const mediaGroupId = msg.media_group_id;
-            if (mediaGroupId) {
-                const existing = mediaGroupBuffer.get(mediaGroupId);
-                if (existing) {
-                    clearTimeout(existing.timer);
-                    existing.messages.push({ msg, ctx });
-                    existing.timer = setTimeout(async () => {
-                        mediaGroupBuffer.delete(mediaGroupId);
-                        mediaGroupProcessing = mediaGroupProcessing
-                            .then(async () => {
-                            await processMediaGroup(existing);
-                        })
-                            .catch(() => undefined);
-                        await mediaGroupProcessing;
-                    }, MEDIA_GROUP_TIMEOUT_MS);
-                }
-                else {
-                    const entry = {
-                        messages: [{ msg, ctx }],
-                        timer: setTimeout(async () => {
-                            mediaGroupBuffer.delete(mediaGroupId);
-                            mediaGroupProcessing = mediaGroupProcessing
-                                .then(async () => {
-                                await processMediaGroup(entry);
-                            })
-                                .catch(() => undefined);
-                            await mediaGroupProcessing;
-                        }, MEDIA_GROUP_TIMEOUT_MS),
-                    };
-                    mediaGroupBuffer.set(mediaGroupId, entry);
+                if (!effectiveGroupAllow.hasEntries) {
+                    logVerbose("Blocked telegram channel message (groupPolicy: allowlist, no allowlist entries)");
+                    return;
                 }
-                return;
-            }
-            let media = null;
-            try {
-                media = await resolveMedia(ctx, mediaMaxBytes, opts.token, opts.proxyFetch);
-            }
-            catch (mediaErr) {
-                const errMsg = String(mediaErr);
-                if (errMsg.includes("exceeds") && errMsg.includes("MB limit")) {
-                    const limitMb = Math.round(mediaMaxBytes / (1024 * 1024));
-                    await withTelegramApiErrorLogging({
-                        operation: "sendMessage",
-                        runtime,
-                        fn: () => bot.api.sendMessage(chatId, `⚠️ File too large. Maximum size is ${limitMb}MB.`, {
-                            reply_to_message_id: msg.message_id,
-                        }),
-                    }).catch(() => { });
-                    logger.warn({ chatId, error: errMsg }, "media exceeds size limit");
+                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;
                 }
-                throw mediaErr;
-            }
-            // Skip sticker-only messages where the sticker was skipped (animated/video)
-            // These have no media and no text content to process.
-            const hasText = Boolean((msg.text ?? msg.caption ?? "").trim());
-            if (msg.sticker && !media && !hasText) {
-                logVerbose("telegram: skipping sticker-only message (unsupported sticker type)");
-                return;
             }
-            const allMedia = media
-                ? [
-                    {
-                        path: media.path,
-                        contentType: media.contentType,
-                        stickerMetadata: media.stickerMetadata,
-                    },
-                ]
-                : [];
-            const senderId = msg.from?.id ? String(msg.from.id) : "";
-            const conversationKey = resolvedThreadId != null ? `${chatId}:topic:${resolvedThreadId}` : String(chatId);
-            const debounceKey = senderId
-                ? `telegram:${accountId ?? "default"}:${conversationKey}:${senderId}`
-                : null;
-            await inboundDebouncer.enqueue({
-                ctx,
-                msg,
-                allMedia,
+            // 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,
-                debounceKey,
-                botUsername: ctx.me?.username,
+                sendOversizeWarning: false,
+                oversizeLogMessage: "channel post media exceeds size limit",
             });
         }
         catch (err) {
-            runtime.error?.(danger(`handler failed: ${String(err)}`));
+            runtime.error?.(danger(`channel_post handler failed: ${String(err)}`));
         }
     });
 };