codex-copilot-dx 0.7.1 → 0.7.2

package/README.md

@@ -1,8 +1,8 @@
 # codex-copilot-dx
 
-Use Codex Desktop or the ChatGPT app with GPT models provided by your **GitHub Copilot** subscription.
+Use Codex App with GPT models provided by your **GitHub Copilot** subscription.
 
-CCDX is a local compatibility adapter. It configures Codex-compatible desktop clients to use an OpenAI Responses API on loopback while GitHub authentication, model discovery, and inference stay backed by GitHub Copilot.
+CCDX is a local compatibility adapter for Codex App. It configures Codex to use an OpenAI Responses API on loopback while GitHub authentication, model discovery, and inference stay backed by GitHub Copilot.
 
 ## How it works
 
@@ -14,7 +14,7 @@ One in-process adapter listens on `127.0.0.1:2026` by default and exposes:
 
 Responses-only models and compaction use Copilot's Responses transport directly. For GPT models that advertise only Chat Completions, CCDX converts the supported text, image, and function-tool subset and rejects incompatible request shapes explicitly. Both streaming SSE and non-streaming responses are supported.
 
-The adapter preserves Codex and ChatGPT app behavior around response history, encrypted reasoning state, function/custom tools, images, compaction, cancellation, retries, and usage metadata. Model routing follows the live Copilot catalog instead of a hard-coded GPT model list.
+The adapter preserves Codex App behavior around response history, encrypted reasoning state, function/custom tools, images, compaction, cancellation, retries, and usage metadata. Model routing follows the live Copilot catalog instead of a hard-coded GPT model list.
 
 ### Fast and Standard modes
 
@@ -22,11 +22,17 @@ Codex can select Standard or Fast without changing CCDX configuration. When the
 
 Codex Auto-review uses the hidden `codex-auto-review` model ID. CCDX maps it to Copilot's `gpt-5.5` Responses model by default, independently of the interactive Fast/Standard selection, and logs both model IDs when the mapping is used. The review target can be changed interactively without reinstalling or restarting CCDX.
 
+### GPT-6 model catalog
+
+Codex App requests a versioned, capability-rich model catalog that is different from Copilot's raw model list. CCDX reads the complete catalog bundled with the installed Codex App and preserves every other model entry and capability. It makes `gpt-6-astra` visible only when the live Copilot catalog advertises that exact model as enabled, selectable, OpenAI-owned, and Responses-capable.
+
+CCDX 0.7.2 exposes only the verified GPT-6 Standard path and removes its unverified speed-tier metadata. Codex Ultra remains available because the client maps it to the model's supported multi-agent reasoning effort. GPT-5.6 Sol Fast remains unchanged. The bundled catalog is matched to the Codex client version, cached by application binary identity, and reloaded automatically after an App update.
+
 ## Prerequisites
 
 - GitHub Copilot subscription (Individual, Business, or Enterprise)
 - Node.js 22.15 or newer, for built-in Zstandard request decompression
-- Codex Desktop or the ChatGPT app on macOS
+- Codex App on macOS
 
 ## Install and start
 
@@ -49,7 +55,7 @@ On a normal launch, CCDX:
 2. Reuses a compatible running adapter when available; otherwise it reuses a compatible local Copilot credential or starts GitHub Device Flow when authentication is required.
 3. Refreshes Copilot model metadata and listens on the configured loopback address.
 4. Updates `~/.codex/config.toml` to use the local `/v1` endpoint while preserving unrelated Codex settings.
-5. Attempts to open Codex Desktop or the ChatGPT app on macOS unless `CCDX_AUTO_LAUNCH` disables it.
+5. Attempts to open Codex App on macOS unless `CCDX_AUTO_LAUNCH` disables it.
 
 The `OPENAI_API_KEY=dummy` value written into the Codex shell environment is only a client-side placeholder. It is not a GitHub credential. CCDX exchanges the saved GitHub OAuth credential for short-lived Copilot service tokens internally.
 
