zardbot-telegram 1.0.0

package/dist/bot/streaming/tool-call-streamer.js

@@ -0,0 +1,285 @@
+import { logger } from "../../utils/logger.js";
+const TELEGRAM_MESSAGE_SAFE_LENGTH = 4000;
+function getErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+function getRetryAfterMs(error) {
+    const message = getErrorMessage(error);
+    if (!/\b429\b/.test(message)) {
+        return null;
+    }
+    const retryMatch = message.match(/retry after\s+(\d+)/i);
+    if (!retryMatch) {
+        return null;
+    }
+    const seconds = Number.parseInt(retryMatch[1], 10);
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+        return null;
+    }
+    return seconds * 1000;
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function splitLongText(text, limit) {
+    if (text.length <= limit) {
+        return [text];
+    }
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > limit) {
+        let splitIndex = remaining.lastIndexOf("\n", limit);
+        if (splitIndex <= 0 || splitIndex < Math.floor(limit * 0.5)) {
+            splitIndex = limit;
+        }
+        chunks.push(remaining.slice(0, splitIndex));
+        remaining = remaining.slice(splitIndex).replace(/^\n+/, "");
+    }
+    if (remaining.length > 0) {
+        chunks.push(remaining);
+    }
+    return chunks;
+}
+function buildParts(entries) {
+    const text = entries
+        .map((entry) => entry.text.trim())
+        .filter(Boolean)
+        .join("\n\n");
+    if (!text) {
+        return [];
+    }
+    return splitLongText(text, TELEGRAM_MESSAGE_SAFE_LENGTH).filter(Boolean);
+}
+export class ToolCallStreamer {
+    throttleMs;
+    sendText;
+    editText;
+    deleteText;
+    states = new Map();
+    allStates = new Set();
+    constructor(options) {
+        this.throttleMs = Math.max(0, Math.floor(options.throttleMs));
+        this.sendText = options.sendText;
+        this.editText = options.editText;
+        this.deleteText = options.deleteText;
+    }
+    append(sessionId, text) {
+        const normalizedText = text.trim();
+        if (!sessionId || !normalizedText) {
+            return;
+        }
+        const state = this.getOrCreateState(sessionId);
+        state.entries.push({ text: normalizedText });
+        state.latestParts = buildParts(state.entries);
+        this.ensureTimer(state);
+    }
+    replaceByPrefix(sessionId, prefix, text) {
+        const normalizedPrefix = prefix.trim();
+        const normalizedText = text.trim();
+        if (!sessionId || !normalizedPrefix || !normalizedText) {
+            return;
+        }
+        const state = this.getOrCreateState(sessionId);
+        const existingEntry = state.entries.find((entry) => entry.prefix === normalizedPrefix);
+        if (existingEntry) {
+            existingEntry.text = normalizedText;
+        }
+        else {
+            state.entries.push({ prefix: normalizedPrefix, text: normalizedText });
+        }
+        state.latestParts = buildParts(state.entries);
+        this.ensureTimer(state);
+    }
+    async flushSession(sessionId, reason) {
+        const state = this.states.get(sessionId);
+        if (!state) {
+            return;
+        }
+        this.clearTimer(state);
+        await this.enqueueTask(state, () => this.syncState(state, reason));
+    }
+    async breakSession(sessionId, reason) {
+        const state = this.states.get(sessionId);
+        if (!state) {
+            return;
+        }
+        state.isBreaking = true;
+        this.getOrCreateState(sessionId);
+        this.clearTimer(state);
+        await this.enqueueTask(state, () => this.syncState(state, reason));
+        this.cancelState(state);
+        this.removeState(state);
+        logger.debug(`[ToolCallStreamer] Broke session stream: session=${sessionId}, reason=${reason}`);
+    }
+    clearSession(sessionId, reason) {
+        let clearedAny = false;
+        for (const state of Array.from(this.allStates)) {
+            if (state.sessionId !== sessionId) {
+                continue;
+            }
+            this.cancelState(state);
+            this.removeState(state);
+            clearedAny = true;
+        }
+        if (clearedAny) {
+            logger.debug(`[ToolCallStreamer] Cleared session stream: session=${sessionId}, reason=${reason}`);
+        }
+    }
+    clearAll(reason) {
+        for (const state of Array.from(this.allStates)) {
+            this.cancelState(state);
+        }
+        const count = this.allStates.size;
+        this.states.clear();
+        this.allStates.clear();
+        if (count > 0) {
+            logger.debug(`[ToolCallStreamer] Cleared all streams: count=${count}, reason=${reason}`);
+        }
+    }
+    getOrCreateState(sessionId) {
+        const existing = this.states.get(sessionId);
+        if (existing && !existing.isBroken && !existing.cancelled && !existing.isBreaking) {
+            return existing;
+        }
+        if (existing && (existing.isBroken || existing.cancelled)) {
+            this.clearTimer(existing);
+            this.removeState(existing);
+        }
+        const state = {
+            sessionId,
+            entries: [],
+            latestParts: [],
+            lastSentParts: [],
+            telegramMessageIds: [],
+            timer: null,
+            task: Promise.resolve(true),
+            cancelled: false,
+            isBroken: false,
+            isBreaking: false,
+            fatalErrorMessage: null,
+            fatalErrorLogged: false,
+        };
+        this.states.set(sessionId, state);
+        this.allStates.add(state);
+        return state;
+    }
+    clearTimer(state) {
+        if (!state.timer) {
+            return;
+        }
+        clearTimeout(state.timer);
+        state.timer = null;
+    }
+    ensureTimer(state) {
+        if (state.timer || state.isBroken || state.cancelled) {
+            return;
+        }
+        if (this.throttleMs === 0) {
+            void this.enqueueTask(state, () => this.syncState(state, "immediate")).catch((error) => {
+                logger.error(`[ToolCallStreamer] Immediate sync failed: session=${state.sessionId}`, error);
+            });
+            return;
+        }
+        state.timer = setTimeout(() => {
+            state.timer = null;
+            void this.enqueueTask(state, () => this.syncState(state, "throttle_elapsed")).catch((error) => {
+                logger.error(`[ToolCallStreamer] Throttled sync failed: session=${state.sessionId}`, error);
+            });
+        }, this.throttleMs);
+    }
+    enqueueTask(state, task) {
+        const nextTask = state.task.catch(() => false).then(task);
+        state.task = nextTask;
+        return nextTask;
+    }
+    cancelState(state) {
+        state.cancelled = true;
+        this.clearTimer(state);
+    }
+    removeState(state) {
+        if (this.states.get(state.sessionId) === state) {
+            this.states.delete(state.sessionId);
+        }
+        this.allStates.delete(state);
+    }
+    async syncState(state, reason) {
+        if (state.cancelled) {
+            return false;
+        }
+        if (state.isBroken) {
+            return false;
+        }
+        while (!state.isBroken && !state.cancelled) {
+            const parts = state.latestParts;
+            const unchanged = parts.length === state.lastSentParts.length &&
+                parts.every((part, index) => state.lastSentParts[index] === part);
+            if (unchanged) {
+                return state.telegramMessageIds.length > 0;
+            }
+            if (parts.length === 0) {
+                return state.telegramMessageIds.length > 0;
+            }
+            try {
+                await this.syncMessages(state, parts);
+                if (state.cancelled) {
+                    return false;
+                }
+                logger.debug(`[ToolCallStreamer] Stream synced: session=${state.sessionId}, reason=${reason}, parts=${parts.length}`);
+                return true;
+            }
+            catch (error) {
+                const retryAfterMs = getRetryAfterMs(error);
+                if (retryAfterMs === null) {
+                    this.markStreamBroken(state, error, reason);
+                    return false;
+                }
+                const delayMs = Math.max(this.throttleMs, retryAfterMs);
+                logger.warn(`[ToolCallStreamer] Stream sync rate-limited, retrying in ${delayMs}ms: session=${state.sessionId}, reason=${reason}`, error);
+                await delay(delayMs);
+            }
+        }
+        return false;
+    }
+    markStreamBroken(state, error, reason) {
+        state.isBroken = true;
+        state.fatalErrorMessage = getErrorMessage(error);
+        if (state.fatalErrorLogged) {
+            return;
+        }
+        state.fatalErrorLogged = true;
+        logger.error(`[ToolCallStreamer] Stream marked as broken: session=${state.sessionId}, reason=${reason}, error=${state.fatalErrorMessage}`, error);
+    }
+    async syncMessages(state, parts) {
+        for (let index = 0; index < parts.length; index++) {
+            if (state.cancelled) {
+                return;
+            }
+            const text = parts[index];
+            const currentMessageId = state.telegramMessageIds[index];
+            if (currentMessageId) {
+                await this.editText(state.sessionId, currentMessageId, text);
+                state.lastSentParts[index] = text;
+                continue;
+            }
+            const messageId = await this.sendText(state.sessionId, text);
+            state.telegramMessageIds[index] = messageId;
+            state.lastSentParts[index] = text;
+        }
+        for (let index = state.telegramMessageIds.length - 1; index >= parts.length; index--) {
+            if (state.cancelled) {
+                return;
+            }
+            const messageId = state.telegramMessageIds[index];
+            if (messageId) {
+                await this.deleteText(state.sessionId, messageId);
+            }
+            state.telegramMessageIds.pop();
+            state.lastSentParts.pop();
+        }
+    }
+}

