From e318bcba46e2bead7cd284fdba352b07c01577ab Mon Sep 17 00:00:00 2001 From: 0xmrpeter <0xmrpeter@gmail.com> Date: Sun, 29 Mar 2026 19:50:15 +0700 Subject: [PATCH] =?UTF-8?q?fix:=20tool=20card=20display=20issues=20?= =?UTF-8?q?=E2=80=94=20serial=20dispatch,=20overflow=20editing,=20thinking?= =?UTF-8?q?=20cleanup?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Serialize per-session message dispatch to prevent out-of-order event processing (tool_update arriving before tool_call due to concurrent fire-and-forget dispatch) - Buffer tool updates that arrive before their tool_call and apply on addTool - Allow post-finalize tool updates to flush immediately (late completion after seal) - Track overflow message IDs and edit them instead of only sending once - Forward tool updates to previous sealed card for late completions - Count failed/error tools as done in header (Tools N/N ✅) - Stop deleting thinking indicator messages to reduce Telegram API calls Co-Authored-By: Claude Opus 4.6 (1M context) --- .../primitives/tool-card-state.ts | 31 ++++++++++--- .../telegram/__tests__/activity.test.ts | 37 ++++++--------- src/plugins/telegram/activity.ts | 45 ++++++++++--------- src/plugins/telegram/adapter.ts | 38 +++++++++++----- 4 files changed, 91 insertions(+), 60 deletions(-) diff --git a/src/core/adapter-primitives/primitives/tool-card-state.ts b/src/core/adapter-primitives/primitives/tool-card-state.ts index bbf9a84..6cc3f6e 100644 --- a/src/core/adapter-primitives/primitives/tool-card-state.ts +++ b/src/core/adapter-primitives/primitives/tool-card-state.ts @@ -9,7 +9,6 @@ import { formatToolSummary, resolveToolIcon, } from "../message-formatter.js"; - const DEBOUNCE_MS = 500; export interface ToolCardEntry { @@ -55,6 +54,8 @@ export class ToolCardState { private debounceTimer?: ReturnType; private verbosity: DisplayVerbosity; private onFlush: (snapshot: ToolCardSnapshot) => void; + /** Buffer for tool updates that arrive before their tool_call (out-of-order dispatch) */ + private pendingUpdates = new Map(); constructor(config: ToolCardStateConfig) { this.verbosity = config.verbosity; @@ -78,6 +79,17 @@ export class ToolCardState { viewerFilePath: meta.viewerFilePath, hidden, }; + + // Apply buffered updates that arrived before this tool_call (out-of-order dispatch) + const pending = this.pendingUpdates.get(meta.id); + if (pending) { + entry.status = pending.status; + entry.icon = resolveToolIcon({ status: pending.status, kind }); + if (pending.viewerLinks) entry.viewerLinks = pending.viewerLinks; + if (pending.viewerFilePath) entry.viewerFilePath = pending.viewerFilePath; + this.pendingUpdates.delete(meta.id); + } + this.entries.push(entry); if (this.isFirstFlush) { @@ -94,16 +106,24 @@ export class ToolCardState { viewerLinks?: ViewerLinks, viewerFilePath?: string, ): void { - if (this.finalized) return; - const entry = this.entries.find((e) => e.id === id); - if (!entry) return; + if (!entry) { + // Buffer the update — tool_call may arrive later (out-of-order concurrent dispatch) + this.pendingUpdates.set(id, { status, viewerLinks, viewerFilePath }); + return; + } entry.status = status; entry.icon = resolveToolIcon({ status, kind: entry.kind }); if (viewerLinks) entry.viewerLinks = viewerLinks; if (viewerFilePath) entry.viewerFilePath = viewerFilePath; + if (this.finalized) { + // Post-finalize update (e.g. last tool completed after card was sealed): + // flush immediately so the final status is rendered. + this.onFlush(this.snapshot()); + return; + } this.scheduleFlush(); } @@ -143,8 +163,9 @@ export class ToolCardState { private snapshot(): ToolCardSnapshot { const visible = this.entries.filter((e) => !e.hidden); + const DONE_STATUSES = new Set(["completed", "done", "failed", "error"]); const completedVisible = visible.filter( - (e) => e.status === "completed" || e.status === "done", + (e) => DONE_STATUSES.has(e.status), ).length; const allComplete = visible.length > 0 && completedVisible === visible.length; diff --git a/src/plugins/telegram/__tests__/activity.test.ts b/src/plugins/telegram/__tests__/activity.test.ts index cc66a33..10d880d 100644 --- a/src/plugins/telegram/__tests__/activity.test.ts +++ b/src/plugins/telegram/__tests__/activity.test.ts @@ -65,24 +65,15 @@ describe("ThinkingIndicator", () => { expect(api.sendMessage).toHaveBeenCalledOnce(); }); - it("dismiss() deletes the Telegram message when msgId exists", async () => { + it("dismiss() leaves message in chat (no deleteMessage to save API calls)", async () => { await indicator.show(); - await indicator.dismiss(); - expect(api.deleteMessage).toHaveBeenCalledOnce(); - expect(api.deleteMessage).toHaveBeenCalledWith(100, 42); - }); - - it("dismiss() does not call deleteMessage when no message was sent", async () => { await indicator.dismiss(); expect(api.deleteMessage).not.toHaveBeenCalled(); }); - it("dismiss() swallows errors from deleteMessage", async () => { - api.deleteMessage.mockRejectedValueOnce(new Error("already deleted")); - await indicator.show(); - // Should not throw + it("dismiss() is safe when no message was sent", async () => { await indicator.dismiss(); - expect(api.deleteMessage).toHaveBeenCalledOnce(); + expect(api.deleteMessage).not.toHaveBeenCalled(); }); it("show() works again after dismiss() + reset()", async () => { @@ -100,7 +91,7 @@ describe("ThinkingIndicator", () => { expect(api.sendMessage).toHaveBeenCalledOnce(); }); - it("show() deletes just-sent message if dismissed during queue wait (C17)", async () => { + it("show() leaves just-sent message if dismissed during queue wait", async () => { // Simulate a slow queue: enqueue holds the promise until we resolve it let resolveEnqueue!: (val: unknown) => void; const slowQueue = { @@ -126,9 +117,9 @@ describe("ThinkingIndicator", () => { await resolveEnqueue(undefined); await showPromise; - // The message was sent but should be immediately deleted + // The message was sent but NOT deleted (saves API calls) expect(api.sendMessage).toHaveBeenCalledOnce(); - expect(api.deleteMessage).toHaveBeenCalledWith(100, 42); + expect(api.deleteMessage).not.toHaveBeenCalled(); }); }); @@ -225,16 +216,16 @@ describe("ActivityTracker", () => { expect(api.sendMessage).toHaveBeenCalledOnce(); }); - it("onToolCall() dismisses thinking and deletes message", async () => { + it("onToolCall() dismisses thinking (no delete)", async () => { await tracker.onThought(); await tracker.onToolCall(makeMeta(), "file_read", { path: "/tmp/foo" }); - expect(api.deleteMessage).toHaveBeenCalledWith(100, 42); + expect(api.deleteMessage).not.toHaveBeenCalled(); }); - it("onTextStart() dismisses thinking and deletes message", async () => { + it("onTextStart() dismisses thinking (no delete)", async () => { await tracker.onThought(); await tracker.onTextStart(); - expect(api.deleteMessage).toHaveBeenCalledWith(100, 42); + expect(api.deleteMessage).not.toHaveBeenCalled(); }); it("sendUsage() is a no-op (usage is sent as separate message by adapter)", async () => { @@ -244,10 +235,10 @@ describe("ActivityTracker", () => { expect(api.sendMessage).not.toHaveBeenCalled(); }); - it("onNewPrompt() dismisses thinking and deletes message", async () => { + it("onNewPrompt() dismisses thinking (no delete)", async () => { await tracker.onThought(); await tracker.onNewPrompt(); - expect(api.deleteMessage).toHaveBeenCalledWith(100, 42); + expect(api.deleteMessage).not.toHaveBeenCalled(); }); it("cleanup() finalizes toolCard and dismisses thinking", async () => { @@ -259,11 +250,11 @@ describe("ActivityTracker", () => { expect(true).toBe(true); }); - it("onNewPrompt() deletes thinking message", async () => { + it("onNewPrompt() dismisses thinking (message left in chat)", async () => { await tracker.onThought(); expect(api.sendMessage).toHaveBeenCalledOnce(); await tracker.onNewPrompt(); - expect(api.deleteMessage).toHaveBeenCalledWith(100, 42); + expect(api.deleteMessage).not.toHaveBeenCalled(); }); it("getToolCardMsgId() returns undefined when no tool content", () => { diff --git a/src/plugins/telegram/activity.ts b/src/plugins/telegram/activity.ts index 16d8c06..f5ca31e 100644 --- a/src/plugins/telegram/activity.ts +++ b/src/plugins/telegram/activity.ts @@ -46,12 +46,7 @@ export class ThinkingIndicator { ); if (result) { if (this.dismissed) { - // dismissed during queue wait — delete the just-sent message - try { - await this.api.deleteMessage(this.chatId, result.message_id); - } catch { - // Message may already be deleted - } + // dismissed during queue wait — message stays in chat (no delete to save API calls) } else { this.msgId = result.message_id; this.startRefreshTimer(); @@ -64,20 +59,12 @@ export class ThinkingIndicator { } } - /** Dismiss indicator: stops refresh timer and deletes the Telegram message */ + /** Dismiss indicator: stops refresh timer. Message is left in chat to reduce API calls. */ async dismiss(): Promise { if (this.dismissed) return; this.dismissed = true; this.stopRefreshTimer(); - const msgId = this.msgId; this.msgId = undefined; - if (msgId) { - try { - await this.api.deleteMessage(this.chatId, msgId); - } catch { - // Message may already be deleted - } - } } /** Reset for a new prompt cycle */ @@ -128,7 +115,7 @@ export class ToolCard { private msgId?: number; private lastSentText?: string; private flushPromise: Promise = Promise.resolve(); - private overflowCount = 0; + private overflowMsgIds: number[] = []; constructor( private api: Bot["api"], @@ -217,18 +204,29 @@ export class ToolCard { if (result) this.msgId = result.message_id; } - // Overflow chunks: always send as new messages + // Overflow chunks: edit existing overflow messages or send new ones for (let i = 1; i < chunks.length; i++) { - // Only send overflow chunks that haven't been sent yet - if (i > this.overflowCount) { + const overflowIdx = i - 1; // index into overflowMsgIds + if (overflowIdx < this.overflowMsgIds.length) { + // Edit existing overflow message await this.sendQueue.enqueue(() => + this.api.editMessageText( + this.chatId, + this.overflowMsgIds[overflowIdx], + chunks[i], + { parse_mode: "HTML" }, + ), + ); + } else { + // Send new overflow message + const result = await this.sendQueue.enqueue(() => this.api.sendMessage(this.chatId, chunks[i], { message_thread_id: this.threadId, parse_mode: "HTML", disable_notification: true, }), ); - this.overflowCount = i; + if (result) this.overflowMsgIds.push(result.message_id); } } } catch (err) { @@ -243,6 +241,7 @@ export class ActivityTracker { private isFirstEvent = true; private thinking: ThinkingIndicator; private toolCard: ToolCard; + private previousToolCard?: ToolCard; private verbosity: DisplayVerbosity; constructor( @@ -303,6 +302,9 @@ export class ActivityTracker { private async sealToolCardIfNeeded(): Promise { if (!this.toolCard.hasContent()) return; await this.toolCard.finalize(); + // Keep reference so late tool_updates (e.g. last tool completing after text starts) + // can still reach the sealed card and update its status. + this.previousToolCard = this.toolCard; this.toolCard = new ToolCard( this.api, this.chatId, @@ -319,6 +321,9 @@ export class ActivityTracker { viewerFilePath?: string, ): Promise { this.toolCard.updateTool(id, status, viewerLinks, viewerFilePath); + // Forward to previous sealed card — the tool may belong there if text/thought + // started before this tool's completion update arrived. + this.previousToolCard?.updateTool(id, status, viewerLinks, viewerFilePath); } async onPlan(entries: PlanEntry[]): Promise { diff --git a/src/plugins/telegram/adapter.ts b/src/plugins/telegram/adapter.ts index 2979193..46e4d04 100644 --- a/src/plugins/telegram/adapter.ts +++ b/src/plugins/telegram/adapter.ts @@ -847,6 +847,16 @@ export class TelegramAdapter extends MessagingAdapter { // --- MessagingAdapter overrides --- + /** + * Per-session serial dispatch queues. + * SessionBridge fires sendMessage() as fire-and-forget, so multiple events + * (tool_call, tool_update, text) can arrive concurrently. Without serialization, + * fast handlers (tool_update) overtake slow ones (tool_call with draftManager.finalize), + * causing out-of-order processing where a tool's completion update is processed before + * its creation event. This queue ensures events are processed in the order they arrive. + */ + private _dispatchQueues = new Map>(); + async sendMessage( sessionId: string, content: OutgoingMessage, @@ -869,13 +879,20 @@ export class TelegramAdapter extends MessagingAdapter { return; } - // Store threadId for handlers to use (keyed by sessionId for concurrency safety) - this._sessionThreadIds.set(sessionId, threadId); - try { - await super.sendMessage(sessionId, content); - } finally { - this._sessionThreadIds.delete(sessionId); - } + // Serialize dispatch per session to preserve event ordering + const prev = this._dispatchQueues.get(sessionId) ?? Promise.resolve(); + const next = prev.then(async () => { + this._sessionThreadIds.set(sessionId, threadId); + try { + await super.sendMessage(sessionId, content); + } finally { + this._sessionThreadIds.delete(sessionId); + } + }).catch((err) => { + log.warn({ err, sessionId }, "Dispatch queue error"); + }); + this._dispatchQueues.set(sessionId, next); + await next; } protected async handleThought( @@ -893,13 +910,10 @@ export class TelegramAdapter extends MessagingAdapter { content: OutgoingMessage, ): Promise { const threadId = this.getThreadId(sessionId); - // CRITICAL: This handler must be fully synchronous to preserve text ordering. - // sendMessage() is not awaited in wireSessionEvents, so multiple text events - // run concurrently. Any await here creates a gap where subsequent text events - // process first, causing out-of-order buffer accumulation. + // Per-session dispatch queue serializes all events, so we can safely await here. if (!this.draftManager.hasDraft(sessionId)) { const tracker = this.getOrCreateTracker(sessionId, threadId); - tracker.onTextStart().catch(() => {}); // Fire-and-forget, no await + await tracker.onTextStart(); } const draft = this.draftManager.getOrCreate(sessionId, threadId); draft.append(content.text);