@grinev/opencode-telegram-bot 0.21.2 → 0.22.1

package/dist/bot/services/event-subscription-service.js

@@ -5,9 +5,10 @@ import { InputFile } from "grammy";
 import { config } from "../../config.js";
 import { t } from "../../i18n/index.js";
 import { summaryAggregator } from "../../app/managers/summary-aggregation-manager.js";
-import { formatToolInfo } from "../../app/formatters/summary-formatter.js";
+import { formatCompactToolActivity, formatToolInfo } from "../../app/formatters/summary-formatter.js";
 import { renderSubagentCards } from "../../app/formatters/subagent-formatter.js";
 import { ToolMessageBatcher } from "../../app/formatters/tool-message-batcher.js";
+import { getCompactOutputMode, getResponseStreamingMode, getSendDiffFileAttachments, getShowAssistantRunFooter, getShowThinkingContent, } from "../../app/stores/settings-store.js";
 import { getCurrentSession } from "../../app/services/session-service.js";
 import { ingestSessionInfoForCache } from "../../app/services/session-cache-service.js";
 import { logger } from "../../utils/logger.js";
@@ -27,10 +28,12 @@ import { scheduledTaskRuntime } from "../../app/services/scheduled-task-runtime-
 import { assistantRunState } from "../../app/managers/assistant-run-state-manager.js";
 import { ResponseStreamer } from "../streaming/response-streamer.js";
 import { ToolCallStreamer } from "../streaming/tool-call-streamer.js";
+import { CompactProgressStreamer } from "../streaming/compact-progress-streamer.js";
 import { attachManager } from "../../app/managers/attach-manager.js";
 import { markAttachedSessionBusy, markAttachedSessionIdle, } from "../../app/services/attach-service.js";
 import { externalUserInputSuppressionManager } from "../../app/managers/external-input-suppression-manager.js";
 import { prepareAssistantFinalStreamingPayload, prepareAssistantStreamingPayload, renderAssistantFinalPartsSafe, } from "../messages/assistant-rendering.js";
+import { makeThinkingPayloadExpandable, prepareThinkingStreamingPayload, } from "../messages/thinking-rendering.js";
 import { deliverExternalUserInputNotification } from "../messages/external-user-input-notification.js";
 import { backgroundSessionTracker, } from "../../app/managers/background-session-manager.js";
 import { buildBackgroundSessionOpenKeyboard } from "../menus/session-selection-menu.js";
@@ -41,13 +44,15 @@ import { clearAllInteractionState } from "../../app/managers/interaction-manager
 import { stopEventListening, subscribeToEvents } from "../../opencode/events.js";
 const TELEGRAM_DOCUMENT_CAPTION_MAX_LENGTH = 1024;
 const RESPONSE_STREAM_THROTTLE_MS = config.bot.responseStreamThrottleMs;
-const RESPONSE_STREAMING_MODE = config.bot.responseStreamingMode;
 const RESPONSE_STREAM_TEXT_LIMIT = 3800;
 const SESSION_RETRY_PREFIX = "🔁";
 const SUBAGENT_STREAM_PREFIX = "🧩";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const TEMP_DIR = path.join(__dirname, "..", "..", ".tmp");
+function isCompactProgressMode() {
+    return getCompactOutputMode();
+}
 export function createEventSubscriptionService() {
     return new EventSubscriptionService();
 }
