codex-copilot-dx 0.9.2 → 0.9.4

package/README.md

@@ -26,9 +26,9 @@ Codex Auto-review uses the hidden `codex-auto-review` model ID. CCDX maps it to
 
 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 exposes each managed GPT-6 entry only when Copilot advertises that exact model as enabled, selectable, OpenAI-owned, and Responses-capable.
 
-When an installed 0.155.x catalog does not yet contain `gpt-6-sol` or `gpt-6-luna`, CCDX derives their client-compatible entries from that catalog's GPT-6 Astra schema and the published OpenAI Codex model definitions at commit `0a2eb4696c26ac33204bcd255721ab30220a4774`. Only those two missing entries are inserted. Their fallback reasoning controls are intersected with Copilot's advertised efforts; every other bundled entry remains byte-for-byte equivalent. A newer client-provided Sol/Luna entry always wins and is preserved.
+When an installed 0.155.x catalog does not yet contain `gpt-6-sol` or `gpt-6-luna`, CCDX derives their client-compatible entries from that catalog's GPT-6 Astra schema and the published OpenAI Codex model definitions at commit `0a2eb4696c26ac33204bcd255721ab30220a4774`. When an installed 0.158+ catalog contains `gpt-6-sol` but not `gpt-6.1-sol`, CCDX derives only the missing 6.1 entry from that client's Sol schema and OpenAI Codex model identity/defaults at commit `ab84d71f5767e4a565ce81c2c426287cb48c7918`. Fallback reasoning controls are intersected with Copilot's advertised efforts; every other bundled entry retains its established behavior. A newer client-provided entry supplies its schema and future fields while CCDX still gates its visibility, speed tiers, and 6.1 Sol reasoning controls against Copilot.
 
-CCDX exposes GPT-6 Standard paths and removes unverified speed-tier metadata. It leaves bundled reasoning-effort options unchanged, including Ultra when supplied by the installed catalog. Fast follows the exact upstream-variant rule above. Versioned model discovery matches the bundled catalog to the client's `client_version`, caches it by application binary identity, and reloads it after an App update. If a matching usable catalog cannot be loaded, the versioned models request returns `503`; an unversioned request returns the Copilot-style list.
+CCDX exposes GPT-6 Standard paths and removes unverified speed-tier metadata. Existing GPT-6 bundled reasoning-effort options remain unchanged; 6.1 Sol is limited to efforts advertised by Copilot. Fast follows the exact upstream-variant rule above. Versioned model discovery matches the bundled catalog to the client's `client_version`, including the nested Codex CLI binary in current macOS App bundles, caches it by application binary identity, and reloads it after an App update. If a matching usable catalog cannot be loaded, the versioned models request returns `503`; an unversioned request returns the Copilot-style list.
 
 `/v1/models` still attempts live discovery first. With a usable in-process catalog, it limits that upstream wait to 1.5 seconds (or a shorter configured upstream timeout) before falling back to last-known-good data. Without a catalog it retains the regular upstream timeout. Received HTTP `401`/`403` responses remain errors, not cached successes; fallback does not grant inference access. This does not change the explicitly live `ccdx models` command.
 
@@ -107,6 +107,8 @@ This performs a fresh, read-only GitHub Copilot model-directory lookup without s
 
 Interactive terminals use aligned tables for `models`, `auth status`, and `usage`. Redirected or piped output retains the plain-text layout for scripts; use `--format table` or `--format plain` when a command offers an explicit format override.
 
+`ccdx usage` and the dashboard Usage table show token cache hit rate for each model and the aggregate: cached input tokens divided by input tokens, weighted by token count rather than averaging request percentages. This describes the upstream prompt cache; the local history and image-transform caches are separate. A rate is `—` when input tokens are zero or any included record lacks valid paired input/cache counts. Older logs may omit explicit zero cache counts; new Responses usage records retain reported zeros. CLI tables keep existing token columns on narrow terminals and show rates below the table when the extra column does not fit.
+
 ### Auto-review model
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "Use Codex App with GitHub Copilot",
   "author": "Dale Xiao",
   "type": "module",

package/src/codex-model-catalog.mjs

@@ -4,11 +4,17 @@ import os from "node:os";
 import path from "node:path";
 import { CODEX_GPT6_MODEL } from "./models.mjs";
 
