@narumitw/pi-usage 0.64.3 → 0.65.0

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;
@@ -1289,6 +1284,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 +1516,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 +1590,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 +1623,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 +1652,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 +1699,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 +1844,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 +1867,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 +1916,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) => {
@@ -1754,7 +1999,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 +2148,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 +2179,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 +2193,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 +2310,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 +2354,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 +2370,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 +2410,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 +2534,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 +2549,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 +2681,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 +2711,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 +2739,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 +2772,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 +2834,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 +2988,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 +3034,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 +3068,7 @@ export {
   formatUsageReport,
   formatUsageStatusline,
   isBoundedTargetId,
+  isOfficialCodexModel,
   isStaleExtensionContextError,
   listCodexResetCredits,
   listUsageTargets,