codex-copilot-dx 0.4.33 → 0.4.35

package/src/http-transport.mjs

@@ -4,6 +4,10 @@ import { status } from "./status.mjs";
 
 const DEFAULT_MAX_BODY_BYTES = 64 * 1024 * 1024;
 const DEFAULT_MAX_DECODED_BODY_BYTES = 128 * 1024 * 1024;
+const DEFAULT_MAX_INFLIGHT_BODY_BYTES = 32 * 1024 * 1024;
+const DEFAULT_MAX_QUEUED_REQUESTS = 16;
+const DEFAULT_REQUEST_QUEUE_TIMEOUT_MS = 120 * 1000;
+const COMPRESSED_BODY_WEIGHT_MULTIPLIER = 4;
 const gunzipAsync = promisify(zlib.gunzip);
 const inflateAsync = promisify(zlib.inflate);
 const brotliDecompressAsync = promisify(zlib.brotliDecompress);
@@ -16,6 +20,9 @@ function positiveInt(value, fallback) {
 
 const MAX_BODY_BYTES = positiveInt(process.env.CCDX_MAX_BODY_BYTES, DEFAULT_MAX_BODY_BYTES);
 const MAX_DECODED_BODY_BYTES = positiveInt(process.env.CCDX_MAX_DECODED_BODY_BYTES, DEFAULT_MAX_DECODED_BODY_BYTES);
+const MAX_INFLIGHT_BODY_BYTES = positiveInt(process.env.CCDX_MAX_INFLIGHT_BODY_BYTES, DEFAULT_MAX_INFLIGHT_BODY_BYTES);
+const MAX_QUEUED_REQUESTS = positiveInt(process.env.CCDX_MAX_QUEUED_REQUESTS, DEFAULT_MAX_QUEUED_REQUESTS);
+const REQUEST_QUEUE_TIMEOUT_MS = positiveInt(process.env.CCDX_REQUEST_QUEUE_TIMEOUT_MS, DEFAULT_REQUEST_QUEUE_TIMEOUT_MS);
 
 export function httpError(message, statusCode) {
   const err = new Error(message);
@@ -31,6 +38,108 @@ function requestContentLength(req) {
   return Number.parseInt(req.headers?.["content-length"] || "", 10);
 }
 
+function requestAdmissionWeight(req, maxBytes) {
+  const encodings = contentEncodings(req.headers?.["content-encoding"]);
+  const contentLength = requestContentLength(req);
+  if (!Number.isFinite(contentLength) || contentLength < 0) return maxBytes;
+  const compressed = encodings.some((encoding) => encoding !== "identity");
+  const weightedLength = compressed ? contentLength * COMPRESSED_BODY_WEIGHT_MULTIPLIER : contentLength;
+  return Math.max(1, Math.min(weightedLength, maxBytes));
+}
+
+function admissionAbortError(signal) {
+  if (signal?.reason instanceof Error) return signal.reason;
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  return error;
+}
+
+export function createRequestAdmission({
+  maxBytes = MAX_INFLIGHT_BODY_BYTES,
+  maxQueued = MAX_QUEUED_REQUESTS,
+  waitTimeoutMs = REQUEST_QUEUE_TIMEOUT_MS,
+} = {}) {
+  const byteLimit = positiveInt(maxBytes, MAX_INFLIGHT_BODY_BYTES);
+  const queueLimit = positiveInt(maxQueued, MAX_QUEUED_REQUESTS);
+  const timeoutMs = positiveInt(waitTimeoutMs, REQUEST_QUEUE_TIMEOUT_MS);
+  const queue = [];
+  let activeBytes = 0;
+
+  const remove = (entry) => {
+    const index = queue.indexOf(entry);
+    if (index >= 0) queue.splice(index, 1);
+  };
+
+  const activate = (entry) => {
+    entry.cleanup();
+    activeBytes += entry.weight;
+    let released = false;
+    entry.resolve(() => {
+      if (released) return;
+      released = true;
+      activeBytes = Math.max(0, activeBytes - entry.weight);
+      drain();
+    });
+  };
+
+  const drain = () => {
+    for (let index = 0; index < queue.length;) {
+      const entry = queue[index];
+      if (entry.cancelled) {
+        queue.splice(index, 1);
+        continue;
+      }
+      if (activeBytes + entry.weight > byteLimit) {
+        index += 1;
+        continue;
+      }
+      queue.splice(index, 1);
+      activate(entry);
+    }
+  };
+
+  const acquire = (req, { signal } = {}) => {
+    if (signal?.aborted) return Promise.reject(admissionAbortError(signal));
+    const weight = requestAdmissionWeight(req, byteLimit);
+    if (queue.length >= queueLimit && activeBytes + weight > byteLimit) {
+      return Promise.reject(httpError(`Request queue is full (${queueLimit} waiting)`, 503));
+    }
+
+    return new Promise((resolve, reject) => {
+      let timer;
+      const entry = {
+        cancelled: false,
+        weight,
+        resolve,
+        cleanup: () => {
+          if (timer) clearTimeout(timer);
+          signal?.removeEventListener("abort", onAbort);
+        },
+      };
+      const cancel = (error) => {
+        if (entry.cancelled) return;
+        entry.cancelled = true;
+        entry.cleanup();
+        remove(entry);
+        reject(error);
+        drain();
+      };
+      const onAbort = () => cancel(admissionAbortError(signal));
+      signal?.addEventListener("abort", onAbort, { once: true });
+      timer = setTimeout(() => {
+        cancel(httpError(`Request admission timed out after ${timeoutMs}ms`, 503));
+      }, timeoutMs);
+      timer.unref?.();
+      queue.push(entry);
+      if (signal?.aborted) onAbort();
+      else drain();
+    });
+  };
+
+  acquire.stats = () => ({ activeBytes, queued: queue.length, maxBytes: byteLimit });
+  return acquire;
+}
+
 async function readRequestBuffer(req, maxBytes) {
   const contentLength = requestContentLength(req);
   if (Number.isFinite(contentLength) && contentLength > maxBytes) {

package/src/image-optimization.mjs

@@ -130,13 +130,16 @@ export async function optimizeImageDataUrl(dataUrl, {
   const match = /^data:(image\/[a-z+.-]+);base64,(.+)$/i.exec(dataUrl);
   if (!match) return 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;
+  const encoded = match[2];
+  const inputBytes = Buffer.byteLength(encoded, "base64");
+  if (inputBytes < IMG_MIN_BYTES || 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 resize = await sharp();
       const image = resize(raw, { failOn: "none", limitInputPixels: IMG_MAX_INPUT_PIXELS });
       const out = await image
@@ -156,7 +159,7 @@ export async function optimizeImageDataUrl(dataUrl, {
     }, { signal });
   } catch (e) {
     if (signal?.aborted || e?.name === "AbortError") throw e;
-    console.warn(status("warn", `image optimize failed (${mime}, ${raw.length}b): ${e.message}`));
+    console.warn(status("warn", `image optimize failed (${mime}, ${inputBytes}b): ${e.message}`));
     return dataUrl;
   }
 }

package/src/models.mjs

@@ -225,6 +225,19 @@ export function resolveOpenAIModel(model, env = process.env) {
   };
 }
 
+export function codexAutoReviewModelStatus(models, env = process.env) {
+  const { upstreamModel } = resolveOpenAIModel(CODEX_AUTO_REVIEW_MODEL, env);
+  const model = copilotModelData(models).find((entry) => String(entry?.id || "").trim() === upstreamModel);
+  if (!model) return { available: false, upstreamModel, reason: "model is not advertised" };
+  const endpoints = modelEndpoints(model);
+  const available = endpoints.includes("/responses") || endpoints.includes("/v1/responses");
+  return {
+    available,
+    upstreamModel,
+    reason: available ? "" : "model does not advertise a Responses endpoint",
+  };
+}
+
 export function anthropicModelInfo(model) {
   return {
     id: model.id,