codex-copilot-dx 0.6.18 → 0.6.19

package/README.md

@@ -378,6 +378,8 @@ Environment variables:
 | `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_INFLIGHT_BODY_BYTES` | `33554432` | Per-pool byte budget for raw bodies, decoded bodies, and materialized response history; a larger item runs exclusively in its pool |
+| `CCDX_MAX_UPSTREAM_CHAT_RESPONSE_BYTES` | `67108864` | Maximum buffered successful Chat Completions response used by Responses, Anthropic, and PM Studio conversion paths |
+| `CCDX_MAX_UPSTREAM_RESPONSES_RESPONSE_BYTES` | `268435456` | Maximum buffered successful native Responses or compact response; streaming Responses are forwarded with bounded backpressure instead |
 | `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_REQUEST_BODY_TIMEOUT_MS` | `120000` | Maximum time to receive and decode one request body before returning `408` |

package/bin/cli.mjs

@@ -17,6 +17,7 @@ import { assertSafeAdapterHost, isLoopbackHost } from "../src/security.mjs";
 import { runInBackground } from "../src/startup.mjs";
 import { cliCommandName, cliHelp, parseAdapterProbeOptions, parseCliArgs, parseRuntimeOptions } from "../src/cli-options.mjs";
 import { formatAdapterStatus, readAdapterStatus } from "../src/cli-status.mjs";
+import { formatCliError } from "../src/cli-error.mjs";
 import { closeHttpServer } from "../src/shutdown.mjs";
 import { runAutoReviewModelCommand } from "../src/auto-review-model.mjs";
 import { autoReviewModelPreference } from "../src/user-settings.mjs";
@@ -152,7 +153,7 @@ if (CLI.command === "pms") {
     await runPmStudioSetup({ commandName: CLI_NAME });
     process.exit(0);
   } catch (e) {
-    console.error(status("err", e.message));
+    console.error(formatCliError(e));
     process.exit(1);
   }
 }

package/package.json

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

package/src/adapter.mjs

@@ -15,6 +15,7 @@ import { createPmStudioRelayHandler, PM_STUDIO_RELAY_PREFIX } from "./pm-studio-
 import { createStreamPerformanceMetrics } from "./stream-performance.mjs";
 import { status } from "./status.mjs";
 import { createTerminalActivityIndicator } from "./terminal-activity.mjs";
+import { createTokenCounterService } from "./token-counter-service.mjs";
 import { ADAPTER_HEALTH_PATH, adapterHealthPayload } from "./running-adapter.mjs";
 import { createResponsesCompactHandler, createResponsesHandler } from "./responses-handler.mjs";
 import { createResponsesImagePressureController } from "./responses-image-pressure.mjs";
