codex-copilot-dx 0.6.20 → 0.7.0

package/bin/cli.mjs

@@ -2,11 +2,8 @@
 
 import { ensureAuth, openCodex } from "../src/launcher.mjs";
 import { ensureCodexConfig } from "../src/config.mjs";
-import { ensureClaudeConfig } from "../src/claude-config.mjs";
-import { applyClaudeDesktopConfig, formatClaudeDesktopApplyResult, generatedClaudeDesktopApiKey, loadManagedClaudeDesktopApiKey, syncManagedClaudeDesktopModels } from "../src/claude-desktop-config.mjs";
 import { startAdapter } from "../src/adapter.mjs";
 import { defaultCopilotClient, refreshVSCodeVersion } from "../src/copilot.mjs";
-import { claudeDesktopModelIds } from "../src/models.mjs";
 import { status } from "../src/status.mjs";
 import { configureLogging } from "../src/log.mjs";
 import { flushUsageWrites, printUsageSummary } from "../src/usage.mjs";
@@ -17,7 +14,6 @@ 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";
@@ -54,6 +50,15 @@ if (CLI.command === "usage") {
   });
   process.exit(0);
 }
+if (CLI.command === "retired") {
+  console.error(status("err", `${CLI.integration} integration was retired in ccdx 0.7.0.`));
+  if (CLI.integration === "PM Studio") {
+    console.error(status("info", "Update or reinstall PM Studio to remove an older CCDX app patch."));
+  } else {
+    console.error(status("info", "Remove any old CCDX endpoint from the client before using a different provider."));
+  }
+  process.exit(1);
+}
 if (CLI.command === "auth") {
   try {
     const result = await runAuthCommand({
@@ -67,12 +72,6 @@ if (CLI.command === "auth") {
       output: process.stdout,
     });
     if (result.output) console.log(result.output);
-    if (result.action === "login") {
-      if (!result.changed) {
-        console.log(status("ok", `Claude profile is already configured for ${result.identity?.login || result.identity?.id || "the saved account"}`));
-      }
-      console.log(status("warn", `Restart the running ${CLI_NAME} adapter to activate the Claude profile`));
-    }
     process.exit(0);
   } catch (e) {
     console.error(status("err", e.message));
@@ -133,31 +132,6 @@ if (CLI.command === "update") {
     process.exit(1);
   }
 }
-if (CLI.command === "pms") {
-  try {
-    if (CLI.action === "status") {
-      const { runPmStudioStatus } = await import("../src/pm-studio-status.mjs");
-      const result = await runPmStudioStatus({
-        commandName: CLI_NAME,
-        format: CLI.outputFormat || "auto",
-        output: process.stdout,
-      });
-      process.exit(result.ok ? 0 : 1);
-    }
-    if (CLI.action === "restore") {
-      const { runPmStudioRestore } = await import("../src/pm-studio-setup.mjs");
-      await runPmStudioRestore({ commandName: CLI_NAME });
-      process.exit(0);
-    }
-    const { runPmStudioSetup } = await import("../src/pm-studio-setup.mjs");
-    await runPmStudioSetup({ commandName: CLI_NAME });
-    process.exit(0);
-  } catch (e) {
-    console.error(formatCliError(e));
-    process.exit(1);
-  }
-}
-
 let RUNTIME;
 try {
   RUNTIME = parseRuntimeOptions(process.env);
@@ -170,7 +144,6 @@ const ADAPTER_PORT = RUNTIME.adapterPort;
 const ADAPTER_HOST = RUNTIME.adapterHost;
 const MODEL_REFRESH_TIMEOUT_MS = RUNTIME.modelRefreshTimeoutMs;
 const EXISTING_ADAPTER_TIMEOUT_MS = RUNTIME.existingAdapterTimeoutMs;
-const CONFIGURE_CLAUDE_DESKTOP = CLI.configureClaudeDesktop || process.env.CCDX_CONFIGURE_CLAUDE_DESKTOP === "1";
 const LOGGING = configureLogging();
 let activeServer = null;
 let modelRefreshTimer = null;
@@ -181,24 +154,6 @@ if (LOGGING.filePath) {
   if (LOGGING.level === "debug") console.log(status("debug", "Debug logging enabled"));
 }
 
-function currentClaudeDesktopApiKey() {
-  return String(process.env.CCDX_CLAUDE_DESKTOP_API_KEY || process.env.CCDX_PROXY_API_KEY || "").trim();
-}
-
-function syncClaudeDesktopProfileModels(modelDefs) {
-  const result = syncManagedClaudeDesktopModels({
-    port: ADAPTER_PORT,
-    host: ADAPTER_HOST,
-    modelIds: claudeDesktopModelIds(process.env, { modelDefs }),
-  });
-  if (result.updated) {
-    console.log(status("ok", `Updated Claude App profile models: ${result.modelIds.join(", ")}`));
-  } else if (result.error) {
-    console.log(status("warn", `Could not update Claude App profile models (${result.error.message})`));
-  }
-  return result;
-}
-
 async function reuseRunningAdapterIfAvailable() {
   const running = await checkRunningAdapter({
     port: ADAPTER_PORT,
@@ -213,25 +168,6 @@ async function reuseRunningAdapterIfAvailable() {
 
   console.log(status("ok", `Using existing adapter at ${running.baseUrl}`));
   ensureCodexConfig(ADAPTER_PORT, { host: ADAPTER_HOST });
-  ensureClaudeConfig(ADAPTER_PORT, { host: ADAPTER_HOST });
-
-  if (CONFIGURE_CLAUDE_DESKTOP) {
-    const claudeDesktopApiKey = currentClaudeDesktopApiKey();
-    if (claudeDesktopApiKey) {
-      const result = applyClaudeDesktopConfig({
-        port: ADAPTER_PORT,
-        host: ADAPTER_HOST,
-        gatewayApiKey: claudeDesktopApiKey,
-        modelIds: claudeDesktopModelIds(process.env),
-      });
-      console.log(status("ok", `Configured Claude App gateway profile at ${result.baseUrl}`));
-      console.log(formatClaudeDesktopApplyResult(result));
-    } else {
-      console.log(status("warn", "Existing adapter is running; skip Claude App profile update unless CCDX_CLAUDE_DESKTOP_API_KEY or CCDX_PROXY_API_KEY is set"));
-    }
-  } else {
-    console.log(status("ok", "Claude App support available with --configure-claude-app"));
-  }
 
   await openCodex();
   console.log(`
@@ -249,14 +185,13 @@ if (CLI.command === "doctor") {
     host: ADAPTER_HOST,
     online: CLI.online,
     compat: CLI.compat,
-    profile: CLI.profile,
   });
   process.exit(checks.some((check) => check.kind === "err") ? 1 : 0);
 }
 
 console.log(`
   ${CLI_BANNER}
-  Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot
+  Use Codex Desktop and ChatGPT App with GitHub Copilot
 `);
 
 async function printUpdateNotice() {
@@ -279,84 +214,35 @@ try {
   await ensureAuth();
 
   const profileRuntime = createProfileRuntime({ codexClient: defaultCopilotClient });
-  if (profileRuntime.claudeMode === "isolated") {
-    if (profileRuntime.claudeProfile.valid) {
-      const account = profileRuntime.claudeProfile.identity?.login
-        || profileRuntime.claudeProfile.identity?.id
-        || "the saved account";
-      console.log(status("ok", `Claude requests will use the isolated GitHub account ${account}`));
-    } else {
-      console.log(status("warn", `Claude profile is configured but invalid (${profileRuntime.claudeProfile.reason}); Codex remains available, but Claude requests will fail until you run ${CLI_NAME} auth login claude --reauth and restart`));
-    }
-  }
-
   const profileModels = createProfileModelRuntime({
     codexClient: profileRuntime.codexClient,
-    claudeClient: profileRuntime.claudeClient,
-    claudeMode: profileRuntime.claudeMode,
     codexCredentialFingerprint: profileRuntime.codexCredentialFingerprint,
-    claudeCredentialFingerprint: profileRuntime.claudeCredentialFingerprint,
     timeoutMs: MODEL_REFRESH_TIMEOUT_MS,
     commandName: CLI_NAME,
     autoReviewModelResolver: () => autoReviewModelPreference().model,
-    onClaudeModelsChanged: syncClaudeDesktopProfileModels,
   });
 
   // Refresh the VS Code version in the background; fallback is non-blocking.
   void refreshVSCodeVersion();
-  const modelInitialization = await profileModels.initialize();
-  const claudeDesktopModelDefs = modelInitialization.claude.modelDefs;
-  syncClaudeDesktopProfileModels(claudeDesktopModelDefs);
+  await profileModels.initialize();
 
   if (!isLoopbackHost(ADAPTER_HOST)) {
     console.log(status("warn", `ADAPTER_HOST=${ADAPTER_HOST} exposes the adapter beyond loopback because CCDX_ALLOW_LAN=1 is set. Use only on trusted networks.`));
   }
 
-  const configuredClaudeDesktopApiKey = currentClaudeDesktopApiKey();
-  const restoredClaudeDesktopApiKey = configuredClaudeDesktopApiKey ? "" : loadManagedClaudeDesktopApiKey({
-    port: ADAPTER_PORT,
-    host: ADAPTER_HOST,
-  });
-  if (restoredClaudeDesktopApiKey) {
-    console.log(status("ok", "Restored Claude App gateway key from the managed profile"));
-  }
-  const claudeDesktopApiKey = configuredClaudeDesktopApiKey
-    || restoredClaudeDesktopApiKey
-    || (CONFIGURE_CLAUDE_DESKTOP ? generatedClaudeDesktopApiKey() : "");
-
   // Start the in-process adapter.
   activeServer = await startAdapter(ADAPTER_PORT, ADAPTER_HOST, {
-    claudeDesktopApiKey,
-    claudeDesktopModelDefs,
     autoReviewModelResolver: () => autoReviewModelPreference().model,
     codexClient: profileRuntime.codexClient,
-    claudeClient: profileRuntime.claudeClient,
-    claudeProfile: profileRuntime.claudeProfile,
     codexModelRegistry: profileModels.codexRegistry,
-    claudeModelRegistry: profileModels.claudeRegistry,
-    claudeMode: profileRuntime.claudeMode,
-    isClaudeProfileCurrent: profileRuntime.isClaudeProfileCurrent,
     showRequestId: CLI.showRequestId,
     upstreamTimeoutMs: RUNTIME.upstreamTimeoutMs,
     streamHandshakeTimeoutMs: RUNTIME.streamHandshakeTimeoutMs,
     streamIdleTimeoutMs: RUNTIME.streamIdleTimeoutMs,
   });
 
-  // Point Codex and Claude Code at the adapter.
+  // Point Codex and compatible ChatGPT App builds at the adapter.
   ensureCodexConfig(ADAPTER_PORT, { host: ADAPTER_HOST });
-  ensureClaudeConfig(ADAPTER_PORT, { host: ADAPTER_HOST });
-  if (CONFIGURE_CLAUDE_DESKTOP) {
-    const result = applyClaudeDesktopConfig({
-      port: ADAPTER_PORT,
-      host: ADAPTER_HOST,
-      gatewayApiKey: claudeDesktopApiKey,
-      modelIds: claudeDesktopModelIds(process.env, { modelDefs: claudeDesktopModelDefs }),
-    });
-    console.log(status("ok", `Configured Claude App gateway profile at ${result.baseUrl}`));
-    console.log(formatClaudeDesktopApplyResult(result));
-  } else {
-    console.log(status("ok", "Claude App support available with --configure-claude-app"));
-  }
 
   // Launch Codex when available.
   await openCodex();
@@ -371,10 +257,8 @@ try {
     modelRefreshTimer.unref?.();
   }
 
-  const readyClients = ["Codex App", "Claude Code"];
-  if (claudeDesktopApiKey) readyClients.splice(1, 0, "Claude App");
   console.log(`
-  ${status("ok", `Ready, ${readyClients.join(", ")} ${readyClients.length === 1 ? "is" : "are"} ready to use`)}
+  ${status("ok", "Ready, Codex App and ChatGPT App are ready to use")}
 
   Adapter: ${adapterBaseUrl(ADAPTER_HOST, ADAPTER_PORT)}
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.6.20",
-  "description": "Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot",
+  "version": "0.7.0",
+  "description": "Use Codex Desktop and ChatGPT App with GitHub Copilot",
   "author": "Dale Xiao",
   "type": "module",
   "bin": {
@@ -18,11 +18,6 @@
     "codex",
     "copilot",
     "github",
-    "claude",
-    "claude-app",
-    "claude-code",
-    "claude-desktop",
-    "anthropic",
     "openai",
     "proxy",
     "responses-api"
@@ -51,7 +46,6 @@
     "prepublishOnly": "npm run verify"
   },
   "dependencies": {
-    "gpt-tokenizer": "^3.4.0",
     "sharp": "^0.35.3"
   }
 }

package/scripts/benchmark.mjs

@@ -8,7 +8,6 @@ import { setTimeout as delay } from "node:timers/promises";
 import { fileURLToPath } from "node:url";
 import sharp from "sharp";
 import { optimizeImagesInBody, prepareResponsesPayload } from "../src/image-optimization.mjs";
-import { createPmStudioModelRouter } from "../src/profile-routing.mjs";
 
 const packageRoot = fileURLToPath(new URL("../", import.meta.url));
 
@@ -23,14 +22,6 @@ function runProbe(source) {
   return JSON.parse(result.stdout.trim());
 }
 
-function median(values) {
-  const ordered = [...values].sort((left, right) => left - right);
-  const middle = Math.floor(ordered.length / 2);
-  return ordered.length % 2 === 0
-    ? (ordered[middle - 1] + ordered[middle]) / 2
-    : ordered[middle];
-}
-
 function sseLinearityProbe() {
   return runProbe(`
     import { webStreamLines } from "./src/stream.mjs";
@@ -220,38 +211,6 @@ function largePayloadProbe(targetMiB, concurrency) {
   }
 }
 
-function largeTokenCountProbe(mode) {
-  const samples = Array.from({ length: 3 }, () => 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),
-    }));
-  `));
-  return {
-    input_mib: samples[0].input_mib,
-    tokens: samples[0].tokens,
-    elapsed_ms: +median(samples.map((sample) => sample.elapsed_ms)).toFixed(1),
-    rss_mib: +median(samples.map((sample) => sample.rss_mib)).toFixed(1),
-    heap_used_mib: +median(samples.map((sample) => sample.heap_used_mib)).toFixed(1),
-    samples: samples.length,
-  };
-}
-
 function toolOutputParseCacheProbe() {
   return runProbe(`
     import { enforceResponsesImageLimit } from "./src/responses-image-limit.mjs";
@@ -355,29 +314,6 @@ const adapterImport = runProbe(`
   }));
 `);
 
-const tokenCount = runProbe(`
-  const importStarted = performance.now();
-  const { countTokens } = await import("./src/anthropic.mjs");
-  const importMs = performance.now() - importStarted;
-  const body = { messages: [{ role: "user", content: "a ".repeat(50000) }] };
-  const firstStarted = performance.now();
-  const first = await countTokens(body);
-  const firstMs = performance.now() - firstStarted;
-  const warmStarted = performance.now();
-  const warm = await countTokens(body);
-  const warmMs = performance.now() - warmStarted;
-  globalThis.gc?.();
-  const memory = process.memoryUsage();
-  console.log(JSON.stringify({
-    module_import_ms: +importMs.toFixed(1),
-    first_call_ms: +firstMs.toFixed(1),
-    warm_call_ms: +warmMs.toFixed(1),
-    input_tokens: first.input_tokens,
-    deterministic: first.input_tokens === warm.input_tokens,
-    rss_mib: +(memory.rss / 1048576).toFixed(1),
-  }));
-`);
-
 const repeatedImage = "data:image/png;base64,QUJDRA==";
 const duplicateBody = {
   input: [{
@@ -402,34 +338,6 @@ const duplicateImages = {
   optimizer_calls: duplicateCalls,
 };
 
-const routingCatalog = {
-  data: Array.from({ length: 1000 }, (_, index) => index % 5 === 0
-    ? {
-        id: `claude-benchmark-${index}`,
-        vendor: "Anthropic",
-        model_picker_enabled: true,
-        supported_endpoints: ["/chat/completions"],
-      }
-    : { id: `gpt-benchmark-${index}`, vendor: "OpenAI", supported_endpoints: ["/responses"] }),
-};
-const modelRouter = createPmStudioModelRouter({
-  getCatalog: () => routingCatalog,
-  isClaudeEnabled: () => true,
-});
-const routingIterations = 100000;
-const routingStarted = performance.now();
-let claudeClassifications = 0;
-for (let index = 0; index < routingIterations; index += 1) {
-  if (modelRouter.classify("claude-benchmark-0") === "claude") claudeClassifications += 1;
-}
-const pmModelRouting = {
-  catalog_models: routingCatalog.data.length,
-  iterations: routingIterations,
-  elapsed_ms: +(performance.now() - routingStarted).toFixed(1),
-  claude_classifications: claudeClassifications,
-  availability_rebuilds: modelRouter.diagnostics().rebuilds,
-};
-
 const pixels = deterministicPixels(1024 * 1024 * 3, 0x87654321);
 const webp = await sharp(pixels, { raw: { width: 1024, height: 1024, channels: 3 } })
   .webp({ quality: 100 })
@@ -474,18 +382,12 @@ const report = {
     ? "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,
-  pm_model_routing: pmModelRouting,
   oversized_payload: oversizedPayload,
 };
 
 if (checkMode) {
   report.sse_linearity = sseLinearityProbe();
-  report.large_token_count = {
-    proxy: largeTokenCountProbe("proxy"),
-    materialized_array: largeTokenCountProbe("array"),
-  };
   report.tool_output_parse_cache = toolOutputParseCacheProbe();
   report.large_payload_peak = [
     largePayloadProbe(5, 4),
@@ -507,22 +409,6 @@ console.log(JSON.stringify(report, null, 2));
 
 if (checkMode) {
   const failures = [];
-  if (report.pm_model_routing.availability_rebuilds !== 1
-    || report.pm_model_routing.claude_classifications !== report.pm_model_routing.iterations) {
-    failures.push("PM Studio model routing did not reuse the memoized catalog classification");
-  }
-  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`);
-  }
   if (report.tool_output_parse_cache.parse_calls !== 1) {
     failures.push(`stringified tool output parsed ${report.tool_output_parse_cache.parse_calls} times instead of once`);
   }

package/src/adapter.mjs

@@ -1,8 +1,6 @@
 import http from "node:http";
-import { createAnthropicCountTokensHandler, createAnthropicMessagesHandler } from "./anthropic-handler.mjs";
 import { defaultCopilotClient } from "./copilot.mjs";
 import { isValidModelList } from "./model-cache.mjs";
-import { claudeDesktopModelsResponse } from "./models.mjs";
 import {
   ADAPTER_STATUS_PATH,
   classifyAdapterRoute,
@@ -11,11 +9,9 @@ import {
   runtimeStatusPayload,
 } from "./observability.mjs";
 import { createRequestId, runWithRequestContext } from "./request-context.mjs";
-import { createPmStudioRelayHandler, PM_STUDIO_RELAY_PREFIX } from "./pm-studio-relay.mjs";
 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";
@@ -63,17 +59,19 @@ export function requestPath(reqUrl) {
   return new URL(reqUrl || "/", "http://localhost").pathname;
 }
 
-function bearerToken(headers = {}) {
-  const value = headers.authorization || headers.Authorization || "";
-  const match = /^Bearer\s+(.+)$/i.exec(String(value));
-  return match?.[1]?.trim() || "";
-}
-
-export function shouldServeClaudeDesktopModels(req, claudeDesktopApiKey) {
-  if (!claudeDesktopApiKey || claudeDesktopApiKey === "dummy") return false;
-  const token = bearerToken(req.headers);
-  const xApiKey = req.headers?.["x-api-key"] || req.headers?.["X-Api-Key"] || req.headers?.["X-API-Key"] || "";
-  return token === claudeDesktopApiKey || xApiKey === claudeDesktopApiKey;
+function sendRetiredClaudeSurface(res) {
+  res.writeHead(410, {
+    "Content-Type": "application/json",
+    "Cache-Control": "no-store",
+  });
+  res.end(JSON.stringify({
+    type: "error",
+    error: {
+      type: "not_found_error",
+      code: "ccdx_claude_retired",
+      message: "Claude App and Claude Code support was retired in ccdx 0.7.0.",
+    },
+  }));
 }
 
 function modelListCanUseLastKnownGood(statusCode) {
@@ -93,50 +91,18 @@ function sendLastKnownGoodModels(res, modelRegistry) {
 // Shared request handler. Keeping this separate from the listener makes the
 // complete HTTP routing layer testable without opening a local port.
 export function createAdapterHandler(options = {}) {
-  const claudeDesktopApiKey = options.claudeDesktopApiKey
-    || process.env.CCDX_CLAUDE_DESKTOP_API_KEY
-    || process.env.CCDX_PROXY_API_KEY
-    || "";
   const codexClient = options.codexClient || defaultCopilotClient;
-  const hasExplicitClaudeMode = Object.hasOwn(options, "claudeMode");
-  if (hasExplicitClaudeMode && !["inherited", "isolated"].includes(options.claudeMode)) {
-    throw new Error(`Unsupported Claude mode: ${options.claudeMode}`);
-  }
-  if (options.claudeMode === "isolated"
-    && (!options.claudeClient || options.claudeClient === codexClient)) {
-    throw new Error("Isolated Claude mode requires a distinct Claude client");
-  }
-  if (options.claudeMode === "inherited"
-    && options.claudeClient && options.claudeClient !== codexClient) {
-    throw new Error("Inherited Claude mode requires the Codex client");
-  }
-  const claudeClient = options.claudeClient || codexClient;
-  // chatCompletionsFn is retained as a compatibility injection and continues to
-  // override both surfaces in existing tests and embedders. New dual-profile
-  // callers should pass codexClient/claudeClient instead.
-  const codexChatCompletionsFn = options.codexChatCompletionsFn
+  // Keep the established injection names because Responses may still use the
+  // internal Chat Completions compatibility path for upstream models that need it.
+  const chatCompletionsFn = options.codexChatCompletionsFn
     || options.chatCompletionsFn
     || codexClient.chatCompletions;
-  const claudeChatCompletionsFn = options.claudeChatCompletionsFn
-    || options.chatCompletionsFn
-    || claudeClient.chatCompletions;
   const responsesFn = options.responsesFn || codexClient.responses;
   const responsesCompactFn = options.responsesCompactFn || codexClient.responsesCompact;
   const listModelsFn = options.listModelsFn || codexClient.listModels;
   const getCachedModelEndpointsFn = options.getCachedModelEndpointsFn
     || codexClient.getCachedModelEndpoints;
-  const claudeMode = hasExplicitClaudeMode
-    ? options.claudeMode
-    : claudeClient === codexClient ? "inherited" : "isolated";
-  if (claudeMode === "isolated" && options.chatCompletionsFn) {
-    throw new Error("Isolated Claude mode cannot use the shared chatCompletionsFn override; pass codexChatCompletionsFn or claudeChatCompletionsFn explicitly");
-  }
   const codexModelRegistry = options.codexModelRegistry || options.modelRegistry;
-  const claudeModelRegistry = options.claudeModelRegistry || options.modelRegistry || codexModelRegistry;
-  if (claudeMode === "isolated"
-    && (!options.claudeModelRegistry || claudeModelRegistry === codexModelRegistry)) {
-    throw new Error("Isolated Claude mode requires a distinct Claude model registry");
-  }
   const openAIModelEnv = options.openAIModelEnv || process.env;
   const upstreamTimeoutMs = parsePositiveInteger(options.upstreamTimeoutMs, ADAPTER_RUNTIME_CONFIG.upstreamTimeoutMs);
   const streamHandshakeTimeoutMs = parsePositiveInteger(options.streamHandshakeTimeoutMs, ADAPTER_RUNTIME_CONFIG.streamHandshakeTimeoutMs);
@@ -146,19 +112,10 @@ 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 } : {};
-  };
   const responsesHandler = createResponsesHandler({
     acquireRequest,
     autoReviewModelResolver: options.autoReviewModelResolver,
-    chatCompletionsFn: codexChatCompletionsFn,
+    chatCompletionsFn,
     getCachedModelEndpointsFn,
     imagePressure,
     modelRegistry: codexModelRegistry,
@@ -184,34 +141,6 @@ export function createAdapterHandler(options = {}) {
     streamIdleTimeoutMs,
     upstreamTimeoutMs,
   });
-  const anthropicCountTokensHandler = createAnthropicCountTokensHandler({
-    acquireRequest,
-    requestBodyTimeoutMs,
-    countTokensFn: (body, countOptions) => tokenCounterService.count(body, countOptions),
-  });
-  const anthropicMessagesHandler = createAnthropicMessagesHandler({
-    acquireRequest,
-    chatCompletionsFn: claudeChatCompletionsFn,
-    environment: process.env,
-    modelOptions: claudeDesktopModelOptions,
-    requestBodyTimeoutMs,
-    streamHandshakeTimeoutMs,
-    streamIdleTimeoutMs,
-    upstreamTimeoutMs,
-  });
-  const pmStudioRelayHandler = createPmStudioRelayHandler({
-    acquireRequest,
-    claudeClient,
-    claudeMode,
-    claudeProfile: options.claudeProfile,
-    claudeModelRegistry,
-    fetchImpl: options.pmStudioFetchImpl,
-    requestBodyTimeoutMs,
-    streamHandshakeTimeoutMs,
-    streamIdleTimeoutMs,
-    upstreamTimeoutMs,
-  });
-
   const dispatch = (req, res, pathname) => {
     if (req.method === "GET" && pathname === ADAPTER_STATUS_PATH) {
       if (!isLoopbackAddress(req.socket?.remoteAddress)) {
@@ -227,11 +156,7 @@ export function createAdapterHandler(options = {}) {
         imagePressure,
         modelRegistry: codexModelRegistry,
         codexClient,
-        claudeClient,
         codexModelRegistry,
-        claudeModelRegistry,
-        claudeMode,
-        isClaudeProfileCurrent: options.isClaudeProfileCurrent,
       })));
       return;
     }
@@ -242,10 +167,6 @@ export function createAdapterHandler(options = {}) {
       return;
     }
 
-    if (pathname.startsWith(`${PM_STUDIO_RELAY_PREFIX}/`)) {
-      return pmStudioRelayHandler(req, res, pathname);
-    }
-
     if (req.method === "POST" && pathname === "/v1/responses") {
       return responsesHandler(req, res);
     }
@@ -255,11 +176,6 @@ export function createAdapterHandler(options = {}) {
     }
 
     if (req.method === "GET" && pathname === "/v1/models") {
-      if (shouldServeClaudeDesktopModels(req, claudeDesktopApiKey)) {
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify(claudeDesktopModelsResponse(process.env, claudeDesktopModelOptions())));
-        return;
-      }
       const abort = createRequestAbort(req, res);
       abort.setTimeout(upstreamTimeoutMs);
       listModelsFn({ signal: abort.signal })
@@ -296,11 +212,11 @@ export function createAdapterHandler(options = {}) {
     }
 
     if (req.method === "POST" && pathname === "/v1/messages/count_tokens") {
-      return anthropicCountTokensHandler(req, res);
+      return sendRetiredClaudeSurface(res);
     }
 
     if (req.method === "POST" && pathname === "/v1/messages") {
-      return anthropicMessagesHandler(req, res);
+      return sendRetiredClaudeSurface(res);
     }
 
     res.writeHead(404, { "Content-Type": "application/json" });
@@ -388,9 +304,6 @@ export function createAdapterHandler(options = {}) {
       containUnexpectedError(error);
     }
   };
-  handler.cleanup = () => {
-    if (ownsTokenCounterService) tokenCounterService.close();
-  };
   return handler;
 }