@poolzin/pool-bot 2026.1.39 → 2026.2.1

package/dist/slack/monitor/media.js

@@ -1,14 +1,77 @@
 import { fetchRemoteMedia } from "../../media/fetch.js";
 import { saveMediaBuffer } from "../../media/store.js";
+function normalizeHostname(hostname) {
+    const normalized = hostname.trim().toLowerCase().replace(/\.$/, "");
+    if (normalized.startsWith("[") && normalized.endsWith("]")) {
+        return normalized.slice(1, -1);
+    }
+    return normalized;
+}
+function isSlackHostname(hostname) {
+    const normalized = normalizeHostname(hostname);
+    if (!normalized) {
+        return false;
+    }
+    // Slack-hosted files typically come from *.slack.com and redirect to Slack CDN domains.
+    // Include a small allowlist of known Slack domains to avoid leaking tokens if a file URL
+    // is ever spoofed or mishandled.
+    const allowedSuffixes = ["slack.com", "slack-edge.com", "slack-files.com"];
+    return allowedSuffixes.some((suffix) => normalized === suffix || normalized.endsWith(`.${suffix}`));
+}
+function assertSlackFileUrl(rawUrl) {
+    let parsed;
+    try {
+        parsed = new URL(rawUrl);
+    }
+    catch {
+        throw new Error(`Invalid Slack file URL: ${rawUrl}`);
+    }
+    if (parsed.protocol !== "https:") {
+        throw new Error(`Refusing Slack file URL with non-HTTPS protocol: ${parsed.protocol}`);
+    }
+    if (!isSlackHostname(parsed.hostname)) {
+        throw new Error(`Refusing to send Slack token to non-Slack host "${parsed.hostname}" (url: ${rawUrl})`);
+    }
+    return parsed;
+}
+function resolveRequestUrl(input) {
+    if (typeof input === "string") {
+        return input;
+    }
+    if (input instanceof URL) {
+        return input.toString();
+    }
+    if ("url" in input && typeof input.url === "string") {
+        return input.url;
+    }
+    throw new Error("Unsupported fetch input: expected string, URL, or Request");
+}
+function createSlackMediaFetch(token) {
+    let includeAuth = true;
+    return async (input, init) => {
+        const url = resolveRequestUrl(input);
+        const { headers: initHeaders, redirect: _redirect, ...rest } = init ?? {};
+        const headers = new Headers(initHeaders);
+        if (includeAuth) {
+            includeAuth = false;
+            const parsed = assertSlackFileUrl(url);
+            headers.set("Authorization", `Bearer ${token}`);
+            return fetch(parsed.href, { ...rest, headers, redirect: "manual" });
+        }
+        headers.delete("Authorization");
+        return fetch(url, { ...rest, headers, redirect: "manual" });
+    };
+}
 /**
  * Fetches a URL with Authorization header, handling cross-origin redirects.
  * Node.js fetch strips Authorization headers on cross-origin redirects for security.
- * Slack's files.slack.com URLs redirect to CDN domains with pre-signed URLs that
- * don't need the Authorization header, so we handle the initial auth request manually.
+ * Slack's file URLs redirect to CDN domains with pre-signed URLs that don't need the
+ * Authorization header, so we handle the initial auth request manually.
  */
 export async function fetchWithSlackAuth(url, token) {
+    const parsed = assertSlackFileUrl(url);
     // Initial request with auth and manual redirect handling
-    const initialRes = await fetch(url, {
+    const initialRes = await fetch(parsed.href, {
         headers: { Authorization: `Bearer ${token}` },
         redirect: "manual",
     });
@@ -22,31 +85,36 @@ export async function fetchWithSlackAuth(url, token) {
         return initialRes;
     }
     // Resolve relative URLs against the original
-    const resolvedUrl = new URL(redirectUrl, url).toString();
+    const resolvedUrl = new URL(redirectUrl, parsed.href);
+    // Only follow safe protocols (we do NOT include Authorization on redirects).
+    if (resolvedUrl.protocol !== "https:") {
+        return initialRes;
+    }
     // Follow the redirect without the Authorization header
     // (Slack's CDN URLs are pre-signed and don't need it)
-    return fetch(resolvedUrl, { redirect: "follow" });
+    return fetch(resolvedUrl.toString(), { redirect: "follow" });
 }
 export async function resolveSlackMedia(params) {
     const files = params.files ?? [];
     for (const file of files) {
         const url = file.url_private_download ?? file.url_private;
-        if (!url)
+        if (!url) {
             continue;
+        }
         try {
-            // Note: We ignore init options because fetchWithSlackAuth handles
-            // redirect behavior specially. fetchRemoteMedia only passes the URL.
-            const fetchImpl = (input) => {
-                const inputUrl = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
-                return fetchWithSlackAuth(inputUrl, params.token);
-            };
+            // Note: fetchRemoteMedia calls fetchImpl(url) with the URL string today and
+            // handles size limits internally. Provide a fetcher that uses auth once, then lets
+            // the redirect chain continue without credentials.
+            const fetchImpl = createSlackMediaFetch(params.token);
             const fetched = await fetchRemoteMedia({
                 url,
                 fetchImpl,
                 filePathHint: file.name,
+                maxBytes: params.maxBytes,
             });
-            if (fetched.buffer.byteLength > params.maxBytes)
+            if (fetched.buffer.byteLength > params.maxBytes) {
                 continue;
+            }
             const saved = await saveMediaBuffer(fetched.buffer, fetched.contentType ?? file.mimetype, "inbound", params.maxBytes);
             const label = fetched.fileName ?? file.name;
             return {
@@ -65,8 +133,9 @@ const THREAD_STARTER_CACHE = new Map();
 export async function resolveSlackThreadStarter(params) {
     const cacheKey = `${params.channelId}:${params.threadTs}`;
     const cached = THREAD_STARTER_CACHE.get(cacheKey);
-    if (cached)
+    if (cached) {
         return cached;
+    }
     try {
         const response = (await params.client.conversations.replies({
             channel: params.channelId,
@@ -76,8 +145,9 @@ export async function resolveSlackThreadStarter(params) {
         }));
         const message = response?.messages?.[0];
         const text = (message?.text ?? "").trim();
-        if (!message || !text)
+        if (!message || !text) {
             return null;
+        }
         const starter = {
             text,
             userId: message.user,

package/dist/tailscale/detect.js

@@ -0,0 +1,145 @@
+import { execSync } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+/**
+ * Check if Tailscale is installed by looking for the binary.
+ */
+async function isTailscaleInstalled() {
+    try {
+        const platform = os.platform();
+        const possiblePaths = [];
+        if (platform === "linux") {
+            possiblePaths.push("/usr/bin/tailscale", "/usr/local/bin/tailscale");
+        }
+        else if (platform === "darwin") {
+            possiblePaths.push("/Applications/Tailscale.app/Contents/MacOS/Tailscale", "/usr/local/bin/tailscale");
+        }
+        else if (platform === "win32") {
+            possiblePaths.push("C:\\Program Files\\Tailscale\\tailscale.exe", "C:\\ProgramData\\chocolatey\\lib\\tailscale\\tools\\tailscale.exe");
+        }
+        for (const binPath of possiblePaths) {
+            try {
+                await fs.access(binPath);
+                return true;
+            }
+            catch {
+                continue;
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Run tailscale status command and parse output.
+ */
+async function getTailscaleStatus() {
+    try {
+        const platform = os.platform();
+        const binPath = platform === "win32"
+            ? "tailscale.exe"
+            : platform === "darwin"
+                ? "/Applications/Tailscale.app/Contents/MacOS/Tailscale"
+                : "tailscale";
+        const timeout = 5000;
+        const result = execSync(`"${binPath}" status --json`, {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout,
+        });
+        const status = JSON.parse(result.trim());
+        // Extract useful info from Tailscale status JSON
+        const self = status.Self || {};
+        const backendState = status.BackendState || "";
+        return {
+            installed: true,
+            running: backendState === "Running",
+            ip: self.TailscaleIPs?.[0],
+            dnsName: self.DNSName,
+            hostname: self.HostName,
+            tailnet: status.MagicsockName || status.TailnetName,
+            online: self.Online ?? false,
+            canServe: true, // If running, can serve
+            canFunnel: self.Capabilities?.map.includes("funnel") ?? false,
+        };
+    }
+    catch {
+        return {
+            installed: await isTailscaleInstalled(),
+            running: false,
+            canServe: false,
+            canFunnel: false,
+            online: false,
+        };
+    }
+}
+/**
+ * Auto-detect Tailscale configuration and recommend settings.
+ *
+ * This is a SAFE detection function - it only reads status and never
+ * modifies configuration. Recommendations are purely advisory.
+ *
+ * @returns Tailscale auto-detection result
+ */
+export async function detectTailscaleConfig() {
+    const info = {
+        installed: await isTailscaleInstalled(),
+        running: false,
+        canServe: false,
+        canFunnel: false,
+        online: false,
+    };
+    if (!info.installed) {
+        return { detected: false };
+    }
+    // Get detailed status if installed
+    const status = await getTailscaleStatus();
+    Object.assign(info, status);
+    // Generate recommendations based on detected state
+    const recommended = info.online
+        ? {
+            mode: info.canFunnel ? "funnel" : "serve",
+            bind: "tailnet",
+            port: 18789,
+            reason: info.canFunnel
+                ? "Tailscale is online and supports funnel (public access)"
+                : "Tailscale is online - use serve for private tailnet access",
+        }
+        : info.running
+            ? {
+                mode: "off",
+                bind: "loopback",
+                port: 18789,
+                reason: "Tailscale is installed but offline - use loopback bind",
+            }
+            : undefined;
+    return {
+        detected: true,
+        info,
+        recommended,
+    };
+}
+/**
+ * Get a human-readable summary of Tailscale detection.
+ */
+export function formatTailscaleDetection(result) {
+    if (!result.detected || !result.info) {
+        return "Tailscale: Not installed";
+    }
+    const { info, recommended } = result;
+    const parts = [];
+    parts.push(`Tailscale: ${info.installed ? "Installed" : "Not installed"}`);
+    parts.push(`Status: ${info.running ? (info.online ? "Online" : "Offline") : "Not running"}`);
+    if (info.online && info.ip) {
+        parts.push(`IP: ${info.ip}`);
+    }
+    if (info.dnsName) {
+        parts.push(`DNS: ${info.dnsName}`);
+    }
+    if (recommended) {
+        parts.push(`\nRecommendation: ${recommended.mode} (${recommended.reason})`);
+    }
+    return parts.join(" | ");
+}

package/dist/telegram/bot/helpers.js

@@ -1,22 +1,67 @@
 import { formatLocationText } from "../../channels/location.js";
 const TELEGRAM_GENERAL_TOPIC_ID = 1;
+/**
+ * Resolve the thread ID for Telegram forum topics.
+ * For non-forum groups, returns undefined even if messageThreadId is present
+ * (reply threads in regular groups should not create separate sessions).
+ * For forum groups, returns the topic ID (or General topic ID=1 if unspecified).
+ */
 export function resolveTelegramForumThreadId(params) {
-    if (params.isForum && params.messageThreadId == null) {
+    // Non-forum groups: ignore message_thread_id (reply threads are not real topics)
+    if (!params.isForum) {
+        return undefined;
+    }
+    // Forum groups: use the topic ID, defaulting to General topic
+    if (params.messageThreadId == null) {
         return TELEGRAM_GENERAL_TOPIC_ID;
     }
-    return params.messageThreadId ?? undefined;
+    return params.messageThreadId;
+}
+export function resolveTelegramThreadSpec(params) {
+    if (params.isGroup) {
+        const id = resolveTelegramForumThreadId({
+            isForum: params.isForum,
+            messageThreadId: params.messageThreadId,
+        });
+        return {
+            id,
+            scope: params.isForum ? "forum" : "none",
+        };
+    }
+    if (params.messageThreadId == null) {
+        return { scope: "dm" };
+    }
+    return {
+        id: params.messageThreadId,
+        scope: "dm",
+    };
 }
 /**
  * Build thread params for Telegram API calls (messages, media).
  * General forum topic (id=1) must be treated like a regular supergroup send:
  * Telegram rejects sendMessage/sendMedia with message_thread_id=1 ("thread not found").
+ *
+ * Accepts either a TelegramThreadSpec (preferred) or a raw messageThreadId number
+ * for backward compatibility with callers that haven't migrated yet.
  */
-export function buildTelegramThreadParams(messageThreadId) {
-    if (messageThreadId == null) {
+export function buildTelegramThreadParams(threadOrId) {
+    if (threadOrId == null) {
+        return undefined;
+    }
+    // Legacy call: raw number
+    if (typeof threadOrId === "number") {
+        const normalized = Math.trunc(threadOrId);
+        if (normalized === TELEGRAM_GENERAL_TOPIC_ID) {
+            return undefined;
+        }
+        return { message_thread_id: normalized };
+    }
+    // New call: TelegramThreadSpec
+    if (!threadOrId.id) {
         return undefined;
     }
-    const normalized = Math.trunc(messageThreadId);
-    if (normalized === TELEGRAM_GENERAL_TOPIC_ID) {
+    const normalized = Math.trunc(threadOrId.id);
+    if (normalized === TELEGRAM_GENERAL_TOPIC_ID && threadOrId.scope === "forum") {
         return undefined;
     }
     return { message_thread_id: normalized };
@@ -43,6 +88,19 @@ export function buildTelegramGroupPeerId(chatId, messageThreadId) {
 export function buildTelegramGroupFrom(chatId, messageThreadId) {
     return `telegram:group:${buildTelegramGroupPeerId(chatId, messageThreadId)}`;
 }
+/**
+ * Build parentPeer for forum topic binding inheritance.
+ * When a message comes from a forum topic, the peer ID includes the topic suffix
+ * (e.g., `-1001234567890:topic:99`). To allow bindings configured for the base
+ * group ID to match, we provide the parent group as `parentPeer` so the routing
+ * layer can fall back to it when the exact peer doesn't match.
+ */
+export function buildTelegramParentPeer(params) {
+    if (!params.isGroup || params.resolvedThreadId == null) {
+        return undefined;
+    }
+    return { kind: "group", id: String(params.chatId) };
+}
 export function buildSenderName(msg) {
     const name = [msg.from?.first_name, msg.from?.last_name].filter(Boolean).join(" ").trim() ||
         msg.from?.username;
@@ -93,7 +151,7 @@ export function expandTextLinks(text, entities) {
         return text;
     const textLinks = entities
         .filter((entity) => entity.type === "text_link" && Boolean(entity.url))
-        .sort((a, b) => b.offset - a.offset);
+        .toSorted((a, b) => b.offset - a.offset);
     if (textLinks.length === 0)
         return text;
     let result = text;
@@ -115,33 +173,53 @@ export function resolveTelegramReplyId(raw) {
 }
 export function describeReplyTarget(msg) {
     const reply = msg.reply_to_message;
-    if (!reply)
-        return null;
-    const replyBody = (reply.text ?? reply.caption ?? "").trim();
-    let body = replyBody;
-    if (!body) {
-        if (reply.photo)
-            body = "<media:image>";
-        else if (reply.video)
-            body = "<media:video>";
-        else if (reply.audio || reply.voice)
-            body = "<media:audio>";
-        else if (reply.document)
-            body = "<media:document>";
-        else {
-            const locationData = extractTelegramLocation(reply);
-            if (locationData)
-                body = formatLocationText(locationData);
+    const externalReply = msg
+        .external_reply;
+    const quoteText = msg.quote?.text ??
+        externalReply?.quote?.text;
+    let body = "";
+    let kind = "reply";
+    if (typeof quoteText === "string") {
+        body = quoteText.trim();
+        if (body) {
+            kind = "quote";
         }
     }
-    if (!body)
+    const replyLike = reply ?? externalReply;
+    if (!body && replyLike) {
+        const replyBody = (replyLike.text ?? replyLike.caption ?? "").trim();
+        body = replyBody;
+        if (!body) {
+            if (replyLike.photo) {
+                body = "<media:image>";
+            }
+            else if (replyLike.video) {
+                body = "<media:video>";
+            }
+            else if (replyLike.audio || replyLike.voice) {
+                body = "<media:audio>";
+            }
+            else if (replyLike.document) {
+                body = "<media:document>";
+            }
+            else {
+                const locationData = extractTelegramLocation(replyLike);
+                if (locationData) {
+                    body = formatLocationText(locationData);
+                }
+            }
+        }
+    }
+    if (!body) {
         return null;
-    const sender = buildSenderName(reply);
-    const senderLabel = sender ? `${sender}` : "unknown sender";
+    }
+    const sender = replyLike ? buildSenderName(replyLike) : undefined;
+    const senderLabel = sender ?? "unknown sender";
     return {
-        id: reply.message_id ? String(reply.message_id) : undefined,
+        id: replyLike?.message_id ? String(replyLike.message_id) : undefined,
         sender: senderLabel,
         body,
+        kind,
     };
 }
 function normalizeForwardedUserLabel(user) {
@@ -191,6 +269,7 @@ function buildForwardedContextFromChat(params) {
         return null;
     const signature = params.signature?.trim() || undefined;
     const from = signature ? `${display} (${signature})` : display;
+    const chatType = (params.chat.type?.trim() || undefined);
     return {
         from,
         date: params.date,
@@ -199,6 +278,8 @@ function buildForwardedContextFromChat(params) {
         fromUsername: username,
         fromTitle: title,
         fromSignature: signature,
+        fromChatType: chatType,
+        fromMessageId: params.messageId,
     };
 }
 function resolveForwardOrigin(origin, signature) {

package/dist/telegram/bot-handlers.js

@@ -2,21 +2,27 @@
 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 { loadConfig } from "../config/config.js";
+import { loadSessionStore, resolveStorePath } from "../config/sessions.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 { resolveTelegramForumThreadId } from "./bot/helpers.js";
+import { buildTelegramGroupPeerId, buildTelegramParentPeer, resolveTelegramForumThreadId, } from "./bot/helpers.js";
 import { firstDefined, isSenderAllowed, normalizeAllowFromWithStore } from "./bot-access.js";
 import { MEDIA_GROUP_TIMEOUT_MS } from "./bot-updates.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";
 export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, mediaMaxBytes, telegramCfg, groupAllowFrom, resolveGroupPolicy, resolveTelegramGroupConfig, shouldSkipUpdate, processMessage, logger, }) => {
     const TELEGRAM_TEXT_FRAGMENT_START_THRESHOLD_CHARS = 4000;
@@ -72,6 +78,57 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
             runtime.error?.(danger(`telegram debounce flush failed: ${String(err)}`));
         },
     });
+    const resolveTelegramSessionModel = (params) => {
+        const resolvedThreadId = params.resolvedThreadId ??
+            resolveTelegramForumThreadId({
+                isForum: params.isForum,
+                messageThreadId: params.messageThreadId,
+            });
+        const peerId = params.isGroup
+            ? buildTelegramGroupPeerId(params.chatId, resolvedThreadId)
+            : String(params.chatId);
+        const parentPeer = buildTelegramParentPeer({
+            isGroup: params.isGroup,
+            resolvedThreadId,
+            chatId: params.chatId,
+        });
+        const route = resolveAgentRoute({
+            cfg,
+            channel: "telegram",
+            accountId,
+            peer: {
+                kind: params.isGroup ? "group" : "dm",
+                id: peerId,
+            },
+            parentPeer,
+        });
+        const baseSessionKey = route.sessionKey;
+        const dmThreadId = !params.isGroup ? params.messageThreadId : undefined;
+        const threadKeys = dmThreadId != null
+            ? resolveThreadSessionKeys({ baseSessionKey, threadId: String(dmThreadId) })
+            : null;
+        const sessionKey = threadKeys?.sessionKey ?? baseSessionKey;
+        const storePath = resolveStorePath(cfg.session?.store, { agentId: route.agentId });
+        const store = loadSessionStore(storePath);
+        const entry = store[sessionKey];
+        const storedOverride = resolveStoredModelOverride({
+            sessionEntry: entry,
+            sessionStore: store,
+            sessionKey,
+        });
+        if (storedOverride) {
+            return storedOverride.provider
+                ? `${storedOverride.provider}/${storedOverride.model}`
+                : storedOverride.model;
+        }
+        const provider = entry?.modelProvider?.trim();
+        const model = entry?.model?.trim();
+        if (provider && model) {
+            return `${provider}/${model}`;
+        }
+        const modelCfg = cfg.agents?.defaults?.model;
+        return typeof modelCfg === "string" ? modelCfg : modelCfg?.primary;
+    };
     const processMediaGroup = async (entry) => {
         try {
             entry.messages.sort((a, b) => a.msg.message_id - b.msg.message_id);
@@ -205,7 +262,7 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
                     }
                 }
                 const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
-                const groupPolicy = telegramCfg.groupPolicy ?? defaultGroupPolicy ?? "open";
+                const groupPolicy = firstDefined(topicConfig?.groupPolicy, groupConfig?.groupPolicy, telegramCfg.groupPolicy, defaultGroupPolicy, "open");
                 if (groupPolicy === "disabled") {
                     logVerbose(`Blocked telegram group message (groupPolicy: disabled)`);
                     return;
@@ -293,6 +350,90 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
                 }
                 return;
             }
+            // Model selection callback handler (mdl_prov, mdl_list_*, mdl_sel_*, mdl_back)
+            const modelCallback = parseModelCallbackData(data);
+            if (modelCallback) {
+                const modelData = await buildModelsProviderData(cfg);
+                const { byProvider, providers } = modelData;
+                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);
+                    }
+                    catch (editErr) {
+                        const errStr = String(editErr);
+                        if (!errStr.includes("message is not modified")) {
+                            throw editErr;
+                        }
+                    }
+                };
+                if (modelCallback.type === "providers" || modelCallback.type === "back") {
+                    if (providers.length === 0) {
+                        await editMessageWithButtons("No providers available.", []);
+                        return;
+                    }
+                    const providerInfos = providers.map((p) => ({
+                        id: p,
+                        count: byProvider.get(p)?.size ?? 0,
+                    }));
+                    const buttons = buildProviderKeyboard(providerInfos);
+                    await editMessageWithButtons("Select a provider:", buttons);
+                    return;
+                }
+                if (modelCallback.type === "list") {
+                    const { provider, page } = modelCallback;
+                    const modelSet = byProvider.get(provider);
+                    if (!modelSet || modelSet.size === 0) {
+                        const providerInfos = providers.map((p) => ({
+                            id: p,
+                            count: byProvider.get(p)?.size ?? 0,
+                        }));
+                        const buttons = buildProviderKeyboard(providerInfos);
+                        await editMessageWithButtons(`Unknown provider: ${provider}\n\nSelect a provider:`, buttons);
+                        return;
+                    }
+                    const models = [...modelSet].toSorted();
+                    const pageSize = getModelsPageSize();
+                    const totalPages = calculateTotalPages(models.length, pageSize);
+                    const safePage = Math.max(1, Math.min(page, totalPages));
+                    const currentModel = resolveTelegramSessionModel({
+                        chatId,
+                        isGroup,
+                        isForum,
+                        messageThreadId,
+                        resolvedThreadId,
+                    });
+                    const buttons = buildModelsKeyboard({
+                        provider,
+                        models,
+                        currentModel,
+                        currentPage: safePage,
+                        totalPages,
+                        pageSize,
+                    });
+                    const text = `Models (${provider}) — ${models.length} available`;
+                    await editMessageWithButtons(text, buttons);
+                    return;
+                }
+                if (modelCallback.type === "select") {
+                    const { provider, model } = modelCallback;
+                    const syntheticMessage = {
+                        ...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, {
+                        forceWasMentioned: true,
+                        messageIdOverride: callback.id,
+                    });
+                    return;
+                }
+                return;
+            }
             const syntheticMessage = {
                 ...callbackMessage,
                 from: callback.from,
@@ -403,7 +544,7 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
                 // - "disabled": block all group messages entirely
                 // - "allowlist": only allow group messages from senders in groupAllowFrom/allowFrom
                 const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
-                const groupPolicy = telegramCfg.groupPolicy ?? defaultGroupPolicy ?? "open";
+                const groupPolicy = firstDefined(topicConfig?.groupPolicy, groupConfig?.groupPolicy, telegramCfg.groupPolicy, defaultGroupPolicy, "open");
                 if (groupPolicy === "disabled") {
                     logVerbose(`Blocked telegram group message (groupPolicy: disabled)`);
                     return;