codex-copilot-dx 0.6.3 → 0.6.4

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
@@ -330,9 +331,10 @@ 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 |

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.4",
   "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);

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/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/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),