codex-copilot-dx 0.6.5 → 0.6.7

package/src/cli-table.mjs

@@ -0,0 +1,114 @@
+import { stripVTControlCharacters } from "node:util";
+
+const DEFAULT_TERMINAL_COLUMNS = 120;
+const COMBINING_MARK = /\p{Mark}/u;
+const EMOJI = /\p{Extended_Pictographic}|\p{Regional_Indicator}/u;
+const SIMPLE_WIDTH = /^[\u0020-\u007e\u2014]*$/;
+let graphemeSegmenter;
+
+function wideCodePoint(codePoint) {
+  return codePoint >= 0x1100 && (
+    codePoint <= 0x115f
+    || codePoint === 0x2329
+    || codePoint === 0x232a
+    || (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f)
+    || (codePoint >= 0xac00 && codePoint <= 0xd7a3)
+    || (codePoint >= 0xf900 && codePoint <= 0xfaff)
+    || (codePoint >= 0xfe10 && codePoint <= 0xfe19)
+    || (codePoint >= 0xfe30 && codePoint <= 0xfe6f)
+    || (codePoint >= 0xff00 && codePoint <= 0xff60)
+    || (codePoint >= 0xffe0 && codePoint <= 0xffe6)
+    || (codePoint >= 0x20000 && codePoint <= 0x3fffd)
+  );
+}
+
+function graphemeWidth(segment) {
+  if (EMOJI.test(segment)) return 2;
+  let width = 0;
+  for (const character of segment) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint === 0x200d || (codePoint >= 0xfe00 && codePoint <= 0xfe0f) || COMBINING_MARK.test(character)) continue;
+    width += wideCodePoint(codePoint) ? 2 : 1;
+  }
+  return width;
+}
+
+function displayWidth(value) {
+  if (SIMPLE_WIDTH.test(value)) return value.length;
+  graphemeSegmenter ||= new Intl.Segmenter("en", { granularity: "grapheme" });
+  let width = 0;
+  for (const { segment } of graphemeSegmenter.segment(value)) width += graphemeWidth(segment);
+  return width;
+}
+
+function padding(length) {
+  return length > 0 ? " ".repeat(length) : "";
+}
+
+function padded(value, width, align) {
+  const spaces = padding(width - displayWidth(value));
+  return align === "right" ? `${spaces}${value}` : `${value}${spaces}`;
+}
+
+export function terminalCell(value, { fallback = "—" } = {}) {
+  if (value === undefined || value === null) return fallback;
+  const text = stripVTControlCharacters(String(value))
+    .replace(/[\u0000-\u001f\u007f-\u009f]/g, " ")
+    .replace(/[\u061c\u200b\u200e\u200f\u202a-\u202e\u2060\u2066-\u2069\ufeff]/g, "")
+    .replace(/\s+/g, " ")
+    .trim();
+  return text || fallback;
+}
+
+export function cliOutputFormat(format = "auto", output = process.stdout) {
+  if (format === "table" || format === "plain") return format;
+  return output?.isTTY === true ? "table" : "plain";
+}
+
+export function cliOutputWidth(output = process.stdout) {
+  const columns = Number(output?.columns);
+  return Number.isSafeInteger(columns) && columns > 0 ? columns : DEFAULT_TERMINAL_COLUMNS;
+}
+
+export function formatCliTable({ columns, rows, gap = 2 }) {
+  const normalizedColumns = columns.map((column) => ({
+    ...column,
+    label: terminalCell(column.label, { fallback: "" }),
+  }));
+  const normalizedRows = rows.map((row) => Object.fromEntries(normalizedColumns.map((column) => [
+    column.key,
+    terminalCell(row[column.key]),
+  ])));
+  const widths = normalizedColumns.map((column) => Math.max(
+    displayWidth(column.label),
+    ...normalizedRows.map((row) => displayWidth(row[column.key])),
+  ));
+  const line = (values) => normalizedColumns
+    .map((column, index) => padded(values[column.key], widths[index], column.align))
+    .join(" ".repeat(gap))
+    .trimEnd();
+  const header = Object.fromEntries(normalizedColumns.map((column) => [column.key, column.label]));
+  const separator = Object.fromEntries(normalizedColumns.map((column, index) => [
+    column.key,
+    "-".repeat(widths[index]),
+  ]));
+  return [line(header), line(separator), ...normalizedRows.map(line)].join("\n");
+}
+
+export function cliTableWidth(table) {
+  return Math.max(0, ...String(table).split("\n").map(displayWidth));
+}
+
+export function formatResponsiveCliTable({ columns, compactColumns, rows, width = DEFAULT_TERMINAL_COLUMNS, gap = 2 }) {
+  const full = formatCliTable({ columns, rows, gap });
+  const fullWidth = cliTableWidth(full);
+  if (!compactColumns?.length || fullWidth <= width) {
+    return { output: full, compact: false, overflow: fullWidth > width };
+  }
+  const compact = formatCliTable({ columns: compactColumns, rows, gap });
+  return {
+    output: compact,
+    compact: true,
+    overflow: cliTableWidth(compact) > width,
+  };
+}

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;
 }

