@jacobbd/relay-ai 0.3.1 → 0.3.2

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [0.3.2] - 2026-06-22
+
+### Fixed
+
+- **Codex App: rate limit errors now appear in the conversation instead of crashing silently** — when a model hits its usage limit (e.g. OpenCode Go's 5-hour cap), the proxy now injects a readable error message directly into the Codex App conversation: `"5-hour usage limit reached. Resets in Xmin. To continue using this model now, enable usage from your available balance: ..."`. Previously the session just stalled with no explanation in the UI.
+
+- **Codex App: rate limit errors print a clean one-liner in the terminal** — instead of flooding the terminal with full RetryError stack traces (one per retry attempt, per request), the proxy now prints a single `[relay-ai] <model>: <message>` line per failed request.
+
+- **Codex proxy: removed SDK default `console.error` on stream failures** — the Vercel AI SDK's `streamText` calls `console.error(error)` by default whenever the stream encounters an error. This was the root cause of the full stack trace dumps. The proxy now passes `onError: () => {}` to suppress this. The error is still handled through the stream pipeline and surfaced to the user.
+
+- **Codex App: context overflow no longer crashes long sessions** — relay-ai now writes `model_context_window` and `model_auto_compact_token_limit` (70% of the model's actual limit) into `~/.codex/config.toml` at session start. Codex uses these values to trigger auto-compaction before the conversation reaches the model's hard limit, preventing the compaction-fails-at-limit crash that previously broke sessions and made them unrecoverable. Applies to single-provider, favorites, and Vertex AI sessions alike.
+
+- **Codex App: proxy-level message truncation as a safety net** — if a conversation history arrives that already exceeds 85% of the selected model's context window (e.g. a long native GPT-5.5 session loaded into a 1 M-token model), relay-ai silently drops the oldest messages before forwarding to the upstream model. The session continues in a degraded but functional state instead of crashing with an unrecoverable error.
+
+- **Codex App: Ctrl+C now shows a confirmation menu instead of immediately closing** — pressing Ctrl+C now presents an arrow-key selection menu: *"Close Codex Desktop and restore your Codex config?"* (Yes / No). Pressing Ctrl+C a second time during the prompt, or pressing Enter on Yes, closes the app and restores config. Choosing No keeps the session running. SIGTERM and SIGHUP still close immediately without a prompt.
+
+- **Codex App: `--trace` request observability** — `--trace` mode now logs `previous_response_id`, `input_items`, and `body_bytes` for every incoming proxy request, making it possible to verify Codex's conversation-history protocol against a specific provider setup.
+
 ## [0.3.1] - 2026-06-22
 
 ### Fixed

package/dist/cli.js

@@ -35,7 +35,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@jacobbd/relay-ai",
-  version: "0.3.1",
+  version: "0.3.2",
   publishConfig: {
     access: "public"
   },
@@ -832,11 +832,16 @@ function parseCodexAppModelSlug(modelKey) {
 }
 function buildCodexAppRootConfig(spec) {
   const slug = codexAppModelSlug(spec.route.modelId);
+  const ctxWindow = spec.route.contextWindow;
   return {
     model: slug,
     model_provider: "openai",
     openai_base_url: `http://127.0.0.1:${spec.proxyPort}/v1`,
-    model_catalog_json: spec.catalogPath
+    model_catalog_json: spec.catalogPath,
+    ...ctxWindow && ctxWindow > 0 ? {
+      model_context_window: ctxWindow,
+      model_auto_compact_token_limit: Math.floor(ctxWindow * 0.7)
+    } : {}
   };
 }
 
@@ -5594,7 +5599,8 @@ async function writeAnthropicStream(fullStream, modelId, write, log19) {
   emit("message_stop", { type: "message_stop" });
 }
 async function streamAnthropicResponse(model, params, modelId, write, log19) {
-  const result = streamText({ model, ...params });
+  const result = streamText({ model, ...params, onError: () => {
+  } });
   Promise.resolve(result.text).catch(() => {
   });
   Promise.resolve(result.toolCalls).catch(() => {
@@ -9110,11 +9116,11 @@ async function runProvidersRemove(id, interactive = false) {
     return 1;
   }
   if (interactive) {
-    const confirm10 = await p10.confirm({
+    const confirm9 = await p10.confirm({
       message: `Remove ${provider.name} (${id})?`,
       initialValue: false
     });
-    if (p10.isCancel(confirm10) || !confirm10) {
+    if (p10.isCancel(confirm9) || !confirm9) {
       p10.cancel("Cancelled.");
       return 0;
     }
@@ -9308,6 +9314,53 @@ import { createServer as createServer3 } from "http";
 
 // src/codex-responses-adapter.ts
 import { streamText as streamText3, generateText as generateText3, tool as tool3, jsonSchema as jsonSchema3 } from "ai";
+
+// src/codex/upstream-error.ts
+function formatUpstreamError(err) {
+  if (!err || typeof err !== "object") return "Upstream model request failed.";
+  const rec = err;
+  if (rec.data?.error?.message) {
+    const short = sanitizeMessage(rec.data.error.message);
+    return rec.statusCode ? `${short} (HTTP ${rec.statusCode})` : short;
+  }
+  if (rec.responseBody) {
+    try {
+      const parsed = JSON.parse(rec.responseBody);
+      if (parsed.error?.message) {
+        const short = sanitizeMessage(parsed.error.message);
+        return rec.statusCode ? `${short} (HTTP ${rec.statusCode})` : short;
+      }
+    } catch {
+    }
+  }
+  const last = rec.lastError;
+  if (last?.message) {
+    const code = last.statusCode;
+    const short = sanitizeMessage(last.message);
+    return code ? `${short} (HTTP ${code})` : short;
+  }
+  const fromList = rec.errors?.[rec.errors.length - 1];
+  if (fromList?.message) {
+    const short = sanitizeMessage(fromList.message);
+    return fromList.statusCode ? `${short} (HTTP ${fromList.statusCode})` : short;
+  }
+  if (rec.message) {
+    const short = sanitizeMessage(rec.message);
+    if (short && !short.includes("file://") && !short.includes("APICallError") && short.length < 240) {
+      return rec.statusCode ? `${short} (HTTP ${rec.statusCode})` : short;
+    }
+  }
+  return "Upstream model request failed.";
+}
+function sanitizeMessage(message) {
+  const line = message.split("\n")[0]?.trim() ?? message;
+  if (line.startsWith("RetryError") || line.includes("AI_RetryError")) {
+    return "Upstream model request failed after retries.";
+  }
+  return line;
+}
+
+// src/codex-responses-adapter.ts
 function messageText(content) {
   if (typeof content === "string") return content;
   return (content ?? []).map((p21) => p21.type === "output_text" || p21.type === "input_text" || p21.type === "text" ? p21.text ?? "" : "").join("");
@@ -9620,20 +9673,29 @@ async function writeResponsesStream(fullStream, modelId, write) {
       case "finish":
         if (part.totalUsage) usage = usageFromPart(part);
         break;
-      case "error":
-        emit("response.completed", {
-          type: "response.completed",
-          response: {
-            id: responseId,
-            object: "response",
-            model: modelId,
-            created_at: createdAt,
-            status: "failed",
-            output: [],
-            error: { message: String(part.error ?? "Upstream error"), type: "api_error" }
-          }
-        });
+      case "error": {
+        const msg = formatUpstreamError(part.error);
+        const is429 = msg.includes("429") || part.error && typeof part.error === "object" && (part.error.statusCode === 429 || part.error.lastError?.statusCode === 429);
+        process.stderr.write(`[relay-ai] ${modelId}: ${msg}
+`);
+        if (is429) {
+          writeResponsesRateLimitStream(modelId, msg, write);
+        } else {
+          emit("response.completed", {
+            type: "response.completed",
+            response: {
+              id: responseId,
+              object: "response",
+              model: modelId,
+              created_at: createdAt,
+              status: "failed",
+              output: [],
+              error: { message: msg, type: "api_error" }
+            }
+          });
+        }
         return;
+      }
       default:
         break;
     }
@@ -9712,7 +9774,8 @@ async function writeResponsesStream(fullStream, modelId, write) {
   });
 }
 async function streamResponsesResponse(model, params, modelId, write) {
-  const result = streamText3({ model, ...params });
+  const result = streamText3({ model, ...params, onError: () => {
+  } });
   Promise.resolve(result.text).catch(() => {
   });
   Promise.resolve(result.toolCalls).catch(() => {
@@ -9723,6 +9786,8 @@ async function streamResponsesResponse(model, params, modelId, write) {
   });
   Promise.resolve(result.usage).catch(() => {
   });
+  Promise.resolve(result.response).catch(() => {
+  });
   await writeResponsesStream(result.fullStream, modelId, write);
 }
 async function generateResponsesResponse(model, params, modelId) {
@@ -9786,53 +9851,102 @@ function writeResponsesErrorStream(modelId, message, write, statusCode = 401) {
     response: responsesErrorBody(modelId, message, statusCode)
   }));
 }
+function writeResponsesRateLimitStream(modelId, message, write) {
+  const responseId = newResponseId();
+  const itemId = newItemId("msg");
+  const createdAt = Math.floor(Date.now() / 1e3);
+  const content = [{ type: "output_text", text: message }];
+  write(sseChunk("response.output_item.added", {
+    type: "response.output_item.added",
+    output_index: 0,
+    item: { id: itemId, type: "message", role: "assistant", status: "in_progress", content: [] }
+  }));
+  write(sseChunk("response.content_part.added", {
+    type: "response.content_part.added",
+    item_id: itemId,
+    output_index: 0,
+    content_index: 0,
+    part: { type: "output_text", text: "" }
+  }));
+  write(sseChunk("response.output_text.delta", {
+    type: "response.output_text.delta",
+    item_id: itemId,
+    output_index: 0,
+    content_index: 0,
+    delta: message
+  }));
+  write(sseChunk("response.output_text.done", {
+    type: "response.output_text.done",
+    item_id: itemId,
+    output_index: 0,
+    content_index: 0,
+    text: message
+  }));
+  write(sseChunk("response.content_part.done", {
+    type: "response.content_part.done",
+    item_id: itemId,
+    output_index: 0,
+    content_index: 0,
+    part: { type: "output_text", text: message }
+  }));
+  write(sseChunk("response.output_item.done", {
+    type: "response.output_item.done",
+    output_index: 0,
+    item: { id: itemId, type: "message", role: "assistant", status: "completed", content }
+  }));
+  write(sseChunk("response.completed", {
+    type: "response.completed",
+    response: {
+      id: responseId,
+      object: "response",
+      model: modelId,
+      created_at: createdAt,
+      status: "completed",
+      output: [{ id: itemId, type: "message", role: "assistant", status: "completed", content }]
+    }
+  }));
+}
+function responsesRateLimitBody(modelId, message) {
+  const itemId = newItemId("msg");
+  const content = [{ type: "output_text", text: message }];
+  return {
+    id: newResponseId(),
+    object: "response",
+    model: modelId,
+    created_at: Math.floor(Date.now() / 1e3),
+    status: "completed",
+    output: [{ id: itemId, type: "message", role: "assistant", status: "completed", content }]
+  };
+}
 
-// src/codex/upstream-error.ts
-function formatUpstreamError(err) {
-  if (!err || typeof err !== "object") return "Upstream model request failed.";
-  const rec = err;
-  if (rec.data?.error?.message) {
-    const short = sanitizeMessage(rec.data.error.message);
-    return rec.statusCode ? `${short} (HTTP ${rec.statusCode})` : short;
-  }
-  if (rec.responseBody) {
-    try {
-      const parsed = JSON.parse(rec.responseBody);
-      if (parsed.error?.message) {
-        const short = sanitizeMessage(parsed.error.message);
-        return rec.statusCode ? `${short} (HTTP ${rec.statusCode})` : short;
+// src/codex-proxy.ts
+function estimateMessageChars(params) {
+  let chars = (params.system ?? "").length;
+  for (const msg of params.messages) {
+    if (Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        if (part && typeof part === "object" && "text" in part && typeof part.text === "string") {
+          chars += part.text.length;
+        }
       }
-    } catch {
+    } else if (typeof msg.content === "string") {
+      chars += msg.content.length;
     }
   }
-  const last = rec.lastError;
-  if (last?.message) {
-    const code = last.statusCode;
-    const short = sanitizeMessage(last.message);
-    return code ? `${short} (HTTP ${code})` : short;
-  }
-  const fromList = rec.errors?.[rec.errors.length - 1];
-  if (fromList?.message) {
-    const short = sanitizeMessage(fromList.message);
-    return fromList.statusCode ? `${short} (HTTP ${fromList.statusCode})` : short;
-  }
-  if (rec.message) {
-    const short = sanitizeMessage(rec.message);
-    if (short && !short.includes("file://") && !short.includes("APICallError") && short.length < 240) {
-      return rec.statusCode ? `${short} (HTTP ${rec.statusCode})` : short;
-    }
-  }
-  return "Upstream model request failed.";
+  return chars;
 }
-function sanitizeMessage(message) {
-  const line = message.split("\n")[0]?.trim() ?? message;
-  if (line.startsWith("RetryError") || line.includes("AI_RetryError")) {
-    return "Upstream model request failed after retries.";
+function trimToContextLimit(params, contextWindow) {
+  const charLimit = Math.floor(contextWindow * 0.85) * 4;
+  if (estimateMessageChars(params) <= charLimit) return params;
+  let messages = [...params.messages];
+  while (messages.length > 1 && estimateMessageChars({ ...params, messages }) > charLimit) {
+    messages = messages.slice(1);
+    while (messages.length > 0 && messages[0].role !== "user") {
+      messages = messages.slice(1);
+    }
   }
-  return line;
+  return { ...params, messages };
 }
-
-// src/codex-proxy.ts
 var PROXY_PLACEHOLDER_KEY = "proxy-local";
 function codexRouteLookupIds(requestedModel) {
   const ids = routeLookupIds(requestedModel);
@@ -9871,11 +9985,6 @@ function upstreamHttpStatus(err, msg) {
   if (msg.includes("HTTP 400")) return 400;
   return 500;
 }
-function logUpstreamError(err, modelId) {
-  const msg = formatUpstreamError(err);
-  const prefix = modelId ? `[relay-ai codex-proxy] ${modelId}: ` : "[relay-ai codex-proxy] ";
-  console.error(`${prefix}${msg}`);
-}
 function resolveModel(routes, models, requestedModel) {
   const route = findCodexProxyRoute(routes, requestedModel);
   if (!route) return void 0;
@@ -9905,8 +10014,7 @@ async function startCodexProxy(routes, options = {}) {
     const log19 = debug ? makeTraceLogger(getCodexProxyDebugLogPath()) : () => {
     };
     const onRejection = (reason) => {
-      logUpstreamError(reason);
-      if (debug) log19(formatUpstreamError(reason));
+      if (debug) log19(`unhandled-rejection: ${formatUpstreamError(reason)}`);
     };
     process.on("unhandledRejection", onRejection);
     const server = createServer3(async (req, res) => {
@@ -10006,6 +10114,11 @@ async function startCodexProxy(routes, options = {}) {
           sendJson(res, 400, { error: { message: "Invalid JSON body", type: "invalid_request_error" } });
           return;
         }
+        if (debug) {
+          const prevId = body.previous_response_id ?? null;
+          const inputItems = Array.isArray(body.input) ? body.input.length : typeof body.input === "string" ? 1 : 0;
+          log19(`request: model=${String(body.model ?? "")} previous_response_id=${prevId ?? "(none)"} input_items=${inputItems} body_bytes=${rawBody.length}`);
+        }
         const modelId = String(body.model ?? "");
         let resolved = resolveModel(routes, models, modelId);
         if (!resolved) {
@@ -10026,7 +10139,7 @@ async function startCodexProxy(routes, options = {}) {
         }
         const { route, languageModel } = resolved;
         try {
-          const params = translateResponsesRequest(
+          let params = translateResponsesRequest(
             body,
             route.npm,
             {
@@ -10037,6 +10150,13 @@ async function startCodexProxy(routes, options = {}) {
               interleavedReasoningField: route.interleavedReasoningField
             }
           );
+          if (route.contextWindow && route.contextWindow > 0) {
+            const before = params.messages.length;
+            params = trimToContextLimit(params, route.contextWindow);
+            if (debug && params.messages.length < before) {
+              log19(`context trim: model=${route.modelId} window=${route.contextWindow} kept=${params.messages.length}/${before} messages`);
+            }
+          }
           if (debug) {
             const effort = body.reasoning?.effort;
             log19(`model=${route.modelId} effort=${effort ?? "(none)"} providerOptions=${JSON.stringify(params.providerOptions)}`);
@@ -10052,8 +10172,13 @@ async function startCodexProxy(routes, options = {}) {
               await streamResponsesResponse(languageModel, params, modelId, write);
             } catch (err) {
               const msg = formatUpstreamError(err);
-              logUpstreamError(err, route.modelId);
-              writeResponsesErrorStream(modelId, msg, write, upstreamHttpStatus(err, msg));
+              const status = upstreamHttpStatus(err, msg);
+              if (debug) log19(`sdk error: ${route.modelId}: ${msg}`);
+              if (status === 429) {
+                writeResponsesRateLimitStream(modelId, msg, write);
+              } else {
+                writeResponsesErrorStream(modelId, msg, write, status);
+              }
             }
             res.end();
           } else {
@@ -10062,9 +10187,13 @@ async function startCodexProxy(routes, options = {}) {
               sendJson(res, 200, response);
             } catch (err) {
               const msg = formatUpstreamError(err);
-              logUpstreamError(err, route.modelId);
               const status = upstreamHttpStatus(err, msg);
-              sendJson(res, status, { error: { message: msg, type: status === 429 ? "rate_limit_error" : "api_error" } });
+              if (debug) log19(`sdk error: ${route.modelId}: ${msg}`);
+              if (status === 429) {
+                sendJson(res, 200, responsesRateLimitBody(modelId, msg));
+              } else {
+                sendJson(res, status, { error: { message: msg, type: "api_error" } });
+              }
             }
           }
         } catch (err) {
@@ -10169,7 +10298,8 @@ function buildCodexProxyRoutesForProvider(provider, apiKey, selectedModelId, age
       oauthAccountId: route.oauthAccountId,
       supportedParameters: route.supportedParameters,
       reasoning: route.reasoning,
-      interleavedReasoningField: route.interleavedReasoningField
+      interleavedReasoningField: route.interleavedReasoningField,
+      contextWindow: route.contextWindow
     };
   });
 }
@@ -10681,7 +10811,8 @@ function buildCodexProxyRoutesFromResolved(resolved, providersById) {
       upstreamModelId: route.upstreamModelId,
       providerId: route.providerId,
       authType: route.authType,
-      oauthAccountId: route.oauthAccountId
+      oauthAccountId: route.oauthAccountId,
+      contextWindow: route.contextWindow
     };
   }).filter((r) => r !== void 0);
   if (skippedOAuth.length > 0) {
@@ -12430,6 +12561,18 @@ function rootString(config, key) {
   const v = config[key];
   return { had: true, value: typeof v === "string" ? v : String(v ?? "") };
 }
+function rootNumber(config, key) {
+  if (!(key in config)) return { had: false };
+  const v = config[key];
+  return { had: true, value: typeof v === "number" ? v : void 0 };
+}
+function applyRestoreNumber(config, key, had, value) {
+  if (had && value !== void 0) {
+    config[key] = value;
+  } else {
+    delete config[key];
+  }
+}
 function readCodexConfigText(path = getCodexConfigPath()) {
   if (!existsSync14(path)) return "";
   return readFileSync11(path, "utf8");
@@ -12446,6 +12589,8 @@ function captureRestoreState(text5) {
   const modelCatalog = rootString(config, "model_catalog_json");
   const openAIBaseUrl = rootString(config, "openai_base_url");
   const reasoning = rootString(config, "model_reasoning_effort");
+  const contextWindow = rootNumber(config, "model_context_window");
+  const autoCompact = rootNumber(config, "model_auto_compact_token_limit");
   return {
     hadProfile: profile.had,
     profile: profile.value,
@@ -12458,7 +12603,11 @@ function captureRestoreState(text5) {
     hadOpenAIBaseUrl: openAIBaseUrl.had,
     openAIBaseUrl: openAIBaseUrl.value,
     hadModelReasoningEffort: reasoning.had,
-    modelReasoningEffort: reasoning.value
+    modelReasoningEffort: reasoning.value,
+    hadModelContextWindow: contextWindow.had,
+    modelContextWindow: contextWindow.value,
+    hadModelAutoCompactTokenLimit: autoCompact.had,
+    modelAutoCompactTokenLimit: autoCompact.value
   };
 }
 function isAppManagedConfig(text5) {
@@ -12477,6 +12626,16 @@ function mergeAppConfig(existing, spec) {
   out.model_provider = patch.model_provider;
   out.openai_base_url = patch.openai_base_url;
   out.model_catalog_json = patch.model_catalog_json;
+  if (patch.model_context_window !== void 0) {
+    out.model_context_window = patch.model_context_window;
+  } else {
+    delete out.model_context_window;
+  }
+  if (patch.model_auto_compact_token_limit !== void 0) {
+    out.model_auto_compact_token_limit = patch.model_auto_compact_token_limit;
+  } else {
+    delete out.model_auto_compact_token_limit;
+  }
   const providers = asRecord(out.model_providers);
   delete providers[CODEX_APP_PROVIDER_ID];
   const profiles = asRecord(out.profiles);
@@ -12577,6 +12736,8 @@ function restoreConfigFromState(state, configPath = getCodexConfigPath()) {
     applyRestoreKey(config, "openai_base_url", Boolean(state.hadOpenAIBaseUrl), state.openAIBaseUrl);
   }
   applyRestoreKey(config, "model_reasoning_effort", state.hadModelReasoningEffort, state.modelReasoningEffort);
+  applyRestoreNumber(config, "model_context_window", state.hadModelContextWindow ?? false, state.modelContextWindow);
+  applyRestoreNumber(config, "model_auto_compact_token_limit", state.hadModelAutoCompactTokenLimit ?? false, state.modelAutoCompactTokenLimit);
   const sidecar = getCodexAppSidecarProfilePath();
   if (existsSync14(sidecar)) {
     try {
@@ -12744,6 +12905,7 @@ function waitForShutdown2() {
     const cleanup = () => {
       process.removeListener("SIGINT", onSigint);
       process.removeListener("SIGTERM", onSigterm);
+      process.removeListener("SIGHUP", onSighup);
     };
     const onSigint = () => {
       cleanup();
@@ -12753,8 +12915,13 @@ function waitForShutdown2() {
       cleanup();
       resolve("sigterm");
     };
+    const onSighup = () => {
+      cleanup();
+      resolve("sighup");
+    };
     process.once("SIGINT", onSigint);
     process.once("SIGTERM", onSigterm);
+    process.once("SIGHUP", onSighup);
   });
 }
 
@@ -12968,6 +13135,21 @@ function codexAppInstallHint() {
 }
 
 // src/codex-app.ts
+async function waitForShutdownWithConfirm() {
+  while (true) {
+    const signal = await waitForShutdown2();
+    if (signal !== "sigint") break;
+    console.log("");
+    const choice = await p17.select({
+      message: "Close Codex Desktop and restore your Codex config?",
+      options: [
+        { value: "yes", label: "Yes, close Codex and restore config" },
+        { value: "no", label: "No, keep session running" }
+      ]
+    });
+    if (p17.isCancel(choice) || choice === "yes") break;
+  }
+}
 function codexAppHelpText() {
   return `${pc15.bold("relay-ai codex-app")} \u2014 launch Codex desktop app with your registry providers
 
@@ -13068,7 +13250,8 @@ async function runCodexAppVertexLaunch(configOnly, trace = false) {
     upstreamModelId: selectedEntry.upstream_id ?? selectedEntry.id,
     npm: VERTEX_ANTHROPIC_NPM,
     apiKey: "",
-    providerId: "vertex"
+    providerId: "vertex",
+    contextWindow: resolveContextWindow(selectedEntry.id)
   };
   if (configOnly) {
     const home = process.env["HOME"] ?? "";
@@ -13141,18 +13324,16 @@ async function runCodexAppVertexLaunch(configOnly, trace = false) {
       restoreCommand: "relay-ai codex-app --restore"
     });
     codexAppOutro(selectedEntry.display_name);
-    await waitForShutdown2();
+    await waitForShutdownWithConfirm();
     console.log("");
+    if (isCodexAppRunning()) {
+      p17.log.step("Stopping Codex Desktop...");
+      quitCodexAppGracefully();
+    }
     if (sessionActive) {
       restoreCodexAppOverlay();
       sessionActive = false;
     }
-    if (isCodexAppRunning()) {
-      const shouldClose = await p17.confirm({ message: "Codex Desktop is still running. Close it?" });
-      if (shouldClose && !p17.isCancel(shouldClose)) {
-        quitCodexAppGracefully();
-      }
-    }
     return 0;
   } finally {
     proxyHandle?.close();
@@ -13323,7 +13504,8 @@ async function runCodexAppCommand(args, opts = {}) {
       providerId: activeProvider.id,
       npm: "",
       upstreamModelId: "",
-      apiKey: ""
+      apiKey: "",
+      contextWindow: selectedModel.contextWindow
     } : appRoute;
     const specBase = { route: activeRoute, catalogPath };
     if (configOnly) {
@@ -13413,19 +13595,17 @@ async function runCodexAppCommand(args, opts = {}) {
       restoreCommand: "relay-ai codex-app --restore"
     });
     codexAppOutro(modelLabel);
-    await waitForShutdown2();
+    await waitForShutdownWithConfirm();
     if (trace) printTraceLog(debugLogPath);
     console.log("");
+    if (isCodexAppRunning()) {
+      p17.log.step("Stopping Codex Desktop...");
+      quitCodexAppGracefully();
+    }
     if (sessionActive) {
       restoreCodexAppOverlay();
       sessionActive = false;
     }
-    if (isCodexAppRunning()) {
-      const shouldClose = await p17.confirm({ message: "Codex Desktop is still running. Close it?" });
-      if (shouldClose && !p17.isCancel(shouldClose)) {
-        quitCodexAppGracefully();
-      }
-    }
     return 0;
   } finally {
     proxyHandle?.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jacobbd/relay-ai",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "publishConfig": {
     "access": "public"
   },