@grinev/opencode-telegram-bot 0.13.1 → 0.14.0

package/dist/summary/aggregator.js

@@ -39,6 +39,7 @@ class SummaryAggregator {
     onThinkingCallback = null;
     onTokensCallback = null;
     onCostCallback = null;
+    onSubagentCallback = null;
     onSessionCompactedCallback = null;
     onSessionErrorCallback = null;
     onSessionRetryCallback = null;
@@ -54,6 +55,13 @@ class SummaryAggregator {
     typingTimer = null;
     typingIndicatorEnabled = true;
     partHashes = new Map();
+    trackedSessionParents = new Map();
+    subagentStates = new Map();
+    subagentOrder = [];
+    subagentCardIdBySessionId = new Map();
+    pendingSubagentCardIdsByParent = new Map();
+    pendingChildSessionIdsByParent = new Map();
+    fallbackSubagentCardIdsByParent = new Map();
     setBotAndChatId(bot, chatId) {
         this.bot = bot;
         this.chatId = chatId;
@@ -85,6 +93,9 @@ class SummaryAggregator {
     setOnCost(callback) {
         this.onCostCallback = callback;
     }
+    setOnSubagent(callback) {
+        this.onSubagentCallback = callback;
+    }
     setOnSessionCompacted(callback) {
         this.onSessionCompactedCallback = callback;
     }
@@ -150,6 +161,10 @@ class SummaryAggregator {
             logger.debug(`[Aggregator] Session event: ${event.type}`, JSON.stringify(event.properties, null, 2));
         }
         switch (event.type) {
+            case "session.created":
+            case "session.updated":
+                this.handleSessionCreatedOrUpdated(event);
+                break;
             case "message.updated":
                 this.handleMessageUpdated(event);
                 break;
@@ -195,6 +210,7 @@ class SummaryAggregator {
         if (this.currentSessionId !== sessionId) {
             this.clear();
             this.currentSessionId = sessionId;
+            this.trackedSessionParents.set(sessionId, null);
         }
     }
     clear() {
@@ -206,6 +222,13 @@ class SummaryAggregator {
         this.knownTextPartIds.clear();
         this.processedToolStates.clear();
         this.thinkingFiredForMessages.clear();
+        this.trackedSessionParents.clear();
+        this.subagentStates.clear();
+        this.subagentOrder = [];
+        this.subagentCardIdBySessionId.clear();
+        this.pendingSubagentCardIdsByParent.clear();
+        this.pendingChildSessionIdsByParent.clear();
+        this.fallbackSubagentCardIdsByParent.clear();
         this.messageCount = 0;
         this.lastUpdated = 0;
         if (this.onClearedCallback) {
@@ -217,8 +240,362 @@ class SummaryAggregator {
             }
         }
     }
+    isTrackedChildSession(sessionId) {
+        return this.trackedSessionParents.has(sessionId) && sessionId !== this.currentSessionId;
+    }
+    getQueue(map, parentSessionId) {
+        const existing = map.get(parentSessionId);
+        if (existing) {
+            return existing;
+        }
+        const queue = [];
+        map.set(parentSessionId, queue);
+        return queue;
+    }
+    dequeue(map, parentSessionId) {
+        const queue = map.get(parentSessionId);
+        if (!queue || queue.length === 0) {
+            return undefined;
+        }
+        const value = queue.shift();
+        if (queue.length === 0) {
+            map.delete(parentSessionId);
+        }
+        return value;
+    }
+    removeFromQueue(map, parentSessionId, value) {
+        const queue = map.get(parentSessionId);
+        if (!queue) {
+            return;
+        }
+        const index = queue.indexOf(value);
+        if (index >= 0) {
+            queue.splice(index, 1);
+        }
+        if (queue.length === 0) {
+            map.delete(parentSessionId);
+        }
+    }
+    emitSubagentState() {
+        if (!this.currentSessionId || !this.onSubagentCallback || this.subagentOrder.length === 0) {
+            return;
+        }
+        const subagents = this.subagentOrder
+            .map((cardId) => this.subagentStates.get(cardId))
+            .filter((state) => Boolean(state))
+            .map((state) => ({
+            cardId: state.cardId,
+            sessionId: state.sessionId,
+            parentSessionId: state.parentSessionId,
+            agent: state.agent,
+            description: state.description,
+            prompt: state.prompt,
+            command: state.command,
+            status: state.status,
+            providerID: state.providerID,
+            modelID: state.modelID,
+            tokens: { ...state.tokens },
+            cost: state.cost,
+            currentTool: state.currentTool,
+            currentToolInput: state.currentToolInput ? { ...state.currentToolInput } : undefined,
+            currentToolTitle: state.currentToolTitle,
+            terminalMessage: state.terminalMessage,
+            updatedAt: state.updatedAt,
+        }));
+        this.onSubagentCallback(this.currentSessionId, subagents);
+    }
+    createSubagentState(parentSessionId, sessionId, cardId = `subagent-${parentSessionId}-${Date.now()}-${this.subagentOrder.length}`) {
+        const state = {
+            cardId,
+            sessionId,
+            parentSessionId,
+            agent: "",
+            description: "",
+            prompt: "",
+            status: "pending",
+            tokens: {
+                input: 0,
+                output: 0,
+                reasoning: 0,
+                cacheRead: 0,
+                cacheWrite: 0,
+            },
+            cost: 0,
+            terminalMessage: undefined,
+            updatedAt: Date.now(),
+            hasSubtaskMetadata: false,
+            hasTaskToolMetadata: false,
+            hasSessionTitleMetadata: false,
+            createdAt: Date.now(),
+        };
+        this.subagentStates.set(cardId, state);
+        this.subagentOrder.push(cardId);
+        if (sessionId) {
+            this.subagentCardIdBySessionId.set(sessionId, cardId);
+        }
+        return state;
+    }
+    enrichSubagentFromSubtask(state, details) {
+        state.agent = details.agent || state.agent;
+        state.description = details.description || details.prompt || state.description;
+        state.prompt = details.prompt;
+        state.command = details.command;
+        state.hasSubtaskMetadata = true;
+        state.updatedAt = Date.now();
+    }
+    enrichSubagentFromTaskTool(state, details) {
+        const nextDescription = details.description?.trim() || details.prompt?.trim();
+        if (details.agent?.trim()) {
+            state.agent = details.agent.trim();
+        }
+        if (nextDescription) {
+            state.description = nextDescription;
+        }
+        if (details.prompt?.trim()) {
+            state.prompt = details.prompt.trim();
+        }
+        if (details.command?.trim()) {
+            state.command = details.command.trim();
+        }
+        state.hasTaskToolMetadata = true;
+        state.updatedAt = Date.now();
+    }
+    enrichSubagentFromSessionTitle(state, title) {
+        const trimmedTitle = title?.trim();
+        if (!trimmedTitle) {
+            return;
+        }
+        const match = trimmedTitle.match(/^(.*?)(?:\s+\(@([^\s)]+)\s+subagent\))?$/i);
+        const rawDescription = match?.[1]?.trim() || trimmedTitle;
+        const rawAgent = match?.[2]?.trim();
+        if (rawDescription) {
+            state.description = rawDescription;
+        }
+        if (rawAgent) {
+            state.agent = rawAgent.replace(/^@/, "");
+        }
+        state.hasSessionTitleMetadata = true;
+        state.updatedAt = Date.now();
+    }
+    attachSessionToSubagent(cardId, sessionId) {
+        const state = this.subagentStates.get(cardId);
+        if (!state) {
+            return;
+        }
+        state.sessionId = sessionId;
+        state.updatedAt = Date.now();
+        this.subagentCardIdBySessionId.set(sessionId, cardId);
+        this.removeFromQueue(this.pendingSubagentCardIdsByParent, state.parentSessionId, cardId);
+    }
+    findPendingSubagentWithoutSession() {
+        for (const cardId of this.subagentOrder) {
+            const state = this.subagentStates.get(cardId);
+            if (state && !state.sessionId) {
+                return state;
+            }
+        }
+        return null;
+    }
+    attachUnknownSessionToPendingSubagent(sessionId) {
+        const pendingState = this.findPendingSubagentWithoutSession();
+        if (!pendingState) {
+            return false;
+        }
+        this.trackedSessionParents.set(sessionId, pendingState.parentSessionId);
+        this.attachSessionToSubagent(pendingState.cardId, sessionId);
+        this.removeFromQueue(this.pendingChildSessionIdsByParent, pendingState.parentSessionId, sessionId);
+        this.emitSubagentState();
+        return true;
+    }
+    findNextSubagentForTaskTool(parentSessionId) {
+        for (const cardId of this.subagentOrder) {
+            const state = this.subagentStates.get(cardId);
+            if (state && state.parentSessionId === parentSessionId && !state.hasTaskToolMetadata) {
+                return state;
+            }
+        }
+        return null;
+    }
+    updateSubagentFromTaskTool(parentSessionId, input) {
+        const subagent = this.findNextSubagentForTaskTool(parentSessionId);
+        if (!subagent || !input) {
+            return;
+        }
+        const description = typeof input.description === "string" ? input.description : undefined;
+        const prompt = typeof input.prompt === "string" ? input.prompt : undefined;
+        const agent = typeof input.subagent_type === "string" ? input.subagent_type : undefined;
+        const command = typeof input.command === "string" ? input.command : undefined;
+        if (!description && !prompt && !agent && !command) {
+            return;
+        }
+        this.enrichSubagentFromTaskTool(subagent, { agent, description, prompt, command });
+        this.emitSubagentState();
+    }
+    getOrCreateSubagentForSession(sessionId) {
+        const existingCardId = this.subagentCardIdBySessionId.get(sessionId);
+        if (existingCardId) {
+            return this.subagentStates.get(existingCardId);
+        }
+        const parentSessionId = this.trackedSessionParents.get(sessionId) ?? this.currentSessionId ?? sessionId;
+        this.removeFromQueue(this.pendingChildSessionIdsByParent, parentSessionId, sessionId);
+        const state = this.createSubagentState(parentSessionId, sessionId);
+        this.getQueue(this.fallbackSubagentCardIdsByParent, parentSessionId).push(state.cardId);
+        return state;
+    }
+    registerSubtaskPart(parentSessionId, partId, agent, description, prompt, command) {
+        const fallbackCardId = this.dequeue(this.fallbackSubagentCardIdsByParent, parentSessionId);
+        if (fallbackCardId) {
+            const fallbackState = this.subagentStates.get(fallbackCardId);
+            if (fallbackState) {
+                this.enrichSubagentFromSubtask(fallbackState, { agent, description, prompt, command });
+                this.emitSubagentState();
+                return;
+            }
+        }
+        const state = this.createSubagentState(parentSessionId, null, `subtask-${parentSessionId}-${partId}`);
+        this.enrichSubagentFromSubtask(state, { agent, description, prompt, command });
+        const pendingChildSessionId = this.dequeue(this.pendingChildSessionIdsByParent, parentSessionId);
+        if (pendingChildSessionId) {
+            this.attachSessionToSubagent(state.cardId, pendingChildSessionId);
+        }
+        else {
+            this.getQueue(this.pendingSubagentCardIdsByParent, parentSessionId).push(state.cardId);
+        }
+        this.emitSubagentState();
+    }
+    trackChildSession(sessionId, parentSessionId) {
+        this.trackedSessionParents.set(sessionId, parentSessionId);
+        const pendingCardId = this.dequeue(this.pendingSubagentCardIdsByParent, parentSessionId);
+        if (pendingCardId) {
+            this.attachSessionToSubagent(pendingCardId, sessionId);
+            this.emitSubagentState();
+            return;
+        }
+        this.getQueue(this.pendingChildSessionIdsByParent, parentSessionId).push(sessionId);
+    }
+    handleSessionCreatedOrUpdated(event) {
+        if (!this.currentSessionId) {
+            return;
+        }
+        const { info } = event.properties;
+        if (!info.parentID) {
+            return;
+        }
+        if (!this.trackedSessionParents.has(info.parentID)) {
+            return;
+        }
+        if (info.id === this.currentSessionId) {
+            return;
+        }
+        if (!this.trackedSessionParents.has(info.id)) {
+            this.trackChildSession(info.id, info.parentID);
+        }
+        const subagent = this.getOrCreateSubagentForSession(info.id);
+        this.enrichSubagentFromSessionTitle(subagent, info.title);
+        this.emitSubagentState();
+    }
+    updateSubagentFromAssistantMessage(info) {
+        const subagent = this.getOrCreateSubagentForSession(info.sessionID);
+        if (info.agent) {
+            subagent.agent = info.agent;
+        }
+        if (info.providerID) {
+            subagent.providerID = info.providerID;
+        }
+        if (info.modelID) {
+            subagent.modelID = info.modelID;
+        }
+        if (info.tokens) {
+            subagent.tokens = {
+                input: info.tokens.input,
+                output: info.tokens.output,
+                reasoning: info.tokens.reasoning,
+                cacheRead: info.tokens.cache?.read || 0,
+                cacheWrite: info.tokens.cache?.write || 0,
+            };
+        }
+        if (typeof info.cost === "number") {
+            subagent.cost = info.cost;
+        }
+        subagent.updatedAt = Date.now();
+        this.emitSubagentState();
+    }
+    updateSubagentToolState(sessionId, state, tool, input, title) {
+        const subagent = this.getOrCreateSubagentForSession(sessionId);
+        const status = "status" in state ? state.status : undefined;
+        if (status === "running") {
+            subagent.status = "running";
+            subagent.terminalMessage = undefined;
+        }
+        if (status === "pending" && subagent.status === "pending") {
+            subagent.status = "pending";
+            subagent.terminalMessage = undefined;
+        }
+        subagent.currentTool = tool;
+        subagent.currentToolInput = input ? { ...input } : undefined;
+        subagent.currentToolTitle = title;
+        subagent.updatedAt = Date.now();
+        this.emitSubagentState();
+    }
+    updateSubagentStepStart(sessionId, snapshot) {
+        const subagent = this.getOrCreateSubagentForSession(sessionId);
+        subagent.status = "running";
+        subagent.terminalMessage = undefined;
+        subagent.currentTool = undefined;
+        subagent.currentToolInput = undefined;
+        subagent.currentToolTitle = snapshot?.trim() || subagent.currentToolTitle;
+        subagent.updatedAt = Date.now();
+        this.emitSubagentState();
+    }
+    updateSubagentStepFinish(sessionId, tokens, cost, snapshot) {
+        const subagent = this.getOrCreateSubagentForSession(sessionId);
+        subagent.status = "running";
+        subagent.terminalMessage = undefined;
+        subagent.tokens = {
+            input: tokens.input,
+            output: tokens.output,
+            reasoning: tokens.reasoning,
+            cacheRead: tokens.cache.read,
+            cacheWrite: tokens.cache.write,
+        };
+        subagent.cost += cost;
+        if (snapshot?.trim()) {
+            subagent.currentToolTitle = snapshot.trim();
+        }
+        subagent.updatedAt = Date.now();
+        this.emitSubagentState();
+    }
+    setSubagentTerminalStatus(sessionId, status, terminalMessage) {
+        const cardId = this.subagentCardIdBySessionId.get(sessionId);
+        if (!cardId) {
+            return;
+        }
+        const subagent = this.subagentStates.get(cardId);
+        if (!subagent) {
+            return;
+        }
+        subagent.status = status;
+        subagent.currentTool = undefined;
+        subagent.currentToolInput = undefined;
+        subagent.currentToolTitle = undefined;
+        subagent.terminalMessage = terminalMessage?.trim() || undefined;
+        subagent.updatedAt = Date.now();
+        this.emitSubagentState();
+    }
     handleMessageUpdated(event) {
         const { info } = event.properties;
+        if (info.sessionID !== this.currentSessionId &&
+            !this.trackedSessionParents.has(info.sessionID) &&
+            info.role === "assistant") {
+            this.attachUnknownSessionToPendingSubagent(info.sessionID);
+        }
+        if (this.isTrackedChildSession(info.sessionID)) {
+            if (info.role === "assistant") {
+                const assistantInfo = info;
+                this.updateSubagentFromAssistantMessage(assistantInfo);
+            }
+            return;
+        }
         if (info.sessionID !== this.currentSessionId) {
             return;
         }
@@ -242,23 +619,24 @@ class SummaryAggregator {
             if (!isCompleted && textState.optimisticUpdateCount === 1) {
                 this.emitPartialText(info.sessionID, messageID, messageText);
             }
+            // Extract and report tokens for EVERY message.updated with token data
+            // (both intermediate and completed). This keeps keyboard context in sync.
+            const assistantInfo = info;
+            if (this.onTokensCallback && assistantInfo.tokens) {
+                const tokens = {
+                    input: assistantInfo.tokens.input,
+                    output: assistantInfo.tokens.output,
+                    reasoning: assistantInfo.tokens.reasoning,
+                    cacheRead: assistantInfo.tokens.cache?.read || 0,
+                    cacheWrite: assistantInfo.tokens.cache?.write || 0,
+                };
+                logger.debug(`[Aggregator] Tokens: input=${tokens.input}, output=${tokens.output}, reasoning=${tokens.reasoning}, cacheRead=${tokens.cacheRead}, cacheWrite=${tokens.cacheWrite}, completed=${isCompleted}`);
+                // Call synchronously so keyboardManager is updated before onComplete sends the reply
+                this.onTokensCallback(tokens, isCompleted);
+            }
             if (isCompleted) {
                 const finalText = messageText;
                 logger.debug(`[Aggregator] Message part completed: messageId=${messageID}, textLength=${finalText.length}, totalParts=${textState.orderedPartIds.length}, session=${this.currentSessionId}`);
-                // Extract and report tokens BEFORE onComplete so keyboard context is updated
-                const assistantInfo = info;
-                if (this.onTokensCallback && assistantInfo.tokens) {
-                    const tokens = {
-                        input: assistantInfo.tokens.input,
-                        output: assistantInfo.tokens.output,
-                        reasoning: assistantInfo.tokens.reasoning,
-                        cacheRead: assistantInfo.tokens.cache?.read || 0,
-                        cacheWrite: assistantInfo.tokens.cache?.write || 0,
-                    };
-                    logger.debug(`[Aggregator] Tokens: input=${tokens.input}, output=${tokens.output}, reasoning=${tokens.reasoning}`);
-                    // Call synchronously so keyboardManager is updated before onComplete sends the reply
-                    this.onTokensCallback(tokens);
-                }
                 // Extract and report cost
                 if (this.onCostCallback && assistantInfo.cost !== undefined) {
                     logger.debug(`[Aggregator] Cost: $${assistantInfo.cost.toFixed(2)}`);
@@ -282,7 +660,35 @@ class SummaryAggregator {
     }
     handleMessagePartUpdated(event) {
         const { part } = event.properties;
-        if (part.sessionID !== this.currentSessionId) {
+        if (part.sessionID !== this.currentSessionId &&
+            !this.trackedSessionParents.has(part.sessionID) &&
+            part.type !== "subtask") {
+            this.attachUnknownSessionToPendingSubagent(part.sessionID);
+        }
+        const isCurrentRootSession = part.sessionID === this.currentSessionId;
+        const isTrackedChildSession = this.isTrackedChildSession(part.sessionID);
+        if (!isCurrentRootSession && !isTrackedChildSession) {
+            return;
+        }
+        if (part.type === "subtask") {
+            this.registerSubtaskPart(part.sessionID, part.id, part.agent, part.description, part.prompt, part.command);
+            this.lastUpdated = Date.now();
+            return;
+        }
+        if (isTrackedChildSession) {
+            if (part.type === "tool") {
+                const state = part.state;
+                const input = "input" in state ? state.input : undefined;
+                const title = "title" in state ? state.title : undefined;
+                this.updateSubagentToolState(part.sessionID, state, part.tool, input, title);
+            }
+            if (part.type === "step-start") {
+                this.updateSubagentStepStart(part.sessionID, part.snapshot);
+            }
+            if (part.type === "step-finish") {
+                this.updateSubagentStepFinish(part.sessionID, part.tokens, part.cost, part.snapshot);
+            }
+            this.lastUpdated = Date.now();
             return;
         }
         const messageID = part.messageID;
@@ -337,6 +743,9 @@ class SummaryAggregator {
             const state = part.state;
             const input = "input" in state ? state.input : undefined;
             const title = "title" in state ? state.title : undefined;
+            if (part.tool === "task") {
+                this.updateSubagentFromTaskTool(part.sessionID, input);
+            }
             logger.debug(`[Aggregator] Tool event: callID=${part.callID}, tool=${part.tool}, status=${"status" in state ? state.status : "unknown"}`);
             if (part.tool === "question") {
                 logger.debug(`[Aggregator] Question tool part update:`, JSON.stringify(part, null, 2));
@@ -618,6 +1027,11 @@ class SummaryAggregator {
     }
     handleSessionIdle(event) {
         const { sessionID } = event.properties;
+        if (this.isTrackedChildSession(sessionID)) {
+            logger.info(`[Aggregator] Subagent session became idle: ${sessionID}`);
+            this.setSubagentTerminalStatus(sessionID, "completed");
+            return;
+        }
         if (sessionID !== this.currentSessionId) {
             return;
         }
@@ -644,10 +1058,15 @@ class SummaryAggregator {
     }
     handleSessionError(event) {
         const { sessionID, error } = event.properties;
+        const message = error?.data?.message || error?.message || error?.name || "Unknown session error";
+        if (sessionID && this.isTrackedChildSession(sessionID)) {
+            logger.warn(`[Aggregator] Subagent session error: ${sessionID}: ${message}`);
+            this.setSubagentTerminalStatus(sessionID, "error", message);
+            return;
+        }
         if (sessionID !== this.currentSessionId) {
             return;
         }
-        const message = error?.data?.message || error?.message || error?.name || "Unknown session error";
         logger.warn(`[Aggregator] Session error: ${sessionID}: ${message}`);
         this.stopTypingIndicator();
         if (this.onSessionErrorCallback) {

package/dist/summary/formatter.js

@@ -5,18 +5,45 @@ import { logger } from "../utils/logger.js";
 import { t } from "../i18n/index.js";
 import { getCurrentProject } from "../settings/manager.js";
 const TELEGRAM_MESSAGE_LIMIT = 4096;
-function splitText(text, maxLength) {
+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) {
-        let endIndex = currentIndex + maxLength;
-        if (endIndex >= text.length) {
-            parts.push(text.slice(currentIndex));
-            break;
-        }
-        const breakPoint = text.lastIndexOf("\n", endIndex);
-        if (breakPoint > currentIndex) {
-            endIndex = breakPoint + 1;
+        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;
@@ -134,16 +161,48 @@ export function getAssistantParseMode() {
     }
     return undefined;
 }
+export function escapePlainTextForTelegramMarkdownV2(text) {
+    return text.replace(MARKDOWN_V2_RESERVED_CHARS, "\\$1");
+}
 function formatMarkdownForTelegram(text) {
     try {
         const preprocessed = preprocessMarkdownForTelegram(text);
-        return convert(preprocessed, "keep");
+        return escapeMarkdownV2PipesOutsideCode(convert(preprocessed, "keep"));
     }
     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 [];
@@ -159,7 +218,9 @@ export function formatSummaryWithMode(text, mode, maxLength = TELEGRAM_MESSAGE_L
         }
         if (mode === "markdown") {
             const converted = formatMarkdownForTelegram(trimmed);
-            const convertedParts = splitText(converted, normalizedMaxLength);
+            const convertedParts = splitText(converted, normalizedMaxLength, {
+                avoidTrailingMarkdownEscape: true,
+            });
             for (const convertedPart of convertedParts) {
                 const normalizedPart = convertedPart.trim();
                 if (normalizedPart) {
@@ -310,7 +371,7 @@ export function formatToolInfo(toolInfo) {
         const todos = toolInfo.metadata.todos;
         const toolIcon = getToolIcon(tool);
         const todosList = formatTodos(todos);
-        return `${toolIcon} ${tool} (${todos.length})\n${todosList}`;
+        return `${toolIcon} ${tool} (${todos.length})\n\n${todosList}`;
     }
     let details = title || getToolDetails(tool, input);
     const toolIcon = getToolIcon(tool);
@@ -360,6 +421,17 @@ export function formatToolInfo(toolInfo) {
     }
     return `${toolIcon} ${description}${tool}${detailsStr}${lineInfo}`;
 }
+export function formatCompactToolInfo(toolInfo, maxLength = 64, fallback = "-") {
+    const formatted = formatToolInfo(toolInfo);
+    const normalized = formatted?.replace(/\s*\n+\s*/g, " ").trim() ?? "";
+    if (!normalized) {
+        return fallback;
+    }
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    return `${normalized.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...`;
+}
 function countLines(text) {
     return text.split("\n").length;
 }