appback-remoteagent 0.23.1 → 0.23.3

package/README.md

@@ -105,7 +105,8 @@ 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`. Use `/model gpt-6-astra` for an existing session. |
+| `/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;
@@ -67,6 +68,9 @@ export class CodexAdapter {
         if (request.model) {
             args.push("-m", request.model);
         }
+        if (request.model === "gpt-6-astra") {
+            args.push("-c", `model_reasoning_effort=${JSON.stringify(request.reasoningEffort ?? getAstraReasoning())}`);
+        }
         this.appendSandboxArgs(args, sandboxMode);
         args.push("-o", outputPath, "-C", request.cwd);
         this.appendPromptStdinArg(args);
@@ -82,6 +86,9 @@ export class CodexAdapter {
         if (request.model) {
             args.push("-m", request.model);
         }
+        if (request.model === "gpt-6-astra") {
+            args.push("-c", `model_reasoning_effort=${JSON.stringify(request.reasoningEffort ?? getAstraReasoning())}`);
+        }
         this.appendSandboxArgs(args, sandboxMode);
         args.push("-o", outputPath, request.sessionId);
         this.appendPromptStdinArg(args);

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:",
@@ -30,7 +32,7 @@ const HELP_TEXT = [
     "/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",
@@ -642,12 +644,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 +662,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)) {
@@ -2507,12 +2521,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 +2537,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,13 +2,14 @@ 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 = {
-    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 +368,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" ? ` | ${response.reasoningEffort ?? getAstraReasoning()}` : "";
+            const header = `[${response.provider.toUpperCase()} | ${modelLabel}${effortLabel} | ${sessionLabel}]`;
             return `${header}\n${response.output}`;
         });
     }
@@ -498,8 +500,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,
@@ -520,6 +524,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,
@@ -610,6 +615,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.1",
+  "version": "0.23.3",
   "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,16 @@ 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}`);
+  }
+}
 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,10 @@ 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;
   const first = await bridge.routeMessage("test-bot", "test-chat", "first request", async (response) => {

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");