codex-copilot-dx 0.4.10 → 0.4.12

package/bin/cli.mjs

@@ -5,7 +5,8 @@ import { ensureCodexConfig } from "../src/config.mjs";
 import { ensureClaudeConfig } from "../src/claude-config.mjs";
 import { applyClaudeDesktopConfig, formatClaudeDesktopApplyResult, generatedClaudeDesktopApiKey } from "../src/claude-desktop-config.mjs";
 import { startAdapter } from "../src/adapter.mjs";
-import { refreshVSCodeVersion } from "../src/copilot.mjs";
+import { listModels, refreshVSCodeVersion } from "../src/copilot.mjs";
+import { claudeDesktopModelDefsFromCopilotModels, claudeDesktopModelIds, parseModelAliasEnv } from "../src/models.mjs";
 import { status } from "../src/status.mjs";
 import { printUsageSummary } from "../src/usage.mjs";
 import { checkForUpdate, localPackageVersion } from "../src/version.mjs";
@@ -13,6 +14,7 @@ import { runDoctor } from "../src/doctor.mjs";
 
 const ADAPTER_PORT = parseInt(process.env.ADAPTER_PORT || "2026");
 const ADAPTER_HOST = process.env.ADAPTER_HOST || "127.0.0.1";
+const MODEL_REFRESH_TIMEOUT_MS = parseInt(process.env.CCDX_MODEL_REFRESH_TIMEOUT_MS || "5000", 10);
 const LOCAL_VERSION = localPackageVersion();
 const command = process.argv[2];
 const CONFIGURE_CLAUDE_DESKTOP = command === "--configure-claude-desktop" || process.env.CCDX_CONFIGURE_CLAUDE_DESKTOP === "1";
@@ -21,6 +23,31 @@ function isLoopbackHost(host) {
   return ["127.0.0.1", "localhost", "::1"].includes(String(host).toLowerCase());
 }
 
