appback-remoteagent 0.14.2 → 0.14.4

package/dist/bot.js

@@ -1087,10 +1087,14 @@ async function runWithPendingAnimation(botToken, chatId, task) {
                 const rendered = formatProviderTelegramChunks(progressChunks, parseMode);
                 const extra = rendered.parseMode ? { parse_mode: rendered.parseMode } : undefined;
                 for (const chunk of rendered.chunks) {
-                    await sendTelegramMessage(botToken, chatId, chunk, extra);
+                    await sendTelegramMessage(botToken, chatId, chunk, extra).catch((error) => {
+                        console.warn(`[telegram-progress-delivery] chat=${chatId} dropped progress message: ${formatTelegramDeliveryError(error)}`);
+                    });
                 }
                 if (normalized.documents.length > 0) {
-                    await sendTelegramDocuments(botToken, chatId, normalized.documents);
+                    await sendTelegramDocuments(botToken, chatId, normalized.documents).catch((error) => {
+                        console.warn(`[telegram-progress-delivery] chat=${chatId} dropped progress document(s): ${formatTelegramDeliveryError(error)}`);
+                    });
                 }
             },
         };
@@ -1146,6 +1150,7 @@ async function routeTelegramWorkLoop(bridge, botId, chatId, message, label, botM
     let untaggedIntentRetryCount = 0;
     let missingEvidenceRetryCount = 0;
     let deliveredProgressCount = 0;
+    let providerCompleted = false;
     const ensureStillBound = async (phase) => {
         if (!sessionId) {
             return;
@@ -1238,6 +1243,7 @@ async function routeTelegramWorkLoop(bridge, botId, chatId, message, label, botM
                     if (currentSession) {
                         await memoryService.completeTask(currentSession.session, parsed.chunks.join("\n"));
                     }
+                    providerCompleted = true;
                     autoContinue.clear(botId, chatId, sessionId);
                     return parsed.chunks;
                 }
@@ -1314,7 +1320,12 @@ async function routeTelegramWorkLoop(bridge, botId, chatId, message, label, botM
     }
     finally {
         if (currentSession) {
-            await botManagement.markProviderIdle(botId, sessionId);
+            if (providerCompleted) {
+                await botManagement.markProviderCompleted(botId, sessionId);
+            }
+            else {
+                await botManagement.markProviderIdle(botId, sessionId);
+            }
         }
     }
 }
@@ -2226,23 +2237,38 @@ async function sendTelegramDocument(botToken, chatId, document) {
 async function sendTelegramMessage(botToken, chatId, text, extra) {
     const startedAt = Date.now();
     try {
-        try {
-            return await callTelegramApi(botToken, "sendMessage", {
-                chat_id: String(chatId),
-                text,
-                parse_mode: extra?.parse_mode,
-            });
-        }
-        catch (error) {
-            if (!extra?.parse_mode || !isTelegramEntityParseError(error)) {
-                throw error;
+        let lastError;
+        for (let attempt = 1; attempt <= 3; attempt += 1) {
+            try {
+                try {
+                    return await callTelegramApi(botToken, "sendMessage", {
+                        chat_id: String(chatId),
+                        text,
+                        parse_mode: extra?.parse_mode,
+                    });
+                }
+                catch (error) {
+                    if (!extra?.parse_mode || !isTelegramEntityParseError(error)) {
+                        throw error;
+                    }
+                    console.warn(`[telegram-sendMessage-fallback] chat=${chatId} parseMode=${extra.parse_mode}: ${formatTelegramDeliveryError(error)}`);
+                    return await callTelegramApi(botToken, "sendMessage", {
+                        chat_id: String(chatId),
+                        text: stripTelegramHtml(text),
+                    });
+                }
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt >= 3 || !isRetryableTelegramDeliveryError(error)) {
+                    throw error;
+                }
+                const delayMs = attempt * 1500;
+                console.warn(`[telegram-sendMessage-retry] chat=${chatId} attempt=${attempt}/3 delayMs=${delayMs}: ${formatTelegramDeliveryError(error)}`);
+                await sleep(delayMs);
             }
-            console.warn(`[telegram-sendMessage-fallback] chat=${chatId} parseMode=${extra.parse_mode}: ${error instanceof Error ? error.message : String(error)}`);
-            return await callTelegramApi(botToken, "sendMessage", {
-                chat_id: String(chatId),
-                text: stripTelegramHtml(text),
-            });
         }
+        throw lastError instanceof Error ? lastError : new Error(String(lastError));
     }
     finally {
         const elapsedMs = Date.now() - startedAt;
@@ -2282,7 +2308,16 @@ async function callTelegramApi(botToken, method, params) {
             args.push("--data-urlencode", `${key}=${value}`);
         }
     }
-    const { stdout, stderr } = await execFileAsync("curl", args);
+    let stdout;
+    let stderr;
+    try {
+        const result = await execFileAsync("curl", args);
+        stdout = result.stdout;
+        stderr = result.stderr;
+    }
+    catch (error) {
+        throw new TelegramApiError(method, summarizeCurlTelegramError(error, method));
+    }
     if (stderr?.trim()) {
         console.error(`curl stderr for ${method}: ${stderr.trim()}`);
     }
@@ -2302,6 +2337,26 @@ class TelegramApiError extends Error {
         this.name = "TelegramApiError";
     }
 }
+function summarizeCurlTelegramError(error, method) {
+    if (!(error instanceof Error)) {
+        return `Telegram API ${method} failed: ${String(error)}`;
+    }
+    const stderr = typeof error === "object" && error !== null && "stderr" in error
+        ? String(error.stderr ?? "").trim()
+        : "";
+    const code = typeof error === "object" && error !== null && "code" in error
+        ? String(error.code ?? "")
+        : "";
+    const message = stderr || error.message;
+    return [`Telegram API ${method} curl failed`, code ? `code=${code}` : undefined, message].filter(Boolean).join(": ");
+}
+function formatTelegramDeliveryError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isRetryableTelegramDeliveryError(error) {
+    const message = formatTelegramDeliveryError(error);
+    return /timed out|timeout|Bad Gateway|502|503|504|ECONNRESET|connection reset|EAI_AGAIN|ENOTFOUND/i.test(message);
+}
 function isTelegramForbiddenError(error) {
     if (error instanceof GrammyError) {
         return error.error_code === 403 || /^Forbidden:/i.test(error.description);

package/dist/index.js

@@ -236,11 +236,13 @@ async function pollTelegramBot(pollingBot, runtime, options) {
             runtime.offset = orderedUpdates[orderedUpdates.length - 1].update_id + 1;
         }
         const receivedMessage = orderedUpdates.some(hasMessagePayload);
-        const lastMessageAt = receivedMessage ? new Date(now).toISOString() : options.state?.lastMessageAt;
+        const lastUserMessageAt = receivedMessage ? new Date(now).toISOString() : options.state?.lastUserMessageAt;
+        const lastMessageAt = receivedMessage ? lastUserMessageAt : options.state?.lastMessageAt;
         const nextPollAt = now + computePolicyPollIntervalMs(options.totalBots, receivedMessage ? 1 : options.botRank, {
             ...options.state,
             botId,
             consecutiveFailures: options.state?.consecutiveFailures ?? runtime.consecutiveFailures,
+            lastUserMessageAt,
             lastMessageAt,
         }, {
             tieredPollingMinBots: config.telegramTieredPollingMinBots,
@@ -253,6 +255,7 @@ async function pollTelegramBot(pollingBot, runtime, options) {
             username: pollingBot.botInfo.username,
             lastPollAt: new Date(now).toISOString(),
             lastUpdateAt: orderedUpdates.length > 0 ? new Date(now).toISOString() : undefined,
+            lastUserMessageAt,
             lastMessageAt,
             nextPollAt: new Date(nextPollAt).toISOString(),
             consecutiveFailures: 0,

package/dist/services/bot-management-service.js

@@ -54,6 +54,11 @@ export class BotManagementService {
         const pollingBotId = bot ? String(bot.id) : botId;
         await this.pollingState.markIdle(pollingBotId, sessionId, bot?.username);
     }
+    async markProviderCompleted(botId, sessionId) {
+        const bot = await this.findConfiguredBot(botId);
+        const pollingBotId = bot ? String(bot.id) : botId;
+        await this.pollingState.markCompleted(pollingBotId, sessionId, bot?.username);
+    }
     async getPendingOperationNotice() {
         const pending = await this.readPendingOperation();
         if (!pending) {

package/dist/services/bot-polling-state-service.js

@@ -70,6 +70,21 @@ export class BotPollingStateService {
         state.bots[botId] = current;
         await this.writeNow();
     }
+    async markCompleted(botId, sessionId, username) {
+        await this.markIdle(botId, sessionId, username);
+        const state = await this.read();
+        const current = state.bots[botId] ?? {
+            botId,
+            username,
+            consecutiveFailures: 0,
+        };
+        if (username) {
+            current.username = username;
+        }
+        current.lastProviderCompletedAt = new Date().toISOString();
+        state.bots[botId] = current;
+        await this.writeNow();
+    }
     async recordPoll(botId, patch) {
         const state = await this.read();
         const current = state.bots[botId] ?? {

package/dist/services/polling-policy.js

@@ -2,7 +2,7 @@ export function computeRecentMessageRanks(botIds, states) {
     const ranked = botIds
         .map((botId) => ({
         botId,
-        timestamp: parseStateTime(states[botId]?.lastMessageAt) ?? 0,
+        timestamp: latestTimestamp(states[botId]?.lastUserMessageAt ?? states[botId]?.lastMessageAt, states[botId]?.lastProviderCompletedAt),
     }))
         .sort((left, right) => right.timestamp - left.timestamp);
     return new Map(ranked.map((entry, index) => [entry.botId, index + 1]));
@@ -29,3 +29,6 @@ function parseStateTime(value) {
     const timestamp = Date.parse(value);
     return Number.isFinite(timestamp) ? timestamp : undefined;
 }
+function latestTimestamp(...values) {
+    return Math.max(0, ...values.map((value) => parseStateTime(value) ?? 0));
+}

package/docs/BOT_POLLING_POLICY.md

@@ -14,6 +14,13 @@ When 5 or more bots are configured:
 - the next 4 idle bots poll every 60 seconds
 - all remaining idle bots poll every 180 seconds
 
+Recent activity is updated only when:
+
+- the operator sends a message to that bot
+- the provider returns a completed result to that bot
+
+Polling itself must not update recent activity. A bot should not become "recent" merely because RemoteAgent checked Telegram for updates.
+
 When a bot has active provider work:
 
 - that bot polls every 60 seconds

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appback-remoteagent",
-  "version": "0.14.2",
+  "version": "0.14.4",
   "description": "Personal installable session server for continuing local AI work across PC and Telegram",
   "license": "MIT",
   "type": "module",