codex-copilot-dx 0.6.2 → 0.6.4

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";
@@ -79,53 +84,133 @@ export function createResponsesHandler(options) {
     autoReviewModelResolver,
     chatCompletionsFn,
     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);
     let releaseRequest = () => {};
-    try {
-      releaseRequest = await acquireRequest(req, { signal: abort.signal });
-      const parsed = await readJsonBody(req);
+    let prepared = null;
+    let imagePressureResult = null;
+    let parsed = null;
+    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(
-        parsed.stream ? streamHandshakeTimeoutMs : upstreamTimeoutMs,
-        parsed.stream ? "stream_handshake_timeout" : "upstream_timeout",
+        streaming ? streamHandshakeTimeoutMs : upstreamTimeoutMs,
+        streaming ? "stream_handshake_timeout" : "upstream_timeout",
       );
-      const prepared = prepareResponsesRequest(parsed, { mutate: true });
+    };
+    const applyAdaptiveTimeout = (error) => {
+      if (!["responses_prepare_timeout", "stream_handshake_timeout", "upstream_timeout"].includes(abort.reason)) {
+        return error;
+      }
+      const activated = imagePressure?.markTimeout?.(prepared?.historyRootId, {
+        eligible: imagePressureResult?.pressureEligible === true,
+      });
+      if (!activated) return error;
+      const message = "Responses timed out while processing a large visual history. Retry the request; ccdx will keep fewer earlier images automatically. Restart is not required.";
+      error.statusCode = 504;
+      error.jsonBody = {
+        error: {
+          message,
+          type: "timeout_error",
+          code: "ccdx_visual_history_timeout",
+          retryable: true,
+        },
+      };
+      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 });
+      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)
         || (usesCustomTools && cachedModelSupportsResponses(upstreamModel, getCachedModelEndpointsFn));
       if (usesCustomTools && !useNativeResponses) throw unsupportedCustomToolsError(upstreamModel);
       if (useNativeResponses) {
-        await proxyCopilotResponses(prepared, req, res, responsesFn, {
+        const result = await proxyCopilotResponses(prepared, req, res, responsesFn, {
           signal: abort.signal,
           abort,
-          releaseRequest,
+          onUpstreamStart: startUpstreamTimeout,
+          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;
-          await forwardToChat(chatReq, async (event, data) => {
+          const successful = await forwardToChat(chatReq, async (event, data) => {
             if (!res.headersSent) res.writeHead(200, {
               ...streamResponseHeaders,
               "Cache-Control": "no-cache",
@@ -139,10 +224,11 @@ 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;
               }
-              const responseError = error || Object.assign(new Error(errMsg), { statusCode });
+              const responseError = applyAdaptiveTimeout(error || Object.assign(new Error(errMsg), { statusCode }));
               sendJsonError(res, responseError, statusCode || 500);
               return;
             }
@@ -150,9 +236,10 @@ export function createResponsesHandler(options) {
           }, {
             signal: abort.signal,
             abort,
+            onUpstreamStart: startUpstreamTimeout,
             streamIdleTimeoutMs,
             chatCompletionsFn,
-            releaseRequest,
+            releaseRequest: releaseChatPayload,
             bodyText,
             onUpstreamResponse: (upstreamResponse) => {
               streamResponseHeaders = safeUpstreamResponseHeaders(upstreamResponse.headers, {
@@ -160,33 +247,43 @@ export function createResponsesHandler(options) {
               });
             },
           });
+          if (successful) imagePressure?.markSuccess?.(prepared.historyRootId);
         } else {
           try {
-            const upstream = await chatCompletionsFn(chatReq, { signal: abort.signal, bodyText });
-            releaseRequest();
+            startUpstreamTimeout();
+            const upstream = await chatCompletionsFn(chatReq, {
+              signal: abort.signal,
+              bodyText,
+              onUpstreamStart: startUpstreamTimeout,
+            });
+            releaseChatPayload();
             const data = await upstream.text();
             if (!upstream.ok) {
+              markAdaptiveHttpTimeout(upstream.status);
               sendUpstreamError(res, upstream, data);
               return;
             }
             const response = chatToResponses(JSON.parse(data), model);
             rememberResponseHistory(prepared, response);
+            imagePressure?.markSuccess?.(prepared.historyRootId);
             recordResponsesUsage({ surface: prepared.surface, mode: "json", model, response, event: response });
             res.writeHead(200, safeUpstreamResponseHeaders(upstream.headers, {
               contentType: "application/json",
             }));
             res.end(JSON.stringify(response));
           } catch (error) {
-            logRequestFailure("Responses", error, abort);
-            sendJsonError(res, error, 502);
+            const responseError = applyAdaptiveTimeout(error);
+            logRequestFailure("Responses", responseError, abort);
+            sendJsonError(res, responseError, 502);
           }
         }
       }
     } catch (error) {
-      logRequestFailure("Responses", error, abort);
-      sendJsonError(res, error, 502);
+      const responseError = applyAdaptiveTimeout(error);
+      logRequestFailure("Responses", responseError, abort);
+      sendJsonError(res, responseError, 502);
     } finally {
-      releaseRequest();
+      releaseUpstreamPayload();
       abort.cleanup();
     }
   };
@@ -196,32 +293,61 @@ export function createResponsesCompactHandler(options) {
   const {
     acquireRequest,
     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(upstreamTimeoutMs, "upstream_timeout");
+      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);
       if (upstreamModel !== requestedModel) prepared.body.model = upstreamModel;
       const upstreamLog = upstreamModel === requestedModel ? "" : ` upstream_model=${upstreamModel}`;
       console.log(status("info", `responses compact model=${requestedModel}${upstreamLog} stream=false`));
-      await proxyCopilotResponses(prepared, req, res, responsesCompactFn, {
+      const result = await proxyCopilotResponses(prepared, req, res, responsesCompactFn, {
         signal: abort.signal,
         abort,
+        onUpstreamStart: startUpstreamTimeout,
         releaseRequest,
       });
+      if (result?.compacted) imagePressure?.clear?.(prepared.historyRootId);
     } catch (error) {
       logRequestFailure("Responses compact", error, abort);
       sendJsonError(res, error, 502);

package/src/responses-image-pressure.mjs

@@ -0,0 +1,180 @@
+import {
+  responsesHistoricalImageStats,
+  trimResponsesHistoricalImages,
+} from "./responses-byte-budget.mjs";
+
+const MIB = 1024 * 1024;
+
+export const DEFAULT_RESPONSES_IMAGE_PRESSURE_POLICY = Object.freeze({
+  triggerHistoricalImages: 24,
+  triggerBodyBytes: 18 * MIB,
+  pressureHistoricalImages: 16,
+  pressureBodyBytes: 16 * MIB,
+  recoveryHistoricalImages: 8,
+  recoveryBodyBytes: 10 * MIB,
+});
+
+function normalizedPolicy(policy = {}) {
+  return { ...DEFAULT_RESPONSES_IMAGE_PRESSURE_POLICY, ...policy };
+}
+
+function bodyPayload(body) {
+  const bodyText = JSON.stringify(body);
+  return { bodyText, bodyBytes: Buffer.byteLength(bodyText) };
+}
+
+export function applyResponsesImagePressure(reqContext, {
+  mode = "normal",
+  policy: policyOverrides,
+} = {}) {
+  const policy = normalizedPolicy(policyOverrides);
+  const body = reqContext?.body;
+  const currentInputStart = Number.isFinite(reqContext?.currentInputStart)
+    ? reqContext.currentInputStart
+    : 0;
+  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
+  );
+  const recovery = mode === "recovery";
+  const maxHistoricalImages = recovery
+    ? policy.recoveryHistoricalImages
+    : policy.pressureHistoricalImages;
+  const targetBytes = recovery ? policy.recoveryBodyBytes : policy.pressureBodyBytes;
+  const shouldAdapt = initialImages.historicalImages > 0 && (recovery
+    ? initialImages.historicalImages > maxHistoricalImages || initial.bodyBytes > targetBytes
+    : pressureEligible);
+
+  if (!shouldAdapt) {
+    return {
+      mode: "normal",
+      pressureEligible,
+      adapted: false,
+      imagesOmitted: 0,
+      initialBodyBytes: initial.bodyBytes,
+      bodyBytes: initial.bodyBytes,
+      initialHistoricalImages: initialImages.historicalImages,
+      historicalImages: initialImages.historicalImages,
+      currentImages: initialImages.currentImages,
+      overBudget: false,
+      overImageBudget: false,
+    };
+  }
+
+  const trimmed = trimResponsesHistoricalImages(body, {
+    currentInputStart,
+    maxHistoricalImages,
+    targetBytes,
+    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,
+    ...trimmedResult,
+  };
+}
+
+export function createResponsesImagePressureController({
+  now = Date.now,
+  maxEntries = 256,
+  recoveryTtlMs = 10 * 60 * 1000,
+  successesToClear = 2,
+  policy: policyOverrides,
+} = {}) {
+  const policy = normalizedPolicy(policyOverrides);
+  const recovery = new Map();
+  const counters = {
+    adaptedRequests: 0,
+    imagesOmitted: 0,
+    recoveryActivations: 0,
+    timeoutsRecorded: 0,
+  };
+
+  const prune = () => {
+    const timestamp = now();
+    for (const [rootId, state] of recovery) {
+      if (state.expiresAt <= timestamp) recovery.delete(rootId);
+    }
+    while (recovery.size > maxEntries) recovery.delete(recovery.keys().next().value);
+  };
+
+  const modeFor = (rootId) => {
+    prune();
+    return rootId && recovery.has(rootId) ? "recovery" : "normal";
+  };
+
+  return Object.freeze({
+    apply(reqContext) {
+      const result = applyResponsesImagePressure(reqContext, {
+        mode: modeFor(reqContext?.historyRootId),
+        policy,
+      });
+      if (result.adapted) {
+        counters.adaptedRequests += 1;
+        counters.imagesOmitted += result.imagesOmitted;
+      }
+      return result;
+    },
+    markTimeout(rootId, { eligible = false } = {}) {
+      if (!rootId || !eligible) return false;
+      prune();
+      const existing = recovery.get(rootId);
+      recovery.delete(rootId);
+      recovery.set(rootId, { expiresAt: now() + recoveryTtlMs, successes: 0 });
+      counters.timeoutsRecorded += 1;
+      if (!existing) counters.recoveryActivations += 1;
+      prune();
+      return true;
+    },
+    markSuccess(rootId) {
+      if (!rootId) return false;
+      prune();
+      const state = recovery.get(rootId);
+      if (!state) return false;
+      state.successes += 1;
+      if (state.successes >= successesToClear) {
+        recovery.delete(rootId);
+        return true;
+      }
+      return false;
+    },
+    clear(rootId) {
+      return rootId ? recovery.delete(rootId) : false;
+    },
+    snapshot() {
+      prune();
+      return {
+        active_recovery_trees: recovery.size,
+        adapted_requests: counters.adaptedRequests,
+        historical_images_omitted: counters.imagesOmitted,
+        recovery_activations: counters.recoveryActivations,
+        timeouts_recorded: counters.timeoutsRecorded,
+        recovery_ttl_ms: recoveryTtlMs,
+        pressure_image_limit: policy.pressureHistoricalImages,
+        recovery_image_limit: policy.recoveryHistoricalImages,
+      };
+    },
+  });
+}

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;
+    return { successful: false, compacted: false, upstreamStatus: resp.status };
   }
 
   if (reqContext.body.stream) {
@@ -158,7 +158,7 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
           if (!streamState.sawTerminal) throw incompleteUpstreamStream("a terminal Responses event");
           storeCompletedResponse(reqContext, streamState.completed);
           res.end();
-          return;
+          return { successful: Boolean(streamState.completed), compacted: false };
         }
         options.abort?.setTimeout(options.streamIdleTimeoutMs, "stream_idle_timeout");
         buffer += decoder.decode(value, { stream: true });
@@ -170,12 +170,13 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
         if (streamState.sawTerminal) {
           storeCompletedResponse(reqContext, streamState.completed);
           res.end();
-          return;
+          return { successful: Boolean(streamState.completed), compacted: false };
         }
       }
     } catch (e) {
       logRequestFailure("Responses", e, options.abort);
       await endStreamWithError(res, "responses", e, options.abort);
+      return { successful: false, compacted: false };
     } finally {
       await reader.cancel().catch(() => {});
       reader.releaseLock();
@@ -199,7 +200,7 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
         contentType: "application/json",
       }));
       res.end(JSON.stringify(response));
-      return;
+      return { successful: true, compacted: true };
     }
     res.writeHead(resp.status, safeUpstreamResponseHeaders(resp.headers, {
       contentType: "application/json",
@@ -216,7 +217,9 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
           response,
           event: response,
         });
+        return { successful: true, compacted: false };
       } catch {}
     }
+    return { successful: false, compacted: false };
   }
 }