@@ -145,6 +146,11 @@ export function createAdapterHandler(options = {}) {
   const requestMetrics = options.requestMetrics || createRequestMetrics();
   const streamPerformanceMetrics = options.streamPerformanceMetrics || createStreamPerformanceMetrics();
   const imagePressure = options.imagePressure || createResponsesImagePressureController();
+  const ownsTokenCounterService = !options.tokenCounterService;
+  const tokenCounterService = options.tokenCounterService || createTokenCounterService({
+    timeoutMs: options.countTokensTimeoutMs,
+    maxQueued: options.countTokensMaxQueued,
+  });
   const claudeDesktopModelOptions = () => {
     const modelDefs = claudeModelRegistry?.modelDefs || options.claudeDesktopModelDefs;
     return Array.isArray(modelDefs) ? { modelDefs } : {};
@@ -178,7 +184,11 @@ export function createAdapterHandler(options = {}) {
     streamIdleTimeoutMs,
     upstreamTimeoutMs,
   });
-  const anthropicCountTokensHandler = createAnthropicCountTokensHandler({ acquireRequest, requestBodyTimeoutMs });
+  const anthropicCountTokensHandler = createAnthropicCountTokensHandler({
+    acquireRequest,
+    requestBodyTimeoutMs,
+    countTokensFn: (body, countOptions) => tokenCounterService.count(body, countOptions),
+  });
   const anthropicMessagesHandler = createAnthropicMessagesHandler({
     acquireRequest,
     chatCompletionsFn: claudeChatCompletionsFn,
@@ -300,7 +310,7 @@ export function createAdapterHandler(options = {}) {
     ? options.dispatchRequestForTests
     : dispatch;
 
-  return (req, res) => {
+  const handler = (req, res) => {
     const requestId = createRequestId();
     if (typeof res.setHeader === "function") {
       res.setHeader("X-Request-Id", requestId);
@@ -378,6 +388,10 @@ export function createAdapterHandler(options = {}) {
       containUnexpectedError(error);
     }
   };
+  handler.cleanup = () => {
+    if (ownsTokenCounterService) tokenCounterService.close();
+  };
+  return handler;
 }
 
 // Public server entry point.
@@ -385,9 +399,11 @@ export function createAdapterHandler(options = {}) {
 export function startAdapter(port = 2026, host = "127.0.0.1", options = {}) {
   const ownsTerminalActivity = !Object.hasOwn(options, "terminalActivity");
   const terminalActivity = ownsTerminalActivity ? createTerminalActivityIndicator() : options.terminalActivity;
-  const server = http.createServer(createAdapterHandler({ ...options, terminalActivity }));
+  const handler = createAdapterHandler({ ...options, terminalActivity });
+  const server = http.createServer(handler);
   const cleanupTerminalActivity = () => {
     if (ownsTerminalActivity) terminalActivity?.cleanup?.();
+    handler.cleanup?.();
   };
   server.once("close", cleanupTerminalActivity);
 

package/src/anthropic-handler.mjs

@@ -7,6 +7,7 @@ import {
 import {
   createRequestAbort,
   logRequestFailure,
+  MAX_UPSTREAM_CHAT_SUCCESS_BODY_BYTES,
   MAX_UPSTREAM_ERROR_BODY_BYTES,
   readJsonBody,
   readBoundedResponseText,
@@ -60,7 +61,7 @@ function sendAnthropicUpstreamError(res, response, text) {
 }
 
 export function createAnthropicCountTokensHandler(options) {
-  const { acquireRequest, requestBodyTimeoutMs } = options;
+  const { acquireRequest, requestBodyTimeoutMs, countTokensFn = countTokens } = options;
 
   return async function handleAnthropicCountTokens(req, res) {
     const abort = createRequestAbort(req, res);
@@ -70,12 +71,12 @@ export function createAnthropicCountTokensHandler(options) {
       abort.setTimeout(requestBodyTimeoutMs, "request_body_timeout");
       const parsed = await readJsonBody(req, { admission: releaseRequest, signal: abort.signal });
       abort.clearTimeout();
-      const result = await countTokens(parsed);
+      const result = await countTokensFn(parsed, { signal: abort.signal });
       releaseRequest();
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(JSON.stringify(result));
     } catch (error) {
-      sendJsonError(res, error, abort.reason === "request_body_timeout" ? 408 : 400);
+      sendJsonError(res, error, abort.reason === "request_body_timeout" ? 408 : 500);
     } finally {
       releaseRequest();
       abort.cleanup();
@@ -157,7 +158,11 @@ export function createAnthropicMessagesHandler(options) {
         const upstream = await chatCompletionsFn({ ...chatReq, stream: false }, { signal: abort.signal });
         releaseRequest();
         const data = upstream.ok
-          ? await upstream.text()
+          ? await readBoundedResponseText(upstream, {
+            maxBytes: MAX_UPSTREAM_CHAT_SUCCESS_BODY_BYTES,
+            label: "Copilot Chat success body",
+            signal: abort.signal,
+          })
           : await readBoundedResponseText(upstream, {
             maxBytes: MAX_UPSTREAM_ERROR_BODY_BYTES,
             label: "Copilot Chat error body",

package/src/anthropic.mjs

@@ -350,8 +350,7 @@ export async function streamAnthropicFromLines(lineIterator, emit, model, option
   await emit("message_stop", { type: "message_stop" });
 }
 
-// Copilot has no count_tokens endpoint; estimate locally with gpt-tokenizer.
-export async function countTokens(body) {
+export function anthropicTokenText(body) {
   const parts = [];
   const sys = systemToText(body.system);
   if (sys) parts.push(sys);
@@ -374,7 +373,15 @@ export async function countTokens(body) {
     }
   }
 
-  const text = parts.join("\n");
+  return parts.join("\n");
+}
+
+export async function countTokenText(text) {
   const count = await tokenCounter();
   return { input_tokens: count(text) };
 }
+
+// Copilot has no count_tokens endpoint; estimate locally with gpt-tokenizer.
+export async function countTokens(body) {
+  return countTokenText(anthropicTokenText(body));
+}

package/src/cli-auth.mjs

@@ -21,6 +21,10 @@ import {
   githubTokenFingerprint,
   normalizeGithubIdentity,
 } from "./github-identity.mjs";
+import {
+  MAX_UPSTREAM_MODEL_CATALOG_BYTES,
+  readBoundedResponseText,
+} from "./http-transport.mjs";
 import { saveModelCache } from "./model-cache.mjs";
 import { isClaudeCopilotModel } from "./models.mjs";
 import { profileRouting } from "./profile-routing.mjs";
@@ -32,6 +36,8 @@ import {
   terminalCell,
 } from "./cli-table.mjs";
 
+const DEFAULT_COPILOT_CATALOG_TIMEOUT_MS = 30 * 1000;
+
 function openAndCopy(userCode, verificationUri) {
   if (process.platform !== "darwin") return;
   try {
@@ -50,6 +56,44 @@ function responseDetail(value) {
   return String(value || "").replace(/\s+/g, " ").trim().slice(0, 240);
 }
 
+function abortError(signal) {
+  if (signal?.reason instanceof Error) return signal.reason;
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  return error;
+}
+
+function cancelResponseBody(response) {
+  try { Promise.resolve(response?.body?.cancel?.()).catch(() => {}); } catch {}
+}
+
+function fetchWithSignal(operation, signal) {
+  if (signal?.aborted) return Promise.reject(abortError(signal));
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (callback, value) => {
+      if (settled) return false;
+      settled = true;
+      signal?.removeEventListener("abort", onAbort);
+      callback(value);
+      return true;
+    };
+    const onAbort = () => finish(reject, abortError(signal));
+    signal?.addEventListener("abort", onAbort, { once: true });
+    Promise.resolve()
+      .then(operation)
+      .then((response) => {
+        if (!finish(resolve, response)) cancelResponseBody(response);
+      }, (error) => finish(reject, error));
+  });
+}
+
+function catalogTimeoutError(label, timeoutMs) {
+  const error = new Error(`${label} model catalog timed out after ${timeoutMs}ms`);
+  error.code = "CCDX_COPILOT_CATALOG_TIMEOUT";
+  return error;
+}
+
 async function jsonResponse({ response, data, jsonError }, label) {
   if (!response.ok) {
     throw new Error(`${label} failed with HTTP ${response.status}`);
@@ -121,33 +165,58 @@ async function fetchCopilotCatalog(tokenData, {
   signal,
   vscodeVersion = FALLBACK_VSCODE_VERSION,
   label = "Copilot",
+  timeoutMs = DEFAULT_COPILOT_CATALOG_TIMEOUT_MS,
 } = {}) {
-  const apiBase = tokenData?.endpoints?.api || DEFAULT_API_BASE;
-  const headers = buildHeaders({
-    token: tokenData.token,
-    version: vscodeVersion,
-    initiator: "user",
-    vision: false,
-  });
-  const modelResponse = await fetchImpl(`${apiBase}/models`, {
-    headers,
-    redirect: "error",
-    signal,
-  });
-  const modelText = await modelResponse.text();
-  if (!modelResponse.ok) {
-    const detail = responseDetail(modelText);
-    throw new Error(`${label} model catalog failed with HTTP ${modelResponse.status}${detail ? `: ${detail}` : ""}`);
-  }
-
-  let catalog;
+  const parsedTimeout = Number(timeoutMs);
+  const deadlineMs = Number.isFinite(parsedTimeout) && parsedTimeout > 0
+    ? parsedTimeout
+    : DEFAULT_COPILOT_CATALOG_TIMEOUT_MS;
+  const controller = new AbortController();
+  const onCallerAbort = () => controller.abort(signal?.reason);
+  signal?.addEventListener("abort", onCallerAbort, { once: true });
+  if (signal?.aborted) onCallerAbort();
+  const timer = setTimeout(() => controller.abort(catalogTimeoutError(label, deadlineMs)), deadlineMs);
+  let modelResponse;
   try {
-    catalog = JSON.parse(modelText);
-  } catch {
-    throw new Error(`${label} model catalog returned invalid JSON`);
+    const apiBase = tokenData?.endpoints?.api || DEFAULT_API_BASE;
+    const headers = buildHeaders({
+      token: tokenData.token,
+      version: vscodeVersion,
+      initiator: "user",
+      vision: false,
+    });
+    modelResponse = await fetchWithSignal(() => fetchImpl(`${apiBase}/models`, {
+      headers,
+      redirect: "error",
+      signal: controller.signal,
+    }), controller.signal);
+    const modelText = await readBoundedResponseText(modelResponse, {
+      maxBytes: MAX_UPSTREAM_MODEL_CATALOG_BYTES,
+      label: `${label} model catalog`,
+      signal: controller.signal,
+    });
+    if (!modelResponse.ok) {
+      const detail = responseDetail(modelText);
+      throw new Error(`${label} model catalog failed with HTTP ${modelResponse.status}${detail ? `: ${detail}` : ""}`);
+    }
+
+    let catalog;
+    try {
+      catalog = JSON.parse(modelText);
+    } catch {
+      throw new Error(`${label} model catalog returned invalid JSON`);
+    }
+    catalogModels(catalog);
+    return { catalog, apiBase };
+  } catch (error) {
+    if (signal?.aborted) throw abortError(signal);
+    if (controller.signal.aborted) throw abortError(controller.signal);
+    throw error;
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", onCallerAbort);
+    if (controller.signal.aborted) cancelResponseBody(modelResponse);
   }
-  catalogModels(catalog);
-  return { catalog, apiBase };
 }
 
 export async function validateClaudeCandidate(githubToken, {
@@ -156,6 +225,7 @@ export async function validateClaudeCandidate(githubToken, {
   fetchImpl = fetch,
   signal,
   vscodeVersion = FALLBACK_VSCODE_VERSION,
+  catalogTimeoutMs,
 } = {}) {
   const validation = await validateGithubToken(githubToken, { fetchImpl, signal });
   if (!validation.ok) {
@@ -180,6 +250,7 @@ export async function validateClaudeCandidate(githubToken, {
     signal,
     vscodeVersion,
     label: "Claude account",
+    timeoutMs: catalogTimeoutMs,
   });
   const models = claudeModels(catalog);
   if (!models.length) {
@@ -205,6 +276,7 @@ export async function authorizeClaudeProfile({
   log = console.log,
   openAndCopyFn = openAndCopy,
   deviceCodeTimeoutMs,
+  catalogTimeoutMs,
   sleepImpl,
   now = Date.now,
   saveModelCacheFn = saveModelCache,
@@ -268,6 +340,7 @@ export async function authorizeClaudeProfile({
       expectedLogin,
       fetchImpl,
       signal,
+      catalogTimeoutMs,
     });
     await withAuthProfileLock(AUTH_PROFILE_CODEX, () => {
       const currentCodex = readAuthProfileCredentials(AUTH_PROFILE_CODEX, { home });

package/src/cli-error.mjs

@@ -0,0 +1,44 @@
+import { terminalCell } from "./cli-table.mjs";
+import { status } from "./status.mjs";
+
+const MAX_MESSAGE_CHARACTERS = 1024;
+const MAX_DETAIL_CHARACTERS = 512;
+const MAX_DETAILS = 16;
+
+function redactSensitiveValues(value) {
+  return value
+    .replace(/\b(authorization\s*[:=]\s*)(?:bearer\s+)?[^\s,;]+/gi, "$1[REDACTED]")
+    .replace(/\bbearer\s+[^\s,;]+/gi, "Bearer [REDACTED]")
+    .replace(/\b((?:api[-_ ]?key|access[-_ ]?token|refresh[-_ ]?token|password|secret)\s*[:=]\s*)[^\s,;]+/gi, "$1[REDACTED]")
+    .replace(/\b(?:github_pat_[A-Za-z0-9_]{8,}|gh[pousr]_[A-Za-z0-9_]{8,}|sk-[A-Za-z0-9_-]{8,})\b/g, "[REDACTED]");
+}
+
+function boundedTerminalText(value, fallback, maxCharacters) {
+  try {
+    return redactSensitiveValues(terminalCell(value, { fallback })).slice(0, maxCharacters);
+  } catch {
+    return fallback;
+  }
+}
+
+export function formatCliError(error) {
+  const message = boundedTerminalText(error?.message, "Command failed", MAX_MESSAGE_CHARACTERS);
+  let details;
+  try {
+    details = error?.details;
+  } catch {
+    details = undefined;
+  }
+  const values = details === undefined
+    ? []
+    : Array.isArray(details) ? details : [details];
+  const visible = values.slice(0, MAX_DETAILS);
+  const lines = [status("err", message)];
+  for (const detail of visible) {
+    lines.push(status("info", boundedTerminalText(detail, "Detail unavailable", MAX_DETAIL_CHARACTERS)));
+  }
+  if (values.length > visible.length) {
+    lines.push(status("info", `${values.length - visible.length} additional detail(s) omitted`));
+  }
+  return lines.join("\n");
+}

package/src/http-transport.mjs

@@ -20,6 +20,8 @@ const REQUEST_QUEUE_TIMEOUT_MS = HTTP_RUNTIME_CONFIG.requestQueueTimeoutMs;
 export const MAX_UPSTREAM_ERROR_BODY_BYTES = 1024 * 1024;
 export const MAX_UPSTREAM_MODEL_CATALOG_BYTES = 8 * 1024 * 1024;
 export const MAX_UPSTREAM_RETRY_DRAIN_BYTES = 64 * 1024;
+export const MAX_UPSTREAM_CHAT_SUCCESS_BODY_BYTES = HTTP_RUNTIME_CONFIG.maxUpstreamChatResponseBytes;
+export const MAX_UPSTREAM_RESPONSES_SUCCESS_BODY_BYTES = HTTP_RUNTIME_CONFIG.maxUpstreamResponsesResponseBytes;
 
 export function httpError(message, statusCode) {
   const err = new Error(message);
@@ -57,6 +59,37 @@ async function cancelResponseBody(response) {
   try { await response?.body?.cancel?.(); } catch {}
 }
 
+function responseAbortError(signal) {
+  if (signal?.reason instanceof Error) return signal.reason;
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  return error;
+}
+
+function readResponseChunk(reader, signal) {
+  if (!signal) return reader.read();
+  if (signal.aborted) return Promise.reject(responseAbortError(signal));
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (callback, value) => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      callback(value);
+    };
+    const onAbort = () => {
+      const error = responseAbortError(signal);
+      try { Promise.resolve(reader.cancel(error)).catch(() => {}); } catch {}
+      finish(reject, error);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    reader.read().then(
+      (value) => finish(resolve, value),
+      (error) => finish(reject, error),
+    );
+  });
+}
+
 function responseContentLength(response) {
   const raw = response?.headers?.get?.("content-length")
     ?? response?.headers?.["content-length"]
@@ -68,13 +101,23 @@ function responseContentLength(response) {
 export async function readBoundedResponseBuffer(response, {
   maxBytes,
   label = "Upstream response body",
+  signal,
 } = {}) {
   const limit = Number.isFinite(maxBytes) && maxBytes >= 0 ? Math.floor(maxBytes) : 0;
+  if (signal?.aborted) {
+    cancelResponseBody(response);
+    throw responseAbortError(signal);
+  }
   if (responseContentLength(response) > limit) {
     await cancelResponseBody(response);
     throw upstreamBodyTooLarge(label, limit);
   }
   if (!response?.body) {
+    if (typeof response?.text === "function") {
+      const buffer = Buffer.from(await response.text());
+      if (buffer.length > limit) throw upstreamBodyTooLarge(label, limit);
+      return buffer;
+    }
     if ((responseContentLength(response) || 0) > 0) throw unreadableUpstreamBody(label);
     return Buffer.alloc(0);
   }
@@ -84,7 +127,7 @@ export async function readBoundedResponseBuffer(response, {
   let total = 0;
   try {
     while (true) {
-      const { done, value } = await reader.read();
+      const { done, value } = await readResponseChunk(reader, signal);
       if (done) break;
       const chunk = Buffer.from(value);
       total += chunk.length;
@@ -96,7 +139,11 @@ export async function readBoundedResponseBuffer(response, {
     }
     return Buffer.concat(chunks, total);
   } finally {
-    reader.releaseLock();
+    try {
+      reader.releaseLock();
+    } catch (error) {
+      if (!signal?.aborted) throw error;
+    }
   }
 }
 

package/src/lock.mjs

@@ -149,8 +149,12 @@ function maybeRemoveAbandonedGuard(guardPath, staleMs, nowMs, io, processAlive)
       restoreQuarantinedLock(guardPath, quarantinePath, io);
       return false;
     }
-    io.unlinkSync(quarantinePath);
-    return true;
+    try {
+      io.unlinkSync(quarantinePath);
+      return true;
+    } catch {
+      return recoverQuarantineUnlinkFailure(guardPath, quarantinePath, snapshot, io);
+    }
   } catch (error) {
     return error?.code === "ENOENT";
   }
@@ -167,6 +171,18 @@ function restoreQuarantinedLock(lockPath, quarantinePath, io) {
   } catch {}
 }
 
+function recoverQuarantineUnlinkFailure(lockPath, quarantinePath, snapshot, io) {
+  restoreQuarantinedLock(lockPath, quarantinePath, io);
+  try {
+    const restored = readStaleLockSnapshot(lockPath, io);
+    if (!restored.safe || !sameLock(snapshot, restored)) return false;
+    io.unlinkSync(lockPath);
+    return true;
+  } catch (error) {
+    return error?.code === "ENOENT";
+  }
+}
+
 function maybeRemoveStaleLock(lockPath, staleMs, nowMs, io, processAlive) {
   if (!Number.isFinite(staleMs) || staleMs <= 0) return false;
   try {
@@ -192,8 +208,12 @@ function maybeRemoveStaleLock(lockPath, staleMs, nowMs, io, processAlive) {
         restoreQuarantinedLock(lockPath, quarantinePath, io);
         return false;
       }
-      io.unlinkSync(quarantinePath);
-      return true;
+      try {
+        io.unlinkSync(quarantinePath);
+        return true;
+      } catch {
+        return recoverQuarantineUnlinkFailure(lockPath, quarantinePath, current, io);
+      }
     } finally {
       removeOwnedLock(guard.guardPath, guard.owner, io);
     }

package/src/pm-studio-relay.mjs

@@ -5,6 +5,10 @@ import {
   createRequestAdmission,
   httpError,
   isAbortLikeError,
+  MAX_UPSTREAM_CHAT_SUCCESS_BODY_BYTES,
+  MAX_UPSTREAM_ERROR_BODY_BYTES,
+  MAX_UPSTREAM_MODEL_CATALOG_BYTES,
+  readBoundedResponseBuffer,
   readJsonBody,
   sendJsonError,
   writeOrDrain,
@@ -150,12 +154,12 @@ function catalogData(catalog) {
   return Array.isArray(catalog?.data) ? catalog.data : null;
 }
 
-async function responseSnapshot(response) {
+async function responseSnapshot(response, { maxBytes, label, signal }) {
   return {
     status: response.status,
     ok: response.ok,
     headers: new Headers(response.headers),
-    body: Buffer.from(await response.arrayBuffer()),
+    body: await readBoundedResponseBuffer(response, { maxBytes, label, signal }),
   };
 }
 
@@ -209,7 +213,15 @@ function mergeModelCatalog(snapshot, modelRouter) {
 async function relayUpstreamResponse(response, reqBody, res, abort, streamIdleTimeoutMs) {
   const stream = reqBody?.stream === true;
   if (!stream || !response.ok) {
-    const snapshot = await responseSnapshot(response);
+    const snapshot = await responseSnapshot(response, response.ok ? {
+      maxBytes: MAX_UPSTREAM_CHAT_SUCCESS_BODY_BYTES,
+      label: "PM Studio Claude success body",
+      signal: abort.signal,
+    } : {
+      maxBytes: MAX_UPSTREAM_ERROR_BODY_BYTES,
+      label: "PM Studio Claude error body",
+      signal: abort.signal,
+    });
     sendSnapshot(res, snapshot);
     return;
   }
@@ -345,9 +357,18 @@ export function createPmStudioRelayHandler(options = {}) {
     }
     activeModelRequests += 1;
     try {
-      return await fetchEnterprise(
+      const response = await fetchEnterprise(
         "/models", "GET", inboundHeaders, token, undefined, signal,
-      ).then(responseSnapshot);
+      );
+      return await responseSnapshot(response, response.ok ? {
+        maxBytes: MAX_UPSTREAM_MODEL_CATALOG_BYTES,
+        label: "PM Studio model catalog",
+        signal,
+      } : {
+        maxBytes: MAX_UPSTREAM_ERROR_BODY_BYTES,
+        label: "PM Studio model catalog error body",
+        signal,
+      });
     } finally {
       activeModelRequests -= 1;
     }

package/src/pm-studio-setup.mjs

@@ -346,7 +346,7 @@ function statusInspectExecutableIntegrity({ appPath, infoPlistPath, recipe, proc
   };
 }
 
-export function createPmStudioStatusOperationOverrides() {
+function createPmStudioFileInspectionOperationOverrides() {
   const evidenceCache = new Map();
   const bundleReadBuffer = Buffer.allocUnsafe(1024 * 1024);
   return {
@@ -370,6 +370,10 @@ export function createPmStudioStatusOperationOverrides() {
   };
 }
 
+export function createPmStudioStatusOperationOverrides() {
+  return createPmStudioFileInspectionOperationOverrides();
+}
+
 function defaultSignApp({ appPath, source, processRunner }) {
   const preserve = [];
   if (source?.codeSign?.displayValid === true) {
@@ -1043,7 +1047,7 @@ function patchRecordForState(manifest, recipe, state) {
   return patchRecordMatches(manifest?.patched, recipe, state) ? manifest.patched : null;
 }
 
-function validateBackup({ backupDir, recipe, operations }) {
+function validateBackup({ backupDir, recipe, operations, evidence }) {
   const manifestPath = path.join(backupDir, "manifest.json");
   const backupAppPath = path.join(backupDir, "PM Studio.app");
   let manifest;
@@ -1079,6 +1083,9 @@ function validateBackup({ backupDir, recipe, operations }) {
   if (inspection.state !== "clean") {
     throw setupError("PM_STUDIO_BACKUP_INVALID", "Existing PM Studio backup is not an exact clean bundle", inspection.issues);
   }
+  if (evidence) {
+    evidence.inspection = inspection;
+  }
   return { backupDir, backupAppPath, manifestPath, manifest, reused: true };
 }
 
@@ -1316,6 +1323,10 @@ function restoreStateFingerprint(inspection, bundleContent) {
 
 function inspectRestoreState({ appPath, recipe, operations }) {
   const inspection = inspectPmStudioApp({ appPath, recipe, operations });
+  return restoreStateFromInspection({ appPath, inspection, recipe, operations });
+}
+
+function restoreStateFromInspection({ appPath, inspection, recipe, operations }) {
   const bundleContent = inspection.bundleContent || operations.inspectBundleContent({
     ...appPaths(appPath, recipe),
     recipe,
@@ -1355,7 +1366,10 @@ export async function runPmStudioSetup({
   operations: operationOverrides = {},
   logger = (line) => console.log(line),
 } = {}) {
-  const operations = createPmStudioSetupOperations(operationOverrides);
+  const operations = createPmStudioSetupOperations({
+    ...createPmStudioFileInspectionOperationOverrides(),
+    ...operationOverrides,
+  });
   return operations.withSetupLock({ appPath }, async () => {
   const messages = [];
   const emit = (message) => {
@@ -1548,7 +1562,10 @@ export async function runPmStudioRestore({
   operations: operationOverrides = {},
   logger = (line) => console.log(line),
 } = {}) {
-  const operations = createPmStudioSetupOperations(operationOverrides);
+  const operations = createPmStudioSetupOperations({
+    ...createPmStudioFileInspectionOperationOverrides(),
+    ...operationOverrides,
+  });
   return operations.withSetupLock({ appPath }, async () => {
     const messages = [];
     const emit = (message) => {
@@ -1590,7 +1607,8 @@ export async function runPmStudioRestore({
 
     const manifestPath = pmStudioPatchManifestPath({ home, backupRoot, recipe });
     const backupDir = path.dirname(manifestPath);
-    const backup = validateBackup({ backupDir, recipe, operations });
+    const backupEvidence = {};
+    const backup = validateBackup({ backupDir, recipe, operations, evidence: backupEvidence });
     assertPatchedBinaryRecord({
       inspection: source.inspection,
       manifestPath: backup.manifestPath,
@@ -1604,7 +1622,12 @@ export async function runPmStudioRestore({
     });
     assertRestoreSpace({ appPath, backupAppPath: backup.backupAppPath, operations });
     const manifestSnapshot = fs.readFileSync(backup.manifestPath);
-    const backupSource = inspectRestoreState({ appPath: backup.backupAppPath, recipe, operations });
+    const backupSource = restoreStateFromInspection({
+      appPath: backup.backupAppPath,
+      inspection: backupEvidence.inspection,
+      recipe,
+      operations,
+    });
     if (backupSource.inspection.state !== "clean") {
       throw setupError("PM_STUDIO_BACKUP_INVALID", "Verified PM Studio backup is not an exact clean bundle",
         backupSource.inspection.issues);
@@ -1623,9 +1646,16 @@ export async function runPmStudioRestore({
         throw setupError("PM_STUDIO_BACKUP_CHANGED",
           "PM Studio backup manifest changed during restore; the verified staging bundle was not installed");
       }
-      const currentBackup = validateBackup({ backupDir, recipe, operations });
-      const unchangedBackup = inspectRestoreState({
+      const currentBackupEvidence = {};
+      const currentBackup = validateBackup({
+        backupDir,
+        recipe,
+        operations,
+        evidence: currentBackupEvidence,
+      });
+      const unchangedBackup = restoreStateFromInspection({
         appPath: currentBackup.backupAppPath,
+        inspection: currentBackupEvidence.inspection,
         recipe,
         operations,
       });

package/src/responses-handler.mjs

@@ -3,6 +3,7 @@ import { applyCopilotResponsesRequestPolicies } from "./copilot-responses-policy
 import {
   createRequestAbort,
   logRequestFailure,
+  MAX_UPSTREAM_CHAT_SUCCESS_BODY_BYTES,
   MAX_UPSTREAM_ERROR_BODY_BYTES,
   readJsonBody,
   readBoundedResponseText,
@@ -136,7 +137,7 @@ export function createResponsesHandler(options) {
       if (!["responses_prepare_timeout", "stream_handshake_timeout", "upstream_timeout"].includes(abort.reason)) {
         return error;
       }
-      const activated = imagePressure?.markTimeout?.(prepared?.historyRootId, {
+      const activated = imagePressure?.markTimeout?.(responseHistoryPressureRootId(prepared), {
         eligible: imagePressureResult?.pressureEligible === true,
       });
       if (!activated) return error;
@@ -310,7 +311,11 @@ export function createResponsesHandler(options) {
             });
             releaseChatPayload();
             const data = upstream.ok
-              ? await upstream.text()
+              ? await readBoundedResponseText(upstream, {
+                maxBytes: MAX_UPSTREAM_CHAT_SUCCESS_BODY_BYTES,
+                label: "Copilot Chat success body",
+                signal: abort.signal,
+              })
               : await readBoundedResponseText(upstream, {
                 maxBytes: MAX_UPSTREAM_ERROR_BODY_BYTES,
                 label: "Copilot Chat error body",

package/src/responses-proxy.mjs

@@ -3,6 +3,7 @@ import {
   httpError,
   logRequestFailure,
   MAX_UPSTREAM_ERROR_BODY_BYTES,
+  MAX_UPSTREAM_RESPONSES_SUCCESS_BODY_BYTES,
   readBoundedResponseText,
   sendUpstreamError,
   writeOrDrain,
@@ -265,7 +266,11 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
     }
   } else {
     const data = resp.ok
-      ? await resp.text()
+      ? await readBoundedResponseText(resp, {
+        maxBytes: MAX_UPSTREAM_RESPONSES_SUCCESS_BODY_BYTES,
+        label: "Copilot Responses success body",
+        signal: options.signal,
+      })
       : await readBoundedResponseText(resp, {
         maxBytes: MAX_UPSTREAM_ERROR_BODY_BYTES,
         label: "Copilot Responses error body",

package/src/runtime-config.mjs

@@ -7,6 +7,8 @@ export const RUNTIME_DEFAULTS = Object.freeze({
   maxBodyBytes: 64 * 1024 * 1024,
   maxDecodedBodyBytes: 128 * 1024 * 1024,
   maxInflightBodyBytes: 32 * 1024 * 1024,
+  maxUpstreamChatResponseBytes: 64 * 1024 * 1024,
+  maxUpstreamResponsesResponseBytes: 256 * 1024 * 1024,
   maxQueuedRequests: 16,
   requestQueueTimeoutMs: 120 * 1000,
   responseHistoryMaxBytes: 64 * 1024 * 1024,
@@ -30,6 +32,14 @@ export function loadRuntimeConfig(env = process.env) {
     maxBodyBytes: parsePositiveInteger(env.CCDX_MAX_BODY_BYTES, RUNTIME_DEFAULTS.maxBodyBytes),
     maxDecodedBodyBytes: parsePositiveInteger(env.CCDX_MAX_DECODED_BODY_BYTES, RUNTIME_DEFAULTS.maxDecodedBodyBytes),
     maxInflightBodyBytes: parsePositiveInteger(env.CCDX_MAX_INFLIGHT_BODY_BYTES, RUNTIME_DEFAULTS.maxInflightBodyBytes),
+    maxUpstreamChatResponseBytes: parsePositiveInteger(
+      env.CCDX_MAX_UPSTREAM_CHAT_RESPONSE_BYTES,
+      RUNTIME_DEFAULTS.maxUpstreamChatResponseBytes,
+    ),
+    maxUpstreamResponsesResponseBytes: parsePositiveInteger(
+      env.CCDX_MAX_UPSTREAM_RESPONSES_RESPONSE_BYTES,
+      RUNTIME_DEFAULTS.maxUpstreamResponsesResponseBytes,
+    ),
     maxQueuedRequests: parsePositiveInteger(env.CCDX_MAX_QUEUED_REQUESTS, RUNTIME_DEFAULTS.maxQueuedRequests),
     requestQueueTimeoutMs: parsePositiveInteger(env.CCDX_REQUEST_QUEUE_TIMEOUT_MS, RUNTIME_DEFAULTS.requestQueueTimeoutMs),
     responseHistoryMaxBytes: parsePositiveInteger(env.CCDX_RESPONSE_HISTORY_MAX_BYTES, RUNTIME_DEFAULTS.responseHistoryMaxBytes),

package/src/token-counter-service.mjs

@@ -0,0 +1,188 @@
+import { Worker } from "node:worker_threads";
+import { anthropicTokenText } from "./anthropic.mjs";
+
+export const DEFAULT_TOKEN_COUNTER_TIMEOUT_MS = 120 * 1000;
+export const DEFAULT_TOKEN_COUNTER_MAX_QUEUED = 16;
+
+function serviceError(message, statusCode) {
+  return Object.assign(new Error(message), { statusCode });
+}
+
+function positiveInteger(value, fallback) {
+  return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+
+function abortError(signal) {
+  if (signal?.reason instanceof Error) return signal.reason;
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  return error;
+}
+
+export function tokenCounterWorkerExecArgv(execArgv = process.execArgv) {
+  const filtered = [];
+  for (let index = 0; index < execArgv.length; index += 1) {
+    const value = execArgv[index];
+    if (value === "--input-type") {
+      index += 1;
+      continue;
+    }
+    if (value.startsWith("--input-type=")) continue;
+    filtered.push(value);
+  }
+  return filtered;
+}
+
+function createTokenCounterWorker() {
+  const execArgv = tokenCounterWorkerExecArgv();
+  const options = execArgv.length === process.execArgv.length ? undefined : { execArgv };
+  return new Worker(new URL("./token-counter-worker.mjs", import.meta.url), options);
+}
+
+export function createTokenCounterService({
+  timeoutMs = DEFAULT_TOKEN_COUNTER_TIMEOUT_MS,
+  maxQueued = DEFAULT_TOKEN_COUNTER_MAX_QUEUED,
+  workerFactory = createTokenCounterWorker,
+} = {}) {
+  timeoutMs = positiveInteger(timeoutMs, DEFAULT_TOKEN_COUNTER_TIMEOUT_MS);
+  maxQueued = positiveInteger(maxQueued, DEFAULT_TOKEN_COUNTER_MAX_QUEUED);
+  const queue = [];
+  let worker = null;
+  let active = null;
+  let nextId = 1;
+  let closed = false;
+
+  const finish = (job, callback, value) => {
+    if (job.finished) return;
+    job.finished = true;
+    if (job.timer) clearTimeout(job.timer);
+    job.signal?.removeEventListener("abort", job.onAbort);
+    callback(value);
+  };
+
+  const retireWorker = () => {
+    const retired = worker;
+    worker = null;
+    if (!retired) return;
+    retired.removeAllListeners();
+    retired.on("error", () => {});
+    Promise.resolve(retired.terminate()).catch(() => {});
+  };
+
+  const pump = () => {
+    if (closed || active || queue.length === 0) return;
+    if (!worker) {
+      try {
+        worker = workerFactory();
+      } catch {
+        const job = queue.shift();
+        if (job) finish(job, job.reject, serviceError("Token counter worker failed", 500));
+        queueMicrotask(pump);
+        return;
+      }
+      worker.on("message", (message) => {
+        if (!active || message?.id !== active.id) return;
+        const job = active;
+        active = null;
+        if (message.error) {
+          retireWorker();
+          finish(job, job.reject, serviceError("Token counter worker failed", 500));
+        } else {
+          finish(job, job.resolve, message.result);
+        }
+        pump();
+      });
+      worker.on("error", () => {
+        const job = active;
+        active = null;
+        retireWorker();
+        if (job) finish(job, job.reject, serviceError("Token counter worker failed", 500));
+        pump();
+      });
+      worker.on("exit", () => {
+        const job = active;
+        active = null;
+        worker = null;
+        if (job) finish(job, job.reject, serviceError("Token counter worker failed", 500));
+        pump();
+      });
+      worker.unref?.();
+    }
+    const job = queue.shift();
+    if (!job || job.finished) return pump();
+    active = job;
+    try {
+      worker.postMessage({ id: job.id, text: job.text });
+      job.text = null;
+    } catch {
+      active = null;
+      retireWorker();
+      finish(job, job.reject, serviceError("Token counter worker failed", 500));
+      pump();
+    }
+  };
+
+  const cancel = (job, error) => {
+    if (job.finished) return;
+    const queuedIndex = queue.indexOf(job);
+    if (queuedIndex >= 0) queue.splice(queuedIndex, 1);
+    if (active === job) {
+      active = null;
+      retireWorker();
+    }
+    finish(job, job.reject, error);
+    pump();
+  };
+
+  return {
+    count(body, { signal, deadlineMs = timeoutMs } = {}) {
+      if (closed) return Promise.reject(serviceError("Token counter service is closed", 503));
+      if (signal?.aborted) return Promise.reject(abortError(signal));
+      let text;
+      try {
+        text = anthropicTokenText(body);
+      } catch {
+        return Promise.reject(serviceError("Invalid count_tokens request", 400));
+      }
+      if (active && queue.length >= maxQueued) {
+        return Promise.reject(serviceError(`Token counter queue is full (${maxQueued} waiting)`, 503));
+      }
+      return new Promise((resolve, reject) => {
+        deadlineMs = positiveInteger(deadlineMs, timeoutMs);
+        const job = {
+          id: nextId++,
+          text,
+          signal,
+          resolve,
+          reject,
+          finished: false,
+          timer: null,
+          onAbort: null,
+        };
+        job.onAbort = () => cancel(job, abortError(signal));
+        signal?.addEventListener("abort", job.onAbort, { once: true });
+        job.timer = setTimeout(() => {
+          cancel(job, serviceError(`Token counting timed out after ${deadlineMs}ms`, 504));
+        }, deadlineMs);
+        queue.push(job);
+        if (signal?.aborted) job.onAbort();
+        else pump();
+      });
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      const error = serviceError("Token counter service is closed", 503);
+      if (active) {
+        const job = active;
+        active = null;
+        finish(job, job.reject, error);
+      }
+      for (const job of queue.splice(0)) finish(job, job.reject, error);
+      retireWorker();
+    },
+    stats() {
+      return { active: active ? 1 : 0, queued: queue.length, worker: worker ? 1 : 0 };
+    },
+  };
+}

package/src/token-counter-worker.mjs

@@ -0,0 +1,10 @@
+import { parentPort } from "node:worker_threads";
+import { countTokenText } from "./anthropic.mjs";
+
+parentPort.on("message", async ({ id, text }) => {
+  try {
+    parentPort.postMessage({ id, result: await countTokenText(text) });
+  } catch {
+    parentPort.postMessage({ id, error: true });
+  }
+});