@grinev/opencode-telegram-bot 0.21.0 → 0.21.2

package/dist/bot/menus/session-selection-menu.js

@@ -0,0 +1,115 @@
+import { InlineKeyboard } from "grammy";
+import { opencodeClient } from "../../opencode/client.js";
+import { getDateLocale, t } from "../../i18n/index.js";
+import { logger } from "../../utils/logger.js";
+export const SESSION_CALLBACK_PREFIX = "session:";
+const SESSION_PAGE_CALLBACK_PREFIX = "session:page:";
+const BACKGROUND_SESSION_CALLBACK_PREFIX = "background-session:";
+const SESSION_FETCH_EXTRA_COUNT = 1;
+const BACKGROUND_SESSION_KIND_CALLBACK_MARKERS = {
+    assistant_response: "a",
+    question_asked: "q",
+    permission_asked: "p",
+};
+const BACKGROUND_SESSION_KIND_BY_CALLBACK_MARKER = {
+    a: "assistant_response",
+    q: "question_asked",
+    p: "permission_asked",
+};
+function buildSessionPageCallback(page) {
+    return `${SESSION_PAGE_CALLBACK_PREFIX}${page}`;
+}
+export function parseSessionPageCallback(data) {
+    if (!data.startsWith(SESSION_PAGE_CALLBACK_PREFIX)) {
+        return null;
+    }
+    const rawPage = data.slice(SESSION_PAGE_CALLBACK_PREFIX.length);
+    const page = Number(rawPage);
+    if (!Number.isInteger(page) || page < 0) {
+        return null;
+    }
+    return page;
+}
+export function parseSessionIdCallback(data) {
+    if (!data.startsWith(SESSION_CALLBACK_PREFIX)) {
+        return null;
+    }
+    if (data.startsWith(SESSION_PAGE_CALLBACK_PREFIX)) {
+        return null;
+    }
+    const sessionId = data.slice(SESSION_CALLBACK_PREFIX.length);
+    return sessionId.length > 0 ? sessionId : null;
+}
+export function parseBackgroundSessionCallback(data) {
+    if (!data.startsWith(BACKGROUND_SESSION_CALLBACK_PREFIX)) {
+        return null;
+    }
+    const payload = data.slice(BACKGROUND_SESSION_CALLBACK_PREFIX.length);
+    const markerSeparatorIndex = payload.indexOf(":");
+    if (markerSeparatorIndex < 0) {
+        return payload.length > 0 ? { sessionId: payload, kind: null } : null;
+    }
+    const marker = payload.slice(0, markerSeparatorIndex);
+    const sessionId = payload.slice(markerSeparatorIndex + 1);
+    const kind = BACKGROUND_SESSION_KIND_BY_CALLBACK_MARKER[marker];
+    if (!kind || sessionId.length === 0) {
+        return null;
+    }
+    return { sessionId, kind };
+}
+export function buildBackgroundSessionOpenKeyboard(sessionId, kind) {
+    const marker = BACKGROUND_SESSION_KIND_CALLBACK_MARKERS[kind];
+    return new InlineKeyboard().text(t("background.open_session_button"), `${BACKGROUND_SESSION_CALLBACK_PREFIX}${marker}:${sessionId}`);
+}
+function formatSessionsSelectText(page) {
+    if (page === 0) {
+        return t("sessions.select");
+    }
+    return t("sessions.select_page", { page: page + 1 });
+}
+export async function loadSessionPage(directory, page, pageSize) {
+    const startIndex = page * pageSize;
+    const endExclusive = startIndex + pageSize;
+    const { data: sessions, error } = await opencodeClient.session.list({
+        directory,
+        limit: endExclusive + SESSION_FETCH_EXTRA_COUNT,
+        roots: true,
+    });
+    if (error || !sessions) {
+        throw error || new Error("No data received from server");
+    }
+    const hasNext = sessions.length > endExclusive;
+    const pagedSessions = sessions.slice(startIndex, endExclusive);
+    logger.debug(`[Sessions] Loaded page=${page + 1}, startIndex=${startIndex}, endExclusive=${endExclusive}, pageSize=${pageSize}, items=${pagedSessions.length}, hasNext=${hasNext}`);
+    return {
+        sessions: pagedSessions,
+        hasNext,
+        page,
+    };
+}
+function buildSessionsKeyboard(pageData, pageSize) {
+    const keyboard = new InlineKeyboard();
+    const localeForDate = getDateLocale();
+    const pageStartIndex = pageData.page * pageSize;
+    pageData.sessions.forEach((session, index) => {
+        const date = new Date(session.time.created).toLocaleDateString(localeForDate);
+        const label = `${pageStartIndex + index + 1}. ${session.title} (${date})`;
+        keyboard.text(label, `${SESSION_CALLBACK_PREFIX}${session.id}`).row();
+    });
+    if (pageData.page > 0) {
+        keyboard.text(t("sessions.button.prev_page"), buildSessionPageCallback(pageData.page - 1));
+    }
+    if (pageData.hasNext) {
+        keyboard.text(t("sessions.button.next_page"), buildSessionPageCallback(pageData.page + 1));
+    }
+    if (pageData.page > 0 || pageData.hasNext) {
+        keyboard.row();
+    }
+    return keyboard;
+}
+export function buildSessionSelectionMenuView(pageData, pageSize) {
+    return {
+        text: formatSessionsSelectText(pageData.page),
+        keyboard: buildSessionsKeyboard(pageData, pageSize),
+    };
+}

