@poolzin/pool-bot 2026.2.0 → 2026.2.1

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

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

package/dist/telegram/bot.js

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

package/dist/telegram/model-buttons.js

@@ -0,0 +1,163 @@
+/**
+ * Telegram inline button utilities for model selection.
+ *
+ * Callback data patterns (max 64 bytes for Telegram):
+ * - mdl_prov              - show providers list
+ * - mdl_list_{prov}_{pg}  - show models for provider (page N, 1-indexed)
+ * - mdl_sel_{provider/id} - select model
+ * - mdl_back              - back to providers list
+ */
+const MODELS_PAGE_SIZE = 8;
+const MAX_CALLBACK_DATA_BYTES = 64;
+/**
+ * Parse a model callback_data string into a structured object.
+ * Returns null if the data doesn't match a known pattern.
+ */
+export function parseModelCallbackData(data) {
+    const trimmed = data.trim();
+    if (!trimmed.startsWith("mdl_")) {
+        return null;
+    }
+    if (trimmed === "mdl_prov" || trimmed === "mdl_back") {
+        return { type: trimmed === "mdl_prov" ? "providers" : "back" };
+    }
+    // mdl_list_{provider}_{page}
+    const listMatch = trimmed.match(/^mdl_list_([a-z0-9_-]+)_(\d+)$/i);
+    if (listMatch) {
+        const [, provider, pageStr] = listMatch;
+        const page = Number.parseInt(pageStr ?? "1", 10);
+        if (provider && Number.isFinite(page) && page >= 1) {
+            return { type: "list", provider, page };
+        }
+    }
+    // mdl_sel_{provider/model}
+    const selMatch = trimmed.match(/^mdl_sel_(.+)$/);
+    if (selMatch) {
+        const modelRef = selMatch[1];
+        if (modelRef) {
+            const slashIndex = modelRef.indexOf("/");
+            if (slashIndex > 0 && slashIndex < modelRef.length - 1) {
+                return {
+                    type: "select",
+                    provider: modelRef.slice(0, slashIndex),
+                    model: modelRef.slice(slashIndex + 1),
+                };
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Build provider selection keyboard with 2 providers per row.
+ */
+export function buildProviderKeyboard(providers) {
+    if (providers.length === 0) {
+        return [];
+    }
+    const rows = [];
+    let currentRow = [];
+    for (const provider of providers) {
+        const button = {
+            text: `${provider.id} (${provider.count})`,
+            callback_data: `mdl_list_${provider.id}_1`,
+        };
+        currentRow.push(button);
+        if (currentRow.length === 2) {
+            rows.push(currentRow);
+            currentRow = [];
+        }
+    }
+    // Push any remaining button
+    if (currentRow.length > 0) {
+        rows.push(currentRow);
+    }
+    return rows;
+}
+/**
+ * Build model list keyboard with pagination and back button.
+ */
+export function buildModelsKeyboard(params) {
+    const { provider, models, currentModel, currentPage, totalPages } = params;
+    const pageSize = params.pageSize ?? MODELS_PAGE_SIZE;
+    if (models.length === 0) {
+        return [[{ text: "<< Back", callback_data: "mdl_back" }]];
+    }
+    const rows = [];
+    // Calculate page slice
+    const startIndex = (currentPage - 1) * pageSize;
+    const endIndex = Math.min(startIndex + pageSize, models.length);
+    const pageModels = models.slice(startIndex, endIndex);
+    // Model buttons - one per row
+    const currentModelId = currentModel?.includes("/")
+        ? currentModel.split("/").slice(1).join("/")
+        : currentModel;
+    for (const model of pageModels) {
+        const callbackData = `mdl_sel_${provider}/${model}`;
+        // Skip models that would exceed Telegram's callback_data limit
+        if (Buffer.byteLength(callbackData, "utf8") > MAX_CALLBACK_DATA_BYTES) {
+            continue;
+        }
+        const isCurrentModel = model === currentModelId;
+        const displayText = truncateModelId(model, 38);
+        const text = isCurrentModel ? `${displayText} ✓` : displayText;
+        rows.push([
+            {
+                text,
+                callback_data: callbackData,
+            },
+        ]);
+    }
+    // Pagination row
+    if (totalPages > 1) {
+        const paginationRow = [];
+        if (currentPage > 1) {
+            paginationRow.push({
+                text: "◀ Prev",
+                callback_data: `mdl_list_${provider}_${currentPage - 1}`,
+            });
+        }
+        paginationRow.push({
+            text: `${currentPage}/${totalPages}`,
+            callback_data: `mdl_list_${provider}_${currentPage}`, // noop
+        });
+        if (currentPage < totalPages) {
+            paginationRow.push({
+                text: "Next ▶",
+                callback_data: `mdl_list_${provider}_${currentPage + 1}`,
+            });
+        }
+        rows.push(paginationRow);
+    }
+    // Back button
+    rows.push([{ text: "<< Back", callback_data: "mdl_back" }]);
+    return rows;
+}
+/**
+ * Build "Browse providers" button for /model summary.
+ */
+export function buildBrowseProvidersButton() {
+    return [[{ text: "Browse providers", callback_data: "mdl_prov" }]];
+}
+/**
+ * Truncate model ID for display, preserving end if too long.
+ */
+function truncateModelId(modelId, maxLen) {
+    if (modelId.length <= maxLen) {
+        return modelId;
+    }
+    // Show last part with ellipsis prefix
+    return `…${modelId.slice(-(maxLen - 1))}`;
+}
+/**
+ * Get page size for model list pagination.
+ */
+export function getModelsPageSize() {
+    return MODELS_PAGE_SIZE;
+}
+/**
+ * Calculate total pages for a model list.
+ */
+export function calculateTotalPages(totalModels, pageSize) {
+    const size = pageSize ?? MODELS_PAGE_SIZE;
+    return size > 0 ? Math.ceil(totalModels / size) : 1;
+}