@poolzin/pool-bot 2026.2.21 → 2026.2.22

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

@@ -7,23 +7,24 @@ import { formatInboundEnvelope, resolveEnvelopeFormatOptions } from "../auto-rep
 import { buildPendingHistoryContextFromMap, recordPendingHistoryEntryIfEnabled, } from "../auto-reply/reply/history.js";
 import { finalizeInboundContext } from "../auto-reply/reply/inbound-context.js";
 import { buildMentionRegexes, matchesMentionWithExplicit } from "../auto-reply/reply/mentions.js";
+import { shouldAckReaction as shouldAckReactionGate } from "../channels/ack-reactions.js";
+import { resolveControlCommandGate } from "../channels/command-gating.js";
 import { formatLocationText, toLocationContext } from "../channels/location.js";
+import { logInboundDrop } from "../channels/logging.js";
+import { resolveMentionGatingWithBypass } from "../channels/mention-gating.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 { readSessionUpdatedAt, resolveStorePath } from "../config/sessions.js";
 import { logVerbose, shouldLogVerbose } from "../globals.js";
 import { recordChannelActivity } from "../infra/channel-activity.js";
+import { buildPairingReply } from "../pairing/pairing-messages.js";
+import { upsertChannelPairingRequest } from "../pairing/pairing-store.js";
 import { resolveAgentRoute } from "../routing/resolve-route.js";
 import { resolveThreadSessionKeys } from "../routing/session-key.js";
-import { shouldAckReaction as shouldAckReactionGate } from "../channels/ack-reactions.js";
-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, 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";
+import { buildGroupLabel, buildSenderLabel, buildSenderName, buildTelegramGroupFrom, buildTelegramGroupPeerId, buildTelegramParentPeer, buildTypingThreadParams, resolveTelegramMediaPlaceholder, expandTextLinks, normalizeForwardedContext, describeReplyTarget, extractTelegramLocation, hasBotMention, resolveTelegramThreadSpec, } from "./bot/helpers.js";
+import { evaluateTelegramGroupBaseAccess } from "./group-access.js";
 async function resolveStickerVisionSupport(params) {
     try {
         const catalog = await loadModelCatalog({ config: params.cfg });
@@ -32,8 +33,9 @@ async function resolveStickerVisionSupport(params) {
             agentId: params.agentId,
         });
         const entry = findModelInCatalog(catalog, defaultModel.provider, defaultModel.model);
-        if (!entry)
+        if (!entry) {
             return false;
+        }
         return modelSupportsVision(entry);
     }
     catch {
@@ -61,17 +63,19 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
     const { groupConfig, topicConfig } = resolveTelegramGroupConfig(chatId, resolvedThreadId);
     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: loadConfig(),
         channel: "telegram",
         accountId: account.accountId,
         peer: {
-            kind: isGroup ? "group" : "dm",
+            kind: isGroup ? "group" : "direct",
             id: peerId,
         },
         parentPeer,
     });
     const baseSessionKey = route.sessionKey;
+    // DMs: use raw messageThreadId for thread sessions (not forum topic ids)
     const dmThreadId = threadSpec.scope === "dm" ? threadSpec.id : undefined;
     const threadKeys = dmThreadId != null
         ? resolveThreadSessionKeys({ baseSessionKey, threadId: String(dmThreadId) })
@@ -85,14 +89,40 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
         storeAllowFrom,
     });
     const hasGroupAllowOverride = typeof groupAllowOverride !== "undefined";