package/dist/bot/menus/skills-catalog-menu.js

@@ -0,0 +1,99 @@
+import { InlineKeyboard } from "grammy";
+import { t } from "../../i18n/index.js";
+export const SKILLS_CALLBACK_PREFIX = "skills:";
+export const SKILLS_CALLBACK_SELECT_PREFIX = `${SKILLS_CALLBACK_PREFIX}select:`;
+const SKILLS_CALLBACK_PAGE_PREFIX = `${SKILLS_CALLBACK_PREFIX}page:`;
+export const SKILLS_CALLBACK_CANCEL = `${SKILLS_CALLBACK_PREFIX}cancel`;
+export const SKILLS_CALLBACK_EXECUTE = `${SKILLS_CALLBACK_PREFIX}execute`;
+const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
+export function formatExecutingSkillMessage(skillName, args) {
+    const prefix = t("skills.executing_prefix");
+    const skillText = `/${skillName}`;
+    const argsSuffix = args ? ` ${args}` : "";
+    return {
+        text: `${prefix}\n${skillText}${argsSuffix}`,
+        entities: [
+            {
+                type: "code",
+                offset: prefix.length + 1,
+                length: skillText.length,
+            },
+        ],
+    };
+}
+export function buildSkillPageCallback(page) {
+    return `${SKILLS_CALLBACK_PAGE_PREFIX}${page}`;
+}
+export function parseSkillPageCallback(data) {
+    if (!data.startsWith(SKILLS_CALLBACK_PAGE_PREFIX)) {
+        return null;
+    }
+    const rawPage = data.slice(SKILLS_CALLBACK_PAGE_PREFIX.length);
+    const page = Number(rawPage);
+    if (!Number.isInteger(page) || page < 0) {
+        return null;
+    }
+    return page;
+}
+export function parseSkillSelectCallback(data) {
+    if (!data.startsWith(SKILLS_CALLBACK_SELECT_PREFIX)) {
+        return null;
+    }
+    const rawIndex = data.slice(SKILLS_CALLBACK_SELECT_PREFIX.length);
+    const index = Number(rawIndex);
+    if (!Number.isInteger(index) || index < 0) {
+        return null;
+    }
+    return index;
+}
+export function formatSkillsSelectText(page) {
+    if (page === 0) {
+        return t("skills.select");
+    }
+    return t("skills.select_page", { page: page + 1 });
+}
+function formatSkillButtonLabel(skill) {
+    const description = skill.description?.trim() || t("skills.no_description");
+    const rawLabel = `/${skill.name} - ${description}`;
+    if (rawLabel.length <= MAX_INLINE_BUTTON_LABEL_LENGTH) {
+        return rawLabel;
+    }
+    return `${rawLabel.slice(0, MAX_INLINE_BUTTON_LABEL_LENGTH - 3)}...`;
+}
+export function calculateSkillsPaginationRange(totalSkills, page, pageSize) {
+    const safePageSize = Math.max(1, pageSize);
+    const totalPages = Math.max(1, Math.ceil(totalSkills / safePageSize));
+    const normalizedPage = Math.min(Math.max(0, page), totalPages - 1);
+    const startIndex = normalizedPage * safePageSize;
+    const endIndex = Math.min(startIndex + safePageSize, totalSkills);
+    return {
+        page: normalizedPage,
+        totalPages,
+        startIndex,
+        endIndex,
+    };
+}
+export function buildSkillsListKeyboard(skills, page, pageSize) {
+    const keyboard = new InlineKeyboard();
+    const { page: normalizedPage, totalPages, startIndex, endIndex, } = calculateSkillsPaginationRange(skills.length, page, pageSize);
+    skills.slice(startIndex, endIndex).forEach((skill, index) => {
+        const globalIndex = startIndex + index;
+        keyboard.text(formatSkillButtonLabel(skill), `${SKILLS_CALLBACK_SELECT_PREFIX}${globalIndex}`).row();
+    });
+    if (totalPages > 1) {
+        if (normalizedPage > 0) {
+            keyboard.text(t("skills.button.prev_page"), buildSkillPageCallback(normalizedPage - 1));
+        }
+        if (normalizedPage < totalPages - 1) {
+            keyboard.text(t("skills.button.next_page"), buildSkillPageCallback(normalizedPage + 1));
+        }
+        keyboard.row();
+    }
+    keyboard.text(t("skills.button.cancel"), SKILLS_CALLBACK_CANCEL);
+    return keyboard;
+}
+export function buildSkillsConfirmKeyboard() {
+    return new InlineKeyboard()
+        .text(t("skills.button.execute"), SKILLS_CALLBACK_EXECUTE)
+        .text(t("skills.button.cancel"), SKILLS_CALLBACK_CANCEL);
+}