+async function refreshClaudeDesktopModelDefs() {
+  if (parseModelAliasEnv(process.env.CCDX_CLAUDE_MODEL_ALIASES).length) {
+    console.log(status("info", "Using CCDX_CLAUDE_MODEL_ALIASES for Claude models"));
+    return undefined;
+  }
+
+  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 modelDefs = claudeDesktopModelDefsFromCopilotModels(JSON.parse(body));
+    if (!modelDefs.length) throw new Error("Copilot models response contained no Claude models");
+    console.log(status("ok", `Refreshed Claude models from GitHub Copilot: ${modelDefs.map((model) => model.id).join(", ")}`));
+    return modelDefs;
+  } catch (e) {
+    console.log(status("warn", `Could not refresh Claude models; using built-in model list (${e.message})`));
+    return undefined;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 if (command === "--version" || command === "-v" || command === "version") {
   console.log(`codex-copilot-dx v${LOCAL_VERSION}`);
   process.exit(0);
@@ -53,6 +80,7 @@ try {
 
   // Refresh the VS Code version in the background; fallback is non-blocking.
   refreshVSCodeVersion();
+  const claudeDesktopModelDefs = await refreshClaudeDesktopModelDefs();
 
   if (!isLoopbackHost(ADAPTER_HOST)) {
     console.log(status("warn", `ADAPTER_HOST=${ADAPTER_HOST} exposes the adapter beyond loopback. Use only on trusted networks.`));
@@ -63,7 +91,7 @@ try {
     : (process.env.CCDX_CLAUDE_DESKTOP_API_KEY || process.env.CCDX_PROXY_API_KEY || "");
 
   // Start the in-process adapter.
-  await startAdapter(ADAPTER_PORT, ADAPTER_HOST, { claudeDesktopApiKey });
+  await startAdapter(ADAPTER_PORT, ADAPTER_HOST, { claudeDesktopApiKey, claudeDesktopModelDefs });
 
   // Point Codex and Claude Code at the adapter.
   ensureCodexConfig(ADAPTER_PORT);
@@ -73,6 +101,7 @@ try {
       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));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.4.10",
+  "version": "0.4.12",
   "description": "Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot",
   "type": "module",
   "bin": {

package/src/adapter.mjs

@@ -228,6 +228,17 @@ function responsesInputItems(input) {
   return Array.isArray(input) ? cloneJson(input) : [cloneJson(input)];
 }
 
+export function stripInternalResponsesInputFields(inputItems) {
+  if (!Array.isArray(inputItems)) return inputItems;
+  for (const item of inputItems) {
+    if (!item || typeof item !== "object") continue;
+    for (const key of Object.keys(item)) {
+      if (key.startsWith("internal_")) delete item[key];
+    }
+  }
+  return inputItems;
+}
+
 function responsesOutputItems(output) {
   if (!Array.isArray(output)) return [];
   return cloneJson(output.filter((item) => item?.type === "message" || item?.type === "function_call"));
@@ -335,6 +346,7 @@ export function prepareResponsesRequest(reqBody) {
     body.tools = body.tools.filter((tool) => tool?.type !== "image_generation");
     if (!body.tools.length) delete body.tools;
   }
+  stripInternalResponsesInputFields(body.input);
 
   return { body, inputItems: body.input };
 }
@@ -555,6 +567,9 @@ export function startAdapter(port = 2026, host = "127.0.0.1", options = {}) {
     || process.env.CCDX_CLAUDE_DESKTOP_API_KEY
     || process.env.CCDX_PROXY_API_KEY
     || "";
+  const claudeDesktopModelOptions = Array.isArray(options.claudeDesktopModelDefs)
+    ? { modelDefs: options.claudeDesktopModelDefs }
+    : {};
 
   const server = http.createServer((req, res) => {
     const pathname = requestPath(req.url);
@@ -636,7 +651,7 @@ export function startAdapter(port = 2026, host = "127.0.0.1", options = {}) {
     if (req.method === "GET" && pathname === "/v1/models") {
       if (shouldServeClaudeDesktopModels(req, claudeDesktopApiKey)) {
         res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify(claudeDesktopModelsResponse()));
+        res.end(JSON.stringify(claudeDesktopModelsResponse(process.env, claudeDesktopModelOptions)));
         return;
       }
       const abort = createRequestAbort(req, res);
@@ -676,7 +691,7 @@ export function startAdapter(port = 2026, host = "127.0.0.1", options = {}) {
         try {
           const parsed = await readJsonBody(req);
           if (!parsed.stream) abort.setTimeout(UPSTREAM_TIMEOUT_MS);
-          const { requestedModel, upstreamModel } = resolveAnthropicModel(parsed.model || "unknown");
+          const { requestedModel, upstreamModel } = resolveAnthropicModel(parsed.model || "unknown", process.env, claudeDesktopModelOptions);
           const modelNote = upstreamModel === requestedModel ? requestedModel : `${requestedModel} -> ${upstreamModel}`;
           console.log(status("info", `messages model=${modelNote} stream=${!!parsed.stream}`));
           const chatReq = anthropicToChat(parsed, { upstreamModel });

package/src/models.mjs

@@ -1,4 +1,12 @@
 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",
@@ -73,18 +81,81 @@ export function parseModelAliasEnv(value) {
   return aliases;
 }
 
-export function claudeDesktopModelDefs(env = process.env) {
+function cloneModelDefs(modelDefs) {
+  return modelDefs.map((model) => ({ ...model }));
+}
+
+function numericLimit(value, fallback) {
+  return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+
+function hasMessagesEndpoint(model) {
+  const endpoints = Array.isArray(model?.supported_endpoints) ? model.supported_endpoints : [];
+  return endpoints.includes("/v1/messages") || endpoints.includes("/chat/completions");
+}
+
+function isClaudeCopilotModel(model) {
+  const id = String(model?.id || "").trim();
+  const vendor = String(model?.vendor || "").toLowerCase();
+  return id
+    && (id.startsWith("claude-") || vendor === "anthropic")
+    && model?.model_picker_enabled !== false
+    && hasMessagesEndpoint(model);
+}
+
+export function claudeDesktopModelDefsFromCopilotModels(models) {
+  const data = Array.isArray(models) ? models : models?.data;
+  if (!Array.isArray(data)) return [];
+
+  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),
+    });
+  }
+
+  const upstreamIds = new Set(defs.map((model) => model.upstream));
+  for (const alias of DEFAULT_CLAUDE_DESKTOP_MODEL_DEFS) {
+    if (alias.id === alias.upstream || seen.has(alias.id) || !upstreamIds.has(alias.upstream)) continue;
+    const upstream = defs.find((model) => model.upstream === alias.upstream);
+    defs.push({
+      ...alias,
+      displayName: upstream?.displayName || alias.displayName,
+      maxInputTokens: upstream?.maxInputTokens || alias.maxInputTokens,
+      maxOutputTokens: upstream?.maxOutputTokens || alias.maxOutputTokens,
+    });
+    seen.add(alias.id);
+  }
+
+  return defs;
+}
+
+export function claudeDesktopModelDefs(env = process.env, options = {}) {
   const custom = parseModelAliasEnv(env.CCDX_CLAUDE_MODEL_ALIASES);
-  return custom.length ? custom : DEFAULT_CLAUDE_DESKTOP_MODEL_DEFS.map((model) => ({ ...model }));
+  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) {
-  return claudeDesktopModelDefs(env).map((model) => model.id);
+export function claudeDesktopModelIds(env = process.env, options = {}) {
+  return claudeDesktopModelDefs(env, options).map((model) => model.id);
 }
 
-export function resolveAnthropicModel(model, env = process.env) {
+export function resolveAnthropicModel(model, env = process.env, options = {}) {
   const requestedModel = String(model || "");
-  const match = claudeDesktopModelDefs(env).find((entry) => entry.id === requestedModel);
+  const match = claudeDesktopModelDefs(env, options).find((entry) => entry.id === requestedModel);
   return {
     requestedModel,
     upstreamModel: match?.upstream || requestedModel,
@@ -102,9 +173,9 @@ export function anthropicModelInfo(model) {
   };
 }
 
-export function claudeDesktopModelsResponse(env = process.env) {
+export function claudeDesktopModelsResponse(env = process.env, options = {}) {
   return {
     object: "list",
-    data: claudeDesktopModelDefs(env).map(anthropicModelInfo),
+    data: claudeDesktopModelDefs(env, options).map(anthropicModelInfo),
   };
 }