@poolzin/pool-bot 2026.2.21 → 2026.2.23

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

@@ -4,100 +4,97 @@ import { finalizeInboundContext } from "../auto-reply/reply/inbound-context.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 { createReplyPrefixOptions } from "../channels/reply-prefix.js";
 import { resolveMarkdownTableMode } from "../config/markdown-tables.js";
-import { resolveTelegramCustomCommands } from "../config/telegram-custom-commands.js";
-import { normalizeTelegramCommandName, TELEGRAM_COMMAND_NAME_PATTERN, } from "../config/telegram-custom-commands.js";
+import { normalizeTelegramCommandName, resolveTelegramCustomCommands, TELEGRAM_COMMAND_NAME_PATTERN, } from "../config/telegram-custom-commands.js";
 import { danger, logVerbose } from "../globals.js";
-import { readChannelAllowFromStore } from "../pairing/pairing-store.js";
+import { getAgentScopedMediaLocalRoots } from "../media/local-roots.js";
 import { executePluginCommand, getPluginCommandSpecs, matchPluginCommand, } from "../plugins/commands.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 { buildCappedTelegramMenuCommands, buildPluginTelegramMenuCommands, syncTelegramMenuCommands, } from "./bot-native-command-menu.js";
 import { deliverReplies } from "./bot/delivery.js";
-import { buildTelegramThreadParams, buildSenderName, buildTelegramGroupFrom, buildTelegramGroupPeerId, resolveTelegramForumThreadId, } from "./bot/helpers.js";
+import { buildTelegramThreadParams, buildSenderName, buildTelegramGroupFrom, buildTelegramGroupPeerId, buildTelegramParentPeer, resolveTelegramGroupAllowFromContext, resolveTelegramThreadSpec, } from "./bot/helpers.js";
+import { evaluateTelegramGroupBaseAccess, evaluateTelegramGroupPolicyAccess, } from "./group-access.js";
 import { buildInlineKeyboard } from "./send.js";
