codex-copilot-dx 0.5.6 → 0.6.1

package/README.md

@@ -1,14 +1,16 @@
 # codex-copilot-dx
 
-Use [Codex Desktop](https://openai.com/codex), [Claude Code](https://claude.com/claude-code), and optionally Claude App with your **GitHub Copilot** subscription.
+Use [Codex Desktop](https://openai.com/codex), [Claude Code](https://claude.com/claude-code), and optionally Claude App or PM Studio with your **GitHub Copilot** subscription.
 
 ## How it works
 
-A single in-process adapter (port `2026`) exposes both APIs over your Copilot subscription:
+A single in-process adapter (port `2026`) exposes both APIs over one Copilot
+account by default, or over isolated Codex and Claude accounts when configured:
 
 - **Codex** -> OpenAI Responses API (`/v1/responses`, `/v1/responses/compact`); Responses-only models and compaction proxy directly, chat models convert to Chat Completions.
 - **Claude Code** -> Anthropic Messages API (`/v1/messages`, `/v1/messages/count_tokens`), translated to/from Chat Completions.
 - **Claude App** -> optional Claude Desktop App gateway profile using the same local Messages API plus local model discovery for the configured gateway key.
+- **PM Studio** -> optional macOS app patch that keeps the active PM profile for GPT models while routing enabled Claude models through an isolated CCDX Claude account.
 
 Supports both HTTP SSE streaming and non-streaming.
 
@@ -18,7 +20,7 @@ Codex Auto-review requests use the hidden `codex-auto-review` model ID. The adap
 
 - GitHub Copilot subscription (Individual, Business, or Enterprise)
 - Node.js 22.15+ (required for built-in Zstandard request decompression)
-- [Codex Desktop](https://openai.com/codex), [Claude Code](https://claude.com/claude-code), and/or Claude App installed
+- [Codex Desktop](https://openai.com/codex), [Claude Code](https://claude.com/claude-code), Claude App, and/or a supported PM Studio installation
 
 ## Usage
 
@@ -33,8 +35,8 @@ global install, use `npx codex-copilot-dx@latest`.
 Both installed commands expose the same options and subcommands; help, version,
 doctor, status, and argument-error output use the command name that was invoked.
 
-To query the models currently advertised as selectable for the saved Copilot
-account, run:
+To query the models currently advertised as selectable for the saved Codex
+Copilot account, run:
 
 ```bash
 ccdx models
@@ -48,6 +50,122 @@ being advertised does not guarantee that a later inference request will avoid
 quota, rate-limit, or policy enforcement. `codex-copilot-dx models` is fully
 equivalent.
 
+### Separate GitHub account for Claude
+
+The default remains fully backward compatible: Codex and Claude requests share
+the existing GitHub authentication. To keep an enterprise account for Codex
+while using a different personal account that has Claude models enabled, run:
+
+```bash
+ccdx auth login claude --github-login <personal-github-login>
+```
+
+This is the only command that starts the additional Device Flow. It verifies
+the selected GitHub identity, Copilot entitlement, and an enabled Claude model
+before saving anything. It refuses the current Codex account and never changes,
+migrates, or deletes the existing Codex credential. The optional login pin is
+recommended so authorizing the wrong browser account fails before activation.
+
+The existing Codex token remains at
+`~/.local/share/copilot-api/github_token`. The isolated Claude credential is
+stored with mode `0600` under
+`~/.local/share/copilot-api/profiles/claude/github_token`, with matching account
+metadata committed last. Restart a running adapter after authentication.
+
+Once enabled, routing is fixed by API surface rather than by model name:
+
+- `/v1/responses`, `/v1/responses/compact`, their Chat fallback, and normal
+  `/v1/models` use the Codex account.
+- `/v1/messages` and Claude App model discovery use the isolated Claude account.
+- `/v1/messages/count_tokens` remains local and uses neither account.
+
+The two profiles keep separate service tokens, API bases, refresh/backoff state,
+model endpoint metadata, and model caches. If the isolated Claude profile later
+becomes invalid, Claude requests fail with a reauthentication instruction while
+Codex remains available; CCDX never silently falls back to the enterprise
+account. Reauthorize it explicitly with:
+
+```bash
+ccdx auth login claude --reauth --github-login <personal-github-login>
+```
+
+These commands are read-only and never start Device Flow:
+
+```bash
+ccdx auth status
+ccdx auth status --online
+ccdx models --profile claude
+ccdx doctor --online --profile all
+```
+
+### PM Studio opt-in patch
+
+CCDX can add the isolated Claude catalog to PM Studio without switching its
+active account or profile. GPT requests continue to use the bearer supplied by
+the current PM profile; exact enabled Anthropic model IDs use the isolated
+CCDX Claude profile. Neither credential is copied into the other application.
+
+The first recipe supports only an exact, unmodified PM Studio 2.9.7 bundle on
+macOS. Authorize the isolated Claude profile first, quit PM Studio and its
+updater, then run the one-time setup command:
+
+```bash
+ccdx auth login claude --reauth --github-login <personal-github-login>
+ccdx pms setup
+```
+
+`ccdx pms setup` performs only local preflight, backup, staging, integrity,
+signing, and replacement work. It never starts Device Flow, the adapter,
+Codex, or PM Studio, and it does not modify PM profiles, cached model lists, or
+saved PM tokens. Unknown versions, hashes, signatures, partial patches, a
+running PM process, insufficient space, and every pre-replacement verification
+failure leave the installed App unchanged. If the final read-only verification
+after an atomic replacement detects an exceptional filesystem drift, setup
+does not attempt a second automatic write: it preserves the verified backup,
+retains any diagnostic stage still present, and prints recovery paths. Repeating
+setup for the exact installed recipe is idempotent.
+
+The patch is App-wide: every PM profile sends its Copilot API traffic through
+the loopback-only `/pm-ccdx/*` relay. Run ordinary `ccdx` before opening PM
+Studio; if port 2026 is unavailable, PM Copilot requests cannot connect. The
+relay explicitly supports only the PM 2.9.7 Copilot paths discovered in the
+validated bundle (`GET /models` and `POST /chat/completions`, `/responses`, and
+`/embeddings`) and is not a general-purpose proxy.
+
+Patching replaces the vendor signature with an ad-hoc signature. PM Studio's
+updater is not disabled; an official update may overwrite the patch or may
+require reinstalling the official App. Setup prints the verified backup and
+manifest paths plus the version-matched restore procedure. Never restore a
+2.9.7 backup over a newer PM Studio installation.
+
+To restore, first quit PM Studio and its updater. Use the exact verified backup
+path printed by setup as `BACKUP_APP`, then confirm that both the installed App
+and backup still report version/build `2.9.7/2.9.7`:
+
+```bash
+BACKUP_APP="<verified-backup-path-from-ccdx-pms-setup>"
+/usr/bin/plutil -extract CFBundleShortVersionString raw -o - "/Applications/PM Studio.app/Contents/Info.plist"
+/usr/bin/plutil -extract CFBundleVersion raw -o - "/Applications/PM Studio.app/Contents/Info.plist"
+/usr/bin/plutil -extract CFBundleShortVersionString raw -o - "$BACKUP_APP/Contents/Info.plist"
+/usr/bin/plutil -extract CFBundleVersion raw -o - "$BACKUP_APP/Contents/Info.plist"
+```
+
+Only when all four values match `2.9.7`, move the patched App aside, restore the
+complete vendor-signed backup, and verify it before launch:
+
+```bash
+RECOVERY_DIR="$(/usr/bin/mktemp -d '/Applications/CCDX-PM-Studio-recovery.XXXXXX')"
+PATCHED_APP="$RECOVERY_DIR/PM Studio.app"
+mv "/Applications/PM Studio.app" "$PATCHED_APP"
+/usr/bin/ditto --rsrc --extattr --acl "$BACKUP_APP" "/Applications/PM Studio.app"
+/usr/bin/codesign --verify --deep --strict --verbose=2 "/Applications/PM Studio.app"
+```
+
+If the version check, copy, or signature verification fails, do not launch the
+restored App. Keep the moved patched bundle at `$PATCHED_APP` and reinstall the official PM Studio
+instead of applying a 2.9.7 backup to unknown content. CCDX never runs these
+restore commands or `sudo` automatically.
+
 To change the model used by Codex Auto-review, run:
 
 ```bash
@@ -123,6 +241,9 @@ ccdx doctor --online
 ```
 
 The online doctor never starts device flow, scans for replacement tokens, or changes the saved token.
+Use `--profile codex`, `--profile claude`, or `--profile all` to choose which
+account entitlement is checked. Without `--profile`, the legacy Codex check is
+preserved.
 
 To actively verify the protocol path through an already-running adapter, run:
 

package/bin/cli.mjs

@@ -5,8 +5,8 @@ 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 { cacheModelEndpoints, listModels, refreshVSCodeVersion } from "../src/copilot.mjs";
-import { claudeDesktopModelDefsFromCopilotModels, claudeDesktopModelIds, codexAutoReviewModelStatus, gptModelIdsFromCopilotModels, parseModelAliasEnv } from "../src/models.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";
@@ -14,14 +14,16 @@ import { checkForUpdate, localPackageVersion } from "../src/version.mjs";
 import { runDoctor } from "../src/doctor.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";
+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 { closeHttpServer } from "../src/shutdown.mjs";
 import { runAutoReviewModelCommand } from "../src/auto-review-model.mjs";
 import { autoReviewModelPreference } from "../src/user-settings.mjs";
 import { fetchLiveCopilotModels, formatLiveCopilotModels } from "../src/cli-models.mjs";
+import { runAuthCommand } from "../src/cli-auth.mjs";
+import { createProfileRuntime } from "../src/profile-runtime.mjs";
+import { createProfileModelRuntime } from "../src/profile-model-runtime.mjs";
 
 const LOCAL_VERSION = localPackageVersion();
 const CLI_NAME = cliCommandName();
@@ -48,6 +50,29 @@ if (CLI.command === "usage") {
   await printUsageSummary();
   process.exit(0);
 }
+if (CLI.command === "auth") {
+  try {
+    const result = await runAuthCommand({
+      action: CLI.action,
+      profile: CLI.profile,
+      online: CLI.online,
+      reauth: CLI.reauth,
+      expectedLogin: CLI.expectedLogin,
+      commandName: CLI_NAME,
+    });
+    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));
+    process.exit(1);
+  }
+}
 if (CLI.command === "status") {
   let probe;
   try {
@@ -71,7 +96,7 @@ if (CLI.command === "status") {
 }
 if (CLI.command === "models") {
   try {
-    const catalog = await fetchLiveCopilotModels();
+    const catalog = await fetchLiveCopilotModels({ profile: CLI.profile });
     console.log(formatLiveCopilotModels(catalog, { commandName: CLI_NAME }));
     process.exit(0);
   } catch (e) {
@@ -98,6 +123,16 @@ if (CLI.command === "update") {
     process.exit(1);
   }
 }
+if (CLI.command === "pms") {
+  try {
+    const { runPmStudioSetup } = await import("../src/pm-studio-setup.mjs");
+    await runPmStudioSetup({ commandName: CLI_NAME });
+    process.exit(0);
+  } catch (e) {
+    console.error(status("err", e.message));
+    process.exit(1);
+  }
+}
 
 let RUNTIME;
 try {
@@ -113,7 +148,6 @@ 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();
-const MODEL_REGISTRY = { modelDefs: undefined, models: undefined, source: "built-in" };
 let activeServer = null;
 let modelRefreshTimer = null;
 let shuttingDown = false;
@@ -123,88 +157,11 @@ if (LOGGING.filePath) {
   if (LOGGING.level === "debug") console.log(status("debug", "Debug logging enabled"));
 }
 
-function applyModelsToRegistry(models, source, { updateClaudeModels = true } = {}) {
-  if (!isValidModelList(models)) throw new Error("Copilot models response contained no valid models");
-  const modelDefs = updateClaudeModels
-    ? claudeDesktopModelDefsFromCopilotModels(models)
-    : MODEL_REGISTRY.modelDefs;
-  cacheModelEndpoints(models);
-  MODEL_REGISTRY.models = models;
-  if (updateClaudeModels && modelDefs.length) {
-    MODEL_REGISTRY.modelDefs = modelDefs;
-    MODEL_REGISTRY.source = source;
-  }
-  return modelDefs;
-}
-
-function loadCachedModelRegistry() {
-  const cached = loadModelCache();
-  if (!cached) return false;
-  try {
-    const customAliases = parseModelAliasEnv(process.env.CCDX_CLAUDE_MODEL_ALIASES).length > 0;
-    applyModelsToRegistry(cached, "cache", { updateClaudeModels: !customAliases });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function refreshClaudeDesktopModelDefs() {
-  const customAliases = parseModelAliasEnv(process.env.CCDX_CLAUDE_MODEL_ALIASES).length > 0;
-
-  const ctrl = new AbortController();
-  const timer = setTimeout(() => ctrl.abort(), MODEL_REFRESH_TIMEOUT_MS);
-  try {
-    const { status: httpStatus, body } = await listModels({ signal: ctrl.signal });
-    if (httpStatus < 200 || httpStatus >= 300) {
-      throw new Error(`Copilot models returned HTTP ${httpStatus}`);
-    }
-    const models = JSON.parse(body);
-    const autoReview = codexAutoReviewModelStatus(models, process.env, {
-      autoReviewModel: autoReviewModelPreference().model,
-    });
-    if (!autoReview.available) {
-      console.log(status("warn", `Auto-review target ${autoReview.upstreamModel} is unavailable: ${autoReview.reason}. Run ${CLI_NAME} 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(", ")}`));
-    } else {
-      console.log(status("warn", "Copilot models response contained no GPT models"));
-    }
-
-    const modelDefs = applyModelsToRegistry(models, "live", { updateClaudeModels: !customAliases });
-    try {
-      saveModelCache(models);
-    } catch (e) {
-      console.log(status("warn", `Could not persist the Copilot model cache (${e.message})`));
-    }
-    if (customAliases) {
-      console.log(status("info", "Using CCDX_CLAUDE_MODEL_ALIASES for Claude models"));
-    } else if (modelDefs?.length) {
-      console.log(status("ok", `Refreshed Claude models from GitHub Copilot: ${modelDefs.map((model) => model.id).join(", ")}`));
-    } else {
-      console.log(status("warn", "Copilot models response contained no Claude models; using built-in Claude models"));
-    }
-    syncClaudeDesktopProfileModels(MODEL_REGISTRY.modelDefs);
-    return modelDefs;
-  } catch (e) {
-    const fallback = MODEL_REGISTRY.modelDefs?.length ? `${MODEL_REGISTRY.source} model list` : "built-in model list";
-    const message = ctrl.signal.aborted
-      ? `Model refresh timed out after ${MODEL_REFRESH_TIMEOUT_MS}ms; using ${fallback}`
-      : `Could not refresh model list; using ${fallback} (${e.message})`;
-    console.log(status("warn", message));
-    return MODEL_REGISTRY.modelDefs;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
 function currentClaudeDesktopApiKey() {
   return String(process.env.CCDX_CLAUDE_DESKTOP_API_KEY || process.env.CCDX_PROXY_API_KEY || "").trim();
 }
 
-function syncClaudeDesktopProfileModels(modelDefs = MODEL_REGISTRY.modelDefs) {
+function syncClaudeDesktopProfileModels(modelDefs) {
   const result = syncManagedClaudeDesktopModels({
     port: ADAPTER_PORT,
     host: ADAPTER_HOST,
@@ -268,6 +225,7 @@ 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);
 }
@@ -296,14 +254,33 @@ try {
   // Ensure GitHub login, using device flow if no token exists.
   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,
+    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 initializeModelRegistry({
-    loadCached: loadCachedModelRegistry,
-    currentModelDefs: () => MODEL_REGISTRY.modelDefs,
-    refresh: refreshClaudeDesktopModelDefs,
-  });
-  const claudeDesktopModelDefs = modelInitialization.modelDefs;
+  const modelInitialization = await profileModels.initialize();
+  const claudeDesktopModelDefs = modelInitialization.claude.modelDefs;
   syncClaudeDesktopProfileModels(claudeDesktopModelDefs);
 
   if (!isLoopbackHost(ADAPTER_HOST)) {
@@ -327,7 +304,12 @@ try {
     claudeDesktopApiKey,
     claudeDesktopModelDefs,
     autoReviewModelResolver: () => autoReviewModelPreference().model,
-    modelRegistry: MODEL_REGISTRY,
+    codexClient: profileRuntime.codexClient,
+    claudeClient: profileRuntime.claudeClient,
+    claudeProfile: profileRuntime.claudeProfile,
+    codexModelRegistry: profileModels.codexRegistry,
+    claudeModelRegistry: profileModels.claudeRegistry,
+    claudeMode: profileRuntime.claudeMode,
     showRequestId: CLI.showRequestId,
     upstreamTimeoutMs: RUNTIME.upstreamTimeoutMs,
     streamHandshakeTimeoutMs: RUNTIME.streamHandshakeTimeoutMs,
@@ -358,7 +340,7 @@ try {
   const refreshIntervalMs = RUNTIME.modelRefreshIntervalMs;
   if (Number.isFinite(refreshIntervalMs) && refreshIntervalMs > 0) {
     modelRefreshTimer = setInterval(() => {
-      refreshClaudeDesktopModelDefs().catch(() => {});
+      profileModels.refreshAll().catch(() => {});
     }, refreshIntervalMs);
     modelRefreshTimer.unref?.();
   }

package/package.json

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

package/src/adapter.mjs

@@ -1,6 +1,6 @@
 import http from "node:http";
 import { createAnthropicCountTokensHandler, createAnthropicMessagesHandler } from "./anthropic-handler.mjs";
-import { chatCompletions, listModels, responses as copilotResponses, responsesCompact as copilotResponsesCompact } from "./copilot.mjs";
+import { defaultCopilotClient } from "./copilot.mjs";
 import { isValidModelList } from "./model-cache.mjs";
 import { claudeDesktopModelsResponse } from "./models.mjs";
 import {
@@ -11,6 +11,7 @@ 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";
@@ -90,10 +91,46 @@ export function createAdapterHandler(options = {}) {
     || process.env.CCDX_CLAUDE_DESKTOP_API_KEY
     || process.env.CCDX_PROXY_API_KEY
     || "";
-  const chatCompletionsFn = options.chatCompletionsFn || chatCompletions;
-  const responsesFn = options.responsesFn || copilotResponses;
-  const responsesCompactFn = options.responsesCompactFn || copilotResponsesCompact;
-  const listModelsFn = options.listModelsFn || listModels;
+  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
+    || 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);
@@ -102,13 +139,14 @@ export function createAdapterHandler(options = {}) {
   const requestMetrics = options.requestMetrics || createRequestMetrics();
   const streamPerformanceMetrics = options.streamPerformanceMetrics || createStreamPerformanceMetrics();
   const claudeDesktopModelOptions = () => {
-    const modelDefs = options.modelRegistry?.modelDefs || options.claudeDesktopModelDefs;
+    const modelDefs = claudeModelRegistry?.modelDefs || options.claudeDesktopModelDefs;
     return Array.isArray(modelDefs) ? { modelDefs } : {};
   };
   const responsesHandler = createResponsesHandler({
     acquireRequest,
     autoReviewModelResolver: options.autoReviewModelResolver,
-    chatCompletionsFn,
+    chatCompletionsFn: codexChatCompletionsFn,
+    getCachedModelEndpointsFn,
     openAIModelEnv,
     responsesPayloadOptions: options.responsesPayloadOptions,
     responsesFn,
@@ -128,13 +166,24 @@ export function createAdapterHandler(options = {}) {
   const anthropicCountTokensHandler = createAnthropicCountTokensHandler({ acquireRequest });
   const anthropicMessagesHandler = createAnthropicMessagesHandler({
     acquireRequest,
-    chatCompletionsFn,
+    chatCompletionsFn: claudeChatCompletionsFn,
     environment: process.env,
     modelOptions: claudeDesktopModelOptions,
     streamHandshakeTimeoutMs,
     streamIdleTimeoutMs,
     upstreamTimeoutMs,
   });
+  const pmStudioRelayHandler = createPmStudioRelayHandler({
+    acquireRequest,
+    claudeClient,
+    claudeMode,
+    claudeProfile: options.claudeProfile,
+    claudeModelRegistry,
+    fetchImpl: options.pmStudioFetchImpl,
+    streamHandshakeTimeoutMs,
+    streamIdleTimeoutMs,
+    upstreamTimeoutMs,
+  });
 
   const dispatch = (req, res, pathname) => {
     if (req.method === "GET" && pathname === ADAPTER_STATUS_PATH) {
@@ -148,7 +197,12 @@ export function createAdapterHandler(options = {}) {
         metrics: requestMetrics,
         streamPerformance: streamPerformanceMetrics,
         admission: acquireRequest,
-        modelRegistry: options.modelRegistry,
+        modelRegistry: codexModelRegistry,
+        codexClient,
+        claudeClient,
+        codexModelRegistry,
+        claudeModelRegistry,
+        claudeMode,
       })));
       return;
     }
@@ -159,6 +213,10 @@ 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);
     }
@@ -181,24 +239,24 @@ export function createAdapterHandler(options = {}) {
             let models;
             try { models = JSON.parse(body); } catch {}
             if (isValidModelList(models)) {
-              if (options.modelRegistry) {
-                options.modelRegistry.models = models;
+              if (codexModelRegistry) {
+                codexModelRegistry.models = models;
               }
               res.writeHead(status, { "Content-Type": "application/json" });
               res.end(body);
               return;
             }
-            if (sendLastKnownGoodModels(res, options.modelRegistry)) return;
+            if (sendLastKnownGoodModels(res, codexModelRegistry)) return;
             sendJsonError(res, httpError("Copilot models response contained no valid models", 502), 502);
             return;
           }
-          if (modelListCanUseLastKnownGood(status) && sendLastKnownGoodModels(res, options.modelRegistry)) return;
+          if (modelListCanUseLastKnownGood(status) && sendLastKnownGoodModels(res, codexModelRegistry)) return;
           res.writeHead(status, { "Content-Type": "application/json" });
           res.end(body);
         })
         .catch((e) => {
           logRequestFailure("Models", e, abort);
-          if (sendLastKnownGoodModels(res, options.modelRegistry)) return;
+          if (sendLastKnownGoodModels(res, codexModelRegistry)) return;
           if (!res.destroyed && !res.writableEnded) {
             if (!res.headersSent) res.writeHead(e?.statusCode || 502);
             res.end(JSON.stringify({ error: e.message }));