codex-copilot-dx 0.4.21 → 0.4.23

package/bin/cli.mjs

@@ -96,7 +96,7 @@ async function reuseRunningAdapterIfAvailable() {
     console.log(status("ok", "Claude App support available with --configure-claude-desktop"));
   }
 
-  openCodex();
+  await openCodex();
   console.log(`
   ${status("ok", "Ready, using the existing codex-copilot-dx adapter")}
 
@@ -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);
@@ -170,7 +179,17 @@ try {
   }
 
   // Launch Codex when available.
-  openCodex();
+  await 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.23",
   "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/launcher.mjs

@@ -3,17 +3,62 @@ import { status } from "./status.mjs";
 
 export { ensureAuth } from "./auth.mjs";
 
-export function openCodex() {
-  if (process.platform === "darwin") {
+// The Codex desktop app was folded into the ChatGPT app, but it keeps the
+// original bundle identifier. Launching by bundle id works for both the old
+// Codex.app and the new ChatGPT.app regardless of where they are installed.
+const CODEX_BUNDLE_ID = "com.openai.codex";
+const APP_PATH_CANDIDATES = [
+  "/Applications/Codex.app",
+  "/Applications/ChatGPT.app",
+];
+
+export function autoLaunchEnabled(env = process.env) {
+  const raw = env.CCDX_AUTO_LAUNCH;
+  if (raw === undefined || raw === "") return true;
+  return !/^(0|false|no|off)$/i.test(String(raw).trim());
+}
+
+// Run `open` and resolve to true only when it exits successfully.
+function tryOpen(args, { spawnImpl = spawn } = {}) {
+  return new Promise((resolve) => {
+    let child;
     try {
-      spawn("open", ["/Applications/Codex.app"], { detached: true, stdio: "ignore" });
-      console.log(status("ok", "Codex app launched"));
+      child = spawnImpl("open", args, { stdio: "ignore" });
     } catch {
-      console.log(status("warn", "Codex app not found at /Applications/Codex.app"));
-      console.log(status("info", "Download Codex from https://openai.com/codex"));
+      resolve(false);
+      return;
     }
-  } else {
-    console.log(status("warn", "Auto-launch is not supported on this platform"));
-    console.log(status("info", "Open Codex manually; it will connect to the adapter."));
+    child.on("error", () => resolve(false));
+    child.on("exit", (code) => resolve(code === 0));
+  });
+}
+
+// Build the ordered list of launch attempts: bundle id first, then paths.
+export function launchAttempts() {
+  return [["-b", CODEX_BUNDLE_ID], ...APP_PATH_CANDIDATES.map((path) => [path])];
+}
+
+export async function openCodex({ env = process.env, spawnImpl = spawn, platform = process.platform } = {}) {
+  if (platform !== "darwin") {
+    console.log(status("warn", "Auto-launch is only supported on macOS"));
+    console.log(status("info", "Open Codex or the ChatGPT app manually; it will connect to the adapter."));
+    return false;
   }
+
+  if (!autoLaunchEnabled(env)) {
+    console.log(status("info", "Auto-launch disabled (CCDX_AUTO_LAUNCH=0); open Codex or the ChatGPT app manually."));
+    return false;
+  }
+
+  for (const args of launchAttempts()) {
+    if (await tryOpen(args, { spawnImpl })) {
+      console.log(status("ok", "Codex app launched"));
+      return true;
+    }
+  }
+
+  console.log(status("warn", "Could not launch the Codex app (checked com.openai.codex, Codex.app, ChatGPT.app)"));
+  console.log(status("info", "Open Codex or the ChatGPT app manually; it will connect to the adapter."));
+  console.log(status("info", "Download it from https://openai.com/codex"));
+  return false;
 }

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 : [];