codex-copilot-dx 0.4.34 → 0.4.35

package/README.md

@@ -70,7 +70,7 @@ To actively verify the protocol path through an already-running adapter, run:
 codex-copilot-dx doctor --compat
 ```
 
-The compatibility doctor sends a few minimal Copilot requests to check native Responses, streaming history, compaction, image tool namespace handling, and Anthropic streaming. It consumes a small amount of Copilot usage, never starts the adapter or device flow, and does not change client configuration. Combine it with `--online` when both the saved-token entitlement check and the adapter protocol checks are needed.
+The compatibility doctor sends a few minimal Copilot requests to check Codex Auto-review, native Responses, streaming history, compaction, image tool namespace handling, and Anthropic streaming. It consumes a small amount of Copilot usage, never starts the adapter or device flow, and does not change client configuration. Combine it with `--online` when both the saved-token entitlement check and the adapter protocol checks are needed.
 
 When the saved token is missing, `codex-copilot-dx` first looks for compatible local Copilot GitHub tokens, validates them with GitHub and Copilot, and imports a valid one before starting device login. It checks explicit token sources (`CCDX_GITHUB_TOKEN`, `CCDX_GITHUB_TOKEN_PATH`, `CCDX_GITHUB_TOKEN_PATHS`) plus common local `auth.json` layouts under application config directories. It does not rely on a specific app name. Generic discovery refuses to choose silently when valid tokens for multiple GitHub accounts are found. After an account is selected, automatic `401`/`403` recovery and in-process token rotation accept only the same GitHub account. Concurrent callers share token refresh work without sharing cancellation, and a still-valid Copilot token may be used briefly after a transient refresh failure. Explicit token variables remain the intentional way to switch accounts.
 
@@ -110,12 +110,15 @@ Environment variables:
 | `CCDX_ALLOW_LAN` | unset | Set to `1` to allow non-loopback `ADAPTER_HOST` values such as `0.0.0.0`; exposes your Copilot-backed adapter beyond this machine |
 | `CCDX_MAX_BODY_BYTES` | `67108864` | Maximum compressed/raw request body size |
 | `CCDX_MAX_DECODED_BODY_BYTES` | `134217728` | Maximum decoded request body size after decompression |
+| `CCDX_MAX_INFLIGHT_BODY_BYTES` | `33554432` | Shared byte budget for admitted request bodies; a larger single request runs exclusively |
+| `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_MAX_UPSTREAM_BODY_BYTES` | `31457280` | Responses body target; larger image payloads are compressed more aggressively before forwarding |
 | `CCDX_MAX_SSE_BUFFER_BYTES` | `8388608` | Maximum buffered bytes for one unterminated upstream SSE line/event |
 | `CCDX_UPSTREAM_TIMEOUT_MS` | `120000` | Timeout for non-streaming upstream Copilot requests |
 | `CCDX_STREAM_HANDSHAKE_TIMEOUT_MS` | `120000` | Timeout while waiting for upstream streaming response headers |
 | `CCDX_STREAM_IDLE_TIMEOUT_MS` | `120000` | Maximum idle time between upstream streaming body chunks |
-| `CCDX_UPSTREAM_RETRIES` | `2` | Retries for transient Copilot upstream network errors; capped at `5` |
+| `CCDX_UPSTREAM_RETRIES` | `2` | Retries for safe requests and clearly pre-connect POST failures; capped at `5` |
 | `CCDX_UPSTREAM_RETRY_DELAY_MS` | `300` | Initial upstream retry backoff in milliseconds; capped at `5000` |
 | `CCDX_AUTO_REVIEW_MODEL` | `gpt-5.5` | Copilot Responses model used for Codex Auto-review requests |
 | `CCDX_LOG_PATH` | unset | Mirror terminal logs to a file; set to `1` for `~/.local/share/codex-copilot-dx/debug.log` |
@@ -178,4 +181,4 @@ npm run verify
 npm run bench:payload
 ```
 
-`npm test` runs the unit and handler-level suite. `npm run test:smoke` starts a real local HTTP adapter with fully injected offline upstreams. `npm run pack:check` verifies the npm tarball contents without publishing. `npm run bench:payload` is a report-only, isolated-process benchmark for 5-60 MiB image payloads and does not contact Copilot. The CI workflow runs the verification checks on supported Node.js release lines.
+`npm test` runs the unit and handler-level suite. `npm run test:smoke` starts a real local HTTP adapter with fully injected offline upstreams. `npm run bench:check` enforces relative token-counting performance and request-admission resource limits. `npm run pack:check` verifies the npm tarball contents without publishing. `npm run bench:payload` remains a report-only, isolated-process benchmark for 5-60 MiB image payloads and does not contact Copilot. The CI workflow runs the verification checks on supported Node.js release lines.

