@poolzin/pool-bot 2026.2.21 → 2026.2.22

package/dist/slack/streaming.js

@@ -0,0 +1,77 @@
+/**
+ * Slack native text streaming helpers.
+ *
+ * Uses the Slack SDK's `ChatStreamer` (via `client.chatStream()`) to stream
+ * text responses word-by-word in a single updating message, matching Slack's
+ * "Agents & AI Apps" streaming UX.
+ *
+ * @see https://docs.slack.dev/ai/developing-ai-apps#streaming
+ * @see https://docs.slack.dev/reference/methods/chat.startStream
+ * @see https://docs.slack.dev/reference/methods/chat.appendStream
+ * @see https://docs.slack.dev/reference/methods/chat.stopStream
+ */
+import { logVerbose } from "../globals.js";
+// ---------------------------------------------------------------------------
+// Stream lifecycle
+// ---------------------------------------------------------------------------
+/**
+ * Start a new Slack text stream.
+ *
+ * Returns a {@link SlackStreamSession} that should be passed to
+ * {@link appendSlackStream} and {@link stopSlackStream}.
+ *
+ * The first chunk of text can optionally be included via `text`.
+ */
+export async function startSlackStream(params) {
+    const { client, channel, threadTs, text } = params;
+    logVerbose(`slack-stream: starting stream in ${channel} thread=${threadTs}`);
+    const streamer = client.chatStream({
+        channel,
+        thread_ts: threadTs,
+    });
+    const session = {
+        streamer,
+        channel,
+        threadTs,
+        stopped: false,
+    };
+    // If initial text is provided, send it as the first append which will
+    // trigger the ChatStreamer to call chat.startStream under the hood.
+    if (text) {
+        await streamer.append({ markdown_text: text });
+        logVerbose(`slack-stream: appended initial text (${text.length} chars)`);
+    }
+    return session;
+}
+/**
+ * Append markdown text to an active Slack stream.
+ */
+export async function appendSlackStream(params) {
+    const { session, text } = params;
+    if (session.stopped) {
+        logVerbose("slack-stream: attempted to append to a stopped stream, ignoring");
+        return;
+    }
+    if (!text) {
+        return;
+    }
+    await session.streamer.append({ markdown_text: text });
+    logVerbose(`slack-stream: appended ${text.length} chars`);
+}
+/**
+ * Stop (finalize) a Slack stream.
+ *
+ * After calling this the stream message becomes a normal Slack message.
+ * Optionally include final text to append before stopping.
+ */
+export async function stopSlackStream(params) {
+    const { session, text } = params;
+    if (session.stopped) {
+        logVerbose("slack-stream: stream already stopped, ignoring duplicate stop");
+        return;
+    }
+    session.stopped = true;
+    logVerbose(`slack-stream: stopping stream in ${session.channel} thread=${session.threadTs}${text ? ` (final text: ${text.length} chars)` : ""}`);
+    await session.streamer.stop(text ? { markdown_text: text } : undefined);
+    logVerbose("slack-stream: stream stopped");
+}

package/dist/telegram/accounts.js

