@poolzin/pool-bot 2026.2.24 → 2026.2.26

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

@@ -6,6 +6,7 @@ import { listSkillCommandsForAgents } from "../auto-reply/skill-commands.js";
 import { resolveCommandAuthorizedFromAuthorizers } from "../channels/command-gating.js";
 import { createReplyPrefixOptions } from "../channels/reply-prefix.js";
 import { resolveMarkdownTableMode } from "../config/markdown-tables.js";
+import { recordSessionMetaFromInbound, resolveStorePath } from "../config/sessions.js";
 import { normalizeTelegramCommandName, resolveTelegramCustomCommands, TELEGRAM_COMMAND_NAME_PATTERN, } from "../config/telegram-custom-commands.js";
 import { danger, logVerbose } from "../globals.js";
 import { getAgentScopedMediaLocalRoots } from "../media/local-roots.js";
@@ -29,6 +30,7 @@ async function resolveTelegramCommandAuth(params) {
     const groupAllowContext = await resolveTelegramGroupAllowFromContext({
         chatId,
         accountId,
+        dmPolicy: telegramCfg.dmPolicy ?? "pairing",
         isForum,
         messageThreadId,
         groupAllowFrom,
@@ -100,6 +102,7 @@ async function resolveTelegramCommandAuth(params) {
     const dmAllow = normalizeAllowFromWithStore({
         allowFrom: allowFrom,
         storeAllowFrom,
+        dmPolicy: telegramCfg.dmPolicy ?? "pairing",
     });
     const senderAllowed = isSenderAllowed({
         allow: dmAllow,
@@ -377,6 +380,19 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                         OriginatingChannel: "telegram",
                         OriginatingTo: `telegram:${chatId}`,
                     });
+                    const storePath = resolveStorePath(cfg.session?.store, {
+                        agentId: route.agentId,
+                    });
+                    try {
+                        await recordSessionMetaFromInbound({
+                            storePath,
+                            sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+                            ctx: ctxPayload,
+                        });
+                    }
+                    catch (err) {
+                        runtime.error?.(danger(`telegram slash: failed updating session meta: ${String(err)}`));
+                    }
                     const disableBlockStreaming = typeof telegramCfg.blockStreaming === "boolean"
                         ? !telegramCfg.blockStreaming
                         : undefined;

package/dist/telegram/draft-stream.js

@@ -13,8 +13,10 @@ export function createTelegramDraftStream(params) {
         : threadParams;
     let streamMessageId;
     let lastSentText = "";
+    let lastSentParseMode;
     let stopped = false;
     let isFinal = false;
+    let generation = 0;
     const sendOrEditStreamMessage = async (text) => {
         // Allow final flush even if stopped (e.g., after clear()).
         if (stopped && !isFinal) {
@@ -24,36 +26,66 @@ export function createTelegramDraftStream(params) {
         if (!trimmed) {
             return false;
         }
-        if (trimmed.length > maxChars) {
+        const rendered = params.renderText?.(trimmed) ?? { text: trimmed };
+        const renderedText = rendered.text.trimEnd();
+        const renderedParseMode = rendered.parseMode;
+        if (!renderedText) {
+            return false;
+        }
+        if (renderedText.length > maxChars) {
             // Telegram text messages/edits cap at 4096 chars.
             // Stop streaming once we exceed the cap to avoid repeated API failures.
             stopped = true;
-            params.warn?.(`telegram stream preview stopped (text length ${trimmed.length} > ${maxChars})`);
+            params.warn?.(`telegram stream preview stopped (text length ${renderedText.length} > ${maxChars})`);
             return false;
         }
-        if (trimmed === lastSentText) {
+        if (renderedText === lastSentText && renderedParseMode === lastSentParseMode) {
             return true;
         }
+        const sendGeneration = generation;
         // Debounce first preview send for better push notification quality.
         if (typeof streamMessageId !== "number" && minInitialChars != null && !isFinal) {
-            if (trimmed.length < minInitialChars) {
+            if (renderedText.length < minInitialChars) {
                 return false;
             }
         }
-        lastSentText = trimmed;
+        lastSentText = renderedText;
+        lastSentParseMode = renderedParseMode;
         try {
             if (typeof streamMessageId === "number") {
-                await params.api.editMessageText(chatId, streamMessageId, trimmed);
+                if (renderedParseMode) {
+                    await params.api.editMessageText(chatId, streamMessageId, renderedText, {
+                        parse_mode: renderedParseMode,
+                    });
+                }
+                else {
+                    await params.api.editMessageText(chatId, streamMessageId, renderedText);
+                }
                 return true;
             }
-            const sent = await params.api.sendMessage(chatId, trimmed, replyParams);
+            const sendParams = renderedParseMode
+                ? {
+                    ...replyParams,
+                    parse_mode: renderedParseMode,
+                }
+                : replyParams;
+            const sent = await params.api.sendMessage(chatId, renderedText, sendParams);
             const sentMessageId = sent?.message_id;
             if (typeof sentMessageId !== "number" || !Number.isFinite(sentMessageId)) {
                 stopped = true;
                 params.warn?.("telegram stream preview stopped (missing message id from sendMessage)");
                 return false;
             }
-            streamMessageId = Math.trunc(sentMessageId);
+            const normalizedMessageId = Math.trunc(sentMessageId);
+            if (sendGeneration !== generation) {
+                params.onSupersededPreview?.({
+                    messageId: normalizedMessageId,
+                    textSnapshot: renderedText,
+                    parseMode: renderedParseMode,
+                });
+                return true;
+            }
+            streamMessageId = normalizedMessageId;
             return true;
         }
         catch (err) {
@@ -88,15 +120,19 @@ export function createTelegramDraftStream(params) {
         }
         try {
             await params.api.deleteMessage(chatId, messageId);
+            params.log?.(`telegram stream preview deleted (chat=${chatId}, message=${messageId})`);
         }
         catch (err) {
             params.warn?.(`telegram stream preview cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
         }
     };
     const forceNewMessage = () => {
+        generation += 1;
         streamMessageId = undefined;
         lastSentText = "";
+        lastSentParseMode = undefined;
         loop.resetPending();
+        loop.resetThrottleWindow();
     };
     params.log?.(`telegram stream preview ready (maxChars=${maxChars}, throttleMs=${throttleMs})`);
     return {

package/dist/telegram/inline-buttons.js

@@ -1,9 +1,9 @@
 import { listTelegramAccountIds, resolveTelegramAccount } from "./accounts.js";
-import { parseTelegramTarget } from "./targets.js";
 const DEFAULT_INLINE_BUTTONS_SCOPE = "allowlist";
 function normalizeInlineButtonsScope(value) {
-    if (typeof value !== "string")
+    if (typeof value !== "string") {
         return undefined;
+    }
     const trimmed = value.trim().toLowerCase();
     if (trimmed === "off" ||
         trimmed === "dm" ||
@@ -15,8 +15,9 @@ function normalizeInlineButtonsScope(value) {
     return undefined;
 }
 function resolveInlineButtonsScopeFromCapabilities(capabilities) {
-    if (!capabilities)
+    if (!capabilities) {
         return DEFAULT_INLINE_BUTTONS_SCOPE;
+    }
     if (Array.isArray(capabilities)) {
         const enabled = capabilities.some((entry) => String(entry).trim().toLowerCase() === "inlinebuttons");
         return enabled ? "all" : "off";
@@ -41,15 +42,4 @@ export function isTelegramInlineButtonsEnabled(params) {
     }
     return accountIds.some((accountId) => resolveTelegramInlineButtonsScope({ cfg: params.cfg, accountId }) !== "off");
 }
-export function resolveTelegramTargetChatType(target) {
-    if (!target.trim())
-        return "unknown";
-    const parsed = parseTelegramTarget(target);
-    const chatId = parsed.chatId.trim();
-    if (!chatId)
-        return "unknown";
-    if (/^-?\d+$/.test(chatId)) {
-        return chatId.startsWith("-") ? "group" : "direct";
-    }
-    return "unknown";
-}
+export { resolveTelegramTargetChatType } from "./targets.js";

package/dist/telegram/monitor.js

@@ -39,12 +39,14 @@ const TELEGRAM_POLL_RESTART_POLICY = {
     jitter: 0.25,
 };
 const isGetUpdatesConflict = (err) => {
-    if (!err || typeof err !== "object")
+    if (!err || typeof err !== "object") {
         return false;
+    }
     const typed = err;
     const errorCode = typed.error_code ?? typed.errorCode;
-    if (errorCode !== 409)
+    if (errorCode !== 409) {
         return false;
+    }
     const haystack = [typed.method, typed.description, typed.message]
         .filter((value) => typeof value === "string")
         .join(" ")
@@ -81,14 +83,14 @@ export async function monitorTelegramProvider(opts = {}) {
         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);
+        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)
+            if (lastUpdateId !== null && updateId <= lastUpdateId) {
                 return;
+            }
             lastUpdateId = updateId;
             try {
                 await writeTelegramUpdateOffset({
@@ -118,7 +120,8 @@ export async function monitorTelegramProvider(opts = {}) {
                 config: cfg,
                 path: opts.webhookPath,
                 port: opts.webhookPort,
-                secret: opts.webhookSecret,
+                secret: opts.webhookSecret ?? account.config.webhookSecret,
+                host: opts.webhookHost ?? account.config.webhookHost,
                 runtime: opts.runtime,
                 fetch: proxyFetch,
                 abortSignal: opts.abortSignal,
@@ -159,8 +162,9 @@ export async function monitorTelegramProvider(opts = {}) {
                     await sleepWithAbort(delayMs, opts.abortSignal);
                 }
                 catch (sleepErr) {
-                    if (opts.abortSignal?.aborted)
+                    if (opts.abortSignal?.aborted) {
                         return;
+                    }
                     throw sleepErr;
                 }
             }

package/dist/telegram/network-config.js

@@ -1,27 +1,39 @@
 import process from "node:process";
 import { isTruthyEnvValue } from "../infra/env.js";
+import { isWSL2Sync } from "../infra/wsl.js";
 export const TELEGRAM_DISABLE_AUTO_SELECT_FAMILY_ENV = "POOLBOT_TELEGRAM_DISABLE_AUTO_SELECT_FAMILY";
 export const TELEGRAM_ENABLE_AUTO_SELECT_FAMILY_ENV = "POOLBOT_TELEGRAM_ENABLE_AUTO_SELECT_FAMILY";
-const TELEGRAM_DISABLE_AUTO_SELECT_FAMILY_ENV_LEGACY = "CLAWDBOT_TELEGRAM_DISABLE_AUTO_SELECT_FAMILY";
-const TELEGRAM_ENABLE_AUTO_SELECT_FAMILY_ENV_LEGACY = "CLAWDBOT_TELEGRAM_ENABLE_AUTO_SELECT_FAMILY";
+let wsl2SyncCache;
+function isWSL2SyncCached() {
+    if (typeof wsl2SyncCache === "boolean") {
+        return wsl2SyncCache;
+    }
+    wsl2SyncCache = isWSL2Sync();
+    return wsl2SyncCache;
+}
 export function resolveTelegramAutoSelectFamilyDecision(params) {
     const env = params?.env ?? process.env;
     const nodeMajor = typeof params?.nodeMajor === "number"
         ? params.nodeMajor
         : Number(process.versions.node.split(".")[0]);
-    if (isTruthyEnvValue(env[TELEGRAM_ENABLE_AUTO_SELECT_FAMILY_ENV]) ||
-        isTruthyEnvValue(env[TELEGRAM_ENABLE_AUTO_SELECT_FAMILY_ENV_LEGACY])) {
+    if (isTruthyEnvValue(env[TELEGRAM_ENABLE_AUTO_SELECT_FAMILY_ENV])) {
         return { value: true, source: `env:${TELEGRAM_ENABLE_AUTO_SELECT_FAMILY_ENV}` };
     }
-    if (isTruthyEnvValue(env[TELEGRAM_DISABLE_AUTO_SELECT_FAMILY_ENV]) ||
-        isTruthyEnvValue(env[TELEGRAM_DISABLE_AUTO_SELECT_FAMILY_ENV_LEGACY])) {
+    if (isTruthyEnvValue(env[TELEGRAM_DISABLE_AUTO_SELECT_FAMILY_ENV])) {
         return { value: false, source: `env:${TELEGRAM_DISABLE_AUTO_SELECT_FAMILY_ENV}` };
     }
     if (typeof params?.network?.autoSelectFamily === "boolean") {
         return { value: params.network.autoSelectFamily, source: "config" };
     }
+    // WSL2 has unstable IPv6 connectivity; disable autoSelectFamily to use IPv4 directly
+    if (isWSL2SyncCached()) {
+        return { value: false, source: "default-wsl2" };
+    }
     if (Number.isFinite(nodeMajor) && nodeMajor >= 22) {
-        return { value: false, source: "default-node22" };
+        return { value: true, source: "default-node22" };
     }
     return { value: null };
 }
+export function resetTelegramNetworkConfigStateForTests() {
+    wsl2SyncCache = undefined;
+}

package/dist/telegram/reasoning-lane-coordinator.js

@@ -0,0 +1,128 @@
+import { formatReasoningMessage } from "../agents/pi-embedded-utils.js";
+import { stripReasoningTagsFromText } from "../shared/text/reasoning-tags.js";
+const REASONING_MESSAGE_PREFIX = "Reasoning:\n";
+const REASONING_TAG_PREFIXES = [
+    "<think",
+    "<thinking",
+    "<thought",
+    "<antthinking",
+    "</think",
+    "</thinking",
+    "</thought",
+    "</antthinking",
+];
+const THINKING_TAG_RE = /<\s*(\/?)\s*(?:think(?:ing)?|thought|antthinking)\b[^<>]*>/gi;
+function findCodeRegions(text) {
+    const regions = [];
+    const fencedRe = /(^|\n)(```|~~~)[^\n]*\n[\s\S]*?(?:\n\2(?:\n|$)|$)/g;
+    for (const match of text.matchAll(fencedRe)) {
+        const start = (match.index ?? 0) + match[1].length;
+        regions.push({ start, end: start + match[0].length - match[1].length });
+    }
+    const inlineRe = /`+[^`]+`+/g;
+    for (const match of text.matchAll(inlineRe)) {
+        const start = match.index ?? 0;
+        const end = start + match[0].length;
+        const insideFenced = regions.some((r) => start >= r.start && end <= r.end);
+        if (!insideFenced) {
+            regions.push({ start, end });
+        }
+    }
+    regions.sort((a, b) => a.start - b.start);
+    return regions;
+}
+function isInsideCode(pos, regions) {
+    return regions.some((r) => pos >= r.start && pos < r.end);
+}
+function extractThinkingFromTaggedStreamOutsideCode(text) {
+    if (!text) {
+        return "";
+    }
+    const codeRegions = findCodeRegions(text);
+    let result = "";
+    let lastIndex = 0;
+    let inThinking = false;
+    THINKING_TAG_RE.lastIndex = 0;
+    for (const match of text.matchAll(THINKING_TAG_RE)) {
+        const idx = match.index ?? 0;
+        if (isInsideCode(idx, codeRegions)) {
+            continue;
+        }
+        if (inThinking) {
+            result += text.slice(lastIndex, idx);
+        }
+        const isClose = match[1] === "/";
+        inThinking = !isClose;
+        lastIndex = idx + match[0].length;
+    }
+    if (inThinking) {
+        result += text.slice(lastIndex);
+    }
+    return result.trim();
+}
+function isPartialReasoningTagPrefix(text) {
+    const trimmed = text.trimStart().toLowerCase();
+    if (!trimmed.startsWith("<")) {
+        return false;
+    }
+    if (trimmed.includes(">")) {
+        return false;
+    }
+    return REASONING_TAG_PREFIXES.some((prefix) => prefix.startsWith(trimmed));
+}
+export function splitTelegramReasoningText(text) {
+    if (typeof text !== "string") {
+        return {};
+    }
+    const trimmed = text.trim();
+    if (isPartialReasoningTagPrefix(trimmed)) {
+        return {};
+    }
+    if (trimmed.startsWith(REASONING_MESSAGE_PREFIX) &&
+        trimmed.length > REASONING_MESSAGE_PREFIX.length) {
+        return { reasoningText: trimmed };
+    }
+    const taggedReasoning = extractThinkingFromTaggedStreamOutsideCode(text);
+    const strippedAnswer = stripReasoningTagsFromText(text, { mode: "strict", trim: "both" });
+    if (!taggedReasoning && strippedAnswer === text) {
+        return { answerText: text };
+    }
+    const reasoningText = taggedReasoning ? formatReasoningMessage(taggedReasoning) : undefined;
+    const answerText = strippedAnswer || undefined;
+    return { reasoningText, answerText };
+}
+export function createTelegramReasoningStepState() {
+    let reasoningStatus = "none";
+    let bufferedFinalAnswer;
+    const noteReasoningHint = () => {
+        if (reasoningStatus === "none") {
+            reasoningStatus = "hinted";
+        }
+    };
+    const noteReasoningDelivered = () => {
+        reasoningStatus = "delivered";
+    };
+    const shouldBufferFinalAnswer = () => {
+        return reasoningStatus === "hinted" && !bufferedFinalAnswer;
+    };
+    const bufferFinalAnswer = (value) => {
+        bufferedFinalAnswer = value;
+    };
+    const takeBufferedFinalAnswer = () => {
+        const value = bufferedFinalAnswer;
+        bufferedFinalAnswer = undefined;
+        return value;
+    };
+    const resetForNextStep = () => {
+        reasoningStatus = "none";
+        bufferedFinalAnswer = undefined;
+    };
+    return {
+        noteReasoningHint,
+        noteReasoningDelivered,
+        shouldBufferFinalAnswer,
+        bufferFinalAnswer,
+        takeBufferedFinalAnswer,
+        resetForNextStep,
+    };
+}

package/dist/telegram/send.js

@@ -27,6 +27,7 @@ const PARSE_ERR_RE = /can't parse entities|parse entities|find end of the entity
 const THREAD_NOT_FOUND_RE = /400:\s*Bad Request:\s*message thread not found/i;
 const MESSAGE_NOT_MODIFIED_RE = /400:\s*Bad Request:\s*message is not modified|MESSAGE_NOT_MODIFIED/i;
 const CHAT_NOT_FOUND_RE = /400: Bad Request: chat not found/i;
+const sendLogger = createSubsystemLogger("telegram/send");
 const diagLogger = createSubsystemLogger("telegram/diagnostic");
 function createTelegramHttpLogger(cfg) {
     const enabled = isDiagnosticFlagEnabled("telegram.http", cfg);
@@ -176,7 +177,7 @@ async function withTelegramHtmlParseFallback(params) {
             throw err;
         }
         if (params.verbose) {
-            console.warn(`telegram ${params.label} failed with HTML parse error, retrying as plain text: ${formatErrorMessage(err)}`);
+            sendLogger.warn(`telegram ${params.label} failed with HTML parse error, retrying as plain text: ${formatErrorMessage(err)}`);
         }
         return await params.requestPlain(`${params.label}-plain`);
     }
@@ -236,7 +237,7 @@ async function withTelegramThreadFallback(params, label, verbose, attempt) {
             throw err;
         }
         if (verbose) {
-            console.warn(`telegram ${label} failed with message_thread_id, retrying without thread: ${formatErrorMessage(err)}`);
+            sendLogger.warn(`telegram ${label} failed with message_thread_id, retrying without thread: ${formatErrorMessage(err)}`);
         }
         const retriedParams = removeMessageThreadIdParam(params);
         return await attempt(retriedParams, `${label}-threadless`);

package/dist/telegram/sent-message-cache.js

@@ -11,7 +11,6 @@ function cleanupExpired(entry) {
     const now = Date.now();
     for (const [msgId, timestamp] of entry.timestamps) {
         if (now - timestamp > TTL_MS) {
-            entry.messageIds.delete(msgId);
             entry.timestamps.delete(msgId);
         }
     }
@@ -23,13 +22,12 @@ export function recordSentMessage(chatId, messageId) {
     const key = getChatKey(chatId);
     let entry = sentMessages.get(key);
     if (!entry) {
-        entry = { messageIds: new Set(), timestamps: new Map() };
+        entry = { timestamps: new Map() };
         sentMessages.set(key, entry);
     }
-    entry.messageIds.add(messageId);
     entry.timestamps.set(messageId, Date.now());
     // Periodic cleanup
-    if (entry.messageIds.size > 100) {
+    if (entry.timestamps.size > 100) {
         cleanupExpired(entry);
     }
 }
@@ -39,11 +37,12 @@ export function recordSentMessage(chatId, messageId) {
 export function wasSentByBot(chatId, messageId) {
     const key = getChatKey(chatId);
     const entry = sentMessages.get(key);
-    if (!entry)
+    if (!entry) {
         return false;
+    }
     // Clean up expired entries on read
     cleanupExpired(entry);
-    return entry.messageIds.has(messageId);
+    return entry.timestamps.has(messageId);
 }
 /**
  * Clear all cached entries (for testing).