codex-copilot-dx 0.4.29 → 0.4.30

package/README.md

@@ -102,6 +102,7 @@ Environment variables:
 | `CCDX_ALLOW_LAN` | unset | Set to `1` to allow non-loopback `ADAPTER_HOST` values such as `0.0.0.0`; exposes your Copilot-backed adapter beyond this machine |
 | `CCDX_MAX_BODY_BYTES` | `67108864` | Maximum compressed/raw request body size |
 | `CCDX_MAX_DECODED_BODY_BYTES` | `134217728` | Maximum decoded request body size after decompression |
+| `CCDX_MAX_UPSTREAM_BODY_BYTES` | `31457280` | Responses body target; larger image payloads are compressed more aggressively before forwarding |
 | `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 |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.4.29",
+  "version": "0.4.30",
   "description": "Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot",
   "type": "module",
   "bin": {

package/src/copilot.mjs

@@ -4,18 +4,13 @@ import { randomUUID } from "node:crypto";
 import { status } from "./status.mjs";
 import { debugLog } from "./log.mjs";
 import { ensureGithubTokenMetadata, githubReauthMessage, githubTokenPath, importDiscoveredGithubToken } from "./auth.mjs";
-import {
-  optimizeImageDataUrl,
-  optimizeImagesInBody,
-  parseImageConcurrency,
-  runWithConcurrency,
-  summarizeReqBody,
-} from "./image-optimization.mjs";
+import { prepareResponsesPayload } from "./image-optimization.mjs";
 
 export {
   optimizeImageDataUrl,
   optimizeImagesInBody,
   parseImageConcurrency,
+  prepareResponsesPayload,
   runWithConcurrency,
   summarizeReqBody,
 } from "./image-optimization.mjs";
@@ -384,10 +379,7 @@ export async function listModels({ signal, fetchImpl, retryOptions } = {}) {
 // Responses-only models go directly to Copilot's /responses endpoint.
 export async function responses(reqBody, { signal, fetchImpl, retryOptions } = {}) {
   const token = await getCopilotToken({ signal });
-  await optimizeImagesInBody(reqBody);
-  const bodyText = JSON.stringify(reqBody);
-  const bodyBytes = Buffer.byteLength(bodyText);
-  const summary = summarizeReqBody(reqBody);
+  const { bodyText, bodyBytes, summary } = await prepareResponsesPayload(reqBody);
   console.log(status("info", `responses payload bytes=${bodyBytes} input_items=${summary.items} images=${summary.images}`));
   const headers = buildHeaders({
     token,

package/src/image-optimization.mjs

@@ -1,14 +1,23 @@
+import { createHash } from "node:crypto";
 import { status } from "./status.mjs";
 
 const DEFAULT_IMG_CONCURRENCY = 2;
 const IMG_MAX_CONCURRENCY = 12;
 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_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);
 const IMG_OPT_DISABLED = process.env.CCDX_DISABLE_IMG_OPT === "1";
 const IMG_CONCURRENCY = parseImageConcurrency(process.env.CCDX_IMG_CONCURRENCY);
+const OVERSIZE_IMAGE_PROFILES = [
+  { maxDim: Math.min(IMG_MAX_DIM, 1600), quality: Math.min(IMG_QUALITY, 75) },
+  { maxDim: Math.min(IMG_MAX_DIM, 1280), quality: Math.min(IMG_QUALITY, 65) },
+];
+const optimizedImageDigests = new Set();
 let sharpImport = null;
 
 function positiveInt(value, fallback, max = Number.MAX_SAFE_INTEGER) {
@@ -32,7 +41,29 @@ async function sharp() {
   return mod.default || mod;
 }
 
-export async function optimizeImageDataUrl(dataUrl) {
+function imageDigest(raw) {
+  return createHash("sha256").update(raw).digest("base64url");
+}
+
+function touchOptimizedImage(digest) {
+  if (!optimizedImageDigests.delete(digest)) return false;
+  optimizedImageDigests.add(digest);
+  return true;
+}
+
+function rememberOptimizedImage(digest) {
+  optimizedImageDigests.delete(digest);
+  optimizedImageDigests.add(digest);
+  if (optimizedImageDigests.size > MAX_OPTIMIZED_IMAGE_DIGESTS) {
+    optimizedImageDigests.delete(optimizedImageDigests.values().next().value);
+  }
+}
+
+export async function optimizeImageDataUrl(dataUrl, {
+  maxDim = IMG_MAX_DIM,
+  quality = IMG_QUALITY,
+  force = false,
+} = {}) {
   if (IMG_OPT_DISABLED) return dataUrl;
   if (typeof dataUrl !== "string" || !dataUrl.startsWith("data:")) return dataUrl;
   const match = /^data:(image\/[a-z+.-]+);base64,(.+)$/i.exec(dataUrl);
@@ -40,23 +71,22 @@ export async function optimizeImageDataUrl(dataUrl) {
   const mime = match[1].toLowerCase();
   const raw = Buffer.from(match[2], "base64");
   if (raw.length < IMG_MIN_BYTES || mime.includes("gif")) return dataUrl;
+  const digest = imageDigest(raw);
+  if (!force && touchOptimizedImage(digest)) return dataUrl;
 
   try {
     const resize = await sharp();
     const image = resize(raw, { failOn: "none", limitInputPixels: IMG_MAX_INPUT_PIXELS });
-    const metadata = await image.metadata();
-    if (mime === "image/webp"
-      && metadata.width <= IMG_MAX_DIM
-      && metadata.height <= IMG_MAX_DIM
-      && (!metadata.orientation || metadata.orientation === 1)) {
-      return dataUrl;
-    }
     const out = await image
       .rotate()
-      .resize(IMG_MAX_DIM, IMG_MAX_DIM, { fit: "inside", withoutEnlargement: true })
-      .webp({ quality: IMG_QUALITY, effort: 4 })
+      .resize(positiveInt(maxDim, IMG_MAX_DIM), positiveInt(maxDim, IMG_MAX_DIM), { fit: "inside", withoutEnlargement: true })
+      .webp({ quality: positiveInt(quality, IMG_QUALITY, 100), effort: 4 })
       .toBuffer();
-    if (out.length >= raw.length) return dataUrl;
+    if (out.length >= raw.length) {
+      rememberOptimizedImage(digest);
+      return dataUrl;
+    }
+    rememberOptimizedImage(imageDigest(out));
     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")}`;
@@ -137,6 +167,35 @@ export async function optimizeImagesInBody(reqBody, {
   return reqBody;
 }
 
+export async function prepareResponsesPayload(reqBody, {
+  maxBytes = MAX_UPSTREAM_BODY_BYTES,
+  profiles = OVERSIZE_IMAGE_PROFILES,
+} = {}) {
+  await optimizeImagesInBody(reqBody);
+  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;
+
+  if (!IMG_OPT_DISABLED && summary.images > 0 && bodyBytes > targetBytes) {
+    for (const profile of profiles) {
+      const beforeBytes = bodyBytes;
+      bodyText = "";
+      await optimizeImagesInBody(reqBody, {
+        optimizeImage: (dataUrl) => optimizeImageDataUrl(dataUrl, { ...profile, force: true }),
+      });
+      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`));
+      if (bodyBytes <= targetBytes) break;
+    }
+  }
+
+  return { bodyText, bodyBytes, summary, adapted };
+}
+
 export function summarizeReqBody(reqBody) {
   try {
     const input = reqBody.input;