package/dist/bot/menus/variant-selection-menu.js

@@ -0,0 +1,67 @@
+import { InlineKeyboard } from "grammy";
+import { getStoredModel } from "../../app/services/model-selection-service.js";
+import { formatVariantForDisplay, getAvailableVariants, getCurrentVariant, } from "../../app/services/variant-selection-service.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+import { replyWithInlineMenu } from "./inline-menu.js";
+/**
+ * Build inline keyboard with available variants
+ * @param currentVariant Current variant for highlighting
+ * @param providerID Provider ID
+ * @param modelID Model ID
+ * @returns InlineKeyboard with variant selection buttons
+ */
+export async function buildVariantSelectionMenu(currentVariant, providerID, modelID) {
+    const keyboard = new InlineKeyboard();
+    const variants = await getAvailableVariants(providerID, modelID);
+    if (variants.length === 0) {
+        logger.warn("[VariantHandler] No variants found");
+        return keyboard;
+    }
+    // Filter only active variants (not disabled)
+    const activeVariants = variants.filter((v) => !v.disabled);
+    if (activeVariants.length === 0) {
+        logger.warn("[VariantHandler] No active variants found");
+        // If no active variants, show default at least
+        keyboard.text(`✅ ${formatVariantForDisplay("default")}`, "variant:default").row();
+        return keyboard;
+    }
+    // Add button for each variant (one per row)
+    activeVariants.forEach((variant) => {
+        const isActive = variant.id === currentVariant;
+        const label = formatVariantForDisplay(variant.id);
+        const labelWithCheck = isActive ? `✅ ${label}` : label;
+        keyboard.text(labelWithCheck, `variant:${variant.id}`).row();
+    });
+    return keyboard;
+}
+/**
+ * Show variant selection menu
+ * @param ctx grammY context
+ */
+export async function showVariantSelectionMenu(ctx) {
+    try {
+        const currentModel = getStoredModel();
+        if (!currentModel.providerID || !currentModel.modelID) {
+            await ctx.reply(t("variant.select_model_first"));
+            return;
+        }
+        const currentVariant = getCurrentVariant();
+        const keyboard = await buildVariantSelectionMenu(currentVariant, currentModel.providerID, currentModel.modelID);
+        if (keyboard.inline_keyboard.length === 0) {
+            await ctx.reply(t("variant.menu.empty"));
+            return;
+        }
+        const displayName = formatVariantForDisplay(currentVariant);
+        const text = t("variant.menu.current", { name: displayName });
+        await replyWithInlineMenu(ctx, {
+            menuKind: "variant",
+            text,
+            keyboard,
+        });
+    }
+    catch (err) {
+        logger.error("[VariantHandler] Error showing variant menu:", err);
+        await ctx.reply(t("variant.menu.error"));
+    }
+}

