@diousk/pi-usage-fast 0.1.0 → 0.3.0

package/README.md

@@ -2,11 +2,11 @@
 
 [![npm](https://img.shields.io/npm/v/@diousk/pi-usage-fast)](https://www.npmjs.com/package/@diousk/pi-usage-fast) [![Pi extension](https://img.shields.io/badge/Pi-extension-blue)](https://pi.dev) [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](./LICENSE)
 
-Inspect usage and DeepSeek API balance for Pi's active provider account, query other configured providers, and toggle Fast mode for supported OpenAI Codex models.
+Inspect usage and DeepSeek API balance for Pi's active provider account, query other configured providers, and toggle Fast mode for supported OpenAI and Codex models.
 The extension keeps each provider's native quota, allowance, and spending semantics instead of treating unlike values as equivalent.
 xAI OAuth subscription reporting follows the reviewed Grok Build contract and runs only after an explicit `/usage` action.
 
-This fork of [pi-usage](https://github.com/narumiruna/pi-extensions/tree/main/packages/pi-usage) adds Fast mode support for `gpt-6-*` models.
+This fork of [pi-usage](https://github.com/narumiruna/pi-extensions/tree/main/packages/pi-usage) adds Fast mode support for `gpt-6-*` and `gpt-6.<minor>-*` models, including `gpt-6.1-sol`.
 Install it instead of the upstream pi-usage package to avoid duplicate commands and status updates.
 Existing `pi-usage.json` settings remain compatible.
 
@@ -51,19 +51,19 @@ The package declares `dist/index.ts`, so an unbuilt local checkout must run the
 
 Run `/usage` in TUI or RPC mode to inspect the active provider, refresh its usage, or choose another configured provider.
 When a provider exposes several billing targets, `/usage` asks for one target before querying usage.
-Run `/fast` to toggle Fast mode for a supported active Codex model.
+Run `/fast` to toggle Fast mode for a supported active OpenAI or Codex model.
 
 ## 💬 Commands
 
 | Command | Purpose |
 | --- | --- |
 | `/usage` | Query the active provider's usage, then manage provider queries, preferences, or eligible Codex resets. |
-| `/fast` | Toggle Fast mode for the active supported Codex model. |
+| `/fast` | Toggle Fast mode for the active supported OpenAI or Codex model. |
 
 Both commands support TUI and RPC, accept no arguments, and reject print and JSON modes.
 Cross-provider queries require an explicit interactive choice; there are no provider-ID, `--refresh`, or `--all` arguments.
 Requests use the matched provider credentials; see [Security and privacy](#-security-and-privacy).
-Fast mode uses more plan allowance; see [Codex Fast mode](#codex-fast-mode) for eligibility and when changes apply.
+Fast mode uses more plan allowance or API credits; see [Codex Fast mode](#codex-fast-mode) for eligibility and when changes apply.
 
 Codex reset redemption requires a freshly matched current OAuth account and explicit confirmation; **after confirmation, its progress view cannot cancel the reset**.
 Read the [query and reset guide](./docs/operations.md) for target selection, cancellation, and safe retry behavior.
@@ -87,11 +87,12 @@ A successful explicit Fireworks account selection writes the generic field and r
 
 ### Codex Fast mode
 
-Run `/fast` without arguments to toggle Fast for the active supported Codex model, or use **Turn Fast mode on/off** in `/usage`.
-Fast is about 1.5× faster and uses more of your plan allowance.
+Run `/fast` without arguments to toggle Fast for the active supported OpenAI or Codex model, or use **Turn Fast mode on/off** in `/usage`.
+Fast requests priority routing and consumes more plan allowance or API credits.
 The `codexFastMode` preference defaults to Off.
 
-Fast currently applies only to official `openai-codex-responses` requests for `gpt-5.5`, `gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`, and `gpt-6-*` models at `https://chatgpt.com`.
+Fast applies to official OpenAI Codex requests at `https://chatgpt.com` and OpenAI Responses requests at `https://api.openai.com`, including the newer ChatGPT sign-in and API-key billing. Supported models are `gpt-5.5`, `gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`, `gpt-6-*`, and `gpt-6.<minor>-*`.
+For example, `gpt-6.1-sol` supports the same toggle, routing, statusline, and priority cost correction as `gpt-6-sol`.
 It sends `service_tier: "priority"` while enabled and explicit `service_tier: "default"` otherwise.
 The statusline adds `fast` only while the preference is effective, for example `codex fast 59% ↻ 2h30m` with the default reset countdown.
 Unsupported models and custom or proxy origins are left unchanged.
@@ -132,6 +133,7 @@ Currencies and billing targets remain separate.
 | Provider | Reported data |
 | --- | --- |
 | OpenAI Codex | Subscription windows, credits, resets, and model buckets |
+| OpenAI | Links to ChatGPT plan usage or API billing; numeric quotas are unavailable through this authentication flow |
 | Kimi For Coding | Plan request windows and a separate booster wallet |
 | Moonshot AI Global/China | Current API balance in USD/CNY |
 | MiniMax Global/China | Token Plan windows or pay-as-you-go API balance |
@@ -146,6 +148,7 @@ Currencies and billing targets remain separate.
 | Z.AI | Coding Plan quota windows, MCP allowance, plan name, and renewal date |
 
 Read the [provider reference](./docs/providers.md) for provider IDs, exact endpoints, authentication requirements, normalization rules, statusline examples, limitations, and pinned contract evidence.
+For Pi's newer OpenAI ChatGPT sign-in, `/usage` links to [ChatGPT usage settings](https://chatgpt.com/settings/usage); API-key accounts link to API billing. Numeric quotas are not exposed through this flow, and its token is never sent to legacy Codex endpoints.
 Codex reset redemption requires a freshly matched current OAuth account and explicit confirmation; custom or proxy origins fail before mutation.
 
 ## 🧭 Current and configured accounts

package/dist/index.ts

@@ -9,17 +9,18 @@ var CODEX_FAST_MODEL_IDS = /* @__PURE__ */ new Set([
   "gpt-5.5",
   "gpt-5.6-luna",
   "gpt-5.6-sol",
-  "gpt-5.6-terra"
+  "gpt-5.6-terra",
+  "gpt-6.1-sol"
 ]);
 function supportsCodexFast(modelId) {
-  return CODEX_FAST_MODEL_IDS.has(modelId) || /^gpt-6-.+/u.test(modelId);
+  return CODEX_FAST_MODEL_IDS.has(modelId) || /^gpt-6(?:\.\d+)?-.+/u.test(modelId);
 }
 function codexFastAvailability(model, enabled) {
-  if (model?.provider !== "openai-codex") return { kind: "not-codex" };
+  if (model?.provider !== "openai-codex" && model?.provider !== "openai") return { kind: "not-codex" };
   if (!isOfficialCodexModel(model)) {
     return {
       kind: "unavailable",
-      reason: "Fast mode requires the official OpenAI Codex Responses endpoint."
+      reason: "Fast mode requires an official OpenAI Responses or Codex Responses endpoint."
     };
   }
   if (!supportsCodexFast(model.id)) {
@@ -64,11 +65,10 @@ function codexFastStatusLabel(status, enabled) {
   return status === "codex" ? "codex fast" : `codex fast${status.slice("codex".length)}`;
 }
 function isOfficialCodexModel(model) {
-  if (model?.provider !== "openai-codex" || !hasApi(model, "openai-codex-responses")) {
-    return false;
-  }
+  if (!model) return false;
   try {
-    return new URL(model.baseUrl).origin === "https://chatgpt.com";
+    const origin = new URL(model.baseUrl).origin;
+    return model.provider === "openai-codex" && hasApi(model, "openai-codex-responses") && origin === "https://chatgpt.com" || model.provider === "openai" && hasApi(model, "openai-responses") && origin === "https://api.openai.com";
   } catch {
     return false;
   }
@@ -1969,6 +1969,116 @@ function clampPercent3(value) {
   return Math.min(100, Math.max(0, value));
 }
 
+// src/usage-http.ts
+var MAX_SUCCESS_BODY_BYTES = 64 * 1024;
+var MAX_ERROR_BODY_BYTES = 4 * 1024;
+async function fetchProviderJson(url, auth, signal, timeoutMs, description, request = {}) {
+  const controller = new AbortController();
+  let timedOut = false;
+  const abortFromCaller = () => controller.abort();
+  if (signal.aborted) controller.abort();
+  else signal.addEventListener("abort", abortFromCaller, { once: true });
+  const timeout = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, timeoutMs);
+  try {
+    const headers = { ...auth.headers };
+    if (request.userAgent !== false && !hasHeader(headers, "User-Agent")) {
+      headers["User-Agent"] = "pi-usage";
+    }
+    if (request.body && !hasHeader(headers, "Content-Type")) {
+      headers["Content-Type"] = "application/json";
+    }
+    const response = await fetch(url, {
+      method: request.method ?? "GET",
+      headers,
+      ...request.body ? { body: JSON.stringify(request.body) } : {},
+      ...request.redirect ? { redirect: request.redirect } : {},
+      signal: controller.signal
+    });
+    if (response.redirected) throw new Error(`${description} refused a redirected response.`);
+    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,
+      description,
+      controller.signal
+    );
+    if (controller.signal.aborted) throw Object.assign(new Error("Usage query aborted."), { name: "AbortError" });
+    const responseError = request.responseError?.(response.status, text);
+    if (responseError) throw new Error(responseError);
+    if (!response.ok) {
+      throw new Error(
+        `${description} returned ${response.status} ${response.statusText}: ${redactUsageError(text, auth.secrets)}`
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch (error) {
+      throw new Error(`${description} returned invalid JSON: ${errorMessage(error)}`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error(`${description} response was not an object.`);
+    }
+    return parsed;
+  } catch (error) {
+    if (timedOut) {
+      throw new Error(`Timed out after ${Math.round(timeoutMs / 1e3)}s while fetching usage.`);
+    }
+    if (signal.aborted) throw Object.assign(new Error("Usage query aborted."), { name: "AbortError" });
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+    signal.removeEventListener("abort", abortFromCaller);
+  }
+}
+async function readBoundedResponse(response, maxBytes, truncateOverflow, description, signal) {
+  if (!response.body) return "";
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  let truncated = false;
+  const abort = () => void reader.cancel().catch(() => void 0);
+  if (signal.aborted) abort();
+  else signal.addEventListener("abort", abort, { once: true });
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const remaining = maxBytes - total;
+      if (value.byteLength > remaining) {
+        if (remaining > 0) chunks.push(value.subarray(0, remaining));
+        total = maxBytes;
+        truncated = true;
+        await reader.cancel();
+        break;
+      }
+      chunks.push(value);
+      total += value.byteLength;
+    }
+  } finally {
+    signal.removeEventListener("abort", abort);
+    reader.releaseLock();
+  }
+  if (truncated && !truncateOverflow) {
+    throw new Error(`${description} response exceeded ${maxBytes} bytes.`);
+  }
+  const body = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  const text = new TextDecoder().decode(body);
+  return truncated ? `${text}\u2026` : text;
+}
+function hasHeader(headers, name) {
+  return Object.keys(headers).some((key) => key.toLowerCase() === name.toLowerCase());
+}
+
 // src/usage-targets.ts
 var MAX_TARGETS = 1e3;
 var MAX_TARGET_ID_CHARS = 256;
@@ -2083,10 +2193,30 @@ var XAI_CLIENT_HEADERS = Object.freeze({
   "x-grok-client-version": "1.0.10",
   "x-grok-client-mode": "interactive"
 });
-var MAX_SUCCESS_BODY_BYTES = 64 * 1024;
-var MAX_ERROR_BODY_BYTES = 4 * 1024;
 var AUTH_FINGERPRINT_SALT = randomBytes(32);
 var SUPPORTED_ADAPTERS = [
+  {
+    id: "openai",
+    displayName: "OpenAI",
+    semantics: { kind: "consumer-subscription", label: "ChatGPT plan usage" },
+    publishesStatusline: false,
+    async query(auth) {
+      const subscription = auth.chatgptPlan === true;
+      return {
+        providerId: "openai",
+        providerName: subscription ? "OpenAI (ChatGPT)" : "OpenAI API",
+        capturedAt: Date.now(),
+        source: "openai-usage-settings",
+        semantics: subscription ? { kind: "consumer-subscription", label: "ChatGPT plan usage" } : { kind: "api-key", label: "OpenAI API usage" },
+        buckets: [],
+        metrics: [],
+        notes: [
+          subscription ? "Review plan usage and app limits in ChatGPT Settings \u2192 Usage: https://chatgpt.com/settings/usage" : "Review OpenAI API usage and billing: https://platform.openai.com/usage",
+          "Numeric usage is unavailable through this authentication flow; no quota is inferred."
+        ]
+      };
+    }
+  },
   {
     id: "baseten",
     displayName: "Baseten",
@@ -2332,7 +2462,7 @@ async function resolveUsageAuth(ctx, adapter, salt = AUTH_FINGERPRINT_SALT, cred
   }
   const model = candidateModels(ctx, adapter.id).find((candidate) => hasOfficialOrigin(candidate, adapter.id));
   if (!model) return void 0;
-  if (["github-copilot", "xai"].includes(adapter.id) && candidateReader?.waitUntilReady && !await candidateReader.waitUntilReady(ctx, adapter.id)) {
+  if (["github-copilot", "xai", "openai"].includes(adapter.id) && candidateReader?.waitUntilReady && !await candidateReader.waitUntilReady(ctx, adapter.id)) {
     throw new Error(`${adapter.displayName} OAuth credential readiness failed closed.`);
   }
   const registry = ctx.modelRegistry;
@@ -2441,12 +2571,27 @@ async function resolveUsageAuth(ctx, adapter, salt = AUTH_FINGERPRINT_SALT, cred
   const secrets = [auth.apiKey, headerValue(auth.headers, "Authorization"), authorization].filter(
     (value) => Boolean(value)
   );
+  let chatgptPlan;
+  if (adapter.id === "openai") {
+    const offered = candidateReader ? await candidateReader(ctx, adapter.id) : fallbackOAuthCredentialCandidates(adapter.id, credentialReader);
+    if (!offered.ok) throw new Error("OpenAI OAuth credential discovery failed closed.");
+    const access = bearerToken(authorization);
+    chatgptPlan = offered.candidates.some(
+      (credential) => credential.access === access && Array.isArray(credential.scopes) && credential.scopes.includes("chatgpt.tokens.use.direct")
+    );
+    if (!chatgptPlan && providerResult?.source === "OAuth") {
+      throw new Error(
+        "The active OpenAI OAuth credential does not match an available ChatGPT plan credential; reload after account activation."
+      );
+    }
+  }
   return finalize({
     apiKey: auth.apiKey,
     headers,
     fingerprint: "",
     secrets,
-    model
+    model,
+    ...chatgptPlan !== void 0 ? { chatgptPlan } : {}
   });
 }
 async function queryProviderUsage(adapter, auth, signal, timeoutMs, guard, targetOrSettings) {
@@ -2522,109 +2667,6 @@ function candidateModels(ctx, providerId) {
   for (const model of ctx.modelRegistry.getAll()) add(model);
   return candidates;
 }
-async function fetchProviderJson(url, auth, signal, timeoutMs, description, request = {}) {
-  const controller = new AbortController();
-  let timedOut = false;
-  const abortFromCaller = () => controller.abort();
-  if (signal.aborted) controller.abort();
-  else signal.addEventListener("abort", abortFromCaller, { once: true });
-  const timeout = setTimeout(() => {
-    timedOut = true;
-    controller.abort();
-  }, timeoutMs);
-  try {
-    const headers = { ...auth.headers };
-    if (request.userAgent !== false && !hasHeader(headers, "User-Agent")) {
-      headers["User-Agent"] = "pi-usage";
-    }
-    if (request.body && !hasHeader(headers, "Content-Type")) {
-      headers["Content-Type"] = "application/json";
-    }
-    const response = await fetch(url, {
-      method: request.method ?? "GET",
-      headers,
-      ...request.body ? { body: JSON.stringify(request.body) } : {},
-      ...request.redirect ? { redirect: request.redirect } : {},
-      signal: controller.signal
-    });
-    if (response.redirected) throw new Error(`${description} refused a redirected response.`);
-    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,
-      description,
-      controller.signal
-    );
-    if (controller.signal.aborted) throw Object.assign(new Error("Usage query aborted."), { name: "AbortError" });
-    const responseError = request.responseError?.(response.status, text);
-    if (responseError) throw new Error(responseError);
-    if (!response.ok) {
-      throw new Error(
-        `${description} returned ${response.status} ${response.statusText}: ${redactUsageError(text, auth.secrets)}`
-      );
-    }
-    let parsed;
-    try {
-      parsed = JSON.parse(text);
-    } catch (error) {
-      throw new Error(`${description} returned invalid JSON: ${errorMessage(error)}`);
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      throw new Error(`${description} response was not an object.`);
-    }
-    return parsed;
-  } catch (error) {
-    if (timedOut) {
-      throw new Error(`Timed out after ${Math.round(timeoutMs / 1e3)}s while fetching usage.`);
-    }
-    if (signal.aborted) throw Object.assign(new Error("Usage query aborted."), { name: "AbortError" });
-    throw error;
-  } finally {
-    clearTimeout(timeout);
-    signal.removeEventListener("abort", abortFromCaller);
-  }
-}
-async function readBoundedResponse(response, maxBytes, truncateOverflow, description, signal) {
-  if (!response.body) return "";
-  const reader = response.body.getReader();
-  const chunks = [];
-  let total = 0;
-  let truncated = false;
-  const abort = () => void reader.cancel().catch(() => void 0);
-  if (signal.aborted) abort();
-  else signal.addEventListener("abort", abort, { once: true });
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      const remaining = maxBytes - total;
-      if (value.byteLength > remaining) {
-        if (remaining > 0) chunks.push(value.subarray(0, remaining));
-        total = maxBytes;
-        truncated = true;
-        await reader.cancel();
-        break;
-      }
-      chunks.push(value);
-      total += value.byteLength;
-    }
-  } finally {
-    signal.removeEventListener("abort", abort);
-    reader.releaseLock();
-  }
-  if (truncated && !truncateOverflow) {
-    throw new Error(`${description} response exceeded ${maxBytes} bytes.`);
-  }
-  const body = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    body.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  const text = new TextDecoder().decode(body);
-  return truncated ? `${text}\u2026` : text;
-}
 function resolveXaiUsageAuth(auth, model, salt, candidates) {
   const resolvedAccess = bearerToken(headerValue(auth.headers, "Authorization")) ?? auth.apiKey;
   if (!resolvedAccess) throw new Error("xAI runtime authentication was incomplete.");
@@ -2770,6 +2812,7 @@ function hasOfficialUrlOrigin(value, providerId) {
       return ["https://inference.baseten.co", "https://api.baseten.co"].includes(url.origin);
     }
     if (providerId === "openai-codex") return url.origin === "https://chatgpt.com";
+    if (providerId === "openai") return url.origin === "https://api.openai.com";
     if (providerId === "deepseek") return url.origin === "https://api.deepseek.com";
     if (providerId === "fireworks") return url.origin === "https://api.fireworks.ai";
     if (providerId === "openrouter") return url.origin === "https://openrouter.ai";
@@ -2795,9 +2838,6 @@ function headerValue(headers, name) {
   const entry = Object.entries(headers ?? {}).find(([candidate]) => candidate.toLowerCase() === name.toLowerCase());
   return entry?.[1] ?? void 0;
 }
-function hasHeader(headers, name) {
-  return Object.keys(headers).some((key) => key.toLowerCase() === name.toLowerCase());
-}
 function validatedXaiUserId(value) {
   if (typeof value !== "string" || !/^[A-Za-z0-9._~-]{1,128}$/u.test(value)) {
     throw new Error("xAI consumer identity returned an unsafe canonical user ID.");
@@ -3999,7 +4039,7 @@ import { randomUUID as randomUUID2 } from "node:crypto";
 
 // 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.";
+var FAST_USAGE_WARNING = "Fast uses priority routing and consumes more plan allowance or API credits.";
 function registerCodexFastMode(pi, settingsRuntime, refreshStatus, options = {}) {
   let sessionController = new AbortController();
   let generation = 0;
@@ -4036,7 +4076,7 @@ function registerCodexFastMode(pi, settingsRuntime, refreshStatus, options = {})
       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");
+        ctx.ui.notify("/fast requires a supported OpenAI or OpenAI Codex model.", "warning");
         return;
       }
       if (availability.kind === "unavailable") {