@grinev/opencode-telegram-bot 0.20.3 → 0.20.5

package/dist/app/start-bot-app.js

@@ -12,6 +12,7 @@ import { getRuntimePaths } from "../runtime/paths.js";
 import { clearServiceStateFile } from "../service/manager.js";
 import { getServiceStateFilePathFromEnv, isServiceChildProcess } from "../service/runtime.js";
 import { getLogFilePath, initializeLogger, logger } from "../utils/logger.js";
+import { safeBackgroundTask } from "../utils/safe-background-task.js";
 const SHUTDOWN_TIMEOUT_MS = 5000;
 async function getBotVersion() {
     try {
@@ -43,8 +44,13 @@ export async function startBotApp() {
     registerOpenCodeReadyRefreshHandler();
     const bot = createBot();
     await scheduledTaskRuntime.initialize(bot);
-    await opencodeAutoRestartService.start();
-    await notifyOpencodeReadyIfHealthy("startup");
+    safeBackgroundTask({
+        taskName: "app.opencodeStartup",
+        task: async () => {
+            await opencodeAutoRestartService.start();
+            await notifyOpencodeReadyIfHealthy("startup");
+        },
+    });
     let shutdownStarted = false;
     let serviceStateCleared = false;
     let shutdownTimeout = null;

package/dist/bot/commands/abort.js

@@ -5,10 +5,19 @@ import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
 import { assistantRunState } from "../assistant-run-state.js";
+import { markAttachedSessionIdle } from "../../attach/service.js";
+import { clearPromptResponseMode } from "../handlers/prompt.js";
+import { markUserAbortRequested } from "../utils/abort-error-suppression.js";
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 function abortLocalStreaming() {
     clearAllInteractionState("abort_command");
 }
+async function releaseAbortBusyState(sessionId, reason) {
+    foregroundSessionState.markIdle(sessionId);
+    assistantRunState.clearRun(sessionId, reason);
+    await markAttachedSessionIdle(sessionId);
+    clearPromptResponseMode(sessionId);
+}
 async function pollSessionStatus(sessionId, directory, maxWaitMs = 5000) {
     const startedAt = Date.now();
     const pollIntervalMs = 500;
@@ -61,6 +70,7 @@ export async function abortCurrentOperation(ctx, options = {}) {
         }
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), 5000);
+        markUserAbortRequested(currentSession.id);
         try {
             const { data: abortResult, error: abortError } = await opencodeClient.session.abort({
                 sessionID: currentSession.id,
@@ -69,12 +79,14 @@ export async function abortCurrentOperation(ctx, options = {}) {
             clearTimeout(timeoutId);
             if (abortError) {
                 logger.warn("[Abort] Abort request failed:", abortError);
+                await releaseAbortBusyState(currentSession.id, "abort_unconfirmed");
                 if (notifyUser && chatId !== null && waitingMessageId !== null) {
                     await ctx.api.editMessageText(chatId, waitingMessageId, t("stop.warn_unconfirmed"));
                 }
                 return;
             }
             if (abortResult !== true) {
+                await releaseAbortBusyState(currentSession.id, "abort_maybe_finished");
                 if (notifyUser && chatId !== null && waitingMessageId !== null) {
                     await ctx.api.editMessageText(chatId, waitingMessageId, t("stop.warn_maybe_finished"));
                 }
@@ -82,8 +94,7 @@ export async function abortCurrentOperation(ctx, options = {}) {
             }
             const finalStatus = await pollSessionStatus(currentSession.id, currentSession.directory, 5000);
             if (finalStatus === "idle" || finalStatus === "not-found") {
-                foregroundSessionState.markIdle(currentSession.id);
-                assistantRunState.clearRun(currentSession.id, "abort_confirmed");
+                await releaseAbortBusyState(currentSession.id, "abort_confirmed");
                 if (notifyUser && chatId !== null && waitingMessageId !== null) {
                     await ctx.api.editMessageText(chatId, waitingMessageId, t("stop.success"));
                 }
@@ -96,6 +107,7 @@ export async function abortCurrentOperation(ctx, options = {}) {
         }
         catch (error) {
             clearTimeout(timeoutId);
+            await releaseAbortBusyState(currentSession.id, "abort_error");
             if (error instanceof Error && error.name === "AbortError") {
                 if (notifyUser && chatId !== null && waitingMessageId !== null) {
                     await ctx.api.editMessageText(chatId, waitingMessageId, t("stop.warn_timeout"));

package/dist/bot/commands/opencode-start.js

@@ -5,6 +5,43 @@ import { opencodeReadyLifecycle } from "../../opencode/ready-lifecycle.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 import { editBotText } from "../utils/telegram-text.js";
+const SERVER_READY_TIMEOUT_MS = 10_000;
+const SERVER_READY_POLL_INTERVAL_MS = 500;
+const HEALTH_CHECK_TIMEOUT_MS = 3_000;
+const HEALTH_CHECK_TIMED_OUT = Symbol("health-check-timed-out");
+async function healthWithTimeout(timeoutMs = HEALTH_CHECK_TIMEOUT_MS) {
+    const controller = new AbortController();
+    let timeout;
+    try {
+        return await Promise.race([
+            opencodeClient.global.health({ signal: controller.signal }),
+            new Promise((resolve) => {
+                timeout = setTimeout(() => {
+                    controller.abort();
+                    resolve(HEALTH_CHECK_TIMED_OUT);
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+    }
+}
+async function getHealthIfAvailable() {
+    try {
+        const result = await healthWithTimeout();
+        if (result === HEALTH_CHECK_TIMED_OUT) {
+            logger.warn(`[Bot] OpenCode health check timed out after ${HEALTH_CHECK_TIMEOUT_MS}ms`);
+            return null;
+        }
+        return result;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Wait for OpenCode server to become ready by polling health endpoint
  * @param maxWaitMs Maximum time to wait in milliseconds
@@ -12,18 +49,12 @@ import { editBotText } from "../utils/telegram-text.js";
  */
 async function waitForServerReady(maxWaitMs = 10000) {
     const startTime = Date.now();
-    const pollInterval = 500;
     while (Date.now() - startTime < maxWaitMs) {
-        try {
-            const { data, error } = await opencodeClient.global.health();
-            if (!error && data?.healthy) {
-                return true;
-            }
-        }
-        catch {
-            // Server not ready yet
+        const health = await getHealthIfAvailable();
+        if (health?.data?.healthy) {
+            return true;
         }
-        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        await new Promise((resolve) => setTimeout(resolve, SERVER_READY_POLL_INTERVAL_MS));
     }
     return false;
 }
@@ -40,8 +71,9 @@ export async function opencodeStartCommand(ctx) {
         }
         // Check if server is already accessible.
         try {
-            const { data, error } = await opencodeClient.global.health();
-            if (!error && data?.healthy) {
+            const health = await getHealthIfAvailable();
+            const data = health?.data;
+            if (data?.healthy) {
                 await ctx.reply(t("opencode_start.already_running", { version: data.version || t("common.unknown") }));
                 await opencodeReadyLifecycle.notifyReady("opencode_start_already_running");
                 return;
@@ -67,7 +99,7 @@ export async function opencodeStartCommand(ctx) {
         }
         childProcess.unref();
         logger.info("[Bot] Waiting for OpenCode server to become ready...");
-        const ready = await waitForServerReady(10000);
+        const ready = await waitForServerReady(SERVER_READY_TIMEOUT_MS);
         if (!ready) {
             await editBotText({
                 api: ctx.api,
@@ -79,7 +111,7 @@ export async function opencodeStartCommand(ctx) {
             });
             return;
         }
-        const { data: health } = await opencodeClient.global.health();
+        const health = (await getHealthIfAvailable())?.data;
         await editBotText({
             api: ctx.api,
             chatId: ctx.chat.id,

package/dist/bot/handlers/question.js

@@ -8,7 +8,11 @@ import { interactionManager } from "../../interaction/manager.js";
 import { logger } from "../../utils/logger.js";
 import { safeBackgroundTask } from "../../utils/safe-background-task.js";
 import { t } from "../../i18n/index.js";
+import { editRenderedBotPart, sendRenderedBotPart } from "../utils/telegram-text.js";
 const MAX_BUTTON_LENGTH = 60;
+const TELEGRAM_MESSAGE_LIMIT = 4096;
+const TRUNCATION_SUFFIX = "…";
+const QUESTION_EMOJI = "❓";
 function getCallbackMessageId(ctx) {
     const message = ctx.callbackQuery?.message;
     if (!message || !("message_id" in message)) {
@@ -186,12 +190,26 @@ async function updateQuestionMessage(ctx) {
         logger.debug("[QuestionHandler] updateQuestionMessage: no current question");
         return;
     }
-    const text = formatQuestionText(question);
+    const part = formatQuestionDetailsPart(question);
     const keyboard = buildQuestionKeyboard(question, questionManager.getSelectedOptions(questionManager.getCurrentIndex()));
     logger.debug("[QuestionHandler] Updating question message");
     try {
-        await ctx.editMessageText(text, {
-            reply_markup: keyboard,
+        const chatId = ctx.chat?.id;
+        const messageId = getCallbackMessageId(ctx);
+        if (!chatId || messageId === null) {
+            await ctx.editMessageText(part.fallbackText, {
+                reply_markup: keyboard,
+            });
+            return;
+        }
+        await editRenderedBotPart({
+            api: ctx.api,
+            chatId,
+            messageId,
+            part,
+            options: {
+                reply_markup: keyboard,
+            },
         });
     }
     catch (err) {
@@ -205,16 +223,21 @@ export async function showCurrentQuestion(bot, chatId) {
         return;
     }
     logger.debug(`[QuestionHandler] Showing question: ${question.header} - ${question.question}`);
-    const text = formatQuestionText(question);
+    const part = formatQuestionDetailsPart(question);
     const keyboard = buildQuestionKeyboard(question, questionManager.getSelectedOptions(questionManager.getCurrentIndex()));
     logger.debug(`[QuestionHandler] Sending message with keyboard, chatId=${chatId}`);
     try {
-        const message = await bot.sendMessage(chatId, text, {
-            reply_markup: keyboard,
+        const { messageId } = await sendRenderedBotPart({
+            api: bot,
+            chatId,
+            part,
+            options: {
+                reply_markup: keyboard,
+            },
         });
-        logger.debug(`[QuestionHandler] Message sent, messageId=${message.message_id}`);
-        questionManager.addMessageId(message.message_id);
-        questionManager.setActiveMessageId(message.message_id);
+        questionManager.addMessageId(messageId);
+        logger.debug(`[QuestionHandler] Message sent, messageId=${messageId}`);
+        questionManager.setActiveMessageId(messageId);
         syncQuestionInteractionState("callback", questionManager.getCurrentIndex(), questionManager.getActiveMessageId());
         summaryAggregator.stopTypingIndicator();
     }
@@ -335,14 +358,67 @@ async function sendAllAnswersToAgent(bot, chatId) {
         },
     });
 }
-function formatQuestionText(question) {
+function formatQuestionDetailsPart(question) {
     const currentIndex = questionManager.getCurrentIndex();
     const totalQuestions = questionManager.getTotalQuestions();
     const progressText = totalQuestions > 0 ? `${currentIndex + 1}/${totalQuestions}` : "";
-    const headerTitle = [progressText, question.header].filter(Boolean).join(" ");
-    const header = headerTitle ? `${headerTitle}\n\n` : "";
+    const headerTitle = [QUESTION_EMOJI, progressText, question.header].filter(Boolean).join(" ");
+    const textParts = [];
+    const entities = [];
+    if (headerTitle) {
+        textParts.push(headerTitle);
+        entities.push({ type: "bold", offset: 0, length: headerTitle.length });
+    }
     const multiple = question.multiple ? t("question.multi_hint") : "";
-    return `${header}${question.question}${multiple}`;
+    const questionText = `${question.question}${multiple}`;
+    if (questionText) {
+        textParts.push(questionText);
+    }
+    for (const option of question.options) {
+        const optionText = formatOptionDetails(option);
+        const offset = textParts.join("\n\n").length + (textParts.length > 0 ? 2 : 0);
+        if (option.label) {
+            entities.push({ type: "bold", offset, length: option.label.length });
+        }
+        textParts.push(optionText);
+    }
+    const text = textParts.filter(Boolean).join("\n\n");
+    const truncated = truncateQuestionPart(text, entities);
+    return {
+        text: truncated.text,
+        entities: truncated.entities.length > 0 ? truncated.entities : undefined,
+        fallbackText: truncated.text,
+        source: truncated.entities.length > 0 ? "entities" : "plain",
+    };
+}
+function truncateQuestionPart(text, entities) {
+    if (text.length <= TELEGRAM_MESSAGE_LIMIT) {
+        return { text, entities };
+    }
+    const maxBaseLength = TELEGRAM_MESSAGE_LIMIT - TRUNCATION_SUFFIX.length;
+    let endIndex = maxBaseLength;
+    if (endIndex > 0 && isHighSurrogate(text.charCodeAt(endIndex - 1))) {
+        endIndex -= 1;
+    }
+    const truncatedText = `${text.slice(0, endIndex)}${TRUNCATION_SUFFIX}`;
+    const truncatedEntities = entities
+        .filter((entity) => entity.offset < endIndex)
+        .map((entity) => ({
+        ...entity,
+        length: Math.min(entity.length, endIndex - entity.offset),
+    }))
+        .filter((entity) => entity.length > 0);
+    return { text: truncatedText, entities: truncatedEntities };
+}
+function isHighSurrogate(codeUnit) {
+    return codeUnit >= 0xd800 && codeUnit <= 0xdbff;
+}
+function formatOptionDetails(option) {
+    const optionTitle = option.label;
+    if (!option.description) {
+        return optionTitle;
+    }
+    return `${optionTitle} — ${option.description}`;
 }
 function buildQuestionKeyboard(question, selectedOptions) {
     const keyboard = new InlineKeyboard();
@@ -351,7 +427,7 @@ function buildQuestionKeyboard(question, selectedOptions) {
     question.options.forEach((option, index) => {
         const isSelected = selectedOptions.has(index);
         const icon = isSelected ? "✅ " : "";
-        const buttonText = formatButtonText(option.label, option.description, icon);
+        const buttonText = formatButtonText(option.label, icon);
         const callbackData = `question:select:${questionIndex}:${index}`;
         logger.debug(`[QuestionHandler] Button ${index}: "${buttonText}" -> "${callbackData}"`);
         keyboard.text(buttonText, callbackData).row();
@@ -367,11 +443,8 @@ function buildQuestionKeyboard(question, selectedOptions) {
     logger.debug(`[QuestionHandler] Final keyboard: ${JSON.stringify(keyboard.inline_keyboard)}`);
     return keyboard;
 }
-function formatButtonText(label, description, icon) {
+function formatButtonText(label, icon) {
     let text = `${icon}${label}`;
-    if (description && icon === "") {
-        text += ` - ${description}`;
-    }
     if (text.length > MAX_BUTTON_LENGTH) {
         text = text.substring(0, MAX_BUTTON_LENGTH - 3) + "...";
     }

package/dist/bot/handlers/voice.js

@@ -8,6 +8,7 @@ import { isSttConfigured, transcribeAudio } from "../../stt/client.js";
 import { processUserPrompt } from "./prompt.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
+import { buildTelegramFileUrl } from "../utils/telegram-file-url.js";
 const TELEGRAM_DOWNLOAD_TIMEOUT_MS = 30_000;
 const TELEGRAM_DOWNLOAD_MAX_REDIRECTS = 3;
 let telegramDownloadAgent;
@@ -80,8 +81,7 @@ async function downloadTelegramFile(ctx, fileId) {
             logger.error("[Voice] Telegram getFile returned no file_path");
             return null;
         }
-        const apiRoot = (config.telegram.apiRoot ?? "https://api.telegram.org").replace(/\/$/, "");
-        const fileUrl = `${apiRoot}/file/bot${ctx.api.token}/${file.file_path}`;
+        const fileUrl = buildTelegramFileUrl(file.file_path);
         logger.debug(`[Voice] Downloading file: ${file.file_path} (${file.file_size ?? "?"} bytes)`);
         const buffer = await downloadTelegramFileByUrl(fileUrl);
         // Extract filename from file_path (e.g., "voice/file_123.oga" -> "file_123.oga")

package/dist/bot/index.js

@@ -62,6 +62,7 @@ import { reconcileBusyState } from "./utils/busy-reconciliation.js";
 import { finalizeAssistantResponse } from "./utils/finalize-assistant-response.js";
 import { sendTtsResponseForSession } from "./utils/send-tts-response.js";
 import { deliverThinkingMessage } from "./utils/thinking-message.js";
+import { shouldSuppressUserAbortSessionError } from "./utils/abort-error-suppression.js";
 import { editRenderedBotPart, getTelegramRenderedPartSignature, sendRenderedBotPart, } from "./utils/telegram-text.js";
 import { formatAssistantRunFooter } from "./utils/assistant-run-footer.js";
 import { getModelCapabilities, supportsInput } from "../model/capabilities.js";
@@ -745,6 +746,12 @@ async function ensureEventSubscription(directory) {
             toolCallStreamer.flushSession(sessionId, "session_error"),
         ]);
         const normalizedMessage = message.trim() || t("common.unknown_error");
+        if (shouldSuppressUserAbortSessionError(sessionId, normalizedMessage)) {
+            logger.debug(`[Bot] Suppressed user-initiated abort error: session=${sessionId}`);
+            foregroundSessionState.markIdle(sessionId);
+            await scheduledTaskRuntime.flushDeferredDeliveries();
+            return;
+        }
         const truncatedMessage = normalizedMessage.length > 3500
             ? `${normalizedMessage.slice(0, 3497)}...`
             : normalizedMessage;

package/dist/bot/middleware/interaction-guard.js

@@ -1,4 +1,5 @@
 import { resolveInteractionGuardDecision } from "../../interaction/guard.js";
+import { reconcileForegroundBusyState } from "../utils/busy-guard.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 function getInteractionBlockedMessage(reason, interactionKind) {
@@ -72,7 +73,11 @@ function getInteractionBlockedMessage(reason, interactionKind) {
     }
 }
 export async function interactionGuardMiddleware(ctx, next) {
-    const decision = resolveInteractionGuardDecision(ctx);
+    let decision = resolveInteractionGuardDecision(ctx);
+    if (!decision.allow && decision.busy) {
+        await reconcileForegroundBusyState();
+        decision = resolveInteractionGuardDecision(ctx);
+    }
     if (decision.allow) {
         await next();
         return;

package/dist/bot/utils/abort-error-suppression.js

@@ -0,0 +1,32 @@
+// Covers abort request timeout, post-abort status polling, and delayed SSE reconnect delivery.
+const USER_ABORT_SUPPRESSION_WINDOW_MS = 90_000;
+const userAbortRequestedAtBySession = new Map();
+function deleteExpiredAbortRequests(now = Date.now()) {
+    for (const [sessionId, requestedAt] of userAbortRequestedAtBySession) {
+        if (now - requestedAt > USER_ABORT_SUPPRESSION_WINDOW_MS) {
+            userAbortRequestedAtBySession.delete(sessionId);
+        }
+    }
+}
+export function markUserAbortRequested(sessionId) {
+    const now = Date.now();
+    deleteExpiredAbortRequests(now);
+    userAbortRequestedAtBySession.set(sessionId, now);
+}
+export function shouldSuppressUserAbortSessionError(sessionId, message) {
+    if (message.trim().toLowerCase() !== "aborted") {
+        return false;
+    }
+    const requestedAt = userAbortRequestedAtBySession.get(sessionId);
+    if (requestedAt === undefined) {
+        return false;
+    }
+    userAbortRequestedAtBySession.delete(sessionId);
+    return Date.now() - requestedAt <= USER_ABORT_SUPPRESSION_WINDOW_MS;
+}
+export function __resetUserAbortErrorSuppressionForTests() {
+    userAbortRequestedAtBySession.clear();
+}
+export function __getUserAbortErrorSuppressionSizeForTests() {
+    return userAbortRequestedAtBySession.size;
+}

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

@@ -1,9 +1,35 @@
 import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
 import { attachManager } from "../../attach/manager.js";
+import { reconcileBusyStateNow } from "./busy-reconciliation.js";
 import { t } from "../../i18n/index.js";
+import { logger } from "../../utils/logger.js";
 export function isForegroundBusy() {
     return foregroundSessionState.isBusy() || attachManager.isBusy();
 }
+function getBusyDirectories() {
+    const directories = new Set();
+    for (const session of foregroundSessionState.getBusySessions()) {
+        directories.add(session.directory);
+    }
+    const attached = attachManager.getSnapshot();
+    if (attached?.busy) {
+        directories.add(attached.directory);
+    }
+    return [...directories];
+}
+export async function reconcileForegroundBusyState() {
+    if (!isForegroundBusy()) {
+        return;
+    }
+    for (const directory of getBusyDirectories()) {
+        try {
+            await reconcileBusyStateNow(directory);
+        }
+        catch (error) {
+            logger.warn("[BusyGuard] Failed to reconcile foreground busy state", error);
+        }
+    }
+}
 export async function replyBusyBlocked(ctx) {
     const message = t("bot.session_busy");
     if (ctx.callbackQuery) {

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

@@ -1,14 +1,9 @@
 // @ts-expect-error — node-fetch v2 ships no TS types and we avoid adding @types/node-fetch
 import nodeFetch from "node-fetch";
 import { Agent as HttpsAgent } from "https";
-import { config } from "../../config.js";
 import { logger } from "../../utils/logger.js";
-const DEFAULT_TELEGRAM_FILE_URL_BASE = "https://api.telegram.org/file/bot";
-function fileUrlBase() {
-    return config.telegram.apiRoot
-        ? `${config.telegram.apiRoot.replace(/\/$/, "")}/file/bot`
-        : DEFAULT_TELEGRAM_FILE_URL_BASE;
-}
+import { config } from "../../config.js";
+import { buildTelegramFileUrl } from "./telegram-file-url.js";
 const MAX_FILE_SIZE_BYTES = 20 * 1024 * 1024; // 20MB Telegram limit
 /**
  * Download a photo from Telegram servers
@@ -26,7 +21,7 @@ export async function downloadTelegramFile(api, fileId) {
         const sizeMb = (file.file_size / (1024 * 1024)).toFixed(2);
         throw new Error(`File too large: ${sizeMb}MB (max 20MB)`);
     }
-    const fileUrl = `${fileUrlBase()}${config.telegram.token}/${file.file_path}`;
+    const fileUrl = buildTelegramFileUrl(file.file_path);
     logger.debug(`[FileDownload] Downloading from ${fileUrl.replace(config.telegram.token, "***")}`);
     const fetchOptions = {};
     // Use proxy if configured

package/dist/bot/utils/telegram-file-url.js

@@ -0,0 +1,11 @@
+import { config } from "../../config.js";
+const DEFAULT_TELEGRAM_API_ROOT = "https://api.telegram.org";
+export function telegramFileUrlBase() {
+    const apiRoot = config.telegram.apiRoot
+        ? config.telegram.apiRoot.replace(/\/+$/, "")
+        : DEFAULT_TELEGRAM_API_ROOT;
+    return `${apiRoot}/file/bot`;
+}
+export function buildTelegramFileUrl(filePath) {
+    return `${telegramFileUrlBase()}${config.telegram.token}/${filePath}`;
+}

package/dist/opencode/auto-restart.js

@@ -5,12 +5,35 @@ import { opencodeReadyLifecycle } from "./ready-lifecycle.js";
 import { resolveLocalOpencodeTarget, startLocalOpencodeServer, } from "./process.js";
 const SERVER_READY_TIMEOUT_MS = 10000;
 const SERVER_READY_POLL_INTERVAL_MS = 500;
+const HEALTH_CHECK_TIMEOUT_MS = 3000;
+const HEALTH_CHECK_TIMED_OUT = Symbol("health-check-timed-out");
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+async function withTimeout(promise, timeoutMs) {
+    let timeout;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((resolve) => {
+                timeout = setTimeout(() => resolve(HEALTH_CHECK_TIMED_OUT), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+    }
+}
 async function isOpencodeServerHealthy() {
     try {
-        const { data, error } = await opencodeClient.global.health();
+        const result = await withTimeout(opencodeClient.global.health(), HEALTH_CHECK_TIMEOUT_MS);
+        if (result === HEALTH_CHECK_TIMED_OUT) {
+            logger.warn(`[OpenCodeAutoRestart] Health-check timed out after ${HEALTH_CHECK_TIMEOUT_MS}ms`);
+            return false;
+        }
+        const { data, error } = result;
         return !error && data?.healthy === true;
     }
     catch {

package/dist/opencode/events.js

@@ -3,7 +3,9 @@ import { logger } from "../utils/logger.js";
 import { isExpectedOpencodeUnavailableError } from "../utils/opencode-error.js";
 const RECONNECT_BASE_DELAY_MS = 1000;
 const RECONNECT_MAX_DELAY_MS = 15000;
+let sseIdleTimeoutMs = 30_000;
 const FATAL_NO_STREAM_ERROR = "No stream returned from event subscription";
+const SSE_IDLE_TIMEOUT_ERROR = "SSE stream idle timeout";
 let eventStream = null;
 let eventCallback = null;
 let isListening = false;
@@ -32,6 +34,44 @@ function waitWithAbort(ms, signal) {
         signal.addEventListener("abort", onAbort, { once: true });
     });
 }
+function createAttemptAbortController(parentSignal) {
+    const controller = new AbortController();
+    if (parentSignal.aborted) {
+        controller.abort();
+        return { controller, cleanup: () => { } };
+    }
+    const onAbort = () => controller.abort();
+    parentSignal.addEventListener("abort", onAbort, { once: true });
+    return {
+        controller,
+        cleanup: () => parentSignal.removeEventListener("abort", onAbort),
+    };
+}
+function readStreamWithIdleTimeout(stream, signal) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (result) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeout);
+            signal.removeEventListener("abort", onAbort);
+            resolve(result);
+        };
+        const onAbort = () => finish({ type: "aborted" });
+        const timeout = setTimeout(() => finish({ type: "timeout" }), sseIdleTimeoutMs);
+        if (signal.aborted) {
+            finish({ type: "aborted" });
+            return;
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+        stream.next().then((result) => finish({ type: "next", result }), (error) => finish({ type: "error", error }));
+    });
+}
+function isEventStreamIdleTimeoutError(error) {
+    return error instanceof Error && error.message === SSE_IDLE_TIMEOUT_ERROR;
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null;
 }
@@ -114,15 +154,17 @@ export async function subscribeToEvents(directory, callback) {
         let reconnectAttempt = 0;
         let useLegacyEventsOnce = false;
         while (isListening && activeDirectory === directory && !controller.signal.aborted) {
+            let attemptAbort = null;
             try {
                 let subscription;
+                attemptAbort = createAttemptAbortController(controller.signal);
                 if (useLegacyEventsOnce) {
                     useLegacyEventsOnce = false;
-                    subscription = await subscribeToLegacyEventStream(directory, controller.signal);
+                    subscription = await subscribeToLegacyEventStream(directory, attemptAbort.controller.signal);
                 }
                 else {
                     try {
-                        subscription = await subscribeToGlobalEventStream(controller.signal);
+                        subscription = await subscribeToGlobalEventStream(attemptAbort.controller.signal);
                         logger.debug(`Using global OpenCode event stream for ${directory}`);
                     }
                     catch (error) {
@@ -133,43 +175,67 @@ export async function subscribeToEvents(directory, callback) {
                             throw error;
                         }
                         logger.warn(`Global event stream unavailable for ${directory}, falling back to project event stream`, error);
-                        subscription = await subscribeToLegacyEventStream(directory, controller.signal);
+                        subscription = await subscribeToLegacyEventStream(directory, attemptAbort.controller.signal);
                     }
                 }
                 reconnectAttempt = 0;
                 eventStream = subscription.stream;
                 let usefulEventCount = 0;
-                for await (const event of eventStream) {
-                    if (!isListening || activeDirectory !== directory || controller.signal.aborted) {
-                        logger.debug(`Event listener stopped or changed directory, breaking loop`);
-                        break;
-                    }
-                    // CRITICAL: Explicitly yield to the event loop BEFORE processing the event
-                    // This allows grammY to handle getUpdates between SSE events
-                    await new Promise((resolve) => setImmediate(resolve));
-                    const normalizedEvent = normalizeEvent(event, subscription.source, directory);
-                    if (!normalizedEvent) {
-                        continue;
-                    }
-                    if (normalizedEvent.type !== "server.connected") {
-                        usefulEventCount++;
-                    }
-                    if (eventCallback) {
-                        // Use setImmediate to avoid blocking the event loop
-                        // and let grammY process incoming Telegram updates
-                        const callbackSnapshot = eventCallback;
-                        setImmediate(() => {
-                            if (streamAbortController !== controller ||
-                                controller.signal.aborted ||
-                                !isListening ||
-                                activeDirectory !== directory ||
-                                listenerGeneration !== generation) {
-                                return;
-                            }
-                            callbackSnapshot(normalizedEvent);
-                        });
+                try {
+                    while (isListening && activeDirectory === directory && !controller.signal.aborted) {
+                        const readResult = await readStreamWithIdleTimeout(eventStream, attemptAbort.controller.signal);
+                        if (readResult.type === "aborted") {
+                            logger.debug(`Event listener stopped or changed directory, breaking loop`);
+                            break;
+                        }
+                        if (readResult.type === "timeout") {
+                            attemptAbort.controller.abort();
+                            const closeStream = eventStream.return?.(undefined);
+                            void closeStream?.catch(() => undefined);
+                            throw new Error(SSE_IDLE_TIMEOUT_ERROR);
+                        }
+                        if (readResult.type === "error") {
+                            throw readResult.error;
+                        }
+                        if (readResult.result.done) {
+                            break;
+                        }
+                        const event = readResult.result.value;
+                        // CRITICAL: Explicitly yield to the event loop BEFORE processing the event
+                        // This allows grammY to handle getUpdates between SSE events
+                        await new Promise((resolve) => setImmediate(resolve));
+                        const normalizedEvent = normalizeEvent(event, subscription.source, directory);
+                        if (!normalizedEvent) {
+                            continue;
+                        }
+                        if (normalizedEvent.type !== "server.connected") {
+                            usefulEventCount++;
+                        }
+                        if (eventCallback) {
+                            // Use setImmediate to avoid blocking the event loop
+                            // and let grammY process incoming Telegram updates
+                            const callbackSnapshot = eventCallback;
+                            setImmediate(() => {
+                                if (streamAbortController !== controller ||
+                                    controller.signal.aborted ||
+                                    !isListening ||
+                                    activeDirectory !== directory ||
+                                    listenerGeneration !== generation) {
+                                    return;
+                                }
+                                try {
+                                    callbackSnapshot(normalizedEvent);
+                                }
+                                catch (error) {
+                                    logger.error("[Events] Callback failed:", error);
+                                }
+                            });
+                        }
                     }
                 }
+                finally {
+                    attemptAbort.cleanup();
+                }
                 eventStream = null;
                 if (!isListening || activeDirectory !== directory || controller.signal.aborted) {
                     break;
@@ -188,6 +254,7 @@ export async function subscribeToEvents(directory, callback) {
                 }
             }
             catch (error) {
+                attemptAbort?.cleanup();
                 eventStream = null;
                 if (controller.signal.aborted || !isListening || activeDirectory !== directory) {
                     logger.info("Event listener aborted");
@@ -199,7 +266,10 @@ export async function subscribeToEvents(directory, callback) {
                 }
                 reconnectAttempt++;
                 const reconnectDelay = getReconnectDelayMs(reconnectAttempt);
-                if (isExpectedOpencodeUnavailableError(error)) {
+                if (isEventStreamIdleTimeoutError(error)) {
+                    logger.warn(`Event stream idle timeout for ${directory}, reconnecting in ${reconnectDelay}ms (attempt=${reconnectAttempt})`);
+                }
+                else if (isExpectedOpencodeUnavailableError(error)) {
                     logger.warn(`Event stream unavailable for ${directory}, reconnecting in ${reconnectDelay}ms (attempt=${reconnectAttempt})`);
                 }
                 else {
@@ -251,3 +321,6 @@ export function stopEventListening() {
     activeDirectory = null;
     logger.info("Event listener stopped");
 }
+export function __setSseIdleTimeoutForTests(timeoutMs) {
+    sseIdleTimeoutMs = timeoutMs;
+}

package/dist/scheduled-task/executor.js

@@ -94,9 +94,26 @@ function findLatestAssistantMessage(messages) {
     }
     return null;
 }
+function getAssistantFinishReason(message) {
+    for (let index = message.parts.length - 1; index >= 0; index -= 1) {
+        const part = message.parts[index];
+        if (part?.type === "step-finish" && typeof part.reason === "string" && part.reason.trim()) {
+            return part.reason.trim();
+        }
+    }
+    if (typeof message.info.finish === "string" && message.info.finish.trim()) {
+        return message.info.finish.trim();
+    }
+    return null;
+}
 function extractAssistantResult(message) {
     if (!message) {
-        return { resultText: null, errorMessage: null, completed: false, message: null };
+        return {
+            resultText: null,
+            errorMessage: null,
+            completed: false,
+            message: null,
+        };
     }
     const errorMessage = extractErrorMessage(message.info.error);
     if (errorMessage) {
@@ -108,10 +125,13 @@ function extractAssistantResult(message) {
         };
     }
     const resultText = collectResponseText(message.parts);
+    const completed = Boolean(message.info.time?.completed);
+    const finishReason = getAssistantFinishReason(message);
+    const awaitingToolCalls = completed && finishReason === "tool-calls";
     return {
-        resultText,
+        resultText: awaitingToolCalls ? null : resultText,
         errorMessage: null,
-        completed: Boolean(message.info.time?.completed),
+        completed: completed && !awaitingToolCalls,
         message,
     };
 }
@@ -120,6 +140,7 @@ function summarizeAssistantParts(parts) {
         id: part.id,
         type: part.type,
         ignored: part.ignored,
+        reason: part.reason,
         ...(typeof part.text === "string" ? { textLength: part.text.length } : {}),
         ...(part.tool ? { tool: part.tool } : {}),
         ...(part.state?.status ? { status: part.state.status } : {}),
@@ -136,6 +157,7 @@ function logEmptyAssistantResponseDiagnostics(taskId, sessionId, directory, mess
                 id: message.info.id,
                 completed: Boolean(message.info.time?.completed),
                 summary: Boolean(message.info.summary),
+                finish: getAssistantFinishReason(message),
                 errorMessage: extractErrorMessage(message.info.error),
                 parts: summarizeAssistantParts(message.parts),
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grinev/opencode-telegram-bot",
-  "version": "0.20.3",
+  "version": "0.20.5",
   "description": "Telegram bot client for OpenCode to run and monitor coding tasks from chat.",
   "type": "module",
   "main": "./dist/index.js",