codex-copilot-dx 0.4.42 → 0.4.43

package/README.md

@@ -125,7 +125,7 @@ Environment variables:
 | `CCDX_MAX_INFLIGHT_BODY_BYTES` | `33554432` | Shared byte budget for admitted request bodies; a larger single request runs exclusively |
 | `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_MAX_UPSTREAM_BODY_BYTES` | `31457280` | Responses body target; larger image payloads are compressed more aggressively before forwarding |
+| `CCDX_MAX_UPSTREAM_BODY_BYTES` | `31457280` | Strict maximum forwarded Responses body size; larger payloads are adapted locally or rejected with `413` |
 | `CCDX_MAX_SSE_BUFFER_BYTES` | `8388608` | Maximum buffered bytes for one unterminated upstream SSE line/event |
 | `CCDX_UPSTREAM_TIMEOUT_MS` | `120000` | Timeout for non-streaming upstream Copilot requests |
 | `CCDX_STREAM_HANDSHAKE_TIMEOUT_MS` | `120000` | Timeout while waiting for upstream streaming response headers |
@@ -137,8 +137,8 @@ Environment variables:
 | `CCDX_LOG_LEVEL` | `info` | Set to `debug` to include upstream request attempts, status codes, retry causes, and timings |
 | `CCDX_LOG_MAX_BYTES` | `16777216` | Rotate the debug log at this size, retaining one `.1` backup; set to `0` to disable rotation |
 | `CCDX_IMG_MAX_DIM` | `2048` | Max long edge in pixels for image downscaling |
-| `CCDX_IMG_QUALITY` | `85` | WebP quality used when re-encoding images |
-| `CCDX_IMG_MIN_BYTES` | `100000` | Images smaller than this are left untouched |
+| `CCDX_IMG_QUALITY` | `82` | Initial WebP quality used when re-encoding images |
+| `CCDX_IMG_MIN_BYTES` | `100000` | In-bounds images smaller than this are left untouched; oversized images are still downscaled |
 | `CCDX_IMG_CONCURRENCY` | `2` | Global concurrent image optimization tasks; values above `12` are capped at `12` |
 | `CCDX_IMG_MAX_INPUT_PIXELS` | `40000000` | Maximum decoded pixels accepted by `sharp` for one image |
 | `CCDX_DISABLE_IMG_OPT` | unset | Set to `1` to disable image optimization |
@@ -175,12 +175,16 @@ codex-copilot-dx usage
 
 ### Image optimization
 
-Long computer-use sessions can accumulate screenshots inside the conversation history. Each screenshot is shipped on later turns, and GitHub Copilot's `/responses` endpoint can reject oversized requests with `413 Payload Too Large`.
+Long computer-use sessions can accumulate screenshots inside the conversation history. Each screenshot is shipped on later turns, and GitHub Copilot's `/responses` endpoint can reject oversized requests with `408 Request Timeout` while reading the body or `413 Payload Too Large`.
 
-The adapter automatically downsamples embedded screenshots to long-edge <= 2048 px and re-encodes them as WebP before forwarding `/v1/responses`. It keeps an existing in-bounds WebP unchanged, never replaces an image with a larger encoding, and applies one global concurrency limit across direct and tool-output images.
+The adapter automatically downsamples embedded screenshots to model-appropriate pixel bounds (with a conservative 2048 px long-edge fallback) and initially re-encodes them as WebP quality 82 before forwarding `/v1/responses`. It never replaces an image with a larger encoding and applies one global concurrency limit across direct, function-tool, and custom-tool output images.
+
+The final serialized UTF-8 request body is measured before forwarding. Above the configured byte limit, unique source images are processed largest-first from their originals at quality 75 / 1600 px and then quality 65 / 1280 px, stopping as soon as the body fits. If necessary, the forwarded view omits older duplicate images, historical tool images, other historical images, and finally old tool outputs while preserving current input and tool-call skeletons. A request that still cannot fit is rejected locally with a structured `413` instead of sending an oversized body upstream.
 
 When expanded Responses history exceeds Copilot's 50-image request limit, the adapter removes older duplicate image occurrences first, then keeps the 50 most recent images. This applies only to the forwarded request: local history remains complete, current images are preferred over older history, and requests at or below the limit are unchanged.
 