package/dist/bot/utils/busy-guard.js

@@ -0,0 +1,15 @@
+import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
+import { t } from "../../i18n/index.js";
+export function isForegroundBusy() {
+    return foregroundSessionState.isBusy();
+}
+export async function replyBusyBlocked(ctx) {
+    const message = t("interaction.blocked.finish_current");
+    if (ctx.callbackQuery) {
+        await ctx.answerCallbackQuery({ text: message }).catch(() => { });
+        return;
+    }
+    if (ctx.chat) {
+        await ctx.reply(message).catch(() => { });
+    }
+}

package/dist/bot/utils/commands.js

@@ -0,0 +1,21 @@
+import { BOT_COMMANDS } from "../commands/definitions.js";
+const KNOWN_COMMANDS = new Set(["start", ...BOT_COMMANDS.map((item) => item.command)]);
+export function extractCommandName(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith("/")) {
+        return null;
+    }
+    const token = trimmed.split(/\s+/)[0];
+    const withoutSlash = token.slice(1);
+    if (!withoutSlash) {
+        return null;
+    }
+    const withoutMention = withoutSlash.split("@")[0].toLowerCase();
+    if (!withoutMention) {
+        return null;
+    }
+    return withoutMention;
+}
+export function isKnownCommand(commandName) {
+    return KNOWN_COMMANDS.has(commandName);
+}