@@ -55,10 +60,16 @@ class EventSubscriptionService {
     botInstance = null;
     chatIdInstance = null;
     nextDraftId = 1;
+    thinkingStreamingPayloads = new Map();
     sessionCompletionTasks = new Map();
-    responseStreamer;
+    compactProgressFinalizationTasks = new Map();
+    assistantEditResponseStreamer;
+    assistantDraftResponseStreamer;
+    thinkingResponseStreamer;
+    assistantResponseStreamModes = new Map();
     toolCallStreamer;
     toolMessageBatcher;
+    compactProgressStreamer;
     constructor() {
         this.toolMessageBatcher = new ToolMessageBatcher({
             sendText: async (sessionId, text) => {
@@ -100,9 +111,48 @@ class EventSubscriptionService {
                 }
             },
         });
-        this.responseStreamer = this.createResponseStreamer();
-        setResponseStreamerForReconciliation(this.responseStreamer);
+        this.assistantEditResponseStreamer = this.createResponseStreamer("edit");
+        this.assistantDraftResponseStreamer = this.createResponseStreamer("draft");
+        this.thinkingResponseStreamer = this.createResponseStreamer("edit");
+        setResponseStreamerForReconciliation({
+            hasActiveStream: (sessionId) => this.hasActiveAssistantResponseStream(sessionId),
+        });
         setPromptResponseModeClearerForReconciliation(clearPromptResponseMode);
+        this.compactProgressStreamer = new CompactProgressStreamer({
+            throttleMs: RESPONSE_STREAM_THROTTLE_MS,
+            sendText: async (sessionId, text) => {
+                if (!this.botInstance || !this.chatIdInstance || this.chatIdInstance <= 0) {
+                    throw new Error("Bot context missing for compact progress send");
+                }
+                const currentSession = getCurrentSession();
+                if (!currentSession || currentSession.id !== sessionId) {
+                    throw new Error(`Compact progress session mismatch for send: ${sessionId}`);
+                }
+                const sentMessage = await this.botInstance.api.sendMessage(this.chatIdInstance, text, {
+                    disable_notification: true,
+                });
+                return sentMessage.message_id;
+            },
+            editText: async (sessionId, messageId, text) => {
+                if (!this.botInstance || !this.chatIdInstance || this.chatIdInstance <= 0) {
+                    throw new Error("Bot context missing for compact progress edit");
+                }
+                const currentSession = getCurrentSession();
+                if (!currentSession || currentSession.id !== sessionId) {
+                    throw new Error(`Compact progress session mismatch for edit: ${sessionId}`);
+                }
+                try {
+                    await this.botInstance.api.editMessageText(this.chatIdInstance, messageId, text);
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+                    if (errorMessage.includes("message is not modified")) {
+                        return;
+                    }
+                    throw error;
+                }
+            },
+        });
         this.toolCallStreamer = new ToolCallStreamer({
             throttleMs: RESPONSE_STREAM_THROTTLE_MS,
             sendText: async (sessionId, text) => {
@@ -163,9 +213,12 @@ class EventSubscriptionService {
     clearRuntimeState(reason) {
         backgroundSessionTracker.clear();
         this.nextDraftId = 1;
-        this.responseStreamer.clearAll(reason);
+        this.clearAllResponseStreams(reason);
         this.toolCallStreamer.clearAll(reason);
         this.toolMessageBatcher.clearAll(reason);
+        this.compactProgressStreamer.clearAll(reason);
+        this.compactProgressFinalizationTasks.clear();
+        this.thinkingStreamingPayloads.clear();
         this.sessionCompletionTasks.clear();
         assistantRunState.clearAll(reason);
     }
@@ -189,7 +242,10 @@ class EventSubscriptionService {
         summaryAggregator.setOnCleared(() => {
             this.toolMessageBatcher.clearAll("summary_aggregator_clear");
             this.toolCallStreamer.clearAll("summary_aggregator_clear");
-            this.responseStreamer.clearAll("summary_aggregator_clear");
+            this.clearAllResponseStreams("summary_aggregator_clear");
+            this.compactProgressStreamer.clearAll("summary_aggregator_clear");
+            this.compactProgressFinalizationTasks.clear();
+            this.thinkingStreamingPayloads.clear();
         });
         summaryAggregator.setOnPartial((sessionId, messageId, messageText) => {
             if (!this.botInstance || !this.chatIdInstance) {
@@ -199,21 +255,43 @@ class EventSubscriptionService {
             if (!currentSession || currentSession.id !== sessionId) {
                 return;
             }
+            if (isCompactProgressMode()) {
+                void this.finalizeCompactProgress(sessionId)
+                    .then(() => {
+                    const activeSession = getCurrentSession();
+                    if (!activeSession || activeSession.id !== sessionId) {
+                        return;
+                    }
+                    const preparedStreamPayload = this.prepareStreamingPayload(messageText);
+                    if (!preparedStreamPayload) {
+                        return;
+                    }
+                    preparedStreamPayload.sendOptions = { disable_notification: true };
+                    preparedStreamPayload.editOptions = undefined;
+                    this.enqueueAssistantResponse(sessionId, messageId, preparedStreamPayload);
+                })
+                    .catch((error) => {
+                    logger.error("[Bot] Failed to finalize compact progress before assistant stream", error);
+                });
+                return;
+            }
             const preparedStreamPayload = this.prepareStreamingPayload(messageText);
             if (!preparedStreamPayload) {
                 return;
             }
             preparedStreamPayload.sendOptions = { disable_notification: true };
             preparedStreamPayload.editOptions = undefined;
-            this.responseStreamer.enqueue(sessionId, messageId, preparedStreamPayload);
+            this.enqueueAssistantResponse(sessionId, messageId, preparedStreamPayload);
         });
         summaryAggregator.setOnComplete((sessionId, messageId, messageText, completionInfo) => {
             void this.enqueueSessionCompletionTask(sessionId, async () => {
                 if (!this.botInstance || !this.chatIdInstance) {
                     logger.error("Bot or chat ID not available for sending message");
                     clearPromptResponseMode(sessionId);
-                    this.responseStreamer.clearMessage(sessionId, messageId, "bot_context_missing");
+                    this.clearAssistantResponseStream(sessionId, messageId, "bot_context_missing");
+                    this.clearThinkingStream(sessionId, messageId, "bot_context_missing");
                     this.toolCallStreamer.clearSession(sessionId, "bot_context_missing");
+                    this.compactProgressStreamer.clearSession(sessionId, "bot_context_missing");
                     assistantRunState.clearRun(sessionId, "bot_context_missing");
                     foregroundSessionState.markIdle(sessionId);
                     return;
@@ -221,8 +299,10 @@ class EventSubscriptionService {
                 const currentSession = getCurrentSession();
                 if (currentSession?.id !== sessionId) {
                     clearPromptResponseMode(sessionId);
-                    this.responseStreamer.clearMessage(sessionId, messageId, "session_mismatch");
+                    this.clearAssistantResponseStream(sessionId, messageId, "session_mismatch");
+                    this.clearThinkingStream(sessionId, messageId, "session_mismatch");
                     this.toolCallStreamer.clearSession(sessionId, "session_mismatch");
+                    this.compactProgressStreamer.clearSession(sessionId, "session_mismatch");
                     assistantRunState.clearRun(sessionId, "session_mismatch");
                     foregroundSessionState.markIdle(sessionId);
                     await scheduledTaskRuntime.flushDeferredDeliveries();
@@ -236,11 +316,18 @@ class EventSubscriptionService {
                         providerID: completionInfo.providerID,
                         modelID: completionInfo.modelID,
                     });
+                    await this.completeThinkingStream(sessionId, messageId);
+                    if (isCompactProgressMode()) {
+                        await this.finalizeCompactProgress(sessionId);
+                    }
+                    const assistantResponseMode = this.getAssistantResponseStreamMode(sessionId, messageId);
                     await finalizeAssistantResponse({
                         sessionId,
                         messageId,
                         messageText,
-                        responseStreamer: this.responseStreamer,
+                        responseStreamer: {
+                            complete: (completeSessionId, completeMessageId, payload, options) => this.completeAssistantResponse(completeSessionId, completeMessageId, payload, options),
+                        },
                         flushPendingServiceMessages: () => Promise.all([
                             this.toolMessageBatcher.flushSession(sessionId, "assistant_message_completed"),
                             this.toolCallStreamer.breakSession(sessionId, "assistant_message_completed"),
@@ -248,6 +335,7 @@ class EventSubscriptionService {
                         prepareStreamingPayload: this.prepareFinalStreamingPayload,
                         renderFinalParts: (text) => renderAssistantFinalPartsSafe(text),
                         getReplyKeyboard: this.getCurrentReplyKeyboard,
+                        notifyFirstFinalPart: assistantResponseMode === "draft" && !getShowAssistantRunFooter(),
                         sendRenderedPart: async (part, options) => {
                             await sendRenderedBotPart({
                                 api: botApi,
@@ -266,6 +354,8 @@ class EventSubscriptionService {
                 }
                 catch (err) {
                     clearPromptResponseMode(sessionId);
+                    this.clearThinkingStream(sessionId, messageId, "assistant_finalize_failed");
+                    this.compactProgressStreamer.clearSession(sessionId, "assistant_finalize_failed");
                     assistantRunState.clearRun(sessionId, "assistant_finalize_failed");
                     logger.error("Failed to send message to Telegram:", err);
                     logger.error("[Bot] CRITICAL: Stopping event processing due to error");
@@ -297,6 +387,22 @@ class EventSubscriptionService {
                 }
             });
         });
+        summaryAggregator.setOnRootToolUpdate((toolInfo) => {
+            if (!isCompactProgressMode()) {
+                return;
+            }
+            const currentSession = getCurrentSession();
+            if (!currentSession || currentSession.id !== toolInfo.sessionId) {
+                return;
+            }
+            const activity = this.getCompactToolActivity(toolInfo);
+            if (activity) {
+                this.compactProgressStreamer.updateActivity(toolInfo.sessionId, activity);
+            }
+            if ("status" in toolInfo.state && toolInfo.state.status === "completed") {
+                this.compactProgressStreamer.addToolCall(toolInfo.sessionId, toolInfo.callId);
+            }
+        });
         summaryAggregator.setOnTool(async (toolInfo) => {
             if (!this.botInstance || !this.chatIdInstance) {
                 logger.error("Bot or chat ID not available for sending tool notification");
@@ -306,11 +412,13 @@ class EventSubscriptionService {
             if (!currentSession || currentSession.id !== toolInfo.sessionId) {
                 return;
             }
-            const shouldIncludeToolInfoInFileCaption = toolInfo.hasFileAttachment &&
+            if (isCompactProgressMode()) {
+                return;
+            }
+            const shouldSendToolFileAttachment = toolInfo.hasFileAttachment &&
+                getSendDiffFileAttachments() &&
                 (toolInfo.tool === "write" || toolInfo.tool === "edit" || toolInfo.tool === "apply_patch");
-            if (config.bot.hideToolCallMessages ||
-                shouldIncludeToolInfoInFileCaption ||
-                toolInfo.tool === "task") {
+            if (shouldSendToolFileAttachment || toolInfo.tool === "task") {
                 return;
             }
             try {
@@ -327,7 +435,7 @@ class EventSubscriptionService {
             if (!this.botInstance || !this.chatIdInstance) {
                 return;
             }
-            if (config.bot.hideToolCallMessages) {
+            if (isCompactProgressMode()) {
                 return;
             }
             const currentSession = getCurrentSession();
@@ -354,7 +462,10 @@ class EventSubscriptionService {
             if (!currentSession || currentSession.id !== fileInfo.sessionId) {
                 return;
             }
-            if (config.bot.hideToolFileMessages) {
+            if (isCompactProgressMode()) {
+                return;
+            }
+            if (!getSendDiffFileAttachments()) {
                 return;
             }
             try {
@@ -379,6 +490,9 @@ class EventSubscriptionService {
             if (!currentSession || currentSession.id !== sessionId) {
                 return;
             }
+            if (isCompactProgressMode()) {
+                this.compactProgressStreamer.updateWaitingForQuestion(sessionId);
+            }
             await Promise.all([
                 this.toolMessageBatcher.flushSession(currentSession.id, "question_asked"),
                 this.toolCallStreamer.flushSession(currentSession.id, "question_asked"),
@@ -418,6 +532,9 @@ class EventSubscriptionService {
             if (!currentSession || (!isCurrent && !isSubagent)) {
                 return;
             }
+            if (isCompactProgressMode()) {
+                this.compactProgressStreamer.updateWaitingForPermission(currentSession.id);
+            }
             await Promise.all([
                 this.toolMessageBatcher.flushSession(request.sessionID, "permission_asked"),
                 this.toolCallStreamer.flushSession(request.sessionID, "permission_asked"),
@@ -425,23 +542,63 @@ class EventSubscriptionService {
             logger.info(`[Bot] Received permission request from agent: type=${request.permission}, requestID=${request.id}, subagent=${isSubagent}`);
             await showPermissionRequest(this.botInstance.api, this.chatIdInstance, request);
         });
-        summaryAggregator.setOnThinking(async (sessionId) => {
+        summaryAggregator.setOnThinking(async (update) => {
             if (!this.botInstance || !this.chatIdInstance) {
                 return;
             }
             const currentSession = getCurrentSession();
-            if (!currentSession || currentSession.id !== sessionId) {
+            if (!currentSession || currentSession.id !== update.sessionId) {
                 return;
             }
-            logger.debug("[Bot] Agent started thinking");
-            await this.toolCallStreamer.breakSession(sessionId, "thinking_started");
-            deliverThinkingMessage(sessionId, this.toolMessageBatcher, {
-                hideThinkingMessages: config.bot.hideThinkingMessages,
+            logger.debug("[Bot] Agent thinking update", {
+                sessionId: update.sessionId,
+                messageId: update.messageId,
+                sectionCount: update.sections.length,
+                isFirstUpdate: update.isFirstUpdate,
             });
-            if (pinnedMessageManager.isInitialized()) {
+            if (isCompactProgressMode()) {
+                this.compactProgressStreamer.updateThinking(update.sessionId);
+                if (update.isFirstUpdate && pinnedMessageManager.isInitialized()) {
+                    await pinnedMessageManager.refresh();
+                }
+                return;
+            }
+            if (update.isFirstUpdate) {
+                void this.toolCallStreamer.breakSession(update.sessionId, "thinking_started").catch((error) => {
+                    logger.error("[Bot] Failed to break tool stream before thinking message", error);
+                });
+            }
+            if (getShowThinkingContent()) {
+                const payload = prepareThinkingStreamingPayload(update.sections, RESPONSE_STREAM_TEXT_LIMIT, {
+                    expandable: false,
+                });
+                if (payload) {
+                    payload.sendOptions = { disable_notification: true };
+                    payload.editOptions = undefined;
+                    this.thinkingStreamingPayloads.set(this.getThinkingPayloadKey(update.sessionId, update.messageId), payload);
+                    this.thinkingResponseStreamer.enqueue(update.sessionId, this.getThinkingStreamId(update.messageId), payload);
+                }
+            }
+            else if (update.isFirstUpdate) {
+                deliverThinkingMessage(update.sessionId, this.toolMessageBatcher);
+            }
+            if (update.isFirstUpdate && pinnedMessageManager.isInitialized()) {
                 await pinnedMessageManager.refresh();
             }
         });
+        summaryAggregator.setOnThinkingFinished((sessionId, messageId) => {
+            if (!this.botInstance || !this.chatIdInstance) {
+                return;
+            }
+            const currentSession = getCurrentSession();
+            if (!currentSession || currentSession.id !== sessionId) {
+                return;
+            }
+            logger.debug("[Bot] Agent thinking finished", { sessionId, messageId });
+            void this.completeThinkingStream(sessionId, messageId).catch((error) => {
+                logger.error("[Bot] Failed to finalize thinking stream early", error);
+            });
+        });
         summaryAggregator.setOnTokens(async (tokens, isCompleted) => {
             if (!pinnedMessageManager.isInitialized()) {
                 return;
@@ -510,7 +667,7 @@ class EventSubscriptionService {
                     this.toolMessageBatcher.flushSession(sessionId, "session_idle"),
                     this.toolCallStreamer.flushSession(sessionId, "session_idle"),
                 ]);
-                if (completedRun?.hasCompletedResponse) {
+                if (getShowAssistantRunFooter() && completedRun?.hasCompletedResponse) {
                     const agent = completedRun.actualAgent || completedRun.configuredAgent;
                     const providerID = completedRun.actualProviderID || completedRun.configuredProviderID;
                     const modelID = completedRun.actualModelID || completedRun.configuredModelID;
@@ -539,6 +696,7 @@ class EventSubscriptionService {
             await markAttachedSessionIdle(sessionId);
             if (!this.botInstance || !this.chatIdInstance) {
                 clearPromptResponseMode(sessionId);
+                this.compactProgressStreamer.clearSession(sessionId, "session_error_no_bot_context");
                 assistantRunState.clearRun(sessionId, "session_error_no_bot_context");
                 foregroundSessionState.markIdle(sessionId);
                 return;
@@ -546,14 +704,16 @@ class EventSubscriptionService {
             const currentSession = getCurrentSession();
             if (!currentSession || currentSession.id !== sessionId) {
                 clearPromptResponseMode(sessionId);
-                this.responseStreamer.clearSession(sessionId, "session_error_not_current");
+                this.clearAssistantResponseSession(sessionId, "session_error_not_current");
                 this.toolCallStreamer.clearSession(sessionId, "session_error_not_current");
+                this.compactProgressStreamer.clearSession(sessionId, "session_error_not_current");
                 assistantRunState.clearRun(sessionId, "session_error_not_current");
                 foregroundSessionState.markIdle(sessionId);
                 await scheduledTaskRuntime.flushDeferredDeliveries();
                 return;
             }
-            this.responseStreamer.clearSession(sessionId, "session_error");
+            this.clearAssistantResponseSession(sessionId, "session_error");
+            this.compactProgressStreamer.clearSession(sessionId, "session_error");
             clearPromptResponseMode(sessionId);
             assistantRunState.clearRun(sessionId, "session_error");
             await Promise.all([
@@ -586,6 +746,10 @@ class EventSubscriptionService {
             if (!currentSession || currentSession.id !== sessionId) {
                 return;
             }
+            if (isCompactProgressMode()) {
+                this.compactProgressStreamer.updateActivity(sessionId, t("progress.compact.retrying"));
+                return;
+            }
             const normalizedMessage = message.trim() || t("common.unknown_error");
             const truncatedMessage = normalizedMessage.length > 3500
                 ? `${normalizedMessage.slice(0, 3497)}...`
@@ -593,7 +757,12 @@ class EventSubscriptionService {
             const retryMessage = t("bot.session_retry", { message: truncatedMessage });
             this.toolCallStreamer.replaceByPrefix(sessionId, SESSION_RETRY_PREFIX, retryMessage);
         });
-        summaryAggregator.setOnSessionDiff(async (_sessionId, diffs) => {
+        summaryAggregator.setOnSessionDiff(async (sessionId, diffs) => {
+            if (isCompactProgressMode()) {
+                for (const diff of diffs) {
+                    this.compactProgressStreamer.addFileChange(sessionId, diff.file);
+                }
+            }
             if (!pinnedMessageManager.isInitialized()) {
                 return;
             }
@@ -605,6 +774,12 @@ class EventSubscriptionService {
             }
         });
         summaryAggregator.setOnFileChange((change) => {
+            if (isCompactProgressMode()) {
+                const currentSession = getCurrentSession();
+                if (currentSession) {
+                    this.compactProgressStreamer.addFileChange(currentSession.id, change.file);
+                }
+            }
             if (!pinnedMessageManager.isInitialized()) {
                 return;
             }
@@ -648,8 +823,57 @@ class EventSubscriptionService {
             logger.error("Failed to subscribe to events:", err);
         });
     };
-    createResponseStreamer() {
-        if (RESPONSE_STREAMING_MODE === "draft") {
+    getAssistantResponseStreamKey(sessionId, messageId) {
+        return `${sessionId}:${messageId}`;
+    }
+    getAssistantResponseStreamer(mode) {
+        return mode === "draft"
+            ? this.assistantDraftResponseStreamer
+            : this.assistantEditResponseStreamer;
+    }
+    getAssistantResponseStreamMode(sessionId, messageId) {
+        return (this.assistantResponseStreamModes.get(this.getAssistantResponseStreamKey(sessionId, messageId)) ??
+            getResponseStreamingMode());
+    }
+    enqueueAssistantResponse(sessionId, messageId, payload) {
+        const key = this.getAssistantResponseStreamKey(sessionId, messageId);
+        const mode = this.getAssistantResponseStreamMode(sessionId, messageId);
+        this.assistantResponseStreamModes.set(key, mode);
+        this.getAssistantResponseStreamer(mode).enqueue(sessionId, messageId, payload);
+    }
+    async completeAssistantResponse(sessionId, messageId, payload, options) {
+        const key = this.getAssistantResponseStreamKey(sessionId, messageId);
+        const mode = this.getAssistantResponseStreamMode(sessionId, messageId);
+        const result = await this.getAssistantResponseStreamer(mode).complete(sessionId, messageId, payload, options);
+        this.assistantResponseStreamModes.delete(key);
+        return result;
+    }
+    clearAssistantResponseStream(sessionId, messageId, reason) {
+        this.assistantResponseStreamModes.delete(this.getAssistantResponseStreamKey(sessionId, messageId));
+        this.assistantEditResponseStreamer.clearMessage(sessionId, messageId, reason);
+        this.assistantDraftResponseStreamer.clearMessage(sessionId, messageId, reason);
+    }
+    clearAssistantResponseSession(sessionId, reason) {
+        for (const key of this.assistantResponseStreamModes.keys()) {
+            if (key.startsWith(`${sessionId}:`)) {
+                this.assistantResponseStreamModes.delete(key);
+            }
+        }
+        this.assistantEditResponseStreamer.clearSession(sessionId, reason);
+        this.assistantDraftResponseStreamer.clearSession(sessionId, reason);
+    }
+    clearAllResponseStreams(reason) {
+        this.assistantResponseStreamModes.clear();
+        this.assistantEditResponseStreamer.clearAll(reason);
+        this.assistantDraftResponseStreamer.clearAll(reason);
+        this.thinkingResponseStreamer.clearAll(reason);
+    }
+    hasActiveAssistantResponseStream(sessionId) {
+        return (this.assistantEditResponseStreamer.hasActiveStream(sessionId) ||
+            this.assistantDraftResponseStreamer.hasActiveStream(sessionId));
+    }
+    createResponseStreamer(mode) {
+        if (mode === "draft") {
             return new ResponseStreamer({
                 throttleMs: RESPONSE_STREAM_THROTTLE_MS,
                 sendPart: async (part) => {
@@ -763,6 +987,37 @@ class EventSubscriptionService {
     prepareFinalStreamingPayload(messageText) {
         return prepareAssistantFinalStreamingPayload(messageText, RESPONSE_STREAM_TEXT_LIMIT);
     }
+    getThinkingStreamId(messageId) {
+        return `thinking:${messageId}`;
+    }
+    getThinkingPayloadKey(sessionId, messageId) {
+        return `${sessionId}:${messageId}`;
+    }
+    clearThinkingStream(sessionId, messageId, reason) {
+        this.thinkingResponseStreamer.clearMessage(sessionId, this.getThinkingStreamId(messageId), reason);
+        this.thinkingStreamingPayloads.delete(this.getThinkingPayloadKey(sessionId, messageId));
+    }
+    async completeThinkingStream(sessionId, messageId) {
+        const key = this.getThinkingPayloadKey(sessionId, messageId);
+        const payload = this.thinkingStreamingPayloads.get(key);
+        const finalPayload = payload ? makeThinkingPayloadExpandable(payload) : undefined;
+        const result = await this.thinkingResponseStreamer.complete(sessionId, this.getThinkingStreamId(messageId), finalPayload);
+        this.thinkingStreamingPayloads.delete(key);
+        if (result.streamed || !finalPayload) {
+            return;
+        }
+        if (!this.botInstance || !this.chatIdInstance) {
+            return;
+        }
+        for (const part of finalPayload.parts) {
+            await sendRenderedBotPart({
+                api: this.botInstance.api,
+                chatId: this.chatIdInstance,
+                part,
+                options: finalPayload.sendOptions,
+            });
+        }
+    }
     enqueueSessionCompletionTask(sessionId, task) {
         const previousTask = this.sessionCompletionTasks.get(sessionId) ?? Promise.resolve();
         const nextTask = previousTask
@@ -776,6 +1031,19 @@ class EventSubscriptionService {
         this.sessionCompletionTasks.set(sessionId, nextTask);
         return nextTask;
     }
+    finalizeCompactProgress(sessionId) {
+        const existingTask = this.compactProgressFinalizationTasks.get(sessionId);
+        if (existingTask) {
+            return existingTask;
+        }
+        const nextTask = this.compactProgressStreamer.finalize(sessionId).finally(() => {
+            if (this.compactProgressFinalizationTasks.get(sessionId) === nextTask) {
+                this.compactProgressFinalizationTasks.delete(sessionId);
+            }
+        });
+        this.compactProgressFinalizationTasks.set(sessionId, nextTask);
+        return nextTask;
+    }
     getNextDraftId() {
         const id = this.nextDraftId;
         this.nextDraftId += 1;
@@ -787,6 +1055,12 @@ class EventSubscriptionService {
         }
         return "default";
     }
+    getCompactToolActivity(toolInfo) {
+        if (toolInfo.tool === "task") {
+            return t("progress.compact.task");
+        }
+        return formatCompactToolActivity(toolInfo, 128);
+    }
     formatShortSessionId(sessionId) {
         return sessionId.length <= 8 ? sessionId : sessionId.slice(0, 8);
     }