codex-copilot-dx 0.4.33 → 0.4.35

package/README.md

@@ -64,7 +64,15 @@ codex-copilot-dx doctor --online
 
 The online doctor never starts device flow, scans for replacement tokens, or changes the saved token.
 
-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 accepts only the same GitHub account. Explicit token variables remain the intentional way to switch accounts.
+To actively verify the protocol path through an already-running adapter, run:
+
+```bash
+codex-copilot-dx doctor --compat
+```
+
+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.
 
 If Copilot token refresh still fails with `401` or `403`, the saved GitHub token may be expired, revoked, or missing Copilot access. Delete the saved token and start the tool again to trigger GitHub device login:
 
@@ -102,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` |
@@ -167,6 +178,7 @@ MIT
 ```bash
 npm ci
 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. The CI workflow runs all three 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();
@@ -187,6 +191,7 @@ if (CLI.command === "doctor") {
     port: ADAPTER_PORT,
     host: ADAPTER_HOST,
     online: CLI.online,
+    compat: CLI.compat,
   });
   process.exit(checks.some((check) => check.kind === "err") ? 1 : 0);
 }
@@ -251,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,
@@ -282,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.33",
+  "version": "0.4.35",
   "description": "Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot",
   "author": "Dale Xiao",
   "type": "module",
@@ -43,8 +43,10 @@
     "test:smoke": "node scripts/offline-smoke.mjs",
     "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

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 
 import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { fileURLToPath } from "node:url";
 import sharp from "sharp";
@@ -29,6 +32,150 @@ function deterministicPixels(byteLength, initialSeed) {
   return pixels;
 }
 
+function largePayloadProbe(targetMiB, concurrency) {
+  const fixtureDir = fs.mkdtempSync(path.join(os.tmpdir(), "ccdx-payload-bench-"));
+  const fixtureStarted = performance.now();
+  try {
+    const generator = spawnSync(process.execPath, ["--input-type=module", "-e", `
+      import fs from "node:fs";
+      import path from "node:path";
+      import sharp from "sharp";
+      const targetBytes = ${targetMiB} * 1024 * 1024;
+      const requestConcurrency = ${concurrency};
+      const imageCount = 8;
+      const fixtureDir = ${JSON.stringify(fixtureDir)};
+      const basePng = await sharp({
+        create: { width: 32, height: 32, channels: 3, background: { r: 40, g: 90, b: 140 } },
+      }).png().toBuffer();
+      for (let requestIndex = 0; requestIndex < requestConcurrency; requestIndex += 1) {
+        const approximateDataUrlBytes = Math.floor(targetBytes / imageCount);
+        const rawBytes = Math.max(basePng.length, Math.floor((approximateDataUrlBytes - 32) * 3 / 4));
+        const content = [];
+        for (let imageIndex = 0; imageIndex < imageCount; imageIndex += 1) {
+          const raw = Buffer.alloc(rawBytes, (requestIndex * imageCount + imageIndex + 1) % 251);
+          basePng.copy(raw, 0);
+          content.push({ type: "input_image", image_url: \`data:image/png;base64,\${raw.toString("base64")}\` });
+        }
+        const source = {
+          model: "gpt-benchmark",
+          stream: false,
+          input: [{ type: "message", role: "user", content }],
+        };
+        fs.writeFileSync(path.join(fixtureDir, \`request-\${requestIndex}.json\`), JSON.stringify(source));
+      }
+    `], { cwd: packageRoot, encoding: "utf8" });
+    if (generator.status !== 0) {
+      throw new Error(generator.stderr.trim() || `benchmark fixture generator exited with ${generator.status}`);
+    }
+    const fixturePrepareMs = performance.now() - fixtureStarted;
+    const fixtureFiles = Array.from({ length: concurrency }, (_, index) => path.join(fixtureDir, `request-${index}.json`));
+    const result = runProbe(`
+      import fs from "node:fs";
+      import { prepareResponsesRequest } from "./src/adapter.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);
+      };
+      globalThis.gc?.();
+      const idleMemory = process.memoryUsage();
+      for (const field of memoryFields) peak[field] = idleMemory[field] || 0;
+      const timer = setInterval(sample, 5);
+      timer.unref?.();
+
+      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 = 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;
+      const originalWarn = console.warn;
+      console.log = () => {};
+      console.warn = () => {};
+      const started = performance.now();
+      let results;
+      try {
+        results = await Promise.all(fixtureFiles.map(processRequest));
+      } finally {
+        clearInterval(timer);
+        console.log = originalLog;
+        console.warn = originalWarn;
+      }
+      sample();
+      const finalMemory = process.memoryUsage();
+      const mib = (bytes) => +(bytes / 1048576).toFixed(1);
+      const memory = Object.fromEntries(memoryFields.map((field) => [field.replace("Used", "_used").replace("Buffers", "_buffers").toLowerCase(), {
+        idle_mib: mib(idleMemory[field] || 0),
+        peak_mib: mib(peak[field] || 0),
+        peak_delta_mib: mib((peak[field] || 0) - (idleMemory[field] || 0)),
+        final_mib: mib(finalMemory[field] || 0),
+      }]));
+      process.stdout.write(JSON.stringify({
+        target_request_mib: ${targetMiB},
+        concurrency: fixtureFiles.length,
+        elapsed_ms: +(performance.now() - started).toFixed(1),
+        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,
+      }));
+    `);
+    result.fixture_prepare_ms = +fixturePrepareMs.toFixed(1);
+    return result;
+  } finally {
+    fs.rmSync(fixtureDir, { recursive: true, force: true });
+  }
+}
+
+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");
@@ -126,10 +273,62 @@ try {
   console.warn = originalWarn;
 }
 
