appback-remoteagent 0.23.2 → 0.23.4

package/README.md

@@ -105,7 +105,9 @@ 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. New Codex sessions default to `gpt-6-astra` with `medium` reasoning. Use `/model gpt-6-astra` for an existing session. |
+| `/model [name]` | Lists selectable provider models or changes the current session model. New Codex sessions default to `gpt-6-astra`. Use `/model gpt-6-astra` for an existing session. |
+| `/model restore` | Clears temporary Codex fallback after a usage reset or credit purchase. Server-wide; next execution uses each session's configured model. Running work is preserved. Also available through the model menu's restore button. |
+| `/option reasoning [low\|medium\|high\|xhigh\|max]` | Shows or changes Astra reasoning for all bots on this server. Defaults to `medium`; persisted as `CODEX_REASONING_EFFORT`. Applies on the next execution without restarting. Running replies retain their actual execution effort in the header. |
 | `/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

@@ -3,6 +3,7 @@ import os from "node:os";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { spawnWithPlatformShell } from "./windows-shell.js";
+import { getAstraReasoning } from "../services/codex-reasoning.js";
 export class CodexAdapter {
     codexBin;
     timeoutMs;
@@ -68,7 +69,7 @@ export class CodexAdapter {
             args.push("-m", request.model);
         }
         if (request.model === "gpt-6-astra") {
-            args.push("-c", 'model_reasoning_effort="medium"');
+            args.push("-c", `model_reasoning_effort=${JSON.stringify(request.reasoningEffort ?? getAstraReasoning())}`);
         }
         this.appendSandboxArgs(args, sandboxMode);
         args.push("-o", outputPath, "-C", request.cwd);
@@ -86,7 +87,7 @@ export class CodexAdapter {
             args.push("-m", request.model);
         }
         if (request.model === "gpt-6-astra") {
-            args.push("-c", 'model_reasoning_effort="medium"');
+            args.push("-c", `model_reasoning_effort=${JSON.stringify(request.reasoningEffort ?? getAstraReasoning())}`);
         }
         this.appendSandboxArgs(args, sandboxMode);
         args.push("-o", outputPath, request.sessionId);

package/dist/bot.js

@@ -3,6 +3,7 @@ import fsSync from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import process from "node:process";
 import { randomUUID } from "node:crypto";
 import { promisify } from "node:util";
 import { Bot, GrammyError, HttpError } from "grammy";
@@ -13,6 +14,7 @@ import { AgentMemoryService } from "./services/agent-memory-service.js";
 import { WorkspaceCleanupService } from "./services/workspace-cleanup-service.js";
 import { exportSecrets } from "./services/secret-transfer-service.js";
 import { deleteTelegramCommandMenu, setTelegramCommandMenu } from "./telegram-command-menu.js";
+import { ASTRA_REASONING_LEVELS, getAstraReasoning, isAstraReasoning } from "./services/codex-reasoning.js";
 const execFileAsync = promisify(execFile);
 const HELP_TEXT = [
     "Commands:",
@@ -25,12 +27,12 @@ const HELP_TEXT = [
     "/batch start|send|cancel|status",
     "/attach codex <thread_id>",
     "/attach claude <session_id>",
-    "/model [name]",
+    "/model [name|restore]",
     "/queue [remove <id>|del]",
     "/stop",
     "/sandbox codex <read-only|workspace-write|danger-full-access>",
     "/status",
-    "/option [retry <count>|timeout <seconds>|intent <count>|command-menu <on|off|refresh>]",
+    "/option [retry <count>|timeout <seconds>|intent <count>|reasoning <low|medium|high|xhigh|max>|command-menu <on|off|refresh>]",
     "/state [clear|note <text>]",
     "/artifacts list|cleanup <days>",
     "/cleanup",
@@ -545,16 +547,22 @@ ${bridge.formatStatus(mapping)}`);
         const { args, rest } = parseCommand(ctx.message?.text, 1);
         const model = args[0]?.trim();
         if (rest?.trim()) {
-            await reply(ctx, "Usage: `/model` or `/model <name|number>`", {
+            await reply(ctx, "Usage: `/model`, `/model <name|number>`, or `/model restore`", {
                 parse_mode: "Markdown",
             });
             return;
         }
+        if (model?.toLowerCase() === "restore") {
+            await ensureOwnerControlAccess(ctx);
+            await reply(ctx, await bridge.restoreCodexModel());
+            return;
+        }
         if (!model) {
             const selection = await bridge.getModelSelection(botId, chatId);
             const rows = selection.presets.map((preset) => [
                 actionButton(ctx, `${preset === selection.currentModel ? "✓ " : ""}${preset}`, { kind: "model.set", model: preset }),
             ]);
+            rows.push([actionButton(ctx, "원래 모델 복귀", { kind: "model.restore" })]);
             await reply(ctx, await bridge.formatModelSelection(botId, chatId), {
                 parse_mode: "Markdown",
                 ...(keyboardOptions(rows) ?? {}),
@@ -642,12 +650,13 @@ ${bridge.formatStatus(mapping)}`);
                 ],
                 [
                     actionButton(ctx, "Intent", { kind: "option.show", option: "intent" }),
+                    actionButton(ctx, "Reasoning", { kind: "option.show", option: "reasoning" }),
                     actionButton(ctx, "Command menu", { kind: "option.show", option: "command-menu" }),
                 ],
             ]));
             return;
         }
-        if (option !== "retry" && option !== "timeout" && option !== "intent" && option !== "command-menu") {
+        if (option !== "retry" && option !== "timeout" && option !== "intent" && option !== "reasoning" && option !== "command-menu") {
             await reply(ctx, "Usage: `/option retry <count>`, `/option timeout <seconds>`, `/option intent <count>`, or `/option command-menu <on|off|refresh>`\n\n`retry` controls automatic continuation turns. `timeout` controls one provider execution limit. `intent` controls retries for untagged intent-only provider replies. `command-menu` controls Telegram slash-command autocomplete for all configured bots.", {
                 parse_mode: "Markdown",
             });
@@ -659,6 +668,17 @@ ${bridge.formatStatus(mapping)}`);
             });
             return;
         }
+        if (option === "reasoning") {
+            const effort = value.toLowerCase();
+            if (!isAstraReasoning(effort)) {
+                await reply(ctx, `Invalid reasoning effort. Use /option reasoning <${ASTRA_REASONING_LEVELS.join("|")}>.`);
+                return;
+            }
+            await upsertInstalledEnvValue("CODEX_REASONING_EFFORT", effort);
+            process.env.CODEX_REASONING_EFFORT = effort;
+            await reply(ctx, `Set Astra reasoning effort to ${effort}. Applies to the next Astra execution for all bots on this server; running executions keep their current effort.\n\nSaved: CODEX_REASONING_EFFORT=${effort}`);
+            return;
+        }
         if (option === "command-menu") {
             const action = value.toLowerCase();
             if (!["on", "off", "refresh"].includes(action)) {
@@ -1137,6 +1157,11 @@ ${bridge.formatStatus(mapping)}`);
                 await reply(ctx, await setChatModel(ctx, action.model));
                 return;
             }
+            if (action.kind === "model.restore") {
+                await ensureOwnerControlAccess(ctx);
+                await reply(ctx, await bridge.restoreCodexModel());
+                return;
+            }
             if (action.kind === "macro.run") {
                 const result = await runMacro(ctx, action.alias);
                 if (result) {
@@ -2507,12 +2532,14 @@ function formatRuntimeOptions() {
         `- retry: ${formatRetryLimit(config.telegramAutoProgressMaxTurns)} (TELEGRAM_AUTO_PROGRESS_MAX_TURNS)`,
         `- timeout: ${formatTimeoutSeconds(config.commandTimeoutMs)} (COMMAND_TIMEOUT_MS)`,
         `- intent: ${formatRetryLimit(config.telegramUntaggedIntentRetries)} (TELEGRAM_UNTAGGED_INTENT_RETRIES)`,
+        `- reasoning: ${getAstraReasoning()} (Astra, server-wide, CODEX_REASONING_EFFORT)`,
         `- command-menu: ${config.telegramCommandMenuEnabled ? "on" : "off"} (TELEGRAM_COMMAND_MENU_ENABLED)`,
         "",
         "Usage:",
         "/option retry <count>",
         "/option timeout <seconds>",
         "/option intent <count>",
+        "/option reasoning <low|medium|high|xhigh|max>",
         "/option command-menu <on|off|refresh>",
         "",
         "`retry 0` disables the automatic continuation limit.",
@@ -2521,6 +2548,9 @@ function formatRuntimeOptions() {
     ].join("\n");
 }
 function formatRuntimeOptionDetail(option) {
+    if (option === "reasoning") {
+        return `Current Astra reasoning effort: ${getAstraReasoning()}\n\nUsage: /option reasoning <low|medium|high|xhigh|max>\nApplies to the next Astra execution for all bots on this server. No restart required.`;
+    }
     if (option === "retry") {
         return `Current automatic continuation retry limit: ${formatRetryLimit(config.telegramAutoProgressMaxTurns)}\n\nUsage: \`/option retry <count>\``;
     }

package/dist/services/bridge-service.js

@@ -2,6 +2,7 @@ import fs from "node:fs/promises";
 import { randomBytes } from "node:crypto";
 import os from "node:os";
 import path from "node:path";
+import { getAstraReasoning } from "./codex-reasoning.js";
 import { stopSpawnedExecution } from "../adapters/windows-shell.js";
 import { CODEX_USAGE_FALLBACK_MODEL, CodexUsageFallbackService, parseCodexUsageLimit, } from "./codex-usage-fallback-service.js";
 const MODEL_PRESETS = {
@@ -194,12 +195,17 @@ export class BridgeService {
             ...presets.map((item, index) => ` ${index + 1}. ${item}`),
             "",
             "Use `/model <name>` or `/model <number>` to change it.",
+            "Use `/model restore` to clear temporary Codex fallback for all bots on this server. The next execution uses each session's configured model.",
         ];
         if (presets.length === 0) {
             lines.splice(3, 1, "availablePresets: none");
         }
         return lines.join("\n");
     }
+    async restoreCodexModel() {
+        await this.codexUsageFallback.clear();
+        return "이 서버의 Codex 임시 전환 상태를 해제했습니다. 다음 실행부터 각 세션에 설정된 원래 모델을 사용합니다.\n진행 중인 작업과 세션의 모델 설정은 유지됩니다. 실제 사용 한도가 남아 있으면 다시 임시 전환될 수 있습니다.";
+    }
     async getModelSelection(botId, chatId) {
         const chatSession = await this.requireChat(botId, chatId);
         const provider = chatSession.session.mode;
@@ -367,7 +373,7 @@ export class BridgeService {
         return responses.map((response) => {
             const sessionLabel = response.publicSessionId ?? response.sessionId;
             const modelLabel = response.model?.trim() || this.defaultModelFor(response.provider);
-            const effortLabel = response.provider === "codex" && modelLabel === "gpt-6-astra" ? " | medium" : "";
+            const effortLabel = response.provider === "codex" && modelLabel === "gpt-6-astra" ? ` | ${response.reasoningEffort ?? getAstraReasoning()}` : "";
             const header = `[${response.provider.toUpperCase()} | ${modelLabel}${effortLabel} | ${sessionLabel}]`;
             return `${header}\n${response.output}`;
         });
@@ -499,8 +505,10 @@ export class BridgeService {
                 ? await this.codexUsageFallback.selectExecutionModel(primaryModel)
                 : { model: primaryModel, recoveryProbe: false };
             let executionModel = selection.model;
+            const reasoningEffort = getAstraReasoning();
             const forwardProgress = async (output, model) => {
                 const progressResponse = {
+                    reasoningEffort: provider === "codex" && model === "gpt-6-astra" ? reasoningEffort : undefined,
                     provider,
                     sessionId: providerSession.sessionId ?? session.sessionId,
                     publicSessionId: session.publicId,
@@ -521,6 +529,7 @@ export class BridgeService {
                 await onProgress?.(progressResponse);
             };
             const sendWithModel = (model) => this.adapters[provider].send({
+                reasoningEffort: provider === "codex" && model === "gpt-6-astra" ? reasoningEffort : undefined,
                 botId,
                 chatId: chatId ?? requestSource,
                 remoteSessionId: session.sessionId,
@@ -611,6 +620,7 @@ export class BridgeService {
                 ...response,
                 publicSessionId: session.publicId,
                 model: executionModel,
+                reasoningEffort: provider === "codex" && executionModel === "gpt-6-astra" ? reasoningEffort : undefined,
             });
         }
         return responses;

package/dist/services/codex-reasoning.js

@@ -0,0 +1,8 @@
+export const ASTRA_REASONING_LEVELS = ["low", "medium", "high", "xhigh", "max"];
+export function isAstraReasoning(value) {
+    return ASTRA_REASONING_LEVELS.includes(value);
+}
+export function getAstraReasoning() {
+    const value = process.env.CODEX_REASONING_EFFORT ?? "medium";
+    return isAstraReasoning(value) ? value : "medium";
+}

package/package.json

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

package/scripts/selftest-codex-stream.mjs

@@ -35,6 +35,10 @@ 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"]) {
+  for (const reasoningEffort of ["low", "medium", "high", "xhigh", "max"]) {
+    const args = adapter[method]({model: "gpt-6-astra", reasoningEffort, cwd: tmp, sessionId: "stream-thread"}, path.join(tmp, "output"), "read-only");
+    if (!args.includes(`model_reasoning_effort="${reasoningEffort}"`)) throw new Error(`Missing ${reasoningEffort} in ${method}`);
+  }
   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}`);

package/scripts/selftest-model-fallback.mjs

@@ -63,6 +63,9 @@ try {
   );
 
   let bridge = createBridge();
+  process.env.CODEX_REASONING_EFFORT = "max";
+  assert.match(bridge.formatResponses([{provider: "codex", model: primaryModel, reasoningEffort: "high", publicSessionId: "S081", output: "done"}])[0], /\| high \| S081/);
+  process.env.CODEX_REASONING_EFFORT = "medium";
   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;
@@ -118,6 +121,14 @@ try {
   );
   assert.deepEqual(calls.map((call) => call.model), [primaryModel, CODEX_USAGE_FALLBACK_MODEL]);
 
+  await bridge.restoreCodexModel();
+  await assert.rejects(fs.stat(fallbackStatePath), { code: "ENOENT" });
+  failPrimaryWithUsageLimit = false;
+  calls.length = 0;
+  await bridge.routeMessage("test-bot", "test-chat", "after coupon reset");
+  assert.deepEqual(calls.map(call => call.model), [primaryModel]);
+  assert.equal((await store.getChatSession("test-bot", "test-chat"))?.session.sessionId, originalSessionId);
+
   console.log(JSON.stringify({
     ok: true,
     detectedExactUsageError: true,
@@ -127,6 +138,7 @@ try {
     fallbackSharedAcrossSessions: true,
     primaryRestoredAfterSuccessfulProbe: true,
     fallbackAttemptLimit: 1,
+    manualRestoreUsesPrimary: true,
   }, null, 2));
 } finally {
   await fs.rm(root, { recursive: true, force: true });

package/scripts/selftest-telegram-update.mjs

@@ -323,6 +323,13 @@ await send("/start codex");
 await send("/option retry 6");
 await send("/option timeout 600");
 await send("/option intent 4");
+await send("/option reasoning high");
+if (process.env.CODEX_REASONING_EFFORT !== "high" || !(await fs.readFile(path.join(dataDir, ".env"), "utf8")).includes("CODEX_REASONING_EFFORT=high")) {
+  throw new Error("Reasoning option was not applied and persisted");
+}
+await send("/option reasoning invalid");
+if (process.env.CODEX_REASONING_EFFORT !== "high") throw new Error("Invalid reasoning changed runtime setting");
+await send("/option reasoning medium");
 await send("/secret set REMOTEAGENT_TRANSFER_PASSPHRASE correct-horse-battery-staple");
 await send("/secret set API_TOKEN telegram-secret-export-value");
 await send("/secret export REMOTEAGENT_TRANSFER_PASSPHRASE API_TOKEN");
@@ -524,6 +531,20 @@ await waitForTelegramCall((call) => call.text.includes("Switched this chat to se
 
 await send("/model");
 const modelListCall = await waitForTelegramCall((call) => call.text.includes("availablePresets:"));
+const restoreButton = findInlineButton(modelListCall, "원래 모델 복귀");
+if (!restoreButton?.callback_data) throw new Error("Model restore button missing");
+const fallbackPath = path.join(dataDir, "codex-usage-fallback.json");
+const fallbackFixture = JSON.stringify({fallbackModel: "gpt-5.3-codex-spark", activatedAt: new Date().toISOString(), resetAt: "2099-01-01T00:00:00Z"});
+const beforeRestore = await fs.readFile(path.join(dataDir, "state.json"), "utf8");
+await fs.writeFile(fallbackPath, fallbackFixture);
+await click(restoreButton.callback_data);
+if (await pathExists(fallbackPath)) throw new Error("Restore button did not clear fallback");
+await fs.writeFile(fallbackPath, fallbackFixture);
+await send("/model restore");
+await send("/model restore");
+if (await pathExists(fallbackPath)) throw new Error("Restore command did not clear fallback");
+const afterRestore = await fs.readFile(path.join(dataDir, "state.json"), "utf8");
+if (JSON.stringify(JSON.parse(beforeRestore).sessions) !== JSON.stringify(JSON.parse(afterRestore).sessions)) throw new Error("Restore changed sessions");
 const modelButton = findInlineButton(modelListCall, "gpt-5.6-terra");
 if (!modelButton?.callback_data) {
   throw new Error(`Model selection button is missing: ${modelListCall.reply_markup}`);