codex-copilot-dx 0.6.5 → 0.6.6

package/README.md

@@ -120,8 +120,8 @@ ccdx auth login claude --reauth --github-login <personal-github-login>
 ccdx pms setup
 ```
 
-Inspect the installed version, exact patch integrity, isolated Claude profile,
-and relay without changing files:
+Inspect the installed version, exact patch manifest plus executable/signing
+integrity, isolated Claude profile, and live relay routing without changing files:
 
 ```bash
 ccdx pms status

package/bin/cli.mjs

@@ -316,6 +316,7 @@ try {
     codexModelRegistry: profileModels.codexRegistry,
     claudeModelRegistry: profileModels.claudeRegistry,
     claudeMode: profileRuntime.claudeMode,
+    isClaudeProfileCurrent: profileRuntime.isClaudeProfileCurrent,
     showRequestId: CLI.showRequestId,
     upstreamTimeoutMs: RUNTIME.upstreamTimeoutMs,
     streamHandshakeTimeoutMs: RUNTIME.streamHandshakeTimeoutMs,

package/package.json

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

package/scripts/benchmark.mjs

@@ -23,6 +23,14 @@ function runProbe(source) {
   return JSON.parse(result.stdout.trim());
 }
 
+function median(values) {
+  const ordered = [...values].sort((left, right) => left - right);
+  const middle = Math.floor(ordered.length / 2);
+  return ordered.length % 2 === 0
+    ? (ordered[middle - 1] + ordered[middle]) / 2
+    : ordered[middle];
+}
+
 function deterministicPixels(byteLength, initialSeed) {
   const pixels = Buffer.alloc(byteLength);
   let seed = initialSeed;
@@ -154,7 +162,7 @@ function largePayloadProbe(targetMiB, concurrency) {
 }
 
 function largeTokenCountProbe(mode) {
-  return runProbe(`
+  const samples = Array.from({ length: 3 }, () => runProbe(`
     const text = "a ".repeat(2 * 1024 * 1024);
     const started = performance.now();
     let tokens;
@@ -174,6 +182,51 @@ function largeTokenCountProbe(mode) {
       rss_mib: +(memory.rss / 1048576).toFixed(1),
       heap_used_mib: +(memory.heapUsed / 1048576).toFixed(1),
     }));
+  `));
+  return {
+    input_mib: samples[0].input_mib,
+    tokens: samples[0].tokens,
+    elapsed_ms: +median(samples.map((sample) => sample.elapsed_ms)).toFixed(1),
+    rss_mib: +median(samples.map((sample) => sample.rss_mib)).toFixed(1),
+    heap_used_mib: +median(samples.map((sample) => sample.heap_used_mib)).toFixed(1),
+    samples: samples.length,
+  };
+}
+
+function toolOutputParseCacheProbe() {
+  return runProbe(`
+    import { enforceResponsesImageLimit } from "./src/responses-image-limit.mjs";
+    import { responsesHistoricalImageStats } from "./src/responses-byte-budget.mjs";
+    import { prepareResponsesChatPayload } from "./src/responses-chat-payload.mjs";
+
+    const item = {
+      type: "function_call_output",
+      call_id: "call_benchmark",
+      output: JSON.stringify([{ type: "input_text", text: "x".repeat(8 * 1024 * 1024) }]),
+    };
+    const source = item.output;
+    const originalParse = JSON.parse;
+    let parseCalls = 0;
+    JSON.parse = function countedParse(value, ...args) {
+      if (value === source) parseCalls += 1;
+      return originalParse.call(this, value, ...args);
+    };
+    const started = performance.now();
+    try {
+      enforceResponsesImageLimit([item]);
+      responsesHistoricalImageStats([item], 1);
+      await prepareResponsesChatPayload({
+        body: { model: "gpt-4o", input: [item] },
+        currentInputStart: 1,
+      }, { payloadOptions: { maxBytes: 30 * 1024 * 1024 } });
+    } finally {
+      JSON.parse = originalParse;
+    }
+    process.stdout.write(JSON.stringify({
+      output_mib: +(Buffer.byteLength(source) / 1048576).toFixed(1),
+      parse_calls: parseCalls,
+      elapsed_ms: +(performance.now() - started).toFixed(1),
+    }));
   `);
 }
 
@@ -373,6 +426,7 @@ if (checkMode) {
     proxy: largeTokenCountProbe("proxy"),
     materialized_array: largeTokenCountProbe("array"),
   };
+  report.tool_output_parse_cache = toolOutputParseCacheProbe();
   report.large_payload_peak = [
     largePayloadProbe(5, 4),
     largePayloadProbe(30, 1),
@@ -409,6 +463,9 @@ if (checkMode) {
   if (proxy.heap_used_mib > array.heap_used_mib * 0.75) {
     failures.push(`token counter heap regression: proxy=${proxy.heap_used_mib}MiB array=${array.heap_used_mib}MiB`);
   }
+  if (report.tool_output_parse_cache.parse_calls !== 1) {
+    failures.push(`stringified tool output parsed ${report.tool_output_parse_cache.parse_calls} times instead of once`);
+  }
   for (const payload of report.large_payload_peak) {
     if (payload.admission_max_active_mib > payload.admission_budget_mib) {
       failures.push(`request admission exceeded its budget at ${payload.target_request_mib}MiB x${payload.concurrency}`);

package/src/adapter.mjs

@@ -215,6 +215,7 @@ export function createAdapterHandler(options = {}) {
         codexModelRegistry,
         claudeModelRegistry,
         claudeMode,
+        isClaudeProfileCurrent: options.isClaudeProfileCurrent,
       })));
       return;
     }

package/src/cli-auth.mjs

@@ -21,6 +21,7 @@ import {
   normalizeGithubIdentity,
 } from "./github-identity.mjs";
 import { saveModelCache } from "./model-cache.mjs";
+import { isClaudeCopilotModel } from "./models.mjs";
 import { profileRouting } from "./profile-routing.mjs";
 import { status } from "./status.mjs";
 
@@ -145,17 +146,7 @@ async function codexIdentity({ home, fetchImpl, signal }) {
 function claudeModels(payload) {
   const models = Array.isArray(payload) ? payload : payload?.data;
   if (!Array.isArray(models)) throw new Error("Claude account model catalog contained no model list");
-  return models.filter((model) => {
-    const id = String(model?.id || "").trim();
-    const vendor = String(model?.vendor || model?.owned_by || "").trim().toLowerCase();
-    const policy = String(model?.policy?.state || "").trim().toLowerCase();
-    const endpoints = Array.isArray(model?.supported_endpoints) ? model.supported_endpoints : [];
-    return Boolean(id)
-      && (id.toLowerCase().startsWith("claude-") || vendor === "anthropic")
-      && model?.model_picker_enabled === true
-      && (!policy || policy === "enabled")
-      && (endpoints.includes("/chat/completions") || endpoints.includes("/v1/messages"));
-  });
+  return models.filter(isClaudeCopilotModel);
 }
 
 function catalogModels(payload) {

package/src/cli-models.mjs

@@ -6,6 +6,10 @@ import {
   readAuthProfileCredentials,
 } from "./auth-profile.mjs";
 import { buildHeaders, DEFAULT_API_BASE, FALLBACK_VSCODE_VERSION } from "./copilot.mjs";
+import {
+  isClaudeCopilotCatalogEntry,
+  isClaudeCopilotModel,
+} from "./models.mjs";
 import { status } from "./status.mjs";
 
 const DEFAULT_MODELS_TIMEOUT_MS = 10000;
@@ -37,11 +41,15 @@ export function selectableCopilotModels(payload) {
   const models = [];
   const seen = new Set();
   for (const model of data) {
-    if (model?.model_picker_enabled !== true) continue;
-    const policyState = safeText(model?.policy?.state).toLowerCase();
-    if (policyState && policyState !== "enabled") continue;
-    const capabilityType = safeText(model?.capabilities?.type).toLowerCase();
-    if (capabilityType && capabilityType !== "chat") continue;
+    if (isClaudeCopilotCatalogEntry(model)) {
+      if (!isClaudeCopilotModel(model)) continue;
+    } else {
+      if (model?.model_picker_enabled !== true) continue;
+      const policyState = safeText(model?.policy?.state).toLowerCase();
+      if (policyState && policyState !== "enabled") continue;
+      const capabilityType = safeText(model?.capabilities?.type).toLowerCase();
+      if (capabilityType && capabilityType !== "chat") continue;
+    }
 
     const id = safeText(model?.id);
     const endpoints = endpointLabels(model);
@@ -163,8 +171,7 @@ export function formatLiveCopilotModels(catalog, { commandName = "ccdx" } = {})
   const profile = catalog?.profile === AUTH_PROFILE_CLAUDE ? AUTH_PROFILE_CLAUDE : AUTH_PROFILE_CODEX;
   const responses = models.filter((model) => model.endpoints.includes("responses")).length;
   const chat = models.filter((model) => model.endpoints.includes("chat")).length;
-  const claude = models.filter((model) => model.id.toLowerCase().startsWith("claude-")
-    || model.vendor.toLowerCase() === "anthropic").length;
+  const claude = models.filter(isClaudeCopilotCatalogEntry).length;
   const lines = [
     `${commandName} models${profile === AUTH_PROFILE_CLAUDE ? " --profile claude" : ""}`,
     status("ok", `Live catalog from ${safeText(catalog?.upstreamHost, "GitHub Copilot")}: ${models.length} selectable of ${Number(catalog?.advertised) || 0} advertised`),

package/src/copilot-client.mjs

@@ -150,6 +150,7 @@ export function createCopilotClientRuntime({
   }
 
   async function responses(reqBody, {
+    assertActive,
     signal,
     fetchImpl,
     retryOptions,
@@ -160,13 +161,14 @@ export function createCopilotClientRuntime({
   } = {}) {
     const token = await tokenSession.getToken({ signal });
     const preparedPayload = await prepareResponsesPayload(reqBody, {
+      assertActive,
       ...payloadOptions,
       currentInputStart,
       profiles: payloadPrepared ? [] : payloadOptions.profiles,
       skipInitialOptimization: payloadPrepared || payloadOptions.skipInitialOptimization,
       signal,
     });
-    const finalizedPayload = enforceResponsesPayloadByteBudget(reqBody, preparedPayload);
+    const finalizedPayload = enforceResponsesPayloadByteBudget(reqBody, preparedPayload, { assertActive });
     const { bodyText, bodyBytes, stage, adapted } = finalizedPayload;
     const summary = finalizedPayload.stage === preparedPayload.stage
       ? preparedPayload.summary

package/src/doctor.mjs

@@ -12,7 +12,7 @@ import { claudeDesktopPaths } from "./claude-desktop-config.mjs";
 import { status } from "./status.mjs";
 import { buildHeaders, DEFAULT_API_BASE, FALLBACK_VSCODE_VERSION } from "./copilot.mjs";
 import { adapterBaseUrl, checkRunningAdapter } from "./running-adapter.mjs";
-import { CODEX_AUTO_REVIEW_MODEL } from "./models.mjs";
+import { CODEX_AUTO_REVIEW_MODEL, isClaudeCopilotModel } from "./models.mjs";
 import { loadModelCache } from "./model-cache.mjs";
 
 function localGatewayBaseUrl(host, port) {
@@ -66,7 +66,7 @@ function modelEndpoints(model) {
 
 export function selectCompatibilityModels(models, { claudeModels = models } = {}) {
   const data = copilotModelData(models).filter((model) => model?.model_picker_enabled !== false);
-  const claudeData = copilotModelData(claudeModels).filter((model) => model?.model_picker_enabled !== false);
+  const claudeData = copilotModelData(claudeModels);
   const responsesCandidates = data.filter((model) => {
     const id = String(model?.id || "");
     const endpoints = modelEndpoints(model);
@@ -74,12 +74,7 @@ export function selectCompatibilityModels(models, { claudeModels = models } = {}
   });
   const responsesOnly = [...responsesCandidates].reverse()
     .find((model) => !modelEndpoints(model).includes("/chat/completions"));
-  const claude = claudeData.find((model) => {
-    const id = String(model?.id || "");
-    const vendor = String(model?.vendor || "").toLowerCase();
-    return (id.startsWith("claude-") || vendor === "anthropic")
-      && modelEndpoints(model).includes("/chat/completions");
-  });
+  const claude = claudeData.find(isClaudeCopilotModel);
   return {
     responsesModel: String((responsesOnly || responsesCandidates[0])?.id || ""),
     claudeModel: String(claude?.id || ""),
@@ -588,6 +583,12 @@ export async function collectDoctorChecks({
       }
       if (!pm.adapter?.ok) {
         checks.push({ kind: "warn", message: "PM Studio relay is not currently available", fix: "ccdx start" });
+      } else if (!pm.runtime?.ok) {
+        checks.push({
+          kind: "warn",
+          message: "PM Studio relay is running, but its isolated routing is not ready",
+          fix: "stop the running adapter, then run ccdx start",
+        });
       }
     } else if (pm.app.state === "clean") {
       checks.push({

package/src/http-transport.mjs

@@ -47,29 +47,56 @@ function admissionAbortError(signal) {
   return error;
 }
 
-function createSupplementalAdmission({ maxWeight, maxQueued, waitTimeoutMs, label }) {
+function createSupplementalAdmission({ maxWeight, maxQueued, waitTimeoutMs, label, blockBehindExclusive = false }) {
   const queue = [];
   let activeWeight = 0;
+  let activeRequestedWeight = 0;
   let activeRequests = 0;
 
   const activate = (entry) => {
     entry.cleanup();
     activeWeight += entry.weight;
+    activeRequestedWeight += entry.requestedWeight;
     activeRequests += 1;
     let released = false;
-    entry.resolve(() => {
+    const release = () => {
       if (released) return;
       released = true;
       activeWeight = Math.max(0, activeWeight - entry.weight);
+      activeRequestedWeight = Math.max(0, activeRequestedWeight - entry.requestedWeight);
       activeRequests = Math.max(0, activeRequests - 1);
       drain();
+    };
+    release.resize = (requestedWeight) => {
+      if (released) return 0;
+      const parsedWeight = Number.isFinite(requestedWeight) && requestedWeight > 0
+        ? Math.ceil(requestedWeight)
+        : maxWeight;
+      const requested = Math.max(1, parsedWeight);
+      const weight = Math.min(requested, maxWeight);
+      if (weight > entry.weight) {
+        throw new RangeError(`${label} admission weight cannot grow`);
+      }
+      activeWeight = Math.max(0, activeWeight - (entry.weight - weight));
+      activeRequestedWeight = Math.max(0, activeRequestedWeight + requested - entry.requestedWeight);
+      entry.weight = weight;
+      entry.requestedWeight = requested;
+      drain();
+      return weight;
+    };
+    Object.defineProperties(release, {
+      weight: { get: () => released ? 0 : entry.weight },
+      requestedWeight: { get: () => released ? 0 : entry.requestedWeight },
+      maxWeight: { value: maxWeight },
     });
+    entry.resolve(release);
   };
 
   const drain = () => {
     for (let index = 0; index < queue.length;) {
       const entry = queue[index];
       if (activeWeight + entry.weight > maxWeight) {
+        if (blockBehindExclusive && entry.weight === maxWeight) break;
         index += 1;
         continue;
       }
@@ -83,8 +110,12 @@ function createSupplementalAdmission({ maxWeight, maxQueued, waitTimeoutMs, labe
     const parsedWeight = Number.isFinite(requestedWeight) && requestedWeight > 0
       ? Math.ceil(requestedWeight)
       : maxWeight;
-    const weight = Math.max(1, Math.min(parsedWeight, maxWeight));
-    if (queue.length >= maxQueued && activeWeight + weight > maxWeight) {
+    const requested = Math.max(1, parsedWeight);
+    const weight = Math.min(requested, maxWeight);
+    const blockedByExclusive = blockBehindExclusive
+      && queue.some((entry) => entry.weight === maxWeight);
+    const mustWait = blockedByExclusive || activeWeight + weight > maxWeight;
+    if (queue.length >= maxQueued && mustWait) {
       return Promise.reject(httpError(`${label} queue is full (${maxQueued} waiting)`, 503));
     }
 
@@ -92,6 +123,7 @@ function createSupplementalAdmission({ maxWeight, maxQueued, waitTimeoutMs, labe
       let timer;
       const entry = {
         weight,
+        requestedWeight: requested,
         resolve,
         cleanup: () => {
           if (timer) clearTimeout(timer);
@@ -120,7 +152,13 @@ function createSupplementalAdmission({ maxWeight, maxQueued, waitTimeoutMs, labe
     });
   };
 
-  acquire.stats = () => ({ activeWeight, activeRequests, queued: queue.length, maxWeight });
+  acquire.stats = () => ({
+    activeWeight,
+    activeRequestedWeight,
+    activeRequests,
+    queued: queue.length,
+    maxWeight,
+  });
   return acquire;
 }
 
@@ -143,6 +181,7 @@ export function createRequestAdmission({
     maxQueued: queueLimit,
     waitTimeoutMs: timeoutMs,
     label: "Decoded request body",
+    blockBehindExclusive: true,
   });
   const acquireResponseHistory = createSupplementalAdmission({
     maxWeight: byteLimit,
@@ -194,10 +233,30 @@ export function createRequestAdmission({
         releaseSupplemental();
         throw admissionAbortError(options?.signal);
       }
-      supplementalReleases.add(releaseSupplemental);
+      let supplementalReleased = false;
+      const releaseReservation = () => {
+        if (supplementalReleased) return;
+        supplementalReleased = true;
+        supplementalReleases.delete(releaseReservation);
+        releaseSupplemental();
+      };
+      releaseReservation.resize = (nextWeight) => {
+        if (supplementalReleased) return 0;
+        return releaseSupplemental.resize(nextWeight);
+      };
+      Object.defineProperties(releaseReservation, {
+        weight: { get: () => supplementalReleased ? 0 : releaseSupplemental.weight },
+        requestedWeight: {
+          get: () => supplementalReleased ? 0 : releaseSupplemental.requestedWeight,
+        },
+        maxWeight: { value: releaseSupplemental.maxWeight },
+      });
+      supplementalReleases.add(releaseReservation);
+      return releaseReservation;
     };
     release.acquireDecompression = (options) => acquireDecompression(1, options);
     release.reserveDecodedBody = (bytes, options) => reserve(acquireDecodedBody, bytes, options);
+    release.reserveDecodedBody.supportsResize = true;
     release.reserveResponseHistory = (bytes, options) => reserve(acquireResponseHistory, bytes, options);
     entry.resolve(release);
   };
@@ -285,7 +344,8 @@ export function createRequestAdmission({
     waitMsMax: counters.waitMsMax,
     decompressionsActive: acquireDecompression.stats().activeRequests,
     decompressionsQueued: acquireDecompression.stats().queued,
-    decodedBodyBytes: acquireDecodedBody.stats().activeWeight,
+    decodedBodyBytes: acquireDecodedBody.stats().activeRequestedWeight,
+    decodedBodyAdmissionBytes: acquireDecodedBody.stats().activeWeight,
     decodedBodiesActive: acquireDecodedBody.stats().activeRequests,
     decodedBodiesQueued: acquireDecodedBody.stats().queued,
     responseHistoryBytes: acquireResponseHistory.stats().activeWeight,
@@ -445,21 +505,62 @@ export async function readJsonBody(req, {
     return parseRequestJson(await readIdentityText(req, maxBodyBytes, maxDecodedBodyBytes, signal));
   }
   const buffer = await readRequestBuffer(req, maxBodyBytes, signal);
-  const releaseDecompression = await admission?.acquireDecompression?.({ signal }) || (() => {});
+  let releaseDecompression = () => {};
+  let decodedReservation;
+  let retainDecodedReservation = false;
   try {
     let decoded;
+    const supportsResizableReservation = admission?.reserveDecodedBody?.supportsResize === true;
+    // Most compressed bodies fit the existing 4x admission estimate. High-ratio bodies retry
+    // only after obtaining the pool's exclusive reservation, so a full decoded body never waits
+    // outside the decoded-body budget.
+    const estimatedDecodedBytes = Math.max(
+      1,
+      Math.min(buffer.length * COMPRESSED_BODY_WEIGHT_MULTIPLIER, maxDecodedBodyBytes),
+    );
+    if (supportsResizableReservation) {
+      decodedReservation = await admission.reserveDecodedBody(estimatedDecodedBytes, { signal });
+    }
+    releaseDecompression = await admission?.acquireDecompression?.({ signal }) || (() => {});
+    const reservedBytes = decodedReservation?.requestedWeight;
+    const reservedAdmissionBytes = decodedReservation?.weight;
+    const decodedPoolBytes = decodedReservation?.maxWeight;
+    const tentativeDecodeLimit = Number.isFinite(reservedBytes)
+      && Number.isFinite(reservedAdmissionBytes)
+      && Number.isFinite(decodedPoolBytes)
+      && reservedAdmissionBytes < decodedPoolBytes
+      ? Math.min(reservedBytes, maxDecodedBodyBytes)
+      : maxDecodedBodyBytes;
     try {
-      decoded = await decodeRequestBuffer(buffer, req.headers?.["content-encoding"], maxDecodedBodyBytes);
+      decoded = await decodeRequestBuffer(buffer, req.headers?.["content-encoding"], tentativeDecodeLimit);
     } catch (e) {
-      if (e?.statusCode) throw e;
-      throw httpError(`Invalid compressed request body: ${e.message}`, 400);
+      if (e?.statusCode === 413 && tentativeDecodeLimit < maxDecodedBodyBytes && supportsResizableReservation) {
+        releaseDecompression();
+        releaseDecompression = () => {};
+        decodedReservation();
+        decodedReservation = await admission.reserveDecodedBody(maxDecodedBodyBytes, { signal });
+        releaseDecompression = await admission.acquireDecompression?.({ signal }) || (() => {});
+        try {
+          decoded = await decodeRequestBuffer(buffer, req.headers?.["content-encoding"], maxDecodedBodyBytes);
+        } catch (retryError) {
+          if (retryError?.statusCode) throw retryError;
+          throw httpError(`Invalid compressed request body: ${retryError.message}`, 400);
+        }
+      } else {
+        if (e?.statusCode) throw e;
+        throw httpError(`Invalid compressed request body: ${e.message}`, 400);
+      }
     }
     if (signal?.aborted) throw admissionAbortError(signal);
     if (decoded.length > 0) {
-      await admission?.reserveDecodedBody?.(decoded.length, { signal });
+      if (supportsResizableReservation) decodedReservation.resize(decoded.length);
+      else decodedReservation = await admission?.reserveDecodedBody?.(decoded.length, { signal });
     }
-    return parseRequestJson(decoded.toString("utf8"));
+    const parsed = parseRequestJson(decoded.toString("utf8"));
+    retainDecodedReservation = true;
+    return parsed;
   } finally {
+    if (!retainDecodedReservation) decodedReservation?.();
     releaseDecompression();
   }
 }

package/src/image-optimization.mjs

@@ -273,9 +273,11 @@ export async function runWithConcurrency(taskFns, concurrency) {
   }));
 }
 
-function visitImageParts(parts, references, commit = null) {
+function visitImageParts(parts, references, commit = null, assertActive) {
   if (!Array.isArray(parts)) return;
-  for (const part of parts) {
+  for (let index = 0; index < parts.length; index += 1) {
+    if ((index & 63) === 0) assertActive?.();
+    const part = parts[index];
     const image = readResponsesImagePart(part);
     if (!image?.identity) continue;
     references.push({
@@ -286,22 +288,24 @@ function visitImageParts(parts, references, commit = null) {
   }
 }
 
-function collectImageReferences(reqBody) {
+function collectImageReferences(reqBody, assertActive) {
   const references = [];
   const dirtyCommits = new Set();
   if (!Array.isArray(reqBody?.input)) {
     return { references, markDirty() {}, commitDirty() {} };
   }
 
-  for (const item of reqBody.input) {
+  for (let index = 0; index < reqBody.input.length; index += 1) {
+    if ((index & 63) === 0) assertActive?.();
+    const item = reqBody.input[index];
     if (!item) continue;
-    visitImageParts([item], references);
+    visitImageParts([item], references, null, assertActive);
     if (item.type === "message" && Array.isArray(item.content)) {
-      visitImageParts(item.content, references);
+      visitImageParts(item.content, references, null, assertActive);
     }
     const toolOutput = readResponsesToolOutputParts(item);
     if (toolOutput) {
-      visitImageParts(toolOutput.parts, references, toolOutput.commit);
+      visitImageParts(toolOutput.parts, references, toolOutput.commit, assertActive);
     }
   }
 
@@ -320,6 +324,7 @@ function collectImageReferences(reqBody) {
 }
 
 async function optimizeImageReferences(collection, {
+  assertActive,
   concurrency,
   model,
   optimizeImage,
@@ -334,7 +339,9 @@ async function optimizeImageReferences(collection, {
     return optimizedByDataUrl.get(identity);
   };
   const tasks = collection.references.map((reference) => async () => {
+    assertActive?.();
     if (reference.set(await optimizeOnce(reference.get()))) collection.markDirty([reference]);
+    assertActive?.();
   });
   if (tasks.length) await runWithConcurrency(tasks, concurrency);
   collection.commitDirty();
@@ -346,9 +353,11 @@ function imageInputBytes(dataUrl) {
   return match ? Buffer.byteLength(match[1], "base64") : 0;
 }
 
-function uniqueOriginalImages(references) {
+function uniqueOriginalImages(references, assertActive) {
   const unique = new Map();
-  for (const reference of references) {
+  for (let index = 0; index < references.length; index += 1) {
+    if ((index & 63) === 0) assertActive?.();
+    const reference = references[index];
     const dataUrl = reference.get();
     const identity = canonicalInlineImageIdentity(dataUrl);
     if (!identity) continue;
@@ -422,6 +431,7 @@ export async function optimizeImagesInBody(reqBody, {
 }
 
 export async function prepareResponsesPayload(reqBody, {
+  assertActive,
   currentInputStart = 0,
   maxBytes = MAX_UPSTREAM_BODY_BYTES,
   optimizeImage = optimizeImageDataUrl,
@@ -429,18 +439,22 @@ export async function prepareResponsesPayload(reqBody, {
   skipInitialOptimization = false,
   signal,
 } = {}) {
+  assertActive?.();
   const shouldOptimizeImages = !IMG_OPT_DISABLED && !skipInitialOptimization;
-  const collection = shouldOptimizeImages ? collectImageReferences(reqBody) : null;
-  const originalImages = collection ? uniqueOriginalImages(collection.references) : [];
+  const collection = shouldOptimizeImages ? collectImageReferences(reqBody, assertActive) : null;
+  const originalImages = collection ? uniqueOriginalImages(collection.references, assertActive) : [];
   if (collection) {
     await optimizeImageReferences(collection, {
+      assertActive,
       concurrency: IMG_CONCURRENCY,
       model: reqBody.model,
       optimizeImage: (dataUrl, options) => optimizeImage(dataUrl, { ...options, quality: IMG_QUALITY }),
       signal,
     });
   }
+  assertActive?.();
   let bodyText = JSON.stringify(reqBody);
+  assertActive?.();
   let bodyBytes = Buffer.byteLength(bodyText);
   const summary = summarizeReqBody(reqBody);
   const targetBytes = positiveInt(maxBytes, MAX_UPSTREAM_BODY_BYTES);
@@ -450,11 +464,13 @@ export async function prepareResponsesPayload(reqBody, {
   if (collection && originalImages.length > 0 && bodyBytes > targetBytes) {
     const batchSize = Math.max(1, IMG_CONCURRENCY);
     for (const profile of Array.isArray(profiles) ? profiles : []) {
+      assertActive?.();
       const beforeBytes = bodyBytes;
       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) {
+        assertActive?.();
         const batch = orderedImages.slice(index, index + batchSize);
         const candidates = await Promise.all(batch.map((image) => optimizeImage(image.dataUrl, {
           ...profile,
@@ -462,6 +478,7 @@ export async function prepareResponsesPayload(reqBody, {
           model: reqBody.model,
           signal,
         })));
+        assertActive?.();
         for (let offset = 0; offset < batch.length && bodyBytes > targetBytes; offset += 1) {
           processed += 1;
           const applied = applyImageCandidate(collection, batch[offset], candidates[offset], bodyBytes);
@@ -469,19 +486,24 @@ export async function prepareResponsesPayload(reqBody, {
           adapted ||= applied.changed;
           if (bodyBytes <= targetBytes) {
             collection.commitDirty();
+            assertActive?.();
             bodyText = JSON.stringify(reqBody);
+            assertActive?.();
             bodyBytes = Buffer.byteLength(bodyText);
           }
         }
       }
       collection.commitDirty();
+      assertActive?.();
       bodyText = JSON.stringify(reqBody);
+      assertActive?.();
       bodyBytes = Buffer.byteLength(bodyText);
       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;
     }
   }
 
+  assertActive?.();
   return {
     bodyText,
     bodyBytes,

package/src/legacy-command-warning.mjs

@@ -30,8 +30,9 @@ export function shouldShowLegacyCommandWarning({
   }
   try {
     atomicWriteFileSync(filePath, `${now}\n`, { mode: 0o600 });
+    return true;
   } catch {
-    // The warning remains best effort when the cache directory is read-only.
+    // Stay silent when the throttle cannot persist, otherwise every invocation would warn.
+    return false;
   }
-  return true;
 }