codex-copilot-dx 0.6.21 → 0.7.1

package/src/models.mjs

@@ -1,100 +1,6 @@
-const DEFAULT_CLAUDE_DESKTOP_MODEL_DEFS = [
-  {
-    id: "claude-sonnet-5",
-    upstream: "claude-sonnet-5",
-    displayName: "Claude Sonnet 5",
-    createdAt: "2026-06-30T00:00:00Z",
-    maxInputTokens: 1000000,
-    maxOutputTokens: 64000,
-  },
-  {
-    id: "claude-sonnet-4.6",
-    upstream: "claude-sonnet-4.6",
-    displayName: "Claude Sonnet 4.6",
-    createdAt: "2026-02-17T00:00:00Z",
-    maxInputTokens: 200000,
-    maxOutputTokens: 8192,
-  },
-  {
-    id: "claude-opus-4.8",
-    upstream: "claude-opus-4.8",
-    displayName: "Claude Opus 4.8",
-    createdAt: "2026-05-28T00:00:00Z",
-    maxInputTokens: 200000,
-    maxOutputTokens: 8192,
-  },
-  {
-    id: "claude-haiku-4.5",
-    upstream: "claude-haiku-4.5",
-    displayName: "Claude Haiku 4.5",
-    createdAt: "2025-10-01T00:00:00Z",
-    maxInputTokens: 200000,
-    maxOutputTokens: 8192,
-  },
-];
-
-const DEFAULT_CLAUDE_MODEL_ALIAS_DEFS = [
-  {
-    id: "claude-sonnet-4-6",
-    upstream: "claude-sonnet-4.6",
-    displayName: "Claude Sonnet 4.6",
-    createdAt: "2026-02-17T00:00:00Z",
-    maxInputTokens: 200000,
-    maxOutputTokens: 8192,
-  },
-  {
-    id: "claude-opus-4-8",
-    upstream: "claude-opus-4.8",
-    displayName: "Claude Opus 4.8",
-    createdAt: "2026-05-28T00:00:00Z",
-    maxInputTokens: 200000,
-    maxOutputTokens: 8192,
-  },
-  {
-    id: "claude-haiku-4-5",
-    upstream: "claude-haiku-4.5",
-    displayName: "Claude Haiku 4.5",
-    createdAt: "2025-10-01T00:00:00Z",
-    maxInputTokens: 200000,
-    maxOutputTokens: 8192,
-  },
-];
-
 export const CODEX_AUTO_REVIEW_MODEL = "codex-auto-review";
 export const DEFAULT_CODEX_AUTO_REVIEW_MODEL = "gpt-5.5";
 
