@poolzin/pool-bot 2026.1.39 → 2026.2.1

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;
+}

package/dist/telegram/monitor.js

@@ -1,9 +1,10 @@
 import { run } from "@grammyjs/runner";
-import { loadConfig } from "../config/config.js";
 import { resolveAgentMaxConcurrent } from "../config/agent-limits.js";
+import { loadConfig } from "../config/config.js";
 import { computeBackoff, sleepWithAbort } from "../infra/backoff.js";
 import { formatErrorMessage } from "../infra/errors.js";
-import { formatDurationMs } from "../infra/format-duration.js";
+import { formatDurationPrecise } from "../infra/format-time/format-duration.js";
+import { registerUnhandledRejectionHandler } from "../infra/unhandled-rejections.js";
 import { resolveTelegramAccount } from "./accounts.js";
 import { resolveTelegramAllowedUpdates } from "./allowed-updates.js";
 import { createTelegramBot } from "./bot.js";
@@ -50,101 +51,125 @@ const isGetUpdatesConflict = (err) => {
         .toLowerCase();
     return haystack.includes("getupdates");
 };
-export async function monitorTelegramProvider(opts = {}) {
-    const cfg = opts.config ?? loadConfig();
-    const account = resolveTelegramAccount({
-        cfg,
-        accountId: opts.accountId,
-    });
-    const token = opts.token?.trim() || account.token;
-    if (!token) {
-        throw new Error(`Telegram bot token missing for account "${account.accountId}" (set channels.telegram.accounts.${account.accountId}.botToken/tokenFile or TELEGRAM_BOT_TOKEN for default).`);
+/** Check if error is a Grammy HttpError (used to scope unhandled rejection handling) */
+const isGrammyHttpError = (err) => {
+    if (!err || typeof err !== "object") {
+        return false;
     }
-    const proxyFetch = opts.proxyFetch ??
-        (account.config.proxy ? makeProxyFetch(account.config.proxy) : undefined);
-    let lastUpdateId = await readTelegramUpdateOffset({
-        accountId: account.accountId,
-    });
-    const persistUpdateId = async (updateId) => {
-        if (lastUpdateId !== null && updateId <= lastUpdateId)
-            return;
-        lastUpdateId = updateId;
-        try {
-            await writeTelegramUpdateOffset({
-                accountId: account.accountId,
-                updateId,
-            });
-        }
-        catch (err) {
-            (opts.runtime?.error ?? console.error)(`telegram: failed to persist update offset: ${String(err)}`);
+    return err.name === "HttpError";
+};
+export async function monitorTelegramProvider(opts = {}) {
+    const log = opts.runtime?.error ?? console.error;
+    // Register handler for Grammy HttpError unhandled rejections.
+    // This catches network errors that escape the polling loop's try-catch
+    // (e.g., from setMyCommands during bot setup).
+    // We gate on isGrammyHttpError to avoid suppressing non-Telegram errors.
+    const unregisterHandler = registerUnhandledRejectionHandler((err) => {
+        if (isGrammyHttpError(err) && isRecoverableTelegramNetworkError(err, { context: "polling" })) {
+            log(`[telegram] Suppressed network error: ${formatErrorMessage(err)}`);
+            return true; // handled - don't crash
         }
-    };
-    const bot = createTelegramBot({
-        token,
-        runtime: opts.runtime,
-        proxyFetch,
-        config: cfg,
-        accountId: account.accountId,
-        updateOffset: {
-            lastUpdateId,
-            onUpdateId: persistUpdateId,
-        },
+        return false;
     });
-    if (opts.useWebhook) {
-        await startTelegramWebhook({
-            token,
+    try {
+        const cfg = opts.config ?? loadConfig();
+        const account = resolveTelegramAccount({
+            cfg,
+            accountId: opts.accountId,
+        });
+        const token = opts.token?.trim() || account.token;
+        if (!token) {
+            throw new Error(`Telegram bot token missing for account "${account.accountId}" (set channels.telegram.accounts.${account.accountId}.botToken/tokenFile or TELEGRAM_BOT_TOKEN for default).`);
+        }
+        const proxyFetch = opts.proxyFetch ??
+            (account.config.proxy ? makeProxyFetch(account.config.proxy) : undefined);
+        let lastUpdateId = await readTelegramUpdateOffset({
             accountId: account.accountId,
-            config: cfg,
-            path: opts.webhookPath,
-            port: opts.webhookPort,
-            secret: opts.webhookSecret,
-            runtime: opts.runtime,
-            fetch: proxyFetch,
-            abortSignal: opts.abortSignal,
-            publicUrl: opts.webhookUrl,
         });
-        return;
-    }
-    // Use grammyjs/runner for concurrent update processing
-    let restartAttempts = 0;
-    while (!opts.abortSignal?.aborted) {
-        const runner = run(bot, createTelegramRunnerOptions(cfg));
-        const stopOnAbort = () => {
-            if (opts.abortSignal?.aborted) {
-                void runner.stop();
+        const persistUpdateId = async (updateId) => {
+            if (lastUpdateId !== null && updateId <= lastUpdateId)
+                return;
+            lastUpdateId = updateId;
+            try {
+                await writeTelegramUpdateOffset({
+                    accountId: account.accountId,
+                    updateId,
+                });
+            }
+            catch (err) {
+                (opts.runtime?.error ?? console.error)(`telegram: failed to persist update offset: ${String(err)}`);
             }
         };
-        opts.abortSignal?.addEventListener("abort", stopOnAbort, { once: true });
-        try {
-            // runner.task() returns a promise that resolves when the runner stops
-            await runner.task();
+        const bot = createTelegramBot({
+            token,
+            runtime: opts.runtime,
+            proxyFetch,
+            config: cfg,
+            accountId: account.accountId,
+            updateOffset: {
+                lastUpdateId,
+                onUpdateId: persistUpdateId,
+            },
+        });
+        if (opts.useWebhook) {
+            await startTelegramWebhook({
+                token,
+                accountId: account.accountId,
+                config: cfg,
+                path: opts.webhookPath,
+                port: opts.webhookPort,
+                secret: opts.webhookSecret,
+                runtime: opts.runtime,
+                fetch: proxyFetch,
+                abortSignal: opts.abortSignal,
+                publicUrl: opts.webhookUrl,
+            });
             return;
         }
-        catch (err) {
-            if (opts.abortSignal?.aborted) {
-                throw err;
-            }
-            const isConflict = isGetUpdatesConflict(err);
-            const isRecoverable = isRecoverableTelegramNetworkError(err, { context: "polling" });
-            if (!isConflict && !isRecoverable) {
-                throw err;
-            }
-            restartAttempts += 1;
-            const delayMs = computeBackoff(TELEGRAM_POLL_RESTART_POLICY, restartAttempts);
-            const reason = isConflict ? "getUpdates conflict" : "network error";
-            const errMsg = formatErrorMessage(err);
-            (opts.runtime?.error ?? console.error)(`Telegram ${reason}: ${errMsg}; retrying in ${formatDurationMs(delayMs)}.`);
+        // Use grammyjs/runner for concurrent update processing
+        let restartAttempts = 0;
+        while (!opts.abortSignal?.aborted) {
+            const runner = run(bot, createTelegramRunnerOptions(cfg));
+            const stopOnAbort = () => {
+                if (opts.abortSignal?.aborted) {
+                    void runner.stop();
+                }
+            };
+            opts.abortSignal?.addEventListener("abort", stopOnAbort, { once: true });
             try {
-                await sleepWithAbort(delayMs, opts.abortSignal);
+                // runner.task() returns a promise that resolves when the runner stops
+                await runner.task();
+                return;
             }
-            catch (sleepErr) {
-                if (opts.abortSignal?.aborted)
-                    return;
-                throw sleepErr;
+            catch (err) {
+                if (opts.abortSignal?.aborted) {
+                    throw err;
+                }
+                const isConflict = isGetUpdatesConflict(err);
+                const isRecoverable = isRecoverableTelegramNetworkError(err, { context: "polling" });
+                if (!isConflict && !isRecoverable) {
+                    throw err;
+                }
+                restartAttempts += 1;
+                const delayMs = computeBackoff(TELEGRAM_POLL_RESTART_POLICY, restartAttempts);
+                const reason = isConflict ? "getUpdates conflict" : "network error";
+                const errMsg = formatErrorMessage(err);
+                (opts.runtime?.error ?? console.error)(`Telegram ${reason}: ${errMsg}; retrying in ${formatDurationPrecise(delayMs)}.`);
+                try {
+                    await sleepWithAbort(delayMs, opts.abortSignal);
+                }
+                catch (sleepErr) {
+                    if (opts.abortSignal?.aborted)
+                        return;
+                    throw sleepErr;
+                }
+            }
+            finally {
+                opts.abortSignal?.removeEventListener("abort", stopOnAbort);
             }
         }
-        finally {
-            opts.abortSignal?.removeEventListener("abort", stopOnAbort);
-        }
+    }
+    finally {
+        unregisterHandler();
     }
 }

package/dist/telegram/send.js

@@ -23,6 +23,7 @@ import { parseTelegramTarget, stripTelegramInternalPrefixes } from "./targets.js
 import { resolveTelegramVoiceSend } from "./voice.js";
 import { buildTelegramThreadParams } from "./bot/helpers.js";
 const PARSE_ERR_RE = /can't parse entities|parse entities|find end of the entity/i;
+const THREAD_NOT_FOUND_RE = /400:\s*Bad Request:\s*message thread not found/i;
 const diagLogger = createSubsystemLogger("telegram/diagnostic");
 function createTelegramHttpLogger(cfg) {
     const enabled = isDiagnosticFlagEnabled("telegram.http", cfg);
@@ -101,6 +102,26 @@ function normalizeMessageId(raw) {
     }
     throw new Error("Message id is required for Telegram actions");
 }
+function isTelegramThreadNotFoundError(err) {
+    return THREAD_NOT_FOUND_RE.test(formatErrorMessage(err));
+}
+function hasMessageThreadIdParam(params) {
+    if (!params)
+        return false;
+    const value = params.message_thread_id;
+    if (typeof value === "number")
+        return Number.isFinite(value);
+    if (typeof value === "string")
+        return value.trim().length > 0;
+    return false;
+}
+function removeMessageThreadIdParam(params) {
+    if (!params || !hasMessageThreadIdParam(params))
+        return params;
+    const next = { ...params };
+    delete next.message_thread_id;
+    return Object.keys(next).length > 0 ? next : undefined;
+}
 export function buildInlineKeyboard(buttons) {
     if (!buttons?.length)
         return undefined;
@@ -136,8 +157,17 @@ export async function sendMessageTelegram(to, text, opts = {}) {
     const messageThreadId = opts.messageThreadId != null ? opts.messageThreadId : target.messageThreadId;
     const threadIdParams = buildTelegramThreadParams(messageThreadId);
     const threadParams = threadIdParams ? { ...threadIdParams } : {};
+    const quoteText = opts.quoteText?.trim();
     if (opts.replyToMessageId != null) {
-        threadParams.reply_to_message_id = Math.trunc(opts.replyToMessageId);
+        if (quoteText) {
+            threadParams.reply_parameters = {
+                message_id: Math.trunc(opts.replyToMessageId),
+                quote: quoteText,
+            };
+        }
+        else {
+            threadParams.reply_to_message_id = Math.trunc(opts.replyToMessageId);
+        }
     }
     const hasThreadParams = Object.keys(threadParams).length > 0;
     const request = createTelegramRetryRunner({
@@ -163,6 +193,21 @@ export async function sendMessageTelegram(to, text, opts = {}) {
             `Input was: ${JSON.stringify(to)}.`,
         ].join(" "));
     };
+    const sendWithThreadFallback = async (params, label, attempt) => {
+        try {
+            return await attempt(params, label);
+        }
+        catch (err) {
+            if (!hasMessageThreadIdParam(params) || !isTelegramThreadNotFoundError(err)) {
+                throw err;
+            }
+            if (opts.verbose) {
+                console.warn(`telegram ${label} failed with message_thread_id, retrying without thread: ${formatErrorMessage(err)}`);
+            }
+            const retriedParams = removeMessageThreadIdParam(params);
+            return await attempt(retriedParams, `${label}-threadless`);
+        }
+    };
     const textMode = opts.textMode ?? "markdown";
     const tableMode = resolveMarkdownTableMode({
         cfg,
@@ -174,36 +219,40 @@ export async function sendMessageTelegram(to, text, opts = {}) {
     const linkPreviewEnabled = account.config.linkPreview ?? true;
     const linkPreviewOptions = linkPreviewEnabled ? undefined : { is_disabled: true };
     const sendTelegramText = async (rawText, params, fallbackText) => {
-        const htmlText = renderHtmlText(rawText);
-        const baseParams = params ? { ...params } : {};
-        if (linkPreviewOptions) {
-            baseParams.link_preview_options = linkPreviewOptions;
-        }
-        const hasBaseParams = Object.keys(baseParams).length > 0;
-        const sendParams = {
-            parse_mode: "HTML",
-            ...baseParams,
-            ...(opts.silent === true ? { disable_notification: true } : {}),
-        };
-        const res = await requestWithDiag(() => api.sendMessage(chatId, htmlText, sendParams), "message").catch(async (err) => {
-            // Telegram rejects malformed HTML (e.g., unsupported tags or entities).
-            // When that happens, fall back to plain text so the message still delivers.
-            const errText = formatErrorMessage(err);
-            if (PARSE_ERR_RE.test(errText)) {
-                if (opts.verbose) {
-                    console.warn(`telegram HTML parse failed, retrying as plain text: ${errText}`);
-                }
-                const fallback = fallbackText ?? rawText;
-                const plainParams = hasBaseParams ? baseParams : undefined;
-                return await requestWithDiag(() => plainParams
-                    ? api.sendMessage(chatId, fallback, plainParams)
-                    : api.sendMessage(chatId, fallback), "message-plain").catch((err2) => {
-                    throw wrapChatNotFound(err2);
-                });
+        return await sendWithThreadFallback(params, "message", async (effectiveParams, label) => {
+            const htmlText = renderHtmlText(rawText);
+            const baseParams = effectiveParams ? { ...effectiveParams } : {};
+            if (linkPreviewOptions) {
+                baseParams.link_preview_options = linkPreviewOptions;
             }
-            throw wrapChatNotFound(err);
+            const hasBaseParams = Object.keys(baseParams).length > 0;
+            const sendParams = {
+                parse_mode: "HTML",
+                ...baseParams,
+                ...(opts.silent === true ? { disable_notification: true } : {}),
+            };
+            const res = await requestWithDiag(() => api.sendMessage(chatId, htmlText, sendParams), label).catch(async (err) => {
+                // Telegram rejects malformed HTML (e.g., unsupported tags or entities).
+                // When that happens, fall back to plain text so the message still delivers.
+                const errText = formatErrorMessage(err);
+                if (PARSE_ERR_RE.test(errText)) {
+                    if (opts.verbose) {
+                        console.warn(`telegram HTML parse failed, retrying as plain text: ${errText}`);
+                    }
+                    const fallback = fallbackText ?? rawText;
+                    const plainParams = hasBaseParams
+                        ? baseParams
+                        : undefined;
+                    return await requestWithDiag(() => plainParams
+                        ? api.sendMessage(chatId, fallback, plainParams)
+                        : api.sendMessage(chatId, fallback), `${label}-plain`).catch((err2) => {
+                        throw wrapChatNotFound(err2);
+                    });
+                }
+                throw wrapChatNotFound(err);
+            });
+            return res;
         });
-        return res;
     };
     if (mediaUrl) {
         const media = await loadWebMedia(mediaUrl, opts.maxBytes);
@@ -212,9 +261,21 @@ export async function sendMessageTelegram(to, text, opts = {}) {
             contentType: media.contentType,
             fileName: media.fileName,
         });
+        const isVideoNote = kind === "video" && opts.asVideoNote === true;
         const fileName = media.fileName ?? (isGif ? "animation.gif" : inferFilename(kind)) ?? "file";
         const file = new InputFile(media.buffer, fileName);
-        const { caption, followUpText } = splitTelegramCaption(text);
+        let caption;
+        let followUpText;
+        if (isVideoNote) {
+            // Video notes don't support captions; send any text as follow-up.
+            caption = undefined;
+            followUpText = text.trim() ? text : undefined;
+        }
+        else {
+            const split = splitTelegramCaption(text);
+            caption = split.caption;
+            followUpText = split.followUpText;
+        }
         const htmlCaption = caption ? renderHtmlText(caption) : undefined;
         // If text exceeds Telegram's caption limit, send media without caption
         // then send text as a separate follow-up message.
@@ -226,26 +287,32 @@ export async function sendMessageTelegram(to, text, opts = {}) {
             ...(!needsSeparateText && replyMarkup ? { reply_markup: replyMarkup } : {}),
         };
         const mediaParams = {
-            caption: htmlCaption,
-            ...(htmlCaption ? { parse_mode: "HTML" } : {}),
+            ...(htmlCaption ? { caption: htmlCaption, parse_mode: "HTML" } : {}),
             ...baseMediaParams,
             ...(opts.silent === true ? { disable_notification: true } : {}),
         };
         let result;
         if (isGif) {
-            result = await requestWithDiag(() => api.sendAnimation(chatId, file, mediaParams), "animation").catch((err) => {
+            result = await sendWithThreadFallback(mediaParams, "animation", async (effectiveParams, label) => requestWithDiag(() => api.sendAnimation(chatId, file, effectiveParams), label).catch((err) => {
                 throw wrapChatNotFound(err);
-            });
+            }));
         }
         else if (kind === "image") {
-            result = await requestWithDiag(() => api.sendPhoto(chatId, file, mediaParams), "photo").catch((err) => {
+            result = await sendWithThreadFallback(mediaParams, "photo", async (effectiveParams, label) => requestWithDiag(() => api.sendPhoto(chatId, file, effectiveParams), label).catch((err) => {
                 throw wrapChatNotFound(err);
-            });
+            }));
         }
         else if (kind === "video") {
-            result = await requestWithDiag(() => api.sendVideo(chatId, file, mediaParams), "video").catch((err) => {
-                throw wrapChatNotFound(err);
-            });
+            if (isVideoNote) {
+                result = await sendWithThreadFallback(mediaParams, "video_note", async (effectiveParams, label) => requestWithDiag(() => api.sendVideoNote(chatId, file, effectiveParams), label).catch((err) => {
+                    throw wrapChatNotFound(err);
+                }));
+            }
+            else {
+                result = await sendWithThreadFallback(mediaParams, "video", async (effectiveParams, label) => requestWithDiag(() => api.sendVideo(chatId, file, effectiveParams), label).catch((err) => {
+                    throw wrapChatNotFound(err);
+                }));
+            }
         }
         else if (kind === "audio") {
             const { useVoice } = resolveTelegramVoiceSend({
@@ -255,20 +322,20 @@ export async function sendMessageTelegram(to, text, opts = {}) {
                 logFallback: logVerbose,
             });
             if (useVoice) {
-                result = await requestWithDiag(() => api.sendVoice(chatId, file, mediaParams), "voice").catch((err) => {
+                result = await sendWithThreadFallback(mediaParams, "voice", async (effectiveParams, label) => requestWithDiag(() => api.sendVoice(chatId, file, effectiveParams), label).catch((err) => {
                     throw wrapChatNotFound(err);
-                });
+                }));
             }
             else {
-                result = await requestWithDiag(() => api.sendAudio(chatId, file, mediaParams), "audio").catch((err) => {
+                result = await sendWithThreadFallback(mediaParams, "audio", async (effectiveParams, label) => requestWithDiag(() => api.sendAudio(chatId, file, effectiveParams), label).catch((err) => {
                     throw wrapChatNotFound(err);
-                });
+                }));
             }
         }
         else {
-            result = await requestWithDiag(() => api.sendDocument(chatId, file, mediaParams), "document").catch((err) => {
+            result = await sendWithThreadFallback(mediaParams, "document", async (effectiveParams, label) => requestWithDiag(() => api.sendDocument(chatId, file, effectiveParams), label).catch((err) => {
                 throw wrapChatNotFound(err);
-            });
+            }));
         }
         const mediaMessageId = String(result?.message_id ?? "unknown");
         const resolvedChatId = String(result?.chat?.id ?? chatId);
@@ -508,10 +575,25 @@ export async function sendStickerTelegram(to, fileId, opts = {}) {
             `Input was: ${JSON.stringify(to)}.`,
         ].join(" "));
     };
+    const sendWithStickerThreadFallback = async (params, label, attempt) => {
+        try {
+            return await attempt(params, label);
+        }
+        catch (err) {
+            if (!hasMessageThreadIdParam(params) || !isTelegramThreadNotFoundError(err)) {
+                throw err;
+            }
+            if (opts.verbose) {
+                console.warn(`telegram ${label} failed with message_thread_id, retrying without thread: ${formatErrorMessage(err)}`);
+            }
+            const retriedParams = removeMessageThreadIdParam(params);
+            return await attempt(retriedParams, `${label}-threadless`);
+        }
+    };
     const stickerParams = hasThreadParams ? threadParams : undefined;
-    const result = await requestWithDiag(() => api.sendSticker(chatId, fileId.trim(), stickerParams), "sticker").catch((err) => {
+    const result = await sendWithStickerThreadFallback(stickerParams, "sticker", async (effectiveParams, label) => requestWithDiag(() => api.sendSticker(chatId, fileId.trim(), effectiveParams), label).catch((err) => {
         throw wrapChatNotFound(err);
-    });
+    }));
     const messageId = String(result?.message_id ?? "unknown");
     const resolvedChatId = String(result?.chat?.id ?? chatId);
     if (result?.message_id) {