package/bin/cli.mjs

@@ -6,13 +6,13 @@ import { ensureClaudeConfig } from "../src/claude-config.mjs";
 import { applyClaudeDesktopConfig, formatClaudeDesktopApplyResult, generatedClaudeDesktopApiKey, loadManagedClaudeDesktopApiKey } from "../src/claude-desktop-config.mjs";
 import { startAdapter } from "../src/adapter.mjs";
 import { cacheModelEndpoints, listModels, refreshVSCodeVersion } from "../src/copilot.mjs";
-import { claudeDesktopModelDefsFromCopilotModels, claudeDesktopModelIds, gptModelIdsFromCopilotModels, parseModelAliasEnv } from "../src/models.mjs";
+import { claudeDesktopModelDefsFromCopilotModels, claudeDesktopModelIds, codexAutoReviewModelStatus, gptModelIdsFromCopilotModels, parseModelAliasEnv } from "../src/models.mjs";
 import { status } from "../src/status.mjs";
 import { configureLogging } from "../src/log.mjs";
 import { flushUsageWrites, printUsageSummary } from "../src/usage.mjs";
 import { checkForUpdate, localPackageVersion } from "../src/version.mjs";
 import { runDoctor } from "../src/doctor.mjs";
-import { checkRunningAdapter } from "../src/running-adapter.mjs";
+import { adapterBaseUrl, checkRunningAdapter } from "../src/running-adapter.mjs";
 import { assertSafeAdapterHost, isLoopbackHost } from "../src/security.mjs";
 import { isValidModelList, loadModelCache, saveModelCache } from "../src/model-cache.mjs";
 import { initializeModelRegistry, runInBackground } from "../src/startup.mjs";
@@ -105,6 +105,10 @@ async function refreshClaudeDesktopModelDefs() {
       throw new Error(`Copilot models returned HTTP ${httpStatus}`);
     }
     const models = JSON.parse(body);