package/dist/bot/menus/worktree-selection-menu.js

@@ -0,0 +1,76 @@
+import { InlineKeyboard } from "grammy";
+import { config } from "../../config.js";
+import { t } from "../../i18n/index.js";
+import { buildProjectButtonLabel, calculateProjectsPaginationRange, } from "./project-selection-menu.js";
+const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
+export const WORKTREE_CALLBACK_PREFIX = "worktree:";
+const WORKTREE_PAGE_CALLBACK_PREFIX = "worktree:page:";
+function formatWorktreeButtonLabel(label, isActive) {
+    const prefix = isActive ? "✅ " : "";
+    const availableLength = MAX_INLINE_BUTTON_LABEL_LENGTH - prefix.length;
+    if (label.length <= availableLength) {
+        return `${prefix}${label}`;
+    }
+    return `${prefix}${label.slice(0, Math.max(0, availableLength - 3))}...`;
+}
+function buildWorktreeButtonLabel(index, entry) {
+    return buildProjectButtonLabel(index, entry.path);
+}
+export function parseWorktreePageCallback(data) {
+    if (!data.startsWith(WORKTREE_PAGE_CALLBACK_PREFIX)) {
+        return null;
+    }
+    const rawPage = data.slice(WORKTREE_PAGE_CALLBACK_PREFIX.length);
+    if (!/^\d+$/.test(rawPage)) {
+        return null;
+    }
+    return Number.parseInt(rawPage, 10);
+}
+export function parseWorktreeIndexCallback(data) {
+    if (!data.startsWith(WORKTREE_CALLBACK_PREFIX) ||
+        data.startsWith(WORKTREE_PAGE_CALLBACK_PREFIX)) {
+        return null;
+    }
+    const rawIndex = data.slice(WORKTREE_CALLBACK_PREFIX.length);
+    if (!/^\d+$/.test(rawIndex)) {
+        return null;
+    }
+    return Number.parseInt(rawIndex, 10);
+}
+function buildWorktreeMenuText(page, totalPages) {
+    const baseText = t("worktree.select_with_current");
+    if (totalPages <= 1) {
+        return baseText;
+    }
+    return `${baseText}\n\n${t("projects.page_indicator", {
+        current: String(page + 1),
+        total: String(totalPages),
+    })}`;
+}
+function buildWorktreeKeyboard(worktrees, page) {
+    const keyboard = new InlineKeyboard();
+    const pageSize = config.bot.projectsListLimit;
+    const { page: normalizedPage, totalPages, startIndex, endIndex, } = calculateProjectsPaginationRange(worktrees.length, page, pageSize);
+    worktrees.slice(startIndex, endIndex).forEach((entry, index) => {
+        const label = buildWorktreeButtonLabel(startIndex + index, entry);
+        keyboard
+            .text(formatWorktreeButtonLabel(label, entry.isCurrent), `${WORKTREE_CALLBACK_PREFIX}${startIndex + index}`)
+            .row();
+    });
+    if (totalPages > 1) {
+        if (normalizedPage > 0) {
+            keyboard.text(t("projects.prev_page"), `${WORKTREE_PAGE_CALLBACK_PREFIX}${normalizedPage - 1}`);
+        }
+        if (normalizedPage < totalPages - 1) {
+            keyboard.text(t("projects.next_page"), `${WORKTREE_PAGE_CALLBACK_PREFIX}${normalizedPage + 1}`);
+        }
+    }
+    return keyboard;
+}
+export function buildWorktreeMenuView(worktrees, page) {
+    const { page: normalizedPage, totalPages } = calculateProjectsPaginationRange(worktrees.length, page, config.bot.projectsListLimit);
+    return {
+        text: buildWorktreeMenuText(normalizedPage, totalPages),
+        keyboard: buildWorktreeKeyboard(worktrees, normalizedPage),
+    };
+}

package/dist/bot/{utils → messages}/assistant-rendering.js

