@iletai/nzb 1.6.4 → 1.7.3

package/dist/telegram/handlers/streaming.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { InlineKeyboard } from "grammy";
 import { config } from "../../config.js";
 import { getQueueSize, sendToOrchestrator } from "../../copilot/orchestrator.js";
@@ -56,6 +57,18 @@ export function registerMessageHandler(bot, getBot) {
             }
         };
         await startTyping();
+        // Safety timeout — force-stop typing if orchestrator hangs
+        const MAX_TYPING_MS = 120_000; // 2 minutes
+        const typingTimeout = setTimeout(() => {
+            if (!typingStopped) {
+                console.log("[nzb] Typing indicator timeout, force stopping");
+                stopTyping();
+            }
+        }, MAX_TYPING_MS);
+        const stopTypingAndClearTimeout = () => {
+            stopTyping();
+            clearTimeout(typingTimeout);
+        };
         // Progressive streaming state — all Telegram API calls are serialized through editChain
         // to prevent duplicate placeholder messages and race conditions
         let placeholderMsgId;
@@ -75,6 +88,7 @@ export function registerMessageHandler(bot, getBot) {
         // prevents push notification spam for very short initial chunks (inspired by OpenClaw's draft-stream).
         const MIN_INITIAL_CHARS = 80;
         const handlerStartTime = Date.now();
+        const requestId = randomUUID();
         const enqueueEdit = (text) => {
             if (finalized || text === lastEditedText)
                 return;
@@ -102,13 +116,15 @@ export function registerMessageHandler(bot, getBot) {
                         const msg = await ctx.reply(safeText, { reply_parameters: replyParams });
                         placeholderMsgId = msg.message_id;
                         // Stop typing once placeholder is visible — edits serve as the indicator now
-                        stopTyping();
+                        stopTypingAndClearTimeout();
                     }
                     catch {
                         return;
                     }
                 }
                 else {
+                    if (finalized)
+                        return;
                     try {
                         await editSafe(getBot().api, chatId, placeholderMsgId, safeText);
                     }
@@ -121,7 +137,9 @@ export function registerMessageHandler(bot, getBot) {
                 }
                 lastEditedText = safeText;
             })
-                .catch(() => { });
+                .catch((err) => {
+                console.error("[nzb] Edit chain error:", err instanceof Error ? err.message : err);
+            });
         };
         const onToolEvent = (event) => {
             console.log(`[nzb] Bot received tool event: ${event.type} ${event.toolName}`);
@@ -194,106 +212,73 @@ export function registerMessageHandler(bot, getBot) {
                 userPrompt = `[Replying to: "${quoted}"]\n\n${userPrompt}`;
             }
         }