-    if (isGroup && groupConfig?.enabled === false) {
-        logVerbose(`Blocked telegram group ${chatId} (group disabled)`);
-        return null;
-    }
-    if (isGroup && topicConfig?.enabled === false) {
-        logVerbose(`Blocked telegram topic ${chatId} (${resolvedThreadId ?? "unknown"}) (topic disabled)`);
+    const senderId = msg.from?.id ? String(msg.from.id) : "";
+    const senderUsername = msg.from?.username ?? "";
+    const baseAccess = evaluateTelegramGroupBaseAccess({
+        isGroup,
+        groupConfig,
+        topicConfig,
+        hasGroupAllowOverride,
+        effectiveGroupAllow,
+        senderId,
+        senderUsername,
+        enforceAllowOverride: true,
+        requireSenderForAllowOverride: false,
+    });
+    if (!baseAccess.allowed) {
+        if (baseAccess.reason === "group-disabled") {
+            logVerbose(`Blocked telegram group ${chatId} (group disabled)`);
+            return null;
+        }
+        if (baseAccess.reason === "topic-disabled") {
+            logVerbose(`Blocked telegram topic ${chatId} (${resolvedThreadId ?? "unknown"}) (topic disabled)`);
+            return null;
+        }
+        logVerbose(`Blocked telegram group sender ${senderId || "unknown"} (group allowFrom override)`);
         return null;
     }
+    // Compute requireMention early for preflight transcription gating
+    const activationOverride = resolveGroupActivation({
+        chatId,
+        messageThreadId: resolvedThreadId,
+        sessionKey: sessionKey,
+        agentId: route.agentId,
+    });
+    const baseRequireMention = resolveGroupRequireMention(chatId);
+    const requireMention = firstDefined(activationOverride, topicConfig?.requireMention, groupConfig?.requireMention, baseRequireMention);
     const sendTyping = async () => {
         await withTelegramApiErrorLogging({
             operation: "sendChatAction",
@@ -112,12 +142,13 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
     };
     // DM access control (secure defaults): "pairing" (default) / "allowlist" / "open" / "disabled"
     if (!isGroup) {
-        if (dmPolicy === "disabled")
+        if (dmPolicy === "disabled") {
             return null;
+        }
         if (dmPolicy !== "open") {
+            const senderUsername = msg.from?.username ?? "";
             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,
                 senderId: candidate,
@@ -130,11 +161,15 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
                     try {
                         const from = msg.from;
                         const telegramUserId = from?.id ? String(from.id) : candidate;
-                        const { code, created } = await upsertTelegramPairingRequest({
-                            chatId: candidate,
-                            username: from?.username,
-                            firstName: from?.first_name,
-                            lastName: from?.last_name,
+                        const { code, created } = await upsertChannelPairingRequest({
+                            channel: "telegram",
+                            id: telegramUserId,
+                            accountId: account.accountId,
+                            meta: {
+                                username: from?.username,
+                                firstName: from?.first_name,
+                                lastName: from?.last_name,
+                            },
                         });
                         if (created) {
                             logger.info({
@@ -148,16 +183,11 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
                             }, "telegram pairing request");
                             await withTelegramApiErrorLogging({
                                 operation: "sendMessage",
-                                fn: () => bot.api.sendMessage(chatId, [
-                                    "Poolbot: access not configured.",
-                                    "",
-                                    `Your Telegram user id: ${telegramUserId}`,
-                                    "",
-                                    `Pairing code: ${code}`,
-                                    "",
-                                    "Ask the bot owner to approve with:",
-                                    formatCliCommand("poolbot pairing approve telegram <code>"),
-                                ].join("\n")),
+                                fn: () => bot.api.sendMessage(chatId, buildPairingReply({
+                                    channel: "telegram",
+                                    idLine: `Your Telegram user id: ${telegramUserId}`,
+                                    code,
+                                })),
                             });
                         }
                     }
@@ -173,19 +203,6 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
         }
     }
     const botUsername = primaryCtx.me?.username?.toLowerCase();
-    const senderId = msg.from?.id ? String(msg.from.id) : "";
-    const senderUsername = msg.from?.username ?? "";
-    if (isGroup && hasGroupAllowOverride) {
-        const allowed = isSenderAllowed({
-            allow: effectiveGroupAllow,
-            senderId,
-            senderUsername,
-        });
-        if (!allowed) {
-            logVerbose(`Blocked telegram group sender ${senderId || "unknown"} (group allowFrom override)`);
-            return null;
-        }
-    }
     const allowForCommands = isGroup ? effectiveGroupAllow : effectiveDmAllow;
     const senderAllowedForCommands = isSenderAllowed({
         allow: allowForCommands,
@@ -204,19 +221,7 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
     });
     const commandAuthorized = commandGate.commandAuthorized;
     const historyKey = isGroup ? buildTelegramGroupPeerId(chatId, resolvedThreadId) : undefined;
-    let placeholder = "";
-    if (msg.photo)
-        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)
-        placeholder = "<media:document>";
-    else if (msg.sticker)
-        placeholder = "<media:sticker>";
+    let placeholder = resolveTelegramMediaPlaceholder(msg) ?? "";
     // Check if sticker has a cached description - if so, use it instead of sending the image
     const cachedStickerDescription = allMedia[0]?.stickerMetadata?.cachedDescription;
     const stickerSupportsVision = msg.sticker
@@ -234,14 +239,52 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
     const locationText = locationData ? formatLocationText(locationData) : undefined;
     const rawTextSource = msg.text ?? msg.caption ?? "";
     const rawText = expandTextLinks(rawTextSource, msg.entities ?? msg.caption_entities).trim();
+    const hasUserText = Boolean(rawText || locationText);
     let rawBody = [rawText, locationText].filter(Boolean).join("\n").trim();
-    if (!rawBody)
+    if (!rawBody) {
         rawBody = placeholder;
-    if (!rawBody && allMedia.length === 0)
+    }
+    if (!rawBody && allMedia.length === 0) {
         return null;
+    }
     let bodyText = rawBody;
+    const hasAudio = allMedia.some((media) => media.contentType?.startsWith("audio/"));
+    // Preflight audio transcription for mention detection in groups
+    // This allows voice notes to be checked for mentions before being dropped
+    let preflightTranscript;
+    const needsPreflightTranscription = isGroup && requireMention && hasAudio && !hasUserText && mentionRegexes.length > 0;
+    if (needsPreflightTranscription) {
+        try {
+            const { transcribeFirstAudio } = await import("../media-understanding/audio-preflight.js");
+            // Build a minimal context for transcription
+            const tempCtx = {
+                MediaPaths: allMedia.length > 0 ? allMedia.map((m) => m.path) : undefined,
+                MediaTypes: allMedia.length > 0
+                    ? allMedia.map((m) => m.contentType).filter(Boolean)
+                    : undefined,
+            };
+            preflightTranscript = await transcribeFirstAudio({
+                ctx: tempCtx,
+                cfg,
+                agentDir: undefined,
+            });
+        }
+        catch (err) {
+            logVerbose(`telegram: audio preflight transcription failed: ${String(err)}`);
+        }
+    }
+    // Replace audio placeholder with transcript when preflight succeeds.
+    if (hasAudio && bodyText === "<media:audio>" && preflightTranscript) {
+        bodyText = preflightTranscript;
+    }
+    // Build bodyText fallback for messages that still have no text.
     if (!bodyText && allMedia.length > 0) {
-        bodyText = `<media:image>${allMedia.length > 1 ? ` (${allMedia.length} images)` : ""}`;
+        if (hasAudio) {
+            bodyText = preflightTranscript || "<media:audio>";
+        }
+        else {
+            bodyText = `<media:image>${allMedia.length > 1 ? ` (${allMedia.length} images)` : ""}`;
+        }
     }
     const hasAnyMention = (msg.entities ?? msg.caption_entities ?? []).some((ent) => ent.type === "mention");
     const explicitlyMentioned = botUsername ? hasBotMention(msg, botUsername) : false;
@@ -253,6 +296,7 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
             isExplicitlyMentioned: explicitlyMentioned,
             canResolveExplicit: Boolean(botUsername),
         },
+        transcript: preflightTranscript,
     });
     const wasMentioned = options?.forceWasMentioned === true ? true : computedWasMentioned;
     if (isGroup && commandGate.shouldBlock) {
@@ -264,14 +308,6 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
         });
         return null;
     }
