codex-copilot-dx 0.4.21 → 0.4.22

package/bin/cli.mjs

@@ -125,11 +125,20 @@ console.log(`
   Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot
 `);
 
-checkForUpdate({ currentVersion: LOCAL_VERSION }).then(({ latestVersion, updateAvailable }) => {
-  if (!updateAvailable) return;
-  console.log(`\n  ${status("warn", `Update available: ${LOCAL_VERSION} -> ${latestVersion}`)}`);
-  console.log("  npm install -g codex-copilot-dx@latest\n");
-});
+async function printUpdateNotice() {
+  try {
+    const { latestVersion, updateAvailable } = await checkForUpdate({ currentVersion: LOCAL_VERSION });
+    if (!updateAvailable) return;
+    console.log(`\n  ${status("warn", `Update available: ${LOCAL_VERSION} -> ${latestVersion}`)}`);
+    console.log("  npm install -g codex-copilot-dx@latest\n");
+  } catch {
+    // Never block startup on the update check.
+  }
+}
+
+// Await the update check up front so the notice is shown even on the
+// "reuse existing adapter" path, which exits early below.
+await printUpdateNotice();
 
 try {
   assertSafeAdapterHost(ADAPTER_HOST, process.env);
@@ -172,6 +181,16 @@ try {
   // Launch Codex when available.
   openCodex();
 
+  // Periodically refresh the model list + endpoint cache so a long-running
+  // adapter picks up newly released models without a restart.
+  const refreshIntervalMs = parseInt(process.env.CCDX_MODEL_REFRESH_INTERVAL_MS || String(30 * 60 * 1000), 10);
+  if (Number.isFinite(refreshIntervalMs) && refreshIntervalMs > 0) {
+    const timer = setInterval(() => {
+      refreshClaudeDesktopModelDefs().catch(() => {});
+    }, refreshIntervalMs);
+    if (typeof timer.unref === "function") timer.unref();
+  }
+
   console.log(`
   ${status("ok", "Ready, Claude Code, Claude App and Codex App are now ready to use")}
 

package/package.json

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

package/src/adapter.mjs

@@ -2,16 +2,20 @@ import http from "node:http";
 import { randomUUID } from "node:crypto";
 import { promisify } from "node:util";
 import * as zlib from "node:zlib";
-import { chatCompletions, listModels, responses as copilotResponses, responsesCompact as copilotResponsesCompact } from "./copilot.mjs";
+import { chatCompletions, listModels, responses as copilotResponses, responsesCompact as copilotResponsesCompact, getCachedModelEndpoints } from "./copilot.mjs";
 import { webStreamLines } from "./stream.mjs";
 import { anthropicToChat, chatToAnthropic, streamAnthropicFromLines, countTokens } from "./anthropic.mjs";
-import { claudeDesktopModelsResponse, resolveAnthropicModel } from "./models.mjs";
+import { claudeDesktopModelsResponse, resolveAnthropicModel, modelIsResponsesOnly, modelSupportsChatCompletions } from "./models.mjs";
 import { status } from "./status.mjs";
 import { recordAnthropicUsage, recordResponsesUsage } from "./usage.mjs";
 import { ADAPTER_HEALTH_PATH, adapterHealthPayload } from "./running-adapter.mjs";
 
-// Models that only support Responses API (not chat/completions)
-const RESPONSES_ONLY = new Set([
+// Fallback list for models known to only support the Responses API, used when
+// live model metadata (supported_endpoints) has not been cached yet.
+const RESPONSES_ONLY_FALLBACK = new Set([
+  "gpt-5.6-luna",
+  "gpt-5.6-sol",
+  "gpt-5.6-terra",
   "gpt-5.5",
   "gpt-5.4",
   "gpt-5.4-mini",
@@ -19,6 +23,18 @@ const RESPONSES_ONLY = new Set([
   "gpt-5.2-codex",
 ]);
 
+// Decide whether a model must be proxied straight to /responses (vs converted to
+// /chat/completions). Prefer real endpoint metadata; fall back to the static list.
+function isResponsesOnlyModel(model) {
+  const endpoints = getCachedModelEndpoints(model);
+  if (endpoints) {
+    const fakeModel = { supported_endpoints: endpoints };
+    if (modelSupportsChatCompletions(fakeModel)) return false;
+    if (modelIsResponsesOnly(fakeModel)) return true;
+  }
+  return RESPONSES_ONLY_FALLBACK.has(model);
+}
+
 // Direct Copilot Responses API proxy.
 
 const RESPONSE_HISTORY_LIMIT = 64;
@@ -324,6 +340,19 @@ export function clearResponseHistoryForTests() {
   responseHistories.clear();
 }
 
+// The GPT (gpt-5.6) Responses backend registers a built-in `image_gen` tool
+// namespace. When the client also sends an image generation tool, the upstream
+// rejects the request with "User-defined namespace 'image_gen' collides ...".
+// Strip any built-in image tool (matched by type/name/namespace) before proxying.
+function isBuiltinImageTool(tool) {
+  if (!tool || typeof tool !== "object") return false;
+  const candidates = [tool.type, tool.name, tool.namespace];
+  return candidates.some((v) => {
+    const s = String(v || "").toLowerCase();
+    return s === "image_gen" || s === "image_generation" || s.startsWith("image_gen");
+  });
+}
+
 export function prepareResponsesRequest(reqBody) {
   const body = cloneJson(reqBody);
   const currentInputItems = responsesInputItems(body.input);
@@ -344,7 +373,7 @@ export function prepareResponsesRequest(reqBody) {
   delete body.previous_response_id;
   delete body.store;
   if (Array.isArray(body.tools)) {
-    body.tools = body.tools.filter((tool) => tool?.type !== "image_generation");
+    body.tools = body.tools.filter((tool) => !isBuiltinImageTool(tool));
     if (!body.tools.length) delete body.tools;
   }
   stripInternalResponsesInputFields(body.input);
@@ -591,7 +620,7 @@ export function startAdapter(port = 2026, host = "127.0.0.1", options = {}) {
           prepared.surface = "responses";
           const model = parsed.model || "unknown";
           console.log(status("info", `responses model=${model} stream=${!!parsed.stream}`));
-          if (RESPONSES_ONLY.has(model)) {
+          if (isResponsesOnlyModel(model)) {
             await proxyCopilotResponses(prepared, req, res, copilotResponses, { signal: abort.signal });
           } else {
             const chatReq = responsesToChat(prepared.body);

package/src/copilot.mjs

@@ -7,6 +7,30 @@ import { githubReauthMessage, githubTokenPath, importDiscoveredGithubToken } fro
 
 export const DEFAULT_API_BASE = "https://api.githubcopilot.com";
 let apiBase = DEFAULT_API_BASE;
+
+// Cache of model id -> supported_endpoints, populated from listModels(). Used to
+// route requests to /responses vs /chat/completions based on real model metadata.
+const modelEndpointCache = new Map();
+
+export function cacheModelEndpoints(models) {
+  const data = Array.isArray(models) ? models : models?.data;
+  if (!Array.isArray(data)) return;
+  for (const model of data) {
+    const id = String(model?.id || "").trim();
+    if (id && Array.isArray(model?.supported_endpoints)) {
+      modelEndpointCache.set(id, model.supported_endpoints);
+    }
+  }
+}
+
+// Returns the cached supported_endpoints for a model id, or null if unknown.
+export function getCachedModelEndpoints(modelId) {
+  return modelEndpointCache.get(String(modelId || "").trim()) || null;
+}
+
+export function resetModelEndpointCacheForTests() {
+  modelEndpointCache.clear();
+}
 const IMG_MAX_DIM = parseInt(process.env.CCDX_IMG_MAX_DIM || "2048", 10);
 const IMG_QUALITY = parseInt(process.env.CCDX_IMG_QUALITY || "85", 10);
 const IMG_MIN_BYTES = parseInt(process.env.CCDX_IMG_MIN_BYTES || "100000", 10);
@@ -486,7 +510,11 @@ export async function listModels({ signal, fetchImpl, retryOptions } = {}) {
     token, version: getVSCodeVersion(), initiator: "user", vision: false,
   });
   const resp = await fetchCopilotUpstream(`${getApiBase()}/models`, { headers, signal }, { fetchImpl, ...retryOptions });
-  return { status: resp.status, body: await resp.text() };
+  const body = await resp.text();
+  if (resp.ok) {
+    try { cacheModelEndpoints(JSON.parse(body)); } catch {}
+  }
+  return { status: resp.status, body };
 }
 
 // Responses-only models go directly to Copilot's /responses endpoint.

package/src/models.mjs

@@ -102,6 +102,23 @@ function hasOpenAIEndpoint(model) {
   return endpoints.includes("/responses") || endpoints.includes("/v1/responses") || endpoints.includes("/chat/completions");
 }
 
+// Endpoint-based routing helpers. A model is "responses-only" when it exposes a
+// /responses endpoint but does NOT accept /chat/completions. These read the real
+// model metadata so new models (e.g. gpt-5.6-*) route correctly without a hardcoded list.
+export function modelEndpoints(model) {
+  return Array.isArray(model?.supported_endpoints) ? model.supported_endpoints : [];
+}
+
+export function modelSupportsChatCompletions(model) {
+  return modelEndpoints(model).includes("/chat/completions");
+}
+
+export function modelIsResponsesOnly(model) {
+  const endpoints = modelEndpoints(model);
+  const hasResponses = endpoints.includes("/responses") || endpoints.includes("/v1/responses");
+  return hasResponses && !endpoints.includes("/chat/completions");
+}
+
 function copilotModelData(models) {
   const data = Array.isArray(models) ? models : models?.data;
   return Array.isArray(data) ? data : [];