-// Compatibility metadata is derived from OpenAI Codex's public models catalog
-// at commit 0a2eb4696c26ac33204bcd255721ab30220a4774. The installed client's
-// GPT-6 Astra entry supplies its own schema and instructions; these overrides
-// describe only the two new model identities and capability differences.
+// GPT-6 Sol/Luna compatibility metadata comes from OpenAI Codex's public models
+// catalog at commit 0a2eb4696c26ac33204bcd255721ab30220a4774. GPT-6.1 Sol
+// identity and defaults come from commit ab84d71f5767e4a565ce81c2c426287cb48c7918.
+// The installed client's Astra or Sol entry supplies its schema and instructions.
 const GPT6_COMPATIBILITY_SPECS = new Map([
+  ["gpt-6.1-sol", Object.freeze({
+    display_name: "GPT-6.1-Sol",
+    description: "Latest workhorse model for coding and everyday work.",
+    default_reasoning_level: "low",
+    priority: 1,
+  })],
   ["gpt-6-sol", Object.freeze({
     display_name: "GPT-6-Sol",
     description: "Workhorse model for coding and everyday work.",
@@ -33,8 +39,12 @@ export { CODEX_GPT6_MODEL };
 export const CODEX_APP_BINARY_PATHS = [
   "/Applications/Codex.app/Contents/Resources/codex",
   "/Applications/ChatGPT.app/Contents/Resources/codex",
+  "/Applications/Codex.app/Contents/Resources/codex-cli/CodexCLI.app/Contents/MacOS/codex",
+  "/Applications/ChatGPT.app/Contents/Resources/codex-cli/CodexCLI.app/Contents/MacOS/codex",
   path.join(os.homedir(), "Applications", "Codex.app", "Contents", "Resources", "codex"),
   path.join(os.homedir(), "Applications", "ChatGPT.app", "Contents", "Resources", "codex"),
+  path.join(os.homedir(), "Applications", "Codex.app", "Contents", "Resources", "codex-cli", "CodexCLI.app", "Contents", "MacOS", "codex"),
+  path.join(os.homedir(), "Applications", "ChatGPT.app", "Contents", "Resources", "codex-cli", "CodexCLI.app", "Contents", "MacOS", "codex"),
 ];
 export const CODEX_MODEL_CATALOG_TIMEOUT_MS = 5_000;
 export const CODEX_MODEL_CATALOG_MAX_BUFFER = 8 * 1024 * 1024;
@@ -96,7 +106,7 @@ function catalogModelForCopilot(model, copilotModels, { filterReasoning = false
   const patched = {
     ...structuredClone(model),
     visibility: "list",
-    supported_reasoning_levels: filterReasoning && reasoning.size
+    supported_reasoning_levels: filterReasoning && reasoning.size && Array.isArray(model.supported_reasoning_levels)
       ? model.supported_reasoning_levels.filter(({ effort }) => reasoning.has(effort))
       : model.supported_reasoning_levels,
   };
@@ -111,17 +121,18 @@ function catalogModelForCopilot(model, copilotModels, { filterReasoning = false
 }
 
 function compatibilityModel(codexCatalog, slug) {
-  const astra = codexCatalog.models.find((model) => model.slug === CODEX_GPT6_MODEL);
+  const isGpt61Sol = slug === "gpt-6.1-sol";
+  const template = codexCatalog.models.find((model) => model.slug === (isGpt61Sol ? "gpt-6-sol" : CODEX_GPT6_MODEL));
   const spec = GPT6_COMPATIBILITY_SPECS.get(slug);
-  if (!astra || !spec) return null;
+  if (!template || !spec || (isGpt61Sol && !Array.isArray(template.supported_reasoning_levels))) return null;
   return {
-    ...structuredClone(astra),
+    ...structuredClone(template),
     ...spec,
     slug,
     supports_parallel_tool_calls: true,
-    multi_agent_reasoning_effort: null,
+    multi_agent_reasoning_effort: isGpt61Sol ? "xhigh" : null,
     supports_experimental_context: false,
-    minimal_client_version: "0.155.0",
+    minimal_client_version: isGpt61Sol ? "0.158.0" : "0.155.0",
   };
 }
 
@@ -141,7 +152,7 @@ export function buildCodexModelResponse({ copilotModels, codexCatalog } = {}) {
   const models = codexCatalog.models.map((model) => {
     if (!MANAGED_GPT6_MODELS.has(model.slug)) return model;
     if (!isEligibleCopilotGpt6(copilotModels, model.slug)) return { ...model, visibility: "hide" };
-    return catalogModelForCopilot(model, copilotModels);
+    return catalogModelForCopilot(model, copilotModels, { filterReasoning: model.slug === "gpt-6.1-sol" });
   });
   for (const slug of GPT6_COMPATIBILITY_SPECS.keys()) {
     if (bundledSlugs.has(slug) || !isEligibleCopilotGpt6(copilotModels, slug)) continue;

package/src/dashboard/index.html

@@ -63,7 +63,8 @@
         <section class="panel dashboard-section" aria-label="Usage by model">
           <div class="panel-heading"><h2>USAGE</h2><div class="heading-actions"><span id="usage-state">READING LOG</span><button id="refresh-usage" type="button">Refresh</button></div></div>
           <p id="usage-note" class="table-note">Aggregating local usage metadata…</p>
-          <div class="table-wrap"><table class="usage-table"><thead><tr><th scope="col">MODEL</th><th scope="col">CALLS</th><th scope="col">INPUT</th><th scope="col">CACHE READ</th><th scope="col">OUTPUT</th><th scope="col">TOTAL</th></tr></thead><tbody id="usage-body"><tr><td colspan="6">Loading…</td></tr></tbody></table></div>
+          <div class="table-wrap"><table class="usage-table"><thead><tr><th scope="col">MODEL</th><th scope="col">CALLS</th><th scope="col">INPUT</th><th scope="col">CACHE READ</th><th scope="col">OUTPUT</th><th scope="col">TOTAL</th><th scope="col">CACHE HIT</th></tr></thead><tbody id="usage-body"><tr><td colspan="7">Loading…</td></tr></tbody></table></div>
+          <p class="hint">Cache hit = cached / input tokens. — = incomplete usage data or no input tokens.</p>
         </section>
 
         <section class="lower" aria-label="Recent failures">

package/src/dashboard/ui.js

@@ -308,7 +308,9 @@ async function loadModels() {
 }
 
 function usageValues(row) {
-  return [row.model, number(row.requests), number(row.input_tokens), number(row.cache_read_tokens), number(row.output_tokens), number(row.total_tokens)];
+  const rate = Number.isFinite(row.cache_hit_rate) && row.cache_hit_rate >= 0 && row.cache_hit_rate <= 1
+    ? `${(row.cache_hit_rate * 100).toFixed(1)}%` : "—";
+  return [row.model, number(row.requests), number(row.input_tokens), number(row.cache_read_tokens), number(row.output_tokens), number(row.total_tokens), rate];
 }
 
 async function loadUsage() {
@@ -316,7 +318,7 @@ async function loadUsage() {
   button.disabled = true;
   text("usage-state", "READING LOG");
   text("usage-note", "Aggregating local usage metadata…");
-  emptyTable("usage-body", 6, "Loading…");
+  emptyTable("usage-body", 7, "Loading…");
   try {
     const response = await fetch("/_ccdx/ui/usage", { cache: "no-store", headers: { "X-CCDX-Dashboard": "1" }, signal: AbortSignal.timeout(15000) });
     const data = await response.json();
@@ -327,14 +329,14 @@ async function loadUsage() {
       body.append(tableRow(usageValues(data.total), { total: true }));
       for (const row of data.rows) body.append(tableRow(usageValues(row)));
     } else {
-      emptyTable("usage-body", 6, "No usage records.");
+      emptyTable("usage-body", 7, "No usage records.");
     }
     text("usage-state", "LOCAL LOG");
     text("usage-note", `${number(data.total.requests)} records / ${number(data.rows.length)} of ${number(data.model_count)} models shown`);
   } catch (error) {
     text("usage-state", "LOG UNAVAILABLE");
     text("usage-note", String(error.message || error).slice(0, 180));
-    emptyTable("usage-body", 6, "No usage summary available.");
+    emptyTable("usage-body", 7, "No usage summary available.");
   } finally {
     button.disabled = false;
   }

package/src/dashboard-api.mjs

@@ -9,7 +9,7 @@ import {
   renderTerminalAnimationFrame,
   TERMINAL_ANIMATION_THEMES,
 } from "./terminal-animation.mjs";
-import { summarizeUsageLogs } from "./usage.mjs";
+import { cacheReadTokens, summarizeUsageLogs, usageCacheHitRate } from "./usage.mjs";
 import { readUserSettings, terminalAnimationPreference, writeTerminalAnimationTheme } from "./user-settings.mjs";
 
 const ANIMATION_PATH = "/_ccdx/ui/animation";
@@ -79,17 +79,13 @@ function finite(value) {
   return Number.isFinite(value) ? Math.max(0, value) : null;
 }
 
-function cacheReadTokens(usage = {}) {
-  const values = [usage.cache_read_input_tokens, usage.cached_input_tokens].filter(Number.isFinite);
-  return values.length ? values.reduce((sum, value) => sum + value, 0) : null;
-}
-
 function usageRow(model, values) {
   return {
     model: safeText(model, 100),
     requests: finite(values.requests),
     input_tokens: finite(values.input_tokens),
-    cache_read_tokens: cacheReadTokens(values),
+    cache_read_tokens: cacheReadTokens(values) ?? null,
+    cache_hit_rate: usageCacheHitRate(values),
     output_tokens: finite(values.output_tokens),
     total_tokens: finite(values.total_tokens),
   };

package/src/usage.mjs

@@ -54,9 +54,10 @@ function hasPositiveTokenValue(usage) {
 
 function normalizeResponsesUsage(usage) {
   if (!usage || typeof usage !== "object") return undefined;
+  const cachedInput = numberOrUndefined(usage.cached_input_tokens ?? usage.input_tokens_details?.cached_tokens);
   const out = compactObject({
     input_tokens: positiveNumber(usage.input_tokens),
-    cached_input_tokens: positiveNumber(usage.cached_input_tokens ?? usage.input_tokens_details?.cached_tokens),
+    cached_input_tokens: cachedInput >= 0 ? cachedInput : undefined,
     output_tokens: positiveNumber(usage.output_tokens),
     reasoning_output_tokens: positiveNumber(usage.reasoning_output_tokens ?? usage.output_tokens_details?.reasoning_tokens),
     total_tokens: positiveNumber(usage.total_tokens),
@@ -251,7 +252,7 @@ export async function readUsageRecords(filePath = usageLogPath(), { warn = conso
 }
 
 function addUsageTotals(target, usage = {}) {
-  for (const [key, value] of Object.entries(usage)) {
+  for (const [key, value] of Object.entries(usage || {})) {
     if (Number.isFinite(value)) target[key] = (target[key] || 0) + value;
   }
 }
@@ -270,6 +271,12 @@ export function summarizeUsage(records) {
     const modelTotals = summary.byModel[model];
     modelTotals.requests += 1;
     addUsageTotals(modelTotals, record.usage);
+    const input = record.usage?.input_tokens;
+    const cached = cacheReadTokens(record.usage || {});
+    if (!Number.isFinite(input) || input < 0 || !Number.isFinite(cached) || cached < 0 || cached > input) {
+      summary.totals.cache_hit_unknown_requests = (summary.totals.cache_hit_unknown_requests || 0) + 1;
+      modelTotals.cache_hit_unknown_requests = (modelTotals.cache_hit_unknown_requests || 0) + 1;
+    }
   }
   return summary;
 }
@@ -298,13 +305,26 @@ function tableNumber(n) {
   return Number.isFinite(n) ? n.toLocaleString("en-US") : undefined;
 }
 
-function cacheReadTokens(usage = {}) {
+export function cacheReadTokens(usage = {}) {
   const values = [usage.cache_read_input_tokens, usage.cached_input_tokens]
     .filter((value) => Number.isFinite(value));
   const value = values.length > 0 ? values.reduce((total, current) => total + current, 0) : undefined;
   return Number.isFinite(value) ? value : undefined;
 }
 
+export function usageCacheHitRate(usage = {}) {
+  const input = usage.input_tokens;
+  const cached = cacheReadTokens(usage);
+  if (usage.cache_hit_unknown_requests > 0 || !Number.isFinite(input) || input <= 0
+    || !Number.isFinite(cached) || cached < 0 || cached > input) return null;
+  return cached / input;
+}
+
+function cacheHitPercent(usage) {
+  const rate = usageCacheHitRate(usage);
+  return rate === null ? "—" : `${(rate * 100).toFixed(1)}%`;
+}
+
 function formatPlainUsageSummary(summary, filePath, { sanitize = false } = {}) {
   const lines = [`Usage log: ${filePath}`];
   if (summary.requests === 0) {
@@ -314,11 +334,12 @@ function formatPlainUsageSummary(summary, filePath, { sanitize = false } = {}) {
   lines.push(
     `Requests: ${fmt(summary.requests)}`,
     `Tokens: input=${fmt(summary.totals.input_tokens)} cache_read=${fmt(cacheReadTokens(summary.totals))} output=${fmt(summary.totals.output_tokens)} total=${fmt(summary.totals.total_tokens)}`,
+    `Cache hit: ${cacheHitPercent(summary.totals)} (cached/input tokens)`,
     "",
     "By model:",
   );
   for (const [model, row] of Object.entries(summary.byModel)) {
-    lines.push(`  ${model}: requests=${fmt(row.requests)} input=${fmt(row.input_tokens)} cache_read=${fmt(cacheReadTokens(row))} output=${fmt(row.output_tokens)} total=${fmt(row.total_tokens)}`);
+    lines.push(`  ${model}: requests=${fmt(row.requests)} input=${fmt(row.input_tokens)} cache_read=${fmt(cacheReadTokens(row))} output=${fmt(row.output_tokens)} total=${fmt(row.total_tokens)} cache_hit=${cacheHitPercent(row)}`);
   }
   return (sanitize ? lines.map((line) => terminalCell(line, { fallback: "" })) : lines).join("\n");
 }
@@ -338,11 +359,12 @@ function usageTableRow(model, usage) {
     cacheRead: tableNumber(cacheReadTokens(usage)),
     output: tableNumber(usage.output_tokens),
     total: tableNumber(usage.total_tokens),
+    cacheHit: cacheHitPercent(usage),
   };
 }
 
 function usageDetailLine(model, usage) {
-  return `${terminalCell(model)}: input=${fmt(usage.input_tokens)} cache_read=${fmt(cacheReadTokens(usage))} output=${fmt(usage.output_tokens)}`;
+  return `${terminalCell(model)}: input=${fmt(usage.input_tokens)} cache_read=${fmt(cacheReadTokens(usage))} output=${fmt(usage.output_tokens)} cache_hit=${cacheHitPercent(usage)}`;
 }
 
 function formatTableUsageSummary(summary, filePath, output) {
@@ -362,13 +384,19 @@ function formatTableUsageSummary(summary, filePath, output) {
     .sort(compareModelUsage);
   const totalUsage = { requests: summary.requests, ...summary.totals };
   const rows = [usageTableRow("TOTAL", totalUsage), ...modelUsage.map(({ model, row }) => usageTableRow(model, row))];
-  const table = formatResponsiveCliTable({
-    columns,
-    compactColumns,
+  let table = formatResponsiveCliTable({
+    columns: [...columns, { key: "cacheHit", label: "HIT %", align: "right" }],
+    compactColumns: columns,
     rows,
     width: cliOutputWidth(output),
     gap: 1,
   });
+  const rateFits = !table.compact;
+  if (table.overflow) {
+    table = formatResponsiveCliTable({ columns, compactColumns, rows, width: cliOutputWidth(output), gap: 1 });
+  } else {
+    table.compact = false;
+  }
   const lines = [`Usage log: ${safePath}`, "", table.output];
   if (table.compact) {
     lines.push(
@@ -377,6 +405,10 @@ function formatTableUsageSummary(summary, filePath, output) {
       usageDetailLine("TOTAL", totalUsage),
       ...modelUsage.map(({ model, row }) => usageDetailLine(model, row)),
     );
+  } else if (!rateFits) {
+    lines.push("", "Cache hit (cached/input tokens):",
+      `TOTAL: ${cacheHitPercent(totalUsage)}`,
+      ...modelUsage.map(({ model, row }) => `${terminalCell(model)}: ${cacheHitPercent(row)}`));
   }
   return { output: lines.join("\n"), overflow: table.overflow };
 }