@@ -1,7 +1,7 @@
 import { config } from "../../config.js";
 import { logger } from "../../utils/logger.js";
-import { chunkTelegramRenderedBlocks } from "../../telegram/render/chunker.js";
-import { renderTelegramBlocks, renderTelegramParts } from "../../telegram/render/pipeline.js";
+import { chunkTelegramRenderedBlocks } from "../render/chunker.js";
+import { renderTelegramBlocks, renderTelegramParts } from "../render/pipeline.js";
 export function createPlainRenderedBlock(text) {
     return {
         blockType: "plain",

package/dist/bot/messages/busy-blocked-renderer.js

@@ -0,0 +1,11 @@
+import { t } from "../../i18n/index.js";
+export async function replyBusyBlocked(ctx) {
+    const message = t("bot.session_busy");
+    if (ctx.callbackQuery) {
+        await ctx.answerCallbackQuery({ text: message }).catch(() => { });
+        return;
+    }
+    if (ctx.chat) {
+        await ctx.reply(message).catch(() => { });
+    }
+}

package/dist/bot/messages/external-user-input-notification.js

@@ -0,0 +1,22 @@
+import { buildExternalUserInputNotification, } from "../../app/services/external-user-input-service.js";
+import { sendBotText } from "./telegram-text.js";
+async function sendExternalUserInputNotification(api, chatId, notification) {
+    await sendBotText({
+        api,
+        chatId,
+        text: notification.text,
+        rawFallbackText: notification.rawFallbackText,
+        format: "markdown_v2",
+    });
+}
+export async function deliverExternalUserInputNotification({ api, chatId, currentSessionId, sessionId, text, consumeSuppressedInput, }) {
+    const notification = buildExternalUserInputNotification(text);
+    if (!notification || currentSessionId !== sessionId) {
+        return false;
+    }
+    if (consumeSuppressedInput(sessionId, text)) {
+        return false;
+    }
+    await sendExternalUserInputNotification(api, chatId, notification);
+    return true;
+}

package/dist/bot/messages/scheduled-task-delivery.js

@@ -0,0 +1,63 @@
+import { config } from "../../config.js";
+import { escapePlainTextForTelegramMarkdownV2, formatSummaryWithMode, } from "./summary-message-formatter.js";
+import { sendBotText } from "./telegram-text.js";
+const TELEGRAM_MESSAGE_LIMIT = 4096;
+function getScheduledTaskDeliveryFormat() {
+    return config.bot.messageFormatMode === "markdown" ? "markdown_v2" : "raw";
+}
+function getSilentDeliveryOptions() {
+    return config.bot.scheduledTaskNotificationsSilent
+        ? { options: { disable_notification: true } }
+        : {};
+}
+function buildScheduledTaskSuccessMessageParts(delivery) {
+    if (!delivery.resultText) {
+        return [delivery.notificationText];
+    }
+    if (config.bot.messageFormatMode !== "markdown") {
+        return formatSummaryWithMode(`${delivery.notificationText}\n\n${delivery.resultText}`, config.bot.messageFormatMode);
+    }
+    const header = escapePlainTextForTelegramMarkdownV2(delivery.notificationText);
+    const resultParts = formatSummaryWithMode(delivery.resultText, config.bot.messageFormatMode);
+    if (resultParts.length === 0) {
+        return [header];
+    }
+    const firstPart = `${header}\n\n${resultParts[0]}`;
+    if (firstPart.length <= TELEGRAM_MESSAGE_LIMIT) {
+        return [firstPart, ...resultParts.slice(1)];
+    }
+    return [header, ...resultParts];
+}
+export function createScheduledTaskDeliverySender(api, chatId) {
+    return {
+        async send(delivery) {
+            const messageParts = delivery.status === "success"
+                ? buildScheduledTaskSuccessMessageParts(delivery)
+                : [delivery.notificationText];
+            const format = delivery.status === "success" ? getScheduledTaskDeliveryFormat() : "raw";
+            const suppressResultNotification = delivery.status === "success" && Boolean(delivery.footerText);
+            const resultDeliveryOptions = suppressResultNotification && !config.bot.scheduledTaskNotificationsSilent
+                ? { options: { disable_notification: true } }
+                : getSilentDeliveryOptions();
+            for (const part of messageParts) {
+                await sendBotText({
+                    api,
+                    chatId,
+                    text: part,
+                    format,
+                    ...resultDeliveryOptions,
+                });
+            }
+            if (delivery.status === "success" && delivery.footerText) {
+                await sendBotText({
+                    api,
+                    chatId,
+                    text: delivery.footerText,
+                    format: "raw",
+                    ...getSilentDeliveryOptions(),
+                });
+            }
+            return true;
+        },
+    };
+}

package/dist/bot/{utils → messages}/send-downloaded-file.js

@@ -1,7 +1,7 @@
 import { InputFile } from "grammy";
 import { promises as fs } from "node:fs";
 import path from "node:path";
-import { formatFileSize } from "./file-download.js";
+import { formatFileSize } from "../../app/services/file-download-service.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 const MAX_FILE_SIZE_MB = 50;

package/dist/bot/messages/summary-message-formatter.js

@@ -0,0 +1,130 @@
+import { config } from "../../config.js";
+import { logger } from "../../utils/logger.js";
+import { normalizeMarkdownForTelegramRendering } from "../render/markdown-normalizer.js";
+import { convertToTelegramMarkdownV2 } from "../render/markdown-to-telegram-v2.js";
+const TELEGRAM_MESSAGE_LIMIT = 4096;
+const MARKDOWN_V2_RESERVED_CHARS = /([_\*\[\]\(\)~`>#+\-=|{}.!\\])/g;
+function endsWithOddTrailingBackslashes(text, start, end) {
+    let backslashCount = 0;
+    for (let index = end - 1; index >= start; index--) {
+        if (text[index] !== "\\") {
+            break;
+        }
+        backslashCount += 1;
+    }
+    return backslashCount % 2 === 1;
+}
+function resolveSplitEndIndex(text, currentIndex, maxLength, options) {
+    const hardLimit = Math.min(text.length, currentIndex + maxLength);
+    if (hardLimit >= text.length) {
+        return text.length;
+    }
+    let endIndex = hardLimit;
+    const breakPoint = text.lastIndexOf("\n", endIndex);
+    if (breakPoint > currentIndex) {
+        endIndex = breakPoint + 1;
+    }
+    if (!options?.avoidTrailingMarkdownEscape) {
+        return endIndex;
+    }
+    while (endIndex > currentIndex && endsWithOddTrailingBackslashes(text, currentIndex, endIndex)) {
+        endIndex -= 1;
+    }
+    return endIndex > currentIndex ? endIndex : hardLimit;
+}
+function splitText(text, maxLength, options) {
+    const parts = [];
+    let currentIndex = 0;
+    while (currentIndex < text.length) {
+        const endIndex = resolveSplitEndIndex(text, currentIndex, maxLength, options);
+        if (endIndex <= currentIndex) {
+            const fallbackEnd = Math.min(text.length, currentIndex + 1);
+            parts.push(text.slice(currentIndex, fallbackEnd));
+            currentIndex = fallbackEnd;
+            continue;
+        }
+        parts.push(text.slice(currentIndex, endIndex));
+        currentIndex = endIndex;
+    }
+    return parts;
+}
+export function formatSummary(text) {
+    return formatSummaryWithMode(text, config.bot.messageFormatMode);
+}
+export function escapePlainTextForTelegramMarkdownV2(text) {
+    return text.replace(MARKDOWN_V2_RESERVED_CHARS, "\\$1");
+}
+function formatMarkdownForTelegram(text) {
+    try {
+        const preprocessed = normalizeMarkdownForTelegramRendering(text);
+        return escapeMarkdownV2PipesOutsideCode(convertToTelegramMarkdownV2(preprocessed));
+    }
+    catch (error) {
+        logger.warn("[Formatter] Failed to convert markdown summary, falling back to raw text", error);
+        return text;
+    }
+}
+function escapeMarkdownV2PipesOutsideCode(text) {
+    let result = "";
+    let index = 0;
+    let inInlineCode = false;
+    let inCodeFence = false;
+    while (index < text.length) {
+        if (text.startsWith("```", index)) {
+            result += "```";
+            index += 3;
+            inCodeFence = !inCodeFence;
+            continue;
+        }
+        const char = text[index];
+        if (!inCodeFence && char === "`") {
+            inInlineCode = !inInlineCode;
+            result += char;
+            index += 1;
+            continue;
+        }
+        if (!inCodeFence && !inInlineCode && char === "|" && text[index - 1] !== "\\") {
+            result += "\\|";
+            index += 1;
+            continue;
+        }
+        result += char;
+        index += 1;
+    }
+    return result;
+}
+export function formatSummaryWithMode(text, mode, maxLength = TELEGRAM_MESSAGE_LIMIT) {
+    if (!text || text.trim().length === 0) {
+        return [];
+    }
+    const normalizedMaxLength = Math.max(1, Math.floor(maxLength));
+    const rawTextLimit = mode === "raw" ? Math.max(1, normalizedMaxLength - "```\n\n```".length) : normalizedMaxLength;
+    const parts = splitText(text, rawTextLimit);
+    const formattedParts = [];
+    for (const part of parts) {
+        const trimmed = part.trim();
+        if (!trimmed) {
+            continue;
+        }
+        if (mode === "markdown") {
+            const converted = formatMarkdownForTelegram(trimmed);
+            const convertedParts = splitText(converted, normalizedMaxLength, {
+                avoidTrailingMarkdownEscape: true,
+            });
+            for (const convertedPart of convertedParts) {
+                const normalizedPart = convertedPart.trim();
+                if (normalizedPart) {
+                    formattedParts.push(normalizedPart);
+                }
+            }
+            continue;
+        }
+        if (parts.length > 1) {
+            formattedParts.push(`\`\`\`\n${trimmed}\n\`\`\``);
+        }
+        else {
+            formattedParts.push(trimmed);
+        }
+    }
+    return formattedParts;
+}

package/dist/bot/{utils → messages}/telegram-text.js

@@ -103,6 +103,66 @@ export async function editRenderedBotPart({ api, chatId, messageId, part, option
         };
     }
 }