@@ -227,7 +233,7 @@ ccdx
 | `CCDX_IMG_MAX_INPUT_PIXELS` | `40000000` | Maximum decoded pixels accepted for one image |
 | `CCDX_IMG_CACHE_MAX_BYTES` | `67108864` | Process-local byte ceiling for cached image transforms; set to `0` to disable the cache |
 | `CCDX_DISABLE_IMG_OPT` | unset | Set to `1` to disable image optimization |
-| `CCDX_AUTO_LAUNCH` | enabled | Set to `0`, `false`, `no`, or `off` to start without opening Codex or ChatGPT |
+| `CCDX_AUTO_LAUNCH` | enabled | Set to `0`, `false`, `no`, or `off` to start without opening Codex App |
 | `CCDX_GITHUB_TOKEN` | unset | Explicit GitHub Copilot OAuth token to validate and import before Device Flow |
 | `CCDX_GITHUB_TOKEN_PATH` | unset | Explicit file containing a GitHub Copilot OAuth token |
 | `CCDX_GITHUB_TOKEN_PATHS` | unset | Multiple token files separated by the platform path delimiter (`:` on macOS/Linux, `;` on Windows) |
@@ -277,7 +283,7 @@ For `/v1/responses/compact`, CCDX sends one terminal `compaction_trigger`, valid
 
 Successful streaming responses are accepted only when the upstream body is SSE and reaches its protocol terminal event. Unexpected EOF becomes a protocol-native stream error, and repeated blank tool-argument deltas are stopped per tool call. Safe quota, retry, model, trace, and upstream request-ID metadata are forwarded; cookies, authorization, body-length, and encoding headers are not.
 
-Newer Codex and ChatGPT clients can advertise an `image_gen` namespace that already exists upstream. CCDX removes that exact conflicting client tool before forwarding and retries once only when Copilot explicitly reports an image namespace collision. Image input and screenshot optimization remain enabled.
+Newer Codex App builds can advertise an `image_gen` namespace that already exists upstream. CCDX removes that exact conflicting client tool before forwarding and retries once only when Copilot explicitly reports an image namespace collision. Image input and screenshot optimization remain enabled.
 
 ## Development
 

package/bin/cli.mjs

@@ -21,6 +21,7 @@ import { fetchLiveCopilotModels, formatLiveCopilotModels } from "../src/cli-mode
 import { runAuthCommand } from "../src/cli-auth.mjs";
 import { createProfileRuntime } from "../src/profile-runtime.mjs";
 import { createProfileModelRuntime } from "../src/profile-model-runtime.mjs";
+import { createCodexModelCatalog } from "../src/codex-model-catalog.mjs";
 
 const LOCAL_VERSION = localPackageVersion();
 const CLI_NAME = cliCommandName();