-    const activationOverride = resolveGroupActivation({
-        chatId,
-        messageThreadId: resolvedThreadId,
-        sessionKey: sessionKey,
-        agentId: route.agentId,
-    });
-    const baseRequireMention = resolveGroupRequireMention(chatId);
-    const requireMention = firstDefined(activationOverride, topicConfig?.requireMention, groupConfig?.requireMention, baseRequireMention);
     // Reply-chain detection: replying to a bot message acts like an implicit mention.
     const botId = primaryCtx.me?.id;
     const replyFromId = msg.reply_to_message?.from?.id;
@@ -309,7 +345,10 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
         }
     }
     // ACK reactions
-    const ackReaction = resolveAckReaction(cfg, route.agentId);
+    const ackReaction = resolveAckReaction(cfg, route.agentId, {
+        channel: "telegram",
+        accountId: account.accountId,
+    });
     const removeAckAfterReply = cfg.messages?.removeAckAfterReply ?? false;
     const shouldAckReaction = () => Boolean(ackReaction &&
         shouldAckReactionGate({
@@ -404,8 +443,10 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
         : undefined;
     const ctxPayload = finalizeInboundContext({
         Body: combinedBody,
-        RawBody: rawBody,
+        // Agent prompt should be the raw user text only; metadata/context is provided via system prompt.
         BodyForAgent: bodyText,
+        InboundHistory: inboundHistory,
+        RawBody: rawBody,
         CommandBody: commandBody,
         From: isGroup ? buildTelegramGroupFrom(chatId, resolvedThreadId) : `telegram:${chatId}`,
         To: `telegram:${chatId}`,
@@ -458,7 +499,7 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
         Sticker: allMedia[0]?.stickerMetadata,
         ...(locationData ? toLocationContext(locationData) : undefined),
         CommandAuthorized: commandAuthorized,
-        InboundHistory: inboundHistory,
+        // For groups: use resolved forum topic id; for DMs: use raw messageThreadId
         MessageThreadId: threadSpec.id,
         IsForum: isForum,
         // Originating channel for reply routing.
@@ -475,6 +516,7 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
                 channel: "telegram",
                 to: String(chatId),
                 accountId: route.accountId,
+                // Preserve DM topic threadId for replies (fixes #8891)
                 threadId: dmThreadId != null ? String(dmThreadId) : undefined,
             }
             : undefined,