@jiayunxie/aerial 0.1.9 → 0.1.10

package/README.md

@@ -73,18 +73,18 @@ You normally do not need to create, copy, or export an API key yourself.
 
 ## Choosing A Model
 
-The easiest path is to let setup show the compatible models:
+The easiest path is to let setup show the compatible models and ask for reasoning effort:
 
 ```bash
 aerial setup codex
 aerial setup claude
 ```
 
-To pin a model without the prompt:
+To skip the prompts:
 
 ```bash
-aerial setup codex --model <responses-model-id>
-aerial setup claude --model <messages-model-id>
+aerial setup codex --model <responses-model-id> --effort <low|medium|high|xhigh|max>
+aerial setup claude --model <messages-model-id> --effort <low|medium|high|xhigh|max>
 ```
 
 To inspect the full model matrix:

package/docs/usage.md

@@ -71,7 +71,7 @@ The local key is generated and stored by Aerial automatically. Users do not need
 
 For a dry inspection without touching your real config, set `HOME`/`USERPROFILE` to a temporary directory before running this command.
 
-To skip the prompt, pass `--model <responses-model-id>`.
+To skip the prompts, pass `--model <responses-model-id>` and/or `--effort <low|medium|high|xhigh|max>` (`max` is an alias for `xhigh`). The chosen effort is written into the `[profiles.aerial]` block as `model_reasoning_effort = "<effort>"` and is also persisted as Aerial-wide `defaultEffort` in `~/.aerial/config.json`. Under non-TTY (CI/pipes) the wizard does not prompt and falls back to the default effort `medium`.
 
 ## 6. Configure Claude Code
 
@@ -85,7 +85,15 @@ If Claude Code was previously pointed at another Anthropic-compatible gateway, s
 
 For a dry inspection without touching your real config, set `HOME`/`USERPROFILE` to a temporary directory before running this command.
 
-To skip the prompt, pass `--model <messages-model-id>`.
+To skip the prompts, pass `--model <messages-model-id>` and/or `--effort <low|medium|high|xhigh|max>`. Claude `settings.json` does not store an effort value; instead, `setup claude --effort <value>` updates Aerial-wide `defaultEffort` and the local proxy injects it into outgoing `/v1/messages` payloads. Precedence for the Anthropic effort applied to a Claude Opus 4.7 request, in order:
+
+1. An explicit `output_config.effort` in the request body is preserved verbatim.
+2. A legacy `thinking: { type: "enabled", budget_tokens }` is translated to `thinking: { type: "adaptive" }` with a derived `output_config.effort`.
+3. `thinking: { type: "adaptive" }` without an explicit effort is preserved as-is; Aerial does not inject a default.
+4. Otherwise Aerial injects Aerial `defaultEffort` from `~/.aerial/config.json` as `output_config.effort`.
+5. If no Aerial default is set, Aerial falls back to `medium`.
+
+Non-Opus-4.7 Claude requests are not modified.
 
 ## 7. Verify
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jiayunxie/aerial",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "Local-only GitHub Copilot proxy for Codex CLI and Claude Code.",
   "type": "module",
   "private": false,

package/src/cli.js

@@ -2,12 +2,14 @@
 import { fileURLToPath } from "node:url";
 import { startDeviceFlow, pollDeviceFlow, readGitHubToken, gitHubTokenSource } from "./auth.js";
 import { ensureApiKey, loadConfig, saveConfig } from "./config.js";
+import { configPath } from "./paths.js";
 import { startServer } from "./server.js";
 import { setupClaude, setupCodex, setupStatus, restoreClient, restoreAllClients } from "./setup.js";
 import { serviceInstall, serviceStart, serviceStop, serviceRestart, serviceUninstall, serviceStatus } from "./service.js";
 import { doctor, renderDoctorText } from "./doctor.js";
 import { runProbe, formatProbeReport } from "./probe.js";
 import { chooseSetupModel, formatModelChoices } from "./model-selection.js";
+import { chooseSetupEffort, formatEffortSelection, assertValidEffort } from "./setup-selection.js";
 import { printVersion } from "./version.js";
 import { computeAppStatus } from "./app-status.js";
 
