appback-remoteagent 0.23.0 → 0.23.2

package/README.md

@@ -105,7 +105,7 @@ Current command surface implemented in `src/bot.ts`:
 | `/new` | Creates and binds a new session using the saved default mode in a new managed workspace |
 | `/switch <session>` | Rebinds this chat to an existing RemoteAgent session |
 | `/status` | Shows current session, workspace, provider, and sandbox state |
-| `/model [name]` | Lists selectable provider models or changes the current session model |
+| `/model [name]` | Lists selectable provider models or changes the current session model. New Codex sessions default to `gpt-6-astra` with `medium` reasoning. Use `/model gpt-6-astra` for an existing session. |
 | `/sandbox [codex <mode>]` | Lists Codex sandbox choices or changes the current session sandbox |
 | `/option retry <count>` | Sets the automatic continuation turn limit and persists it to `~/.remoteagent/.env` |
 | `/option timeout <seconds>` | Sets the provider execution timeout and persists it to `~/.remoteagent/.env` |

package/dist/adapters/codex-adapter.js

@@ -67,6 +67,9 @@ export class CodexAdapter {
         if (request.model) {
             args.push("-m", request.model);
         }
+        if (request.model === "gpt-6-astra") {
+            args.push("-c", 'model_reasoning_effort="medium"');
+        }
         this.appendSandboxArgs(args, sandboxMode);
         args.push("-o", outputPath, "-C", request.cwd);
         this.appendPromptStdinArg(args);
@@ -82,6 +85,9 @@ export class CodexAdapter {
         if (request.model) {
             args.push("-m", request.model);
         }
+        if (request.model === "gpt-6-astra") {
+            args.push("-c", 'model_reasoning_effort="medium"');
+        }
         this.appendSandboxArgs(args, sandboxMode);
         args.push("-o", outputPath, request.sessionId);
         this.appendPromptStdinArg(args);

package/dist/bot.js

@@ -1452,6 +1452,10 @@ async function runWithPendingAnimation(botToken, chatId, task) {
                     typingStopped = true;
                     return;
                 }
+                if (isTelegramRateLimitError(error)) {
+                    console.warn(`[telegram-chat-action] chat=${chatId} paused by Telegram rate limit: ${formatTelegramDeliveryError(error)}`);
+                    return;
+                }
                 console.warn(`[telegram-chat-action] chat=${chatId} failed: ${error instanceof Error ? error.message : String(error)}`);
             })
                 .finally(() => {
@@ -1467,6 +1471,9 @@ async function runWithPendingAnimation(botToken, chatId, task) {
     try {
         const helpers = {
             reportProgress: async (chunks, parseMode, messageOptions) => {
+                if (getTelegramRateLimitDelayMs(botToken) > 0) {
+                    return;
+                }
                 const normalized = await normalizeTelegramDelivery(chunks);
                 const progressChunks = flattenChunks(normalized.chunks, 3900);
                 if (progressChunks.length === 0 && normalized.documents.length === 0) {
@@ -1478,12 +1485,12 @@ async function runWithPendingAnimation(botToken, chatId, task) {
                     ...(rendered.parseMode ? { parse_mode: rendered.parseMode } : {}),
                 };
                 for (const chunk of rendered.chunks) {
-                    await sendTelegramMessage(botToken, chatId, chunk, extra).catch((error) => {
+                    await sendTelegramMessage(botToken, chatId, chunk, extra, "progress").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).catch((error) => {
+                    await sendTelegramDocuments(botToken, chatId, normalized.documents, "progress").catch((error) => {
                         console.warn(`[telegram-progress-delivery] chat=${chatId} dropped progress document(s): ${formatTelegramDeliveryError(error)}`);
                     });
                 }
@@ -3052,9 +3059,29 @@ async function isReadableTelegramDocument(filePath) {
         return false;
     }
 }
-async function sendTelegramDocuments(botToken, chatId, documents) {
+async function sendTelegramDocuments(botToken, chatId, documents, deliveryClass = "final") {
+    if (deliveryClass === "progress" && getTelegramRateLimitDelayMs(botToken) > 0) {
+        return;
+    }
     for (const document of documents) {
-        await sendTelegramDocument(botToken, chatId, document);
+        if (deliveryClass === "progress") {
+            await sendTelegramDocument(botToken, chatId, document);
+            continue;
+        }
+        await serializeTelegramMessage(botToken, async () => {
+            for (let attempt = 1; attempt <= 3; attempt += 1) {
+                await waitForTelegramRateLimit(botToken);
+                try {
+                    await sendTelegramDocument(botToken, chatId, document);
+                    return;
+                }
+                catch (error) {
+                    if (!isTelegramRateLimitError(error) || attempt >= 3) {
+                        throw error;
+                    }
+                }
+            }
+        });
     }
 }
 async function sendTelegramDocument(botToken, chatId, document) {
@@ -3081,7 +3108,14 @@ async function sendTelegramDocument(botToken, chatId, document) {
     }
     const payload = JSON.parse(stdout);
     if (!payload.ok || !payload.result) {
-        throw new Error(payload.description || "Telegram API sendDocument failed.");
+        const retryAfterSeconds = payload.parameters?.retry_after;
+        const retryAfterMs = typeof retryAfterSeconds === "number" && retryAfterSeconds > 0
+            ? Math.ceil(retryAfterSeconds * 1000) + 250
+            : undefined;
+        if (payload.error_code === 429 || retryAfterMs !== undefined) {
+            registerTelegramRateLimit(botToken, retryAfterMs ?? 5_250);
+        }
+        throw new TelegramApiError("sendDocument", payload.description || "Telegram API sendDocument failed.", payload.error_code, retryAfterMs);
     }
     return payload.result;
 }
@@ -3104,11 +3138,23 @@ async function deleteTelegramMessage(botToken, chatId, messageId) {
         throw new Error(payload.description || "Telegram API deleteMessage failed.");
     }
 }
-async function sendTelegramMessage(botToken, chatId, text, extra) {
+async function sendTelegramMessage(botToken, chatId, text, extra, deliveryClass = "final") {
+    if (deliveryClass === "progress") {
+        if (getTelegramRateLimitDelayMs(botToken) > 0) {
+            throw new TelegramDeliveryDeferredError("Telegram progress delivery skipped during rate-limit cooldown.");
+        }
+        return sendTelegramMessageNow(botToken, chatId, text, extra, deliveryClass);
+    }
+    return serializeTelegramMessage(botToken, () => sendTelegramMessageNow(botToken, chatId, text, extra, deliveryClass));
+}
+async function sendTelegramMessageNow(botToken, chatId, text, extra, deliveryClass) {
     const startedAt = Date.now();
     try {
         let lastError;
         for (let attempt = 1; attempt <= 3; attempt += 1) {
+            if (deliveryClass === "final") {
+                await waitForTelegramRateLimit(botToken);
+            }
             try {
                 try {
                     return await callTelegramApi(botToken, "sendMessage", {
@@ -3132,6 +3178,15 @@ async function sendTelegramMessage(botToken, chatId, text, extra) {
             }
             catch (error) {
                 lastError = error;
+                if (isTelegramRateLimitError(error)) {
+                    if (deliveryClass === "progress" || attempt >= 3) {
+                        throw error;
+                    }
+                    const delayMs = getTelegramRateLimitDelayMs(botToken);
+                    console.warn(`[telegram-sendMessage-rate-limit] chat=${chatId} attempt=${attempt}/3 retryAfterMs=${delayMs}`);
+                    await waitForTelegramRateLimit(botToken);
+                    continue;
+                }
                 if (attempt >= 3 || !isRetryableTelegramDeliveryError(error)) {
                     throw error;
                 }
@@ -3163,6 +3218,9 @@ function stripTelegramHtml(value) {
         .replace(/&amp;/g, "&");
 }
 async function sendTelegramChatAction(botToken, chatId, action) {
+    if (getTelegramRateLimitDelayMs(botToken) > 0) {
+        return;
+    }
     await callTelegramApi(botToken, "sendChatAction", {
         chat_id: String(chatId),
         action,
@@ -3195,20 +3253,78 @@ async function callTelegramApi(botToken, method, params) {
     }
     const payload = JSON.parse(stdout);
     if (!payload.ok) {
-        throw new TelegramApiError(method, payload.description || `Telegram API ${method} failed.`);
+        const retryAfterSeconds = payload.parameters?.retry_after;
+        const retryAfterMs = typeof retryAfterSeconds === "number" && retryAfterSeconds > 0
+            ? Math.ceil(retryAfterSeconds * 1000) + 250
+            : undefined;
+        if (payload.error_code === 429 || retryAfterMs !== undefined) {
+            registerTelegramRateLimit(botToken, retryAfterMs ?? 5_250);
+        }
+        throw new TelegramApiError(method, payload.description || `Telegram API ${method} failed.`, payload.error_code, retryAfterMs);
     }
     return payload.result;
 }
 class TelegramApiError extends Error {
     method;
     description;
-    constructor(method, description) {
+    errorCode;
+    retryAfterMs;
+    constructor(method, description, errorCode, retryAfterMs) {
         super(description);
         this.method = method;
         this.description = description;
+        this.errorCode = errorCode;
+        this.retryAfterMs = retryAfterMs;
         this.name = "TelegramApiError";
     }
 }
+class TelegramDeliveryDeferredError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TelegramDeliveryDeferredError";
+    }
+}
+const telegramRateLimitUntil = new Map();
+const telegramMessageQueues = new Map();
+function telegramBotKey(botToken) {
+    return botToken.split(":", 1)[0] || botToken;
+}
+function registerTelegramRateLimit(botToken, retryAfterMs) {
+    const key = telegramBotKey(botToken);
+    const until = Date.now() + Math.max(250, retryAfterMs);
+    telegramRateLimitUntil.set(key, Math.max(telegramRateLimitUntil.get(key) ?? 0, until));
+}
+function getTelegramRateLimitDelayMs(botToken) {
+    const key = telegramBotKey(botToken);
+    const until = telegramRateLimitUntil.get(key) ?? 0;
+    const delayMs = until - Date.now();
+    if (delayMs <= 0) {
+        telegramRateLimitUntil.delete(key);
+        return 0;
+    }
+    return delayMs;
+}
+async function waitForTelegramRateLimit(botToken) {
+    const delayMs = getTelegramRateLimitDelayMs(botToken);
+    if (delayMs > 0) {
+        await sleep(delayMs);
+    }
+}
+async function serializeTelegramMessage(botToken, task) {
+    const key = telegramBotKey(botToken);
+    const previous = telegramMessageQueues.get(key) ?? Promise.resolve();
+    const current = previous.catch(() => undefined).then(task);
+    const tail = current.then(() => undefined, () => undefined);
+    telegramMessageQueues.set(key, tail);
+    try {
+        return await current;
+    }
+    finally {
+        if (telegramMessageQueues.get(key) === tail) {
+            telegramMessageQueues.delete(key);
+        }
+    }
+}
 function summarizeCurlTelegramError(error, method) {
     if (!(error instanceof Error)) {
         return `Telegram API ${method} failed: ${String(error)}`;
@@ -3229,6 +3345,9 @@ 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 isTelegramRateLimitError(error) {
+    return error instanceof TelegramApiError && (error.errorCode === 429 || error.retryAfterMs !== undefined);
+}
 function isTelegramForbiddenError(error) {
     if (error instanceof GrammyError) {
         return error.error_code === 403 || /^Forbidden:/i.test(error.description);

package/dist/index.js

@@ -20,7 +20,6 @@ import { ProviderRecoveryService } from "./services/provider-recovery-service.js
 import { computePolicyPollIntervalMs, computeRecentMessageRanks } from "./services/polling-policy.js";
 import { terminateAllSpawnedExecutions } from "./adapters/windows-shell.js";
 import { buildProviderEnv } from "./adapters/runtime-env.js";
-import { setTelegramCommandMenu } from "./telegram-command-menu.js";
 import { buildBotInfoFromIdentity, buildFallbackBotInfo } from "./telegram-bot-identity.js";
 const execFileAsync = promisify(execFile);
 const TELEGRAM_GET_UPDATES_HTTP_TIMEOUT_SECONDS = 30;
@@ -72,20 +71,14 @@ async function main() {
     }
     const botInfos = await Promise.all(config.telegramBotTokens.map((token, index) => resolveBotInfo(token, index, config.telegramBotUsernames[index])));
     const bots = config.telegramBotTokens.map((token, index) => createBot(token, bridge, botManagement, botInfos[index]));
-    if (config.telegramCommandMenuEnabled) {
-        for (const bot of bots) {
-            const username = bot.botInfo.username;
-            await configureTelegramCommandMenu(bot).catch((error) => {
-                console.error(`Failed to configure command menu for @${username}:`, error);
-            });
-            console.log(`Bot @${username} is ready`);
-        }
+    if (!config.telegramCommandMenuEnabled) {
+        console.log("Telegram command menu registration is disabled.");
     }
     else {
-        console.log("Telegram command menu registration is disabled.");
-        for (const bot of bots) {
-            console.log(`Bot @${bot.botInfo.username} is ready`);
-        }
+        console.log("Telegram command menu startup refresh is skipped; use /option command-menu refresh to apply changes.");
+    }
+    for (const bot of bots) {
+        console.log(`Bot @${bot.botInfo.username} is ready`);
     }
     await botManagement.reportPendingOperationResult().catch((error) => {
         console.error("Failed to report pending bot operation result:", error);
@@ -140,26 +133,6 @@ function startArtifactCleanupSchedule(memoryService) {
     }, config.artifactCleanupIntervalMs);
     interval.unref();
 }
-async function configureTelegramCommandMenu(bot) {
-    const token = bot.token;
-    if (!token) {
-        throw new Error("Telegram bot token is unavailable for command menu registration.");
-    }
-    let lastError;
-    for (let attempt = 1; attempt <= 3; attempt += 1) {
-        try {
-            await setTelegramCommandMenu(token);
-            return;
-        }
-        catch (error) {
-            lastError = error;
-            if (attempt < 3) {
-                await sleep(1000 * attempt);
-            }
-        }
-    }
-    throw lastError;
-}
 main().catch((error) => {
     console.error("RemoteAgent fatal error:", error);
     releaseProcessLockSync();

package/dist/services/bridge-service.js

@@ -5,10 +5,10 @@ import path from "node:path";
 import { stopSpawnedExecution } from "../adapters/windows-shell.js";
 import { CODEX_USAGE_FALLBACK_MODEL, CodexUsageFallbackService, parseCodexUsageLimit, } from "./codex-usage-fallback-service.js";
 const MODEL_PRESETS = {
-    codex: ["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "gpt-5.6", "gpt-5.5", "gpt-5.4", "gpt-5.4-mini", "gpt-5.3-codex-spark", "gpt-5.2", "gpt-5.1-codex-max"],
+    codex: ["gpt-6-astra", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "gpt-5.6", "gpt-5.5", "gpt-5.4", "gpt-5.4-mini", "gpt-5.3-codex-spark", "gpt-5.2", "gpt-5.1-codex-max"],
     claude: ["sonnet", "opus", "haiku"],
 };
-const DEFAULT_CODEX_MODEL = "gpt-5.6-sol";
+const DEFAULT_CODEX_MODEL = "gpt-6-astra";
 export class BridgeService {
     store;
     adapters;
@@ -367,7 +367,8 @@ export class BridgeService {
         return responses.map((response) => {
             const sessionLabel = response.publicSessionId ?? response.sessionId;
             const modelLabel = response.model?.trim() || this.defaultModelFor(response.provider);
-            const header = `[${response.provider.toUpperCase()} | ${modelLabel} | ${sessionLabel}]`;
+            const effortLabel = response.provider === "codex" && modelLabel === "gpt-6-astra" ? " | medium" : "";
+            const header = `[${response.provider.toUpperCase()} | ${modelLabel}${effortLabel} | ${sessionLabel}]`;
             return `${header}\n${response.output}`;
         });
     }

package/package.json

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

package/scripts/selftest-codex-stream.mjs

@@ -34,6 +34,12 @@ await fs.chmod(fakeCodex, 0o755);
 
 const { CodexAdapter } = await import(path.join(root, "dist", "adapters", "codex-adapter.js"));
 const adapter = new CodexAdapter(fakeCodex, 5000, "read-only");
+for (const method of ["buildExecArgs", "buildResumeArgs"]) {
+  const args = adapter[method]({model: "gpt-6-astra", cwd: tmp, sessionId: "stream-thread"}, path.join(tmp, "output"), "read-only");
+  if (args[args.indexOf("-m") + 1] !== "gpt-6-astra" || !args.some((arg, i) => arg === "-c" && args[i + 1] === 'model_reasoning_effort="medium"')) {
+    throw new Error(`Astra medium missing from ${method}`);
+  }
+}
 const progress = [];
 let settled = false;
 const responsePromise = adapter.send({

package/scripts/selftest-model-fallback.mjs

@@ -18,7 +18,7 @@ const dataDir = path.join(root, "data");
 const workspaceRoot = path.join(root, "workspaces");
 const defaultWorkspace = path.join(root, "default-workspace");
 const fallbackStatePath = path.join(dataDir, "codex-usage-fallback.json");
-const primaryModel = "gpt-5.6-sol";
+const primaryModel = "gpt-6-astra";
 const usageError = "You've hit your usage limit. Visit https://chatgpt.com/codex/settings/usage to purchase more credits or try again at Aug 27th, 2099 3:52 AM.";
 
 try {
@@ -63,6 +63,7 @@ try {
   );
 
   let bridge = createBridge();
+  assert.equal(bridge.formatResponses([{provider: "codex", model: primaryModel, publicSessionId: "S081", output: "done"}])[0], "[CODEX | gpt-6-astra | medium | S081]\ndone");
   const started = await bridge.startSession("test-bot", "test-chat", "codex");
   const originalSessionId = started.session.sessionId;
   const first = await bridge.routeMessage("test-bot", "test-chat", "first request", async (response) => {

package/scripts/selftest-telegram-update.mjs

@@ -12,6 +12,7 @@ const workspaceRoot = path.join(tmp, "workspaces");
 const binDir = path.join(tmp, "bin");
 const telegramCalls = path.join(tmp, "telegram-calls.jsonl");
 const capturedDocument = path.join(tmp, "captured-document.ra-secrets");
+const rateLimitOnce = path.join(tmp, "telegram-rate-limit-once");
 
 await fs.mkdir(workspace, { recursive: true });
 await fs.mkdir(workspaceRoot, { recursive: true });
@@ -27,6 +28,7 @@ document_path=""
 for arg in "$@"; do
   case "$arg" in
     https://api.telegram.org/bot*/sendMessage) method="sendMessage" ;;
+    https://api.telegram.org/bot*/sendChatAction) method="sendChatAction" ;;
     https://api.telegram.org/bot*/editMessageText) method="editMessageText" ;;
     https://api.telegram.org/bot*/deleteMessage) method="deleteMessage" ;;
     https://api.telegram.org/bot*/sendDocument) method="sendDocument" ;;
@@ -40,6 +42,11 @@ done
 text_b64="$(printf '%s' "$text" | base64 -w 0)"
 reply_markup_b64="$(printf '%s' "$reply_markup" | base64 -w 0)"
 printf '%s\\t%s\\t%s\\t%s\\n' "$method" "$chat_id" "$text_b64" "$reply_markup_b64" >> ${JSON.stringify(telegramCalls)}
+if [[ "$method" == "sendMessage" && -n "\${TELEGRAM_SELFTEST_RATE_LIMIT_FILE:-}" && -f "\${TELEGRAM_SELFTEST_RATE_LIMIT_FILE}" ]]; then
+  rm -f "\${TELEGRAM_SELFTEST_RATE_LIMIT_FILE}"
+  printf '{"ok":false,"error_code":429,"description":"Too Many Requests: retry after 1","parameters":{"retry_after":1}}'
+  exit 0
+fi
 case "$method" in
   sendMessage|editMessageText)
     printf '{"ok":true,"result":{"message_id":1001}}'
@@ -69,6 +76,7 @@ process.env.TELEGRAM_AUTO_PROGRESS_MAX_TURNS = "1";
 process.env.TELEGRAM_EMPTY_RESPONSE_RETRIES = "0";
 process.env.TELEGRAM_RETRYABLE_ERROR_RETRIES = "0";
 process.env.LOCAL_UI_ENABLED = "false";
+process.env.TELEGRAM_SELFTEST_RATE_LIMIT_FILE = rateLimitOnce;
 
 const [
   { createBot },
@@ -320,6 +328,13 @@ await send("/secret set API_TOKEN telegram-secret-export-value");
 await send("/secret export REMOTEAGENT_TRANSFER_PASSPHRASE API_TOKEN");
 await send("같은 값을 봐야하는데 로직문제네? 확인해줘\\n이미 수정되어 있을 수 있어.\\n나한테 수정했다고 보고했었거든");
 await send("/state");
+await fs.writeFile(rateLimitOnce, "once", "utf8");
+const rateLimitStartedAt = Date.now();
+await send("/status");
+const rateLimitElapsedMs = Date.now() - rateLimitStartedAt;
+if (rateLimitElapsedMs < 1000) {
+  throw new Error(`Telegram retry_after was not honored: elapsedMs=${rateLimitElapsedMs}`);
+}
 
 const state = JSON.parse(await fs.readFile(path.join(dataDir, "state.json"), "utf8"));
 const sessions = Object.values(state.sessions);
@@ -843,6 +858,7 @@ console.log(JSON.stringify({
   usageLimitFallback: true,
   longTelegramTextStoredAsFile: true,
   telegramSendMessages: evidenceCalls.filter((call) => call.method === "sendMessage").length,
+  telegramRateLimitElapsedMs: rateLimitElapsedMs,
 }, null, 2));
 
 process.exit(0);