package/dist/bot/utils/file-download.js

@@ -0,0 +1,91 @@
+import { config } from "../../config.js";
+import { logger } from "../../utils/logger.js";
+const TELEGRAM_FILE_URL_BASE = "https://api.telegram.org/file/bot";
+const MAX_FILE_SIZE_BYTES = 20 * 1024 * 1024; // 20MB Telegram limit
+/**
+ * Download a photo from Telegram servers
+ * @param api Grammy API instance
+ * @param fileId Telegram file_id
+ * @returns Downloaded photo buffer and path
+ */
+export async function downloadTelegramFile(api, fileId) {
+    logger.debug(`[FileDownload] Getting file info for fileId=${fileId}`);
+    const file = await api.getFile(fileId);
+    if (!file.file_path) {
+        throw new Error("File path not available from Telegram");
+    }
+    if (file.file_size && file.file_size > MAX_FILE_SIZE_BYTES) {
+        const sizeMb = (file.file_size / (1024 * 1024)).toFixed(2);
+        throw new Error(`File too large: ${sizeMb}MB (max 20MB)`);
+    }
+    const fileUrl = `${TELEGRAM_FILE_URL_BASE}${config.telegram.token}/${file.file_path}`;
+    logger.debug(`[FileDownload] Downloading from ${fileUrl.replace(config.telegram.token, "***")}`);
+    const fetchOptions = {};
+    // Use proxy if configured
+    if (config.telegram.proxyUrl) {
+        const { HttpsProxyAgent } = await import("https-proxy-agent");
+        fetchOptions.agent = new HttpsProxyAgent(config.telegram.proxyUrl);
+    }
+    const response = await fetch(fileUrl, fetchOptions);
+    if (!response.ok) {
+        throw new Error(`Failed to download file: ${response.status} ${response.statusText}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+    logger.debug(`[FileDownload] Downloaded ${buffer.length} bytes`);
+    return {
+        buffer,
+        filePath: file.file_path,
+    };
+}
+/**
+ * Convert buffer to base64 data URI
+ * @param buffer File buffer
+ * @param mimeType MIME type (e.g., "image/jpeg")
+ * @returns Data URI string
+ */
+export function toDataUri(buffer, mimeType) {
+    const base64 = buffer.toString("base64");
+    return `data:${mimeType};base64,${base64}`;
+}
+/**
+ * Check if photo size is within limits
+ * @param fileSize Photo size in bytes
+ * @param maxSizeKb Maximum size in KB (from config)
+ * @returns true if within limit
+ */
+export function isFileSizeAllowed(fileSize, maxSizeKb) {
+    if (!fileSize) {
+        return true; // Unknown size, allow (will be checked on download)
+    }
+    const maxBytes = maxSizeKb * 1024;
+    return fileSize <= maxBytes;
+}
+/**
+ * Get human-readable photo size
+ */
+export function formatFileSize(bytes) {
+    if (bytes < 1024) {
+        return `${bytes}B`;
+    }
+    if (bytes < 1024 * 1024) {
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    }
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+const APPLICATION_TEXT_MIME_TYPES = new Set([
+    "application/json",
+    "application/xml",
+    "application/javascript",
+    "application/x-yaml",
+    "application/sql",
+]);
+export function isTextMimeType(mimeType) {
+    if (!mimeType) {
+        return false;
+    }
+    if (mimeType.startsWith("text/")) {
+        return true;
+    }
+    return APPLICATION_TEXT_MIME_TYPES.has(mimeType);
+}

package/dist/bot/utils/finalize-assistant-response.js

@@ -0,0 +1,52 @@
+import { logger } from "../../utils/logger.js";
+import { sendTtsVoiceMessage, cleanTextForTts } from "../handlers/tts.js";
+export async function finalizeAssistantResponse({ sessionId, messageId, messageText, responseStreamer, flushPendingServiceMessages, prepareStreamingPayload, formatSummary, formatRawSummary, resolveFormat, getReplyKeyboard, sendText, deleteMessages, api, chatId, enableTts = true, }) {
+    let streamedMessageIds = [];
+    const preparedStreamPayload = prepareStreamingPayload(messageText);
+    if (preparedStreamPayload) {
+        preparedStreamPayload.sendOptions = { disable_notification: true };
+        preparedStreamPayload.editOptions = undefined;
+    }
+    const result = await responseStreamer.complete(sessionId, messageId, preparedStreamPayload ?? undefined);
+    if (result.streamed) {
+        streamedMessageIds = result.telegramMessageIds;
+    }
+    await flushPendingServiceMessages();
+    // When the response was streamed, delete the streamed messages and re-send
+    // via the non-streamed path so the reply keyboard carries the latest context.
+    if (streamedMessageIds.length > 0) {
+        try {
+            await deleteMessages(streamedMessageIds);
+        }
+        catch (err) {
+            logger.warn("[FinalizeResponse] Failed to delete streamed messages, sending with keyboard anyway:", err);
+        }
+    }
+    const parts = formatSummary(messageText);
+    const rawParts = formatRawSummary(messageText);
+    const format = resolveFormat();
+    for (let partIndex = 0; partIndex < parts.length; partIndex++) {
+        const part = parts[partIndex];
+        const rawFallbackText = rawParts[partIndex];
+        const keyboard = getReplyKeyboard();
+        const options = keyboard ? { reply_markup: keyboard } : undefined;
+        await sendText(part, rawFallbackText, options, format);
+    }
+    // TTS: Send voice message if TTS is enabled and configured
+    if (enableTts && api && chatId) {
+        try {
+            // Clean text for TTS (remove code blocks, markdown, etc.)
+            const cleanedText = cleanTextForTts(messageText);
+            if (cleanedText.length > 0) {
+                // Send TTS in background - don't block the response
+                sendTtsVoiceMessage(api, chatId, cleanedText).catch((err) => {
+                    logger.warn("[FinalizeResponse] TTS failed:", err);
+                });
+            }
+        }
+        catch (err) {
+            logger.warn("[FinalizeResponse] TTS error:", err);
+        }
+    }
+    return false;
+}

package/dist/bot/utils/keyboard.js

@@ -0,0 +1,69 @@
+import { Keyboard } from "grammy";
+import { getAgentDisplayName } from "../../agent/types.js";
+import { formatModelForButton } from "../../model/types.js";
+import { t } from "../../i18n/index.js";
+/**
+ * Format token count for display (e.g., 150000 -> "150K", 1500000 -> "1.5M")
+ */
+function formatTokenCount(count) {
+    if (count >= 1000000) {
+        return `${(count / 1000000).toFixed(1)}M`;
+    }
+    else if (count >= 1000) {
+        return `${Math.round(count / 1000)}K`;
+    }
+    return count.toString();
+}
+/**
+ * Format context information for button
+ */
+function formatContextForButton(contextInfo) {
+    const used = formatTokenCount(contextInfo.tokensUsed);
+    const limit = formatTokenCount(contextInfo.tokensLimit);
+    const percent = Math.round((contextInfo.tokensUsed / contextInfo.tokensLimit) * 100);
+    return t("keyboard.context", { used, limit, percent });
+}
+/**
+ * Create Reply Keyboard with agent, model, variant, and context indicators
+ * @param currentAgent Current agent name (e.g., "build", "plan")
+ * @param currentModel Current model info
+ * @param contextInfo Optional context information (tokens used/limit)
+ * @param variantName Optional variant display name (e.g., "💭 Default")
+ * @returns Reply Keyboard with agent and context in row 1, model and variant in row 2
+ */
+export function createMainKeyboard(currentAgent, currentModel, contextInfo, variantName) {
+    const keyboard = new Keyboard();
+    const agentText = getAgentDisplayName(currentAgent);
+    // Format model with compact provider/model text and icon
+    const modelText = formatModelForButton(currentModel.providerID, currentModel.modelID);
+    // Context text - show "0" if no data available
+    const contextText = contextInfo
+        ? formatContextForButton(contextInfo)
+        : t("keyboard.context_empty");
+    // Variant text - default to "💭 Default" if not provided
+    const variantText = variantName || t("keyboard.variant_default");
+    // Row 1: agent and context buttons
+    keyboard.text(agentText).text(contextText).row();
+    // Row 2: model and variant buttons
+    keyboard.text(modelText).text(variantText).row();
+    return keyboard.resized().persistent();
+}
+/**
+ * Create Reply Keyboard with agent mode indicator
+ * @param currentAgent Current agent name (e.g., "build", "plan")
+ * @returns Reply Keyboard with single button showing current mode
+ * @deprecated Use createMainKeyboard instead
+ */
+export function createAgentKeyboard(currentAgent) {
+    const keyboard = new Keyboard();
+    const displayName = getAgentDisplayName(currentAgent);
+    // Single button with current agent mode
+    keyboard.text(displayName).row();
+    return keyboard.resized().persistent();
+}
+/**
+ * Remove Reply Keyboard (for cleanup)
+ */
+export function removeKeyboard() {
+    return { remove_keyboard: true };
+}