@@ -3,18 +3,20 @@ import { listBoundAccountIds, resolveDefaultAgentBoundAccountId } from "../routi
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "../routing/session-key.js";
 import { resolveTelegramToken } from "./token.js";
 const debugAccounts = (...args) => {
-    if (isTruthyEnvValue(process.env.POOLBOT_DEBUG_TELEGRAM_ACCOUNTS || process.env.CLAWDBOT_DEBUG_TELEGRAM_ACCOUNTS)) {
+    if (isTruthyEnvValue(process.env.POOLBOT_DEBUG_TELEGRAM_ACCOUNTS)) {
         console.warn("[telegram:accounts]", ...args);
     }
 };
 function listConfiguredAccountIds(cfg) {
     const accounts = cfg.channels?.telegram?.accounts;
-    if (!accounts || typeof accounts !== "object")
+    if (!accounts || typeof accounts !== "object") {
         return [];
+    }
     const ids = new Set();
     for (const key of Object.keys(accounts)) {
-        if (!key)
+        if (!key) {
             continue;
+        }
         ids.add(normalizeAccountId(key));
     }
     return [...ids];
@@ -22,26 +24,31 @@ function listConfiguredAccountIds(cfg) {
 export function listTelegramAccountIds(cfg) {
     const ids = Array.from(new Set([...listConfiguredAccountIds(cfg), ...listBoundAccountIds(cfg, "telegram")]));
     debugAccounts("listTelegramAccountIds", ids);
-    if (ids.length === 0)
+    if (ids.length === 0) {
         return [DEFAULT_ACCOUNT_ID];
-    return ids.sort((a, b) => a.localeCompare(b));
+    }
+    return ids.toSorted((a, b) => a.localeCompare(b));
 }
 export function resolveDefaultTelegramAccountId(cfg) {
     const boundDefault = resolveDefaultAgentBoundAccountId(cfg, "telegram");
-    if (boundDefault)
+    if (boundDefault) {
         return boundDefault;
+    }
     const ids = listTelegramAccountIds(cfg);
-    if (ids.includes(DEFAULT_ACCOUNT_ID))
+    if (ids.includes(DEFAULT_ACCOUNT_ID)) {
         return DEFAULT_ACCOUNT_ID;
+    }
     return ids[0] ?? DEFAULT_ACCOUNT_ID;
 }
 function resolveAccountConfig(cfg, accountId) {
     const accounts = cfg.channels?.telegram?.accounts;
-    if (!accounts || typeof accounts !== "object")
+    if (!accounts || typeof accounts !== "object") {
         return undefined;
+    }
     const direct = accounts[accountId];
-    if (direct)
+    if (direct) {
         return direct;
+    }
     const normalized = normalizeAccountId(accountId);
     const matchKey = Object.keys(accounts).find((key) => normalizeAccountId(key) === normalized);
     return matchKey ? accounts[matchKey] : undefined;
@@ -52,6 +59,22 @@ function mergeTelegramAccountConfig(cfg, accountId) {
     const account = resolveAccountConfig(cfg, accountId) ?? {};
     return { ...base, ...account };
 }
+export function createTelegramActionGate(params) {
+    const accountId = normalizeAccountId(params.accountId);
+    const baseActions = params.cfg.channels?.telegram?.actions;
+    const accountActions = resolveAccountConfig(params.cfg, accountId)?.actions;
+    return (key, defaultValue = true) => {
+        const accountValue = accountActions?.[key];
+        if (accountValue !== undefined) {
+            return accountValue;
+        }
+        const baseValue = baseActions?.[key];
+        if (baseValue !== undefined) {
+            return baseValue;
+        }
+        return defaultValue;
+    };
+}
 export function resolveTelegramAccount(params) {
     const hasExplicitAccountId = Boolean(params.accountId?.trim());
     const baseEnabled = params.cfg.channels?.telegram?.enabled !== false;
@@ -76,19 +99,23 @@ export function resolveTelegramAccount(params) {
     };
     const normalized = normalizeAccountId(params.accountId);
     const primary = resolve(normalized);
-    if (hasExplicitAccountId)
+    if (hasExplicitAccountId) {
         return primary;
-    if (primary.tokenSource !== "none")
+    }
+    if (primary.tokenSource !== "none") {
         return primary;
+    }
     // If accountId is omitted, prefer a configured account token over failing on
     // the implicit "default" account. This keeps env-based setups working while
     // making config-only tokens work for things like heartbeats.
     const fallbackId = resolveDefaultTelegramAccountId(params.cfg);
-    if (fallbackId === primary.accountId)
+    if (fallbackId === primary.accountId) {
         return primary;
+    }
     const fallback = resolve(fallbackId);
-    if (fallback.tokenSource === "none")
+    if (fallback.tokenSource === "none") {
         return primary;
+    }
     return fallback;
 }
 export function listEnabledTelegramAccounts(cfg) {

package/dist/telegram/allowed-updates.js

@@ -4,5 +4,8 @@ export function resolveTelegramAllowedUpdates() {
     if (!updates.includes("message_reaction")) {
         updates.push("message_reaction");
     }
+    if (!updates.includes("channel_post")) {
+        updates.push("channel_post");
+    }
     return updates;
 }

package/dist/telegram/bot/delivery.js

@@ -1,26 +1,31 @@
 import { GrammyError, InputFile } from "grammy";
-import { markdownToTelegramChunks, markdownToTelegramHtml, renderTelegramHtmlText, } from "../format.js";
-import { withTelegramApiErrorLogging } from "../api-logging.js";
 import { chunkMarkdownTextWithMode } from "../../auto-reply/chunk.js";
-import { splitTelegramCaption } from "../caption.js";
-import { danger, logVerbose } from "../../globals.js";
+import { danger, logVerbose, warn } from "../../globals.js";
 import { formatErrorMessage } from "../../infra/errors.js";
+import { retryAsync } from "../../infra/retry.js";
 import { mediaKindFromMime } from "../../media/constants.js";
 import { fetchRemoteMedia } from "../../media/fetch.js";
 import { isGifMedia } from "../../media/mime.js";
 import { saveMediaBuffer } from "../../media/store.js";
 import { loadWebMedia } from "../../web/media.js";
+import { withTelegramApiErrorLogging } from "../api-logging.js";
+import { splitTelegramCaption } from "../caption.js";
+import { markdownToTelegramChunks, markdownToTelegramHtml, renderTelegramHtmlText, wrapFileReferencesInHtml, } from "../format.js";
 import { buildInlineKeyboard } from "../send.js";
-import { resolveTelegramVoiceSend } from "../voice.js";
-import { buildTelegramThreadParams, resolveTelegramReplyId } from "./helpers.js";
 import { cacheSticker, getCachedSticker } from "../sticker-cache.js";
+import { resolveTelegramVoiceSend } from "../voice.js";
+import { buildTelegramThreadParams, resolveTelegramMediaPlaceholder, resolveTelegramReplyId, } from "./helpers.js";
 const PARSE_ERR_RE = /can't parse entities|parse entities|find end of the entity/i;
 const VOICE_FORBIDDEN_RE = /VOICE_MESSAGES_FORBIDDEN/;
+const FILE_TOO_BIG_RE = /file is too big/i;
 export async function deliverReplies(params) {
-    const { replies, chatId, runtime, bot, replyToMode, textLimit, messageThreadId, linkPreview } = params;
+    const { replies, chatId, runtime, bot, replyToMode, textLimit, thread, linkPreview, replyQuoteText, } = params;
     const chunkMode = params.chunkMode ?? "length";
-    const threadParams = buildTelegramThreadParams(messageThreadId);
     let hasReplied = false;
+    let hasDelivered = false;
+    const markDelivered = () => {
+        hasDelivered = true;
+    };
     const chunkText = (markdown) => {
         const markdownChunks = chunkMode === "newline"
             ? chunkMarkdownTextWithMode(markdown, textLimit, chunkMode)
@@ -30,7 +35,7 @@ export async function deliverReplies(params) {
             const nested = markdownToTelegramChunks(chunk, textLimit, { tableMode: params.tableMode });
             if (!nested.length && chunk) {
                 chunks.push({
-                    html: markdownToTelegramHtml(chunk, { tableMode: params.tableMode }),
+                    html: wrapFileReferencesInHtml(markdownToTelegramHtml(chunk, { tableMode: params.tableMode, wrapFileRefs: false })),
                     text: chunk,
                 });
                 continue;
@@ -50,6 +55,7 @@ export async function deliverReplies(params) {
             continue;
         }
         const replyToId = replyToMode === "off" ? undefined : resolveTelegramReplyId(reply.replyToId);
+        const replyToMessageIdForPayload = replyToId && (replyToMode === "all" || !hasReplied) ? replyToId : undefined;
         const mediaList = reply.mediaUrls?.length
             ? reply.mediaUrls
             : reply.mediaUrl
@@ -59,23 +65,28 @@ export async function deliverReplies(params) {
         const replyMarkup = buildInlineKeyboard(telegramData?.buttons);
         if (mediaList.length === 0) {
             const chunks = chunkText(reply.text || "");
+            let sentTextChunk = false;
             for (let i = 0; i < chunks.length; i += 1) {
                 const chunk = chunks[i];
-                if (!chunk)
+                if (!chunk) {
                     continue;
+                }
                 // Only attach buttons to the first chunk.
                 const shouldAttachButtons = i === 0 && replyMarkup;
                 await sendTelegramText(bot, chatId, chunk.html, runtime, {
-                    replyToMessageId: replyToId && (replyToMode === "all" || !hasReplied) ? replyToId : undefined,
-                    messageThreadId,
+                    replyToMessageId: replyToMessageIdForPayload,
+                    replyQuoteText,
+                    thread,
                     textMode: "html",
                     plainText: chunk.text,
                     linkPreview,
                     replyMarkup: shouldAttachButtons ? replyMarkup : undefined,
                 });
-                if (replyToId && !hasReplied) {
-                    hasReplied = true;
-                }
+                sentTextChunk = true;
+                markDelivered();
+            }
+            if (replyToMessageIdForPayload && !hasReplied && sentTextChunk) {
+                hasReplied = true;
             }
             continue;
         }
@@ -86,7 +97,9 @@ export async function deliverReplies(params) {
         let pendingFollowUpText;
         for (const mediaUrl of mediaList) {
             const isFirstMedia = first;
-            const media = await loadWebMedia(mediaUrl);
+            const media = await loadWebMedia(mediaUrl, {
+                localRoots: params.mediaLocalRoots,
+            });
             const kind = mediaKindFromMime(media.contentType ?? undefined);
             const isGif = isGifMedia({
                 contentType: media.contentType,
@@ -103,23 +116,24 @@ export async function deliverReplies(params) {
                 pendingFollowUpText = followUpText;
             }
             first = false;
-            const replyToMessageId = replyToId && (replyToMode === "all" || !hasReplied) ? replyToId : undefined;
+            const replyToMessageId = replyToMessageIdForPayload;
             const shouldAttachButtonsToMedia = isFirstMedia && replyMarkup && !followUpText;
             const mediaParams = {
                 caption: htmlCaption,
-                reply_to_message_id: replyToMessageId,
                 ...(htmlCaption ? { parse_mode: "HTML" } : {}),
                 ...(shouldAttachButtonsToMedia ? { reply_markup: replyMarkup } : {}),
+                ...buildTelegramSendParams({
+                    replyToMessageId,
+                    thread,
+                }),
             };
-            if (threadParams) {
-                mediaParams.message_thread_id = threadParams.message_thread_id;
-            }
             if (isGif) {
                 await withTelegramApiErrorLogging({
                     operation: "sendAnimation",
                     runtime,
                     fn: () => bot.api.sendAnimation(chatId, file, { ...mediaParams }),
                 });
+                markDelivered();
             }
             else if (kind === "image") {
                 await withTelegramApiErrorLogging({
@@ -127,6 +141,7 @@ export async function deliverReplies(params) {
                     runtime,
                     fn: () => bot.api.sendPhoto(chatId, file, { ...mediaParams }),
                 });
+                markDelivered();
             }
             else if (kind === "video") {
                 await withTelegramApiErrorLogging({
@@ -134,6 +149,7 @@ export async function deliverReplies(params) {
                     runtime,
                     fn: () => bot.api.sendVideo(chatId, file, { ...mediaParams }),
                 });
+                markDelivered();
             }
             else if (kind === "audio") {
                 const { useVoice } = resolveTelegramVoiceSend({
@@ -153,6 +169,7 @@ export async function deliverReplies(params) {
                             shouldLog: (err) => !isVoiceMessagesForbidden(err),
                             fn: () => bot.api.sendVoice(chatId, file, { ...mediaParams }),
                         });
+                        markDelivered();
                     }
                     catch (voiceErr) {
                         // Fall back to text if voice messages are forbidden in this chat.
@@ -164,19 +181,22 @@ export async function deliverReplies(params) {
                                 throw voiceErr;
                             }
                             logVerbose("telegram sendVoice forbidden (recipient has voice messages blocked in privacy settings); falling back to text");
-                            hasReplied = await sendTelegramVoiceFallbackText({
+                            await sendTelegramVoiceFallbackText({
                                 bot,
                                 chatId,
                                 runtime,
                                 text: fallbackText,
                                 chunkText,
-                                replyToId,
-                                replyToMode,
-                                hasReplied,
-                                messageThreadId,
+                                replyToId: replyToMessageIdForPayload,
+                                thread,
                                 linkPreview,
                                 replyMarkup,
+                                replyQuoteText,
                             });
+                            if (replyToMessageIdForPayload && !hasReplied) {
+                                hasReplied = true;
+                            }
+                            markDelivered();
                             // Skip this media item; continue with next.
                             continue;
                         }
@@ -190,6 +210,7 @@ export async function deliverReplies(params) {
                         runtime,
                         fn: () => bot.api.sendAudio(chatId, file, { ...mediaParams }),
                     });
+                    markDelivered();
                 }
             }
             else {
@@ -198,6 +219,7 @@ export async function deliverReplies(params) {
                     runtime,
                     fn: () => bot.api.sendDocument(chatId, file, { ...mediaParams }),
                 });
+                markDelivered();
             }
             if (replyToId && !hasReplied) {
                 hasReplied = true;
@@ -208,26 +230,37 @@ export async function deliverReplies(params) {
                 const chunks = chunkText(pendingFollowUpText);
                 for (let i = 0; i < chunks.length; i += 1) {
                     const chunk = chunks[i];
-                    const replyToMessageIdFollowup = replyToId && (replyToMode === "all" || !hasReplied) ? replyToId : undefined;
                     await sendTelegramText(bot, chatId, chunk.html, runtime, {
-                        replyToMessageId: replyToMessageIdFollowup,
-                        messageThreadId,
+                        replyToMessageId: replyToMessageIdForPayload,
+                        thread,
                         textMode: "html",
                         plainText: chunk.text,
                         linkPreview,
                         replyMarkup: i === 0 ? replyMarkup : undefined,
                     });
-                    if (replyToId && !hasReplied) {
-                        hasReplied = true;
-                    }
+                    markDelivered();
                 }
                 pendingFollowUpText = undefined;
             }
+            if (replyToMessageIdForPayload && !hasReplied) {
+                hasReplied = true;
+            }
         }
     }
+    return { delivered: hasDelivered };
 }
 export async function resolveMedia(ctx, maxBytes, token, proxyFetch) {
     const msg = ctx.message;
+    const downloadAndSaveTelegramFile = async (filePath, fetchImpl) => {
+        const url = `https://api.telegram.org/file/bot${token}/${filePath}`;
+        const fetched = await fetchRemoteMedia({
+            url,
+            fetchImpl,
+            filePathHint: filePath,
+        });
+        const originalName = fetched.fileName ?? filePath;
+        return saveMediaBuffer(fetched.buffer, fetched.contentType, "inbound", maxBytes, originalName);
+    };
     // Handle stickers separately - only static stickers (WEBP) are supported
     if (msg.sticker) {
         const sticker = msg.sticker;
@@ -236,8 +269,9 @@ export async function resolveMedia(ctx, maxBytes, token, proxyFetch) {
             logVerbose("telegram: skipping animated/video sticker (only static stickers supported)");
             return null;
         }
-        if (!sticker.file_id)
+        if (!sticker.file_id) {
             return null;
+        }
         try {
             const file = await ctx.getFile();
             if (!file.file_path) {
@@ -249,13 +283,7 @@ export async function resolveMedia(ctx, maxBytes, token, proxyFetch) {
                 logVerbose("telegram: fetch not available for sticker download");
                 return null;
             }
-            const url = `https://api.telegram.org/file/bot${token}/${file.file_path}`;
-            const fetched = await fetchRemoteMedia({
-                url,
-                fetchImpl,
-                filePathHint: file.file_path,
-            });
-            const saved = await saveMediaBuffer(fetched.buffer, fetched.contentType, "inbound", maxBytes);
+            const saved = await downloadAndSaveTelegramFile(file.file_path, fetchImpl);
             // Check sticker cache for existing description
             const cached = sticker.file_unique_id ? getCachedSticker(sticker.file_unique_id) : null;
             if (cached) {
@@ -303,10 +331,38 @@ export async function resolveMedia(ctx, maxBytes, token, proxyFetch) {
             return null;
         }
     }
-    const m = msg.photo?.[msg.photo.length - 1] ?? msg.video ?? msg.document ?? msg.audio ?? msg.voice;
-    if (!m?.file_id)
+    const m = msg.photo?.[msg.photo.length - 1] ??
+        msg.video ??
+        msg.video_note ??
+        msg.document ??
+        msg.audio ??
+        msg.voice;
+    if (!m?.file_id) {
         return null;
-    const file = await ctx.getFile();
+    }
+    let file;
+    try {
+        file = await retryAsync(() => ctx.getFile(), {
+            attempts: 3,
+            minDelayMs: 1000,
+            maxDelayMs: 4000,
+            jitter: 0.2,
+            label: "telegram:getFile",
+            shouldRetry: isRetryableGetFileError,
+            onRetry: ({ attempt, maxAttempts }) => logVerbose(`telegram: getFile retry ${attempt}/${maxAttempts}`),
+        });
+    }
+    catch (err) {
+        // Handle "file is too big" separately - Telegram Bot API has a 20MB download limit
+        if (isFileTooBigError(err)) {
+            logVerbose(warn("telegram: getFile failed - file exceeds Telegram Bot API 20MB limit; skipping attachment"));
+            return null;
+        }
+        // All retries exhausted — return null so the message still reaches the agent
+        // with a type-based placeholder (e.g. <media:audio>) instead of being dropped.
+        logVerbose(`telegram: getFile failed after retries: ${String(err)}`);
+        return null;
+    }
     if (!file.file_path) {
         throw new Error("Telegram getFile returned no file_path");
     }
@@ -314,20 +370,8 @@ export async function resolveMedia(ctx, maxBytes, token, proxyFetch) {
     if (!fetchImpl) {
         throw new Error("fetch is not available; set channels.telegram.proxy in config");
     }
-    const url = `https://api.telegram.org/file/bot${token}/${file.file_path}`;
-    const fetched = await fetchRemoteMedia({
-        url,
-        fetchImpl,
-        filePathHint: file.file_path,
-    });
-    const saved = await saveMediaBuffer(fetched.buffer, fetched.contentType, "inbound", maxBytes);
-    let placeholder = "<media:document>";
-    if (msg.photo)
-        placeholder = "<media:image>";
-    else if (msg.video)
-        placeholder = "<media:video>";
-    else if (msg.audio || msg.voice)
-        placeholder = "<media:audio>";
+    const saved = await downloadAndSaveTelegramFile(file.file_path, fetchImpl);
+    const placeholder = resolveTelegramMediaPlaceholder(msg) ?? "<media:document>";
     return { path: saved.path, contentType: saved.contentType, placeholder };
 }
 function isVoiceMessagesForbidden(err) {
@@ -336,27 +380,46 @@ function isVoiceMessagesForbidden(err) {
     }
     return VOICE_FORBIDDEN_RE.test(formatErrorMessage(err));
 }
+/**
+ * Returns true if the error is Telegram's "file is too big" error.
+ * This happens when trying to download files >20MB via the Bot API.
+ * Unlike network errors, this is a permanent error and should not be retried.
+ */
+function isFileTooBigError(err) {
+    if (err instanceof GrammyError) {
+        return FILE_TOO_BIG_RE.test(err.description);
+    }
+    return FILE_TOO_BIG_RE.test(formatErrorMessage(err));
+}
+/**
+ * Returns true if the error is a transient network error that should be retried.
+ * Returns false for permanent errors like "file is too big" (400 Bad Request).
+ */
+function isRetryableGetFileError(err) {
+    // Don't retry "file is too big" - it's a permanent 400 error
+    if (isFileTooBigError(err)) {
+        return false;
+    }
+    // Retry all other errors (network issues, timeouts, etc.)
+    return true;
+}
 async function sendTelegramVoiceFallbackText(opts) {
     const chunks = opts.chunkText(opts.text);
-    let hasReplied = opts.hasReplied;
     for (let i = 0; i < chunks.length; i += 1) {
         const chunk = chunks[i];
         await sendTelegramText(opts.bot, opts.chatId, chunk.html, opts.runtime, {
-            replyToMessageId: opts.replyToId && (opts.replyToMode === "all" || !hasReplied) ? opts.replyToId : undefined,
-            messageThreadId: opts.messageThreadId,
+            replyToMessageId: opts.replyToId,
+            replyQuoteText: opts.replyQuoteText,
+            thread: opts.thread,
             textMode: "html",
             plainText: chunk.text,
             linkPreview: opts.linkPreview,
             replyMarkup: i === 0 ? opts.replyMarkup : undefined,
         });
-        if (opts.replyToId && !hasReplied) {
-            hasReplied = true;
-        }
     }
-    return hasReplied;
 }
 function buildTelegramSendParams(opts) {
-    const threadParams = buildTelegramThreadParams(opts?.messageThreadId);
+    const threadParams = buildTelegramThreadParams(opts?.thread);
     const params = {};
     if (opts?.replyToMessageId) {
         params.reply_to_message_id = opts.replyToMessageId;
@@ -369,7 +432,7 @@ function buildTelegramSendParams(opts) {
 async function sendTelegramText(bot, chatId, text, runtime, opts) {
     const baseParams = buildTelegramSendParams({
         replyToMessageId: opts?.replyToMessageId,
-        messageThreadId: opts?.messageThreadId,
+        thread: opts?.thread,
     });
     // Add link_preview_options when link preview is disabled.
     const linkPreviewEnabled = opts?.linkPreview ?? true;