@poolzin/pool-bot 2026.2.25 → 2026.2.26

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).

package/dist/telegram/status-reaction-variants.js

@@ -0,0 +1,208 @@
+import { DEFAULT_EMOJIS } from "../channels/status-reactions.js";
+const TELEGRAM_GENERIC_REACTION_FALLBACKS = ["👍", "👀", "🔥"];
+const TELEGRAM_SUPPORTED_REACTION_EMOJIS = new Set([
+    "❤",
+    "👍",
+    "👎",
+    "🔥",
+    "🥰",
+    "👏",
+    "😁",
+    "🤔",
+    "🤯",
+    "😱",
+    "🤬",
+    "😢",
+    "🎉",
+    "🤩",
+    "🤮",
+    "💩",
+    "🙏",
+    "👌",
+    "🕊",
+    "🤡",
+    "🥱",
+    "🥴",
+    "😍",
+    "🐳",
+    "❤‍🔥",
+    "🌚",
+    "🌭",
+    "💯",
+    "🤣",
+    "⚡",
+    "🍌",
+    "🏆",
+    "💔",
+    "🤨",
+    "😐",
+    "🍓",
+    "🍾",
+    "💋",
+    "🖕",
+    "😈",
+    "😴",
+    "😭",
+    "🤓",
+    "👻",
+    "👨‍💻",
+    "👀",
+    "🎃",
+    "🙈",
+    "😇",
+    "😨",
+    "🤝",
+    "✍",
+    "🤗",
+    "🫡",
+    "🎅",
+    "🎄",
+    "☃",
+    "💅",
+    "🤪",
+    "🗿",
+    "🆒",
+    "💘",
+    "🙉",
+    "🦄",
+    "😘",
+    "💊",
+    "🙊",
+    "😎",
+    "👾",
+    "🤷‍♂",
+    "🤷",
+    "🤷‍♀",
+    "😡",
+]);
+export const TELEGRAM_STATUS_REACTION_VARIANTS = {
+    queued: ["👀", "👍", "🔥"],
+    thinking: ["🤔", "🤓", "👀"],
+    tool: ["🔥", "⚡", "👍"],
+    coding: ["👨‍💻", "🔥", "⚡"],
+    web: ["⚡", "🔥", "👍"],
+    done: ["👍", "🎉", "💯"],
+    error: ["😱", "😨", "🤯"],
+    stallSoft: ["🥱", "😴", "🤔"],
+    stallHard: ["😨", "😱", "⚡"],
+};
+const STATUS_REACTION_EMOJI_KEYS = [
+    "queued",
+    "thinking",
+    "tool",
+    "coding",
+    "web",
+    "done",
+    "error",
+    "stallSoft",
+    "stallHard",
+];
+function normalizeEmoji(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function toUniqueNonEmpty(values) {
+    return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean)));
+}
+export function resolveTelegramStatusReactionEmojis(params) {
+    const { overrides } = params;
+    const queuedFallback = normalizeEmoji(params.initialEmoji) ?? DEFAULT_EMOJIS.queued;
+    return {
+        queued: normalizeEmoji(overrides?.queued) ?? queuedFallback,
+        thinking: normalizeEmoji(overrides?.thinking) ?? DEFAULT_EMOJIS.thinking,
+        tool: normalizeEmoji(overrides?.tool) ?? DEFAULT_EMOJIS.tool,
+        coding: normalizeEmoji(overrides?.coding) ?? DEFAULT_EMOJIS.coding,
+        web: normalizeEmoji(overrides?.web) ?? DEFAULT_EMOJIS.web,
+        done: normalizeEmoji(overrides?.done) ?? DEFAULT_EMOJIS.done,
+        error: normalizeEmoji(overrides?.error) ?? DEFAULT_EMOJIS.error,
+        stallSoft: normalizeEmoji(overrides?.stallSoft) ?? DEFAULT_EMOJIS.stallSoft,
+        stallHard: normalizeEmoji(overrides?.stallHard) ?? DEFAULT_EMOJIS.stallHard,
+    };
+}
+export function buildTelegramStatusReactionVariants(emojis) {
+    const variantsByRequested = new Map();
+    for (const key of STATUS_REACTION_EMOJI_KEYS) {
+        const requested = normalizeEmoji(emojis[key]);
+        if (!requested) {
+            continue;
+        }
+        const fallbackVariants = TELEGRAM_STATUS_REACTION_VARIANTS[key] ?? [];
+        const candidates = toUniqueNonEmpty([requested, ...fallbackVariants]);
+        variantsByRequested.set(requested, candidates);
+    }
+    return variantsByRequested;
+}
+export function isTelegramSupportedReactionEmoji(emoji) {
+    return TELEGRAM_SUPPORTED_REACTION_EMOJIS.has(emoji);
+}
+export function extractTelegramAllowedEmojiReactions(chat) {
+    if (!chat || typeof chat !== "object") {
+        return undefined;
+    }
+    if (!Object.prototype.hasOwnProperty.call(chat, "available_reactions")) {
+        return undefined;
+    }
+    const availableReactions = chat.available_reactions;
+    if (availableReactions == null) {
+        // Explicitly omitted/null => all emoji reactions are allowed in this chat.
+        return null;
+    }
+    if (!Array.isArray(availableReactions)) {
+        return new Set();
+    }
+    const allowed = new Set();
+    for (const reaction of availableReactions) {
+        if (!reaction || typeof reaction !== "object") {
+            continue;
+        }
+        const typedReaction = reaction;
+        if (typedReaction.type !== "emoji" || typeof typedReaction.emoji !== "string") {
+            continue;
+        }
+        const emoji = typedReaction.emoji.trim();
+        if (emoji) {
+            allowed.add(emoji);
+        }
+    }
+    return allowed;
+}
+export async function resolveTelegramAllowedEmojiReactions(params) {
+    const fromMessage = extractTelegramAllowedEmojiReactions(params.chat);
+    if (fromMessage !== undefined) {
+        return fromMessage;
+    }
+    if (params.getChat) {
+        try {
+            const chatInfo = await params.getChat(params.chatId);
+            const fromLookup = extractTelegramAllowedEmojiReactions(chatInfo);
+            if (fromLookup !== undefined) {
+                return fromLookup;
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    // If unavailable, assume no explicit restriction.
+    return null;
+}
+export function resolveTelegramReactionVariant(params) {
+    const requestedEmoji = normalizeEmoji(params.requestedEmoji);
+    if (!requestedEmoji) {
+        return undefined;
+    }
+    const configuredVariants = params.variantsByRequestedEmoji.get(requestedEmoji) ?? [
+        requestedEmoji,
+    ];
+    const variants = toUniqueNonEmpty([
+        ...configuredVariants,
+        ...TELEGRAM_GENERIC_REACTION_FALLBACKS,
+    ]);
+    for (const candidate of variants) {
+        const isAllowedByChat = params.allowedEmojiReactions == null || params.allowedEmojiReactions.has(candidate);
+        if (isAllowedByChat && isTelegramSupportedReactionEmoji(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}

package/dist/telegram/sticker-cache.js

@@ -1,11 +1,11 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { STATE_DIR } from "../config/paths.js";
-import { loadJsonFile, saveJsonFile } from "../infra/json-file.js";
-import { logVerbose } from "../globals.js";
-import { findModelInCatalog, loadModelCatalog, modelSupportsVision, } from "../agents/model-catalog.js";
 import { resolveApiKeyForProvider } from "../agents/model-auth.js";
+import { findModelInCatalog, loadModelCatalog, modelSupportsVision, } from "../agents/model-catalog.js";
 import { resolveDefaultModelForAgent } from "../agents/model-selection.js";
+import { STATE_DIR } from "../config/paths.js";
+import { logVerbose } from "../globals.js";
+import { loadJsonFile, saveJsonFile } from "../infra/json-file.js";
 import { resolveAutoImageModel } from "../media-understanding/runner.js";
 const CACHE_FILE = path.join(STATE_DIR, "telegram", "sticker-cache.json");
 const CACHE_VERSION = 1;
@@ -74,7 +74,7 @@ export function searchStickers(query, limit = 10) {
         }
     }
     return results
-        .sort((a, b) => b.score - a.score)
+        .toSorted((a, b) => b.score - a.score)
         .slice(0, limit)
         .map((r) => r.sticker);
 }
@@ -94,7 +94,7 @@ export function getCacheStats() {
     if (stickers.length === 0) {
         return { count: 0 };
     }
-    const sorted = [...stickers].sort((a, b) => new Date(a.cachedAt).getTime() - new Date(b.cachedAt).getTime());
+    const sorted = [...stickers].toSorted((a, b) => new Date(a.cachedAt).getTime() - new Date(b.cachedAt).getTime());
     return {
         count: stickers.length,
         oldestAt: sorted[0]?.cachedAt,
@@ -135,12 +135,13 @@ export async function describeStickerImage(params) {
     };
     const selectCatalogModel = (provider) => {
         const entries = catalog.filter((entry) => entry.provider.toLowerCase() === provider.toLowerCase() && modelSupportsVision(entry));
-        if (entries.length === 0)
+        if (entries.length === 0) {
             return undefined;
+        }
         const defaultId = provider === "openai"
             ? "gpt-5-mini"
             : provider === "anthropic"
-                ? "claude-opus-4-5"
+                ? "claude-opus-4-6"
                 : provider === "google"
                     ? "gemini-3-flash-preview"
                     : "MiniMax-VL-01";
@@ -155,8 +156,9 @@ export async function describeStickerImage(params) {
     }
     if (!resolved) {
         for (const provider of VISION_PROVIDERS) {
-            if (!(await hasProviderKey(provider)))
+            if (!(await hasProviderKey(provider))) {
                 continue;
+            }
             const entry = selectCatalogModel(provider);
             if (entry) {
                 resolved = { provider, model: entry.id };

package/dist/terminal/theme.js

@@ -1,22 +1,22 @@
 import chalk, { Chalk } from "chalk";
-import { POOLBOT_PALETTE } from "./palette.js";
+import { LOBSTER_PALETTE } from "./palette.js";
 const hasForceColor = typeof process.env.FORCE_COLOR === "string" &&
     process.env.FORCE_COLOR.trim().length > 0 &&
     process.env.FORCE_COLOR.trim() !== "0";
 const baseChalk = process.env.NO_COLOR && !hasForceColor ? new Chalk({ level: 0 }) : chalk;
 const hex = (value) => baseChalk.hex(value);
 export const theme = {
-    accent: hex(POOLBOT_PALETTE.accent),
-    accentBright: hex(POOLBOT_PALETTE.accentBright),
-    accentDim: hex(POOLBOT_PALETTE.accentDim),
-    info: hex(POOLBOT_PALETTE.info),
-    success: hex(POOLBOT_PALETTE.success),
-    warn: hex(POOLBOT_PALETTE.warn),
-    error: hex(POOLBOT_PALETTE.error),
-    muted: hex(POOLBOT_PALETTE.muted),
-    heading: baseChalk.bold.hex(POOLBOT_PALETTE.accent),
-    command: hex(POOLBOT_PALETTE.accentBright),
-    option: hex(POOLBOT_PALETTE.info),
+    accent: hex(LOBSTER_PALETTE.accent),
+    accentBright: hex(LOBSTER_PALETTE.accentBright),
+    accentDim: hex(LOBSTER_PALETTE.accentDim),
+    info: hex(LOBSTER_PALETTE.info),
+    success: hex(LOBSTER_PALETTE.success),
+    warn: hex(LOBSTER_PALETTE.warn),
+    error: hex(LOBSTER_PALETTE.error),
+    muted: hex(LOBSTER_PALETTE.muted),
+    heading: baseChalk.bold.hex(LOBSTER_PALETTE.accent),
+    command: hex(LOBSTER_PALETTE.accentBright),
+    option: hex(LOBSTER_PALETTE.warn),
 };
 export const isRich = () => Boolean(baseChalk.level > 0);
 export const colorize = (rich, color, value) => rich ? color(value) : value;