codex-copilot-dx 0.6.3 → 0.6.5

package/README.md

@@ -31,7 +31,8 @@ ccdx
 
 `ccdx` is the only documented command and primary launcher. The old
 `codex-copilot-dx` executable remains temporarily as a compatibility shim: it
-prints a deprecation warning and runs `ccdx`, and will be removed in a future
+prints a deprecation warning at most once every 7 days in interactive terminals,
+runs `ccdx`, and remains silent in scripts. It will be removed in a future
 breaking release. For a one-off run without a global install, use
 `npm exec --yes --package=codex-copilot-dx@latest -- ccdx`.
 Run `ccdx <command> --help` (including `auth login claude --help` and
@@ -110,7 +111,7 @@ active account or profile. GPT requests continue to use the bearer supplied by
 the current PM profile; exact enabled Anthropic model IDs use the isolated
 CCDX Claude profile. Neither credential is copied into the other application.
 
-The first recipe supports only an exact, unmodified PM Studio 2.9.7 bundle on
+The current patch recipe supports only an exact, unmodified PM Studio 2.9.7 bundle on
 macOS. Authorize the isolated Claude profile first, quit PM Studio and its
 updater, then run the one-time setup command:
 
@@ -126,7 +127,7 @@ and relay without changing files:
 ccdx pms status
 ```
 
-`pm-studio status` and `pm-studio setup` are equivalent long-form aliases.
+`ccdx pm-studio status` and `ccdx pm-studio setup` are equivalent long-form aliases.
 
 `ccdx pms setup` performs only local preflight, backup, staging, integrity,
 signing, and replacement work. It never starts Device Flow, the adapter,
@@ -186,13 +187,13 @@ To change the model used by Codex Auto-review, run:
 ccdx auto-review-model
 ```
 
-The selector reads the current adapter model list, falling back to the fresh local
-model cache, and offers only enabled models that advertise a Responses endpoint.
+The selector first queries the running adapter, including its last-known-good
+model list when live refresh is unavailable, then falls back to the non-expired
+local model cache. It offers only enabled models that advertise a Responses endpoint.
 It saves the selection in `~/.config/codex-copilot-dx/config.json` (or under
 `XDG_CONFIG_HOME` when set); choosing `gpt-5.5` clears the override and restores
-the package default. A running 0.5.1+
-adapter reads the setting on the next Auto-review request, so it does not need to
-be restarted.
+the package default. A running adapter reads the setting on the next Auto-review
+request, so it does not need to be restarted.
 
 To update the globally installed package, choose a source interactively:
 
@@ -212,26 +213,26 @@ ccdx update github
 The npm source installs `codex-copilot-dx@latest` through the registry already
 configured for npm, including a company mirror. The GitHub source installs the
 latest commit from `DaleXiao/codex-copilot-dx` `main` and opts in to Git fetching
-for that command, as required by npm 12. It does not change npm's persistent
-`allow-git` setting. Both paths use npm's global installer without shell
+for that command. It does not change npm's persistent `allow-git` setting. Both
+paths use npm's global installer without shell
 interpolation. A currently running adapter keeps its loaded version until it is
 stopped and started again.
 If a configured npm mirror has not synchronized the current release yet, use
 the GitHub source to install the current `main` revision.
 
-On first run, it will:
-1. Authenticate with GitHub via device flow (if needed), after first trying compatible local Copilot token sources
-2. Print the local package version and check for a newer npm release in the background
-3. Start the adapter on loopback (`127.0.0.1:2026`)
+On a normal launch, it will:
+1. Print the local package version and check for a newer npm release in the background
+2. Reuse a compatible running adapter when available; otherwise authenticate with GitHub if needed, after first trying compatible local Copilot token sources
+3. When starting a new adapter, refresh Copilot model metadata and listen on loopback (`127.0.0.1:2026`)
 4. Configure Codex (`~/.codex/config.toml`) to use the adapter, including stale shell env base URLs if present
 5. Configure Claude Code (`~/.claude/settings.json`) to use the adapter; it creates the file when missing, otherwise backs up `settings.json.bak` before updating the local API env keys
-6. Launch Codex Desktop
+6. On macOS, attempt to launch Codex or ChatGPT unless `CCDX_AUTO_LAUNCH` disables it
 
 Claude Code picks up the new `ANTHROPIC_BASE_URL` on its next launch.
 
-If an existing `codex-copilot-dx` adapter is already running on the configured host and port, a second launch reuses it instead of starting another proxy. The second launch still refreshes Codex and Claude Code config, then exits.
+If a compatible CCDX adapter is already running on the configured host and port, a second launch reuses it instead of starting another proxy. The second launch still refreshes Codex and Claude Code config, then exits.
 
-The running adapter reports its package and protocol versions. After upgrading `codex-copilot-dx`, stop the old process before starting the new version; the new CLI refuses to silently reuse an incompatible adapter.
+The running adapter reports its package and protocol versions. After upgrading the package, stop the old process before starting the new version; the new CLI refuses to silently reuse an incompatible adapter.
 
 Do not set Claude Code by manually exporting `ANTHROPIC_BASE_URL` or `ANTHROPIC_AUTH_TOKEN` in your shell. Let `ccdx` write the local config files instead. If you previously exported those variables, remove them from shell startup files and restart the terminal before launching Claude Code.
 
@@ -330,12 +331,13 @@ Environment variables:
 | `CCDX_ALLOW_LAN` | unset | Set to `1` to allow non-loopback `ADAPTER_HOST` values such as `0.0.0.0`; exposes your Copilot-backed adapter beyond this machine |
 | `CCDX_MAX_BODY_BYTES` | `67108864` | Maximum compressed/raw request body size |
 | `CCDX_MAX_DECODED_BODY_BYTES` | `134217728` | Maximum decoded request body size after decompression |
-| `CCDX_MAX_INFLIGHT_BODY_BYTES` | `33554432` | Shared byte budget for admitted request bodies; a larger single request runs exclusively |
+| `CCDX_MAX_INFLIGHT_BODY_BYTES` | `33554432` | Per-pool byte budget for raw bodies, decoded bodies, and materialized response history; a larger item runs exclusively in its pool |
 | `CCDX_MAX_QUEUED_REQUESTS` | `16` | Maximum body requests waiting for the shared byte budget |
 | `CCDX_REQUEST_QUEUE_TIMEOUT_MS` | `120000` | Maximum wait for request-body admission before returning `503` |
+| `CCDX_REQUEST_BODY_TIMEOUT_MS` | `120000` | Maximum time to receive and decode one request body before returning `408` |
 | `CCDX_MAX_UPSTREAM_BODY_BYTES` | `31457280` | Strict maximum forwarded Responses body size; larger payloads are adapted locally or rejected with `413` |
 | `CCDX_MAX_SSE_BUFFER_BYTES` | `8388608` | Maximum buffered bytes for one unterminated upstream SSE line/event |
-| `CCDX_UPSTREAM_TIMEOUT_MS` | `120000` | Timeout for non-streaming upstream Copilot requests |
+| `CCDX_UPSTREAM_TIMEOUT_MS` | `120000` | Per-phase timeout for Responses preparation and non-streaming upstream Copilot requests |
 | `CCDX_STREAM_HANDSHAKE_TIMEOUT_MS` | `120000` | Timeout while waiting for upstream streaming response headers |
 | `CCDX_STREAM_IDLE_TIMEOUT_MS` | `120000` | Maximum idle time between upstream streaming body chunks |
 | `CCDX_UPSTREAM_RETRIES` | `2` | Retries for safe requests and clearly pre-connect POST failures; capped at `5` |
@@ -396,7 +398,7 @@ The final serialized UTF-8 request body is measured before forwarding. Above the
 
 Completed image transforms are reused from a byte-bounded process-local LRU cache, and concurrent requests for the same transform share one encode. The cache key includes source content, MIME type, model-aware dimensions, WebP quality, and encoder settings; failures are not cached and request cancellation remains isolated.
 
-Before image encoding, CCDX leaves ordinary visual history byte-for-byte unchanged while it has at most 24 historical images and the expanded body is at most 18 MiB. Above either threshold, the temporary upstream view keeps every current-turn image and at most 16 recent historical images, targeting 16 MiB. If that history tree then times out during local preparation or upstream handshake, the next retry automatically uses an 8-image, 10 MiB recovery window for ten minutes. Two successful requests or a successful compaction clear recovery mode. CCDX never transparently repeats the ambiguous timed-out POST, and no local history is deleted; retrying does not require restarting the service.
+Before image encoding, CCDX leaves ordinary visual history byte-for-byte unchanged while it has at most 24 historical images and the expanded body is at most 18 MiB. Above either threshold, the temporary upstream view keeps every current-turn image and at most 16 recent historical images, targeting 16 MiB. If that history tree then times out during local preparation, a streaming handshake, or a non-streaming upstream request, or if the upstream returns HTTP 408, the next retry automatically uses an 8-image, 10 MiB recovery window for ten minutes. Two successful requests or a successful compaction clear recovery mode. CCDX never transparently repeats the ambiguous timed-out POST, and no local history is deleted; retrying does not require restarting the service.
 
 When expanded Responses history exceeds Copilot's 50-image request limit, the adapter removes older duplicate image occurrences first, then keeps the 50 most recent images. This applies only to the forwarded request: local history remains complete, current images are preferred over older history, and requests at or below the limit are unchanged.
 

package/bin/codex-copilot-dx.mjs

@@ -1,3 +1,10 @@
 #!/usr/bin/env node
-console.warn("codex-copilot-dx is deprecated; use ccdx instead. The compatibility alias will be removed in a future breaking release.");
+
+if (process.stderr.isTTY === true) {
+  const {
+    LEGACY_COMMAND_WARNING,
+    shouldShowLegacyCommandWarning,
+  } = await import("../src/legacy-command-warning.mjs");
+  if (shouldShowLegacyCommandWarning({ interactive: true })) console.warn(LEGACY_COMMAND_WARNING);
+}
 await import("./cli.mjs");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "description": "Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot",
   "author": "Dale Xiao",
   "type": "module",

package/src/adapter.mjs

@@ -136,6 +136,7 @@ export function createAdapterHandler(options = {}) {
   const upstreamTimeoutMs = parsePositiveInteger(options.upstreamTimeoutMs, ADAPTER_RUNTIME_CONFIG.upstreamTimeoutMs);
   const streamHandshakeTimeoutMs = parsePositiveInteger(options.streamHandshakeTimeoutMs, ADAPTER_RUNTIME_CONFIG.streamHandshakeTimeoutMs);
   const streamIdleTimeoutMs = parsePositiveInteger(options.streamIdleTimeoutMs, ADAPTER_RUNTIME_CONFIG.streamIdleTimeoutMs);
+  const requestBodyTimeoutMs = parsePositiveInteger(options.requestBodyTimeoutMs, ADAPTER_RUNTIME_CONFIG.requestBodyTimeoutMs);
   const acquireRequest = options.acquireRequest || createRequestAdmission();
   const requestMetrics = options.requestMetrics || createRequestMetrics();
   const streamPerformanceMetrics = options.streamPerformanceMetrics || createStreamPerformanceMetrics();
@@ -150,9 +151,11 @@ export function createAdapterHandler(options = {}) {
     chatCompletionsFn: codexChatCompletionsFn,
     getCachedModelEndpointsFn,
     imagePressure,
+    now: options.now,
     openAIModelEnv,
     responsesPayloadOptions: options.responsesPayloadOptions,
     responsesFn,
+    requestBodyTimeoutMs,
     streamHandshakeTimeoutMs,
     streamIdleTimeoutMs,
     upstreamTimeoutMs,
@@ -161,18 +164,21 @@ export function createAdapterHandler(options = {}) {
     acquireRequest,
     autoReviewModelResolver: options.autoReviewModelResolver,
     imagePressure,
+    now: options.now,
     openAIModelEnv,
+    requestBodyTimeoutMs,
     responsesCompactFn,
     streamHandshakeTimeoutMs,
     streamIdleTimeoutMs,
     upstreamTimeoutMs,
   });
-  const anthropicCountTokensHandler = createAnthropicCountTokensHandler({ acquireRequest });
+  const anthropicCountTokensHandler = createAnthropicCountTokensHandler({ acquireRequest, requestBodyTimeoutMs });
   const anthropicMessagesHandler = createAnthropicMessagesHandler({
     acquireRequest,
     chatCompletionsFn: claudeChatCompletionsFn,
     environment: process.env,
     modelOptions: claudeDesktopModelOptions,
+    requestBodyTimeoutMs,
     streamHandshakeTimeoutMs,
     streamIdleTimeoutMs,
     upstreamTimeoutMs,
@@ -184,6 +190,7 @@ export function createAdapterHandler(options = {}) {
     claudeProfile: options.claudeProfile,
     claudeModelRegistry,
     fetchImpl: options.pmStudioFetchImpl,
+    requestBodyTimeoutMs,
     streamHandshakeTimeoutMs,
     streamIdleTimeoutMs,
     upstreamTimeoutMs,
@@ -284,13 +291,20 @@ export function createAdapterHandler(options = {}) {
   };
 
   return (req, res) => {
-    const pathname = requestPath(req.url);
     const requestId = createRequestId();
     if (typeof res.setHeader === "function") {
       res.setHeader("X-Request-Id", requestId);
     } else if (res.headers && typeof res.headers === "object") {
       res.headers["X-Request-Id"] = requestId;
     }
+    let pathname;
+    try {
+      pathname = requestPath(req.url);
+    } catch {
+      res.writeHead(400, { "Content-Type": "application/json", Connection: "close" });
+      res.end(JSON.stringify({ error: "Invalid request target" }));
+      return;
+    }
 
     const trackRequest = pathname !== ADAPTER_HEALTH_PATH && pathname !== ADAPTER_STATUS_PATH;
     const routeName = classifyAdapterRoute(req.method, pathname);
@@ -352,11 +366,9 @@ export function startAdapter(port = 2026, host = "127.0.0.1", options = {}) {
   server.once("close", cleanupTerminalActivity);
 
   server.on("upgrade", (req, socket) => {
-    // Codex Desktop 0.130+ negotiates a "responses_websockets" server-push
-    // protocol on WS upgrade. We don't implement that protocol; accepting the
-    // upgrade and waiting for a client request just hangs and triggers a
-    // 5-attempt reconnect storm. Refuse the upgrade so Codex falls back to
-    // plain HTTP SSE, which this adapter handles correctly.
+    // The responses_websockets upgrade expects a server-push protocol that this
+    // adapter does not implement. Refuse it so the client can fall back to the
+    // supported HTTP SSE transport instead of waiting on an unusable socket.
     socket.write("HTTP/1.1 426 Upgrade Required\r\nConnection: close\r\nContent-Length: 0\r\n\r\n");
     socket.destroy();
   });

package/src/anthropic-handler.mjs

@@ -21,20 +21,22 @@ import { safeUpstreamResponseHeaders } from "./upstream-headers.mjs";
 import { recordAnthropicUsage } from "./usage.mjs";
 
 export function createAnthropicCountTokensHandler(options) {
-  const { acquireRequest } = options;
+  const { acquireRequest, requestBodyTimeoutMs } = options;
 
   return async function handleAnthropicCountTokens(req, res) {
     const abort = createRequestAbort(req, res);
     let releaseRequest = () => {};
     try {
       releaseRequest = await acquireRequest(req, { signal: abort.signal });
-      const parsed = await readJsonBody(req);
+      abort.setTimeout(requestBodyTimeoutMs, "request_body_timeout");
+      const parsed = await readJsonBody(req, { admission: releaseRequest, signal: abort.signal });
+      abort.clearTimeout();
       const result = await countTokens(parsed);
       releaseRequest();
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(JSON.stringify(result));
     } catch (error) {
-      sendJsonError(res, error);
+      sendJsonError(res, error, abort.reason === "request_body_timeout" ? 408 : 400);
     } finally {
       releaseRequest();
       abort.cleanup();
@@ -48,6 +50,7 @@ export function createAnthropicMessagesHandler(options) {
     chatCompletionsFn,
     environment,
     modelOptions,
+    requestBodyTimeoutMs,
     streamHandshakeTimeoutMs,
     streamIdleTimeoutMs,
     upstreamTimeoutMs,
@@ -58,7 +61,8 @@ export function createAnthropicMessagesHandler(options) {
     let releaseRequest = () => {};
     try {
       releaseRequest = await acquireRequest(req, { signal: abort.signal });
-      const parsed = await readJsonBody(req);
+      abort.setTimeout(requestBodyTimeoutMs, "request_body_timeout");
+      const parsed = await readJsonBody(req, { admission: releaseRequest, signal: abort.signal });
       abort.setTimeout(
         parsed.stream ? streamHandshakeTimeoutMs : upstreamTimeoutMs,
         parsed.stream ? "stream_handshake_timeout" : "upstream_timeout",

package/src/auto-review-model.mjs

@@ -135,7 +135,7 @@ export async function runAutoReviewModelCommand({
   if (String(env.CCDX_AUTO_REVIEW_MODEL || "").trim()) {
     output.write(`CCDX_AUTO_REVIEW_MODEL=${current.model} remains the effective override until it is unset.\n`);
   } else {
-    output.write("The running 0.5.1+ adapter will use this model on the next Auto Review request.\n");
+    output.write("The running adapter will use this model on the next Auto Review request.\n");
   }
   return { ...result, cancelled: false, model: selectedModel };
 }

package/src/cli-options.mjs

@@ -258,7 +258,7 @@ export function cliCommandName() {
 
 function topicHelp(name, topic) {
   const sections = {
-    start: `Usage:\n  ${name} [start] [--configure-claude-app] [--show-request-id]\n\nStarts or reuses the local adapter, updates Codex and Claude Code configuration, and opens Codex.\n--configure-claude-app also creates or updates the managed Claude App gateway profile.`,
+    start: `Usage:\n  ${name} [start] [--configure-claude-app] [--show-request-id]\n\nStarts or reuses the local adapter, updates Codex and Claude Code configuration, and attempts to open Codex or ChatGPT when auto-launch is enabled and supported.\n--configure-claude-app also creates or updates the managed Claude App gateway profile.`,
     auth: `Usage:\n  ${name} auth status [--online]\n  ${name} auth login claude [--github-login <login>] [--reauth]\n\nShows the two account profiles or configures the isolated Claude account. Device login starts only when no reusable local Copilot credential is available or --reauth is used.`,
     "auth status": `Usage:\n  ${name} auth status [--online]\n\nShows account routing without exposing credentials. --online also verifies both configured Copilot entitlements and model catalogs.`,
     "auth login": `Usage:\n  ${name} auth login claude [--github-login <login>] [--reauth]\n\nReuses a compatible local Copilot credential when possible. --reauth forces GitHub Device Flow.`,

package/src/http-transport.mjs

@@ -47,6 +47,83 @@ function admissionAbortError(signal) {
   return error;
 }
 
+function createSupplementalAdmission({ maxWeight, maxQueued, waitTimeoutMs, label }) {
+  const queue = [];
+  let activeWeight = 0;
+  let activeRequests = 0;
+
+  const activate = (entry) => {
+    entry.cleanup();
+    activeWeight += entry.weight;
+    activeRequests += 1;
+    let released = false;
+    entry.resolve(() => {
+      if (released) return;
+      released = true;
+      activeWeight = Math.max(0, activeWeight - entry.weight);
+      activeRequests = Math.max(0, activeRequests - 1);
+      drain();
+    });
+  };
+
+  const drain = () => {
+    for (let index = 0; index < queue.length;) {
+      const entry = queue[index];
+      if (activeWeight + entry.weight > maxWeight) {
+        index += 1;
+        continue;
+      }
+      queue.splice(index, 1);
+      activate(entry);
+    }
+  };
+
+  const acquire = (requestedWeight, { signal } = {}) => {
+    if (signal?.aborted) return Promise.reject(admissionAbortError(signal));
+    const parsedWeight = Number.isFinite(requestedWeight) && requestedWeight > 0
+      ? Math.ceil(requestedWeight)
+      : maxWeight;
+    const weight = Math.max(1, Math.min(parsedWeight, maxWeight));
+    if (queue.length >= maxQueued && activeWeight + weight > maxWeight) {
+      return Promise.reject(httpError(`${label} queue is full (${maxQueued} waiting)`, 503));
+    }
+
+    return new Promise((resolve, reject) => {
+      let timer;
+      const entry = {
+        weight,
+        resolve,
+        cleanup: () => {
+          if (timer) clearTimeout(timer);
+          signal?.removeEventListener("abort", onAbort);
+        },
+      };
+      const remove = () => {
+        const index = queue.indexOf(entry);
+        if (index >= 0) queue.splice(index, 1);
+      };
+      const fail = (error) => {
+        entry.cleanup();
+        remove();
+        reject(error);
+        drain();
+      };
+      const onAbort = () => fail(admissionAbortError(signal));
+      signal?.addEventListener("abort", onAbort, { once: true });
+      timer = setTimeout(() => {
+        fail(httpError(`${label} admission timed out after ${waitTimeoutMs}ms`, 503));
+      }, waitTimeoutMs);
+      timer.unref?.();
+      queue.push(entry);
+      if (signal?.aborted) onAbort();
+      else drain();
+    });
+  };
+
+  acquire.stats = () => ({ activeWeight, activeRequests, queued: queue.length, maxWeight });
+  return acquire;
+}
+
 export function createRequestAdmission({
   maxBytes = MAX_INFLIGHT_BODY_BYTES,
   maxQueued = MAX_QUEUED_REQUESTS,
@@ -55,6 +132,24 @@ export function createRequestAdmission({
   const byteLimit = parsePositiveInteger(maxBytes, MAX_INFLIGHT_BODY_BYTES);
   const queueLimit = parsePositiveInteger(maxQueued, MAX_QUEUED_REQUESTS);
   const timeoutMs = parsePositiveInteger(waitTimeoutMs, REQUEST_QUEUE_TIMEOUT_MS);
+  const acquireDecompression = createSupplementalAdmission({
+    maxWeight: 1,
+    maxQueued: queueLimit,
+    waitTimeoutMs: timeoutMs,
+    label: "Request decompression",
+  });
+  const acquireDecodedBody = createSupplementalAdmission({
+    maxWeight: byteLimit,
+    maxQueued: queueLimit,
+    waitTimeoutMs: timeoutMs,
+    label: "Decoded request body",
+  });
+  const acquireResponseHistory = createSupplementalAdmission({
+    maxWeight: byteLimit,
+    maxQueued: queueLimit,
+    waitTimeoutMs: timeoutMs,
+    label: "Response history",
+  });
   const queue = [];
   let activeBytes = 0;
   let activeRequests = 0;
@@ -83,13 +178,28 @@ export function createRequestAdmission({
     counters.waitMsTotal += waitMs;
     counters.waitMsMax = Math.max(counters.waitMsMax, waitMs);
     let released = false;
-    entry.resolve(() => {
+    const supplementalReleases = new Set();
+    const release = () => {
       if (released) return;
       released = true;
+      for (const releaseSupplemental of supplementalReleases) releaseSupplemental();
+      supplementalReleases.clear();
       activeBytes = Math.max(0, activeBytes - entry.weight);
       activeRequests = Math.max(0, activeRequests - 1);
       drain();
-    });
+    };
+    const reserve = async (gate, weight, options) => {
+      const releaseSupplemental = await gate(weight, options);
+      if (released) {
+        releaseSupplemental();
+        throw admissionAbortError(options?.signal);
+      }
+      supplementalReleases.add(releaseSupplemental);
+    };
+    release.acquireDecompression = (options) => acquireDecompression(1, options);
+    release.reserveDecodedBody = (bytes, options) => reserve(acquireDecodedBody, bytes, options);
+    release.reserveResponseHistory = (bytes, options) => reserve(acquireResponseHistory, bytes, options);
+    entry.resolve(release);
   };
 
   const drain = () => {
@@ -173,11 +283,64 @@ export function createRequestAdmission({
       ? Number((counters.waitMsTotal / counters.activated).toFixed(1))
       : 0,
     waitMsMax: counters.waitMsMax,
+    decompressionsActive: acquireDecompression.stats().activeRequests,
+    decompressionsQueued: acquireDecompression.stats().queued,
+    decodedBodyBytes: acquireDecodedBody.stats().activeWeight,
+    decodedBodiesActive: acquireDecodedBody.stats().activeRequests,
+    decodedBodiesQueued: acquireDecodedBody.stats().queued,
+    responseHistoryBytes: acquireResponseHistory.stats().activeWeight,
+    responseHistoriesActive: acquireResponseHistory.stats().activeRequests,
+    responseHistoriesQueued: acquireResponseHistory.stats().queued,
   });
   return acquire;
 }
 
-async function readRequestBuffer(req, maxBytes) {
+function consumeRequestChunks(req, { signal, onChunk }) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => {
+      req.off("data", handleData);
+      req.off("end", handleEnd);
+      req.off("error", handleError);
+      req.off("aborted", handleAborted);
+      signal?.removeEventListener("abort", handleSignalAbort);
+    };
+    const finish = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (error) reject(error);
+      else resolve();
+    };
+    const stopReading = (error) => {
+      req.pause?.();
+      finish(error);
+    };
+    const handleData = (chunk) => {
+      try {
+        onChunk(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      } catch (error) {
+        stopReading(error);
+      }
+    };
+    const handleEnd = () => finish();
+    const handleError = (error) => finish(error);
+    const handleAborted = () => finish(admissionAbortError(signal));
+    const handleSignalAbort = () => stopReading(admissionAbortError(signal));
+
+    req.once("end", handleEnd);
+    req.once("error", handleError);
+    req.once("aborted", handleAborted);
+    signal?.addEventListener("abort", handleSignalAbort, { once: true });
+    if (signal?.aborted) handleSignalAbort();
+    else {
+      req.on("data", handleData);
+      req.resume?.();
+    }
+  });
+}
+
+async function readRequestBuffer(req, maxBytes, signal) {
   const contentLength = requestContentLength(req);
   if (Number.isFinite(contentLength) && contentLength > maxBytes) {
     throw payloadTooLarge("Raw", maxBytes);
@@ -185,16 +348,18 @@ async function readRequestBuffer(req, maxBytes) {
 
   const chunks = [];
   let total = 0;
-  for await (const chunk of req) {
-    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-    total += buffer.length;
-    if (total > maxBytes) throw payloadTooLarge("Raw", maxBytes);
-    chunks.push(buffer);
-  }
+  await consumeRequestChunks(req, {
+    signal,
+    onChunk(buffer) {
+      total += buffer.length;
+      if (total > maxBytes) throw payloadTooLarge("Raw", maxBytes);
+      chunks.push(buffer);
+    },
+  });
   return Buffer.concat(chunks);
 }
 
-async function readIdentityText(req, maxBodyBytes, maxDecodedBodyBytes) {
+async function readIdentityText(req, maxBodyBytes, maxDecodedBodyBytes, signal) {
   const contentLength = requestContentLength(req);
   if (Number.isFinite(contentLength) && contentLength > maxBodyBytes) {
     throw payloadTooLarge("Raw", maxBodyBytes);
@@ -206,13 +371,15 @@ async function readIdentityText(req, maxBodyBytes, maxDecodedBodyBytes) {
   const decoder = new TextDecoder();
   let text = "";
   let total = 0;
-  for await (const chunk of req) {
-    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-    total += buffer.length;
-    if (total > maxBodyBytes) throw payloadTooLarge("Raw", maxBodyBytes);
-    if (total > maxDecodedBodyBytes) throw payloadTooLarge("Decoded", maxDecodedBodyBytes);
-    text += decoder.decode(buffer, { stream: true });
-  }
+  await consumeRequestChunks(req, {
+    signal,
+    onChunk(buffer) {
+      total += buffer.length;
+      if (total > maxBodyBytes) throw payloadTooLarge("Raw", maxBodyBytes);
+      if (total > maxDecodedBodyBytes) throw payloadTooLarge("Decoded", maxDecodedBodyBytes);
+      text += decoder.decode(buffer, { stream: true });
+    },
+  });
   return text + decoder.decode();
 }
 
@@ -267,22 +434,34 @@ function parseRequestJson(text) {
 }
 
 export async function readJsonBody(req, {
+  admission,
   maxBodyBytes = MAX_BODY_BYTES,
   maxDecodedBodyBytes = MAX_DECODED_BODY_BYTES,
+  signal,
 } = {}) {
+  if (signal?.aborted) throw admissionAbortError(signal);
   const encodings = contentEncodings(req.headers?.["content-encoding"]);
   if (encodings.every((encoding) => encoding === "identity")) {
-    return parseRequestJson(await readIdentityText(req, maxBodyBytes, maxDecodedBodyBytes));
+    return parseRequestJson(await readIdentityText(req, maxBodyBytes, maxDecodedBodyBytes, signal));
   }
-  const buffer = await readRequestBuffer(req, maxBodyBytes);
-  let decoded;
+  const buffer = await readRequestBuffer(req, maxBodyBytes, signal);
+  const releaseDecompression = await admission?.acquireDecompression?.({ signal }) || (() => {});
   try {
-    decoded = await decodeRequestBuffer(buffer, req.headers?.["content-encoding"], maxDecodedBodyBytes);
-  } catch (e) {
-    if (e?.statusCode) throw e;
-    throw httpError(`Invalid compressed request body: ${e.message}`, 400);
+    let decoded;
+    try {
+      decoded = await decodeRequestBuffer(buffer, req.headers?.["content-encoding"], maxDecodedBodyBytes);
+    } catch (e) {
+      if (e?.statusCode) throw e;
+      throw httpError(`Invalid compressed request body: ${e.message}`, 400);
+    }
+    if (signal?.aborted) throw admissionAbortError(signal);
+    if (decoded.length > 0) {
+      await admission?.reserveDecodedBody?.(decoded.length, { signal });
+    }
+    return parseRequestJson(decoded.toString("utf8"));
+  } finally {
+    releaseDecompression();
   }
-  return parseRequestJson(decoded.toString("utf8"));
 }
 
 export function sendJsonError(res, err, fallbackStatus = 400) {
@@ -291,7 +470,10 @@ export function sendJsonError(res, err, fallbackStatus = 400) {
     res.end();
     return;
   }
-  res.writeHead(err?.statusCode || fallbackStatus, { "Content-Type": "application/json" });
+  const statusCode = err?.statusCode || fallbackStatus;
+  const headers = { "Content-Type": "application/json" };
+  if (statusCode === 408 || statusCode === 413) headers.Connection = "close";
+  res.writeHead(statusCode, headers);
   res.end(JSON.stringify(err?.jsonBody || { error: err?.message || "Request failed" }));
 }
 
@@ -327,6 +509,7 @@ export function isAbortLikeError(err) {
 }
 
 export function abortErrorStatusCode(reason) {
+  if (reason === "request_body_timeout") return 408;
   if (["responses_prepare_timeout", "upstream_timeout", "stream_handshake_timeout", "stream_idle_timeout"].includes(reason)) return 504;
   if (reason === "client_aborted" || reason === "client_closed") return 499;
   return 502;
@@ -352,6 +535,7 @@ export function createRequestAbort(req, res) {
   return {
     signal: controller.signal,
     get reason() { return reason; },
+    abort,
     setTimeout(ms, nextReason = "upstream_timeout") {
       if (timer) clearTimeout(timer);
       timer = null;

package/src/launcher.mjs

@@ -3,9 +3,8 @@ import { status } from "./status.mjs";
 
 export { ensureAuth } from "./auth.mjs";
 
-// The Codex desktop app was folded into the ChatGPT app, but it keeps the
-// original bundle identifier. Launching by bundle id works for both the old
-// Codex.app and the new ChatGPT.app regardless of where they are installed.
+// Prefer the Codex bundle identifier, then fall back to the known app paths.
+// This supports both Codex.app and ChatGPT.app regardless of installation path.
 const CODEX_BUNDLE_ID = "com.openai.codex";
 const APP_PATH_CANDIDATES = [
   "/Applications/Codex.app",

package/src/legacy-command-warning.mjs

@@ -0,0 +1,37 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { atomicWriteFileSync } from "./atomic-file.mjs";
+
+export const LEGACY_COMMAND_WARNING_INTERVAL_MS = 7 * 24 * 60 * 60 * 1000;
+export const LEGACY_COMMAND_WARNING = "codex-copilot-dx is deprecated; use ccdx instead. The compatibility alias will be removed in a future breaking release.";
+
+export function legacyCommandWarningPath({ env = process.env, home = os.homedir() } = {}) {
+  const xdgCacheHome = String(env.XDG_CACHE_HOME || "").trim();
+  const cacheRoot = xdgCacheHome || path.join(home, ".cache");
+  return path.join(cacheRoot, "codex-copilot-dx", "legacy-command-warning");
+}
+
+export function shouldShowLegacyCommandWarning({
+  env = process.env,
+  home = os.homedir(),
+  interactive = process.stderr.isTTY === true,
+  now = Date.now(),
+} = {}) {
+  if (!interactive) return false;
+  const filePath = legacyCommandWarningPath({ env, home });
+  try {
+    const previous = Number.parseInt(fs.readFileSync(filePath, "utf8"), 10);
+    if (Number.isFinite(previous) && Math.abs(now - previous) < LEGACY_COMMAND_WARNING_INTERVAL_MS) {
+      return false;
+    }
+  } catch {
+    // A missing or unreadable cache must not prevent the compatibility command.
+  }
+  try {
+    atomicWriteFileSync(filePath, `${now}\n`, { mode: 0o600 });
+  } catch {
+    // The warning remains best effort when the cache directory is read-only.
+  }
+  return true;
+}

package/src/pm-studio-relay.mjs

@@ -252,6 +252,9 @@ async function relayUpstreamResponse(response, reqBody, res, abort, streamIdleTi
 function safeFailure(error, abort) {
   if (error?.statusCode && !isAbortLikeError(error)) return error;
   if (abort?.signal.aborted || isAbortLikeError(error)) {
+    if (abort?.reason === "request_body_timeout") {
+      return localError(408, "request_timeout", "PM Studio relay request body timed out");
+    }
     return localError(
       abortErrorStatusCode(abort?.reason),
       "upstream_timeout",
@@ -277,6 +280,7 @@ export function createPmStudioRelayHandler(options = {}) {
   const upstreamTimeoutMs = parsePositiveInteger(options.upstreamTimeoutMs, runtime.upstreamTimeoutMs);
   const streamHandshakeTimeoutMs = parsePositiveInteger(options.streamHandshakeTimeoutMs, runtime.streamHandshakeTimeoutMs);
   const streamIdleTimeoutMs = parsePositiveInteger(options.streamIdleTimeoutMs, runtime.streamIdleTimeoutMs);
+  const requestBodyTimeoutMs = parsePositiveInteger(options.requestBodyTimeoutMs, runtime.requestBodyTimeoutMs);
   const validationTtlMs = parsePositiveInteger(options.validationTtlMs, DEFAULT_VALIDATION_TTL_MS);
   const validationCacheSize = parsePositiveInteger(options.validationCacheSize, DEFAULT_VALIDATION_CACHE_SIZE, 4096);
   const validationConcurrency = parsePositiveInteger(
@@ -430,8 +434,10 @@ export function createPmStudioRelayHandler(options = {}) {
   async function handlePost(req, res, pathname, token, abort) {
     let releaseRequest = releaseOnce();
     try {
-      releaseRequest = releaseOnce(await acquireRequest(req, { signal: abort.signal }));
-      const body = await readJsonBody(req);
+      const admission = await acquireRequest(req, { signal: abort.signal });
+      releaseRequest = releaseOnce(admission);
+      abort.setTimeout(requestBodyTimeoutMs, "request_body_timeout");
+      const body = await readJsonBody(req, { admission, signal: abort.signal });
       const supportsStream = pathname === "/chat/completions" || pathname === "/responses";
       const streaming = supportsStream && body?.stream === true;
       const requestTimeoutMs = streaming ? streamHandshakeTimeoutMs : upstreamTimeoutMs;

package/src/response-history.mjs

@@ -178,7 +178,7 @@ export function responseHistoryRootId(responseId) {
   return histories.get(responseId)?.rootId || null;
 }
 
-export function materializeResponseHistory(responseId) {
+function responseHistoryChain(responseId) {
   const chain = [];
   const seen = new Set();
   let currentId = responseId;
@@ -193,7 +193,16 @@ export function materializeResponseHistory(responseId) {
     chain.push(entry);
     currentId = entry.parentId;
   }
-  const rootId = chain[0]?.rootId;
+  return { chain, rootId: chain[0]?.rootId };
+}
+
+export function responseHistoryMaterializedBytes(responseId) {
+  const { chain } = responseHistoryChain(responseId);
+  return chain.reduce((bytes, entry) => bytes + entry.bytes, 0);
+}
+
+export function materializeResponseHistory(responseId) {
+  const { chain, rootId } = responseHistoryChain(responseId);
   const items = [];
   for (const entry of chain.reverse()) items.push(...entry.inputItems, ...entry.outputItems);
   const materialized = cloneJson(items);

package/src/responses-bridge.mjs

@@ -143,23 +143,38 @@ export function chatToResponses(chatResp, model) {
 
 export async function forwardToChat(chatReq, emitEvent, onDone, onError, options = {}) {
   delete chatReq.max_tokens;
-  const upstreamReq = withChatStreamUsage(chatReq);
-  const bodyText = upstreamReq === chatReq ? options.bodyText : undefined;
+  const requestModel = chatReq.model || "unknown";
+  let upstreamReq = withChatStreamUsage(chatReq);
+  let {
+    abort,
+    bodyText,
+    chatCompletionsFn: configuredChatCompletionsFn,
+    onUpstreamResponse,
+    onUpstreamStart,
+    releaseRequest,
+    signal,
+    streamIdleTimeoutMs,
+  } = options;
+  options = undefined;
+  if (upstreamReq !== chatReq) bodyText = undefined;
   let resp;
   try {
-    const chatCompletionsFn = options.chatCompletionsFn || chatCompletions;
+    const chatCompletionsFn = configuredChatCompletionsFn || chatCompletions;
     try {
-      options.onUpstreamStart?.();
+      onUpstreamStart?.();
       resp = await chatCompletionsFn(upstreamReq, {
-        signal: options.signal,
+        signal,
         bodyText,
-        onUpstreamStart: options.onUpstreamStart,
+        onUpstreamStart,
       });
     } finally {
-      options.releaseRequest?.();
+      bodyText = undefined;
+      chatReq = undefined;
+      upstreamReq = undefined;
+      releaseRequest?.();
     }
   } catch (e) {
-    const statusCode = isAbortLikeError(e) ? abortErrorStatusCode(options.abort?.reason) : 502;
+    const statusCode = isAbortLikeError(e) ? abortErrorStatusCode(abort?.reason) : 502;
     await onError(statusCode, e.message);
     return false;
   }
@@ -173,10 +188,10 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
     await onError(error.statusCode, error.message, error);
     return false;
   }
-  options.onUpstreamResponse?.(resp);
-  options.abort?.setTimeout(options.streamIdleTimeoutMs, "stream_idle_timeout");
+  onUpstreamResponse?.(resp);
+  abort?.setTimeout(streamIdleTimeoutMs, "stream_idle_timeout");
   const respId = `resp_${uid()}`;
-  let actualModel = chatReq.model || "unknown";
+  let actualModel = requestModel;
   let fullText = "";
   let messageItem = null;
   let nextOutputIndex = 0;
@@ -280,7 +295,7 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
 
   try {
     for await (const line of webStreamLines(resp, {
-      onChunk: () => options.abort?.setTimeout(options.streamIdleTimeoutMs, "stream_idle_timeout"),
+      onChunk: () => abort?.setTimeout(streamIdleTimeoutMs, "stream_idle_timeout"),
     })) {
       if (!line.startsWith("data: ")) continue;
       const data = line.slice(6).trim();
@@ -334,7 +349,7 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
       }
     }
   } catch (e) {
-    const statusCode = isAbortLikeError(e) ? abortErrorStatusCode(options.abort?.reason) : (e?.statusCode || 502);
+    const statusCode = isAbortLikeError(e) ? abortErrorStatusCode(abort?.reason) : (e?.statusCode || 502);
     await onError(statusCode, e?.message || "upstream stream error", e);
     return false;
   }

package/src/responses-handler.mjs

@@ -17,7 +17,12 @@ import { chatToResponses, forwardToChat, responsesBodyUsesCustomTools } from "./
 import { prepareResponsesChatPayload } from "./responses-chat-payload.mjs";
 import { prepareResponsesCompactionRequest } from "./responses-compaction.mjs";
 import { proxyCopilotResponses } from "./responses-proxy.mjs";
-import { prepareResponsesRequest, rememberResponseHistory } from "./responses-request.mjs";
+import { responseHistoryMaterializedBytes } from "./response-history.mjs";
+import {
+  dropMaterializedResponseHistory,
+  prepareResponsesRequest,
+  rememberResponseHistory,
+} from "./responses-request.mjs";
 import { status } from "./status.mjs";
 import { endStreamWithError } from "./stream-errors.mjs";
 import { safeUpstreamResponseHeaders } from "./upstream-headers.mjs";
@@ -81,12 +86,14 @@ export function createResponsesHandler(options) {
     getCachedModelEndpointsFn = getCachedModelEndpoints,
     imagePressure,
     openAIModelEnv,
+    requestBodyTimeoutMs,
     responsesPayloadOptions,
     responsesFn,
     streamHandshakeTimeoutMs,
     streamIdleTimeoutMs,
     upstreamTimeoutMs,
   } = options;
+  const now = options.now || Date.now;
 
   return async function handleResponses(req, res) {
     const abort = createRequestAbort(req, res);
@@ -94,10 +101,26 @@ export function createResponsesHandler(options) {
     let prepared = null;
     let imagePressureResult = null;
     let parsed = null;
-    const startUpstreamTimeout = () => abort.setTimeout(
-      parsed?.stream ? streamHandshakeTimeoutMs : upstreamTimeoutMs,
-      parsed?.stream ? "stream_handshake_timeout" : "upstream_timeout",
-    );
+    let upstreamPayloadReleased = false;
+    let prepareDeadline = Number.POSITIVE_INFINITY;
+    let upstreamStarted = false;
+    const assertPrepareActive = () => {
+      if (abort.signal.aborted) throw abort.signal.reason;
+      if (now() < prepareDeadline) return;
+      abort.abort("responses_prepare_timeout");
+      throw abort.signal.reason;
+    };
+    const startUpstreamTimeout = () => {
+      if (!upstreamStarted) {
+        assertPrepareActive();
+        upstreamStarted = true;
+      }
+      const streaming = prepared?.body?.stream === true;
+      abort.setTimeout(
+        streaming ? streamHandshakeTimeoutMs : upstreamTimeoutMs,
+        streaming ? "stream_handshake_timeout" : "upstream_timeout",
+      );
+    };
     const applyAdaptiveTimeout = (error) => {
       if (!["responses_prepare_timeout", "stream_handshake_timeout", "upstream_timeout"].includes(abort.reason)) {
         return error;
@@ -118,21 +141,47 @@ export function createResponsesHandler(options) {
       };
       return error;
     };
+    const markAdaptiveHttpTimeout = (statusCode) => {
+      if (statusCode !== 408) return false;
+      return imagePressure?.markTimeout?.(prepared?.historyRootId, {
+        eligible: imagePressureResult?.pressureEligible === true,
+      }) || false;
+    };
+    const releaseUpstreamPayload = (finalContext) => {
+      if (upstreamPayloadReleased) return;
+      upstreamPayloadReleased = true;
+      if (finalContext && finalContext !== prepared) dropMaterializedResponseHistory(finalContext);
+      dropMaterializedResponseHistory(prepared);
+      releaseRequest();
+    };
     try {
       releaseRequest = await acquireRequest(req, { signal: abort.signal });
-      parsed = await readJsonBody(req);
+      abort.setTimeout(requestBodyTimeoutMs, "request_body_timeout");
+      parsed = await readJsonBody(req, { admission: releaseRequest, signal: abort.signal });
+      prepareDeadline = now() + upstreamTimeoutMs;
       abort.setTimeout(upstreamTimeoutMs, "responses_prepare_timeout");
+      if (parsed.previous_response_id !== undefined && parsed.previous_response_id !== null) {
+        const historyBytes = responseHistoryMaterializedBytes(parsed.previous_response_id);
+        if (historyBytes > 0) {
+          await releaseRequest.reserveResponseHistory?.(historyBytes, { signal: abort.signal });
+        }
+        assertPrepareActive();
+      }
       prepared = prepareResponsesRequest(parsed, { mutate: true });
+      parsed = null;
+      assertPrepareActive();
       imagePressureResult = imagePressure?.apply?.(prepared) || null;
+      assertPrepareActive();
       if (imagePressureResult?.adapted) {
         console.warn(status("warn", `responses visual history mode=${imagePressureResult.mode} historical_images=${imagePressureResult.initialHistoricalImages}->${imagePressureResult.historicalImages} omitted=${imagePressureResult.imagesOmitted} bytes=${imagePressureResult.initialBodyBytes}->${imagePressureResult.bodyBytes}`));
       }
       prepared.surface = "responses";
-      const model = parsed.model || "unknown";
+      const model = prepared.body.model || "unknown";
+      const streaming = prepared.body.stream === true;
       const { requestedModel, upstreamModel } = resolveRequestModel(model, openAIModelEnv, autoReviewModelResolver);
       if (upstreamModel !== requestedModel) prepared.body.model = upstreamModel;
       const upstreamLog = upstreamModel === requestedModel ? "" : ` upstream_model=${upstreamModel}`;
-      console.log(status("info", `responses model=${requestedModel}${upstreamLog} stream=${!!parsed.stream}`));
+      console.log(status("info", `responses model=${requestedModel}${upstreamLog} stream=${streaming}`));
       const usesCustomTools = responsesBodyUsesCustomTools(prepared.body);
       const useNativeResponses = requestedModel === CODEX_AUTO_REVIEW_MODEL
         || isResponsesOnlyModel(upstreamModel, getCachedModelEndpointsFn)
@@ -143,18 +192,23 @@ export function createResponsesHandler(options) {
           signal: abort.signal,
           abort,
           onUpstreamStart: startUpstreamTimeout,
-          releaseRequest,
+          releaseRequest: releaseUpstreamPayload,
           streamIdleTimeoutMs,
         });
         if (result?.successful) imagePressure?.markSuccess?.(prepared.historyRootId);
+        else markAdaptiveHttpTimeout(result?.upstreamStatus);
       } else {
-        const chatPayload = await prepareResponsesChatPayload(prepared, {
+        let { chatReq, bodyText } = await prepareResponsesChatPayload(prepared, {
           payloadOptions: responsesPayloadOptions,
           signal: abort.signal,
-          stream: parsed.stream,
+          stream: streaming,
         });
-        const { chatReq, bodyText } = chatPayload;
-        if (parsed.stream) {
+        const releaseChatPayload = () => {
+          chatReq = undefined;
+          bodyText = undefined;
+          releaseUpstreamPayload();
+        };
+        if (streaming) {
           let streamResponseHeaders = null;
           const successful = await forwardToChat(chatReq, async (event, data) => {
             if (!res.headersSent) res.writeHead(200, {
@@ -170,6 +224,7 @@ export function createResponsesHandler(options) {
           }, () => { if (!res.writableEnded) res.end(); }, async (statusCode, errMsg, error, upstreamResponse) => {
             if (!res.headersSent) {
               if (upstreamResponse) {
+                markAdaptiveHttpTimeout(upstreamResponse.status);
                 sendUpstreamError(res, upstreamResponse, errMsg);
                 return;
               }
@@ -184,7 +239,7 @@ export function createResponsesHandler(options) {
             onUpstreamStart: startUpstreamTimeout,
             streamIdleTimeoutMs,
             chatCompletionsFn,
-            releaseRequest,
+            releaseRequest: releaseChatPayload,
             bodyText,
             onUpstreamResponse: (upstreamResponse) => {
               streamResponseHeaders = safeUpstreamResponseHeaders(upstreamResponse.headers, {
@@ -201,9 +256,10 @@ export function createResponsesHandler(options) {
               bodyText,
               onUpstreamStart: startUpstreamTimeout,
             });
-            releaseRequest();
+            releaseChatPayload();
             const data = await upstream.text();
             if (!upstream.ok) {
+              markAdaptiveHttpTimeout(upstream.status);
               sendUpstreamError(res, upstream, data);
               return;
             }
@@ -227,7 +283,7 @@ export function createResponsesHandler(options) {
       logRequestFailure("Responses", responseError, abort);
       sendJsonError(res, responseError, 502);
     } finally {
-      releaseRequest();
+      releaseUpstreamPayload();
       abort.cleanup();
     }
   };
@@ -239,20 +295,46 @@ export function createResponsesCompactHandler(options) {
     autoReviewModelResolver,
     imagePressure,
     openAIModelEnv,
+    requestBodyTimeoutMs,
     responsesCompactFn,
     upstreamTimeoutMs,
   } = options;
+  const now = options.now || Date.now;
 
   return async function handleResponsesCompact(req, res) {
     const abort = createRequestAbort(req, res);
     let releaseRequest = () => {};
     try {
       releaseRequest = await acquireRequest(req, { signal: abort.signal });
-      const parsed = await readJsonBody(req);
+      abort.setTimeout(requestBodyTimeoutMs, "request_body_timeout");
+      const parsed = await readJsonBody(req, { admission: releaseRequest, signal: abort.signal });
+      const prepareDeadline = now() + upstreamTimeoutMs;
+      const assertPrepareActive = () => {
+        if (abort.signal.aborted) throw abort.signal.reason;
+        if (now() < prepareDeadline) return;
+        abort.abort("responses_prepare_timeout");
+        throw abort.signal.reason;
+      };
+      let upstreamStarted = false;
+      const startUpstreamTimeout = () => {
+        if (!upstreamStarted) {
+          assertPrepareActive();
+          upstreamStarted = true;
+        }
+        abort.setTimeout(upstreamTimeoutMs, "upstream_timeout");
+      };
       abort.setTimeout(upstreamTimeoutMs, "responses_prepare_timeout");
+      if (parsed.previous_response_id !== undefined && parsed.previous_response_id !== null) {
+        const historyBytes = responseHistoryMaterializedBytes(parsed.previous_response_id);
+        if (historyBytes > 0) {
+          await releaseRequest.reserveResponseHistory?.(historyBytes, { signal: abort.signal });
+        }
+        assertPrepareActive();
+      }
       const prepared = prepareResponsesCompactionRequest(
         prepareResponsesRequest(parsed, { mutate: true }),
       );
+      assertPrepareActive();
       prepared.surface = "responses_compact";
       const model = parsed.model || "unknown";
       const { requestedModel, upstreamModel } = resolveRequestModel(model, openAIModelEnv, autoReviewModelResolver);
@@ -262,7 +344,7 @@ export function createResponsesCompactHandler(options) {
       const result = await proxyCopilotResponses(prepared, req, res, responsesCompactFn, {
         signal: abort.signal,
         abort,
-        onUpstreamStart: () => abort.setTimeout(upstreamTimeoutMs, "upstream_timeout"),
+        onUpstreamStart: startUpstreamTimeout,
         releaseRequest,
       });
       if (result?.compacted) imagePressure?.clear?.(prepared.historyRootId);

package/src/responses-image-pressure.mjs

@@ -32,8 +32,24 @@ export function applyResponsesImagePressure(reqContext, {
   const currentInputStart = Number.isFinite(reqContext?.currentInputStart)
     ? reqContext.currentInputStart
     : 0;
-  const initial = bodyPayload(body);
   const initialImages = responsesHistoricalImageStats(body?.input, currentInputStart);
+  if (initialImages.historicalImages === 0) {
+    return {
+      mode: "normal",
+      pressureEligible: false,
+      adapted: false,
+      imagesOmitted: 0,
+      initialBodyBytes: null,
+      bodyBytes: null,
+      initialHistoricalImages: 0,
+      historicalImages: 0,
+      currentImages: initialImages.currentImages,
+      overBudget: false,
+      overImageBudget: false,
+    };
+  }
+
+  const initial = bodyPayload(body);
   const pressureEligible = initialImages.historicalImages > 0 && (
     initialImages.historicalImages > policy.triggerHistoricalImages
       || initial.bodyBytes > policy.triggerBodyBytes
@@ -70,12 +86,13 @@ export function applyResponsesImagePressure(reqContext, {
     initialBodyText: initial.bodyText,
     initialBodyBytes: initial.bodyBytes,
   });
+  const { bodyText: _bodyText, ...trimmedResult } = trimmed;
   return {
     mode: recovery ? "recovery" : "pressure",
     pressureEligible: pressureEligible || recovery,
     initialBodyBytes: initial.bodyBytes,
     initialHistoricalImages: initialImages.historicalImages,
-    ...trimmed,
+    ...trimmedResult,
   };
 }
 

package/src/responses-proxy.mjs

@@ -120,13 +120,13 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
   try {
     opened = await openCopilotResponse(reqContext, upstream, options);
   } finally {
-    options.releaseRequest?.();
+    options.releaseRequest?.(opened?.reqContext);
   }
   const { resp, errorText } = opened;
   reqContext = opened.reqContext;
   if (errorText !== undefined) {
     sendUpstreamError(res, resp, errorText);
-    return { successful: false, compacted: false };
+    return { successful: false, compacted: false, upstreamStatus: resp.status };
   }
 
   if (reqContext.body.stream) {

package/src/responses-request.mjs

@@ -245,6 +245,14 @@ export function prepareResponsesRequest(reqBody, { mutate = false } = {}) {
   };
 }
 
+export function dropMaterializedResponseHistory(reqContext) {
+  if (!reqContext?.historyParentId || !Array.isArray(reqContext.historyInputItems)) return false;
+  reqContext.body = { ...reqContext.body, input: reqContext.historyInputItems };
+  reqContext.inputItems = reqContext.historyInputItems;
+  reqContext.currentInputStart = 0;
+  return true;
+}
+
 export function rememberResponseHistory(reqContext, responseJson) {
   if (!responseJson?.id || !Array.isArray(reqContext?.historyInputItems || reqContext?.inputItems)) return;
   const compacted = isSuccessfulCompactionResponse(responseJson);

package/src/runtime-config.mjs

@@ -2,6 +2,7 @@ export const RUNTIME_DEFAULTS = Object.freeze({
   upstreamTimeoutMs: 120 * 1000,
   streamHandshakeTimeoutMs: 120 * 1000,
   streamIdleTimeoutMs: 120 * 1000,
+  requestBodyTimeoutMs: 120 * 1000,
   maxSseBufferBytes: 8 * 1024 * 1024,
   maxBodyBytes: 64 * 1024 * 1024,
   maxDecodedBodyBytes: 128 * 1024 * 1024,
@@ -24,6 +25,7 @@ export function loadRuntimeConfig(env = process.env) {
     upstreamTimeoutMs: parsePositiveInteger(env.CCDX_UPSTREAM_TIMEOUT_MS, RUNTIME_DEFAULTS.upstreamTimeoutMs),
     streamHandshakeTimeoutMs: parsePositiveInteger(env.CCDX_STREAM_HANDSHAKE_TIMEOUT_MS, RUNTIME_DEFAULTS.streamHandshakeTimeoutMs),
     streamIdleTimeoutMs: parsePositiveInteger(env.CCDX_STREAM_IDLE_TIMEOUT_MS, RUNTIME_DEFAULTS.streamIdleTimeoutMs),
+    requestBodyTimeoutMs: parsePositiveInteger(env.CCDX_REQUEST_BODY_TIMEOUT_MS, RUNTIME_DEFAULTS.requestBodyTimeoutMs),
     maxSseBufferBytes: parsePositiveInteger(env.CCDX_MAX_SSE_BUFFER_BYTES, RUNTIME_DEFAULTS.maxSseBufferBytes),
     maxBodyBytes: parsePositiveInteger(env.CCDX_MAX_BODY_BYTES, RUNTIME_DEFAULTS.maxBodyBytes),
     maxDecodedBodyBytes: parsePositiveInteger(env.CCDX_MAX_DECODED_BODY_BYTES, RUNTIME_DEFAULTS.maxDecodedBodyBytes),