codex-copilot-dx 0.6.15 → 0.6.19

package/src/response-history.mjs

@@ -71,6 +71,7 @@ function jsonByteLength(value, seen = new Set()) {
 const histories = new Map();
 const childrenById = new Map();
 const treeLru = new Map();
+const pinnedTrees = new Map();
 const evictedIds = new Set();
 let totalBytes = 0;
 const HISTORY_RUNTIME_CONFIG = loadRuntimeConfig();
@@ -88,6 +89,21 @@ function touchTree(rootId) {
   treeLru.set(rootId, true);
 }
 
+function pinTree(rootId) {
+  if (!rootId) return;
+  pinnedTrees.set(rootId, (pinnedTrees.get(rootId) || 0) + 1);
+}
+
+function unpinTree(rootId) {
+  const count = pinnedTrees.get(rootId) || 0;
+  if (count <= 1) pinnedTrees.delete(rootId);
+  else pinnedTrees.set(rootId, count - 1);
+}
+
+function treeIsPinned(rootId) {
+  return (pinnedTrees.get(rootId) || 0) > 0;
+}
+
 function linkChild(parentId, id) {
   if (!parentId) return;
   let children = childrenById.get(parentId);
@@ -148,18 +164,50 @@ function assignSubtreeRoot(id, rootId) {
   }
 }
 
-function enforceLimits() {
-  while (histories.size > maxEntries || totalBytes > maxBytes) {
-    const oldestRootId = treeLru.keys().next().value;
-    if (!oldestRootId) break;
-    removeSubtree(oldestRootId);
+function subtreeUsage(rootId) {
+  const pending = [rootId];
+  const seen = new Set();
+  let bytes = 0;
+  let entries = 0;
+  while (pending.length) {
+    const id = pending.pop();
+    if (seen.has(id)) continue;
+    seen.add(id);
+    const entry = histories.get(id);
+    if (entry) {
+      entries += 1;
+      bytes += entry.bytes;
+    }
+    const children = childrenById.get(id);
+    if (children) pending.push(...children);
+  }
+  return { bytes, entries };
+}
+
+function makeRoomFor({ additionalBytes, additionalEntries, protectedRoots }) {
+  let projectedBytes = totalBytes + additionalBytes;
+  let projectedEntries = histories.size + additionalEntries;
+  if (projectedEntries <= maxEntries && projectedBytes <= maxBytes) return true;
+
+  const candidates = [];
+  for (const rootId of treeLru.keys()) {
+    if (protectedRoots.has(rootId) || treeIsPinned(rootId)) continue;
+    const usage = subtreeUsage(rootId);
+    candidates.push(rootId);
+    projectedBytes -= usage.bytes;
+    projectedEntries -= usage.entries;
+    if (projectedEntries <= maxEntries && projectedBytes <= maxBytes) break;
   }
+  if (projectedEntries > maxEntries || projectedBytes > maxBytes) return false;
+  for (const rootId of candidates) removeSubtree(rootId);
+  return true;
 }
 
 export function clearResponseHistoryForTests() {
   histories.clear();
   childrenById.clear();
   treeLru.clear();
+  pinnedTrees.clear();
   evictedIds.clear();
   totalBytes = 0;
   maxBytes = DEFAULT_MAX_BYTES;
@@ -202,6 +250,50 @@ export function responseHistoryMaterializedBytes(responseId) {
   return chain.reduce((bytes, entry) => bytes + entry.bytes, 0);
 }
 
+export function acquireResponseHistorySnapshot(responseId, { assertActive, signal } = {}) {
+  assertActive?.();
+  if (signal?.aborted) throw signal.reason || new DOMException("The operation was aborted", "AbortError");
+  const { chain, rootId } = responseHistoryChain(responseId);
+  const entries = chain.slice().reverse();
+  const bytes = chain.reduce((total, entry) => total + entry.bytes, 0);
+  pinTree(rootId);
+
+  let released = false;
+  const release = () => {
+    if (released) return;
+    released = true;
+    signal?.removeEventListener("abort", release);
+    unpinTree(rootId);
+  };
+  signal?.addEventListener("abort", release, { once: true });
+
+  return Object.freeze({
+    responseId,
+    rootId,
+    bytes,
+    materialize({ assertActive: assertSnapshotActive, routeMetadata } = {}) {
+      assertSnapshotActive?.();
+      if (released) throw new Error("Response history snapshot has been released");
+      const items = [];
+      for (let index = 0; index < entries.length; index += 1) {
+        if ((index & 63) === 0) assertSnapshotActive?.();
+        const entry = entries[index];
+        routeMetadata?.push({
+          affinity: entry.routeAffinity || null,
+          hasOpaque: entry.hasOpaque === true,
+        });
+        items.push(...entry.inputItems, ...entry.outputItems);
+      }
+      assertSnapshotActive?.();
+      const materialized = cloneJson(items);
+      assertSnapshotActive?.();
+      touchTree(rootId);
+      return materialized;
+    },
+    release,
+  });
+}
+
 export function materializeResponseHistory(responseId, { assertActive, routeMetadata } = {}) {
   assertActive?.();
   const { chain, rootId } = responseHistoryChain(responseId);
@@ -231,7 +323,13 @@ export function rememberResponseHistoryNode({
   routeAffinity = null,
   takeOwnership = false,
 }) {
-  if (!id || !Array.isArray(inputItems)) return;
+  if (!id || !Array.isArray(inputItems)) return false;
+  const existing = histories.get(id);
+  const parentEntry = parentId ? histories.get(parentId) : null;
+  if (parentId && !parentEntry) {
+    if (!existing) rememberEvictedId(id);
+    return false;
+  }
   clearResponsesToolOutputPartsCache(inputItems);
   clearResponsesToolOutputPartsCache(outputItems);
   const historyValue = routeAffinity
@@ -239,13 +337,11 @@ export function rememberResponseHistoryNode({
     : [inputItems, outputItems];
   const bytes = jsonByteLength(historyValue);
   if (bytes > maxBytes) {
-    if (histories.has(id)) removeSubtree(id);
-    rememberEvictedId(id);
-    return;
+    if (!existing) rememberEvictedId(id);
+    else if (!treeIsPinned(existing.rootId)) removeSubtree(id);
+    return false;
   }
-  const existing = histories.get(id);
-  const parentEntry = parentId ? histories.get(parentId) : null;
-  const rootId = parentEntry?.rootId || (parentId ? existing?.rootId : id) || id;
+  const rootId = parentEntry?.rootId || id;
   const entry = {
     parentId: parentId || null,
     rootId,
@@ -256,6 +352,19 @@ export function rememberResponseHistoryNode({
     bytes,
   };
   const oldRootId = existing?.rootId;
+  const protectedRoots = new Set([rootId]);
+  if (oldRootId) protectedRoots.add(oldRootId);
+  if (!makeRoomFor({
+    additionalBytes: bytes - (existing?.bytes || 0),
+    additionalEntries: existing ? 0 : 1,
+    protectedRoots,
+  })) {
+    if (!existing) {
+      if (parentEntry && !treeIsPinned(rootId)) removeSubtree(rootId);
+      rememberEvictedId(id);
+    }
+    return false;
+  }
   if (existing) {
     totalBytes -= existing.bytes;
     unlinkChild(existing.parentId, id);
@@ -270,5 +379,5 @@ export function rememberResponseHistoryNode({
   totalBytes += entry.bytes;
   evictedIds.delete(id);
   touchTree(rootId);
-  enforceLimits();
+  return true;
 }

package/src/responses-bridge.mjs

@@ -1,7 +1,12 @@
 import { randomUUID } from "node:crypto";
 import { chatCompletions } from "./copilot.mjs";
 import { webStreamLines } from "./stream.mjs";
-import { abortErrorStatusCode, isAbortLikeError } from "./http-transport.mjs";
+import {
+  abortErrorStatusCode,
+  isAbortLikeError,
+  MAX_UPSTREAM_ERROR_BODY_BYTES,
+  readBoundedResponseText,
+} from "./http-transport.mjs";
 import {
   incompleteUpstreamStream,
   invalidUpstreamStream,
@@ -216,7 +221,10 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
     return false;
   }
   if (!resp.ok) {
-    await onError(resp.status, await resp.text(), undefined, resp);
+    await onError(resp.status, await readBoundedResponseText(resp, {
+      maxBytes: MAX_UPSTREAM_ERROR_BODY_BYTES,
+      label: "Copilot Chat error body",
+    }), undefined, resp);
     return false;
   }
   try {
@@ -235,6 +243,13 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
   let usage = { input_tokens: 0, output_tokens: 0, total_tokens: 0 };
   const toolCalls = new Map();
   const toolArgumentGuard = new ToolArgumentDeltaGuard();
+  const downstreamClosed = Symbol("downstream-closed");
+  const configuredEmitEvent = emitEvent;
+  emitEvent = async (...args) => {
+    const written = await configuredEmitEvent(...args);
+    if (written === false) throw downstreamClosed;
+    return written;
+  };
   let performanceOutputSeen = false;
   const markPerformanceOutput = () => {
     if (performanceOutputSeen) return;
@@ -242,8 +257,6 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
     markFirstOutput();
   };
 
-  await emitEvent("response.created", { response: { id: respId, object: "response", status: "in_progress", model: actualModel, output: [] } });
-
   const ensureMessageItem = async () => {
     if (messageItem) return messageItem;
     messageItem = { id: `msg_${uid()}`, outputIndex: nextOutputIndex++ };
@@ -331,6 +344,7 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
   };
 
   try {
+    await emitEvent("response.created", { response: { id: respId, object: "response", status: "in_progress", model: actualModel, output: [] } });
     for await (const line of webStreamLines(resp, {
       onChunk: () => abort?.setTimeout(streamIdleTimeoutMs, "stream_idle_timeout"),
     })) {
@@ -386,6 +400,10 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
       }
     }
   } catch (e) {
+    if (e === downstreamClosed) {
+      await resp.body?.cancel?.().catch?.(() => {});
+      return false;
+    }
     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

@@ -3,7 +3,10 @@ import { applyCopilotResponsesRequestPolicies } from "./copilot-responses-policy
 import {
   createRequestAbort,
   logRequestFailure,
+  MAX_UPSTREAM_CHAT_SUCCESS_BODY_BYTES,
+  MAX_UPSTREAM_ERROR_BODY_BYTES,
   readJsonBody,
+  readBoundedResponseText,
   sendJsonError,
   sendUpstreamError,
   writeOrDrain,
@@ -12,6 +15,7 @@ import {
   CODEX_AUTO_REVIEW_MODEL,
   modelIsResponsesOnly,
   modelSupportsChatCompletions,
+  resolveCopilotPriorityTierModel,
   resolveOpenAIModel,
 } from "./models.mjs";
 import { chatToResponses, forwardToChat, responsesBodyUsesCustomTools } from "./responses-bridge.mjs";
@@ -19,7 +23,7 @@ import { prepareResponsesChatPayload } from "./responses-chat-payload.mjs";
 import { prepareResponsesCompactionRequest } from "./responses-compaction.mjs";
 import { clearResponsesToolOutputPartsCache } from "./responses-content.mjs";
 import { proxyCopilotResponses } from "./responses-proxy.mjs";
-import { responseHistoryMaterializedBytes } from "./response-history.mjs";
+import { acquireResponseHistorySnapshot } from "./response-history.mjs";
 import {
   applyResponseHistoryRoutePlan,
   dropMaterializedResponseHistory,
@@ -90,6 +94,7 @@ export function createResponsesHandler(options) {
     chatCompletionsFn,
     getCachedModelEndpointsFn = getCachedModelEndpoints,
     imagePressure,
+    modelRegistry,
     openAIModelEnv,
     requestBodyTimeoutMs,
     responsesPayloadOptions,
@@ -105,10 +110,15 @@ export function createResponsesHandler(options) {
     let releaseRequest = () => {};
     let prepared = null;
     let imagePressureResult = null;
+    let historySnapshot = null;
     let parsed = null;
     let upstreamPayloadReleased = false;
     let activeDeadline = Number.POSITIVE_INFINITY;
     let activeTimeoutReason = "responses_prepare_timeout";
+    const releaseHistorySnapshot = () => {
+      historySnapshot?.release();
+      historySnapshot = null;
+    };
     const assertPrepareActive = () => {
       if (abort.signal.aborted) throw abort.signal.reason;
       if (now() < activeDeadline) return;
@@ -127,7 +137,7 @@ export function createResponsesHandler(options) {
       if (!["responses_prepare_timeout", "stream_handshake_timeout", "upstream_timeout"].includes(abort.reason)) {
         return error;
       }
-      const activated = imagePressure?.markTimeout?.(prepared?.historyRootId, {
+      const activated = imagePressure?.markTimeout?.(responseHistoryPressureRootId(prepared), {
         eligible: imagePressureResult?.pressureEligible === true,
       });
       if (!activated) return error;
@@ -152,6 +162,7 @@ export function createResponsesHandler(options) {
     const releaseUpstreamPayload = (finalContext) => {
       if (upstreamPayloadReleased) return;
       upstreamPayloadReleased = true;
+      if (finalContext?.historyParentId === null) releaseHistorySnapshot();
       clearResponsesToolOutputPartsCache(prepared?.body?.input);
       clearResponsesToolOutputPartsCache(prepared?.historyInputItems);
       if (finalContext && finalContext !== prepared) {
@@ -170,15 +181,19 @@ export function createResponsesHandler(options) {
       activeTimeoutReason = "responses_prepare_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 });
+        historySnapshot = acquireResponseHistorySnapshot(parsed.previous_response_id, {
+          assertActive: assertPrepareActive,
+          signal: abort.signal,
+        });
+        if (historySnapshot.bytes > 0) {
+          await releaseRequest.reserveResponseHistory?.(historySnapshot.bytes, { signal: abort.signal });
         }
         assertPrepareActive();
       }
       prepared = prepareResponsesRequest(parsed, {
         assertActive: assertPrepareActive,
         copilotBoundary: false,
+        historySnapshot,
         mutate: true,
       });
       parsed = null;
@@ -191,12 +206,22 @@ export function createResponsesHandler(options) {
       prepared.surface = "responses";
       const model = prepared.body.model || "unknown";
       const streaming = prepared.body.stream === true;
-      const { requestedModel, upstreamModel } = resolveRequestModel(model, openAIModelEnv, autoReviewModelResolver);
+      const resolvedModel = resolveRequestModel(model, openAIModelEnv, autoReviewModelResolver);
+      const { requestedModel } = resolvedModel;
+      let { upstreamModel } = resolvedModel;
+      const priorityTierModel = requestedModel === upstreamModel
+        ? resolveCopilotPriorityTierModel(upstreamModel, prepared.body.service_tier, modelRegistry?.models)
+        : null;
+      if (priorityTierModel) {
+        upstreamModel = priorityTierModel;
+        delete prepared.body.service_tier;
+      }
       if (upstreamModel !== requestedModel) prepared.body.model = upstreamModel;
       const upstreamLog = upstreamModel === requestedModel ? "" : ` upstream_model=${upstreamModel}`;
       console.log(status("info", `responses model=${requestedModel}${upstreamLog} stream=${streaming}`));
       const usesCustomTools = responsesBodyUsesCustomTools(prepared.body);
-      const useNativeResponses = requestedModel === CODEX_AUTO_REVIEW_MODEL
+      const useNativeResponses = Boolean(priorityTierModel)
+        || requestedModel === CODEX_AUTO_REVIEW_MODEL
         || isResponsesOnlyModel(upstreamModel, getCachedModelEndpointsFn)
         || (usesCustomTools && cachedModelSupportsResponses(upstreamModel, getCachedModelEndpointsFn));
       if (usesCustomTools && !useNativeResponses) throw unsupportedCustomToolsError(upstreamModel);
@@ -209,6 +234,7 @@ export function createResponsesHandler(options) {
         surface: "responses",
       });
       prepared = applyResponseHistoryRoutePlan(prepared, routePlan);
+      if (prepared.historyParentId === null) releaseHistorySnapshot();
       applyCopilotResponsesRequestPolicies(prepared.body);
       if (routePlan.protocol === "openai-responses") {
         const result = await proxyCopilotResponses(prepared, req, res, responsesFn, {
@@ -241,11 +267,13 @@ export function createResponsesHandler(options) {
               "Cache-Control": "no-cache",
               Connection: "keep-alive",
             });
-            await writeOrDrain(res, `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+            const written = await writeOrDrain(res, `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+            if (!written) return false;
             if (event === "response.completed") {
               rememberResponseHistory(prepared, data.response);
               recordResponsesUsage({ surface: prepared.surface, mode: "stream", model, response: data.response, event: data });
             }
+            return true;
           }, () => { if (!res.writableEnded) res.end(); }, async (statusCode, errMsg, error, upstreamResponse) => {
             if (!res.headersSent) {
               if (upstreamResponse) {
@@ -282,7 +310,16 @@ export function createResponsesHandler(options) {
               onUpstreamStart: startUpstreamTimeout,
             });
             releaseChatPayload();
-            const data = await upstream.text();
+            const data = upstream.ok
+              ? await readBoundedResponseText(upstream, {
+                maxBytes: MAX_UPSTREAM_CHAT_SUCCESS_BODY_BYTES,
+                label: "Copilot Chat success body",
+                signal: abort.signal,
+              })
+              : await readBoundedResponseText(upstream, {
+                maxBytes: MAX_UPSTREAM_ERROR_BODY_BYTES,
+                label: "Copilot Chat error body",
+              });
             if (!upstream.ok) {
               markAdaptiveHttpTimeout(upstream.status);
               sendUpstreamError(res, upstream, data);
@@ -311,6 +348,7 @@ export function createResponsesHandler(options) {
       sendJsonError(res, responseError, 502);
     } finally {
       releaseUpstreamPayload();
+      releaseHistorySnapshot();
       abort.cleanup();
     }
   };
@@ -321,6 +359,7 @@ export function createResponsesCompactHandler(options) {
     acquireRequest,
     autoReviewModelResolver,
     imagePressure,
+    modelRegistry,
     openAIModelEnv,
     requestBodyTimeoutMs,
     responsesCompactFn,
@@ -332,7 +371,47 @@ export function createResponsesCompactHandler(options) {
     const abort = createRequestAbort(req, res);
     let releaseRequest = () => {};
     let prepared = null;
+    let imagePressureResult = null;
+    let historySnapshot = null;
     let upstreamPayloadReleased = false;
+    let activeDeadline = Number.POSITIVE_INFINITY;
+    let activeTimeoutReason = "responses_prepare_timeout";
+    const releaseHistorySnapshot = () => {
+      historySnapshot?.release();
+      historySnapshot = null;
+    };
+    const assertPrepareActive = () => {
+      if (abort.signal.aborted) throw abort.signal.reason;
+      if (now() < activeDeadline) return;
+      abort.abort(activeTimeoutReason);
+      throw abort.signal.reason;
+    };
+    const startUpstreamTimeout = () => {
+      assertPrepareActive();
+      activeDeadline = now() + upstreamTimeoutMs;
+      activeTimeoutReason = "upstream_timeout";
+      abort.setTimeout(upstreamTimeoutMs, "upstream_timeout");
+    };
+    const pressureRootId = () => responseHistoryPressureRootId(prepared);
+    const markCompactTimeout = () => {
+      const eligible = imagePressure?.isEligible?.(prepared) === true;
+      return imagePressure?.markTimeout?.(pressureRootId(), { eligible }) || false;
+    };
+    const applyAdaptiveTimeout = (error) => {
+      if (!["responses_prepare_timeout", "upstream_timeout"].includes(abort.reason)) return error;
+      if (!markCompactTimeout()) return error;
+      const message = "Responses compact 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 releaseUpstreamPayload = (finalContext) => {
       if (upstreamPayloadReleased) return;
       upstreamPayloadReleased = true;
@@ -348,39 +427,43 @@ export function createResponsesCompactHandler(options) {
       releaseRequest = await acquireRequest(req, { signal: abort.signal });
       abort.setTimeout(requestBodyTimeoutMs, "request_body_timeout");
       const parsed = await readJsonBody(req, { admission: releaseRequest, signal: abort.signal });
-      let activeDeadline = now() + upstreamTimeoutMs;
-      let activeTimeoutReason = "responses_prepare_timeout";
-      const assertPrepareActive = () => {
-        if (abort.signal.aborted) throw abort.signal.reason;
-        if (now() < activeDeadline) return;
-        abort.abort(activeTimeoutReason);
-        throw abort.signal.reason;
-      };
-      const startUpstreamTimeout = () => {
-        assertPrepareActive();
-        activeDeadline = now() + upstreamTimeoutMs;
-        activeTimeoutReason = "upstream_timeout";
-        abort.setTimeout(upstreamTimeoutMs, "upstream_timeout");
-      };
+      activeDeadline = now() + upstreamTimeoutMs;
+      activeTimeoutReason = "responses_prepare_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 });
+        historySnapshot = acquireResponseHistorySnapshot(parsed.previous_response_id, {
+          assertActive: assertPrepareActive,
+          signal: abort.signal,
+        });
+        if (historySnapshot.bytes > 0) {
+          await releaseRequest.reserveResponseHistory?.(historySnapshot.bytes, { signal: abort.signal });
         }
         assertPrepareActive();
       }
-      prepared = prepareResponsesCompactionRequest(
-        prepareResponsesRequest(parsed, {
-          assertActive: assertPrepareActive,
-          copilotBoundary: false,
-          mutate: true,
-        }),
-      );
+      prepared = prepareResponsesRequest(parsed, {
+        assertActive: assertPrepareActive,
+        copilotBoundary: false,
+        historySnapshot,
+        mutate: true,
+      });
+      imagePressureResult = imagePressure?.applyRecovery?.(prepared, { assertActive: assertPrepareActive }) || null;
+      if (imagePressureResult?.adapted) {
+        console.warn(status("warn", `responses compact visual history mode=recovery historical_images=${imagePressureResult.initialHistoricalImages}->${imagePressureResult.historicalImages} omitted=${imagePressureResult.imagesOmitted} bytes=${imagePressureResult.initialBodyBytes}->${imagePressureResult.bodyBytes}`));
+      }
+      prepared = prepareResponsesCompactionRequest(prepared);
       assertPrepareActive();
       prepared.surface = "responses_compact";
       const model = parsed.model || "unknown";
-      const { requestedModel, upstreamModel } = resolveRequestModel(model, openAIModelEnv, autoReviewModelResolver);
+      const resolvedModel = resolveRequestModel(model, openAIModelEnv, autoReviewModelResolver);
+      const { requestedModel } = resolvedModel;
+      let { upstreamModel } = resolvedModel;
+      const priorityTierModel = requestedModel === upstreamModel
+        ? resolveCopilotPriorityTierModel(upstreamModel, prepared.body.service_tier, modelRegistry?.models)
+        : null;
+      if (priorityTierModel) {
+        upstreamModel = priorityTierModel;
+        delete prepared.body.service_tier;
+      }
       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`));
@@ -392,6 +475,7 @@ export function createResponsesCompactHandler(options) {
         model: upstreamModel,
         surface: "responses-compact",
       }));
+      releaseHistorySnapshot();
       applyCopilotResponsesRequestPolicies(prepared.body);
       const result = await proxyCopilotResponses(prepared, req, res, responsesCompactFn, {
         assertPrepareActive,
@@ -401,11 +485,14 @@ export function createResponsesCompactHandler(options) {
         releaseRequest: releaseUpstreamPayload,
       });
       if (result?.compacted) imagePressure?.clear?.(responseHistoryPressureRootId(prepared));
+      else if (result?.upstreamStatus === 408) markCompactTimeout();
     } catch (error) {
-      logRequestFailure("Responses compact", error, abort);
-      sendJsonError(res, error, 502);
+      const responseError = applyAdaptiveTimeout(error);
+      logRequestFailure("Responses compact", responseError, abort);
+      sendJsonError(res, responseError, 502);
     } finally {
       releaseUpstreamPayload();
+      releaseHistorySnapshot();
       abort.cleanup();
     }
   };

package/src/responses-image-pressure.mjs

@@ -25,6 +25,20 @@ function bodyPayload(body, assertActive) {
   return { bodyText, bodyBytes: Buffer.byteLength(bodyText) };
 }
 
+export function responsesImagePressureEligible(reqContext, {
+  assertActive,
+  policy: policyOverrides,
+} = {}) {
+  const policy = normalizedPolicy(policyOverrides);
+  const currentInputStart = Number.isFinite(reqContext?.currentInputStart)
+    ? reqContext.currentInputStart
+    : 0;
+  const images = responsesHistoricalImageStats(reqContext?.body?.input, currentInputStart, { assertActive });
+  if (images.historicalImages === 0) return false;
+  if (images.historicalImages > policy.triggerHistoricalImages) return true;
+  return bodyPayload(reqContext?.body, assertActive).bodyBytes > policy.triggerBodyBytes;
+}
+
 export function applyResponsesImagePressure(reqContext, {
   assertActive,
   mode = "normal",
@@ -143,6 +157,22 @@ export function createResponsesImagePressureController({
       }
       return result;
     },
+    isEligible(reqContext, { assertActive } = {}) {
+      return responsesImagePressureEligible(reqContext, { assertActive, policy });
+    },
+    applyRecovery(reqContext, { assertActive } = {}) {
+      if (modeFor(reqContext?.historyRootId) !== "recovery") return null;
+      const result = applyResponsesImagePressure(reqContext, {
+        assertActive,
+        mode: "recovery",
+        policy,
+      });
+      if (result.adapted) {
+        counters.adaptedRequests += 1;
+        counters.imagesOmitted += result.imagesOmitted;
+      }
+      return result;
+    },
     markTimeout(rootId, { eligible = false } = {}) {
       if (!rootId || !eligible) return false;
       prune();

package/src/responses-proxy.mjs

@@ -2,6 +2,9 @@ import { responses as copilotResponses } from "./copilot.mjs";
 import {
   httpError,
   logRequestFailure,
+  MAX_UPSTREAM_ERROR_BODY_BYTES,
+  MAX_UPSTREAM_RESPONSES_SUCCESS_BODY_BYTES,
+  readBoundedResponseText,
   sendUpstreamError,
   writeOrDrain,
 } from "./http-transport.mjs";
@@ -262,7 +265,16 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
       reader.releaseLock();
     }
   } else {
-    const data = await resp.text();
+    const data = resp.ok
+      ? await readBoundedResponseText(resp, {
+        maxBytes: MAX_UPSTREAM_RESPONSES_SUCCESS_BODY_BYTES,
+        label: "Copilot Responses success body",
+        signal: options.signal,
+      })
+      : await readBoundedResponseText(resp, {
+        maxBytes: MAX_UPSTREAM_ERROR_BODY_BYTES,
+        label: "Copilot Responses error body",
+      });
     if (resp.ok && reqContext.surface === "responses_compact") {
       const response = parseResponsesCompactionResult(
         compactionInputWithoutTrigger(reqContext.body.input),

package/src/responses-request.mjs

@@ -298,6 +298,7 @@ export function responseHistoryPressureRootId(reqContext) {
 export function prepareResponsesRequest(reqBody, {
   assertActive,
   copilotBoundary = true,
+  historySnapshot,
   mutate = false,
 } = {}) {
   assertActive?.();
@@ -313,11 +314,22 @@ export function prepareResponsesRequest(reqBody, {
   const historyRouteMetadata = [];
 
   if (previousId !== undefined && previousId !== null) {
-    historyItems = materializeResponseHistory(previousId, {
-      assertActive,
-      routeMetadata: historyRouteMetadata,
-    });
-    historyRootId = responseHistoryRootId(previousId);
+    if (historySnapshot) {
+      if (historySnapshot.responseId !== previousId) {
+        throw new TypeError("Response history snapshot does not match previous_response_id");
+      }
+      historyItems = historySnapshot.materialize({
+        assertActive,
+        routeMetadata: historyRouteMetadata,
+      });
+      historyRootId = historySnapshot.rootId;
+    } else {
+      historyItems = materializeResponseHistory(previousId, {
+        assertActive,
+        routeMetadata: historyRouteMetadata,
+      });
+      historyRootId = responseHistoryRootId(previousId);
+    }
     body.input = [...historyItems, ...currentInputItems];
   } else {
     body.input = currentInputItems;