@@ -36,8 +38,8 @@ function printHelp() {
 Usage:
   aerial --version
   aerial login
-  aerial setup codex [--model <id>]
-  aerial setup claude [--model <id>]
+  aerial setup codex [--model <id>] [--effort <low|medium|high|xhigh|max>]
+  aerial setup claude [--model <id>] [--effort <low|medium|high|xhigh|max>]
   aerial service install
   aerial status [--json]
 
@@ -58,8 +60,20 @@ function argValue(args, name) {
   return index >= 0 ? args[index + 1] : undefined;
 }
 
-async function selectSetupModel(target, route, args) {
-  const selected = await chooseSetupModel({ target, route, explicitModel: argValue(args, "--model") });
+function requiredArgValue(args, name) {
+  const index = args.indexOf(name);
+  if (index < 0) return undefined;
+  const value = args[index + 1];
+  if (value === undefined || value.startsWith("--")) {
+    throw new Error(`${name} requires a value.`);
+  }
+  return value;
+}
+
+async function selectSetupOptions(target, route, args) {
+  const explicitEffort = requiredArgValue(args, "--effort");
+  if (explicitEffort !== undefined) assertValidEffort(explicitEffort);
+  const selected = await chooseSetupModel({ target, route, explicitModel: requiredArgValue(args, "--model") });
   if (!selected.displayed) {
     for (const line of formatModelChoices({ target, route, choices: selected.choices, selectedModel: selected.model, source: selected.source, recommended: selected.recommended })) {
       console.log(line);
@@ -67,14 +81,38 @@ async function selectSetupModel(target, route, args) {
   } else {
     console.log(`Selected ${target} model: ${selected.model}`);
   }
-  return selected.model;
+  const effortChoice = await chooseSetupEffort({ target, explicitEffort });
+  console.log(formatEffortSelection({ target, effort: effortChoice.effort, source: effortChoice.source }));
+  return {
+    model: selected.model,
+    effort: effortChoice.effort,
+    modelSource: selected.source,
+    effortSource: effortChoice.source,
+    modelDisplayed: Boolean(selected.displayed),
+    effortDisplayed: Boolean(effortChoice.displayed)
+  };
+}
+
+function printSetupCompletionSummary({ heading, cli, model, effort, proxy, configFile, aerialConfigFile, aerialDefaultEffort, backup, auth, notes = [] }) {
+  console.log(heading);
+  console.log(`  cli: ${cli}`);
+  console.log(`  model: ${model}`);
+  console.log(`  effort: ${effort}`);
+  console.log(`  proxy: ${proxy}`);
+  console.log(`  client config: ${configFile}`);
+  console.log(`  aerial config: ${aerialConfigFile}`);
+  console.log(`  aerial defaultEffort: ${aerialDefaultEffort}`);
+  console.log(`  backup: ${backup || "none"}`);
+  console.log(`  auth: ${auth}`);
+  for (const note of notes) console.log(`  note: ${note}`);
 }
 
 function printSetupSummary(status) {
   console.log("clients:");
   for (const client of Object.values(status.clients)) {
     const model = client.model ? ` model=${client.model}` : "";
-    console.log(`  ${client.target}: ${client.state}${model}`);
+    const effort = ` effort=${client.effort || "missing"}`;
+    console.log(`  ${client.target}: ${client.state}${model}${effort}`);
   }
   console.log(`api key: ${status.auth.api_key.exists ? "present" : "missing"}`);
   const ghSource = status.auth.github_token.source;
@@ -186,21 +224,41 @@ async function main() {
 
   if (command === "setup") {
     if (subcommand === "codex") {
-      const model = await selectSetupModel("Codex", "responses", rest);
-      const result = setupCodex({ model, authCommand: codexAuthCommand() });
-      console.log(`Updated Codex config: ${result.file}`);
-      console.log(`Configured Codex model: ${result.model}`);
-      if (result.backup) console.log(`Backup: ${result.backup}`);
-      console.log("Configured Codex to read the local Aerial key automatically.");
+      const options = await selectSetupOptions("Codex", "responses", rest);
+      const result = setupCodex({ model: options.model, effort: options.effort, authCommand: codexAuthCommand() });
+      const config = loadConfig();
+      printSetupCompletionSummary({
+        heading: "Configured Codex",
+        cli: "Codex",
+        model: result.model,
+        effort: result.effort || "missing",
+        proxy: `http://${config.host}:${config.port}/v1`,
+        configFile: result.file,
+        aerialConfigFile: configPath(),
+        aerialDefaultEffort: config.defaultEffort || "missing",
+        backup: result.backup,
+        auth: "command-backed local Aerial key",
+        notes: ["restart Codex if it was already running so it reloads the profile."]
+      });
       return;
     }
     if (subcommand === "claude") {
-      const model = await selectSetupModel("Claude Code", "messages", rest);
-      const result = setupClaude({ model, apiKeyHelper: claudeApiKeyHelper() });
-      console.log(`Updated Claude settings: ${result.file}`);
-      if (result.model) console.log(`Configured Claude default model: ${result.model}`);
-      console.log("Configured Claude Code to read the local Aerial key automatically.");
-      if (result.backup) console.log(`Backup: ${result.backup}`);
+      const options = await selectSetupOptions("Claude Code", "messages", rest);
+      const result = setupClaude({ model: options.model, effort: options.effort, apiKeyHelper: claudeApiKeyHelper() });
+      const config = loadConfig();
+      printSetupCompletionSummary({
+        heading: "Configured Claude Code",
+        cli: "Claude Code",
+        model: result.model || "preserved",
+        effort: result.effort || config.defaultEffort || "missing",
+        proxy: `http://${config.host}:${config.port}`,
+        configFile: result.file,
+        aerialConfigFile: configPath(),
+        aerialDefaultEffort: config.defaultEffort || "missing",
+        backup: result.backup,
+        auth: "apiKeyHelper local Aerial key",
+        notes: ["effort is applied via Aerial defaultEffort and proxy fallback; Claude settings.json does not store an effort value."]
+      });
       return;
     }
     if (subcommand === "all") {
@@ -222,7 +280,8 @@ async function main() {
       console.log(`GitHub token:    ${ghSourceText}`);
       for (const cs of Object.values(status.clients)) {
         const head = `${cs.target.padEnd(7)} state=${cs.state}`;
-        console.log(`${head}  file=${cs.file}`);
+        const effortText = ` effort=${cs.effort || "missing"}`;
+        console.log(`${head}${effortText}  file=${cs.file}`);
         if (cs.backups.length) console.log(`         backups=${cs.backups.length}`);
         if (cs.error) console.log(`         error=${cs.error}`);
       }
@@ -469,9 +528,14 @@ async function main() {
     if (subcommand === "set") {
       const [key, value] = rest;
       if (!key || value === undefined) throw new Error("Usage: aerial config set <key> <value>");
-      if (!["host", "port", "defaultModel", "logLevel", "promptCacheRetention", "promptCacheKey"].includes(key)) throw new Error(`Unsupported config key: ${key}`);
+      if (!["host", "port", "defaultModel", "defaultEffort", "logLevel", "promptCacheRetention", "promptCacheKey"].includes(key)) throw new Error(`Unsupported config key: ${key}`);
       if (key === "promptCacheRetention" && !["in_memory", "24h", "off"].includes(value)) throw new Error("promptCacheRetention must be one of: in_memory, 24h, off");
       if (key === "promptCacheKey" && !value.trim()) throw new Error("promptCacheKey must be auto, off, or a non-empty string");
+      if (key === "defaultEffort") {
+        config.defaultEffort = assertValidEffort(value);
+        saveConfig(config);
+        return;
+      }
       config[key] = key === "port" ? Number(value) : value;
       saveConfig(config);
       return;

package/src/config.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import { CONFIG_VERSION, DEFAULT_HOST, DEFAULT_PORT, DEFAULT_VERSIONS } from "./constants.js";
 import { apiKeyPath, configPath, readJsonIfExists, writeJsonPrivate, writePrivateFile } from "./paths.js";
 import { hashApiKey, randomApiKey, verifyApiKey } from "./crypto.js";
+import { DEFAULT_EFFORT, normalizeEffort } from "./setup-selection.js";
 
 export function defaultConfig() {
   return {
@@ -10,6 +11,7 @@ export function defaultConfig() {
     port: DEFAULT_PORT,
     apiKeyHash: undefined,
     defaultModel: undefined,
+    defaultEffort: DEFAULT_EFFORT,
     logLevel: "info",
     promptCacheRetention: "in_memory",
     promptCacheKey: "auto",
@@ -24,7 +26,8 @@ export function loadConfig() {
   const defaults = defaultConfig();
   const promptCacheRetention = envRetention === undefined ? (loaded.promptCacheRetention ?? defaults.promptCacheRetention) : envRetention;
   const promptCacheKey = envCacheKey === undefined ? (loaded.promptCacheKey ?? defaults.promptCacheKey) : envCacheKey;
-  return { ...defaults, ...loaded, promptCacheRetention, promptCacheKey, versions: { ...DEFAULT_VERSIONS, ...(loaded.versions || {}) } };
+  const defaultEffort = normalizeEffort(loaded.defaultEffort) || DEFAULT_EFFORT;
+  return { ...defaults, ...loaded, defaultEffort, promptCacheRetention, promptCacheKey, versions: { ...DEFAULT_VERSIONS, ...(loaded.versions || {}) } };
 }
 
 export function saveConfig(config) {

package/src/copilot.js

@@ -251,8 +251,24 @@ async function fetchModelsCatalogForCopilot() {
   });
 }
 
+function withDefaultAnthropicEffort(payload) {
+  if (payload?.output_config?.effort !== undefined) return payload;
+  if (payload?.thinking?.type === "adaptive") return payload;
+  const model = typeof payload?.model === "string" ? payload.model : "";
+  if (!canonicalClaudeFamily(model)) return payload;
+  const config = loadConfig();
+  const effort = config.defaultEffort || "medium";
+  const outputConfig = payload?.output_config && typeof payload.output_config === "object" && !Array.isArray(payload.output_config)
+    ? payload.output_config
+    : {};
+  logEvent("anthropic_default_effort", { model, effort });
+  return { ...payload, output_config: { ...outputConfig, effort } };
+}
+
 async function withAnthropicDefaults(payload) {
-  const next = withSupportedAnthropicThinking(withDefaultAnthropicCache(payload));
+  const cached = withDefaultAnthropicCache(payload);
+  const thinkingApplied = withSupportedAnthropicThinking(cached);
+  const next = withDefaultAnthropicEffort(thinkingApplied);
   const models = shouldLoadAnthropicCatalog(next)
     ? await fetchModelsCatalogForCopilot().catch(() => undefined)
     : undefined;

package/src/setup-selection.js

@@ -0,0 +1,71 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+
+export const EFFORT_VALUES = Object.freeze(["low", "medium", "high", "xhigh"]);
+export const DEFAULT_EFFORT = "medium";
+
+export function normalizeEffort(value) {
+  if (value === undefined || value === null) return undefined;
+  const trimmed = String(value).trim().toLowerCase();
+  if (!trimmed) return undefined;
+  if (trimmed === "max") return "xhigh";
+  if (EFFORT_VALUES.includes(trimmed)) return trimmed;
+  return undefined;
+}
+
+export function assertValidEffort(raw) {
+  const normalized = normalizeEffort(raw);
+  if (!normalized) {
+    throw new Error(`Invalid --effort ${JSON.stringify(raw)}. Allowed: ${EFFORT_VALUES.join(", ")} (or alias 'max' for xhigh).`);
+  }
+  return normalized;
+}
+
+function parseChoice(value, max, defaultIndex) {
+  const trimmed = String(value || "").trim();
+  if (!trimmed) return defaultIndex;
+  if (!/^\d+$/.test(trimmed)) return undefined;
+  const n = Number(trimmed);
+  return n >= 1 && n <= max ? n - 1 : undefined;
+}
+
+export async function chooseSetupEffort({
+  target,
+  explicitEffort,
+  prompt,
+  input: inputStream = input,
+  output: outputStream = output
+} = {}) {
+  if (explicitEffort !== undefined) {
+    return { effort: assertValidEffort(explicitEffort), source: "explicit", displayed: false };
+  }
+  const shouldPrompt = prompt === undefined ? Boolean(inputStream.isTTY) : prompt;
+  if (!shouldPrompt) {
+    return { effort: DEFAULT_EFFORT, source: "default_non_tty", displayed: false };
+  }
+  const defaultIndex = EFFORT_VALUES.indexOf(DEFAULT_EFFORT);
+  const rl = createInterface({ input: inputStream, output: outputStream });
+  try {
+    outputStream.write(`Choose ${target} reasoning effort:\n`);
+    for (const [index, value] of EFFORT_VALUES.entries()) {
+      const marker = index === defaultIndex ? "  (default)" : "";
+      outputStream.write(`  ${index + 1}. ${value}${marker}\n`);
+    }
+    while (true) {
+      const answer = await rl.question(`Choose effort [1-${EFFORT_VALUES.length}, default ${defaultIndex + 1} = ${DEFAULT_EFFORT}]: `);
+      const selectedIndex = parseChoice(answer, EFFORT_VALUES.length, defaultIndex);
+      if (selectedIndex !== undefined) {
+        return { effort: EFFORT_VALUES[selectedIndex], source: "prompt", displayed: true };
+      }
+      outputStream.write(`Enter a number from 1 to ${EFFORT_VALUES.length}, or press Enter for ${defaultIndex + 1}.\n`);
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+export function formatEffortSelection({ target, effort, source }) {
+  if (source === "explicit") return `Selected ${target} effort: ${effort}`;
+  if (source === "prompt") return `Selected ${target} effort: ${effort}`;
+  return `No interactive terminal detected; selected ${target} effort: ${effort}. Pass --effort <low|medium|high|xhigh|max> to choose a different effort.`;
+}

package/src/setup.js

@@ -2,10 +2,11 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { parse as parseToml } from "smol-toml";
-import { ensureApiKey, loadConfig } from "./config.js";
+import { ensureApiKey, loadConfig, saveConfig } from "./config.js";
 import { apiKeyPath, githubTokenPath } from "./paths.js";
 import { gitHubTokenSource } from "./auth.js";
 import { logEvent } from "./log.js";
+import { assertValidEffort, normalizeEffort } from "./setup-selection.js";
 
 const BACKUP_PREFIX = ".aerial-backup-";
 const PRE_RESTORE_PREFIX = ".aerial-pre-restore-";
@@ -75,7 +76,8 @@ function claudeEnvForAerial(currentEnv, config) {
   };
 }
 
-export function setupCodex({ model, authCommand = DEFAULT_CODEX_AUTH } = {}) {
+export function setupCodex({ model, effort, authCommand = DEFAULT_CODEX_AUTH } = {}) {
+  const normalizedEffort = effort === undefined ? undefined : assertValidEffort(effort);
   ensureApiKey();
   const config = loadConfig();
   const selectedModel = model || config.defaultModel;
@@ -99,13 +101,19 @@ export function setupCodex({ model, authCommand = DEFAULT_CODEX_AUTH } = {}) {
     timeout_ms: authCommand.timeout_ms || DEFAULT_CODEX_AUTH.timeout_ms,
     refresh_interval_ms: authCommand.refresh_interval_ms ?? DEFAULT_CODEX_AUTH.refresh_interval_ms
   });
-  content = upsertTomlSection(content, "profiles.aerial", { model_provider: "aerial", model: selectedModel });
+  const profileValues = { model_provider: "aerial", model: selectedModel };
+  if (normalizedEffort) profileValues.model_reasoning_effort = normalizedEffort;
+  content = upsertTomlSection(content, "profiles.aerial", profileValues);
   fs.writeFileSync(file, content, "utf8");
-  logEvent("setup_write", { target: "codex", file, backup, auth: "command" });
-  return { file, backup, model: selectedModel, auth: { type: "command", command: authCommand.command, args: authCommand.args || [] } };
+  if (normalizedEffort && config.defaultEffort !== normalizedEffort) {
+    saveConfig({ ...config, defaultEffort: normalizedEffort });
+  }
+  logEvent("setup_write", { target: "codex", file, backup, auth: "command", effort: normalizedEffort });
+  return { file, backup, model: selectedModel, effort: normalizedEffort, auth: { type: "command", command: authCommand.command, args: authCommand.args || [] } };
 }
 
-export function setupClaude({ model, apiKeyHelper = DEFAULT_CLAUDE_API_KEY_HELPER } = {}) {
+export function setupClaude({ model, effort, apiKeyHelper = DEFAULT_CLAUDE_API_KEY_HELPER } = {}) {
+  const normalizedEffort = effort === undefined ? undefined : assertValidEffort(effort);
   ensureApiKey();
   const config = loadConfig();
   const selectedModel = model || config.defaultModel;
@@ -121,8 +129,11 @@ export function setupClaude({ model, apiKeyHelper = DEFAULT_CLAUDE_API_KEY_HELPE
   };
   if (selectedModel) next.model = selectedModel;
   fs.writeFileSync(file, `${JSON.stringify(next, null, 2)}\n`, "utf8");
-  logEvent("setup_write", { target: "claude", file, backup, model: selectedModel });
-  return { file, backup, model: selectedModel, apiKeyHelper };
+  if (normalizedEffort && config.defaultEffort !== normalizedEffort) {
+    saveConfig({ ...config, defaultEffort: normalizedEffort });
+  }
+  logEvent("setup_write", { target: "claude", file, backup, model: selectedModel, effort: normalizedEffort });
+  return { file, backup, model: selectedModel, effort: normalizedEffort, apiKeyHelper };
 }
 
 function codexConfigFile() {
@@ -182,25 +193,27 @@ export function codexStatus() {
   const expectedBaseUrl = `http://${config.host}:${config.port}/v1`;
   const file = codexConfigFile();
   const backups = backupPathsFor(file);
-  if (!fs.existsSync(file)) return { target: "codex", state: "missing", file, backups };
+  if (!fs.existsSync(file)) return { target: "codex", state: "missing", file, backups, effort: "missing" };
   let content;
   try {
     content = fs.readFileSync(file, "utf8");
   } catch (err) {
-    return { target: "codex", state: "invalid", file, backups, error: err.message };
+    return { target: "codex", state: "invalid", file, backups, error: err.message, effort: "missing" };
   }
   let doc;
   try {
     doc = parseToml(content);
   } catch (err) {
-    return { target: "codex", state: "invalid", file, backups, error: err.message };
+    return { target: "codex", state: "invalid", file, backups, error: err.message, effort: "missing" };
   }
   const state = codexStateFromDoc(doc, expectedBaseUrl);
   const model = typeof doc?.model === "string" ? doc.model : undefined;
   const baseUrl = typeof doc?.model_providers?.aerial?.base_url === "string"
     ? doc.model_providers.aerial.base_url
     : undefined;
-  return { target: "codex", state, file, backups, model, baseUrl };
+  const profileEffort = doc?.profiles?.aerial?.model_reasoning_effort;
+  const effort = typeof profileEffort === "string" ? (normalizeEffort(profileEffort) || "missing") : "missing";
+  return { target: "codex", state, file, backups, model, baseUrl, effort };
 }
 
 function claudeStateFromDoc(doc, expectedBaseUrl) {
@@ -220,17 +233,18 @@ export function claudeStatus() {
   const expectedBaseUrl = `http://${config.host}:${config.port}`;
   const file = claudeSettingsFile();
   const backups = backupPathsFor(file);
-  if (!fs.existsSync(file)) return { target: "claude", state: "missing", file, backups };
+  const effort = typeof config.defaultEffort === "string" && config.defaultEffort.trim() ? config.defaultEffort.trim() : "missing";
+  if (!fs.existsSync(file)) return { target: "claude", state: "missing", file, backups, effort };
   let doc;
   try {
     doc = JSON.parse(fs.readFileSync(file, "utf8"));
   } catch (err) {
-    return { target: "claude", state: "invalid", file, backups, error: err.message };
+    return { target: "claude", state: "invalid", file, backups, error: err.message, effort };
   }
   const state = claudeStateFromDoc(doc, expectedBaseUrl);
   const model = typeof doc?.model === "string" ? doc.model : undefined;
   const baseUrl = doc?.env?.ANTHROPIC_BASE_URL;
-  return { target: "claude", state, file, backups, model, baseUrl };
+  return { target: "claude", state, file, backups, model, baseUrl, effort };
 }
 
 export function setupStatus() {