+After a successful `/v1/responses/compact` result containing a compaction item, the compact output becomes a new local history root. Later turns continue from that snapshot without re-expanding pre-compaction history; existing older response branches remain available until normal history eviction.
+
 Newer ChatGPT/Codex clients can advertise an `image_gen` namespace that already exists upstream. The adapter removes that exact conflicting client tool before forwarding and retries once only when Copilot explicitly reports an image namespace collision. Image inputs and screenshot optimization remain enabled.
 
 ## License

package/package.json

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

package/src/adapter.mjs

@@ -106,6 +106,7 @@ export function createAdapterHandler(options = {}) {
     acquireRequest,
     chatCompletionsFn,
     openAIModelEnv,
+    responsesPayloadOptions: options.responsesPayloadOptions,
     responsesFn,
     streamHandshakeTimeoutMs,
     streamIdleTimeoutMs,

package/src/copilot.mjs

@@ -17,7 +17,8 @@ import {
   githubTokenFingerprint,
   normalizeGithubIdentity,
 } from "./github-identity.mjs";
-import { prepareResponsesPayload } from "./image-optimization.mjs";
+import { prepareResponsesPayload, summarizeReqBody } from "./image-optimization.mjs";
+import { enforceResponsesPayloadByteBudget } from "./responses-byte-budget.mjs";
 
 export {
   optimizeImageDataUrl,
@@ -500,19 +501,26 @@ export function resetCopilotTokenForTests() {
 }
 
 // chatReq is already converted by the adapter. The caller parses the raw Response.
-export async function chatCompletions(chatReq, { signal, fetchImpl, retryOptions } = {}) {
+export async function chatCompletions(chatReq, {
+  signal,
+  fetchImpl,
+  retryOptions,
+  bodyText,
+} = {}) {
   const token = await getCopilotToken({ signal });
   const messages = chatReq.messages || [];
+  const serializedBody = typeof bodyText === "string" ? bodyText : JSON.stringify(chatReq);
   const headers = buildHeaders({
     token,
     version: getVSCodeVersion(),
     initiator: computeInitiator(messages),
     vision: computeVision(messages),
   });
+  headers["Content-Length"] = String(Buffer.byteLength(serializedBody));
   return fetchCopilotUpstream(`${getApiBase()}/chat/completions`, {
     method: "POST",
     headers,
-    body: JSON.stringify(chatReq),
+    body: serializedBody,
     signal,
   }, { fetchImpl, ...retryOptions });
 }
@@ -582,10 +590,29 @@ export function resetModelListSingleflightForTests() {
 }
 
 // Responses-only models go directly to Copilot's /responses endpoint.
-export async function responses(reqBody, { signal, fetchImpl, retryOptions } = {}) {
+export async function responses(reqBody, {
+  signal,
+  fetchImpl,
+  retryOptions,
+  currentInputStart = 0,
+  payloadPrepared = false,
+  payloadOptions = {},
+} = {}) {
   const token = await getCopilotToken({ signal });
-  const { bodyText, bodyBytes, summary } = await prepareResponsesPayload(reqBody, { signal });
+  const preparedPayload = await prepareResponsesPayload(reqBody, {
+    ...payloadOptions,
+    currentInputStart,
+    profiles: payloadPrepared ? [] : payloadOptions.profiles,
+    skipInitialOptimization: payloadPrepared || payloadOptions.skipInitialOptimization,
+    signal,
+  });
+  const finalizedPayload = enforceResponsesPayloadByteBudget(reqBody, preparedPayload);
+  const { bodyText, bodyBytes, stage, adapted } = finalizedPayload;
+  const summary = finalizedPayload.stage === preparedPayload.stage
+    ? preparedPayload.summary
+    : summarizeReqBody(reqBody);
   console.log(status("info", `responses payload bytes=${bodyBytes} input_items=${summary.items} images=${summary.images}`));
+  if (adapted) debugLog(`responses payload adapted stage=${stage} bytes=${bodyBytes}/${preparedPayload.targetBytes}`);
   const headers = buildHeaders({
     token,
     version: getVSCodeVersion(),

package/src/http-transport.mjs

@@ -291,7 +291,7 @@ export function sendJsonError(res, err, fallbackStatus = 400) {
     return;
   }
   res.writeHead(err?.statusCode || fallbackStatus, { "Content-Type": "application/json" });
-  res.end(JSON.stringify({ error: err?.message || "Request failed" }));
+  res.end(JSON.stringify(err?.jsonBody || { error: err?.message || "Request failed" }));
 }
 
 export function sendUpstreamError(res, response, text) {

package/src/image-optimization.mjs

@@ -1,4 +1,9 @@
 import { createHash } from "node:crypto";
+import {
+  canonicalInlineImageIdentity,
+  readResponsesImagePart,
+  readResponsesToolOutputParts,
+} from "./responses-content.mjs";
 import { status } from "./status.mjs";
 
 const DEFAULT_IMG_CONCURRENCY = 2;
@@ -7,7 +12,7 @@ const DEFAULT_IMG_MAX_INPUT_PIXELS = 40 * 1000 * 1000;
 const DEFAULT_MAX_UPSTREAM_BODY_BYTES = 30 * 1024 * 1024;
 const MAX_OPTIMIZED_IMAGE_DIGESTS = 4096;
 const IMG_MAX_DIM = positiveInt(process.env.CCDX_IMG_MAX_DIM, 2048);
-const IMG_QUALITY = positiveInt(process.env.CCDX_IMG_QUALITY, 85, 100);
+const IMG_QUALITY = positiveInt(process.env.CCDX_IMG_QUALITY, 82, 100);
 const IMG_MIN_BYTES = nonNegativeInt(process.env.CCDX_IMG_MIN_BYTES, 100000);
 const IMG_MAX_INPUT_PIXELS = positiveInt(process.env.CCDX_IMG_MAX_INPUT_PIXELS, DEFAULT_IMG_MAX_INPUT_PIXELS);
 const MAX_UPSTREAM_BODY_BYTES = positiveInt(process.env.CCDX_MAX_UPSTREAM_BODY_BYTES, DEFAULT_MAX_UPSTREAM_BODY_BYTES);
@@ -30,6 +35,39 @@ function nonNegativeInt(value, fallback) {
   return Number.isFinite(n) && n >= 0 ? n : fallback;
 }
 
+export function imageConstraintsForModel(modelId, { maxDim = IMG_MAX_DIM } = {}) {
+  const model = String(modelId || "").trim().toLowerCase();
+  const maxLongEdge = Math.min(positiveInt(maxDim, IMG_MAX_DIM), IMG_MAX_DIM, 2048);
+  const fullSizeGpt4 = /^(?:gpt-4o|gpt-4\.1)(?:$|-)/.test(model)
+    && !/(?:^|-)(?:mini|nano)(?:$|-)/.test(model);
+  const gpt5Mini = /^gpt-5-mini(?:$|-)/.test(model);
+
+  if (fullSizeGpt4 || gpt5Mini) {
+    return { maxLongEdge, maxShortEdge: Math.min(maxLongEdge, 768) };
+  }
+  if (/^gpt-5\.(?:4|5|6)(?:$|-)/.test(model)) {
+    return { maxLongEdge, maxArea: 2_560_000 };
+  }
+  return { maxLongEdge };
+}
+
+export function fitImageDimensions(width, height, constraints = {}) {
+  const sourceWidth = Number(width);
+  const sourceHeight = Number(height);
+  if (!(sourceWidth > 0) || !(sourceHeight > 0)) return null;
+
+  const longEdge = Math.max(sourceWidth, sourceHeight);
+  const shortEdge = Math.min(sourceWidth, sourceHeight);
+  let scale = 1;
+  if (constraints.maxLongEdge > 0) scale = Math.min(scale, constraints.maxLongEdge / longEdge);
+  if (constraints.maxShortEdge > 0) scale = Math.min(scale, constraints.maxShortEdge / shortEdge);
+  if (constraints.maxArea > 0) scale = Math.min(scale, Math.sqrt(constraints.maxArea / (sourceWidth * sourceHeight)));
+  return {
+    width: Math.max(1, Math.floor(sourceWidth * scale)),
+    height: Math.max(1, Math.floor(sourceHeight * scale)),
+  };
+}
+
 export function parseImageConcurrency(value) {
   const n = Number.parseInt(value, 10);
   return Number.isFinite(n) && n > 0 ? Math.min(n, IMG_MAX_CONCURRENCY) : DEFAULT_IMG_CONCURRENCY;
@@ -120,6 +158,16 @@ function imageDigest(raw) {
   return createHash("sha256").update(raw).digest("base64url");
 }
 
+function imageOptimizationKey(digest, constraints, quality) {
+  return [
+    digest,
+    constraints.maxLongEdge || "",
+    constraints.maxShortEdge || "",
+    constraints.maxArea || "",
+    quality,
+  ].join(":");
+}
+
 function touchOptimizedImage(digest) {
   if (!optimizedImageDigests.delete(digest)) return false;
   optimizedImageDigests.add(digest);
@@ -138,6 +186,7 @@ export async function optimizeImageDataUrl(dataUrl, {
   maxDim = IMG_MAX_DIM,
   quality = IMG_QUALITY,
   force = false,
+  model,
   signal,
 } = {}) {
   if (IMG_OPT_DISABLED) return dataUrl;
@@ -147,34 +196,58 @@ export async function optimizeImageDataUrl(dataUrl, {
   const mime = match[1].toLowerCase();
   const encoded = match[2];
   const inputBytes = Buffer.byteLength(encoded, "base64");
-  if (inputBytes < IMG_MIN_BYTES || mime.includes("gif")) return dataUrl;
+  if (mime.includes("gif")) return dataUrl;
 
   try {
     return await runGlobalImageTask(async () => {
       const raw = Buffer.from(encoded, "base64");
-      if (raw.length < IMG_MIN_BYTES) return dataUrl;
       const digest = imageDigest(raw);
-      if (!force && touchOptimizedImage(digest)) return dataUrl;
+      const constraints = imageConstraintsForModel(model, { maxDim });
+      const outputQuality = positiveInt(quality, IMG_QUALITY, 100);
+      const optimizationKey = imageOptimizationKey(digest, constraints, outputQuality);
+      if (!force && touchOptimizedImage(optimizationKey)) return dataUrl;
       const resize = await sharp();
       const image = resize(raw, { failOn: "none", limitInputPixels: IMG_MAX_INPUT_PIXELS });
+      const metadata = await image.metadata();
+      const orientation = Number(metadata.orientation);
+      const rotated = orientation >= 5 && orientation <= 8;
+      const sourceWidth = rotated ? metadata.height : metadata.width;
+      const sourceHeight = rotated ? metadata.width : metadata.height;
+      const target = fitImageDimensions(sourceWidth, sourceHeight, constraints);
+      const resizeRequired = target
+        && (target.width < sourceWidth || target.height < sourceHeight);
+      if (raw.length < IMG_MIN_BYTES && !resizeRequired) {
+        rememberOptimizedImage(optimizationKey);
+        return dataUrl;
+      }
+      const resizeOptions = target
+        ? { ...target, fit: "inside", withoutEnlargement: true }
+        : {
+            width: constraints.maxLongEdge,
+            height: constraints.maxLongEdge,
+            fit: "inside",
+            withoutEnlargement: true,
+          };
       const out = await image
         .rotate()
-        .resize(positiveInt(maxDim, IMG_MAX_DIM), positiveInt(maxDim, IMG_MAX_DIM), { fit: "inside", withoutEnlargement: true })
-        .webp({ quality: positiveInt(quality, IMG_QUALITY, 100), effort: 4 })
+        .resize(resizeOptions)
+        .webp({ quality: outputQuality, effort: 4 })
         .toBuffer();
       if (signal?.aborted) throw abortError(signal);
       if (out.length >= raw.length) {
-        rememberOptimizedImage(digest);
+        rememberOptimizedImage(optimizationKey);
         return dataUrl;
       }
-      rememberOptimizedImage(imageDigest(out));
+      rememberOptimizedImage(imageOptimizationKey(imageDigest(out), constraints, outputQuality));
       const ratio = ((out.length / raw.length) * 100).toFixed(1);
       console.log(status("info", `image ${(raw.length / 1024).toFixed(0)}KB ${mime} -> ${(out.length / 1024).toFixed(0)}KB webp (${ratio}%)`));
       return `data:image/webp;base64,${out.toString("base64")}`;
     }, { signal });
   } catch (e) {
     if (signal?.aborted || e?.name === "AbortError") throw e;
-    console.warn(status("warn", `image optimize failed (${mime}, ${inputBytes}b): ${e.message}`));
+    if (inputBytes >= IMG_MIN_BYTES) {
+      console.warn(status("warn", `image optimize failed (${mime}, ${inputBytes}b): ${e.message}`));
+    }
     return dataUrl;
   }
 }
@@ -191,102 +264,225 @@ export async function runWithConcurrency(taskFns, concurrency) {
   }));
 }
 
-function visitImageParts(parts, tasks, optimizeImage) {
+function visitImageParts(parts, references, commit = null) {
   if (!Array.isArray(parts)) return;
   for (const part of parts) {
-    if (!part) continue;
-    if (part.type === "input_image" && typeof part.image_url === "string") {
-      tasks.push(async () => { part.image_url = await optimizeImage(part.image_url); });
-    } else if (part.type === "image" && part.source?.type === "base64" && part.source?.data) {
-      tasks.push(async () => {
-        const dataUrl = `data:${part.source.media_type || "image/png"};base64,${part.source.data}`;
-        const optimized = await optimizeImage(dataUrl);
-        const match = /^data:([^;]+);base64,(.+)$/.exec(optimized);
-        if (match) {
-          part.source.media_type = match[1];
-          part.source.data = match[2];
-        }
-      });
+    const image = readResponsesImagePart(part);
+    if (!image?.identity) continue;
+    references.push({
+      commit,
+      get: () => image.dataUrl,
+      set: (value) => image.setDataUrl(value),
+    });
+  }
+}
+
+function collectImageReferences(reqBody) {
+  const references = [];
+  const dirtyCommits = new Set();
+  if (!Array.isArray(reqBody?.input)) {
+    return { references, markDirty() {}, commitDirty() {} };
+  }
+
+  for (const item of reqBody.input) {
+    if (!item) continue;
+    visitImageParts([item], references);
+    if (item.type === "message" && Array.isArray(item.content)) {
+      visitImageParts(item.content, references);
+    }
+    const toolOutput = readResponsesToolOutputParts(item);
+    if (toolOutput) {
+      visitImageParts(toolOutput.parts, references, toolOutput.commit);
     }
   }
+
+  return {
+    references,
+    markDirty(changedReferences) {
+      for (const reference of changedReferences) {
+        if (reference.commit) dirtyCommits.add(reference.commit);
+      }
+    },
+    commitDirty() {
+      for (const apply of dirtyCommits) apply();
+      dirtyCommits.clear();
+    },
+  };
 }
 
-export async function optimizeImagesInBody(reqBody, {
-  concurrency = IMG_CONCURRENCY,
-  optimizeImage = optimizeImageDataUrl,
+async function optimizeImageReferences(collection, {
+  concurrency,
+  model,
+  optimizeImage,
   signal,
-} = {}) {
-  if (IMG_OPT_DISABLED || !Array.isArray(reqBody.input)) return reqBody;
-  const tasks = [];
-  const finalize = [];
+}) {
   const optimizedByDataUrl = new Map();
   const optimizeOnce = (dataUrl) => {
-    if (!optimizedByDataUrl.has(dataUrl)) {
-      optimizedByDataUrl.set(dataUrl, Promise.resolve().then(() => optimizeImage(dataUrl, { signal })));
+    const identity = canonicalInlineImageIdentity(dataUrl) || dataUrl;
+    if (!optimizedByDataUrl.has(identity)) {
+      optimizedByDataUrl.set(identity, Promise.resolve().then(() => optimizeImage(dataUrl, { model, signal })));
     }
-    return optimizedByDataUrl.get(dataUrl);
+    return optimizedByDataUrl.get(identity);
   };
+  const tasks = collection.references.map((reference) => async () => {
+    if (reference.set(await optimizeOnce(reference.get()))) collection.markDirty([reference]);
+  });
+  if (tasks.length) await runWithConcurrency(tasks, concurrency);
+  collection.commitDirty();
+}
 
-  for (const item of reqBody.input) {
-    if (!item) continue;
-    if (item.type === "message" && Array.isArray(item.content)) {
-      visitImageParts(item.content, tasks, optimizeOnce);
-    }
-    if (item.type === "function_call_output") {
-      if (Array.isArray(item.output)) {
-        visitImageParts(item.output, tasks, optimizeOnce);
-      } else if (typeof item.output === "string") {
-        const trimmed = item.output.trim();
-        if (trimmed.startsWith("[")) {
-          try {
-            const parsed = JSON.parse(trimmed);
-            if (Array.isArray(parsed)) {
-              const taskCount = tasks.length;
-              visitImageParts(parsed, tasks, optimizeOnce);
-              if (tasks.length > taskCount) finalize.push(() => { item.output = JSON.stringify(parsed); });
-            }
-          } catch {
-            // Leave non-JSON tool output untouched.
-          }
-        }
-      }
+function imageInputBytes(dataUrl) {
+  if (typeof dataUrl !== "string") return 0;
+  const match = /^data:image\/[a-z+.-]+;base64,(.+)$/i.exec(dataUrl);
+  return match ? Buffer.byteLength(match[1], "base64") : 0;
+}
+
+function uniqueOriginalImages(references) {
+  const unique = new Map();
+  for (const reference of references) {
+    const dataUrl = reference.get();
+    const identity = canonicalInlineImageIdentity(dataUrl);
+    if (!identity) continue;
+    const inputBytes = imageInputBytes(dataUrl);
+    if (inputBytes <= 0) continue;
+    let image = unique.get(identity);
+    if (!image) {
+      image = { dataUrl, inputBytes, references: [] };
+      unique.set(identity, image);
     }
+    image.references.push(reference);
   }
+  return [...unique.values()];
+}
 
-  if (tasks.length) await runWithConcurrency(tasks, concurrency);
-  for (const apply of finalize) apply();
+function currentImageWireBytes(image) {
+  return image.references.reduce(
+    (total, reference) => total + Buffer.byteLength(reference.get()),
+    0,
+  );
+}
+
+function orderImagesByCurrentWireBytes(images) {
+  return [...images].sort((left, right) => (
+    currentImageWireBytes(right) - currentImageWireBytes(left)
+      || right.inputBytes - left.inputBytes
+  ));
+}
+
+function applyImageCandidate(collection, image, candidate, bodyBytes) {
+  if (!canonicalInlineImageIdentity(candidate)) {
+    return { bodyBytes, changed: false };
+  }
+  const previous = image.references.map((reference) => reference.get());
+  if (previous.every((value) => value === candidate)) return { bodyBytes, changed: false };
+  // Base64 data URLs need no JSON escaping, so their byte delta also applies to the serialized body.
+  const candidateBytes = Buffer.byteLength(candidate);
+  const byteDelta = previous.reduce(
+    (delta, value) => delta + candidateBytes - Buffer.byteLength(value),
+    0,
+  );
+  if (byteDelta >= 0) return { bodyBytes, changed: false };
+  const changedReferences = [];
+  for (const reference of image.references) {
+    if (reference.set(candidate)) changedReferences.push(reference);
+  }
+  collection.markDirty(changedReferences);
+  return { bodyBytes: bodyBytes + byteDelta, changed: true };
+}
+
+function normalizeCurrentInputStart(value, reqBody) {
+  const parsed = Number.parseInt(value, 10);
+  const itemCount = Array.isArray(reqBody?.input) ? reqBody.input.length : 0;
+  return Number.isFinite(parsed) && parsed >= 0 ? Math.min(parsed, itemCount) : 0;
+}
+
+export async function optimizeImagesInBody(reqBody, {
+  concurrency = IMG_CONCURRENCY,
+  optimizeImage = optimizeImageDataUrl,
+  signal,
+} = {}) {
+  if (IMG_OPT_DISABLED || !Array.isArray(reqBody.input)) return reqBody;
+  const collection = collectImageReferences(reqBody);
+  await optimizeImageReferences(collection, {
+    concurrency,
+    model: reqBody.model,
+    optimizeImage,
+    signal,
+  });
   return reqBody;
 }
 
 export async function prepareResponsesPayload(reqBody, {
+  currentInputStart = 0,
   maxBytes = MAX_UPSTREAM_BODY_BYTES,
+  optimizeImage = optimizeImageDataUrl,
   profiles = OVERSIZE_IMAGE_PROFILES,
+  skipInitialOptimization = false,
   signal,
 } = {}) {
-  await optimizeImagesInBody(reqBody, { signal });
+  const shouldOptimizeImages = !IMG_OPT_DISABLED && !skipInitialOptimization;
+  const collection = shouldOptimizeImages ? collectImageReferences(reqBody) : null;
+  const originalImages = collection ? uniqueOriginalImages(collection.references) : [];
+  if (collection) {
+    await optimizeImageReferences(collection, {
+      concurrency: IMG_CONCURRENCY,
+      model: reqBody.model,
+      optimizeImage: (dataUrl, options) => optimizeImage(dataUrl, { ...options, quality: IMG_QUALITY }),
+      signal,
+    });
+  }
   let bodyText = JSON.stringify(reqBody);
   let bodyBytes = Buffer.byteLength(bodyText);
   const summary = summarizeReqBody(reqBody);
   const targetBytes = positiveInt(maxBytes, MAX_UPSTREAM_BODY_BYTES);
   let adapted = false;
+  let stage = skipInitialOptimization ? "preoptimized" : `q${IMG_QUALITY}`;
 
-  if (!IMG_OPT_DISABLED && summary.images > 0 && bodyBytes > targetBytes) {
-    for (const profile of profiles) {
+  if (collection && originalImages.length > 0 && bodyBytes > targetBytes) {
+    const batchSize = Math.max(1, IMG_CONCURRENCY);
+    for (const profile of Array.isArray(profiles) ? profiles : []) {
       const beforeBytes = bodyBytes;
-      bodyText = "";
-      await optimizeImagesInBody(reqBody, {
-        optimizeImage: (dataUrl) => optimizeImageDataUrl(dataUrl, { ...profile, force: true, signal }),
-        signal,
-      });
+      let processed = 0;
+      stage = `q${positiveInt(profile.quality, IMG_QUALITY, 100)}`;
+      const orderedImages = orderImagesByCurrentWireBytes(originalImages);
+      for (let index = 0; index < orderedImages.length && bodyBytes > targetBytes; index += batchSize) {
+        const batch = orderedImages.slice(index, index + batchSize);
+        const candidates = await Promise.all(batch.map((image) => optimizeImage(image.dataUrl, {
+          ...profile,
+          force: true,
+          model: reqBody.model,
+          signal,
+        })));
+        for (let offset = 0; offset < batch.length && bodyBytes > targetBytes; offset += 1) {
+          processed += 1;
+          const applied = applyImageCandidate(collection, batch[offset], candidates[offset], bodyBytes);
+          bodyBytes = applied.bodyBytes;
+          adapted ||= applied.changed;
+          if (bodyBytes <= targetBytes) {
+            collection.commitDirty();
+            bodyText = JSON.stringify(reqBody);
+            bodyBytes = Buffer.byteLength(bodyText);
+          }
+        }
+      }
+      collection.commitDirty();
       bodyText = JSON.stringify(reqBody);
       bodyBytes = Buffer.byteLength(bodyText);
-      adapted ||= bodyBytes < beforeBytes;
-      console.warn(status("warn", `responses payload ${beforeBytes}b exceeds ${targetBytes}b; image profile max_dim=${profile.maxDim} quality=${profile.quality} -> ${bodyBytes}b`));
+      console.warn(status("warn", `responses payload ${beforeBytes}b exceeds ${targetBytes}b; image profile max_dim=${profile.maxDim} quality=${profile.quality} processed=${processed}/${orderedImages.length} -> ${bodyBytes}b`));
       if (bodyBytes <= targetBytes) break;
     }
   }
 
-  return { bodyText, bodyBytes, summary, adapted };
+  return {
+    bodyText,
+    bodyBytes,
+    summary,
+    adapted,
+    stage,
+    targetBytes,
+    overBudget: bodyBytes > targetBytes,
+    currentInputStart: normalizeCurrentInputStart(currentInputStart, reqBody),
+  };
 }
 
 export function summarizeReqBody(reqBody) {
@@ -297,24 +493,15 @@ export function summarizeReqBody(reqBody) {
     const countImages = (parts) => {
       if (!Array.isArray(parts)) return;
       for (const part of parts) {
-        if (part?.type === "input_image" || part?.type === "image") images += 1;
+        if (["input_image", "image", "image_url"].includes(part?.type)) images += 1;
       }
     };
 
     for (const item of input) {
+      if (["input_image", "image", "image_url"].includes(item?.type)) countImages([item]);
       if (item?.type === "message") countImages(item.content);
-      if (item?.type === "function_call_output") {
-        if (Array.isArray(item.output)) {
-          countImages(item.output);
-        } else if (typeof item.output === "string" && item.output.trim().startsWith("[")) {
-          try {
-            const parsed = JSON.parse(item.output);
-            if (Array.isArray(parsed)) countImages(parsed);
-          } catch {
-            // Ignore non-JSON tool output.
-          }
-        }
-      }
+      const toolOutput = readResponsesToolOutputParts(item);
+      if (toolOutput) countImages(toolOutput.parts);
     }
 
     return { items: input.length, images };