package/src/models.mjs

@@ -95,11 +95,6 @@ function numericLimit(value, fallback) {
   return Number.isFinite(value) && value > 0 ? value : fallback;
 }
 
-function hasMessagesEndpoint(model) {
-  const endpoints = Array.isArray(model?.supported_endpoints) ? model.supported_endpoints : [];
-  return endpoints.includes("/v1/messages") || endpoints.includes("/chat/completions");
-}
-
 function hasOpenAIEndpoint(model) {
   const endpoints = Array.isArray(model?.supported_endpoints) ? model.supported_endpoints : [];
   return endpoints.includes("/responses") || endpoints.includes("/v1/responses") || endpoints.includes("/chat/completions");
@@ -140,13 +135,22 @@ function uniqueIds(models, predicate) {
   return ids;
 }
 
-function isClaudeCopilotModel(model) {
+export function isClaudeCopilotCatalogEntry(model) {
   const id = String(model?.id || "").trim();
-  const vendor = String(model?.vendor || "").toLowerCase();
-  return id
-    && (id.startsWith("claude-") || vendor === "anthropic")
+  const vendor = String(model?.vendor || model?.owned_by || "").trim().toLowerCase();
+  return Boolean(id) && (id.toLowerCase().startsWith("claude-") || vendor === "anthropic");
+}
+
+export function isClaudeCopilotModel(model) {
+  const policy = String(model?.policy?.state || "").trim().toLowerCase();
+  const declaredOwners = [model?.vendor, model?.owned_by]
+    .map((value) => String(value || "").trim().toLowerCase())
+    .filter(Boolean);
+  return isClaudeCopilotCatalogEntry(model)
+    && declaredOwners.every((owner) => owner === "anthropic")
     && model?.model_picker_enabled !== false
-    && hasMessagesEndpoint(model);
+    && (!policy || policy === "enabled")
+    && modelSupportsChatCompletions(model);
 }
 
 export function gptModelIdsFromCopilotModels(models) {

package/src/observability.mjs

@@ -150,6 +150,15 @@ function safeClientRuntimeStatus(client) {
   };
 }
 
+function safeProfileCurrent(checkProfileCurrent) {
+  if (typeof checkProfileCurrent !== "function") return false;
+  try {
+    return checkProfileCurrent() === true;
+  } catch {
+    return false;
+  }
+}
+
 export function runtimeStatusPayload({
   metrics,
   streamPerformance,
@@ -161,6 +170,7 @@ export function runtimeStatusPayload({
   codexModelRegistry,
   claudeModelRegistry,
   claudeMode = "inherited",
+  isClaudeProfileCurrent,
 } = {}) {
   const memory = process.memoryUsage();
   const resolvedClaudeMode = claudeMode === "isolated" ? "isolated" : "inherited";
@@ -172,6 +182,8 @@ export function runtimeStatusPayload({
   const claudeModels = resolvedClaudeMode === "isolated"
     ? modelRegistryStatus(claudeModelRegistry)
     : codexModels;
+  const claudeProfileCurrent = resolvedClaudeMode === "isolated"
+    && safeProfileCurrent(isClaudeProfileCurrent);
   return {
     ...adapterHealthPayload(),
     uptime_ms: Math.round(process.uptime() * 1000),
@@ -192,7 +204,12 @@ export function runtimeStatusPayload({
     models: codexModels,
     profiles: {
       codex: { mode: "legacy", client: codexRuntime, models: codexModels },
-      claude: { mode: resolvedClaudeMode, client: claudeRuntime, models: claudeModels },
+      claude: {
+        mode: resolvedClaudeMode,
+        profile_current: claudeProfileCurrent,
+        client: claudeRuntime,
+        models: claudeModels,
+      },
     },
     routing: profileRouting({ claudeMode: resolvedClaudeMode }),
     limits: {