@jacobbd/relay-ai 0.3.0 → 0.3.2

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # 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
+
+- **Codex App: background GPT model requests no longer crash your session** — The Codex desktop app has an internal agent subsystem that sends background requests using hardcoded model IDs (`gpt-5.4`, `gpt-5.4-mini`, `gpt-5.5`), even when you've configured a completely different model like GLM or DeepSeek. These requests were hitting the relay-ai proxy and getting 404 errors, which interrupted your chat session and showed up as confusing error states in the UI. The proxy now silently routes those background requests to your configured starting model instead. Your session keeps running. (Fixes [#8](https://github.com/jacob-bd/relay-ai/issues/8))
+
+- **Codex App: `GET /v1/responses` polling no longer returns 404** — Codex polls this endpoint in the background for session state. The proxy only handled `POST /v1/responses` before, so every poll got a 404. Now it returns an empty list, which is all Codex actually needs.
+
+- **`--trace` output was a false negative** — `relay-ai codex-app --trace` would print `(no errors found in debug log)` even when the proxy had been silently dropping dozens of model-not-found failures the whole session. Trace output now surfaces `resolveModel failed` and `resolveModel fallback` lines so you can actually see what's happening.
+
 ## [0.3.0] - 2026-06-21
 
 *Happy Father's Day!* 👨‍👦

package/dist/cli.js

@@ -35,7 +35,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@jacobbd/relay-ai",
-  version: "0.3.0",
+  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)
+    } : {}
   };
 }
 
@@ -3640,7 +3645,7 @@ function printTraceLog(debugLogPath) {
   const raw = readFileSync6(debugLogPath, "utf8");
   const log19 = redactTraceLog(raw);
   const errorLines = log19.split("\n").filter(
-    (l) => l.includes("error") || l.includes("Error") || l.includes('"type":"error"') || l.includes("status")
+    (l) => l.includes("error") || l.includes("Error") || l.includes('"type":"error"') || l.includes("status") || l.includes("resolveModel failed") || l.includes("resolveModel fallback")
   );
   console.log("\n" + pc2.bold(pc2.cyan("\u2500\u2500 Debug trace \u2500\u2500")));
   if (errorLines.length > 0) {
@@ -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,18 +10114,32 @@ 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 ?? "");
-        const resolved = resolveModel(routes, models, modelId);
+        let resolved = resolveModel(routes, models, modelId);
         if (!resolved) {
-          if (debug) {
-            log19(`resolveModel failed: requested="${modelId}" known=[${routes.map((r) => r.modelId).join(", ")}]`);
+          const fallbackRoute = routes[0];
+          const fallbackLm = fallbackRoute ? models.get(fallbackRoute.modelId) : void 0;
+          if (fallbackRoute && fallbackLm) {
+            if (debug) {
+              log19(`resolveModel fallback: requested="${modelId}" \u2192 ${fallbackRoute.modelId}`);
+            }
+            resolved = { route: fallbackRoute, languageModel: fallbackLm };
+          } else {
+            if (debug) {
+              log19(`resolveModel failed: requested="${modelId}" known=[${routes.map((r) => r.modelId).join(", ")}]`);
+            }
+            sendJson(res, 404, { error: { message: `Unknown model: ${modelId}`, type: "invalid_request_error" } });
+            return;
           }
-          sendJson(res, 404, { error: { message: `Unknown model: ${modelId}`, type: "invalid_request_error" } });
-          return;
         }
         const { route, languageModel } = resolved;
         try {
-          const params = translateResponsesRequest(
+          let params = translateResponsesRequest(
             body,
             route.npm,
             {
@@ -10028,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)}`);
@@ -10043,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 {
@@ -10053,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) {
@@ -10065,6 +10203,10 @@ async function startCodexProxy(routes, options = {}) {
         }
         return;
       }
+      if (req.method === "GET" && url === "/v1/responses") {
+        sendJson(res, 200, { object: "list", data: [] });
+        return;
+      }
       sendJson(res, 404, { error: { message: "Not found", type: "invalid_request_error" } });
     });
     server.on("error", reject2);
@@ -10156,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
     };
   });
 }
@@ -10668,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) {
@@ -12417,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");
@@ -12433,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,
@@ -12445,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) {
@@ -12464,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);
@@ -12564,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 {
@@ -12731,6 +12905,7 @@ function waitForShutdown2() {
     const cleanup = () => {
       process.removeListener("SIGINT", onSigint);
       process.removeListener("SIGTERM", onSigterm);
+      process.removeListener("SIGHUP", onSighup);
     };
     const onSigint = () => {
       cleanup();
@@ -12740,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);
   });
 }
 
@@ -12955,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
 
@@ -13055,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"] ?? "";
@@ -13128,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();
@@ -13310,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) {
@@ -13400,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.0",
+  "version": "0.3.2",
   "publishConfig": {
     "access": "public"
   },