+export async function sendDraftBotPart({ api, chatId, draftId, part, }) {
+    logger.debug("[Bot] Sending draft part", {
+        draftId,
+        textLength: part.text.length,
+        entityCount: part.entities?.length ?? 0,
+    });
+    if (!part.entities?.length) {
+        await api.sendMessageDraft(chatId, draftId, part.text);
+        return {
+            deliveredSignature: getTelegramRenderedPartSignature({ text: part.text }),
+        };
+    }
+    try {
+        await api.sendMessageDraft(chatId, draftId, part.text, {
+            entities: part.entities,
+        });
+        return {
+            deliveredSignature: getTelegramRenderedPartSignature(part),
+        };
+    }
+    catch (error) {
+        logger.warn("[Bot] Entity draft failed, retrying with raw fallback", error);
+        await api.sendMessageDraft(chatId, draftId, part.fallbackText);
+        return {
+            deliveredSignature: getTelegramRenderedPartSignature({ text: part.fallbackText }),
+        };
+    }
+}
+export async function completeDraftPart({ api, chatId, part, options, }) {
+    const rawOptions = stripRichFormattingOptions(options);
+    logger.debug("[Bot] Completing draft with real message", {
+        textLength: part.text.length,
+        entityCount: part.entities?.length ?? 0,
+    });
+    if (!part.entities?.length) {
+        const sentMessage = await api.sendMessage(chatId, part.text, rawOptions);
+        return {
+            messageId: sentMessage.message_id,
+            deliveredSignature: getTelegramRenderedPartSignature({ text: part.text }),
+        };
+    }
+    try {
+        const sentMessage = await api.sendMessage(chatId, part.text, {
+            ...(rawOptions || {}),
+            entities: part.entities,
+        });
+        return {
+            messageId: sentMessage.message_id,
+            deliveredSignature: getTelegramRenderedPartSignature(part),
+        };
+    }
+    catch (error) {
+        logger.warn("[Bot] Entity complete failed, retrying with raw fallback", error);
+        const sentMessage = await api.sendMessage(chatId, part.fallbackText, rawOptions);
+        return {
+            messageId: sentMessage.message_id,
+            deliveredSignature: getTelegramRenderedPartSignature({ text: part.fallbackText }),
+        };
+    }
+}
 export async function editBotText({ api, chatId, messageId, text, rawFallbackText, options, format = "raw", }) {
     await editMessageWithMarkdownFallback({
         api,