package/src/responses-request.mjs

@@ -1,7 +1,11 @@
 import { responses as copilotResponses } from "./copilot.mjs";
 import { httpError } from "./http-transport.mjs";
 import { debugLog } from "./log.mjs";
-import { materializeResponseHistory, rememberResponseHistoryNode } from "./response-history.mjs";
+import {
+  materializeResponseHistory,
+  rememberResponseHistoryNode,
+  responseHistoryRootId,
+} from "./response-history.mjs";
 import { enforceResponsesImageLimit } from "./responses-image-limit.mjs";
 import { status } from "./status.mjs";
 
@@ -157,6 +161,7 @@ export async function openCopilotResponse(reqContext, upstream = copilotResponse
     const resp = await upstream(reqContext.body, {
       signal: options.signal,
       currentInputStart: reqContext.currentInputStart,
+      onUpstreamStart: options.onUpstreamStart,
       payloadPrepared,
     });
     payloadPrepared = true;
@@ -198,9 +203,11 @@ export function prepareResponsesRequest(reqBody, { mutate = false } = {}) {
   );
   const previousId = body.previous_response_id;
   let historyItems = [];
+  let historyRootId = null;
 
   if (previousId !== undefined && previousId !== null) {
     historyItems = materializeResponseHistory(previousId);
+    historyRootId = responseHistoryRootId(previousId);
     body.input = [...historyItems, ...currentInputItems];
   } else {
     body.input = currentInputItems;
@@ -232,11 +239,20 @@ export function prepareResponsesRequest(reqBody, { mutate = false } = {}) {
     inputItems: body.input,
     currentInputStart: retainedCurrentInputStart < 0 ? body.input.length : retainedCurrentInputStart,
     historyParentId: previousId ?? null,
+    historyRootId,
     historyInputItems,
     takeHistoryOwnership: mutate,
   };
 }
 
+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),