@@ -201,7 +202,7 @@ if (CLI.command === "doctor") {
 
 console.log(`
   ${CLI_BANNER}
-  Use Codex Desktop and ChatGPT App with GitHub Copilot
+  Use Codex App with GitHub Copilot
 `);
 
 async function printUpdateNotice() {
@@ -242,9 +243,11 @@ try {
 
   // Start the in-process adapter.
   const terminalAnimationTheme = terminalAnimationPreference().theme;
+  const codexModelCatalog = createCodexModelCatalog();
   activeServer = await startAdapter(ADAPTER_PORT, ADAPTER_HOST, {
     autoReviewModelResolver: () => autoReviewModelPreference().model,
     codexClient: profileRuntime.codexClient,
+    codexModelCatalog,
     codexModelRegistry: profileModels.codexRegistry,
     showRequestId: CLI.showRequestId,
     upstreamTimeoutMs: RUNTIME.upstreamTimeoutMs,
@@ -253,7 +256,7 @@ try {
     terminalAnimationTheme,
   });
 
-  // Point Codex and compatible ChatGPT App builds at the adapter.
+  // Point Codex App at the adapter.
   ensureCodexConfig(ADAPTER_PORT, { host: ADAPTER_HOST });
 
   // Launch Codex when available.
@@ -270,7 +273,7 @@ try {
   }
 
   console.log(`
-  ${status("ok", "Ready, Codex App and ChatGPT App are ready to use")}
+  ${status("ok", "Ready, Codex App is ready to use")}
 
   Adapter: ${adapterBaseUrl(ADAPTER_HOST, ADAPTER_PORT)}
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.7.1",
-  "description": "Use Codex Desktop and ChatGPT App with GitHub Copilot",
+  "version": "0.7.2",
+  "description": "Use Codex App with GitHub Copilot",
   "author": "Dale Xiao",
   "type": "module",
   "bin": {

package/src/adapter.mjs

@@ -1,5 +1,6 @@
 import http from "node:http";
 import { defaultCopilotClient } from "./copilot.mjs";
+import { buildCodexModelResponse } from "./codex-model-catalog.mjs";
 import { isValidModelList } from "./model-cache.mjs";
 import {
   ADAPTER_STATUS_PATH,
@@ -78,13 +79,58 @@ function modelListCanUseLastKnownGood(statusCode) {
   return [408, 425, 429].includes(statusCode) || statusCode >= 500;
 }
 
-function sendLastKnownGoodModels(res, modelRegistry) {
+function modelClientVersion(reqUrl) {
+  try {
+    return String(new URL(reqUrl || "/", "http://localhost").searchParams.get("client_version") || "").trim();
+  } catch {
+    return "";
+  }
+}
+
+async function sendModelList(res, models, {
+  codexModelCatalog,
+  clientVersion = "",
+  headers = {},
+  rawBody,
+  statusCode = 200,
+} = {}) {
+  let body = rawBody || JSON.stringify(models);
+  if (clientVersion && typeof codexModelCatalog?.load === "function") {
+    let response = null;
+    try {
+      const codexCatalog = await codexModelCatalog.load({ clientVersion });
+      response = buildCodexModelResponse({ copilotModels: models, codexCatalog });
+    } catch {}
+    if (!response) {
+      if (res.destroyed || res.writableEnded) return false;
+      res.writeHead(503, {
+        "Content-Type": "application/json",
+        "Retry-After": "5",
+        ...headers,
+      });
+      res.end(JSON.stringify({
+        error: {
+          message: "The Codex App model catalog is temporarily unavailable",
+          type: "server_error",
+          code: "ccdx_codex_model_catalog_unavailable",
+        },
+      }));
+      return true;
+    }
+    body = JSON.stringify(response);
+  }
+  if (res.destroyed || res.writableEnded) return false;
+  res.writeHead(statusCode, { "Content-Type": "application/json", ...headers });
+  res.end(body);
+  return true;
+}
+
+async function sendLastKnownGoodModels(res, modelRegistry, options = {}) {
   if (!isValidModelList(modelRegistry?.models) || res.destroyed || res.writableEnded) return false;
-  res.writeHead(200, {
-    "Content-Type": "application/json",
-    "X-CCDX-Model-Source": "last-known-good",
+  await sendModelList(res, modelRegistry.models, {
+    ...options,
+    headers: { "X-CCDX-Model-Source": "last-known-good" },
   });
-  res.end(JSON.stringify(modelRegistry.models));
   return true;
 }
 
@@ -100,6 +146,7 @@ export function createAdapterHandler(options = {}) {
   const responsesFn = options.responsesFn || codexClient.responses;
   const responsesCompactFn = options.responsesCompactFn || codexClient.responsesCompact;
   const listModelsFn = options.listModelsFn || codexClient.listModels;
+  const codexModelCatalog = options.codexModelCatalog;
   const getCachedModelEndpointsFn = options.getCachedModelEndpointsFn
     || codexClient.getCachedModelEndpoints;
   const codexModelRegistry = options.codexModelRegistry || options.modelRegistry;
@@ -176,10 +223,12 @@ export function createAdapterHandler(options = {}) {
     }
 
     if (req.method === "GET" && pathname === "/v1/models") {
+      const clientVersion = modelClientVersion(req.url);
       const abort = createRequestAbort(req, res);
       abort.setTimeout(upstreamTimeoutMs);
       listModelsFn({ signal: abort.signal })
-        .then(({ status, body }) => {
+        .then(async ({ status, body }) => {
+          abort.clearTimeout();
           if (status >= 200 && status < 300) {
             let models;
             try { models = JSON.parse(body); } catch {}
@@ -187,21 +236,26 @@ export function createAdapterHandler(options = {}) {
               if (codexModelRegistry) {
                 codexModelRegistry.models = models;
               }
-              res.writeHead(status, { "Content-Type": "application/json" });
-              res.end(body);
+              await sendModelList(res, models, {
+                codexModelCatalog,
+                clientVersion,
+                rawBody: body,
+                statusCode: status,
+              });
               return;
             }
-            if (sendLastKnownGoodModels(res, codexModelRegistry)) return;
+            if (await sendLastKnownGoodModels(res, codexModelRegistry, { codexModelCatalog, clientVersion })) return;
             sendJsonError(res, httpError("Copilot models response contained no valid models", 502), 502);
             return;
           }
-          if (modelListCanUseLastKnownGood(status) && sendLastKnownGoodModels(res, codexModelRegistry)) return;
+          if (modelListCanUseLastKnownGood(status)
+            && await sendLastKnownGoodModels(res, codexModelRegistry, { codexModelCatalog, clientVersion })) return;
           res.writeHead(status, { "Content-Type": "application/json" });
           res.end(body);
         })
-        .catch((e) => {
+        .catch(async (e) => {
           logRequestFailure("Models", e, abort);
-          if (sendLastKnownGoodModels(res, codexModelRegistry)) return;
+          if (await sendLastKnownGoodModels(res, codexModelRegistry, { codexModelCatalog, clientVersion })) return;
           if (!res.destroyed && !res.writableEnded) {
             if (!res.headersSent) res.writeHead(e?.statusCode || 502);
             res.end(JSON.stringify({ error: e.message }));

package/src/cli-options.mjs

@@ -273,7 +273,7 @@ export function cliCommandName() {
 
 function topicHelp(name, topic) {
   const sections = {
-    start: `Usage:\n  ${name} [start] [--show-request-id]\n\nStarts or reuses the local adapter, updates Codex configuration, and attempts to open Codex or ChatGPT when auto-launch is enabled and supported.`,
+    start: `Usage:\n  ${name} [start] [--show-request-id]\n\nStarts or reuses the local adapter, updates Codex configuration, and attempts to open Codex App when auto-launch is enabled and supported.`,
     auth: `Usage:\n  ${name} auth status [--online] [--format table|plain]\n\nShows the saved GitHub Copilot account without exposing credentials. --online also verifies its entitlement and model catalog.`,
     "auth status": `Usage:\n  ${name} auth status [--online] [--format table|plain]\n\nShows the saved GitHub Copilot account without exposing credentials. --online also verifies its entitlement and model catalog. Interactive terminals use a table by default.`,
     doctor: `Usage:\n  ${name} doctor [--online] [--compat]\n\nChecks the local credential, Codex configuration, and adapter. --online validates account entitlement; --compat sends minimal inference requests and consumes a small amount of Copilot usage.`,

package/src/codex-model-catalog.mjs

@@ -0,0 +1,261 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { CODEX_GPT6_MODEL } from "./models.mjs";
+
+export { CODEX_GPT6_MODEL };
+
+export const CODEX_APP_BINARY_PATHS = [
+  "/Applications/Codex.app/Contents/Resources/codex",
+  "/Applications/ChatGPT.app/Contents/Resources/codex",
+  path.join(os.homedir(), "Applications", "Codex.app", "Contents", "Resources", "codex"),
+  path.join(os.homedir(), "Applications", "ChatGPT.app", "Contents", "Resources", "codex"),
+];
+export const CODEX_MODEL_CATALOG_TIMEOUT_MS = 5_000;
+export const CODEX_MODEL_CATALOG_MAX_BUFFER = 8 * 1024 * 1024;
+export const CODEX_MODEL_CATALOG_FAILURE_BACKOFF_MS = 5_000;
+
+function objectRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function codexCatalogIsValid(catalog) {
+  if (!objectRecord(catalog) || !Array.isArray(catalog.models) || catalog.models.length === 0) return false;
+  const slugs = new Set();
+  for (const model of catalog.models) {
+    const slug = String(model?.slug || "").trim();
+    if (!objectRecord(model) || !slug || slugs.has(slug)) return false;
+    slugs.add(slug);
+  }
+  return true;
+}
+
+function copilotModelData(models) {
+  if (!objectRecord(models) || !Array.isArray(models.data) || models.data.length === 0) return null;
+  return models.data;
+}
+
+function supportsResponses(model) {
+  const endpoints = Array.isArray(model?.supported_endpoints) ? model.supported_endpoints : [];
+  return endpoints.includes("/responses") || endpoints.includes("/v1/responses");
+}
+
+function isEligibleOpenAIModel(model, id) {
+  const vendor = String(model?.vendor || model?.owned_by || "").trim().toLowerCase();
+  return String(model?.id || "").trim() === id
+    && vendor === "openai"
+    && String(model?.policy?.state || "").trim().toLowerCase() === "enabled"
+    && model?.model_picker_enabled === true
+    && supportsResponses(model);
+}
+
+export function isEligibleCopilotGpt6(copilotModels) {
+  const data = copilotModelData(copilotModels);
+  if (!data) return false;
+  const matches = data.filter((model) => String(model?.id || "").trim() === CODEX_GPT6_MODEL);
+  return matches.length === 1 && isEligibleOpenAIModel(matches[0], CODEX_GPT6_MODEL);
+}
+
+export function buildCodexModelResponse({ copilotModels, codexCatalog } = {}) {
+  if (!copilotModelData(copilotModels) || !codexCatalogIsValid(codexCatalog)) return null;
+
+  const exposeGpt6 = isEligibleCopilotGpt6(copilotModels);
+  const models = codexCatalog.models.map((model) => {
+    if (model.slug !== CODEX_GPT6_MODEL) return model;
+    if (!exposeGpt6) return { ...model, visibility: "hide" };
+    const patched = {
+      ...model,
+      visibility: "list",
+      additional_speed_tiers: [],
+      service_tiers: [],
+    };
+    delete patched.default_service_tier;
+    return patched;
+  });
+
+  return { ...copilotModels, object: copilotModels.object || "list", models };
+}
+
+function binaryCacheKey(binaryPath, stats) {
+  return [
+    binaryPath,
+    stats.dev,
+    stats.ino,
+    stats.size,
+    stats.mtimeMs,
+    stats.ctimeMs,
+  ].map((part) => String(part ?? "")).join(":");
+}
+
+async function installedCodexBinaries(binaryPaths, statFn) {
+  const installed = [];
+  for (const binaryPath of binaryPaths) {
+    let stats;
+    try {
+      stats = await statFn(binaryPath);
+    } catch {
+      continue;
+    }
+    if (stats && typeof stats.isFile === "function" && stats.isFile()) {
+      installed.push({ binaryPath, key: binaryCacheKey(binaryPath, stats) });
+    }
+  }
+  return installed;
+}
+
+function runCodexCommand(execFileFn, binaryPath, args, options) {
+  return new Promise((resolve, reject) => {
+    try {
+      execFileFn(binaryPath, args, options, (error, stdout) => {
+        if (error) reject(error);
+        else resolve(stdout);
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
+function parsedCodexVersion(stdout) {
+  const match = /^(?:codex-cli|codex)\s+(\S+)$/.exec(String(stdout).trim());
+  return match?.[1] || null;
+}
+
+function wholeSemver(value) {
+  const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.exec(String(value || "").trim());
+  if (!match) return null;
+  if (match[4]?.split(".").some((part) => /^\d+$/.test(part) && part.length > 1 && part.startsWith("0"))) {
+    return null;
+  }
+  return `${match[1]}.${match[2]}.${match[3]}`;
+}
+
+function normalizedBackoff(value) {
+  return Number.isFinite(value) && value >= 0 ? value : CODEX_MODEL_CATALOG_FAILURE_BACKOFF_MS;
+}
+
+export function createCodexModelCatalog({
+  binaryPath,
+  execFileFn = execFile,
+  statFn = fs.promises.stat,
+  timeoutMs = CODEX_MODEL_CATALOG_TIMEOUT_MS,
+  maxBuffer = CODEX_MODEL_CATALOG_MAX_BUFFER,
+  failureBackoffMs = CODEX_MODEL_CATALOG_FAILURE_BACKOFF_MS,
+  now = Date.now,
+} = {}) {
+  const binaryPaths = binaryPath === undefined
+    ? CODEX_APP_BINARY_PATHS
+    : [binaryPath].filter((candidate) => typeof candidate === "string" && path.isAbsolute(candidate));
+  const commandOptions = {
+    encoding: "utf8",
+    maxBuffer,
+    timeout: timeoutMs,
+    windowsHide: true,
+  };
+  const backoffMs = normalizedBackoff(failureBackoffMs);
+  const versionCache = new Map();
+  const versionFailures = new Map();
+  const versionPending = new Map();
+  const catalogCache = new Map();
+  const catalogFailures = new Map();
+  const catalogPending = new Map();
+  let activeBinaryKeys = new Set();
+
+  function retainCurrentEntries(map) {
+    for (const key of map.keys()) {
+      if (!activeBinaryKeys.has(key)) map.delete(key);
+    }
+  }
+
+  async function probeVersion(candidate) {
+    if (versionCache.has(candidate.key)) return versionCache.get(candidate.key);
+    const failure = versionFailures.get(candidate.key);
+    if (failure && now() < failure.retryAt) return null;
+    if (versionPending.has(candidate.key)) return versionPending.get(candidate.key);
+
+    const promise = (async () => {
+      try {
+        const stdout = await runCodexCommand(execFileFn, candidate.binaryPath, ["--version"], commandOptions);
+        const version = wholeSemver(parsedCodexVersion(stdout));
+        if (!version) throw new Error("Invalid Codex version output");
+        if (activeBinaryKeys.has(candidate.key)) {
+          versionCache.set(candidate.key, version);
+          versionFailures.delete(candidate.key);
+        }
+        return version;
+      } catch {
+        if (activeBinaryKeys.has(candidate.key)) {
+          versionFailures.set(candidate.key, { retryAt: now() + backoffMs });
+        }
+        return null;
+      }
+    })();
+    versionPending.set(candidate.key, promise);
+    try {
+      return await promise;
+    } finally {
+      if (versionPending.get(candidate.key) === promise) versionPending.delete(candidate.key);
+    }
+  }
+
+  async function selectBinary(clientVersion) {
+    const installed = await installedCodexBinaries(binaryPaths, statFn);
+    activeBinaryKeys = new Set(installed.map((candidate) => candidate.key));
+    for (const map of [versionCache, versionFailures, catalogCache, catalogFailures]) {
+      retainCurrentEntries(map);
+    }
+    if (installed.length === 0) return null;
+    const rawVersion = String(clientVersion || "").trim();
+    if (!rawVersion) return installed[0];
+    const expectedVersion = wholeSemver(rawVersion);
+    if (!expectedVersion) return null;
+    for (const candidate of installed) {
+      if (await probeVersion(candidate) === expectedVersion) return candidate;
+    }
+    return null;
+  }
+
+  async function loadCatalog(candidate) {
+    if (catalogCache.has(candidate.key)) return catalogCache.get(candidate.key);
+    const failure = catalogFailures.get(candidate.key);
+    if (failure && now() < failure.retryAt) return null;
+    if (catalogPending.has(candidate.key)) return catalogPending.get(candidate.key);
+
+    const promise = (async () => {
+      try {
+        const stdout = await runCodexCommand(
+          execFileFn,
+          candidate.binaryPath,
+          ["debug", "models", "--bundled"],
+          commandOptions,
+        );
+        const catalog = JSON.parse(String(stdout));
+        if (!codexCatalogIsValid(catalog)) throw new Error("Invalid Codex model catalog");
+        if (activeBinaryKeys.has(candidate.key)) {
+          catalogCache.set(candidate.key, catalog);
+          catalogFailures.delete(candidate.key);
+        }
+        return catalog;
+      } catch {
+        if (activeBinaryKeys.has(candidate.key)) {
+          catalogFailures.set(candidate.key, { retryAt: now() + backoffMs });
+        }
+        return null;
+      }
+    })();
+    catalogPending.set(candidate.key, promise);
+    try {
+      return await promise;
+    } finally {
+      if (catalogPending.get(candidate.key) === promise) catalogPending.delete(candidate.key);
+    }
+  }
+
+  async function load({ clientVersion = "" } = {}) {
+    const candidate = await selectBinary(clientVersion);
+    return candidate ? loadCatalog(candidate) : null;
+  }
+
+  return { load };
+}

package/src/launcher.mjs

@@ -3,8 +3,7 @@ import { status } from "./status.mjs";
 
 export { ensureAuth } from "./auth.mjs";
 
-// Prefer the Codex bundle identifier, then fall back to the known app paths.
-// This supports both Codex.app and ChatGPT.app regardless of installation path.
+// Prefer the Codex bundle identifier, then fall back to its known app paths.
 const CODEX_BUNDLE_ID = "com.openai.codex";
 const APP_PATH_CANDIDATES = [
   "/Applications/Codex.app",
@@ -40,12 +39,12 @@ export function launchAttempts() {
 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."));
+    console.log(status("info", "Open Codex 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."));
+    console.log(status("info", "Auto-launch disabled (CCDX_AUTO_LAUNCH=0); open Codex App manually."));
     return false;
   }
 
@@ -57,7 +56,7 @@ export async function openCodex({ env = process.env, spawnImpl = spawn, platform
   }
 
   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", "Open Codex 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

@@ -1,5 +1,6 @@
 export const CODEX_AUTO_REVIEW_MODEL = "codex-auto-review";
 export const DEFAULT_CODEX_AUTO_REVIEW_MODEL = "gpt-5.5";
+export const CODEX_GPT6_MODEL = "gpt-6-astra";
 
 function hasOpenAIEndpoint(model) {
   const endpoints = Array.isArray(model?.supported_endpoints) ? model.supported_endpoints : [];

package/src/responses-handler.mjs

@@ -12,6 +12,7 @@ import {
   writeOrDrain,
 } from "./http-transport.mjs";
 import {
+  CODEX_GPT6_MODEL,
   CODEX_AUTO_REVIEW_MODEL,
   modelIsResponsesOnly,
   modelSupportsChatCompletions,
@@ -87,6 +88,14 @@ function resolveRequestModel(model, openAIModelEnv, autoReviewModelResolver) {
   return resolveOpenAIModel(model, openAIModelEnv, options);
 }
 
+function stripUnsupportedGpt6ServiceTier(body, requestedModel, upstreamModel) {
+  if (requestedModel === CODEX_GPT6_MODEL
+    && upstreamModel === requestedModel
+    && body.service_tier === "priority") {
+    delete body.service_tier;
+  }
+}
+
 export function createResponsesHandler(options) {
   const {
     acquireRequest,
@@ -216,6 +225,7 @@ export function createResponsesHandler(options) {
         upstreamModel = priorityTierModel;
         delete prepared.body.service_tier;
       }
+      stripUnsupportedGpt6ServiceTier(prepared.body, requestedModel, upstreamModel);
       if (requestedModel === CODEX_AUTO_REVIEW_MODEL) delete prepared.body.service_tier;
       if (upstreamModel !== requestedModel) prepared.body.model = upstreamModel;
       const upstreamLog = upstreamModel === requestedModel ? "" : ` upstream_model=${upstreamModel}`;
@@ -465,6 +475,7 @@ export function createResponsesCompactHandler(options) {
         upstreamModel = priorityTierModel;
         delete prepared.body.service_tier;
       }
+      stripUnsupportedGpt6ServiceTier(prepared.body, requestedModel, upstreamModel);
       if (requestedModel === CODEX_AUTO_REVIEW_MODEL) delete prepared.body.service_tier;
       if (upstreamModel !== requestedModel) prepared.body.model = upstreamModel;
       const upstreamLog = upstreamModel === requestedModel ? "" : ` upstream_model=${upstreamModel}`;