-console.log(JSON.stringify({
-  note: "Report-only benchmark; timings vary by machine and are not pass/fail thresholds.",
+const checkMode = process.argv.includes("--check");
+const report = {
+  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,
-}, null, 2));
+};
+
+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),
+    largePayloadProbe(30, 1),
+    largePayloadProbe(30, 2),
+    largePayloadProbe(60, 1),
+  ];
+}
+
+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/cli-options.mjs

@@ -7,28 +7,36 @@ function unexpectedArgs(args) {
 
 export function parseCliArgs(args = []) {
   const [command, ...rest] = args;
-  if (!command) return { command: "start", configureClaudeDesktop: false, online: false };
+  if (!command) return { command: "start", configureClaudeDesktop: false, online: false, compat: false };
   if (HELP_COMMANDS.has(command)) {
     if (rest.length) unexpectedArgs(rest);
-    return { command: "help", configureClaudeDesktop: false, online: false };
+    return { command: "help", configureClaudeDesktop: false, online: false, compat: false };
   }
   if (VERSION_COMMANDS.has(command)) {
     if (rest.length) unexpectedArgs(rest);
-    return { command: "version", configureClaudeDesktop: false, online: false };
+    return { command: "version", configureClaudeDesktop: false, online: false, compat: false };
   }
   if (command === "usage") {
     if (rest.length) unexpectedArgs(rest);
-    return { command: "usage", configureClaudeDesktop: false, online: false };
+    return { command: "usage", configureClaudeDesktop: false, online: false, compat: false };
   }
   if (command === "doctor" || command === "--doctor") {
-    const invalid = rest.filter((arg) => arg !== "--online");
+    const supported = new Set(["--online", "--compat"]);
+    const invalid = rest.filter((arg) => !supported.has(arg));
     if (invalid.length) unexpectedArgs(invalid);
-    if (rest.filter((arg) => arg === "--online").length > 1) unexpectedArgs(["--online"]);
-    return { command: "doctor", configureClaudeDesktop: false, online: rest.includes("--online") };
+    for (const option of supported) {
+      if (rest.filter((arg) => arg === option).length > 1) unexpectedArgs([option]);
+    }
+    return {
+      command: "doctor",
+      configureClaudeDesktop: false,
+      online: rest.includes("--online"),
+      compat: rest.includes("--compat"),
+    };
   }
   if (command === "--configure-claude-desktop") {
     if (rest.length) unexpectedArgs(rest);
-    return { command: "start", configureClaudeDesktop: true, online: false };
+    return { command: "start", configureClaudeDesktop: true, online: false, compat: false };
   }
   throw new Error(`Unknown command or option: ${command}`);
 }
@@ -62,7 +70,7 @@ export function parseRuntimeOptions(env = process.env) {
 export function cliHelp() {
   return `Usage:
   codex-copilot-dx [--configure-claude-desktop]
-  codex-copilot-dx doctor [--online]
+  codex-copilot-dx doctor [--online] [--compat]
   codex-copilot-dx usage
   codex-copilot-dx --version
   codex-copilot-dx --help`;