@narumitw/pi-usage 0.64.3 → 0.65.1

package/dist/index.ts

@@ -47,23 +47,17 @@ import {
   runWithConcurrency,
   sanitizeDisplayText,
   usageAdapters
-} from "./chunks/chunk-ACPQJ2CM.ts";
+} from "./chunks/chunk-N2ZD5X4K.ts";
 
 // src/codex-fast.ts
 import { calculateCost, hasApi } from "@earendil-works/pi-ai";
 var CODEX_FAST_SERVICE_TIER = "priority";
 var CODEX_STANDARD_SERVICE_TIER = "default";
-var CODEX_FAST_MODEL_IDS = /* @__PURE__ */ new Set([
-  "gpt-5.5",
-  "gpt-5.6-luna",
-  "gpt-5.6-sol",
-  "gpt-5.6-terra",
-  "gpt-6-astra",
-  "gpt-6-luna",
-  "gpt-6-sol",
-  "gpt-6.1-sol"
-]);
-function codexFastAvailability(model, enabled) {
+var UNKNOWN_CODEX_FAST_CAPABILITY = {
+  kind: "unknown",
+  reason: "Codex Fast capability information has not been fetched."
+};
+function codexFastAvailability(model, enabled, capability = UNKNOWN_CODEX_FAST_CAPABILITY) {
   if (model?.provider !== "openai-codex") return { kind: "not-codex" };
   if (!isOfficialCodexModel(model)) {
     return {
@@ -71,7 +65,8 @@ function codexFastAvailability(model, enabled) {
       reason: "Fast mode requires the official OpenAI Codex Responses endpoint."
     };
   }
-  if (!CODEX_FAST_MODEL_IDS.has(model.id)) {
+  if (capability.kind === "unknown") return capability;
+  if (capability.kind === "unsupported") {
     return {
       kind: "unavailable",
       reason: `${model.id} does not advertise Codex Fast support.`
@@ -79,20 +74,20 @@ function codexFastAvailability(model, enabled) {
   }
   return { kind: "available", enabled };
 }
-function codexFastIsEffective(model, enabled) {
-  return codexFastAvailability(model, enabled).kind === "available" && enabled;
+function codexFastIsEffective(model, enabled, capability = UNKNOWN_CODEX_FAST_CAPABILITY) {
+  return codexFastAvailability(model, enabled, capability).kind === "available" && enabled;
 }
-function codexFastRequestTier(model, enabled) {
+function codexFastRequestTier(model, enabled, capability = UNKNOWN_CODEX_FAST_CAPABILITY) {
   if (!isOfficialCodexModel(model)) return void 0;
-  return enabled && CODEX_FAST_MODEL_IDS.has(model.id) ? CODEX_FAST_SERVICE_TIER : CODEX_STANDARD_SERVICE_TIER;
+  return enabled && capability.kind === "supported" ? CODEX_FAST_SERVICE_TIER : CODEX_STANDARD_SERVICE_TIER;
 }
-function rewriteCodexFastPayload(payload, model, enabled) {
-  const serviceTier = codexFastRequestTier(model, enabled);
+function rewriteCodexFastPayload(payload, model, enabled, capability = UNKNOWN_CODEX_FAST_CAPABILITY) {
+  const serviceTier = codexFastRequestTier(model, enabled, capability);
   if (!serviceTier || !isRecord(payload)) return void 0;
   return { ...payload, service_tier: serviceTier };
 }
-function correctCodexFastMessageCost(message, model, fastRequested) {
-  if (!codexFastIsEffective(model, fastRequested) || !isRecord(message) || message.role !== "assistant" || message.provider !== model?.provider || message.model !== model?.id) {
+function correctCodexFastMessageCost(message, model, fastRequested, capability = UNKNOWN_CODEX_FAST_CAPABILITY) {
+  if (!codexFastIsEffective(model, fastRequested, capability) || !isRecord(message) || message.role !== "assistant" || message.provider !== model?.provider || message.model !== model?.id) {
     return void 0;
   }
   const usage = isRecord(message.usage) ? message.usage : void 0;
@@ -426,6 +421,14 @@ function formatUsageReport(report, displayState) {
   return lines.join("\n").trimEnd();
 }
 function formatUsageStatusline(report, model, now = Date.now(), showCodexResetCountdown = true, codexStatusPercentage = "remaining") {
+  return formatUsageStatuslineWithCountdown(report, model, now, showCodexResetCountdown, codexStatusPercentage).value;
+}
+function formatUsageStatuslineWithCountdown(report, model, now = Date.now(), showCodexResetCountdown = true, codexStatusPercentage = "remaining") {
+  const countdown = { now, active: false };
+  const value = formatStatusline(report, model, now, showCodexResetCountdown, codexStatusPercentage, countdown);
+  return { value, hasCountdown: countdown.active };
+}
+function formatStatusline(report, model, now, showCodexResetCountdown, codexStatusPercentage, countdown) {
   if (report.providerId === "openai" && report.source === "openai-chatgpt-auth") return "chatgpt usage: web only";
   if (report.source === "openai-chatgpt-companion") {
     const windows = report.buckets.filter((bucket) => bucket.groupId === "chatgpt-plan").map((bucket) => {
@@ -442,24 +445,24 @@ function formatUsageStatusline(report, model, now = Date.now(), showCodexResetCo
   if (report.providerId === "deepseek") return formatDeepSeekStatusline(report);
   if (report.providerId === "fireworks") return formatFireworksStatusline(report);
   if (report.providerId === "vercel-ai-gateway") return formatVercelAIGatewayStatusline(report);
-  if (report.providerId === "github-copilot") return formatGitHubCopilotStatusline(report);
+  if (report.providerId === "github-copilot") return formatGitHubCopilotStatusline(report, countdown);
   if (report.providerId === "openrouter") {
     const limit = report.buckets.find((bucket) => bucket.id === "key-limit");
     if (limit?.remaining !== void 0) return `openrouter ${formatUsd(limit.remaining)} left`;
     const total = report.metrics.find((metric) => metric.id === "usage-total");
     if (typeof total?.value === "number") return `openrouter ${formatUsd(total.value)} used`;
   }
-  if (report.providerId === "opencode-go") return formatOpenCodeZenStatusline(report);
-  if (report.providerId === "command-code") return formatCommandCodeStatusline(report);
-  if (report.providerId === "kimi-coding") return formatKimiCodingStatusline(report);
+  if (report.providerId === "opencode-go") return formatOpenCodeZenStatusline(report, countdown);
+  if (report.providerId === "command-code") return formatCommandCodeStatusline(report, countdown);
+  if (report.providerId === "kimi-coding") return formatKimiCodingStatusline(report, countdown);
   if (report.providerId === "moonshotai" || report.providerId === "moonshotai-cn") {
     return formatMoonshotStatusline(report);
   }
   if (report.providerId === "minimax" || report.providerId === "minimax-cn") {
-    return formatMiniMaxStatusline(report, model);
+    return formatMiniMaxStatusline(report, countdown, model);
   }
   if (report.providerId === "zai" || report.providerId === "zai-coding-cn") {
-    return formatZaiStatusline(report);
+    return formatZaiStatusline(report, countdown);
   }
   return void 0;
 }
@@ -577,7 +580,7 @@ function formatGitHubCopilotReport(lines, report) {
     lines.push(`${"Additional usage:".padEnd(VALUE_COLUMN)}${overage.value} ${quota.label}`);
   }
 }
-function formatGitHubCopilotStatusline(report) {
+function formatGitHubCopilotStatusline(report, countdown) {
   const quota = findGitHubCopilotQuota(report);
   const kind = compactGitHubCopilotQuotaKind(quota);
   if (!quota || quota.limit === void 0 || quota.remaining === void 0) {
@@ -585,7 +588,8 @@ function formatGitHubCopilotStatusline(report) {
   }
   const overage = report.metrics.find((metric) => metric.id === "overage-used");
   const overageSuffix = typeof overage?.value === "number" && overage.value > 0 ? ` +${overage.value} over` : "";
-  return `copilot ${kind === "premium" ? "" : `${kind} `}${quota.remaining}/${quota.limit} ${percentRemaining(quota)}%${overageSuffix}`;
+  const reset = formatQuotaCountdown(quota, countdown);
+  return `copilot ${kind === "premium" ? "" : `${kind} `}${quota.remaining}/${quota.limit} ${percentRemaining(quota)}%${overageSuffix}${reset ? ` \u21BB ${reset}` : ""}`;
 }
 function findGitHubCopilotQuota(report) {
   return report.buckets.find((bucket) => ["ai-credits", "premium-requests", "chat-requests"].includes(bucket.id));
@@ -621,14 +625,14 @@ function formatOpenCodeZenReport(lines, report) {
     lines.push(`${`${bucket.label}:`.padEnd(VALUE_COLUMN)}${used}% used${reset}`);
   }
 }
-function formatOpenCodeZenStatusline(report) {
-  const parts = ["zen"];
+function formatOpenCodeZenStatusline(report, countdown) {
+  const parts = [];
   for (const bucket of report.buckets) {
     if (bucket.used === void 0) continue;
     const compact = bucket.id === "rolling" ? "r" : bucket.id === "weekly" ? "w" : "m";
-    parts.push(`${clampPercent(bucket.used).toFixed(0)}% ${compact}`);
+    parts.push(formatQuotaWindow(bucket, `${clampPercent(bucket.used).toFixed(0)}%`, compact, countdown));
   }
-  return parts.length > 1 ? parts.join(" ") : void 0;
+  return parts.length > 0 ? `zen ${parts.join(" \xB7 ")}` : void 0;
 }
 function formatCommandCodeReport(lines, report) {
   for (const bucket of report.buckets) {
@@ -645,8 +649,8 @@ function formatCommandCodeReport(lines, report) {
     lines.push(`${`${metric.label}:`.padEnd(VALUE_COLUMN)}${formatMetricValue(metric.value, metric.unit)}`);
   }
 }
-function formatCommandCodeStatusline(report) {
-  const parts = ["cmd"];
+function formatCommandCodeStatusline(report, countdown) {
+  const parts = [];
   for (const [id, label] of [
     ["five-hour", "5h"],
     ["weekly", "wk"],
@@ -654,9 +658,9 @@ function formatCommandCodeStatusline(report) {
   ]) {
     const bucket = report.buckets.find((candidate) => candidate.id === id);
     if (bucket?.unit !== "usd" || bucket.limit === void 0 || bucket.remaining === void 0) continue;
-    parts.push(`${percentRemaining(bucket)}% ${label}`);
+    parts.push(formatQuotaWindow(bucket, `${percentRemaining(bucket)}%`, label, countdown));
   }
-  return parts.length > 1 ? parts.join(" ") : void 0;
+  return parts.length > 0 ? `cmd ${parts.join(" \xB7 ")}` : void 0;
 }
 function formatKimiCodingReport(lines, report) {
   for (const bucket of report.buckets) {
@@ -692,7 +696,7 @@ function formatKimiCodingReport(lines, report) {
     lines.push(`${"Monthly limit:".padEnd(VALUE_COLUMN)}${formatCurrencyMetric(monthlyLimit)}`);
   }
 }
-function formatKimiCodingStatusline(report) {
+function formatKimiCodingStatusline(report, countdown) {
   const fiveHour = report.buckets.find((bucket) => bucket.id === "five-hour");
   const weekly = report.buckets.find((bucket) => bucket.id === "weekly");
   const monthly = report.buckets.find((bucket) => bucket.id === "monthly");
@@ -700,15 +704,15 @@ function formatKimiCodingStatusline(report) {
   const selected = [subWindow, weekly, monthly].filter(
     (bucket, index, buckets) => bucket !== void 0 && buckets.indexOf(bucket) === index
   );
-  const parts = ["kimi"];
+  const parts = [];
   for (const bucket of selected) {
     if (bucket.remaining === void 0 || bucket.unit !== "percent" && !bucket.limit) continue;
     const fallback = bucket.id === "weekly" ? "weekly" : "5h";
     const window = bucket.id === "monthly" ? "mo" : formatWindowLabel(bucket.windowMinutes, fallback, true);
     const remaining = bucket.unit === "percent" ? Math.round(clampPercent(bucket.remaining)) : percentRemaining(bucket);
-    parts.push(`${remaining}% ${window}`);
+    parts.push(formatQuotaWindow(bucket, `${remaining}%`, window, countdown));
   }
-  return parts.length > 1 ? parts.join(" ") : void 0;
+  return parts.length > 0 ? `kimi ${parts.join(" \xB7 ")}` : void 0;
 }
 function formatMoonshotReport(lines, report) {
   for (const metric of report.metrics) {
@@ -736,7 +740,7 @@ function formatMiniMaxReport(lines, report) {
     lines.push(`${`${bucket.label}:`.padEnd(VALUE_COLUMN)}${value}`);
   }
 }
-function formatMiniMaxStatusline(report, model) {
+function formatMiniMaxStatusline(report, countdown, model) {
   const prefix = report.providerId === "minimax-cn" ? "minimax cn" : "minimax";
   if (report.source === "minimax-account-balance") {
     const available = report.metrics.find((metric) => metric.id === "available-balance");
@@ -745,22 +749,22 @@ function formatMiniMaxStatusline(report, model) {
   const selectedGroup = selectMiniMaxGroup(report, model);
   if (!selectedGroup) return void 0;
   const selected = report.buckets.filter((bucket) => bucket.groupId === selectedGroup);
-  const parts = [prefix];
+  const parts = [];
   for (const bucket of selected) {
     const fallback = bucket.id.endsWith(":weekly") ? "weekly" : "5h";
     const window = formatWindowLabel(bucket.windowMinutes, fallback, true);
     if (bucket.period === "unlimited") {
-      parts.push(`unlimited ${window}`);
+      parts.push(`${window}:unlimited`);
       continue;
     }
     if (bucket.unit === "percent" && bucket.remaining !== void 0) {
-      parts.push(`${bucket.remaining}% ${window}`);
+      parts.push(formatQuotaWindow(bucket, `${bucket.remaining}%`, window, countdown));
       continue;
     }
     if (bucket.limit === void 0 || bucket.remaining === void 0) continue;
-    parts.push(`${percentRemaining(bucket)}% ${window}`);
+    parts.push(formatQuotaWindow(bucket, `${percentRemaining(bucket)}%`, window, countdown));
   }
-  return parts.length > 1 ? parts.join(" ") : void 0;
+  return parts.length > 0 ? `${prefix} ${parts.join(" \xB7 ")}` : void 0;
 }
 function selectMiniMaxGroup(report, model) {
   const groups = [
@@ -802,18 +806,25 @@ function wildcardKeyMatches(pattern, value) {
   const last = segments.at(-1);
   return pattern.endsWith("*") || last !== void 0 && value.endsWith(last);
 }
-function formatZaiStatusline(report) {
+function formatZaiStatusline(report, countdown) {
   const selected = [
     report.buckets.find((bucket) => bucket.id === "five-hour"),
     report.buckets.find((bucket) => bucket.id === "weekly")
   ];
-  const parts = ["zai"];
+  const parts = [];
   for (const bucket of selected) {
     if (!bucket?.limit || bucket.remaining === void 0) continue;
     const fallback = bucket.id === "weekly" ? "weekly" : "5h";
-    parts.push(`${percentRemaining(bucket)}% ${formatWindowLabel(bucket.windowMinutes, fallback, true)}`);
+    parts.push(
+      formatQuotaWindow(
+        bucket,
+        `${percentRemaining(bucket)}%`,
+        formatWindowLabel(bucket.windowMinutes, fallback, true),
+        countdown
+      )
+    );
   }
-  return parts.length > 1 ? parts.join(" ") : void 0;
+  return parts.length > 0 ? `zai ${parts.join(" \xB7 ")}` : void 0;
 }
 function formatCurrencyMetric(metric) {
   if (typeof metric.value !== "number") return String(metric.value);
@@ -896,7 +907,8 @@ function formatCodexStatusline(report, model, now = Date.now(), showResetCountdo
   if (!group) return formatCodexCreditsStatus(report);
   const buckets = report.buckets.filter((bucket) => (bucket.groupId ?? bucket.id) === group);
   const labelBucket = buckets[0];
-  const parts = [group === "codex" ? "codex" : `codex ${compactLimitLabel(labelBucket?.groupLabel ?? group)}`];
+  const prefix = group === "codex" ? "codex" : `codex ${compactLimitLabel(labelBucket?.groupLabel ?? group)}`;
+  const parts = [];
   for (const bucket of buckets) {
     if (bucket.remaining === void 0) continue;
     const displayedPercentage = percentage === "used" ? bucket.used ?? 100 - bucket.remaining : bucket.remaining;
@@ -904,13 +916,13 @@ function formatCodexStatusline(report, model, now = Date.now(), showResetCountdo
     const fallback = bucket.id.endsWith(":secondary") ? "weekly" : "5h";
     const window = formatWindowLabel(bucket.windowMinutes, fallback, true);
     if (!showResetCountdown) {
-      parts.push(`${percent} ${window}`);
+      parts.push(`${window}:${percent}`);
       continue;
     }
     const reset = formatResetCountdown(bucket.resetsAt, now);
-    parts.push(`${percent} ${reset ? `\u21BB ${reset}` : window}`);
+    parts.push(reset ? `${percent} \u21BB ${reset}` : `${window}:${percent}`);
   }
-  return parts.length > 1 ? parts.join(" ") : formatCodexCreditsStatus(report);
+  return parts.length > 0 ? `${prefix} ${parts.join(" \xB7 ")}` : formatCodexCreditsStatus(report);
 }
 function formatCodexCreditsStatus(report) {
   const credits = report.metrics.find((metric) => metric.id === "credits");
@@ -989,6 +1001,17 @@ function formatWindowLabel(minutes, fallback, compact) {
   if (minutes % 60 === 0) return `${minutes / 60}h`;
   return `${minutes}m`;
 }
+function formatQuotaWindow(bucket, percent, window, countdown) {
+  const reset = formatQuotaCountdown(bucket, countdown);
+  return reset ? `${percent} \u21BB ${reset}` : `${window}:${percent}`;
+}
+function formatQuotaCountdown(bucket, countdown) {
+  if (bucket.period === "unlimited" || bucket.resetsAt === void 0 || !Number.isFinite(bucket.resetsAt * 1e3) || !Number.isFinite(countdown.now) || bucket.resetsAt * 1e3 <= countdown.now)
+    return void 0;
+  const reset = formatResetCountdown(bucket.resetsAt, countdown.now);
+  if (reset !== void 0) countdown.active = true;
+  return reset;
+}
 function formatResetCountdown(resetsAt, now) {
   if (resetsAt === void 0 || !Number.isFinite(resetsAt) || !Number.isFinite(now)) return void 0;
   const totalMinutes = Math.max(0, Math.ceil((resetsAt * 1e3 - now) / 6e4));
@@ -1289,6 +1312,231 @@ function isProviderId(value) {
 // src/usage.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 
+// src/codex-fast-catalog.ts
+import { VERSION } from "@earendil-works/pi-coding-agent";
+
+// src/usage-helpers.ts
+function configuredAdapters(ctx) {
+  return usageAdapters().filter(
+    (adapter) => adapter.id === ctx.model?.provider || providerIsConfigured(ctx, adapter.id)
+  );
+}
+function providerDisplayName(ctx, providerId) {
+  try {
+    return sanitizeDisplayText(ctx.modelRegistry.getProviderDisplayName(providerId), 80);
+  } catch {
+    return sanitizeDisplayText(providerId, 80);
+  }
+}
+function setBoundedMap(map, key, value, limit) {
+  map.delete(key);
+  while (map.size >= limit) {
+    const oldest = map.keys().next().value;
+    if (oldest === void 0) break;
+    map.delete(oldest);
+  }
+  map.set(key, value);
+}
+function modelIdentity(model) {
+  return model ? `${model.provider}/${model.id}` : void 0;
+}
+function isAbortError(error) {
+  return error instanceof Error && error.name === "AbortError";
+}
+function isTimeoutError(error) {
+  return error instanceof Error && error.name === "TimeoutError";
+}
+
+// src/codex-fast-catalog.ts
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+var FAILURE_BACKOFF_MS = 3e4;
+var MAX_ACCOUNT_STATES = 32;
+var MAX_DIRECTORY_BODY_BYTES = 8 * 1024 * 1024;
+var DIRECTORY_URL = new URL("https://chatgpt.com/backend-api/codex/models");
+DIRECTORY_URL.searchParams.set("client_version", VERSION);
+function createCodexFastCatalog(options = {}) {
+  const accounts = /* @__PURE__ */ new Map();
+  const requests = /* @__PURE__ */ new Map();
+  const latestRequests = /* @__PURE__ */ new Map();
+  const timeoutMs = options.timeoutMs ?? 15e3;
+  let requestSequence = 0;
+  let identitySequence = 0;
+  let generation = 0;
+  let active;
+  let issue = UNKNOWN_CODEX_FAST_CAPABILITY.reason;
+  const current = (scope, ctx, signal) => !signal.aborted && generation === scope.generation && active?.key === scope.key && active.fingerprint === scope.fingerprint && active.model === scope.model && active.session === scope.session && modelIdentity2(ctx.model) === scope.model && ctx.sessionManager.getSessionId() === scope.session;
+  const capability = (model, key = active?.key) => {
+    const entry = key ? accounts.get(key) : void 0;
+    const supported = model ? entry?.models?.get(model.id) : void 0;
+    if (supported !== void 0) return { kind: supported ? "supported" : "unsupported" };
+    return {
+      kind: "unknown",
+      reason: entry?.issue ?? (entry?.models && model ? `The Codex model directory has no Fast capability information for ${model.id}.` : issue)
+    };
+  };
+  const identify = async (ctx, signal) => {
+    const identity = ++identitySequence;
+    const owner = generation;
+    const model = modelIdentity2(ctx.model);
+    const session = ctx.sessionManager.getSessionId();
+    if (!isOfficialCodexModel(ctx.model)) {
+      active = void 0;
+      return void 0;
+    }
+    try {
+      const auth = await awaitWithDeadline(
+        resolveCodexResetAuth(ctx, void 0, options.credentialReader, options.candidateReader),
+        signal,
+        timeoutMs,
+        "resolving the current Codex model-directory account"
+      );
+      if (signal.aborted || owner !== generation || identity !== identitySequence || modelIdentity2(ctx.model) !== model || ctx.sessionManager.getSessionId() !== session) {
+        return void 0;
+      }
+      const accountId = auth.headers["chatgpt-account-id"];
+      if (!accountId) throw new Error("The active Codex account ID is unavailable.");
+      const scope = {
+        key: fingerprintResolvedAuth({ headers: { "chatgpt-account-id": accountId } }, AUTH_FINGERPRINT_SALT),
+        fingerprint: auth.fingerprint,
+        model,
+        session,
+        generation: owner
+      };
+      const changed = active?.key !== scope.key;
+      active = scope;
+      issue = "Codex Fast capability information has not been fetched for this account.";
+      if (changed) options.onChanged?.(ctx);
+      return { auth, scope };
+    } catch (error) {
+      if (signal.aborted || owner !== generation || identity !== identitySequence) return void 0;
+      active = void 0;
+      issue = `Codex Fast capability is unknown: ${redactUsageError(errorMessage(error))}`;
+      options.onChanged?.(ctx);
+      return void 0;
+    }
+  };
+  const load = async (ctx, auth, scope, signal, force) => {
+    const entry = accounts.get(scope.key);
+    if (!force && (entry?.models && entry.fingerprint === auth.fingerprint && Date.now() - entry.fetchedAt < CACHE_TTL_MS || entry?.retryAt && Date.now() < entry.retryAt)) {
+      return;
+    }
+    const before = capability(ctx.model, scope.key);
+    const existing = requests.get(auth.fingerprint);
+    let promise = existing?.promise;
+    if (!promise) {
+      const sequence = ++requestSequence;
+      latestRequests.set(scope.key, sequence);
+      const controller = new AbortController();
+      const combined = AbortSignal.any([signal, controller.signal]);
+      let status;
+      promise = (async () => {
+        try {
+          const payload = await fetchProviderJson(
+            DIRECTORY_URL.href,
+            auth,
+            combined,
+            timeoutMs,
+            "Codex model directory",
+            {
+              redirect: "error",
+              maxSuccessBodyBytes: MAX_DIRECTORY_BODY_BYTES,
+              responseError: (responseStatus) => {
+                status = responseStatus;
+                return void 0;
+              }
+            }
+          );
+          const models = normalizeDirectory(payload);
+          if (combined.aborted || scope.generation !== generation || latestRequests.get(scope.key) !== sequence) return;
+          setBoundedMap(
+            accounts,
+            scope.key,
+            { models, fetchedAt: Date.now(), fingerprint: auth.fingerprint },
+            MAX_ACCOUNT_STATES
+          );
+        } catch (error) {
+          if (combined.aborted || scope.generation !== generation || latestRequests.get(scope.key) !== sequence) return;
+          const previous = accounts.get(scope.key);
+          const transient = status === void 0 || status >= 500 || status === 429;
+          setBoundedMap(
+            accounts,
+            scope.key,
+            {
+              ...transient && previous?.models ? previous : { fetchedAt: 0 },
+              retryAt: Date.now() + FAILURE_BACKOFF_MS,
+              issue: `Codex Fast capability is unknown: ${redactUsageError(errorMessage(error), auth.secrets)}`
+            },
+            MAX_ACCOUNT_STATES
+          );
+        } finally {
+          if (requests.get(auth.fingerprint)?.controller === controller) requests.delete(auth.fingerprint);
+          if (latestRequests.get(scope.key) === sequence) latestRequests.delete(scope.key);
+        }
+      })();
+      requests.set(auth.fingerprint, { controller, promise });
+    }
+    try {
+      await awaitWithDeadline(promise, signal, timeoutMs, "fetching the Codex model directory");
+    } catch (error) {
+      if (signal.aborted) return;
+      throw error;
+    }
+    const after = capability(ctx.model, scope.key);
+    if (current(scope, ctx, signal) && JSON.stringify(before) !== JSON.stringify(after)) options.onChanged?.(ctx);
+  };
+  return {
+    get(model) {
+      return capability(model);
+    },
+    async read(ctx, signal, refresh = false, force = false) {
+      const resolved = await identify(ctx, signal);
+      if (!resolved) return void 0;
+      const { auth, scope } = resolved;
+      if (refresh) await load(ctx, auth, scope, signal, force || capability(ctx.model, scope.key).kind === "unknown");
+      else void load(ctx, auth, scope, signal, false);
+      return current(scope, ctx, signal) ? capability(ctx.model, scope.key) : void 0;
+    },
+    reset(clearCache = false) {
+      generation += 1;
+      identitySequence += 1;
+      active = void 0;
+      issue = UNKNOWN_CODEX_FAST_CAPABILITY.reason;
+      for (const { controller } of requests.values()) controller.abort();
+      requests.clear();
+      latestRequests.clear();
+      if (clearCache) accounts.clear();
+    }
+  };
+}
+function normalizeDirectory(payload) {
+  if (!Array.isArray(payload.models)) throw new Error("The Codex model directory returned invalid models.");
+  const models = /* @__PURE__ */ new Map();
+  for (const item of payload.models) {
+    if (!isRecord3(item) || typeof item.slug !== "string" || !item.slug.trim() || models.has(item.slug)) {
+      throw new Error("The Codex model directory returned an invalid or duplicate model ID.");
+    }
+    const hasTiers = item.service_tiers !== void 0;
+    const hasLegacy = item.additional_speed_tiers !== void 0;
+    if (hasTiers && (!Array.isArray(item.service_tiers) || item.service_tiers.some((tier) => !isRecord3(tier) || typeof tier.id !== "string")) || hasLegacy && (!Array.isArray(item.additional_speed_tiers) || item.additional_speed_tiers.some((tier) => typeof tier !== "string"))) {
+      throw new Error("The Codex model directory returned invalid service tiers.");
+    }
+    if (!hasTiers && !hasLegacy) {
+      models.set(item.slug, void 0);
+      continue;
+    }
+    const tiers = item.service_tiers ?? [];
+    const legacy = item.additional_speed_tiers ?? [];
+    models.set(item.slug, tiers.some((tier) => tier.id === "priority") || legacy.includes("fast"));
+  }
+  return models;
+}
+function modelIdentity2(model) {
+  return model ? `${model.provider}/${model.id}` : "";
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/codex-fast-runtime.ts
 var NO_FAST_REQUEST = /* @__PURE__ */ Symbol("no-fast-request");
 var FAST_USAGE_WARNING = "Fast is about 1.5\xD7 faster and uses more of your plan allowance.";
@@ -1296,14 +1544,58 @@ function registerCodexFastMode(pi, settingsRuntime, refreshStatus, options = {})
   let sessionController = new AbortController();
   let generation = 0;
   const pendingFastRequests = /* @__PURE__ */ new Map();
+  const catalog = createCodexFastCatalog({
+    credentialReader: options.credentialReader,
+    candidateReader: options.candidateReader ?? createOAuthCredentialCandidateReader(pi, options.credentialReader),
+    timeoutMs: options.timeoutMs,
+    onChanged(ctx) {
+      if (sessionController.signal.aborted || !settingsRuntime.get().settings.codexFastMode) return;
+      try {
+        refreshStatus(ctx);
+      } catch (error) {
+        if (!isStaleExtensionContextError(error)) throw error;
+      }
+    }
+  });
   const toggle = async (ctx, enabled, callerSignal) => {
     const ownerGeneration = generation;
     const sessionId = ctx.sessionManager.getSessionId();
     const signal = callerSignal ? AbortSignal.any([callerSignal, sessionController.signal]) : sessionController.signal;
+    if (ctx.model?.provider !== "openai-codex") {
+      ctx.ui.notify("/fast is available only for the active OpenAI Codex model.", "warning");
+      return false;
+    }
+    if (!isOfficialCodexModel(ctx.model)) {
+      ctx.ui.notify("Fast mode requires the official OpenAI Codex Responses endpoint.", "warning");
+      return false;
+    }
+    if (settingsRuntime.get().kind === "invalid") {
+      ctx.ui.notify("pi-usage.json is invalid; repair it and run /reload before changing Fast mode.", "error");
+      return false;
+    }
+    if (enabled) {
+      const capability = await catalog.read(ctx, signal, true, catalog.get(ctx.model).kind !== "supported");
+      if (signal.aborted || ownerGeneration !== generation) return false;
+      if (!capability) {
+        const latest = catalog.get(ctx.model);
+        ctx.ui.notify(
+          latest.kind === "unknown" ? latest.reason : "The active Codex account changed while checking Fast capability.",
+          "warning"
+        );
+        return false;
+      }
+      const availability = codexFastAvailability(ctx.model, false, capability);
+      if (availability.kind !== "available") {
+        if (availability.kind === "unknown" || availability.kind === "unavailable") {
+          ctx.ui.notify(availability.reason, "warning");
+        }
+        return false;
+      }
+    }
     try {
       await settingsRuntime.update({ codexFastMode: enabled }, signal);
     } catch (error) {
-      if (isAbortError(error) || isStaleExtensionContextError(error)) return false;
+      if (isAbortError2(error) || isStaleExtensionContextError(error)) return false;
       ctx.ui.notify(`Could not save pi-usage.json: ${errorMessage(error)}`, "error");
       return false;
     }
@@ -1326,26 +1618,18 @@ function registerCodexFastMode(pi, settingsRuntime, refreshStatus, options = {})
         return;
       }
       if (!ctx.hasUI) throw new Error("/fast requires TUI or RPC mode.");
-      const availability = codexFastAvailability(ctx.model, settingsRuntime.get().settings.codexFastMode);
-      if (availability.kind === "not-codex") {
-        ctx.ui.notify("/fast is available only for the active OpenAI Codex model.", "warning");
-        return;
-      }
-      if (availability.kind === "unavailable") {
-        ctx.ui.notify(availability.reason, "warning");
-        return;
-      }
-      if (settingsRuntime.get().kind === "invalid") {
-        ctx.ui.notify("pi-usage.json is invalid; repair it and run /reload before changing Fast mode.", "error");
-        return;
-      }
-      await toggle(ctx, !availability.enabled);
+      await toggle(ctx, !settingsRuntime.get().settings.codexFastMode);
     }
   });
+  const refreshCapabilities = (ctx, callerSignal, force = false) => {
+    const signal = callerSignal ? AbortSignal.any([callerSignal, sessionController.signal]) : sessionController.signal;
+    return catalog.read(ctx, signal, true, force);
+  };
   const prepareSession = (ctx) => {
     const sessionId = ctx.sessionManager.getSessionId();
     generation += 1;
     sessionController.abort();
+    catalog.reset();
     pendingFastRequests.clear();
     sessionController = new AbortController();
     const ownerGeneration = generation;
@@ -1367,18 +1651,28 @@ function registerCodexFastMode(pi, settingsRuntime, refreshStatus, options = {})
         ctx.ui.notify(`Invalid pi-usage.json; using defaults without overwriting it. ${state.issue}`, "warning");
       }
       refreshStatus(ctx);
+      if (state.kind !== "invalid" && isOfficialCodexModel(ctx.model)) void refreshCapabilities(ctx);
     })();
   };
   if (options.registerSessionStart !== false) {
     pi.on("session_start", async (_event, ctx) => prepareSession(ctx));
   }
-  pi.on("before_provider_request", (event, ctx) => {
-    const rewritten = rewriteCodexFastPayload(event.payload, ctx.model, settingsRuntime.get().settings.codexFastMode);
-    const key = activeRequestKey(ctx);
-    if (key && ctx.model) {
+  pi.on("model_select", (_event, ctx) => {
+    void refreshCapabilities(ctx);
+  });
+  pi.on("before_provider_request", async (event, ctx) => {
+    const ownerGeneration = generation;
+    const model = ctx.model;
+    const enabled = settingsRuntime.get().settings.codexFastMode;
+    const capability = enabled && isOfficialCodexModel(model) ? await catalog.read(ctx, sessionController.signal) ?? UNKNOWN_CODEX_FAST_CAPABILITY : UNKNOWN_CODEX_FAST_CAPABILITY;
+    if (sessionController.signal.aborted || ownerGeneration !== generation) return void 0;
+    const rewritten = rewriteCodexFastPayload(event.payload, model, enabled, capability);
+    const key = activeRequestKey(ctx, model);
+    if (key && model) {
       pendingFastRequests.set(key, {
-        fastRequested: isRecord3(rewritten) && rewritten.service_tier === "priority",
-        model: ctx.model
+        fastRequested: isRecord4(rewritten) && rewritten.service_tier === "priority",
+        model,
+        capability
       });
     }
     return rewritten;
@@ -1386,32 +1680,43 @@ function registerCodexFastMode(pi, settingsRuntime, refreshStatus, options = {})
   pi.on("message_end", (event, ctx) => {
     const request = consumeFastRequest(ctx, event.message, pendingFastRequests);
     if (request === NO_FAST_REQUEST) return void 0;
-    const message = correctCodexFastMessageCost(event.message, request.model, request.fastRequested);
+    const message = correctCodexFastMessageCost(
+      event.message,
+      request.model,
+      request.fastRequested,
+      request.capability
+    );
     return message ? { message } : void 0;
   });
   pi.on("session_shutdown", async () => {
     generation += 1;
     sessionController.abort();
+    catalog.reset(true);
     pendingFastRequests.clear();
     await settingsRuntime.flush();
   });
   return {
     prepareSession,
+    refreshCapabilities,
     availability(model) {
-      return codexFastAvailability(model, settingsRuntime.get().settings.codexFastMode);
+      return codexFastAvailability(model, settingsRuntime.get().settings.codexFastMode, catalog.get(model));
     },
     decorateStatus(model, status) {
-      return codexFastStatusLabel(status, codexFastIsEffective(model, settingsRuntime.get().settings.codexFastMode));
+      const enabled = settingsRuntime.get().settings.codexFastMode;
+      const capability = catalog.get(model);
+      if (enabled && codexFastAvailability(model, enabled, capability).kind === "unknown" && /^codex(?:\s|$)/u.test(status)) {
+        return `codex (Fast unknown)${status.slice("codex".length)}`;
+      }
+      return codexFastStatusLabel(status, codexFastIsEffective(model, enabled, capability));
     },
     toggle
   };
 }
-function activeRequestKey(ctx) {
-  const model = ctx.model;
+function activeRequestKey(ctx, model = ctx.model) {
   return model ? `${ctx.sessionManager.getSessionId()}:${model.provider}/${model.id}` : void 0;
 }
 function consumeFastRequest(ctx, message, pending) {
-  if (!isRecord3(message) || message.role !== "assistant") return NO_FAST_REQUEST;
+  if (!isRecord4(message) || message.role !== "assistant") return NO_FAST_REQUEST;
   const key = messageRequestKey(ctx, message);
   if (!key) return NO_FAST_REQUEST;
   const request = pending.get(key);
@@ -1422,44 +1727,12 @@ function messageRequestKey(ctx, message) {
   if (typeof message.provider !== "string" || typeof message.model !== "string") return void 0;
   return `${ctx.sessionManager.getSessionId()}:${message.provider}/${message.model}`;
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isAbortError(error) {
-  return error instanceof Error && error.name === "AbortError";
-}
-
-// src/usage-helpers.ts
-function configuredAdapters(ctx) {
-  return usageAdapters().filter(
-    (adapter) => adapter.id === ctx.model?.provider || providerIsConfigured(ctx, adapter.id)
-  );
-}
-function providerDisplayName(ctx, providerId) {
-  try {
-    return sanitizeDisplayText(ctx.modelRegistry.getProviderDisplayName(providerId), 80);
-  } catch {
-    return sanitizeDisplayText(providerId, 80);
-  }
-}
-function setBoundedMap(map, key, value, limit) {
-  map.delete(key);
-  while (map.size >= limit) {
-    const oldest = map.keys().next().value;
-    if (oldest === void 0) break;
-    map.delete(oldest);
-  }
-  map.set(key, value);
-}
-function modelIdentity(model) {
-  return model ? `${model.provider}/${model.id}` : void 0;
-}
 function isAbortError2(error) {
   return error instanceof Error && error.name === "AbortError";
 }
-function isTimeoutError(error) {
-  return error instanceof Error && error.name === "TimeoutError";
-}
 
 // src/usage-settings-ui.ts
 import { stripVTControlCharacters } from "node:util";
@@ -1599,13 +1872,13 @@ async function showUsageSettings(ctx, settingsRuntime, parentSignal, isCurrent,
 }
 
 // src/usage.ts
-var CACHE_TTL_MS = 5 * 60 * 1e3;
+var CACHE_TTL_MS2 = 5 * 60 * 1e3;
 var STATUS_COUNTDOWN_REFRESH_MS = 60 * 1e3;
 var DEFAULT_TIMEOUT_MS = 15e3;
 var COMMAND_CODE_REVALIDATION_RESERVE_MS = 1e3;
 var ALL_PROVIDER_CONCURRENCY = 2;
-var FAILURE_BACKOFF_MS = 3e4;
-var MAX_ACCOUNT_STATES = 32;
+var FAILURE_BACKOFF_MS2 = 3e4;
+var MAX_ACCOUNT_STATES2 = 32;
 var STATUS_KEY = "usage";
 var REFRESH_CURRENT = "Refresh current usage";
 var VIEW_ANOTHER = "View another configured provider\u2026";
@@ -1622,7 +1895,7 @@ function usageExtension(pi, dependencies = {}) {
   const createRedemptionId = dependencies.createRedemptionId ?? randomUUID2;
   const settingsRuntime = dependencies.settingsRuntime ?? createUsageSettingsRuntime();
   const resolveUsageAuth2 = resolveUsageAuth;
-  const cache = new UsageCache(CACHE_TTL_MS);
+  const cache = new UsageCache(CACHE_TTL_MS2);
   const failureBackoff = /* @__PURE__ */ new Map();
   const latestQueries = /* @__PURE__ */ new Map();
   const activeControllers = /* @__PURE__ */ new Set();
@@ -1671,7 +1944,7 @@ function usageExtension(pi, dependencies = {}) {
       statusRefreshTimer = void 0;
       if (!sessionActive || generation !== statusGeneration) return;
       startStatusRefresh(ctx, model, true);
-    }, CACHE_TTL_MS);
+    }, CACHE_TTL_MS2);
     statusRefreshTimer.unref?.();
   };
   const publishStatus = (ctx, outcome, model, shouldSchedule) => {
@@ -1697,23 +1970,23 @@ function usageExtension(pi, dependencies = {}) {
     const showCodexResetCountdown = outcome.state.report.providerId === "openai-codex" && settings.codexStatusResetCountdown;
     const isCompanionReport = outcome.state.report.source === "openai-chatgpt-companion";
     const now = Date.now();
-    const rawValue = formatUsageStatusline(
+    const status = formatUsageStatuslineWithCountdown(
       outcome.state.report,
       model,
       now,
       showCodexResetCountdown,
       settings.codexStatusPercentage
     );
-    const value = rawValue ? fastRuntime.decorateStatus(model, rawValue) : void 0;
+    const value = status.value ? fastRuntime.decorateStatus(model, status.value) : void 0;
     if (!safeSetStatus(ctx, value)) return;
     if (shouldSchedule && sessionActive) scheduleStatusRefresh(ctx, model);
-    if (sessionActive && (showCodexResetCountdown || isCompanionReport) && outcome.state.report.buckets.some(
+    if (sessionActive && (status.hasCountdown || (showCodexResetCountdown || isCompanionReport) && outcome.state.report.buckets.some(
       (bucket) => (!isCompanionReport || bucket.groupId === "chatgpt-plan") && bucket.resetsAt !== void 0 && Number.isFinite(bucket.resetsAt) && bucket.resetsAt * 1e3 > now
-    )) {
+    ))) {
       const generation = statusGeneration;
       statusCountdownTimer = setTimeout(() => {
-        statusCountdownTimer = void 0;
         if (!sessionActive || generation !== statusGeneration) return;
+        statusCountdownTimer = void 0;
         publishStatus(ctx, outcome, model, false);
       }, STATUS_COUNTDOWN_REFRESH_MS);
       statusCountdownTimer.unref?.();
@@ -1754,7 +2027,7 @@ function usageExtension(pi, dependencies = {}) {
         `resolving ${adapter.displayName} runtime auth`
       );
     } catch (error) {
-      if (isStaleExtensionContextError(error) || isAbortError2(error)) throw error;
+      if (isStaleExtensionContextError(error) || isAbortError(error)) throw error;
       if (adapter.id === "openai") invalidateProviderState(adapter.id);
       const authState = error instanceof UnsupportedOpenAIUsageAuthError ? "unsupported" : adapter.id === "openai" && !isTimeoutError(error) ? "failed" : void 0;
       if (displayState === "current") {
@@ -1903,7 +2176,7 @@ function usageExtension(pi, dependencies = {}) {
       failureBackoff.delete(failureKey);
       querySequence += 1;
       queryId = querySequence;
-      setBoundedMap(latestQueries, failureKey, queryId, MAX_ACCOUNT_STATES);
+      setBoundedMap(latestQueries, failureKey, queryId, MAX_ACCOUNT_STATES2);
       const queryTimeoutMs = Math.max(
         1,
         deadlineAt - Date.now() - (adapter.id === "command-code" ? COMMAND_CODE_REVALIDATION_RESERVE_MS : 0)
@@ -1934,7 +2207,7 @@ function usageExtension(pi, dependencies = {}) {
         rememberedTargetId: expectedTargetId
       };
     } catch (error) {
-      if (isStaleExtensionContextError(error) || isAbortError2(error)) throw error;
+      if (isStaleExtensionContextError(error) || isAbortError(error)) throw error;
       if (retryableAuthChanged && authRetry === 0 && !signal.aborted && !requestContextChanged() && Date.now() < deadlineAt) {
         if (queryId !== void 0 && latestQueries.get(failureKey) === queryId) {
           latestQueries.delete(failureKey);
@@ -1948,7 +2221,7 @@ function usageExtension(pi, dependencies = {}) {
       }
       if (queryId === void 0 || latestQueries.get(failureKey) === queryId) {
         if (adapter.invalidateCacheOnFailure) cache.delete(adapter.id, queryFingerprint);
-        setBoundedMap(failureBackoff, failureKey, { until: now + FAILURE_BACKOFF_MS, message }, MAX_ACCOUNT_STATES);
+        setBoundedMap(failureBackoff, failureKey, { until: now + FAILURE_BACKOFF_MS2, message }, MAX_ACCOUNT_STATES2);
       }
       return {
         state: {
@@ -2065,7 +2338,7 @@ function usageExtension(pi, dependencies = {}) {
   };
   const startStatusRefresh = (ctx, model, force) => {
     void refreshCurrentStatus(ctx, model, force).catch((error) => {
-      if (isStaleExtensionContextError(error) || isAbortError2(error)) return;
+      if (isStaleExtensionContextError(error) || isAbortError(error)) return;
       const message = errorMessage(error);
       console.error("[pi-usage] refresh failed:", message);
       safeSetStatus(ctx, `usage err: ${message.slice(0, 50)}`);
@@ -2109,7 +2382,7 @@ function usageExtension(pi, dependencies = {}) {
         );
         return generation === statusGeneration && modelIdentity(ctx.model) === modelIdentity(model) && (!adapter.targets || settingsRuntime.get().settings.selectedTargets[adapter.id] === outcome.rememberedTargetId) && outcome.authState === "unavailable" && auth === void 0;
       } catch (error) {
-        if (isAbortError2(error) || isStaleExtensionContextError(error)) throw error;
+        if (isAbortError(error) || isStaleExtensionContextError(error)) throw error;
         const unchangedFailure = outcome.authState === "unsupported" && error instanceof UnsupportedOpenAIUsageAuthError || outcome.authState === "failed" && outcome.state.status === "auth-unavailable" && !(error instanceof UnsupportedOpenAIUsageAuthError) && !isTimeoutError(error) && errorMessage(error) === outcome.state.message;
         return unchangedFailure && generation === statusGeneration && modelIdentity(ctx.model) === modelIdentity(model) && (!adapter.targets || settingsRuntime.get().settings.selectedTargets[adapter.id] === outcome.rememberedTargetId);
       }
@@ -2125,7 +2398,7 @@ function usageExtension(pi, dependencies = {}) {
       );
       return generation === statusGeneration && modelIdentity(ctx.model) === modelIdentity(model) && (!adapter.targets || settingsRuntime.get().settings.selectedTargets[adapter.id] === outcome.rememberedTargetId) && auth?.fingerprint === outcome.fingerprint;
     } catch (error) {
-      if (isAbortError2(error) || isStaleExtensionContextError(error)) throw error;
+      if (isAbortError(error) || isStaleExtensionContextError(error)) throw error;
       return false;
     }
   };
@@ -2165,14 +2438,26 @@ function usageExtension(pi, dependencies = {}) {
   };
   const showMenu = async (ctx) => {
     if (!ctx.hasUI) throw new Error("/usage requires TUI or RPC mode.");
-    statusGeneration += 1;
-    const menuGeneration = statusGeneration;
-    statusController?.abort();
-    statusController = void 0;
-    clearStatusTimers();
     const controller = new AbortController();
     activeControllers.add(controller);
     try {
+      if (isOfficialCodexModel(ctx.model)) {
+        const refreshed = await runMenuOperation(
+          ctx,
+          "Checking Codex Fast capability\u2026",
+          controller.signal,
+          async (signal) => {
+            await fastRuntime.refreshCapabilities(ctx, signal);
+            return true;
+          }
+        );
+        if (!refreshed || controller.signal.aborted) return;
+      }
+      statusGeneration += 1;
+      const menuGeneration = statusGeneration;
+      statusController?.abort();
+      statusController = void 0;
+      clearStatusTimers();
       let stableCurrent = await queryStableCurrent(ctx, false, controller, "Checking current usage\u2026");
       if (!stableCurrent) return;
       publishStableCurrent(ctx, stableCurrent);
@@ -2277,7 +2562,7 @@ function usageExtension(pi, dependencies = {}) {
             const fastAvailability = fastRuntime.availability(ctx.model);
             const targetState = actionableTargetState();
             const targetAdapter = adapterForProvider(targetState?.providerId);
-            const fastLines = fastAvailability.kind === "available" ? [`Fast mode: ${fastAvailability.enabled ? "On" : "Off"}`, FAST_USAGE_WARNING] : fastAvailability.kind === "unavailable" ? [`Fast mode: Unavailable \xB7 ${fastAvailability.reason}`] : [];
+            const fastLines = fastAvailability.kind === "available" ? [`Fast mode: ${fastAvailability.enabled ? "On" : "Off"}`, FAST_USAGE_WARNING] : fastAvailability.kind === "unavailable" ? [`Fast mode: Unavailable \xB7 ${fastAvailability.reason}`] : fastAvailability.kind === "unknown" ? [`Fast mode: Unknown \xB7 ${fastAvailability.reason}`] : [];
             return {
               kind: "actions",
               title: "Provider usage",
@@ -2292,10 +2577,10 @@ function usageExtension(pi, dependencies = {}) {
                     action: "target"
                   }
                 ] : [],
-                ...fastAvailability.kind === "available" ? [
+                ...fastAvailability.kind === "available" || fastState.settings.codexFastMode && isOfficialCodexModel(ctx.model) ? [
                   {
                     id: "toggle-fast",
-                    label: fastAvailability.enabled ? "Turn Fast mode off" : "Turn Fast mode on",
+                    label: fastState.settings.codexFastMode ? "Turn Fast mode off" : "Turn Fast mode on",
                     description: fastState.kind === "invalid" ? "Repair pi-usage.json and reload before changing Fast mode." : FAST_USAGE_WARNING,
                     disabled: fastState.kind === "invalid",
                     action: "toggle-fast"
@@ -2424,7 +2709,7 @@ function usageExtension(pi, dependencies = {}) {
               ];
               return { kind: "stay" };
             } catch (error) {
-              if (isAbortError2(error) || isStaleExtensionContextError(error)) {
+              if (isAbortError(error) || isStaleExtensionContextError(error)) {
                 return { kind: "stay" };
               }
               ctx.ui.notify(`Could not select target: ${errorMessage(error)}`, "error");
@@ -2454,10 +2739,11 @@ function usageExtension(pi, dependencies = {}) {
           },
           "toggle-fast": async () => {
             const availability = fastRuntime.availability(ctx.model);
-            if (availability.kind !== "available" || fastState.kind === "invalid") {
+            const enabled = settingsRuntime.get().settings.codexFastMode;
+            if (availability.kind !== "available" && !enabled || fastState.kind === "invalid") {
               return { kind: "rejected" };
             }
-            const changed = await fastRuntime.toggle(ctx, !availability.enabled, controller.signal);
+            const changed = await fastRuntime.toggle(ctx, !enabled, controller.signal);
             if (!changed) return { kind: "rejected" };
             fastState = settingsRuntime.get();
             return { kind: "stay" };
@@ -2481,7 +2767,7 @@ function usageExtension(pi, dependencies = {}) {
                   try {
                     availability = await listCodexResetCredits(auth, signal, DEFAULT_TIMEOUT_MS);
                   } catch (error) {
-                    if (isAbortError2(error) || summaryCount === void 0 || summaryCount <= 0) {
+                    if (isAbortError(error) || summaryCount === void 0 || summaryCount <= 0) {
                       throw error;
                     }
                     availability = {
@@ -2514,7 +2800,7 @@ function usageExtension(pi, dependencies = {}) {
                 screen: loaded.availability.availableCount > 0 ? "reset-picker" : "reset-result"
               };
             } catch (error) {
-              if (isAbortError2(error) || isStaleExtensionContextError(error)) {
+              if (isAbortError(error) || isStaleExtensionContextError(error)) {
                 return { kind: "stay" };
               }
               ctx.ui.notify(`Couldn't load usage limit resets: ${errorMessage(error)}`, "error");
@@ -2576,7 +2862,7 @@ function usageExtension(pi, dependencies = {}) {
               }
               return { kind: "to", screen: "reset-result" };
             } catch (error) {
-              if (isAbortError2(error) || isStaleExtensionContextError(error)) {
+              if (isAbortError(error) || isStaleExtensionContextError(error)) {
                 return { kind: "close" };
               }
               resetFailure = `Couldn't reset usage: ${errorMessage(error)}. Try again with the same request.`;
@@ -2730,7 +3016,7 @@ function usageExtension(pi, dependencies = {}) {
       try {
         await showMenu(ctx);
       } catch (error) {
-        if (isStaleExtensionContextError(error) || isAbortError2(error)) return;
+        if (isStaleExtensionContextError(error) || isAbortError(error)) return;
         throw error;
       }
     }
@@ -2776,15 +3062,18 @@ function usageExtension(pi, dependencies = {}) {
     safeSetStatus(ctx, void 0);
   });
   fastRuntime = registerCodexFastMode(pi, settingsRuntime, (ctx) => startStatusRefresh(ctx, ctx.model, false), {
-    registerSessionStart: false
+    registerSessionStart: false,
+    credentialReader,
+    candidateReader: credentialCandidates,
+    timeoutMs: DEFAULT_TIMEOUT_MS
   });
 }
 export {
-  CODEX_FAST_MODEL_IDS,
   CODEX_FAST_SERVICE_TIER,
   CODEX_STANDARD_SERVICE_TIER,
   DEFAULT_USAGE_SETTINGS,
   SUPPORTED_ADAPTERS,
+  UNKNOWN_CODEX_FAST_CAPABILITY,
   UsageCache,
   XAI_ADAPTER,
   abortError,
@@ -2807,6 +3096,7 @@ export {
   formatUsageReport,
   formatUsageStatusline,
   isBoundedTargetId,
+  isOfficialCodexModel,
   isStaleExtensionContextError,
   listCodexResetCredits,
   listUsageTargets,