+const EMPTY_RESPONSE_FALLBACK = "No response generated. Please try again.";
 async function resolveTelegramCommandAuth(params) {
-    const { msg, bot, cfg, telegramCfg, allowFrom, groupAllowFrom, useAccessGroups, resolveGroupPolicy, resolveTelegramGroupConfig, requireAuth, } = params;
+    const { msg, bot, cfg, accountId, telegramCfg, allowFrom, groupAllowFrom, useAccessGroups, resolveGroupPolicy, resolveTelegramGroupConfig, requireAuth, } = params;
     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 readChannelAllowFromStore("telegram").catch(() => []);
-    const { groupConfig, topicConfig } = resolveTelegramGroupConfig(chatId, resolvedThreadId);
-    const groupAllowOverride = firstDefined(topicConfig?.allowFrom, groupConfig?.allowFrom);
-    const effectiveGroupAllow = normalizeAllowFromWithStore({
-        allowFrom: groupAllowOverride ?? groupAllowFrom,
-        storeAllowFrom,
-    });
-    const hasGroupAllowOverride = typeof groupAllowOverride !== "undefined";
-    const senderIdRaw = msg.from?.id;
-    const senderId = senderIdRaw ? String(senderIdRaw) : "";
+    const { resolvedThreadId, storeAllowFrom, groupConfig, topicConfig, effectiveGroupAllow, hasGroupAllowOverride, } = groupAllowContext;
+    const senderId = msg.from?.id ? String(msg.from.id) : "";
     const senderUsername = msg.from?.username ?? "";
-    if (isGroup && groupConfig?.enabled === false) {
-        await withTelegramApiErrorLogging({
-            operation: "sendMessage",
-            fn: () => bot.api.sendMessage(chatId, "This group is disabled."),
-        });
-        return null;
-    }
-    if (isGroup && topicConfig?.enabled === false) {
+    const sendAuthMessage = async (text) => {
         await withTelegramApiErrorLogging({
             operation: "sendMessage",
-            fn: () => bot.api.sendMessage(chatId, "This topic is disabled."),
+            fn: () => bot.api.sendMessage(chatId, text),
         });
         return null;
-    }
-    if (requireAuth && isGroup && hasGroupAllowOverride) {
-        if (senderIdRaw == null ||
-            !isSenderAllowed({
-                allow: effectiveGroupAllow,
-                senderId: String(senderIdRaw),
-                senderUsername,
-            })) {
-            await withTelegramApiErrorLogging({
-                operation: "sendMessage",
-                fn: () => bot.api.sendMessage(chatId, "You are not authorized to use this command."),
-            });
-            return null;
+    };
+    const rejectNotAuthorized = async () => {
+        return await sendAuthMessage("You are not authorized to use this command.");
+    };
+    const baseAccess = evaluateTelegramGroupBaseAccess({
+        isGroup,
+        groupConfig,
+        topicConfig,
+        hasGroupAllowOverride,
+        effectiveGroupAllow,
+        senderId,
+        senderUsername,
+        enforceAllowOverride: requireAuth,
+        requireSenderForAllowOverride: true,
+    });
+    if (!baseAccess.allowed) {
+        if (baseAccess.reason === "group-disabled") {
+            return await sendAuthMessage("This group is disabled.");
+        }
+        if (baseAccess.reason === "topic-disabled") {
+            return await sendAuthMessage("This topic is disabled.");
         }
+        return await rejectNotAuthorized();
     }
-    if (isGroup && useAccessGroups) {
-        const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
-        const groupPolicy = firstDefined(topicConfig?.groupPolicy, groupConfig?.groupPolicy, telegramCfg.groupPolicy, defaultGroupPolicy, "open");
-        if (groupPolicy === "disabled") {
-            await withTelegramApiErrorLogging({
-                operation: "sendMessage",
-                fn: () => bot.api.sendMessage(chatId, "Telegram group commands are disabled."),
-            });
-            return null;
+    const policyAccess = evaluateTelegramGroupPolicyAccess({
+        isGroup,
+        chatId,
+        cfg,
+        telegramCfg,
+        topicConfig,
+        groupConfig,
+        effectiveGroupAllow,
+        senderId,
+        senderUsername,
+        resolveGroupPolicy,
+        enforcePolicy: useAccessGroups,
+        useTopicAndGroupOverrides: false,
+        enforceAllowlistAuthorization: requireAuth,
+        allowEmptyAllowlistEntries: true,
+        requireSenderForAllowlistAuthorization: true,
+        checkChatAllowlist: useAccessGroups,
+    });
+    if (!policyAccess.allowed) {
+        if (policyAccess.reason === "group-policy-disabled") {
+            return await sendAuthMessage("Telegram group commands are disabled.");
         }
-        if (groupPolicy === "allowlist" && requireAuth) {
-            if (senderIdRaw == null ||
-                !isSenderAllowed({
-                    allow: effectiveGroupAllow,
-                    senderId: String(senderIdRaw),
-                    senderUsername,
-                })) {
-                await withTelegramApiErrorLogging({
-                    operation: "sendMessage",
-                    fn: () => bot.api.sendMessage(chatId, "You are not authorized to use this command."),
-                });
-                return null;
-            }
+        if (policyAccess.reason === "group-policy-allowlist-no-sender" ||
+            policyAccess.reason === "group-policy-allowlist-unauthorized") {
+            return await rejectNotAuthorized();
         }
-        const groupAllowlist = resolveGroupPolicy(chatId);
-        if (groupAllowlist.allowlistEnabled && !groupAllowlist.allowed) {
-            await withTelegramApiErrorLogging({
-                operation: "sendMessage",
-                fn: () => bot.api.sendMessage(chatId, "This group is not allowed."),
-            });
-            return null;
+        if (policyAccess.reason === "group-chat-not-allowed") {
+            return await sendAuthMessage("This group is not allowed.");
         }
     }
     const dmAllow = normalizeAllowFromWithStore({
@@ -115,11 +112,7 @@ async function resolveTelegramCommandAuth(params) {
         modeWhenAccessGroupsOff: "configured",
     });
     if (requireAuth && !commandAuthorized) {
-        await withTelegramApiErrorLogging({
-            operation: "sendMessage",
-            fn: () => bot.api.sendMessage(chatId, "You are not authorized to use this command."),
-        });
-        return null;
+        return await rejectNotAuthorized();
     }
     return {
         chatId,
@@ -137,14 +130,17 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
     const boundRoute = nativeEnabled && nativeSkillsEnabled
         ? resolveAgentRoute({ cfg, channel: "telegram", accountId })
         : null;
-    const boundAgentIds = boundRoute && boundRoute.matchedBy.startsWith("binding.") ? [boundRoute.agentId] : null;
+    const boundAgentIds = boundRoute ? [boundRoute.agentId] : null;
     const skillCommands = nativeEnabled && nativeSkillsEnabled
         ? listSkillCommandsForAgents(boundAgentIds ? { cfg, agentIds: boundAgentIds } : { cfg })
         : [];
     const nativeCommands = nativeEnabled
-        ? listNativeCommandSpecsForConfig(cfg, { skillCommands, provider: "telegram" })
+        ? listNativeCommandSpecsForConfig(cfg, {
+            skillCommands,
+            provider: "telegram",
+        })
         : [];
-    const reservedCommands = new Set(listNativeCommandSpecs().map((command) => command.name.toLowerCase()));
+    const reservedCommands = new Set(listNativeCommandSpecs().map((command) => normalizeTelegramCommandName(command.name)));
     for (const command of skillCommands) {
         reservedCommands.add(command.name.toLowerCase());
     }
@@ -157,82 +153,95 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
     }
     const customCommands = customResolution.commands;
     const pluginCommandSpecs = getPluginCommandSpecs();
-    const pluginCommands = [];
     const existingCommands = new Set([
-        ...nativeCommands.map((command) => command.name),
+        ...nativeCommands.map((command) => normalizeTelegramCommandName(command.name)),
         ...customCommands.map((command) => command.command),
     ].map((command) => command.toLowerCase()));
-    const pluginCommandNames = new Set();
-    for (const spec of pluginCommandSpecs) {
-        const normalized = normalizeTelegramCommandName(spec.name);
-        if (!normalized || !TELEGRAM_COMMAND_NAME_PATTERN.test(normalized)) {
-            runtime.error?.(danger(`Plugin command "/${spec.name}" is invalid for Telegram (use a-z, 0-9, underscore; max 32 chars).`));
-            continue;
-        }
-        const description = spec.description.trim();
-        if (!description) {
-            runtime.error?.(danger(`Plugin command "/${normalized}" is missing a description.`));
-            continue;
-        }
-        if (existingCommands.has(normalized)) {
-            runtime.error?.(danger(`Plugin command "/${normalized}" conflicts with an existing Telegram command.`));
-            continue;
-        }
-        if (pluginCommandNames.has(normalized)) {
-            runtime.error?.(danger(`Plugin command "/${normalized}" is duplicated.`));
-            continue;
-        }
-        pluginCommandNames.add(normalized);
-        existingCommands.add(normalized);
-        pluginCommands.push({ command: normalized, description });
+    const pluginCatalog = buildPluginTelegramMenuCommands({
+        specs: pluginCommandSpecs,
+        existingCommands,
+    });
+    for (const issue of pluginCatalog.issues) {
+        runtime.error?.(danger(issue));
     }
     const allCommandsFull = [
-        ...nativeCommands.map((command) => ({
-            command: command.name,
-            description: command.description,
-        })),
-        ...pluginCommands,
+        ...nativeCommands
+            .map((command) => {
+            const normalized = normalizeTelegramCommandName(command.name);
+            if (!TELEGRAM_COMMAND_NAME_PATTERN.test(normalized)) {
+                runtime.error?.(danger(`Native command "${command.name}" is invalid for Telegram (resolved to "${normalized}"). Skipping.`));
+                return null;
+            }
+            return {
+                command: normalized,
+                description: command.description,
+            };
+        })
+            .filter((cmd) => cmd !== null),
+        ...(nativeEnabled ? pluginCatalog.commands : []),
         ...customCommands,
     ];
-    // 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 { commandsToRegister, totalCommands, maxCommands, overflowCount } = buildCappedTelegramMenuCommands({
+        allCommands: allCommandsFull,
+    });
+    if (overflowCount > 0) {
+        runtime.log?.(`Telegram limits bots to ${maxCommands} commands. ` +
+            `${totalCommands} configured; registering first ${maxCommands}. ` +
+            `Use channels.telegram.commands.native: false to disable, or reduce plugin/skill/custom commands.`);
     }
-    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(() => { });
-        }
+    // Telegram only limits the setMyCommands payload (menu entries).
+    // Keep hidden commands callable by registering handlers for the full catalog.
+    syncTelegramMenuCommands({ bot, runtime, commandsToRegister });
+    const resolveCommandRuntimeContext = (params) => {
+        const { msg, isGroup, isForum, resolvedThreadId } = params;
+        const chatId = msg.chat.id;
+        const messageThreadId = msg.message_thread_id;
+        const threadSpec = resolveTelegramThreadSpec({
+            isGroup,
+            isForum,
+            messageThreadId,
+        });
+        const parentPeer = buildTelegramParentPeer({ isGroup, resolvedThreadId, chatId });
+        const route = resolveAgentRoute({
+            cfg,
+            channel: "telegram",
+            accountId,
+            peer: {
+                kind: isGroup ? "group" : "direct",
+                id: isGroup ? buildTelegramGroupPeerId(chatId, resolvedThreadId) : String(chatId),
+            },
+            parentPeer,
+        });
+        const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, route.agentId);
+        const tableMode = resolveMarkdownTableMode({
+            cfg,
+            channel: "telegram",
+            accountId: route.accountId,
+        });
+        const chunkMode = resolveChunkMode(cfg, "telegram", route.accountId);
+        return { chatId, threadSpec, route, mediaLocalRoots, tableMode, chunkMode };
     };
-    if (typeof bot.api.deleteMyCommands === "function") {
-        withTelegramApiErrorLogging({
-            operation: "deleteMyCommands",
-            runtime,
-            fn: () => bot.api.deleteMyCommands(),
-        })
-            .catch(() => { })
-            .then(registerCommands)
-            .catch(() => { });
-    }
-    else {
-        registerCommands();
-    }
-    if (allCommands.length > 0) {
+    const buildCommandDeliveryBaseOptions = (params) => ({
+        chatId: String(params.chatId),
+        token: opts.token,
+        runtime,
+        bot,
+        mediaLocalRoots: params.mediaLocalRoots,
+        replyToMode,
+        textLimit,
+        thread: params.threadSpec,
+        tableMode: params.tableMode,
+        chunkMode: params.chunkMode,
+        linkPreview: telegramCfg.linkPreview,
+    });
+    if (commandsToRegister.length > 0 || pluginCatalog.commands.length > 0) {
         if (typeof bot.command !== "function") {
             logVerbose("telegram: bot.command unavailable; skipping native handlers");
         }
         else {
             for (const command of nativeCommands) {
-                bot.command(command.name, async (ctx) => {
+                const normalizedCommandName = normalizeTelegramCommandName(command.name);
+                bot.command(normalizedCommandName, async (ctx) => {
                     const msg = ctx.message;
                     if (!msg) {
                         return;
@@ -244,6 +253,7 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                         msg,
                         bot,
                         cfg,
+                        accountId,
                         telegramCfg,
                         allowFrom,
                         groupAllowFrom,
@@ -256,8 +266,20 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                         return;
                     }
                     const { chatId, isGroup, isForum, resolvedThreadId, senderId, senderUsername, groupConfig, topicConfig, commandAuthorized, } = auth;
-                    const messageThreadId = msg.message_thread_id;
-                    const threadParams = buildTelegramThreadParams(resolvedThreadId) ?? {};
+                    const { threadSpec, route, mediaLocalRoots, tableMode, chunkMode } = resolveCommandRuntimeContext({
+                        msg,
+                        isGroup,
+                        isForum,
+                        resolvedThreadId,
+                    });
+                    const deliveryBaseOptions = buildCommandDeliveryBaseOptions({
+                        chatId,
+                        mediaLocalRoots,
+                        threadSpec,
+                        tableMode,
+                        chunkMode,
+                    });
+                    const threadParams = buildTelegramThreadParams(threadSpec) ?? {};
                     const commandDefinition = findCommandByNativeName(command.name, "telegram");
                     const rawText = ctx.match?.trim() ?? "";
                     const commandArgs = commandDefinition
@@ -304,18 +326,9 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                         });
                         return;
                     }
-                    const route = resolveAgentRoute({
-                        cfg,
-                        channel: "telegram",
-                        accountId,
-                        peer: {
-                            kind: isGroup ? "group" : "dm",
-                            id: isGroup ? buildTelegramGroupPeerId(chatId, resolvedThreadId) : String(chatId),
-                        },
-                    });
                     const baseSessionKey = route.sessionKey;
                     // DMs: use raw messageThreadId for thread sessions (not resolvedThreadId which is for forums)
-                    const dmThreadId = !isGroup ? messageThreadId : undefined;
+                    const dmThreadId = threadSpec.scope === "dm" ? threadSpec.id : undefined;
                     const threadKeys = dmThreadId != null
                         ? resolveThreadSessionKeys({
                             baseSessionKey,
@@ -323,11 +336,6 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                         })
                         : null;
                     const sessionKey = threadKeys?.sessionKey ?? baseSessionKey;
-                    const tableMode = resolveMarkdownTableMode({
-                        cfg,
-                        channel: "telegram",
-                        accountId: route.accountId,
-                    });
                     const skillFilter = firstDefined(topicConfig?.skills, groupConfig?.skills);
                     const systemPromptParts = [
                         groupConfig?.systemPrompt?.trim() || null,
@@ -363,7 +371,7 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                         SessionKey: `telegram:slash:${senderId || chatId}`,
                         AccountId: route.accountId,
                         CommandTargetSessionKey: sessionKey,
-                        MessageThreadId: resolvedThreadId,
+                        MessageThreadId: threadSpec.id,
                         IsForum: isForum,
                         // Originating context for sub-agent announce routing
                         OriginatingChannel: "telegram",
@@ -372,10 +380,15 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                     const disableBlockStreaming = typeof telegramCfg.blockStreaming === "boolean"
                         ? !telegramCfg.blockStreaming
                         : undefined;
-                    const chunkMode = resolveChunkMode(cfg, "telegram", route.accountId);
-                    const { onModelSelected, ...prefixOptions } = createReplyPrefixContext({
+                    const deliveryState = {
+                        delivered: false,
+                        skippedNonSilent: 0,
+                    };
+                    const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
                         cfg,
                         agentId: route.agentId,
+                        channel: "telegram",
+                        accountId: route.accountId,
                     });
                     await dispatchReplyWithBufferedBlockDispatcher({
                         ctx: ctxPayload,
@@ -383,19 +396,18 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                         dispatcherOptions: {
                             ...prefixOptions,
                             deliver: async (payload, _info) => {
-                                await deliverReplies({
+                                const result = await deliverReplies({
                                     replies: [payload],
-                                    chatId: String(chatId),
-                                    token: opts.token,
-                                    runtime,
-                                    bot,
-                                    replyToMode,
-                                    textLimit,
-                                    messageThreadId: resolvedThreadId,
-                                    tableMode,
-                                    chunkMode,
-                                    linkPreview: telegramCfg.linkPreview,
+                                    ...deliveryBaseOptions,
                                 });
+                                if (result.delivered) {
+                                    deliveryState.delivered = true;
+                                }
+                            },
+                            onSkip: (_payload, info) => {
+                                if (info.reason !== "silent") {
+                                    deliveryState.skippedNonSilent += 1;
+                                }
                             },
                             onError: (err, info) => {
                                 runtime.error?.(danger(`telegram slash ${info.kind} reply failed: ${String(err)}`));
@@ -407,15 +419,23 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                             onModelSelected,
                         },
                     });
+                    if (!deliveryState.delivered && deliveryState.skippedNonSilent > 0) {
+                        await deliverReplies({
+                            replies: [{ text: EMPTY_RESPONSE_FALLBACK }],
+                            ...deliveryBaseOptions,
+                        });
+                    }
                 });
             }
-            for (const pluginCommand of pluginCommands) {
+            for (const pluginCommand of pluginCatalog.commands) {
                 bot.command(pluginCommand.command, async (ctx) => {
                     const msg = ctx.message;
-                    if (!msg)
+                    if (!msg) {
                         return;
-                    if (shouldSkipUpdate(ctx))
+                    }
+                    if (shouldSkipUpdate(ctx)) {
                         return;
+                    }
                     const chatId = msg.chat.id;
                     const rawText = ctx.match?.trim() ?? "";
                     const commandBody = `/${pluginCommand.command}${rawText ? ` ${rawText}` : ""}`;
@@ -432,6 +452,7 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                         msg,
                         bot,
                         cfg,
+                        accountId,
                         telegramCfg,
                         allowFrom,
                         groupAllowFrom,
@@ -440,11 +461,25 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                         resolveTelegramGroupConfig,
                         requireAuth: match.command.requireAuth !== false,
                     });
-                    if (!auth)
+                    if (!auth) {
                         return;
-                    const { resolvedThreadId, senderId, commandAuthorized, isGroup } = auth;
+                    }
+                    const { senderId, commandAuthorized, isGroup, isForum, resolvedThreadId } = auth;
+                    const { threadSpec, mediaLocalRoots, tableMode, chunkMode } = resolveCommandRuntimeContext({
+                        msg,
+                        isGroup,
+                        isForum,
+                        resolvedThreadId,
+                    });
+                    const deliveryBaseOptions = buildCommandDeliveryBaseOptions({
+                        chatId,
+                        mediaLocalRoots,
+                        threadSpec,
+                        tableMode,
+                        chunkMode,
+                    });
                     const from = isGroup
-                        ? buildTelegramGroupFrom(chatId, resolvedThreadId)
+                        ? buildTelegramGroupFrom(chatId, threadSpec.id)
                         : `telegram:${chatId}`;
                     const to = `telegram:${chatId}`;
                     const result = await executePluginCommand({
@@ -458,33 +493,18 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                         from,
                         to,
                         accountId,
-                        messageThreadId: resolvedThreadId,
+                        messageThreadId: threadSpec.id,
                     });
-                    const tableMode = resolveMarkdownTableMode({
-                        cfg,
-                        channel: "telegram",
-                        accountId,
-                    });
-                    const chunkMode = resolveChunkMode(cfg, "telegram", accountId);
                     await deliverReplies({
                         replies: [result],
-                        chatId: String(chatId),
-                        token: opts.token,
-                        runtime,
-                        bot,
-                        replyToMode,
-                        textLimit,
-                        messageThreadId: resolvedThreadId,
-                        tableMode,
-                        chunkMode,
-                        linkPreview: telegramCfg.linkPreview,
+                        ...deliveryBaseOptions,
                     });
                 });
             }
         }
     }
     else if (nativeDisabledExplicit) {
-        void withTelegramApiErrorLogging({
+        withTelegramApiErrorLogging({
             operation: "setMyCommands",
             runtime,
             fn: () => bot.api.setMyCommands([]),