-function cleanList(value) {
-  return String(value || "")
-    .split(",")
-    .map((item) => item.trim())
-    .filter(Boolean);
-}
-
-export function parseModelAliasEnv(value) {
-  const aliases = [];
-  for (const entry of cleanList(value)) {
-    const [id, upstream] = entry.split("=", 2).map((part) => part?.trim());
-    if (!id || !upstream) continue;
-    aliases.push({
-      id,
-      upstream,
-      displayName: id,
-      createdAt: "2025-01-01T00:00:00Z",
-      maxInputTokens: 200000,
-      maxOutputTokens: 8192,
-    });
-  }
-  return aliases;
-}
-
-function cloneModelDefs(modelDefs) {
-  return modelDefs.map((model) => ({ ...model }));
-}
-
-function numericLimit(value, fallback) {
-  return Number.isFinite(value) && value > 0 ? value : fallback;
-}
-
 function hasOpenAIEndpoint(model) {
   const endpoints = Array.isArray(model?.supported_endpoints) ? model.supported_endpoints : [];
   return endpoints.includes("/responses") || endpoints.includes("/v1/responses") || endpoints.includes("/chat/completions");
@@ -152,24 +58,6 @@ function uniqueIds(models, predicate) {
   return ids;
 }
 
-export function isClaudeCopilotCatalogEntry(model) {
-  const id = String(model?.id || "").trim();
-  const vendor = String(model?.vendor || model?.owned_by || "").trim().toLowerCase();
-  return Boolean(id) && (id.toLowerCase().startsWith("claude-") || vendor === "anthropic");
-}
-
-export function isClaudeCopilotModel(model) {
-  const policy = String(model?.policy?.state || "").trim().toLowerCase();
-  const declaredOwners = [model?.vendor, model?.owned_by]
-    .map((value) => String(value || "").trim().toLowerCase())
-    .filter(Boolean);
-  return isClaudeCopilotCatalogEntry(model)
-    && declaredOwners.every((owner) => owner === "anthropic")
-    && model?.model_picker_enabled !== false
-    && (!policy || policy === "enabled")
-    && modelSupportsChatCompletions(model);
-}
-
 export function gptModelIdsFromCopilotModels(models) {
   return uniqueIds(copilotModelData(models), (model) => {
     const id = String(model?.id || "").trim();
@@ -190,60 +78,6 @@ export function responsesModelIdsFromCopilotModels(models) {
   });
 }
 
-export function claudeDesktopModelDefsFromCopilotModels(models) {
-  const data = copilotModelData(models);
-
-  const defs = [];
-  const seen = new Set();
-  for (const model of data) {
-    if (!isClaudeCopilotModel(model)) continue;
-    const id = String(model.id || "").trim();
-    if (seen.has(id)) continue;
-    seen.add(id);
-
-    const limits = model.capabilities?.limits || {};
-    defs.push({
-      id,
-      upstream: id,
-      displayName: String(model.name || id),
-      createdAt: "2025-01-01T00:00:00Z",
-      maxInputTokens: numericLimit(limits.max_context_window_tokens, numericLimit(limits.max_prompt_tokens, 200000)),
-      maxOutputTokens: numericLimit(limits.max_output_tokens, 8192),
-    });
-  }
-
-  return defs;
-}
-
-export function claudeDesktopModelDefs(env = process.env, options = {}) {
-  const custom = parseModelAliasEnv(env.CCDX_CLAUDE_MODEL_ALIASES);
-  if (custom.length) return custom;
-  if (Array.isArray(options.modelDefs) && options.modelDefs.length) return cloneModelDefs(options.modelDefs);
-  return cloneModelDefs(DEFAULT_CLAUDE_DESKTOP_MODEL_DEFS);
-}
-
-export function claudeDesktopModelIds(env = process.env, options = {}) {
-  return claudeDesktopModelDefs(env, options).map((model) => model.id);
-}
-
-function claudeModelResolutionDefs(env = process.env, options = {}) {
-  const defs = claudeDesktopModelDefs(env, options);
-  if (parseModelAliasEnv(env.CCDX_CLAUDE_MODEL_ALIASES).length) return defs;
-
-  const upstreamIds = new Set(defs.map((model) => model.upstream));
-  const aliases = DEFAULT_CLAUDE_MODEL_ALIAS_DEFS.filter((alias) => upstreamIds.has(alias.upstream));
-  return [...defs, ...aliases];
-}
-
-export function resolveAnthropicModel(model, env = process.env, options = {}) {
-  const requestedModel = String(model || "");
-  const match = claudeModelResolutionDefs(env, options).find((entry) => entry.id === requestedModel);
-  return {
-    requestedModel,
-    upstreamModel: match?.upstream || requestedModel,
-  };
-}
-
 export function resolveOpenAIModel(model, env = process.env, options = {}) {
   const requestedModel = String(model || "");
   if (requestedModel !== CODEX_AUTO_REVIEW_MODEL) {
@@ -269,21 +103,3 @@ export function codexAutoReviewModelStatus(models, env = process.env, options =
     reason: available ? "" : "model does not advertise a Responses endpoint",
   };
 }
-
-export function anthropicModelInfo(model) {
-  return {
-    id: model.id,
-    type: "model",
-    display_name: model.displayName || model.id,
-    created_at: model.createdAt || "2025-01-01T00:00:00Z",
-    max_input_tokens: model.maxInputTokens || 200000,
-    max_tokens: model.maxOutputTokens || 8192,
-  };
-}
-
-export function claudeDesktopModelsResponse(env = process.env, options = {}) {
-  return {
-    object: "list",
-    data: claudeDesktopModelDefs(env, options).map(anthropicModelInfo),
-  };
-}

package/src/observability.mjs

@@ -13,10 +13,6 @@ const ROUTE_NAMES = Object.freeze([
   "responses",
   "responses_compact",
   "models",
-  "messages",
-  "messages_count_tokens",
-  "pm_models",
-  "pm_chat_completions",
   "not_found",
 ]);
 
@@ -98,10 +94,6 @@ export function classifyAdapterRoute(method, pathname) {
   if (method === "POST" && pathname === "/v1/responses") return "responses";
   if (method === "POST" && pathname === "/v1/responses/compact") return "responses_compact";
   if (method === "GET" && pathname === "/v1/models") return "models";
-  if (method === "POST" && pathname === "/v1/messages") return "messages";
-  if (method === "POST" && pathname === "/v1/messages/count_tokens") return "messages_count_tokens";
-  if (method === "GET" && pathname === "/pm-ccdx/models") return "pm_models";
-  if (method === "POST" && pathname === "/pm-ccdx/chat/completions") return "pm_chat_completions";
   return "not_found";
 }
 
@@ -119,7 +111,6 @@ function modelRegistryStatus(modelRegistry) {
   const result = {
     source: String(modelRegistry?.source || "built-in"),
     models: Array.isArray(modelData) ? modelData.length : 0,
-    claude_models: Array.isArray(modelRegistry?.modelDefs) ? modelRegistry.modelDefs.length : 0,
   };
   if (typeof modelRegistry?.cacheState === "string") {
     const savedAtMs = Number(modelRegistry.cacheSavedAtMs);
@@ -158,15 +149,6 @@ function safeClientRuntimeStatus(client) {
   };
 }
 
-function safeProfileCurrent(checkProfileCurrent) {
-  if (typeof checkProfileCurrent !== "function") return false;
-  try {
-    return checkProfileCurrent() === true;
-  } catch {
-    return false;
-  }
-}
-
 export function runtimeStatusPayload({
   metrics,
   streamPerformance,
@@ -174,24 +156,11 @@ export function runtimeStatusPayload({
   imagePressure,
   modelRegistry,
   codexClient,
-  claudeClient,
   codexModelRegistry,
-  claudeModelRegistry,
-  claudeMode = "inherited",
-  isClaudeProfileCurrent,
 } = {}) {
   const memory = process.memoryUsage();
-  const resolvedClaudeMode = claudeMode === "isolated" ? "isolated" : "inherited";
   const codexRuntime = safeClientRuntimeStatus(codexClient);
   const codexModels = modelRegistryStatus(codexModelRegistry || modelRegistry);
-  const claudeRuntime = resolvedClaudeMode === "isolated"
-    ? safeClientRuntimeStatus(claudeClient)
-    : codexRuntime;
-  const claudeModels = resolvedClaudeMode === "isolated"
-    ? modelRegistryStatus(claudeModelRegistry)
-    : codexModels;
-  const claudeProfileCurrent = resolvedClaudeMode === "isolated"
-    && safeProfileCurrent(isClaudeProfileCurrent);
   return {
     ...adapterHealthPayload(),
     uptime_ms: Math.round(process.uptime() * 1000),
@@ -212,14 +181,8 @@ export function runtimeStatusPayload({
     models: codexModels,
     profiles: {
       codex: { mode: "legacy", client: codexRuntime, models: codexModels },
-      claude: {
-        mode: resolvedClaudeMode,
-        profile_current: claudeProfileCurrent,
-        client: claudeRuntime,
-        models: claudeModels,
-      },
     },
-    routing: profileRouting({ claudeMode: resolvedClaudeMode }),
+    routing: profileRouting(),
     limits: {
       max_body_bytes: OBSERVABILITY_RUNTIME_CONFIG.maxBodyBytes,
       max_decoded_body_bytes: OBSERVABILITY_RUNTIME_CONFIG.maxDecodedBodyBytes,

package/src/profile-model-runtime.mjs

@@ -4,10 +4,8 @@ import {
   saveModelCache,
 } from "./model-cache.mjs";
 import {
-  claudeDesktopModelDefsFromCopilotModels,
   codexAutoReviewModelStatus,
   gptModelIdsFromCopilotModels,
-  parseModelAliasEnv,
 } from "./models.mjs";
 import { initializeModelRegistry } from "./startup.mjs";
 import { status } from "./status.mjs";
@@ -36,7 +34,6 @@ function parsedCatalog(result) {
 
 function createModelRegistry() {
   return {
-    modelDefs: undefined,
     models: undefined,
     source: "built-in",
     cacheState: "none",
@@ -48,12 +45,6 @@ function createModelRegistry() {
   };
 }
 
-function sameModelDefs(left, right) {
-  if (left === right) return true;
-  if (!Array.isArray(left) || !Array.isArray(right)) return false;
-  return JSON.stringify(left) === JSON.stringify(right);
-}
-
 function safeRefreshError(error, { timedOut = false, timeoutMs } = {}) {
   if (timedOut) return `Model refresh timed out after ${timeoutMs}ms`;
   const raw = String(error?.message || error?.name || "Model refresh failed")
@@ -66,97 +57,63 @@ function safeRefreshError(error, { timedOut = false, timeoutMs } = {}) {
 
 export function createProfileModelRuntime({
   codexClient,
-  claudeClient = codexClient,
-  claudeMode = "inherited",
   codexCredentialFingerprint = "",
-  claudeCredentialFingerprint = "",
   home,
   env = process.env,
   timeoutMs = DEFAULT_TIMEOUT_MS,
   log = defaultLog,
-  onClaudeModelsChanged = () => {},
   autoReviewModelResolver = () => undefined,
   commandName = "ccdx",
 } = {}) {
   if (!codexClient) throw new Error("codexClient is required");
-  if (claudeMode !== "inherited" && claudeMode !== "isolated") {
-    throw new Error(`Unsupported Claude model mode: ${claudeMode}`);
-  }
-  if (claudeMode === "isolated" && claudeClient === codexClient) {
-    throw new Error("Isolated Claude models require an isolated Claude client");
-  }
 
   const codexRegistry = createModelRegistry();
-  const claudeRegistry = claudeMode === "inherited"
-    ? codexRegistry
-    : createModelRegistry();
-  const customClaudeDefs = parseModelAliasEnv(env.CCDX_CLAUDE_MODEL_ALIASES);
-  const refreshFlights = new Map();
-  const refreshGenerations = new Map();
   const refreshTimeoutMs = Number.isFinite(timeoutMs) && timeoutMs > 0
     ? timeoutMs
     : DEFAULT_TIMEOUT_MS;
+  let refreshFlight = null;
+  let refreshGeneration = 0;
 
   function emit(kind, message) {
     if (typeof log === "function") log(kind, message);
   }
 
-  function notifyClaudeModels(modelDefs) {
-    if (!Array.isArray(modelDefs) || !modelDefs.length) return;
-    try {
-      const pending = onClaudeModelsChanged(modelDefs);
-      pending?.catch?.((error) => emit("warn", `Could not apply refreshed Claude models (${error.message})`));
-    } catch (error) {
-      emit("warn", `Could not apply refreshed Claude models (${error.message})`);
-    }
-  }
-
-  function applyCatalog({ client, models, registry, source, ownsClaudeModels }) {
+  function applyCatalog(models, source) {
     if (!isValidModelList(models)) throw new Error("Copilot models response contained no valid models");
-    client.cacheModelEndpoints(models);
-    registry.models = models;
-    registry.source = source;
-
-    if (!ownsClaudeModels) return registry.modelDefs;
-    const discovered = customClaudeDefs.length
-      ? customClaudeDefs.map((model) => ({ ...model }))
-      : claudeDesktopModelDefsFromCopilotModels(models);
-    if (discovered.length) {
-      const changed = !sameModelDefs(registry.modelDefs, discovered);
-      registry.modelDefs = discovered;
-      if (changed) notifyClaudeModels(discovered);
-    }
-    return registry.modelDefs;
+    codexClient.cacheModelEndpoints(models);
+    codexRegistry.models = models;
+    codexRegistry.source = source;
+    return models;
   }
 
-  function loadCached({ client, profile, registry, ownsClaudeModels }) {
-    const credentialFingerprint = profile === "claude"
-      ? String(claudeCredentialFingerprint || "").trim()
-      : String(codexCredentialFingerprint || "").trim();
-    if (profile === "claude" && !credentialFingerprint) return false;
-    const cached = loadModelCacheEntry({ home, profile, credentialFingerprint });
+  function loadCached() {
+    const cached = loadModelCacheEntry({
+      home,
+      profile: "codex",
+      credentialFingerprint: String(codexCredentialFingerprint || "").trim(),
+    });
     if (!cached) return false;
     try {
-      applyCatalog({ client, models: cached.models, registry, source: "cache", ownsClaudeModels });
-      registry.cacheState = cached.state;
-      registry.cacheSavedAtMs = cached.savedAtMs;
+      applyCatalog(cached.models, "cache");
+      codexRegistry.cacheState = cached.state;
+      codexRegistry.cacheSavedAtMs = cached.savedAtMs;
       return { loaded: true, stale: cached.state === "stale" };
     } catch {
       return false;
     }
   }
 
-  async function requestCatalog(client) {
+  async function requestCatalog() {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), refreshTimeoutMs);
     try {
-      return parsedCatalog(await client.listModels({ signal: controller.signal }));
+      return parsedCatalog(await codexClient.listModels({ signal: controller.signal }));
     } finally {
       clearTimeout(timer);
     }
   }
 
-  function checkCodexCatalog(models) {
+  function checkCatalog(models) {
     const autoReview = codexAutoReviewModelStatus(models, env, {
       autoReviewModel: autoReviewModelResolver(),
     });
@@ -171,166 +128,81 @@ export function createProfileModelRuntime({
     }
   }
 
-  function persist(models, profile, registry, generation) {
-    const credentialFingerprint = profile === "claude"
-      ? String(claudeCredentialFingerprint || "").trim()
-      : String(codexCredentialFingerprint || "").trim();
-    if (profile === "claude" && !credentialFingerprint) return;
+  function persist(models, generation) {
     try {
       const saved = saveModelCache(models, {
         home,
-        profile,
-        credentialFingerprint,
-        isCurrent: () => refreshGenerations.get(profile) === generation,
+        profile: "codex",
+        credentialFingerprint: String(codexCredentialFingerprint || "").trim(),
+        isCurrent: () => refreshGeneration === generation,
       });
       if (saved) {
-        registry.cacheState = "fresh";
-        registry.cacheSavedAtMs = Date.now();
+        codexRegistry.cacheState = "fresh";
+        codexRegistry.cacheSavedAtMs = Date.now();
       }
     } catch (error) {
-      const label = profile === "codex" ? "Copilot" : "Claude Copilot";
-      emit("warn", `Could not persist the ${label} model cache (${error.message})`);
-    }
-  }
-
-  function logClaudeCatalog(modelDefs) {
-    if (customClaudeDefs.length) {
-      emit("info", "Using CCDX_CLAUDE_MODEL_ALIASES for Claude models");
-    } else if (modelDefs?.length) {
-      emit("ok", `Refreshed Claude models from GitHub Copilot: ${modelDefs.map((model) => model.id).join(", ")}`);
-    } else {
-      emit("warn", "Copilot models response contained no Claude models; using built-in Claude models");
-    }
-  }
-
-  function fallbackLabel(registry, profile) {
-    if (claudeMode === "inherited") {
-      return registry.modelDefs?.length ? `${registry.source} model list` : "built-in model list";
+      emit("warn", `Could not persist the Copilot model cache (${error.message})`);
     }
-    if (isValidModelList(registry.models)) return `${registry.source} model list`;
-    return profile === "claude" ? "built-in model list" : "no cached model list";
   }
 
-  async function performRefresh({ client, profile, registry, ownsClaudeModels, checksCodex }, generation) {
-    const controllerLabel = claudeMode === "inherited"
-      ? ""
-      : `${profile === "codex" ? "Codex" : "Claude"} `;
+  async function performRefresh(generation) {
     try {
-      const models = await requestCatalog(client);
-      if (refreshGenerations.get(profile) !== generation) return registry.modelDefs;
-      if (checksCodex) checkCodexCatalog(models);
-      const modelDefs = applyCatalog({
-        client,
-        models,
-        registry,
-        source: "live",
-        ownsClaudeModels,
-      });
-      persist(models, profile, registry, generation);
-      registry.lastError = null;
-      registry.lastErrorAtMs = null;
-      if (ownsClaudeModels) logClaudeCatalog(modelDefs);
-      return modelDefs;
+      const models = await requestCatalog();
+      if (refreshGeneration !== generation) return codexRegistry.models;
+      checkCatalog(models);
+      applyCatalog(models, "live");
+      persist(models, generation);
+      codexRegistry.lastError = null;
+      codexRegistry.lastErrorAtMs = null;
+      return models;
     } catch (error) {
-      if (refreshGenerations.get(profile) !== generation) return registry.modelDefs;
-      const fallback = fallbackLabel(registry, profile);
+      if (refreshGeneration !== generation) return codexRegistry.models;
       const timedOut = error?.name === "AbortError" || error?.code === "ABORT_ERR";
       const diagnostic = safeRefreshError(error, { timedOut, timeoutMs: refreshTimeoutMs });
-      registry.lastError = diagnostic;
-      registry.lastErrorAtMs = Date.now();
-      const message = timedOut
-        ? `${controllerLabel}model refresh timed out after ${refreshTimeoutMs}ms; using ${fallback}`
-        : `Could not refresh ${controllerLabel.toLowerCase()}model list; using ${fallback} (${diagnostic})`;
-      emit("warn", message[0].toUpperCase() + message.slice(1));
-      return registry.modelDefs;
+      codexRegistry.lastError = diagnostic;
+      codexRegistry.lastErrorAtMs = Date.now();
+      const fallback = isValidModelList(codexRegistry.models)
+        ? `${codexRegistry.source} model list`
+        : "no cached model list";
+      emit("warn", timedOut
+        ? `Model refresh timed out after ${refreshTimeoutMs}ms; using ${fallback}`
+        : `Could not refresh model list; using ${fallback} (${diagnostic})`);
+      return codexRegistry.models;
     }
   }
 
-  function refreshProfile(options) {
-    const { profile, registry } = options;
-    const existing = refreshFlights.get(profile);
-    if (existing) return existing.promise;
-
-    const generation = (refreshGenerations.get(profile) || 0) + 1;
-    refreshGenerations.set(profile, generation);
-    registry.generation = generation;
-    registry.refreshInFlight = true;
-    const flight = { generation, promise: null };
-    refreshFlights.set(profile, flight);
-    flight.promise = performRefresh(options, generation).finally(() => {
-      if (refreshFlights.get(profile) === flight) refreshFlights.delete(profile);
-      if (refreshGenerations.get(profile) === generation) registry.refreshInFlight = false;
-    });
-    return flight.promise;
-  }
-
   function refreshCodex() {
-    return refreshProfile({
-      client: codexClient,
-      profile: "codex",
-      registry: codexRegistry,
-      ownsClaudeModels: claudeMode === "inherited",
-      checksCodex: true,
-    });
-  }
-
-  function refreshClaude() {
-    if (claudeMode === "inherited") return refreshCodex();
-    return refreshProfile({
-      client: claudeClient,
-      profile: "claude",
-      registry: claudeRegistry,
-      ownsClaudeModels: true,
-      checksCodex: false,
-    });
-  }
-
-  function initializeProfile({ client, profile, registry, ownsClaudeModels, refresh }) {
-    return initializeModelRegistry({
-      loadCached: () => loadCached({ client, profile, registry, ownsClaudeModels }),
-      currentModelDefs: () => registry.modelDefs,
-      refresh,
+    if (refreshFlight) return refreshFlight;
+    const generation = refreshGeneration + 1;
+    refreshGeneration = generation;
+    codexRegistry.generation = generation;
+    codexRegistry.refreshInFlight = true;
+    const flight = performRefresh(generation).finally(() => {
+      if (refreshFlight === flight) refreshFlight = null;
+      if (refreshGeneration === generation) codexRegistry.refreshInFlight = false;
     });
+    refreshFlight = flight;
+    return flight;
   }
 
   async function initialize() {
-    const codexInitialization = initializeProfile({
-      client: codexClient,
-      profile: "codex",
-      registry: codexRegistry,
-      ownsClaudeModels: claudeMode === "inherited",
+    const initialized = await initializeModelRegistry({
+      loadCached,
+      currentModelDefs: () => codexRegistry.models,
       refresh: refreshCodex,
     });
-    if (claudeMode === "inherited") {
-      const shared = await codexInitialization;
-      return { codex: shared, claude: shared };
-    }
-    const claudeInitialization = initializeProfile({
-      client: claudeClient,
-      profile: "claude",
-      registry: claudeRegistry,
-      ownsClaudeModels: true,
-      refresh: refreshClaude,
-    });
-    const [codex, claude] = await Promise.all([codexInitialization, claudeInitialization]);
-    return { codex, claude };
+    const { modelDefs: models, ...state } = initialized;
+    return { codex: { ...state, models } };
   }
 
   async function refreshAll() {
-    if (claudeMode === "inherited") {
-      const shared = await refreshCodex();
-      return { codex: shared, claude: shared };
-    }
-    const [codex, claude] = await Promise.all([refreshCodex(), refreshClaude()]);
-    return { codex, claude };
+    return { codex: await refreshCodex() };
   }
 
   return {
     codexRegistry,
-    claudeRegistry,
     initialize,
     refreshAll,
     refreshCodex,
-    refreshClaude,
   };
 }