+    const autoReview = codexAutoReviewModelStatus(models);
+    if (!autoReview.available) {
+      console.log(status("warn", `Auto-review target ${autoReview.upstreamModel} is unavailable: ${autoReview.reason}. Run codex-copilot-dx doctor --compat to verify the live path.`));
+    }
     const gptModelIds = gptModelIdsFromCopilotModels(models);
     if (gptModelIds.length) {
       console.log(status("ok", `Refreshed GPT models from GitHub Copilot: ${gptModelIds.join(", ")}`));
@@ -152,8 +156,8 @@ async function reuseRunningAdapterIfAvailable() {
   if (!running.ok) return false;
 
   console.log(status("ok", `Using existing adapter at ${running.baseUrl}`));
-  ensureCodexConfig(ADAPTER_PORT);
-  ensureClaudeConfig(ADAPTER_PORT);
+  ensureCodexConfig(ADAPTER_PORT, { host: ADAPTER_HOST });
+  ensureClaudeConfig(ADAPTER_PORT, { host: ADAPTER_HOST });
 
   if (CONFIGURE_CLAUDE_DESKTOP) {
     const claudeDesktopApiKey = currentClaudeDesktopApiKey();
@@ -252,8 +256,8 @@ try {
   });
 
   // Point Codex and Claude Code at the adapter.
-  ensureCodexConfig(ADAPTER_PORT);
-  ensureClaudeConfig(ADAPTER_PORT);
+  ensureCodexConfig(ADAPTER_PORT, { host: ADAPTER_HOST });
+  ensureClaudeConfig(ADAPTER_PORT, { host: ADAPTER_HOST });
   if (CONFIGURE_CLAUDE_DESKTOP) {
     const result = applyClaudeDesktopConfig({
       port: ADAPTER_PORT,
@@ -283,7 +287,7 @@ try {
   console.log(`
   ${status("ok", "Ready, Claude Code, Claude App and Codex App are now ready to use")}
 
-  Adapter: http://${ADAPTER_HOST}:${ADAPTER_PORT}
+  Adapter: ${adapterBaseUrl(ADAPTER_HOST, ADAPTER_PORT)}
 
   Press Ctrl+C to stop.
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.4.34",
+  "version": "0.4.35",
   "description": "Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot",
   "author": "Dale Xiao",
   "type": "module",
@@ -44,8 +44,9 @@
     "test:e2e": "bash test/e2e.sh",
     "bench": "node scripts/benchmark.mjs",
     "bench:payload": "node scripts/benchmark.mjs --large-payload",
+    "bench:check": "node scripts/benchmark.mjs --check",
     "pack:check": "npm pack --dry-run --json",
-    "verify": "npm test && npm run test:smoke && npm run pack:check",
+    "verify": "npm test && npm run test:smoke && npm run bench:check && npm run pack:check",
     "prepublishOnly": "npm run verify"
   },
   "dependencies": {

package/scripts/benchmark.mjs

@@ -72,12 +72,14 @@ function largePayloadProbe(targetMiB, concurrency) {
     const result = runProbe(`
       import fs from "node:fs";
       import { prepareResponsesRequest } from "./src/adapter.mjs";
-      import { readJsonBody } from "./src/http-transport.mjs";
+      import { createRequestAdmission, readJsonBody } from "./src/http-transport.mjs";
       import { prepareResponsesPayload } from "./src/image-optimization.mjs";
 
       const fixtureFiles = ${JSON.stringify(fixtureFiles)};
+      const acquireRequest = createRequestAdmission();
       const memoryFields = ["rss", "heapUsed", "external", "arrayBuffers"];
       const peak = {};
+      let admissionMaxActiveBytes = 0;
       const sample = () => {
         const memory = process.memoryUsage();
         for (const field of memoryFields) peak[field] = Math.max(peak[field] || 0, memory[field] || 0);
@@ -90,15 +92,23 @@ function largePayloadProbe(targetMiB, concurrency) {
 
       async function processRequest(filePath) {
         const inputBytes = fs.statSync(filePath).size;
+        const headers = { "content-length": String(inputBytes), "content-encoding": "identity" };
+        const releaseRequest = await acquireRequest({ headers });
+        admissionMaxActiveBytes = Math.max(admissionMaxActiveBytes, acquireRequest.stats().activeBytes);
         const req = fs.createReadStream(filePath);
-        req.headers = { "content-length": String(inputBytes), "content-encoding": "identity" };
-        const parsed = await readJsonBody(req);
-        req.destroy();
-        sample();
-        const prepared = prepareResponsesRequest(parsed, { mutate: true });
-        const result = await prepareResponsesPayload(prepared.body);
-        sample();
-        return { inputBytes, outputBytes: result.bodyBytes };
+        req.headers = headers;
+        try {
+          const parsed = await readJsonBody(req);
+          req.destroy();
+          sample();
+          const prepared = prepareResponsesRequest(parsed, { mutate: true });
+          const result = await prepareResponsesPayload(prepared.body);
+          sample();
+          return { inputBytes, outputBytes: result.bodyBytes };
+        } finally {
+          req.destroy();
+          releaseRequest();
+        }
       }
 
       const originalLog = console.log;
@@ -130,6 +140,8 @@ function largePayloadProbe(targetMiB, concurrency) {
         input_body_mib: results.map((entry) => mib(entry.inputBytes)),
         output_body_mib: results.map((entry) => mib(entry.outputBytes)),
         output_body_kib: results.map((entry) => +(entry.outputBytes / 1024).toFixed(1)),
+        admission_max_active_mib: mib(admissionMaxActiveBytes),
+        admission_budget_mib: mib(acquireRequest.stats().maxBytes),
         memory,
       }));
     `);
@@ -140,6 +152,30 @@ function largePayloadProbe(targetMiB, concurrency) {
   }
 }
 
+function largeTokenCountProbe(mode) {
+  return runProbe(`
+    const text = "a ".repeat(2 * 1024 * 1024);
+    const started = performance.now();
+    let tokens;
+    if (${JSON.stringify(mode)} === "proxy") {
+      const { countTokens } = await import("./src/anthropic.mjs");
+      tokens = (await countTokens({ messages: [{ role: "user", content: text }] })).input_tokens;
+    } else {
+      const { encode } = await import("gpt-tokenizer");
+      const encoded = encode(text);
+      tokens = encoded.length;
+    }
+    const memory = process.memoryUsage();
+    process.stdout.write(JSON.stringify({
+      input_mib: +(Buffer.byteLength(text) / 1048576).toFixed(1),
+      tokens,
+      elapsed_ms: +(performance.now() - started).toFixed(1),
+      rss_mib: +(memory.rss / 1048576).toFixed(1),
+      heap_used_mib: +(memory.heapUsed / 1048576).toFixed(1),
+    }));
+  `);
+}
+
 const adapterImport = runProbe(`
   const started = performance.now();
   await import("./src/adapter.mjs");
@@ -237,15 +273,28 @@ try {
   console.warn = originalWarn;
 }
 
+const checkMode = process.argv.includes("--check");
 const report = {
-  note: "Report-only benchmark; timings vary by machine and are not pass/fail thresholds.",
+  note: checkMode
+    ? "Relative performance and resource checks; absolute timings vary by machine."
+    : "Report-only benchmark; timings vary by machine and are not pass/fail thresholds.",
   adapter_import: adapterImport,
   token_count_100kb: tokenCount,
   duplicate_images: duplicateImages,
   oversized_payload: oversizedPayload,
 };
 
-if (process.argv.includes("--large-payload")) {
+if (checkMode) {
+  report.large_token_count = {
+    proxy: largeTokenCountProbe("proxy"),
+    materialized_array: largeTokenCountProbe("array"),
+  };
+  report.large_payload_peak = [
+    largePayloadProbe(5, 4),
+    largePayloadProbe(30, 1),
+    largePayloadProbe(30, 2),
+  ];
+} else if (process.argv.includes("--large-payload")) {
   report.large_payload_peak = [
     largePayloadProbe(5, 1),
     largePayloadProbe(5, 4),
@@ -256,3 +305,30 @@ if (process.argv.includes("--large-payload")) {
 }
 
 console.log(JSON.stringify(report, null, 2));
+
+if (checkMode) {
+  const failures = [];
+  const proxy = report.large_token_count.proxy;
+  const array = report.large_token_count.materialized_array;
+  if (proxy.tokens !== array.tokens) failures.push(`token counts differ: proxy=${proxy.tokens} array=${array.tokens}`);
+  if (proxy.elapsed_ms > array.elapsed_ms * 1.25) {
+    failures.push(`token counter is materially slower: proxy=${proxy.elapsed_ms}ms array=${array.elapsed_ms}ms`);
+  }
+  if (proxy.rss_mib > array.rss_mib * 0.9) {
+    failures.push(`token counter RSS regression: proxy=${proxy.rss_mib}MiB array=${array.rss_mib}MiB`);
+  }
+  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`);
+  }
+  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}`);
+    }
+  }
+  if (failures.length) {
+    for (const failure of failures) console.error(`[FAIL] ${failure}`);
+    process.exitCode = 1;
+  } else {
+    console.error("[OK] Performance and resource checks passed");
+  }
+}

package/src/adapter.mjs

@@ -10,6 +10,7 @@ import { recordAnthropicUsage, recordResponsesUsage } from "./usage.mjs";
 import { ADAPTER_HEALTH_PATH, adapterHealthPayload } from "./running-adapter.mjs";
 import {
   abortErrorStatusCode,
+  createRequestAdmission,
   createRequestAbort,
   httpError,
   isAbortLikeError,
@@ -29,6 +30,7 @@ import {
 
 export {
   abortErrorStatusCode,
+  createRequestAdmission,
   createRequestAbort,
   isAbortLikeError,
   readJsonBody,
@@ -371,7 +373,12 @@ async function endStreamWithError(res, protocol, error, abort) {
 }
 
 async function proxyCopilotResponses(reqContext, req, res, upstream = copilotResponses, options = {}) {
-  const opened = await openCopilotResponse(reqContext, upstream, options);
+  let opened;
+  try {
+    opened = await openCopilotResponse(reqContext, upstream, options);
+  } finally {
+    options.releaseRequest?.();
+  }
   const { resp, errorText } = opened;
   reqContext = opened.reqContext;
   if (errorText !== undefined) {
@@ -547,10 +554,14 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
   let resp;
   try {
     const chatCompletionsFn = options.chatCompletionsFn || chatCompletions;
-    resp = await chatCompletionsFn({
-      ...chatReq,
-      stream: true,
-    }, { signal: options.signal });
+    try {
+      resp = await chatCompletionsFn({
+        ...chatReq,
+        stream: true,
+      }, { signal: options.signal });
+    } finally {
+      options.releaseRequest?.();
+    }
   } catch (e) {
     const statusCode = isAbortLikeError(e) ? abortErrorStatusCode(options.abort?.reason) : 502;
     await onError(statusCode, e.message);
@@ -723,6 +734,7 @@ export function createAdapterHandler(options = {}) {
   const upstreamTimeoutMs = positiveInt(options.upstreamTimeoutMs, UPSTREAM_TIMEOUT_MS);
   const streamHandshakeTimeoutMs = positiveInt(options.streamHandshakeTimeoutMs, STREAM_HANDSHAKE_TIMEOUT_MS);
   const streamIdleTimeoutMs = positiveInt(options.streamIdleTimeoutMs, STREAM_IDLE_TIMEOUT_MS);
+  const acquireRequest = options.acquireRequest || createRequestAdmission();
   const claudeDesktopModelOptions = () => {
     const modelDefs = options.modelRegistry?.modelDefs || options.claudeDesktopModelDefs;
     return Array.isArray(modelDefs) ? { modelDefs } : {};
@@ -740,7 +752,9 @@ export function createAdapterHandler(options = {}) {
     if (req.method === "POST" && pathname === "/v1/responses") {
       return (async () => {
         const abort = createRequestAbort(req, res);
+        let releaseRequest = () => {};
         try {
+          releaseRequest = await acquireRequest(req, { signal: abort.signal });
           const parsed = await readJsonBody(req);
           abort.setTimeout(
             parsed.stream ? streamHandshakeTimeoutMs : upstreamTimeoutMs,
@@ -757,6 +771,7 @@ export function createAdapterHandler(options = {}) {
             await proxyCopilotResponses(prepared, req, res, responsesFn, {
               signal: abort.signal,
               abort,
+              releaseRequest,
               streamIdleTimeoutMs,
             });
           } else {
@@ -781,12 +796,14 @@ export function createAdapterHandler(options = {}) {
                 abort,
                 streamIdleTimeoutMs,
                 chatCompletionsFn,
+                releaseRequest,
               });
             } else {
               chatReq.stream = false;
               delete chatReq.max_tokens;
               try {
                 const upstream = await chatCompletionsFn({ ...chatReq, stream: false }, { signal: abort.signal });
+                releaseRequest();
                 const data = await upstream.text();
                 if (!upstream.ok) {
                   sendUpstreamError(res, upstream, data);
@@ -807,6 +824,7 @@ export function createAdapterHandler(options = {}) {
           logRequestFailure("Responses", e, abort);
           sendJsonError(res, e, 502);
         } finally {
+          releaseRequest();
           abort.cleanup();
         }
       })();
@@ -815,7 +833,9 @@ export function createAdapterHandler(options = {}) {
     if (req.method === "POST" && pathname === "/v1/responses/compact") {
       (async () => {
         const abort = createRequestAbort(req, res);
+        let releaseRequest = () => {};
         try {
+          releaseRequest = await acquireRequest(req, { signal: abort.signal });
           const parsed = await readJsonBody(req);
           abort.setTimeout(
             parsed.stream ? streamHandshakeTimeoutMs : upstreamTimeoutMs,
@@ -831,12 +851,14 @@ export function createAdapterHandler(options = {}) {
           await proxyCopilotResponses(prepared, req, res, responsesCompactFn, {
             signal: abort.signal,
             abort,
+            releaseRequest,
             streamIdleTimeoutMs,
           });
         } catch (e) {
           logRequestFailure("Responses compact", e, abort);
           sendJsonError(res, e, 502);
         } finally {
+          releaseRequest();
           abort.cleanup();
         }
       })();
@@ -887,13 +909,18 @@ export function createAdapterHandler(options = {}) {
     if (req.method === "POST" && pathname === "/v1/messages/count_tokens") {
       (async () => {
         const abort = createRequestAbort(req, res);
+        let releaseRequest = () => {};
         try {
+          releaseRequest = await acquireRequest(req, { signal: abort.signal });
           const parsed = await readJsonBody(req);
+          const result = await countTokens(parsed);
+          releaseRequest();
           res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify(await countTokens(parsed)));
+          res.end(JSON.stringify(result));
         } catch (e) {
           sendJsonError(res, e);
         } finally {
+          releaseRequest();
           abort.cleanup();
         }
       })();
@@ -903,7 +930,9 @@ export function createAdapterHandler(options = {}) {
     if (req.method === "POST" && pathname === "/v1/messages") {
       (async () => {
         const abort = createRequestAbort(req, res);
+        let releaseRequest = () => {};
         try {
+          releaseRequest = await acquireRequest(req, { signal: abort.signal });
           const parsed = await readJsonBody(req);
           abort.setTimeout(
             parsed.stream ? streamHandshakeTimeoutMs : upstreamTimeoutMs,
@@ -916,6 +945,7 @@ export function createAdapterHandler(options = {}) {
           const forceRequestedModel = upstreamModel !== requestedModel;
           if (parsed.stream) {
             const upstream = await chatCompletionsFn({ ...chatReq, stream: true }, { signal: abort.signal });
+            releaseRequest();
             if (!upstream.ok) {
               if (!res.headersSent) res.writeHead(upstream.status);
               res.end(await upstream.text());
@@ -947,6 +977,7 @@ export function createAdapterHandler(options = {}) {
             if (!res.writableEnded) res.end();
           } else {
             const upstream = await chatCompletionsFn({ ...chatReq, stream: false }, { signal: abort.signal });
+            releaseRequest();
             const data = await upstream.text();
             if (!upstream.ok) {
               sendUpstreamError(res, upstream, data);
@@ -961,6 +992,7 @@ export function createAdapterHandler(options = {}) {
           logRequestFailure("Messages", e, abort);
           sendJsonError(res, e, 502);
         } finally {
+          releaseRequest();
           abort.cleanup();
         }
       })();

package/src/anthropic.mjs

@@ -2,9 +2,9 @@ import { randomUUID } from "node:crypto";
 
 let tokenizerModulePromise = null;
 
-async function tokenEncoder() {
+async function tokenCounter() {
   tokenizerModulePromise ||= import("gpt-tokenizer");
-  return (await tokenizerModulePromise).encode;
+  return (await tokenizerModulePromise).countTokens;
 }
 
 // Anthropic Messages API to OpenAI chat/completions translation.
@@ -282,6 +282,6 @@ export async function countTokens(body) {
   }
 
   const text = parts.join("\n");
-  const encode = await tokenEncoder();
-  return { input_tokens: encode(text).length };
+  const count = await tokenCounter();
+  return { input_tokens: count(text) };
 }

package/src/claude-config.mjs

@@ -3,12 +3,13 @@ import path from "node:path";
 import os from "node:os";
 import { status } from "./status.mjs";
 import { atomicWriteFileIfChangedSync } from "./atomic-file.mjs";
+import { adapterBaseUrl } from "./running-adapter.mjs";
 
 const SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json");
 
 // Return an updated settings object without mutating the input.
-export function computeUpdatedSettings(settings, port) {
-  const target = `http://127.0.0.1:${port}`;
+export function computeUpdatedSettings(settings, port, host = "127.0.0.1") {
+  const target = adapterBaseUrl(host, port);
   const current = settings?.env?.ANTHROPIC_BASE_URL;
   const currentToken = settings?.env?.ANTHROPIC_AUTH_TOKEN;
   const changed = current !== target || currentToken !== "dummy";
@@ -24,11 +25,11 @@ export function computeUpdatedSettings(settings, port) {
 }
 
 // Point Claude Code at the adapter by updating ~/.claude/settings.json.
-export function ensureClaudeConfig(port = 2026, { filePath = SETTINGS_PATH } = {}) {
-  const target = `http://127.0.0.1:${port}`;
+export function ensureClaudeConfig(port = 2026, { filePath = SETTINGS_PATH, host = "127.0.0.1" } = {}) {
+  const target = adapterBaseUrl(host, port);
 
   if (!fs.existsSync(filePath)) {
-    const { json } = computeUpdatedSettings({}, port);
+    const { json } = computeUpdatedSettings({}, port, host);
     atomicWriteFileIfChangedSync(filePath, JSON.stringify(json, null, 2) + "\n");
     console.log(status("ok", `Created ~/.claude/settings.json for Claude Code at ${target}`));
     return;
@@ -44,7 +45,7 @@ export function ensureClaudeConfig(port = 2026, { filePath = SETTINGS_PATH } = {
     return;
   }
 
-  const { json, changed } = computeUpdatedSettings(settings, port);
+  const { json, changed } = computeUpdatedSettings(settings, port, host);
   if (!changed) {
     console.log(status("ok", `Claude Code already points to ${target}`));
     return;

package/src/config.mjs

@@ -3,6 +3,7 @@ import path from "node:path";
 import os from "node:os";
 import { status } from "./status.mjs";
 import { atomicWriteFileIfChangedSync } from "./atomic-file.mjs";
+import { adapterBaseUrl } from "./running-adapter.mjs";
 
 const CONFIG_PATH = path.join(os.homedir(), ".codex", "config.toml");
 
@@ -33,9 +34,9 @@ function setTomlKey(lines, sectionName, key, value) {
   return true;
 }
 
-export function computeUpdatedCodexConfig(content, adapterPort = 2026) {
-  const baseUrl = `http://127.0.0.1:${adapterPort}/v1`;
-  const anthropicBaseUrl = `http://127.0.0.1:${adapterPort}`;
+export function computeUpdatedCodexConfig(content, adapterPort = 2026, adapterHost = "127.0.0.1") {
+  const anthropicBaseUrl = adapterBaseUrl(adapterHost, adapterPort);
+  const baseUrl = `${anthropicBaseUrl}/v1`;
   const hadTrailingNewline = content.endsWith("\n");
   const lines = content.split("\n");
   if (hadTrailingNewline) lines.pop();
@@ -59,9 +60,9 @@ export function computeUpdatedCodexConfig(content, adapterPort = 2026) {
   return { content: lines.join("\n") + (hadTrailingNewline ? "\n" : ""), changed };
 }
 
-function initialCodexConfig(adapterPort) {
-  const baseUrl = `http://127.0.0.1:${adapterPort}/v1`;
-  const anthropicBaseUrl = `http://127.0.0.1:${adapterPort}`;
+function initialCodexConfig(adapterPort, adapterHost) {
+  const anthropicBaseUrl = adapterBaseUrl(adapterHost, adapterPort);
+  const baseUrl = `${anthropicBaseUrl}/v1`;
   return `openai_base_url = "${baseUrl}"
 
 [shell_environment_policy]
@@ -75,18 +76,18 @@ OPENAI_API_KEY = "dummy"
 `;
 }
 
-export function ensureCodexConfig(adapterPort = 2026, { filePath = CONFIG_PATH } = {}) {
-  const baseUrl = `http://127.0.0.1:${adapterPort}/v1`;
+export function ensureCodexConfig(adapterPort = 2026, { filePath = CONFIG_PATH, host = "127.0.0.1" } = {}) {
+  const baseUrl = `${adapterBaseUrl(host, adapterPort)}/v1`;
 
   if (!fs.existsSync(filePath)) {
     // Codex config does not exist yet; create the local proxy defaults.
-    atomicWriteFileIfChangedSync(filePath, initialCodexConfig(adapterPort));
+    atomicWriteFileIfChangedSync(filePath, initialCodexConfig(adapterPort, host));
     console.log(status("ok", "Created ~/.codex/config.toml"));
     return;
   }
 
   const content = fs.readFileSync(filePath, "utf-8");
-  const updated = computeUpdatedCodexConfig(content, adapterPort);
+  const updated = computeUpdatedCodexConfig(content, adapterPort, host);
 
   if (!updated.changed) {
     console.log(status("ok", `Codex already points to ${baseUrl}`));

package/src/copilot.mjs

@@ -95,6 +95,12 @@ const RETRYABLE_UPSTREAM_ERROR_CODES = new Set([
   "EAI_AGAIN",
   "ENOTFOUND",
 ]);
+const RETRYABLE_POST_CONNECT_ERROR_CODES = new Set([
+  "UND_ERR_CONNECT_TIMEOUT",
+  "ECONNREFUSED",
+  "EAI_AGAIN",
+  "ENOTFOUND",
+]);
 const RETRYABLE_UPSTREAM_STATUSES = new Set([408, 502, 503, 504]);
 
 function upstreamTarget(url) {
@@ -146,9 +152,15 @@ function requestMethod(init = {}) {
   return String(init.method || "GET").toUpperCase();
 }
 
-export function isRetryableUpstreamError(err, { signal } = {}) {
+export function isRetryableUpstreamError(err, { signal, method = "GET" } = {}) {
   if (isAbortError(err, signal)) return false;
-  return RETRYABLE_UPSTREAM_ERROR_CODES.has(upstreamErrorCode(err));
+  const code = upstreamErrorCode(err);
+  if (!["GET", "HEAD", "OPTIONS"].includes(String(method || "GET").toUpperCase())) {
+    const syscall = err?.cause?.syscall || err?.syscall || "";
+    return RETRYABLE_POST_CONNECT_ERROR_CODES.has(code)
+      || (syscall === "connect" && ["ETIMEDOUT", "ECONNRESET"].includes(code));
+  }
+  return RETRYABLE_UPSTREAM_ERROR_CODES.has(code);
 }
 
 export function isRetryableUpstreamStatus(status, method = "GET") {
@@ -197,7 +209,7 @@ export async function fetchCopilotUpstream(
       return resp;
     } catch (e) {
       debugLog(`upstream ${method} ${target} error=${describeUpstreamError(e)} attempt=${attempt + 1}/${retryCount + 1} attempt_ms=${Date.now() - attemptStart} total_ms=${Date.now() - totalStart}`);
-      if (attempt >= retryCount || !isRetryableUpstreamError(e, { signal })) throw e;
+      if (attempt >= retryCount || !isRetryableUpstreamError(e, { signal, method })) throw e;
       const delay = upstreamRetryDelay(attempt, baseDelay);
       console.warn(status("warn", `upstream ${target} ${describeUpstreamError(e)}; retry ${attempt + 1}/${retryCount} in ${delay}ms`));
       await sleep(delay, { signal });

package/src/doctor.mjs

@@ -6,7 +6,8 @@ import { githubTokenPath, readGithubTokenMetadata, validateGithubToken } from ".
 import { claudeDesktopPaths } from "./claude-desktop-config.mjs";
 import { status } from "./status.mjs";
 import { buildHeaders, DEFAULT_API_BASE, FALLBACK_VSCODE_VERSION } from "./copilot.mjs";
-import { checkRunningAdapter } from "./running-adapter.mjs";
+import { adapterBaseUrl, checkRunningAdapter } from "./running-adapter.mjs";
+import { CODEX_AUTO_REVIEW_MODEL } from "./models.mjs";
 
 function localGatewayBaseUrl(host, port) {
   const safeHost = String(host || "127.0.0.1");
@@ -146,6 +147,15 @@ export async function inspectAdapterCompatibility({
     return checks;
   }
 
+  await runCompatibilityCheck(checks, "Codex Auto-review", async () => {
+    const text = await compatibilityRequest(fetchImpl, `${baseUrl}/v1/responses`, {
+      model: CODEX_AUTO_REVIEW_MODEL,
+      stream: false,
+      input: "Reply with OK only.",
+    }, timeoutMs);
+    parseResponseObject(text);
+  });
+
   const firstResponse = await runCompatibilityCheck(checks, `Native Responses (${responsesModel})`, async () => {
     const text = await compatibilityRequest(fetchImpl, `${baseUrl}/v1/responses`, {
       model: responsesModel,
@@ -259,10 +269,10 @@ export async function inspectGitHubTokenOnline({
   }
 }
 
-export function inspectCodexConfig({ home = os.homedir(), port = 2026 } = {}) {
+export function inspectCodexConfig({ home = os.homedir(), host = "127.0.0.1", port = 2026 } = {}) {
   const filePath = path.join(home, ".codex", "config.toml");
-  const expectedBaseUrl = `http://127.0.0.1:${port}/v1`;
-  const expectedAnthropicBaseUrl = `http://127.0.0.1:${port}`;
+  const expectedAnthropicBaseUrl = adapterBaseUrl(host, port);
+  const expectedBaseUrl = `${expectedAnthropicBaseUrl}/v1`;
   const config = readText(filePath);
   if (!config.ok) {
     return [{ kind: "warn", message: `Codex config not found at ${displayPath(home, filePath)}` }];
@@ -285,9 +295,9 @@ export function inspectCodexConfig({ home = os.homedir(), port = 2026 } = {}) {
   return checks;
 }
 
-export function inspectClaudeCodeConfig({ home = os.homedir(), port = 2026 } = {}) {
+export function inspectClaudeCodeConfig({ home = os.homedir(), host = "127.0.0.1", port = 2026 } = {}) {
   const filePath = path.join(home, ".claude", "settings.json");
-  const expectedBaseUrl = `http://127.0.0.1:${port}`;
+  const expectedBaseUrl = adapterBaseUrl(host, port);
   const settings = readJson(filePath);
   if (!settings.ok) {
     const reason = settings.parseError ? `could not parse: ${settings.error.message}` : `not found at ${displayPath(home, filePath)}`;
@@ -391,8 +401,8 @@ export async function collectDoctorChecks({
 } = {}) {
   const checks = [
     ...inspectGitHubToken({ home }),
-    ...inspectCodexConfig({ home, port }),
-    ...inspectClaudeCodeConfig({ home, port }),
+    ...inspectCodexConfig({ home, host, port }),
+    ...inspectClaudeCodeConfig({ home, host, port }),
     ...inspectClaudeAppConfig({ home, platform, env, host, port }),
   ];
 

package/src/http-transport.mjs

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

package/src/image-optimization.mjs

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

package/src/models.mjs

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