-        sendToOrchestrator(userPrompt, { type: "telegram", chatId, messageId: userMessageId }, (text, done, meta) => {
-            if (done) {
-                finalized = true;
-                stopTyping();
-                const assistantLogId = meta?.assistantLogId;
-                const elapsed = ((Date.now() - handlerStartTime) / 1000).toFixed(1);
-                void logInfo(`✅ Response done (${elapsed}s, ${toolHistory.length} tools, ${text.length} chars)`);
-                // Return the edit chain so callers can await final delivery
-                return editChain.then(async () => {
-                    // Format error messages with a distinct visual
-                    const isError = text.startsWith("Error:");
-                    if (isError) {
-                        void logError(`Response error: ${text.slice(0, 200)}`);
-                        const errorText = `⚠️ ${text}`;
-                        const errorKb = new InlineKeyboard().text("🔄 Retry", "retry").text("📖 Explain", "explain_error");
-                        if (placeholderMsgId) {
-                            try {
-                                await editSafe(getBot().api, chatId, placeholderMsgId, errorText, { reply_markup: errorKb });
-                                return;
-                            }
-                            catch {
-                                /* fall through */
-                            }
-                        }
-                        try {
-                            await ctx.reply(errorText, { reply_parameters: replyParams, reply_markup: errorKb });
-                        }
-                        catch {
-                            /* nothing more we can do */
-                        }
-                        return;
-                    }
-                    let textWithMeta = text;
-                    if (usageInfo && config.usageMode !== "off") {
-                        const fmtTokens = (n) => (n >= 1000 ? `${(n / 1000).toFixed(1)}K` : String(n));
-                        const parts = [];
-                        if (config.usageMode === "full" && usageInfo.model)
-                            parts.push(usageInfo.model);
-                        parts.push(`⬆${fmtTokens(usageInfo.inputTokens)} ⬇${fmtTokens(usageInfo.outputTokens)}`);
-                        const totalTokens = usageInfo.inputTokens + usageInfo.outputTokens;
-                        parts.push(`Σ${fmtTokens(totalTokens)}`);
-                        if (config.usageMode === "full" && usageInfo.duration)
-                            parts.push(`${(usageInfo.duration / 1000).toFixed(1)}s`);
-                        textWithMeta += `\n\n📊 ${parts.join(" · ")}`;
-                    }
-                    const formatted = toTelegramHTML(textWithMeta);
-                    let fullFormatted = formatted;
-                    if (config.showReasoning && toolHistory.length > 0) {
-                        const expandable = formatToolSummaryExpandable(toolHistory.map((t) => ({ name: t.name, durationMs: t.durationMs, detail: t.detail })), {
-                            elapsedMs: Date.now() - handlerStartTime,
-                            model: usageInfo?.model,
-                            inputTokens: usageInfo?.inputTokens,
-                            outputTokens: usageInfo?.outputTokens,
-                        });
-                        fullFormatted += expandable;
-                    }
-                    const chunks = chunkMessage(fullFormatted);
-                    const fallbackChunks = chunkMessage(textWithMeta);
-                    // Build smart suggestion buttons based on response content
-                    const smartKb = createSmartSuggestionsWithContext(text, ctx.message.text, 4);
-                    // Single chunk: edit placeholder in place
-                    if (placeholderMsgId && chunks.length === 1) {
+        try {
+            sendToOrchestrator(userPrompt, { type: "telegram", chatId, messageId: userMessageId }, (text, done, meta) => {
+                if (done) {
+                    finalized = true;
+                    stopTypingAndClearTimeout();
+                    const assistantLogId = meta?.assistantLogId;
+                    const elapsed = ((Date.now() - handlerStartTime) / 1000).toFixed(1);
+                    void logInfo(`✅ Response done (${elapsed}s, ${toolHistory.length} tools, ${text.length} chars)`);
+                    // Return the edit chain so callers can await final delivery
+                    return editChain.then(async () => {
                         try {
-                            await editSafe(getBot().api, chatId, placeholderMsgId, chunks[0], {
-                                parse_mode: "HTML",
-                                reply_markup: smartKb,
-                            });
-                            try {
-                                await getBot().api.setMessageReaction(chatId, userMessageId, [{ type: "emoji", emoji: "👍" }]);
-                            }
-                            catch { }
-                            if (assistantLogId) {
-                                try {
-                                    const { setConversationTelegramMsgId } = await import("../../store/db.js");
-                                    setConversationTelegramMsgId(assistantLogId, placeholderMsgId);
+                            // Format error messages with a distinct visual
+                            const isError = text.startsWith("Error:");
+                            if (isError) {
+                                void logError(`Response error: ${text.slice(0, 200)}`);
+                                const errorText = `⚠️ ${text}`;
+                                const errorKb = new InlineKeyboard().text("🔄 Retry", "retry").text("📖 Explain", "explain_error");
+                                if (placeholderMsgId) {
+                                    try {
+                                        await editSafe(getBot().api, chatId, placeholderMsgId, errorText, { reply_markup: errorKb });
+                                        return;
+                                    }
+                                    catch {
+                                        /* fall through */
+                                    }
                                 }
-                                catch { }
-                            }
-                            return;
-                        }
-                        catch (err) {
-                            // "message is not modified" is harmless — placeholder already has this content
-                            if (isMessageNotModifiedError(err)) {
                                 try {
-                                    await getBot().api.setMessageReaction(chatId, userMessageId, [{ type: "emoji", emoji: "👍" }]);
+                                    await ctx.reply(errorText, { reply_parameters: replyParams, reply_markup: errorKb });
                                 }
-                                catch { }
-                                if (assistantLogId) {
-                                    try {
-                                        const { setConversationTelegramMsgId } = await import("../../store/db.js");
-                                        setConversationTelegramMsgId(assistantLogId, placeholderMsgId);
-                                    }
-                                    catch { }
+                                catch {
+                                    /* nothing more we can do */
                                 }
                                 return;
                             }
-                            // HTML parse error — try plain text fallback
-                            if (isHtmlParseError(err)) {
+                            let textWithMeta = text;
+                            if (usageInfo && config.usageMode !== "off") {
+                                const fmtTokens = (n) => (n >= 1000 ? `${(n / 1000).toFixed(1)}K` : String(n));
+                                const parts = [];
+                                if (config.usageMode === "full" && usageInfo.model)
+                                    parts.push(usageInfo.model);
+                                parts.push(`⬆${fmtTokens(usageInfo.inputTokens)} ⬇${fmtTokens(usageInfo.outputTokens)}`);
+                                const totalTokens = usageInfo.inputTokens + usageInfo.outputTokens;
+                                parts.push(`Σ${fmtTokens(totalTokens)}`);
+                                if (config.usageMode === "full" && usageInfo.duration)
+                                    parts.push(`${(usageInfo.duration / 1000).toFixed(1)}s`);
+                                textWithMeta += `\n\n📊 ${parts.join(" · ")}`;
+                            }
+                            const formatted = toTelegramHTML(textWithMeta);
+                            let fullFormatted = formatted;
+                            if (config.showReasoning && toolHistory.length > 0) {
+                                const expandable = formatToolSummaryExpandable(toolHistory.map((t) => ({ name: t.name, durationMs: t.durationMs, detail: t.detail })), {
+                                    elapsedMs: Date.now() - handlerStartTime,
+                                    model: usageInfo?.model,
+                                    inputTokens: usageInfo?.inputTokens,
+                                    outputTokens: usageInfo?.outputTokens,
+                                });
+                                fullFormatted += expandable;
+                            }
+                            const chunks = chunkMessage(fullFormatted);
+                            const fallbackChunks = chunkMessage(textWithMeta);
+                            // Build smart suggestion buttons based on response content
+                            const smartKb = createSmartSuggestionsWithContext(text, ctx.message.text, 4);
+                            // Single chunk: edit placeholder in place
+                            if (placeholderMsgId && chunks.length === 1) {
                                 try {
-                                    await editSafe(getBot().api, chatId, placeholderMsgId, fallbackChunks[0], {
+                                    await editSafe(getBot().api, chatId, placeholderMsgId, chunks[0], {
+                                        parse_mode: "HTML",
                                         reply_markup: smartKb,
                                     });
                                     try {
@@ -309,135 +294,195 @@ export function registerMessageHandler(bot, getBot) {
                                     }
                                     return;
                                 }
-                                catch {
-                                    /* fall through to send new messages */
+                                catch (err) {
+                                    // "message is not modified" is harmless — placeholder already has this content
+                                    if (isMessageNotModifiedError(err)) {
+                                        try {
+                                            await getBot().api.setMessageReaction(chatId, userMessageId, [{ type: "emoji", emoji: "👍" }]);
+                                        }
+                                        catch { }
+                                        if (assistantLogId) {
+                                            try {
+                                                const { setConversationTelegramMsgId } = await import("../../store/db.js");
+                                                setConversationTelegramMsgId(assistantLogId, placeholderMsgId);
+                                            }
+                                            catch { }
+                                        }
+                                        return;
+                                    }
+                                    // HTML parse error — try plain text fallback
+                                    if (isHtmlParseError(err)) {
+                                        try {
+                                            await editSafe(getBot().api, chatId, placeholderMsgId, fallbackChunks[0], {
+                                                reply_markup: smartKb,
+                                            });
+                                            try {
+                                                await getBot().api.setMessageReaction(chatId, userMessageId, [{ type: "emoji", emoji: "👍" }]);
+                                            }
+                                            catch { }
+                                            if (assistantLogId) {
+                                                try {
+                                                    const { setConversationTelegramMsgId } = await import("../../store/db.js");
+                                                    setConversationTelegramMsgId(assistantLogId, placeholderMsgId);
+                                                }
+                                                catch { }
+                                            }
+                                            return;
+                                        }
+                                        catch {
+                                            /* fall through to send new messages */
+                                        }
+                                    }
+                                    try {
+                                        await editSafe(getBot().api, chatId, placeholderMsgId, fallbackChunks[0], {
+                                            reply_markup: smartKb,
+                                        });
+                                        try {
+                                            await getBot().api.setMessageReaction(chatId, userMessageId, [{ type: "emoji", emoji: "👍" }]);
+                                        }
+                                        catch { }
+                                        if (assistantLogId) {
+                                            try {
+                                                const { setConversationTelegramMsgId } = await import("../../store/db.js");
+                                                setConversationTelegramMsgId(assistantLogId, placeholderMsgId);
+                                            }
+                                            catch { }
+                                        }
+                                        return;
+                                    }
+                                    catch {
+                                        /* fall through to send new messages */
+                                    }
                                 }
                             }
+                            // Multi-chunk or edit fallthrough: send new chunks FIRST, then delete placeholder
+                            const totalChunks = chunks.length;
+                            let firstSentMsgId;
+                            const sendChunk = async (chunk, fallback, index) => {
+                                const isFirst = index === 0 && !placeholderMsgId;
+                                const isLast = index === totalChunks - 1;
+                                // Pagination header for multi-chunk messages
+                                const pageTag = totalChunks > 1 ? `📄 ${index + 1}/${totalChunks}\n` : "";
+                                // Trim chunk if pageTag pushes it over the limit
+                                let safeChunk = chunk;
+                                if (pageTag.length + safeChunk.length > TELEGRAM_MAX_LENGTH) {
+                                    safeChunk = safeChunk.slice(0, TELEGRAM_MAX_LENGTH - pageTag.length - 4) + " ⋯";
+                                }
+                                let safeFallback = fallback;
+                                if (pageTag.length + safeFallback.length > TELEGRAM_MAX_LENGTH) {
+                                    safeFallback = safeFallback.slice(0, TELEGRAM_MAX_LENGTH - pageTag.length - 4) + " ⋯";
+                                }
+                                const opts = {
+                                    parse_mode: "HTML",
+                                    ...(isFirst ? { reply_parameters: replyParams } : {}),
+                                    ...(isLast && smartKb ? { reply_markup: smartKb } : {}),
+                                };
+                                const fallbackOpts = {
+                                    ...(isFirst ? { reply_parameters: replyParams } : {}),
+                                    ...(isLast && smartKb ? { reply_markup: smartKb } : {}),
+                                };
+                                const sent = await ctx
+                                    .reply(pageTag + safeChunk, opts)
+                                    .catch(() => ctx.reply(pageTag + safeFallback, fallbackOpts));
+                                if (index === 0 && sent)
+                                    firstSentMsgId = sent.message_id;
+                            };
+                            let sendSucceeded = false;
                             try {
-                                await editSafe(getBot().api, chatId, placeholderMsgId, fallbackChunks[0], {
-                                    reply_markup: smartKb,
-                                });
-                                try {
-                                    await getBot().api.setMessageReaction(chatId, userMessageId, [{ type: "emoji", emoji: "👍" }]);
+                                for (let i = 0; i < chunks.length; i++) {
+                                    if (i > 0)
+                                        await new Promise((r) => setTimeout(r, 300));
+                                    await sendChunk(chunks[i], fallbackChunks[i] ?? chunks[i], i);
                                 }
-                                catch { }
-                                if (assistantLogId) {
-                                    try {
-                                        const { setConversationTelegramMsgId } = await import("../../store/db.js");
-                                        setConversationTelegramMsgId(assistantLogId, placeholderMsgId);
+                                sendSucceeded = true;
+                            }
+                            catch {
+                                try {
+                                    for (let i = 0; i < fallbackChunks.length; i++) {
+                                        if (i > 0)
+                                            await new Promise((r) => setTimeout(r, 300));
+                                        const pageTag = fallbackChunks.length > 1 ? `📄 ${i + 1}/${fallbackChunks.length}\n` : "";
+                                        const sent = await ctx.reply(pageTag + fallbackChunks[i], i === 0 ? { reply_parameters: replyParams } : {});
+                                        if (i === 0 && sent)
+                                            firstSentMsgId = sent.message_id;
                                     }
-                                    catch { }
+                                    sendSucceeded = true;
+                                }
+                                catch {
+                                    /* nothing more we can do */
                                 }
-                                return;
                             }
-                            catch {
-                                /* fall through to send new messages */
+                            // Only delete placeholder AFTER new messages sent successfully
+                            if (placeholderMsgId && sendSucceeded) {
+                                try {
+                                    await getBot().api.deleteMessage(chatId, placeholderMsgId);
+                                }
+                                catch {
+                                    /* ignore — placeholder stays but user has the real message */
+                                }
                             }
-                        }
-                    }
-                    // Multi-chunk or edit fallthrough: send new chunks FIRST, then delete placeholder
-                    const totalChunks = chunks.length;
-                    let firstSentMsgId;
-                    const sendChunk = async (chunk, fallback, index) => {
-                        const isFirst = index === 0 && !placeholderMsgId;
-                        const isLast = index === totalChunks - 1;
-                        // Pagination header for multi-chunk messages
-                        const pageTag = totalChunks > 1 ? `📄 ${index + 1}/${totalChunks}\n` : "";
-                        // Trim chunk if pageTag pushes it over the limit
-                        let safeChunk = chunk;
-                        if (pageTag.length + safeChunk.length > TELEGRAM_MAX_LENGTH) {
-                            safeChunk = safeChunk.slice(0, TELEGRAM_MAX_LENGTH - pageTag.length - 4) + " ⋯";
-                        }
-                        let safeFallback = fallback;
-                        if (pageTag.length + safeFallback.length > TELEGRAM_MAX_LENGTH) {
-                            safeFallback = safeFallback.slice(0, TELEGRAM_MAX_LENGTH - pageTag.length - 4) + " ⋯";
-                        }
-                        const opts = {
-                            parse_mode: "HTML",
-                            ...(isFirst ? { reply_parameters: replyParams } : {}),
-                            ...(isLast && smartKb ? { reply_markup: smartKb } : {}),
-                        };
-                        const fallbackOpts = {
-                            ...(isFirst ? { reply_parameters: replyParams } : {}),
-                            ...(isLast && smartKb ? { reply_markup: smartKb } : {}),
-                        };
-                        const sent = await ctx
-                            .reply(pageTag + safeChunk, opts)
-                            .catch(() => ctx.reply(pageTag + safeFallback, fallbackOpts));
-                        if (index === 0 && sent)
-                            firstSentMsgId = sent.message_id;
-                    };
-                    let sendSucceeded = false;
-                    try {
-                        for (let i = 0; i < chunks.length; i++) {
-                            if (i > 0)
-                                await new Promise((r) => setTimeout(r, 300));
-                            await sendChunk(chunks[i], fallbackChunks[i] ?? chunks[i], i);
-                        }
-                        sendSucceeded = true;
-                    }
-                    catch {
-                        try {
-                            for (let i = 0; i < fallbackChunks.length; i++) {
-                                if (i > 0)
-                                    await new Promise((r) => setTimeout(r, 300));
-                                const pageTag = fallbackChunks.length > 1 ? `📄 ${i + 1}/${fallbackChunks.length}\n` : "";
-                                const sent = await ctx.reply(pageTag + fallbackChunks[i], i === 0 ? { reply_parameters: replyParams } : {});
-                                if (i === 0 && sent)
-                                    firstSentMsgId = sent.message_id;
+                            // Track bot message ID for reply-to context lookups
+                            const botMsgId = firstSentMsgId ?? placeholderMsgId;
+                            if (assistantLogId && botMsgId) {
+                                try {
+                                    const { setConversationTelegramMsgId } = await import("../../store/db.js");
+                                    setConversationTelegramMsgId(assistantLogId, botMsgId);
+                                }
+                                catch { }
+                            }
+                            // React ✅ on the user's original message to signal completion
+                            try {
+                                await getBot().api.setMessageReaction(chatId, userMessageId, [{ type: "emoji", emoji: "👍" }]);
+                            }
+                            catch {
+                                /* reactions may not be available */
                             }
-                            sendSucceeded = true;
-                        }
-                        catch {
-                            /* nothing more we can do */
                         }
-                    }
-                    // Only delete placeholder AFTER new messages sent successfully
-                    if (placeholderMsgId && sendSucceeded) {
-                        try {
-                            await getBot().api.deleteMessage(chatId, placeholderMsgId);
+                        finally {
+                            placeholderMsgId = undefined;
+                            lastEditedText = "";
                         }
-                        catch {
-                            /* ignore — placeholder stays but user has the real message */
+                    });
+                }
+                else {
+                    // Progressive streaming: update placeholder periodically with delta threshold
+                    const now = Date.now();
+                    const textDelta = Math.abs(text.length - lastEditedText.length);
+                    if (now - lastEditTime >= EDIT_INTERVAL_MS && textDelta >= MIN_EDIT_DELTA) {
+                        lastEditTime = now;
+                        // Show beginning + end for context instead of just the tail
+                        let preview;
+                        if (text.length > 4000) {
+                            preview = text.slice(0, 1800) + "\n\n⋯\n\n" + text.slice(-1800);
                         }
-                    }
-                    // Track bot message ID for reply-to context lookups
-                    const botMsgId = firstSentMsgId ?? placeholderMsgId;
-                    if (assistantLogId && botMsgId) {
-                        try {
-                            const { setConversationTelegramMsgId } = await import("../../store/db.js");
-                            setConversationTelegramMsgId(assistantLogId, botMsgId);
+                        else {
+                            preview = text;
                         }
-                        catch { }
-                    }
-                    // React ✅ on the user's original message to signal completion
-                    try {
-                        await getBot().api.setMessageReaction(chatId, userMessageId, [{ type: "emoji", emoji: "👍" }]);
-                    }
-                    catch {
-                        /* reactions may not be available */
-                    }
-                });
-            }
-            else {
-                // Progressive streaming: update placeholder periodically with delta threshold
-                const now = Date.now();
-                const textDelta = Math.abs(text.length - lastEditedText.length);
-                if (now - lastEditTime >= EDIT_INTERVAL_MS && textDelta >= MIN_EDIT_DELTA) {
-                    lastEditTime = now;
-                    // Show beginning + end for context instead of just the tail
-                    let preview;
-                    if (text.length > 4000) {
-                        preview = text.slice(0, 1800) + "\n\n⋯\n\n" + text.slice(-1800);
-                    }
-                    else {
-                        preview = text;
+                        const statusLine = currentToolName ? `🔧 ${currentToolName}\n\n` : "";
+                        enqueueEdit(statusLine + preview);
                     }
-                    const statusLine = currentToolName ? `🔧 ${currentToolName}\n\n` : "";
-                    enqueueEdit(statusLine + preview);
+                }
+            }, onToolEvent, onUsage);
+        }
+        catch (err) {
+            console.error("[nzb] sendToOrchestrator threw:", err instanceof Error ? err.message : err);
+            // Attempt to notify user of the failure
+            try {
+                const errorText = `⚠️ Error: Failed to process message. Please try again.`;
+                if (placeholderMsgId) {
+                    await editSafe(getBot().api, chatId, placeholderMsgId, errorText);
+                }
+                else {
+                    await ctx.reply(errorText, { reply_parameters: replyParams });
                 }
             }
-        }, onToolEvent, onUsage);
+            catch {
+                /* nothing more we can do */
+            }
+        }
+        finally {
+            stopTypingAndClearTimeout();
+        }
     });
 }
 //# sourceMappingURL=streaming.js.map

package/dist/telegram/handlers/suggestions.js

@@ -82,16 +82,37 @@ export function buildSmartSuggestions(response, prompt, maxButtons = 4) {
 }
 // In-memory store for pending smart suggestion prompts (TTL: 5 minutes)
 const pendingPrompts = new Map();
+const SUGGESTION_MAX_AGE_MS = 5 * 60_000;
+const SUGGESTION_CLEANUP_INTERVAL_MS = 60_000;
+const MAX_PENDING_PROMPTS = 1000;
+// Periodic cleanup to prevent unbounded memory growth
+setInterval(() => {
+    const cutoff = Date.now() - SUGGESTION_MAX_AGE_MS;
+    for (const [key, value] of pendingPrompts) {
+        if (value.timestamp < cutoff) {
+            pendingPrompts.delete(key);
+        }
+    }
+}, SUGGESTION_CLEANUP_INTERVAL_MS).unref();
 /** Store the context for smart suggestion callbacks. */
 export function storeSuggestionContext(callbackPrefix, timeKey, prompt, response) {
     const key = `${callbackPrefix}:${timeKey}`;
     pendingPrompts.set(key, { prompt, response, timestamp: Date.now() });
     // Cleanup old entries (older than 5 minutes)
-    const cutoff = Date.now() - 5 * 60_000;
+    const cutoff = Date.now() - SUGGESTION_MAX_AGE_MS;
     for (const [k, v] of pendingPrompts) {
         if (v.timestamp < cutoff)
             pendingPrompts.delete(k);
     }
+    // Enforce max size to prevent unbounded growth
+    if (pendingPrompts.size > MAX_PENDING_PROMPTS) {
+        const entries = Array.from(pendingPrompts.entries())
+            .sort((a, b) => a[1].timestamp - b[1].timestamp);
+        const toRemove = entries.slice(0, pendingPrompts.size - MAX_PENDING_PROMPTS);
+        for (const [rmKey] of toRemove) {
+            pendingPrompts.delete(rmKey);
+        }
+    }
 }
 /** Register callback handlers for smart suggestion buttons. */
 export function registerSmartSuggestionHandlers(bot) {

package/dist/telegram/log-channel.js

@@ -23,8 +23,8 @@ export async function sendLog(level, message) {
     try {
         await botRef.api.sendMessage(config.logChannelId, header + body, { parse_mode: "HTML" });
     }
-    catch {
-        // best-effort — don't crash if log channel is unreachable
+    catch (err) {
+        console.error("[nzb] Log channel send failed:", err instanceof Error ? err.message : err);
     }
 }
 /** Convenience wrappers */