codex-copilot-dx 0.4.20 → 0.4.22

package/README.md

@@ -93,8 +93,8 @@ Environment variables:
 | `CCDX_UPSTREAM_RETRY_DELAY_MS` | `300` | Initial upstream retry backoff in milliseconds; capped at `5000` |
 | `CCDX_LOG_PATH` | unset | Mirror terminal logs to a file; set to `1` for `~/.local/share/codex-copilot-dx/debug.log` |
 | `CCDX_LOG_LEVEL` | `info` | Set to `debug` to include upstream request attempts, status codes, retry causes, and timings |
-| `CCDX_IMG_MAX_DIM` | `2048` | Max long edge in pixels for optional image downscaling |
-| `CCDX_IMG_QUALITY` | `85` | WebP quality used when optional image re-encoding is available |
+| `CCDX_IMG_MAX_DIM` | `2048` | Max long edge in pixels for image downscaling |
+| `CCDX_IMG_QUALITY` | `85` | WebP quality used when re-encoding images |
 | `CCDX_IMG_MIN_BYTES` | `100000` | Images smaller than this are left untouched |
 | `CCDX_IMG_CONCURRENCY` | `4` | Concurrent image optimization tasks; values above `12` are capped at `12` |
 | `CCDX_DISABLE_IMG_OPT` | unset | Set to `1` to disable image optimization |
@@ -127,7 +127,7 @@ codex-copilot-dx usage
 
 Long computer-use sessions can accumulate screenshots inside the conversation history. Each screenshot is shipped on later turns, and GitHub Copilot's `/responses` endpoint can reject oversized requests with `413 Payload Too Large`.
 
-When the optional `sharp` package is available, the adapter downsamples embedded screenshots to long-edge <= 2048 px and re-encodes them as WebP before forwarding `/v1/responses`. `sharp` is not installed by default so the CLI stays lightweight and avoids native package install stalls; install it alongside `codex-copilot-dx` if you want this optimization.
+The adapter automatically downsamples embedded screenshots to long-edge <= 2048 px and re-encodes them as WebP before forwarding `/v1/responses`.
 
 ## License
 

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.20",
+  "version": "0.4.22",
   "description": "Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot",
   "type": "module",
   "bin": {
@@ -27,5 +27,9 @@
   "license": "MIT",
   "scripts": {
     "test": "node --test"
+  },
+  "dependencies": {
+    "gpt-tokenizer": "^3.4.0",
+    "sharp": "^0.34.5"
   }
 }

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/anthropic.mjs

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { encode } from "gpt-tokenizer";
 
 // Anthropic Messages API to OpenAI chat/completions translation.
 // Pure functions only; network calls stay in adapter.mjs and copilot.mjs.
@@ -237,19 +238,7 @@ export async function streamAnthropicFromLines(lineIterator, emit, model, option
   await emit("message_stop", { type: "message_stop" });
 }
 
-function estimateTokens(text) {
-  if (!text) return 0;
-  let asciiChars = 0;
-  let nonAsciiChars = 0;
-  for (const ch of text) {
-    if (/\s/.test(ch)) continue;
-    if (ch.codePointAt(0) <= 0x7f) asciiChars += 1;
-    else nonAsciiChars += 1;
-  }
-  return Math.max(1, Math.ceil(asciiChars / 4) + nonAsciiChars);
-}
-
-// Copilot has no count_tokens endpoint; estimate locally without install-time dependencies.
+// Copilot has no count_tokens endpoint; estimate locally with gpt-tokenizer.
 export function countTokens(body) {
   const parts = [];
   const sys = systemToText(body.system);
@@ -274,5 +263,5 @@ export function countTokens(body) {
   }
 
   const text = parts.join("\n");
-  return { input_tokens: estimateTokens(text) };
+  return { input_tokens: encode(text).length };
 }

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);
@@ -21,8 +45,6 @@ const IMG_CONCURRENCY = parseImageConcurrency(process.env.CCDX_IMG_CONCURRENCY);
 const UPSTREAM_RETRIES = parseUpstreamRetries(process.env.CCDX_UPSTREAM_RETRIES);
 const UPSTREAM_RETRY_DELAY_MS = parseUpstreamRetryDelayMs(process.env.CCDX_UPSTREAM_RETRY_DELAY_MS);
 let sharpImport = null;
-let sharpUnavailable = false;
-let sharpUnavailableLogged = false;
 
 export function parseImageConcurrency(value) {
   const n = Number.parseInt(value, 10);
@@ -175,16 +197,9 @@ export async function fetchCopilotUpstream(
 }
 
 async function sharp() {
-  if (sharpUnavailable) return null;
-  try {
-    sharpImport ||= import("sharp");
-    const mod = await sharpImport;
-    return mod.default || mod;
-  } catch {
-    sharpUnavailable = true;
-    sharpImport = null;
-    return null;
-  }
+  sharpImport ||= import("sharp");
+  const mod = await sharpImport;
+  return mod.default || mod;
 }
 
 export async function optimizeImageDataUrl(dataUrl) {
@@ -198,13 +213,6 @@ export async function optimizeImageDataUrl(dataUrl) {
 
   try {
     const resize = await sharp();
-    if (!resize) {
-      if (!sharpUnavailableLogged) {
-        sharpUnavailableLogged = true;
-        console.warn(status("warn", "image optimization skipped because optional dependency sharp is not installed"));
-      }
-      return dataUrl;
-    }
     const out = await resize(raw, { failOn: "none" })
       .rotate()
       .resize(IMG_MAX_DIM, IMG_MAX_DIM, { fit: "inside", withoutEnlargement: true })
@@ -502,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 : [];