@poolzin/pool-bot 2026.2.0 → 2026.2.2

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;

package/dist/telegram/bot-message-context.js

@@ -11,6 +11,7 @@ import { formatLocationText, toLocationContext } from "../channels/location.js";
 import { recordInboundSession } from "../channels/session.js";
 import { formatCliCommand } from "../cli/command-format.js";
 import { readSessionUpdatedAt, resolveStorePath } from "../config/sessions.js";
+import { loadConfig } from "../config/config.js";
 import { logVerbose, shouldLogVerbose } from "../globals.js";
 import { recordChannelActivity } from "../infra/channel-activity.js";
 import { resolveAgentRoute } from "../routing/resolve-route.js";
@@ -20,7 +21,7 @@ import { resolveMentionGatingWithBypass } from "../channels/mention-gating.js";
 import { resolveControlCommandGate } from "../channels/command-gating.js";
 import { logInboundDrop } from "../channels/logging.js";
 import { withTelegramApiErrorLogging } from "./api-logging.js";
-import { buildGroupLabel, buildSenderLabel, buildSenderName, buildTelegramGroupFrom, buildTelegramGroupPeerId, buildTypingThreadParams, expandTextLinks, normalizeForwardedContext, describeReplyTarget, extractTelegramLocation, hasBotMention, resolveTelegramForumThreadId, } from "./bot/helpers.js";
+import { buildGroupLabel, buildSenderLabel, buildSenderName, buildTelegramGroupFrom, buildTelegramGroupPeerId, buildTelegramParentPeer, buildTypingThreadParams, expandTextLinks, normalizeForwardedContext, describeReplyTarget, extractTelegramLocation, hasBotMention, resolveTelegramThreadSpec, } from "./bot/helpers.js";
 import { firstDefined, isSenderAllowed, normalizeAllowFromWithStore, resolveSenderAllowMatch, } from "./bot-access.js";
 import { upsertTelegramPairingRequest } from "./pairing-store.js";
 async function resolveStickerVisionSupport(params) {
@@ -50,23 +51,28 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
     const isGroup = msg.chat.type === "group" || msg.chat.type === "supergroup";
     const messageThreadId = msg.message_thread_id;
     const isForum = msg.chat.is_forum === true;
-    const resolvedThreadId = resolveTelegramForumThreadId({
+    const threadSpec = resolveTelegramThreadSpec({
+        isGroup,
         isForum,
         messageThreadId,
     });
+    const resolvedThreadId = threadSpec.scope === "forum" ? threadSpec.id : undefined;
+    const replyThreadId = threadSpec.id;
     const { groupConfig, topicConfig } = resolveTelegramGroupConfig(chatId, resolvedThreadId);
     const peerId = isGroup ? buildTelegramGroupPeerId(chatId, resolvedThreadId) : String(chatId);
+    const parentPeer = buildTelegramParentPeer({ isGroup, resolvedThreadId, chatId });
     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 dmThreadId = threadSpec.scope === "dm" ? threadSpec.id : undefined;
     const threadKeys = dmThreadId != null
         ? resolveThreadSessionKeys({ baseSessionKey, threadId: String(dmThreadId) })
         : null;
@@ -90,14 +96,14 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
     const sendTyping = async () => {
         await withTelegramApiErrorLogging({
             operation: "sendChatAction",
-            fn: () => bot.api.sendChatAction(chatId, "typing", buildTypingThreadParams(resolvedThreadId)),
+            fn: () => bot.api.sendChatAction(chatId, "typing", buildTypingThreadParams(replyThreadId)),
         });
     };
     const sendRecordVoice = async () => {
         try {
             await withTelegramApiErrorLogging({
                 operation: "sendChatAction",
-                fn: () => bot.api.sendChatAction(chatId, "record_voice", buildTypingThreadParams(resolvedThreadId)),
+                fn: () => bot.api.sendChatAction(chatId, "record_voice", buildTypingThreadParams(replyThreadId)),
             });
         }
         catch (err) {
@@ -109,7 +115,8 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
         if (dmPolicy === "disabled")
             return null;
         if (dmPolicy !== "open") {
-            const candidate = String(chatId);
+            const senderUserId = msg.from?.id != null ? String(msg.from.id) : null;
+            const candidate = senderUserId ?? String(chatId);
             const senderUsername = msg.from?.username ?? "";
             const allowMatch = resolveSenderAllowMatch({
                 allow: effectiveDmAllow,
@@ -131,7 +138,8 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
                         });
                         if (created) {
                             logger.info({
-                                chatId: candidate,
+                                chatId: String(chatId),
+                                senderUserId: senderUserId ?? undefined,
                                 username: from?.username,
                                 firstName: from?.first_name,
                                 lastName: from?.last_name,
@@ -201,6 +209,8 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
         placeholder = "<media:image>";
     else if (msg.video)
         placeholder = "<media:video>";
+    else if (msg.video_note)
+        placeholder = "<media:video>";
     else if (msg.audio || msg.voice)
         placeholder = "<media:audio>";
     else if (msg.document)
@@ -326,7 +336,9 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
     const replyTarget = describeReplyTarget(msg);
     const forwardOrigin = normalizeForwardedContext(msg);
     const replySuffix = replyTarget
-        ? `\n\n[Replying to ${replyTarget.sender}${replyTarget.id ? ` id:${replyTarget.id}` : ""}]\n${replyTarget.body}\n[/Replying]`
+        ? replyTarget.kind === "quote"
+            ? `\n\n[Quoting ${replyTarget.sender}${replyTarget.id ? ` id:${replyTarget.id}` : ""}]\n"${replyTarget.body}"\n[/Quoting]`
+            : `\n\n[Replying to ${replyTarget.sender}${replyTarget.id ? ` id:${replyTarget.id}` : ""}]\n${replyTarget.body}\n[/Replying]`
         : "";
     const forwardPrefix = forwardOrigin
         ? `[Forwarded from ${forwardOrigin.from}${forwardOrigin.date ? ` at ${new Date(forwardOrigin.date * 1000).toISOString()}` : ""}]\n`
@@ -383,9 +395,17 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
     ].filter((entry) => Boolean(entry));
     const groupSystemPrompt = systemPromptParts.length > 0 ? systemPromptParts.join("\n\n") : undefined;
     const commandBody = normalizeCommandBody(rawBody, { botUsername });
+    const inboundHistory = isGroup && historyKey && historyLimit > 0
+        ? (groupHistories.get(historyKey) ?? []).map((entry) => ({
+            sender: entry.sender,
+            body: entry.body,
+            timestamp: entry.timestamp,
+        }))
+        : undefined;
     const ctxPayload = finalizeInboundContext({
         Body: combinedBody,
         RawBody: rawBody,
+        BodyForAgent: bodyText,
         CommandBody: commandBody,
         From: isGroup ? buildTelegramGroupFrom(chatId, resolvedThreadId) : `telegram:${chatId}`,
         To: `telegram:${chatId}`,
@@ -404,12 +424,15 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
         ReplyToId: replyTarget?.id,
         ReplyToBody: replyTarget?.body,
         ReplyToSender: replyTarget?.sender,
+        ReplyToIsQuote: replyTarget?.kind === "quote" ? true : undefined,
         ForwardedFrom: forwardOrigin?.from,
         ForwardedFromType: forwardOrigin?.fromType,
         ForwardedFromId: forwardOrigin?.fromId,
         ForwardedFromUsername: forwardOrigin?.fromUsername,
         ForwardedFromTitle: forwardOrigin?.fromTitle,
         ForwardedFromSignature: forwardOrigin?.fromSignature,
+        ForwardedFromChatType: forwardOrigin?.fromChatType,
+        ForwardedFromMessageId: forwardOrigin?.fromMessageId,
         ForwardedDate: forwardOrigin?.date ? forwardOrigin.date * 1000 : undefined,
         Timestamp: msg.date ? msg.date * 1000 : undefined,
         WasMentioned: isGroup ? effectiveWasMentioned : undefined,
@@ -435,7 +458,8 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
         Sticker: allMedia[0]?.stickerMetadata,
         ...(locationData ? toLocationContext(locationData) : undefined),
         CommandAuthorized: commandAuthorized,
-        MessageThreadId: resolvedThreadId,
+        InboundHistory: inboundHistory,
+        MessageThreadId: threadSpec.id,
         IsForum: isForum,
         // Originating channel for reply routing.
         OriginatingChannel: "telegram",
@@ -451,6 +475,7 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
                 channel: "telegram",
                 to: String(chatId),
                 accountId: route.accountId,
+                threadId: dmThreadId != null ? String(dmThreadId) : undefined,
             }
             : undefined,
         onRecordError: (err) => {
@@ -477,6 +502,8 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
         chatId,
         isGroup,
         resolvedThreadId,
+        threadSpec,
+        replyThreadId,
         isForum,
         historyKey,
         historyLimit,

package/dist/telegram/bot-message-dispatch.js

@@ -1,7 +1,7 @@
-// @ts-nocheck
-import { EmbeddedBlockChunker } from "../agents/pi-embedded-block-chunker.js";
+import { resolveAgentDir } from "../agents/agent-scope.js";
 import { findModelInCatalog, loadModelCatalog, modelSupportsVision, } from "../agents/model-catalog.js";
 import { resolveDefaultModelForAgent } from "../agents/model-selection.js";
+import { EmbeddedBlockChunker } from "../agents/pi-embedded-block-chunker.js";
 import { resolveChunkMode } from "../auto-reply/chunk.js";
 import { clearHistoryEntriesIfEnabled } from "../auto-reply/reply/history.js";
 import { dispatchReplyWithBufferedBlockDispatcher } from "../auto-reply/reply/provider-dispatcher.js";
@@ -9,13 +9,13 @@ import { removeAckReactionAfterReply } from "../channels/ack-reactions.js";
 import { logAckFailure, logTypingFailure } from "../channels/logging.js";
 import { createReplyPrefixContext } from "../channels/reply-prefix.js";
 import { createTypingCallbacks } from "../channels/typing.js";
-import { danger, logVerbose } from "../globals.js";
 import { resolveMarkdownTableMode } from "../config/markdown-tables.js";
+import { danger, logVerbose } from "../globals.js";
 import { deliverReplies } from "./bot/delivery.js";
 import { resolveTelegramDraftStreamingChunking } from "./draft-chunking.js";
 import { createTelegramDraftStream } from "./draft-stream.js";
 import { cacheSticker, describeStickerImage } from "./sticker-cache.js";
-import { resolveAgentDir } from "../agents/agent-scope.js";
+const EMPTY_RESPONSE_FALLBACK = "No response generated. Please try again.";
 async function resolveStickerVisionSupport(cfg, agentId) {
     try {
         const catalog = await loadModelCatalog({ config: cfg });
@@ -118,7 +118,7 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
     // Handle uncached stickers: get a dedicated vision description before dispatch
     // This ensures we cache a raw description rather than a conversational response
     const sticker = ctxPayload.Sticker;
-    if (sticker?.fileUniqueId && ctxPayload.MediaPath) {
+    if (sticker?.fileId && sticker.fileUniqueId && ctxPayload.MediaPath) {
         const agentDir = resolveAgentDir(cfg, route.agentId);
         const stickerSupportsVision = await resolveStickerVisionSupport(cfg, route.agentId);
         let description = sticker.cachedDescription ?? null;
@@ -150,19 +150,32 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
                 ctxPayload.MediaTypes = undefined;
             }
             // Cache the description for future encounters
-            cacheSticker({
-                fileId: sticker.fileId,
-                fileUniqueId: sticker.fileUniqueId,
-                emoji: sticker.emoji,
-                setName: sticker.setName,
-                description,
-                cachedAt: new Date().toISOString(),
-                receivedFrom: ctxPayload.From,
-            });
-            logVerbose(`telegram: cached sticker description for ${sticker.fileUniqueId}`);
+            if (sticker.fileId) {
+                cacheSticker({
+                    fileId: sticker.fileId,
+                    fileUniqueId: sticker.fileUniqueId,
+                    emoji: sticker.emoji,
+                    setName: sticker.setName,
+                    description,
+                    cachedAt: new Date().toISOString(),
+                    receivedFrom: ctxPayload.From,
+                });
+                logVerbose(`telegram: cached sticker description for ${sticker.fileUniqueId}`);
+            }
+            else {
+                logVerbose(`telegram: skipped sticker cache (missing fileId)`);
+            }
         }
     }
-    const { queuedFinal } = await dispatchReplyWithBufferedBlockDispatcher({
+    // TODO: pass replyQuoteText to deliverReplies once delivery.ts supports it
+    const _replyQuoteText = ctxPayload.ReplyToIsQuote && ctxPayload.ReplyToBody
+        ? ctxPayload.ReplyToBody.trim() || undefined
+        : undefined;
+    void _replyQuoteText;
+    const deliveryState = {
+        delivered: false,
+    };
+    const { queuedFinal, counts } = await dispatchReplyWithBufferedBlockDispatcher({
         ctx: ctxPayload,
         cfg,
         dispatcherOptions: {
@@ -187,6 +200,7 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
                     onVoiceRecording: sendRecordVoice,
                     linkPreview: telegramCfg.linkPreview,
                 });
+                deliveryState.delivered = true;
             },
             onError: (err, info) => {
                 runtime.error?.(danger(`telegram ${info.kind} reply failed: ${String(err)}`));
@@ -219,7 +233,30 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
         },
     });
     draftStream?.stop();
-    if (!queuedFinal) {
+    let sentFallback = false;
+    if (!deliveryState.delivered && (counts.tool + counts.block + counts.final) > 0) {
+        try {
+            await deliverReplies({
+                replies: [{ text: EMPTY_RESPONSE_FALLBACK }],
+                chatId: String(chatId),
+                token: opts.token,
+                runtime,
+                bot,
+                replyToMode,
+                textLimit,
+                messageThreadId: resolvedThreadId,
+                tableMode,
+                chunkMode,
+                linkPreview: telegramCfg.linkPreview,
+            });
+            sentFallback = true;
+        }
+        catch {
+            // Fallback delivery failed; proceed without it
+        }
+    }
+    const hasFinalResponse = queuedFinal || sentFallback;
+    if (!hasFinalResponse) {
         if (isGroup && historyKey) {
             clearHistoryEntriesIfEnabled({ historyMap: groupHistories, historyKey, limit: historyLimit });
         }