@narumitw/pi-usage 0.64.3 → 0.65.1

package/docs/providers.md

@@ -81,7 +81,7 @@ Contract fixtures derive from [Specode's pinned implementation](https://github.c
 - Source: the Codex usage and earned-reset endpoints using Pi's resolved runtime authorization
 - Displayed data: returned duration-based windows, resets, credits, earned usage-limit resets, and additional model buckets
 - Reset mutation: `POST /wham/rate-limit-reset-credits/consume` with a unique redemption request ID and, when available, the selected opaque credit ID
-- Statusline examples: `codex 59% ↻ 2h30m 61% ↻ 2d15m`, `codex fast 59% ↻ 2h30m`, or `codex spark 100% ↻ 2h30m`. Set `codexStatusPercentage` to `"used"` to show consumed percentages, or set `codexStatusResetCountdown` to `false` for the legacy `5h` and `wk` labels.
+- Statusline examples: `codex 59% ↻ 2h30m · 61% ↻ 2d15m`, `codex fast 59% ↻ 2h30m`, or `codex spark 100% ↻ 2h30m`. Set `codexStatusPercentage` to `"used"` to show consumed percentages, or set `codexStatusResetCountdown` to `false` for static labels such as `codex 5h:59% · wk:61%`.
 
 The statusline selects a returned bucket that matches the current Codex model when one is available.
 The percentage preference affects only this compact status and defaults to remaining quota; it does not change the detailed report or returned usage data.
@@ -101,7 +101,7 @@ Opaque credit and account IDs are never shown or persisted by the extension.
 - Source: `GET https://api.kimi.com/coding/v1/usages` using Pi's freshly resolved runtime Bearer credential
 - Displayed plan data: count-based weekly summaries and returned sub-windows, plus reported ratio-based five-hour, weekly, or monthly quotas and valid reset times
 - Displayed wallet data: balance, monthly spend, and monthly charge limit when the wallet supplies consistent currency and amounts
-- Statusline examples: `kimi 99% 5h 96% wk`, `kimi 56% 5h 21% mo`, or `kimi 95% 1d`
+- Statusline examples: `kimi 77% ↻ 2h52m · 87% ↻ 29d20h`, `kimi 77% ↻ 2h52m · mo:87%`, or static fallback `kimi 1d:95%`
 
 Both Pi API-key credentials and Pi OAuth credentials are accepted because current Pi resolves each form as Bearer authorization for the same official Kimi inference origin.
 The extension queries the fixed usage endpoint only when both the selected model origin and the effective resolved-auth origin are `https://api.kimi.com`.
@@ -148,7 +148,7 @@ The contracts were verified on 2026-08-30 against the official [Global balance r
 - Token Plan source: `GET {region-api-root}/v1/token_plan/remains`
 - Pay-as-you-go source: `GET {region-api-root}/account/query_balance`
 - Region API roots: `https://api.minimax.io` and `https://api.minimaxi.com`
-- Statusline examples: `minimax 15% 5h 80% wk` or `minimax USD 98.00001`
+- Statusline examples: `minimax 15% ↻ 2h30m · 80% ↻ 6d`, static fallback `minimax 5h:15% · wk:80%`, unlimited `minimax cn 5h:unlimited · wk:unlimited`, or pay-as-you-go `minimax USD 98.00001`
 
 Pi's resolved MiniMax API key selects exactly one endpoint before network access.
 Keys with the first-party `sk-api-` prefix query pay-as-you-go balance; other MiniMax API keys query Token Plan quota.
@@ -166,7 +166,7 @@ The contract was verified on 2026-08-30 against MiniMax's [Token Plan FAQ](https
 - Allowance labels: AI credits for usage-based billing, premium requests for legacy annual billing, or chat requests for Copilot Free
 - Source: GitHub's undocumented `GET /copilot_internal/user` endpoint
 - Displayed data: entitlement, remaining allowance, percentage, reset time, plan, and any additional usage beyond the included allowance
-- Statusline examples: `copilot credits 1200/1500 80%`, `copilot 245/300 82%`, or `copilot chat 40/50 80%`
+- Statusline examples: `copilot credits 1200/1500 80% ↻ 6d`, `copilot 245/300 82% ↻ 6d`, or static fallback `copilot chat 40/50 80%`
 
 GitHub's quota endpoint requires the original GitHub OAuth token rather than the short-lived Copilot inference token exposed by runtime auth.
 `pi-usage` supports Copilot accounts created through Pi's `/login` flow and named accounts offered by a compatible `oauth:credential-source:v1` owner.
@@ -260,7 +260,7 @@ The contract was verified on 2026-08-30 against Baseten's [Billing and usage](ht
 - Source: `GET https://opencode.ai/zen/go/v1/usage` using Pi's resolved inference API key
 - Displayed data: used percentage and reset time for each window
 - Status handling: `rate-limited` windows remain visible, while unknown statuses become unavailable notes
-- Statusline examples: `zen 0% r 4% w 2% m`
+- Statusline examples: `zen 0% ↻ 2h30m · 4% ↻ 6d · m:2%` or static fallback `zen r:0% · w:4% · m:2%`
 
 The fixed endpoint is queried only when the OpenCode Go model uses the official `https://opencode.ai` origin.
 When resolved provider auth includes a base URL, that URL must use the same origin.
@@ -275,7 +275,7 @@ Other origins fail before the credential is sent.
 - Plan route: `GET https://api.commandcode.ai/alpha/billing/subscriptions`
 - Period route: `GET https://api.commandcode.ai/alpha/usage/summary`
 - Displayed data: five-hour and weekly spend caps in USD with reset times, the billing-period credit pool and remaining balance, plan name and status, request and token totals, and purchased or free credits when present
-- Statusline examples: `cmd 99% 5h 92% wk 96% mo`
+- Statusline examples: `cmd 99% ↻ 2h30m · 92% ↻ 6d · 96% ↻ 20d` or static fallback `cmd 5h:99% · wk:92% · mo:96%`
 
 The official `@commandcode/pi-commandcode-provider` extension registers this provider through `pi.registerProvider()`, so `command-code` is not a Pi built-in provider.
 Pi still resolves its stored `/login` API key through the normal provider registry, and the extension sends it as Bearer authorization only when the selected model and resolved auth share the official `https://api.commandcode.ai` origin.
@@ -329,7 +329,7 @@ xAI identity and billing requests occur only after an explicit current, configur
 - Allowed origins: the model base URL must resolve to `https://api.z.ai` or `https://open.bigmodel.cn`
 - Displayed data: explicit used and remaining values, reset times, provider-reported per-tool MCP details, and the plan name with its renewal date
 - Percentage-only windows remain percent-based
-- Statusline: publishes remaining plan percentages such as `zai 87% 5h 76% wk`; monthly MCP details remain available through `/usage`
+- Statusline: publishes remaining plan percentages such as `zai 87% ↻ 2h30m · 76% ↻ 6d`, with static fallback `zai 5h:87% · wk:76%`; monthly MCP details remain available through `/usage`
 
 The monitor endpoint is not a published API contract and may return legacy `TOKENS_LIMIT` or newer `CREDIT_LIMIT` window names.
 The extension classifies both forms by the provider's window unit and does not label provider-reported counts as tokens or calls.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@narumitw/pi-usage",
-  "version": "0.64.3",
+  "version": "0.65.1",
   "description": "Pi extension that shows current-account usage and DeepSeek API balance for supported providers.",
   "type": "module",
   "license": "MIT",

package/src/codex-fast-catalog.ts

@@ -0,0 +1,272 @@
+import { type ExtensionContext, VERSION } from "@earendil-works/pi-coding-agent";
+import { type CodexFastCapability, isOfficialCodexModel, UNKNOWN_CODEX_FAST_CAPABILITY } from "./codex-fast.js";
+import { resolveCodexResetAuth } from "./codex-resets.js";
+import { awaitWithDeadline, errorMessage, fingerprintResolvedAuth, redactUsageError } from "./core.js";
+import type { OAuthCredentialCandidateReader, StoredCredentialReader } from "./oauth-credential-source.js";
+import { AUTH_FINGERPRINT_SALT, fetchProviderJson } from "./query.js";
+import type { PiModel, ResolvedUsageAuth } from "./types.js";
+import { setBoundedMap } from "./usage-helpers.js";
+
+const CACHE_TTL_MS = 5 * 60 * 1000;
+const FAILURE_BACKOFF_MS = 30_000;
+const MAX_ACCOUNT_STATES = 32;
+const MAX_DIRECTORY_BODY_BYTES = 8 * 1024 * 1024;
+const DIRECTORY_URL = new URL("https://chatgpt.com/backend-api/codex/models");
+DIRECTORY_URL.searchParams.set("client_version", VERSION);
+
+type CatalogEntry = {
+  models?: ReadonlyMap<string, boolean | undefined>;
+  fetchedAt: number;
+  fingerprint?: string;
+  retryAt?: number;
+  issue?: string;
+};
+
+type AccountScope = {
+  key: string;
+  fingerprint: string;
+  model: string;
+  session: string;
+  generation: number;
+};
+
+type CatalogOptions = {
+  credentialReader?: StoredCredentialReader;
+  candidateReader?: OAuthCredentialCandidateReader;
+  timeoutMs?: number;
+  onChanged?: (ctx: ExtensionContext) => void;
+};
+
+/** Account-scoped discovery; request hooks authenticate their cache read without awaiting directory I/O. */
+export function createCodexFastCatalog(options: CatalogOptions = {}) {
+  const accounts = new Map<string, CatalogEntry>();
+  const requests = new Map<string, { controller: AbortController; promise: Promise<void> }>();
+  const latestRequests = new Map<string, number>();
+  const timeoutMs = options.timeoutMs ?? 15_000;
+  let requestSequence = 0;
+  let identitySequence = 0;
+  let generation = 0;
+  let active: AccountScope | undefined;
+  let issue: string = UNKNOWN_CODEX_FAST_CAPABILITY.reason;
+
+  const current = (scope: AccountScope, ctx: ExtensionContext, signal: AbortSignal) =>
+    !signal.aborted &&
+    generation === scope.generation &&
+    active?.key === scope.key &&
+    active.fingerprint === scope.fingerprint &&
+    active.model === scope.model &&
+    active.session === scope.session &&
+    modelIdentity(ctx.model) === scope.model &&
+    ctx.sessionManager.getSessionId() === scope.session;
+
+  const capability = (model: PiModel | undefined, key = active?.key): CodexFastCapability => {
+    const entry = key ? accounts.get(key) : undefined;
+    const supported = model ? entry?.models?.get(model.id) : undefined;
+    if (supported !== undefined) 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: ExtensionContext, signal: AbortSignal) => {
+    const identity = ++identitySequence;
+    const owner = generation;
+    const model = modelIdentity(ctx.model);
+    const session = ctx.sessionManager.getSessionId();
+    if (!isOfficialCodexModel(ctx.model)) {
+      active = undefined;
+      return undefined;
+    }
+    try {
+      // Reuse the existing active-runtime OAuth/account validation, without any reset request.
+      const auth = await awaitWithDeadline(
+        resolveCodexResetAuth(ctx, undefined, options.credentialReader, options.candidateReader),
+        signal,
+        timeoutMs,
+        "resolving the current Codex model-directory account",
+      );
+      if (
+        signal.aborted ||
+        owner !== generation ||
+        identity !== identitySequence ||
+        modelIdentity(ctx.model) !== model ||
+        ctx.sessionManager.getSessionId() !== session
+      ) {
+        return undefined;
+      }
+      const accountId = auth.headers["chatgpt-account-id"];
+      if (!accountId) throw new Error("The active Codex account ID is unavailable.");
+      const scope: AccountScope = {
+        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 undefined;
+      active = undefined;
+      issue = `Codex Fast capability is unknown: ${redactUsageError(errorMessage(error))}`;
+      options.onChanged?.(ctx);
+      return undefined;
+    }
+  };
+
+  const load = async (
+    ctx: ExtensionContext,
+    auth: ResolvedUsageAuth,
+    scope: AccountScope,
+    signal: AbortSignal,
+    force: boolean,
+  ): Promise<void> => {
+    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: number | undefined;
+      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 undefined;
+              },
+            },
+          );
+          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 === undefined || 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 });
+    }
+    // A cancelled menu must stop waiting without aborting a session-owned shared request.
+    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: PiModel | undefined) {
+      return capability(model);
+    },
+    async read(
+      ctx: ExtensionContext,
+      signal: AbortSignal,
+      refresh = false,
+      force = false,
+    ): Promise<CodexFastCapability | undefined> {
+      const resolved = await identify(ctx, signal);
+      if (!resolved) return undefined;
+      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) : undefined;
+    },
+    reset(clearCache = false) {
+      generation += 1;
+      identitySequence += 1;
+      active = undefined;
+      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: Record<string, unknown>): ReadonlyMap<string, boolean | undefined> {
+  if (!Array.isArray(payload.models)) throw new Error("The Codex model directory returned invalid models.");
+  const models = new Map<string, boolean | undefined>();
+  for (const item of payload.models) {
+    if (!isRecord(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 !== undefined;
+    const hasLegacy = item.additional_speed_tiers !== undefined;
+    if (
+      (hasTiers &&
+        (!Array.isArray(item.service_tiers) ||
+          item.service_tiers.some((tier) => !isRecord(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, undefined);
+      continue;
+    }
+    const tiers = (item.service_tiers ?? []) as Array<{ id: string }>;
+    const legacy = (item.additional_speed_tiers ?? []) as string[];
+    models.set(item.slug, tiers.some((tier) => tier.id === "priority") || legacy.includes("fast"));
+  }
+  return models;
+}
+
+function modelIdentity(model: PiModel | undefined): string {
+  return model ? `${model.provider}/${model.id}` : "";
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/codex-fast-runtime.ts

@@ -1,18 +1,27 @@
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
+  type CodexFastCapability,
   codexFastAvailability,
   codexFastIsEffective,
   codexFastStatusLabel,
   correctCodexFastMessageCost,
+  isOfficialCodexModel,
   rewriteCodexFastPayload,
+  UNKNOWN_CODEX_FAST_CAPABILITY,
 } from "./codex-fast.js";
+import { createCodexFastCatalog } from "./codex-fast-catalog.js";
 import { errorMessage } from "./core.js";
+import {
+  createOAuthCredentialCandidateReader,
+  type OAuthCredentialCandidateReader,
+  type StoredCredentialReader,
+} from "./oauth-credential-source.js";
 import { isStaleExtensionContextError } from "./query.js";
 import type { UsageSettingsRuntime, UsageSettingsState } from "./settings.js";
 import type { PiModel } from "./types.js";
 
 const NO_FAST_REQUEST = Symbol("no-fast-request");
-type PendingFastRequest = { fastRequested: boolean; model: PiModel };
+type PendingFastRequest = { fastRequested: boolean; model: PiModel; capability: CodexFastCapability };
 
 export const FAST_USAGE_WARNING = "Fast is about 1.5× faster and uses more of your plan allowance.";
 
@@ -20,11 +29,29 @@ export function registerCodexFastMode(
   pi: ExtensionAPI,
   settingsRuntime: UsageSettingsRuntime,
   refreshStatus: (ctx: ExtensionContext) => void,
-  options: { registerSessionStart?: boolean } = {},
+  options: {
+    registerSessionStart?: boolean;
+    credentialReader?: StoredCredentialReader;
+    candidateReader?: OAuthCredentialCandidateReader;
+    timeoutMs?: number;
+  } = {},
 ) {
   let sessionController = new AbortController();
   let generation = 0;
   const pendingFastRequests = new Map<string, PendingFastRequest>();
+  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: ExtensionCommandContext,
@@ -34,6 +61,39 @@ export function registerCodexFastMode(
     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) {
@@ -63,27 +123,20 @@ export function registerCodexFastMode(
         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: ExtensionContext, callerSignal?: AbortSignal, force = false) => {
+    const signal = callerSignal ? AbortSignal.any([callerSignal, sessionController.signal]) : sessionController.signal;
+    return catalog.read(ctx, signal, true, force);
+  };
+
   const prepareSession = (ctx: ExtensionContext): Promise<void> => {
     const sessionId = ctx.sessionManager.getSessionId();
     generation += 1;
     sessionController.abort();
+    catalog.reset();
     pendingFastRequests.clear();
     sessionController = new AbortController();
     const ownerGeneration = generation;
@@ -109,20 +162,33 @@ export function registerCodexFastMode(
         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("model_select", (_event, ctx) => {
+    void refreshCapabilities(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("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 undefined;
+    const rewritten = rewriteCodexFastPayload(event.payload, model, enabled, capability);
+    const key = activeRequestKey(ctx, model);
+    if (key && model) {
       pendingFastRequests.set(key, {
         fastRequested: isRecord(rewritten) && rewritten.service_tier === "priority",
-        model: ctx.model,
+        model,
+        capability,
       });
     }
     return rewritten;
@@ -130,30 +196,45 @@ export function registerCodexFastMode(
   pi.on("message_end", (event, ctx) => {
     const request = consumeFastRequest(ctx, event.message, pendingFastRequests);
     if (request === NO_FAST_REQUEST) return undefined;
-    const message = correctCodexFastMessageCost(event.message, request.model, request.fastRequested);
+    const message = correctCodexFastMessageCost(
+      event.message,
+      request.model,
+      request.fastRequested,
+      request.capability,
+    );
     return message ? { message: message as never } : undefined;
   });
   pi.on("session_shutdown", async () => {
     generation += 1;
     sessionController.abort();
+    catalog.reset(true);
     pendingFastRequests.clear();
     await settingsRuntime.flush();
   });
 
   return {
     prepareSession,
+    refreshCapabilities,
     availability(model: PiModel | undefined) {
-      return codexFastAvailability(model, settingsRuntime.get().settings.codexFastMode);
+      return codexFastAvailability(model, settingsRuntime.get().settings.codexFastMode, catalog.get(model));
     },
     decorateStatus(model: PiModel | undefined, status: string) {
-      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: ExtensionContext): string | undefined {
-  const model = ctx.model;
+function activeRequestKey(ctx: ExtensionContext, model = ctx.model): string | undefined {
   return model ? `${ctx.sessionManager.getSessionId()}:${model.provider}/${model.id}` : undefined;
 }
 

package/src/codex-fast.ts

@@ -4,23 +4,24 @@ import type { PiModel } from "./types.js";
 export const CODEX_FAST_SERVICE_TIER = "priority";
 export const CODEX_STANDARD_SERVICE_TIER = "default";
 
-export const CODEX_FAST_MODEL_IDS: ReadonlySet<string> = 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",
-]);
+export type CodexFastCapability = { kind: "supported" } | { kind: "unsupported" } | { kind: "unknown"; reason: string };
+
+export const UNKNOWN_CODEX_FAST_CAPABILITY = {
+  kind: "unknown",
+  reason: "Codex Fast capability information has not been fetched.",
+} as const;
 
 export type CodexFastAvailability =
   | { kind: "available"; enabled: boolean }
   | { kind: "not-codex" }
-  | { kind: "unavailable"; reason: string };
+  | { kind: "unavailable"; reason: string }
+  | { kind: "unknown"; reason: string };
 
-export function codexFastAvailability(model: PiModel | undefined, enabled: boolean): CodexFastAvailability {
+export function codexFastAvailability(
+  model: PiModel | undefined,
+  enabled: boolean,
+  capability: CodexFastCapability = UNKNOWN_CODEX_FAST_CAPABILITY,
+): CodexFastAvailability {
   if (model?.provider !== "openai-codex") return { kind: "not-codex" };
   if (!isOfficialCodexModel(model)) {
     return {
@@ -28,7 +29,8 @@ export function codexFastAvailability(model: PiModel | undefined, enabled: boole
       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.`,
@@ -37,24 +39,30 @@ export function codexFastAvailability(model: PiModel | undefined, enabled: boole
   return { kind: "available", enabled };
 }
 
-export function codexFastIsEffective(model: PiModel | undefined, enabled: boolean): boolean {
-  return codexFastAvailability(model, enabled).kind === "available" && enabled;
+export function codexFastIsEffective(
+  model: PiModel | undefined,
+  enabled: boolean,
+  capability: CodexFastCapability = UNKNOWN_CODEX_FAST_CAPABILITY,
+): boolean {
+  return codexFastAvailability(model, enabled, capability).kind === "available" && enabled;
 }
 
 export function codexFastRequestTier(
   model: PiModel | undefined,
   enabled: boolean,
+  capability: CodexFastCapability = UNKNOWN_CODEX_FAST_CAPABILITY,
 ): typeof CODEX_FAST_SERVICE_TIER | typeof CODEX_STANDARD_SERVICE_TIER | undefined {
   if (!isOfficialCodexModel(model)) return undefined;
-  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;
 }
 
 export function rewriteCodexFastPayload(
   payload: unknown,
   model: PiModel | undefined,
   enabled: boolean,
+  capability: CodexFastCapability = UNKNOWN_CODEX_FAST_CAPABILITY,
 ): unknown | undefined {
-  const serviceTier = codexFastRequestTier(model, enabled);
+  const serviceTier = codexFastRequestTier(model, enabled, capability);
   if (!serviceTier || !isRecord(payload)) return undefined;
   return { ...payload, service_tier: serviceTier };
 }
@@ -63,9 +71,10 @@ export function correctCodexFastMessageCost(
   message: unknown,
   model: PiModel | undefined,
   fastRequested: boolean,
+  capability: CodexFastCapability = UNKNOWN_CODEX_FAST_CAPABILITY,
 ): unknown | undefined {
   if (
-    !codexFastIsEffective(model, fastRequested) ||
+    !codexFastIsEffective(model, fastRequested, capability) ||
     !isRecord(message) ||
     message.role !== "assistant" ||
     message.provider !== model?.provider ||
@@ -92,7 +101,7 @@ export function codexFastStatusLabel(status: string, enabled: boolean): string {
   return status === "codex" ? "codex fast" : `codex fast${status.slice("codex".length)}`;
 }
 
-function isOfficialCodexModel(model: PiModel | undefined): model is PiModel & { api: "openai-codex-responses" } {
+export function isOfficialCodexModel(model: PiModel | undefined): model is PiModel & { api: "openai-codex-responses" } {
   if (model?.provider !== "openai-codex" || !hasApi(model, "openai-codex-responses")) {
     return false;
   }