codex-copilot-dx 0.6.5 → 0.6.6

package/src/responses-byte-budget.mjs

@@ -6,8 +6,10 @@ import {
 
 const IMAGE_OMISSION_TEXT = "[CCDX: earlier image omitted to fit the upstream request byte budget.]";
 
-function bodyPayload(reqBody) {
+function bodyPayload(reqBody, assertActive) {
+  assertActive?.();
   const bodyText = JSON.stringify(reqBody);
+  assertActive?.();
   return { bodyText, bodyBytes: Buffer.byteLength(bodyText) };
 }
 
@@ -26,7 +28,7 @@ function imageMarkerPart(record) {
   return { type: record.usesAnthropicParts ? "text" : "input_text", text: IMAGE_OMISSION_TEXT };
 }
 
-function collectResponseImages(inputItems, currentInputStart) {
+function collectResponseImages(inputItems, currentInputStart, assertActive) {
   const records = [];
   const refs = [];
   const addContainer = (parts, options) => {
@@ -41,6 +43,7 @@ function collectResponseImages(inputItems, currentInputStart) {
       usesAnthropicParts: false,
     };
     for (let partIndex = 0; partIndex < parts.length; partIndex += 1) {
+      if ((partIndex & 63) === 0) assertActive?.();
       const identity = inlineImageIdentity(parts[partIndex]);
       if (!identity) continue;
       if (parts[partIndex].type === "image") record.usesAnthropicParts = true;
@@ -56,6 +59,7 @@ function collectResponseImages(inputItems, currentInputStart) {
 
   const historyBoundary = Math.min(Math.max(0, currentInputStart), inputItems.length);
   for (let itemIndex = 0; itemIndex < inputItems.length; itemIndex += 1) {
+    if ((itemIndex & 63) === 0) assertActive?.();
     const item = inputItems[itemIndex];
     if (!item || typeof item !== "object") continue;
     const historical = itemIndex < historyBoundary;
@@ -90,10 +94,11 @@ function collectResponseImages(inputItems, currentInputStart) {
   return { records, refs };
 }
 
-function orderedHistoricalImageCandidates(refs) {
+function orderedHistoricalImageCandidates(refs, assertActive) {
   const seenByKind = new Map();
   const duplicates = [];
   for (let index = refs.length - 1; index >= 0; index -= 1) {
+    if ((index & 63) === 0) assertActive?.();
     const { kind, value } = refs[index].identity;
     let seen = seenByKind.get(kind);
     if (!seen) {
@@ -121,7 +126,7 @@ function serializedPartBytes(part, stringified) {
     : Buffer.byteLength(serialized);
 }
 
-function createRecordDropState(record) {
+function createRecordDropState(record, assertActive) {
   if (record.kind === "top-level") {
     const marker = {
       type: "message",
@@ -134,7 +139,11 @@ function createRecordDropState(record) {
     };
   }
 
-  const elementBytes = record.parts.map((part) => serializedPartBytes(part, record.stringified));
+  const elementBytes = new Array(record.parts.length);
+  for (let index = 0; index < record.parts.length; index += 1) {
+    if ((index & 63) === 0) assertActive?.();
+    elementBytes[index] = serializedPartBytes(record.parts[index], record.stringified);
+  }
   const remainingElementBytes = elementBytes.reduce((sum, bytes) => sum + bytes, 0);
   const remainingCount = record.parts.length;
   const baseBytes = record.stringified ? 4 : 2;
@@ -159,18 +168,20 @@ function recordBytesAfterDrop(record, state, partIndex) {
   return state.baseBytes + remainingElementBytes + remainingCount - 1;
 }
 
-function selectImageDrops(refs, bodyBytes, targetBytes, maxHistoricalImages = Number.POSITIVE_INFINITY) {
-  const candidates = orderedHistoricalImageCandidates(refs);
+function selectImageDrops(refs, bodyBytes, targetBytes, maxHistoricalImages = Number.POSITIVE_INFINITY, assertActive) {
+  const candidates = orderedHistoricalImageCandidates(refs, assertActive);
   const selected = new Set();
   const byRecord = new Map();
   let projectedBytes = bodyBytes;
   let historicalImages = refs.reduce((count, ref) => count + (ref.historical ? 1 : 0), 0);
-  for (const index of candidates) {
+  for (let candidateIndex = 0; candidateIndex < candidates.length; candidateIndex += 1) {
+    if ((candidateIndex & 63) === 0) assertActive?.();
+    const index = candidates[candidateIndex];
     if (projectedBytes <= targetBytes && historicalImages <= maxHistoricalImages) break;
     const ref = refs[index];
     let state = byRecord.get(ref.record);
     if (!state) {
-      state = createRecordDropState(ref.record);
+      state = createRecordDropState(ref.record, assertActive);
       byRecord.set(ref.record, state);
     }
     const afterBytes = recordBytesAfterDrop(ref.record, state, ref.partIndex);
@@ -188,9 +199,12 @@ function selectImageDrops(refs, bodyBytes, targetBytes, maxHistoricalImages = Nu
   return { selected, historicalImages, projectedBytes };
 }
 
-function applyImageDrops(records, refs, selected) {
+function applyImageDrops(records, refs, selected, assertActive) {
   const byRecord = new Map();
+  let selectedIndex = 0;
   for (const index of selected) {
+    if ((selectedIndex & 63) === 0) assertActive?.();
+    selectedIndex += 1;
     const ref = refs[index];
     let indexes = byRecord.get(ref.record);
     if (!indexes) {
@@ -200,7 +214,9 @@ function applyImageDrops(records, refs, selected) {
     indexes.add(ref.partIndex);
   }
 
-  for (const record of records) {
+  for (let recordIndex = 0; recordIndex < records.length; recordIndex += 1) {
+    if ((recordIndex & 63) === 0) assertActive?.();
+    const record = records[recordIndex];
     const indexes = byRecord.get(record);
     if (!indexes) continue;
     if (record.kind === "top-level") {
@@ -220,11 +236,12 @@ function applyImageDrops(records, refs, selected) {
   }
 }
 
-function omitHistoricalToolOutputs(inputItems, currentInputStart, bodyBytes, targetBytes) {
+function omitHistoricalToolOutputs(inputItems, currentInputStart, bodyBytes, targetBytes, assertActive) {
   let omitted = 0;
   let projectedBytes = bodyBytes;
   const historicalCount = Math.min(Math.max(0, currentInputStart), inputItems.length);
   for (let itemIndex = 0; itemIndex < historicalCount && projectedBytes > targetBytes; itemIndex += 1) {
+    if ((itemIndex & 63) === 0) assertActive?.();
     const item = inputItems[itemIndex];
     if (!isResponsesToolOutputItem(item) || item.output === undefined) continue;
     if (typeof item.output === "string" && item.output.startsWith("[CCDX: earlier tool output omitted")) continue;
@@ -240,12 +257,15 @@ function omitHistoricalToolOutputs(inputItems, currentInputStart, bodyBytes, tar
 }
 
 export function trimResponsesHistoryToByteBudget(reqBody, {
+  assertActive,
   currentInputStart = 0,
   targetBytes,
   initialBodyText,
   initialBodyBytes,
 } = {}) {
+  assertActive?.();
   let bodyText = initialBodyText ?? JSON.stringify(reqBody);
+  assertActive?.();
   let bodyBytes = initialBodyBytes ?? Buffer.byteLength(bodyText);
   const limit = Number.isFinite(targetBytes) && targetBytes > 0 ? Math.floor(targetBytes) : bodyBytes;
   const inputItems = Array.isArray(reqBody?.input) ? reqBody.input : [];
@@ -253,20 +273,22 @@ export function trimResponsesHistoryToByteBudget(reqBody, {
   let toolOutputsOmitted = 0;
 
   while (bodyBytes > limit) {
-    const { records, refs } = collectResponseImages(inputItems, currentInputStart);
+    assertActive?.();
+    const { records, refs } = collectResponseImages(inputItems, currentInputStart, assertActive);
     if (!refs.length) break;
-    const { selected } = selectImageDrops(refs, bodyBytes, limit);
+    const { selected } = selectImageDrops(refs, bodyBytes, limit, Number.POSITIVE_INFINITY, assertActive);
     if (!selected.size) break;
-    applyImageDrops(records, refs, selected);
+    applyImageDrops(records, refs, selected, assertActive);
     imagesOmitted += selected.size;
-    ({ bodyText, bodyBytes } = bodyPayload(reqBody));
+    ({ bodyText, bodyBytes } = bodyPayload(reqBody, assertActive));
   }
 
   while (bodyBytes > limit) {
-    const omitted = omitHistoricalToolOutputs(inputItems, currentInputStart, bodyBytes, limit);
+    assertActive?.();
+    const omitted = omitHistoricalToolOutputs(inputItems, currentInputStart, bodyBytes, limit, assertActive);
     if (omitted === 0) break;
     toolOutputsOmitted += omitted;
-    ({ bodyText, bodyBytes } = bodyPayload(reqBody));
+    ({ bodyText, bodyBytes } = bodyPayload(reqBody, assertActive));
   }
 
   return {
@@ -280,9 +302,9 @@ export function trimResponsesHistoryToByteBudget(reqBody, {
   };
 }
 
-export function responsesHistoricalImageStats(inputItems, currentInputStart = 0) {
+export function responsesHistoricalImageStats(inputItems, currentInputStart = 0, { assertActive } = {}) {
   const items = Array.isArray(inputItems) ? inputItems : [];
-  const { refs } = collectResponseImages(items, currentInputStart);
+  const { refs } = collectResponseImages(items, currentInputStart, assertActive);
   const historicalImages = refs.reduce((count, ref) => count + (ref.historical ? 1 : 0), 0);
   return {
     totalImages: refs.length,
@@ -292,13 +314,16 @@ export function responsesHistoricalImageStats(inputItems, currentInputStart = 0)
 }
 
 export function trimResponsesHistoricalImages(reqBody, {
+  assertActive,
   currentInputStart = 0,
   maxHistoricalImages = Number.POSITIVE_INFINITY,
   targetBytes = Number.POSITIVE_INFINITY,
   initialBodyText,
   initialBodyBytes,
 } = {}) {
+  assertActive?.();
   let bodyText = initialBodyText ?? JSON.stringify(reqBody);
+  assertActive?.();
   let bodyBytes = initialBodyBytes ?? Buffer.byteLength(bodyText);
   const byteLimit = Number.isFinite(targetBytes) && targetBytes > 0
     ? Math.floor(targetBytes)
@@ -310,18 +335,19 @@ export function trimResponsesHistoricalImages(reqBody, {
   let imagesOmitted = 0;
 
   while (true) {
-    const { records, refs } = collectResponseImages(inputItems, currentInputStart);
+    assertActive?.();
+    const { records, refs } = collectResponseImages(inputItems, currentInputStart, assertActive);
     const historicalImages = refs.reduce((count, ref) => count + (ref.historical ? 1 : 0), 0);
     if (bodyBytes <= byteLimit && historicalImages <= imageLimit) break;
     if (!historicalImages) break;
-    const { selected } = selectImageDrops(refs, bodyBytes, byteLimit, imageLimit);
+    const { selected } = selectImageDrops(refs, bodyBytes, byteLimit, imageLimit, assertActive);
     if (!selected.size) break;
-    applyImageDrops(records, refs, selected);
+    applyImageDrops(records, refs, selected, assertActive);
     imagesOmitted += selected.size;
-    ({ bodyText, bodyBytes } = bodyPayload(reqBody));
+    ({ bodyText, bodyBytes } = bodyPayload(reqBody, assertActive));
   }
 
-  const stats = responsesHistoricalImageStats(inputItems, currentInputStart);
+  const stats = responsesHistoricalImageStats(inputItems, currentInputStart, { assertActive });
   return {
     bodyText,
     bodyBytes,
@@ -336,10 +362,11 @@ export function trimResponsesHistoricalImages(reqBody, {
   };
 }
 
-export function enforceResponsesPayloadByteBudget(reqBody, payload) {
+export function enforceResponsesPayloadByteBudget(reqBody, payload, { assertActive } = {}) {
   let finalized = payload;
   if (payload?.overBudget) {
     const trimmed = trimResponsesHistoryToByteBudget(reqBody, {
+      assertActive,
       currentInputStart: payload.currentInputStart,
       targetBytes: payload.targetBytes,
       initialBodyText: payload.bodyText,

package/src/responses-chat-payload.mjs

@@ -22,8 +22,10 @@ function configuredBodyLimit(payloadOptions) {
   return positiveInt(payloadOptions?.maxBytes, environmentLimit);
 }
 
-function jsonPayload(value) {
+function jsonPayload(value, assertActive) {
+  assertActive?.();
   const bodyText = JSON.stringify(value);
+  assertActive?.();
   return { bodyText, bodyBytes: Buffer.byteLength(bodyText) };
 }
 
@@ -38,22 +40,29 @@ function adjustedResponsesTarget(limit, responsesBytes, chatBytes) {
   return Math.max(1, limit - (chatBytes - responsesBytes));
 }
 
-function partsHaveInlineImage(parts) {
-  return Array.isArray(parts) && parts.some((part) => Boolean(readResponsesImagePart(part)?.identity));
+function partsHaveInlineImage(parts, assertActive) {
+  if (!Array.isArray(parts)) return false;
+  for (let index = 0; index < parts.length; index += 1) {
+    if ((index & 63) === 0) assertActive?.();
+    if (readResponsesImagePart(parts[index])?.identity) return true;
+  }
+  return false;
 }
 
-function bodyHasInlineImage(body) {
+function bodyHasInlineImage(body, assertActive) {
   if (!Array.isArray(body?.input)) return false;
-  for (const item of body.input) {
+  for (let index = 0; index < body.input.length; index += 1) {
+    if ((index & 63) === 0) assertActive?.();
+    const item = body.input[index];
     if (readResponsesImagePart(item)?.identity) return true;
-    if (item?.type === "message" && partsHaveInlineImage(item.content)) return true;
+    if (item?.type === "message" && partsHaveInlineImage(item.content, assertActive)) return true;
     const toolOutput = readResponsesToolOutputParts(item);
-    if (toolOutput && partsHaveInlineImage(toolOutput.parts)) return true;
+    if (toolOutput && partsHaveInlineImage(toolOutput.parts, assertActive)) return true;
   }
   return false;
 }
 
-function checkedChatPayload(chatReq, payload, limit, stage, adapted) {
+function checkedChatPayload(chatReq, payload, limit, stage, adapted, assertActive) {
   enforceResponsesPayloadByteBudget(chatReq, {
     ...payload,
     adapted,
@@ -61,29 +70,33 @@ function checkedChatPayload(chatReq, payload, limit, stage, adapted) {
     overBudget: payload.bodyBytes > limit,
     stage: stage === "chat" ? stage : `${stage}+chat`,
     targetBytes: limit,
-  });
+  }, { assertActive });
   return { chatReq, ...payload, adapted, stage };
 }
 
 export async function prepareResponsesChatPayload(reqContext, {
+  assertActive,
   payloadOptions = {},
   signal,
   stream = false,
 } = {}) {
+  assertActive?.();
   const limit = configuredBodyLimit(payloadOptions);
   let finalChatReq = chatRequest(reqContext.body, stream);
-  let finalChat = jsonPayload(finalChatReq);
-  const hasInlineImage = bodyHasInlineImage(reqContext.body);
+  assertActive?.();
+  let finalChat = jsonPayload(finalChatReq, assertActive);
+  const hasInlineImage = bodyHasInlineImage(reqContext.body, assertActive);
   if (!hasInlineImage && (finalChat.bodyBytes <= limit || !(reqContext.currentInputStart > 0))) {
-    return checkedChatPayload(finalChatReq, finalChat, limit, "chat", false);
+    return checkedChatPayload(finalChatReq, finalChat, limit, "chat", false, assertActive);
   }
 
-  let responsesPayload = jsonPayload(reqContext.body);
+  let responsesPayload = jsonPayload(reqContext.body, assertActive);
   let adapted = false;
   let stage = "chat";
   if (hasInlineImage) {
     const prepared = await prepareResponsesPayload(reqContext.body, {
       ...payloadOptions,
+      assertActive,
       currentInputStart: reqContext.currentInputStart,
       maxBytes: adjustedResponsesTarget(limit, responsesPayload.bodyBytes, finalChat.bodyBytes),
       signal,
@@ -92,10 +105,12 @@ export async function prepareResponsesChatPayload(reqContext, {
     adapted = prepared.adapted;
     stage = prepared.stage;
     finalChatReq = chatRequest(reqContext.body, stream);
-    finalChat = jsonPayload(finalChatReq);
+    assertActive?.();
+    finalChat = jsonPayload(finalChatReq, assertActive);
   }
 
   while (finalChat.bodyBytes > limit) {
+    assertActive?.();
     if (!(reqContext.currentInputStart > 0)) break;
     const targetBytes = adjustedResponsesTarget(
       limit,
@@ -103,8 +118,10 @@ export async function prepareResponsesChatPayload(reqContext, {
       finalChat.bodyBytes,
     );
     const bodyBeforeTrim = structuredClone(reqContext.body);
+    assertActive?.();
     const responsesBeforeTrim = responsesPayload;
     const trimmed = trimResponsesHistoryToByteBudget(reqContext.body, {
+      assertActive,
       currentInputStart: reqContext.currentInputStart,
       targetBytes,
       initialBodyText: responsesPayload.bodyText,
@@ -112,7 +129,8 @@ export async function prepareResponsesChatPayload(reqContext, {
     });
     if (!trimmed.adapted) break;
     const candidateChatReq = chatRequest(reqContext.body, stream);
-    const candidateChat = jsonPayload(candidateChatReq);
+    assertActive?.();
+    const candidateChat = jsonPayload(candidateChatReq, assertActive);
     if (candidateChat.bodyBytes >= finalChat.bodyBytes) {
       reqContext.body = bodyBeforeTrim;
       responsesPayload = responsesBeforeTrim;
@@ -125,5 +143,6 @@ export async function prepareResponsesChatPayload(reqContext, {
     if (!stage.endsWith("+history")) stage += "+history";
   }
 
-  return checkedChatPayload(finalChatReq, finalChat, limit, stage, adapted);
+  assertActive?.();
+  return checkedChatPayload(finalChatReq, finalChat, limit, stage, adapted, assertActive);
 }

package/src/responses-content.mjs

@@ -3,6 +3,14 @@ export function isResponsesToolOutputItem(item) {
 }
 
 const INLINE_IMAGE_DATA_URL = /^data:(image\/[a-z+.-]+);base64,(.+)$/i;
+const toolOutputPartsCache = new WeakMap();
+
+export function clearResponsesToolOutputPartsCache(inputItems) {
+  if (!Array.isArray(inputItems)) return;
+  for (const item of inputItems) {
+    if (item && typeof item === "object") toolOutputPartsCache.delete(item);
+  }
+}
 
 export function canonicalInlineImageIdentity(dataUrl) {
   if (typeof dataUrl !== "string") return null;
@@ -71,16 +79,40 @@ export function readResponsesImagePart(part) {
 export function readResponsesToolOutputParts(item) {
   if (!isResponsesToolOutputItem(item)) return null;
   if (Array.isArray(item.output)) return { parts: item.output, commit: null };
-  if (typeof item.output !== "string" || !item.output.trim().startsWith("[")) return null;
+  const source = item.output;
+  if (typeof source !== "string" || !source.trim().startsWith("[")) return null;
+
+  const cached = toolOutputPartsCache.get(item);
+  if (cached?.source === source) {
+    if (!cached.parts) return null;
+    return {
+      parts: cached.parts,
+      commit: () => {
+        const nextSource = JSON.stringify(cached.parts);
+        item.output = nextSource;
+        cached.source = nextSource;
+      },
+    };
+  }
 
   try {
-    const parts = JSON.parse(item.output);
-    if (!Array.isArray(parts)) return null;
+    const parts = JSON.parse(source);
+    if (!Array.isArray(parts)) {
+      toolOutputPartsCache.set(item, { source, parts: null });
+      return null;
+    }
+    const entry = { source, parts };
+    toolOutputPartsCache.set(item, entry);
     return {
       parts,
-      commit: () => { item.output = JSON.stringify(parts); },
+      commit: () => {
+        const nextSource = JSON.stringify(parts);
+        item.output = nextSource;
+        entry.source = nextSource;
+      },
     };
   } catch {
+    toolOutputPartsCache.set(item, { source, parts: null });
     return null;
   }
 }

package/src/responses-handler.mjs

@@ -16,6 +16,7 @@ import {
 import { chatToResponses, forwardToChat, responsesBodyUsesCustomTools } from "./responses-bridge.mjs";
 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 {
@@ -102,24 +103,21 @@ export function createResponsesHandler(options) {
     let imagePressureResult = null;
     let parsed = null;
     let upstreamPayloadReleased = false;
-    let prepareDeadline = Number.POSITIVE_INFINITY;
-    let upstreamStarted = false;
+    let activeDeadline = Number.POSITIVE_INFINITY;
+    let activeTimeoutReason = "responses_prepare_timeout";
     const assertPrepareActive = () => {
       if (abort.signal.aborted) throw abort.signal.reason;
-      if (now() < prepareDeadline) return;
-      abort.abort("responses_prepare_timeout");
+      if (now() < activeDeadline) return;
+      abort.abort(activeTimeoutReason);
       throw abort.signal.reason;
     };
     const startUpstreamTimeout = () => {
-      if (!upstreamStarted) {
-        assertPrepareActive();
-        upstreamStarted = true;
-      }
+      assertPrepareActive();
       const streaming = prepared?.body?.stream === true;
-      abort.setTimeout(
-        streaming ? streamHandshakeTimeoutMs : upstreamTimeoutMs,
-        streaming ? "stream_handshake_timeout" : "upstream_timeout",
-      );
+      const timeoutMs = streaming ? streamHandshakeTimeoutMs : upstreamTimeoutMs;
+      activeTimeoutReason = streaming ? "stream_handshake_timeout" : "upstream_timeout";
+      activeDeadline = now() + timeoutMs;
+      abort.setTimeout(timeoutMs, activeTimeoutReason);
     };
     const applyAdaptiveTimeout = (error) => {
       if (!["responses_prepare_timeout", "stream_handshake_timeout", "upstream_timeout"].includes(abort.reason)) {
@@ -150,6 +148,12 @@ export function createResponsesHandler(options) {
     const releaseUpstreamPayload = (finalContext) => {
       if (upstreamPayloadReleased) return;
       upstreamPayloadReleased = true;
+      clearResponsesToolOutputPartsCache(prepared?.body?.input);
+      clearResponsesToolOutputPartsCache(prepared?.historyInputItems);
+      if (finalContext && finalContext !== prepared) {
+        clearResponsesToolOutputPartsCache(finalContext.body?.input);
+        clearResponsesToolOutputPartsCache(finalContext.historyInputItems);
+      }
       if (finalContext && finalContext !== prepared) dropMaterializedResponseHistory(finalContext);
       dropMaterializedResponseHistory(prepared);
       releaseRequest();
@@ -158,7 +162,8 @@ export function createResponsesHandler(options) {
       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;
+      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);
@@ -167,10 +172,10 @@ export function createResponsesHandler(options) {
         }
         assertPrepareActive();
       }
-      prepared = prepareResponsesRequest(parsed, { mutate: true });
+      prepared = prepareResponsesRequest(parsed, { assertActive: assertPrepareActive, mutate: true });
       parsed = null;
       assertPrepareActive();
-      imagePressureResult = imagePressure?.apply?.(prepared) || null;
+      imagePressureResult = imagePressure?.apply?.(prepared, { assertActive: assertPrepareActive }) || 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}`));
@@ -189,6 +194,7 @@ export function createResponsesHandler(options) {
       if (usesCustomTools && !useNativeResponses) throw unsupportedCustomToolsError(upstreamModel);
       if (useNativeResponses) {
         const result = await proxyCopilotResponses(prepared, req, res, responsesFn, {
+          assertPrepareActive,
           signal: abort.signal,
           abort,
           onUpstreamStart: startUpstreamTimeout,
@@ -199,6 +205,7 @@ export function createResponsesHandler(options) {
         else markAdaptiveHttpTimeout(result?.upstreamStatus);
       } else {
         let { chatReq, bodyText } = await prepareResponsesChatPayload(prepared, {
+          assertActive: assertPrepareActive,
           payloadOptions: responsesPayloadOptions,
           signal: abort.signal,
           stream: streaming,
@@ -304,23 +311,35 @@ export function createResponsesCompactHandler(options) {
   return async function handleResponsesCompact(req, res) {
     const abort = createRequestAbort(req, res);
     let releaseRequest = () => {};
+    let prepared = null;
+    let upstreamPayloadReleased = false;
+    const releaseUpstreamPayload = (finalContext) => {
+      if (upstreamPayloadReleased) return;
+      upstreamPayloadReleased = true;
+      clearResponsesToolOutputPartsCache(prepared?.body?.input);
+      clearResponsesToolOutputPartsCache(prepared?.historyInputItems);
+      if (finalContext && finalContext !== prepared) {
+        clearResponsesToolOutputPartsCache(finalContext.body?.input);
+        clearResponsesToolOutputPartsCache(finalContext.historyInputItems);
+      }
+      releaseRequest();
+    };
     try {
       releaseRequest = await acquireRequest(req, { signal: abort.signal });
       abort.setTimeout(requestBodyTimeoutMs, "request_body_timeout");
       const parsed = await readJsonBody(req, { admission: releaseRequest, signal: abort.signal });
-      const prepareDeadline = now() + upstreamTimeoutMs;
+      let activeDeadline = now() + upstreamTimeoutMs;
+      let activeTimeoutReason = "responses_prepare_timeout";
       const assertPrepareActive = () => {
         if (abort.signal.aborted) throw abort.signal.reason;
-        if (now() < prepareDeadline) return;
-        abort.abort("responses_prepare_timeout");
+        if (now() < activeDeadline) return;
+        abort.abort(activeTimeoutReason);
         throw abort.signal.reason;
       };
-      let upstreamStarted = false;
       const startUpstreamTimeout = () => {
-        if (!upstreamStarted) {
-          assertPrepareActive();
-          upstreamStarted = true;
-        }
+        assertPrepareActive();
+        activeDeadline = now() + upstreamTimeoutMs;
+        activeTimeoutReason = "upstream_timeout";
         abort.setTimeout(upstreamTimeoutMs, "upstream_timeout");
       };
       abort.setTimeout(upstreamTimeoutMs, "responses_prepare_timeout");
@@ -331,8 +350,8 @@ export function createResponsesCompactHandler(options) {
         }
         assertPrepareActive();
       }
-      const prepared = prepareResponsesCompactionRequest(
-        prepareResponsesRequest(parsed, { mutate: true }),
+      prepared = prepareResponsesCompactionRequest(
+        prepareResponsesRequest(parsed, { assertActive: assertPrepareActive, mutate: true }),
       );
       assertPrepareActive();
       prepared.surface = "responses_compact";
@@ -342,17 +361,18 @@ export function createResponsesCompactHandler(options) {
       const upstreamLog = upstreamModel === requestedModel ? "" : ` upstream_model=${upstreamModel}`;
       console.log(status("info", `responses compact model=${requestedModel}${upstreamLog} stream=false`));
       const result = await proxyCopilotResponses(prepared, req, res, responsesCompactFn, {
+        assertPrepareActive,
         signal: abort.signal,
         abort,
         onUpstreamStart: startUpstreamTimeout,
-        releaseRequest,
+        releaseRequest: releaseUpstreamPayload,
       });
       if (result?.compacted) imagePressure?.clear?.(prepared.historyRootId);
     } catch (error) {
       logRequestFailure("Responses compact", error, abort);
       sendJsonError(res, error, 502);
     } finally {
-      releaseRequest();
+      releaseUpstreamPayload();
       abort.cleanup();
     }
   };