@narumitw/pi-usage 0.64.3 → 0.65.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@narumitw/pi-usage",
-  "version": "0.64.3",
+  "version": "0.65.0",
   "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;
   }

package/src/index.ts

@@ -1,5 +1,5 @@
+export type { CodexFastAvailability, CodexFastCapability } from "./codex-fast.js";
 export {
-  CODEX_FAST_MODEL_IDS,
   CODEX_FAST_SERVICE_TIER,
   CODEX_STANDARD_SERVICE_TIER,
   codexFastAvailability,
@@ -7,7 +7,9 @@ export {
   codexFastRequestTier,
   codexFastStatusLabel,
   correctCodexFastMessageCost,
+  isOfficialCodexModel,
   rewriteCodexFastPayload,
+  UNKNOWN_CODEX_FAST_CAPABILITY,
 } from "./codex-fast.js";
 export type {
   CodexResetAvailability,

package/src/query.ts

@@ -679,6 +679,7 @@ export async function fetchProviderJson(
     body?: Record<string, unknown>;
     redirect?: RequestRedirect;
     userAgent?: boolean;
+    maxSuccessBodyBytes?: number;
     responseError?: (status: number, text: string) => string | undefined;
   } = {},
 ): Promise<Record<string, unknown>> {
@@ -710,7 +711,7 @@ export async function fetchProviderJson(
     if (controller.signal.aborted) throw Object.assign(new Error("Usage query aborted."), { name: "AbortError" });
     const text = await readBoundedResponse(
       response,
-      response.ok ? MAX_SUCCESS_BODY_BYTES : MAX_ERROR_BODY_BYTES,
+      response.ok ? (request.maxSuccessBodyBytes ?? MAX_SUCCESS_BODY_BYTES) : MAX_ERROR_BODY_BYTES,
       !response.ok,
       description,
       controller.signal,