@diousk/pi-usage-fast 0.2.0 → 0.3.0

package/docs/providers.md

@@ -5,6 +5,7 @@
 This reference preserves each provider's endpoint, authentication boundary, billing semantics, and contract evidence.
 The README contains the capability overview and shared security requirements.
 
+- [OpenAI](#openai)
 - [OpenAI Codex](#openai-codex)
 - [Kimi For Coding](#kimi-for-coding)
 - [Moonshot AI](#moonshot-ai-api-balance)
@@ -21,6 +22,21 @@ The README contains the capability overview and shared security requirements.
 
 ## 📋 Provider semantics
 
+### OpenAI
+
+- Provider ID: `openai`
+- Semantics: ChatGPT subscription management or API billing, selected from the active runtime credential
+- Source: no quota request; links to [ChatGPT usage settings](https://chatgpt.com/settings/usage) or [API usage](https://platform.openai.com/usage)
+- Displayed data: a management link without numeric quotas, reset estimates, or statusline percentages
+
+The newer ChatGPT sign-in uses OpenAI's public Responses API at `https://api.openai.com`.
+An exactly matching OAuth credential with the `chatgpt.tokens.use.direct` scope identifies plan usage; API-key credentials select API billing.
+Compatible pending account activation finishes before credentials are resolved, and an unmatched OAuth account fails closed.
+Custom or proxy origins are rejected before credential resolution.
+
+OpenAI's [token-sharing inference contract](https://developers.openai.com/siwc/token-sharing-open-source/models-and-inference) requires the public API rather than ChatGPT backend endpoints.
+Its [usage-management guidance](https://developers.openai.com/siwc/ui-ux-guidelines) provides the settings destination, so this adapter never sends the new token to legacy Codex quota or reset endpoints.
+
 ### OpenAI Codex
 
 - Provider ID: `openai-codex`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diousk/pi-usage-fast",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Pi provider usage and API balance extension with Codex Fast mode support for gpt-6-* models.",
   "type": "module",
   "license": "MIT",
@@ -57,9 +57,9 @@
     "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "0.86.0",
-    "@earendil-works/pi-coding-agent": "0.86.0",
-    "@earendil-works/pi-tui": "0.86.0",
+    "@earendil-works/pi-ai": "1.3.0",
+    "@earendil-works/pi-coding-agent": "1.3.0",
+    "@earendil-works/pi-tui": "1.3.0",
     "@types/node": "26.6.2",
     "esbuild": "0.28.2",
     "typescript": "7.0.2"

package/src/codex-fast-runtime.ts

@@ -14,7 +14,7 @@ import type { PiModel } from "./types.js";
 const NO_FAST_REQUEST = Symbol("no-fast-request");
 type PendingFastRequest = { fastRequested: boolean; model: PiModel };
 
-export const FAST_USAGE_WARNING = "Fast is about 1.5× faster and uses more of your plan allowance.";
+export const FAST_USAGE_WARNING = "Fast uses priority routing and consumes more plan allowance or API credits.";
 
 export function registerCodexFastMode(
   pi: ExtensionAPI,
@@ -65,7 +65,7 @@ export function registerCodexFastMode(
       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") {

package/src/codex-fast.ts

@@ -9,6 +9,7 @@ export const CODEX_FAST_MODEL_IDS: ReadonlySet<string> = new Set([
   "gpt-5.6-luna",
   "gpt-5.6-sol",
   "gpt-5.6-terra",
+  "gpt-6.1-sol",
 ]);
 
 function supportsCodexFast(modelId: string): boolean {
@@ -21,11 +22,11 @@ export type CodexFastAvailability =
   | { kind: "unavailable"; reason: string };
 
 export function codexFastAvailability(model: PiModel | undefined, enabled: boolean): CodexFastAvailability {
-  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)) {
@@ -92,12 +93,18 @@ 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" } {
-  if (model?.provider !== "openai-codex" || !hasApi(model, "openai-codex-responses")) {
-    return false;
-  }
+function isOfficialCodexModel(
+  model: PiModel | undefined,
+): model is PiModel & { api: "openai-codex-responses" | "openai-responses" } {
+  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;
   }

package/src/query.ts

@@ -1,5 +1,5 @@
-// This module intentionally keeps adapter transport beside resolved-auth and origin validation;
-// separating that security boundary would duplicate request and redaction policy across providers.
+// Adapter selection, resolved auth and origin validation share this provider security boundary.
+// Bounded HTTP transport lives separately and receives only validated request auth.
 import { randomBytes } from "node:crypto";
 import { type ExtensionContext, readStoredCredential } from "@earendil-works/pi-coding-agent";
 import { errorMessage, fingerprintResolvedAuth, redactUsageError } from "./core.js";
@@ -41,8 +41,11 @@ import type {
   ZaiQuotaPayload,
   ZaiSubscriptionPayload,
 } from "./types.js";
+import { fetchProviderJson } from "./usage-http.js";
 import { resolveUsageTarget } from "./usage-targets.js";
 
+export { fetchProviderJson } from "./usage-http.js";
+
 const BASETEN_BILLING_USAGE_URL = "https://api.baseten.co/v1/billing/usage_summary";
 const BASETEN_USAGE_WINDOW_DAYS = 30;
 const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
@@ -68,12 +71,36 @@ const XAI_CLIENT_HEADERS = Object.freeze({
   "x-grok-client-version": "1.0.10",
   "x-grok-client-mode": "interactive",
 });
-const MAX_SUCCESS_BODY_BYTES = 64 * 1024;
-const MAX_ERROR_BODY_BYTES = 4 * 1024;
 
 export const AUTH_FINGERPRINT_SALT = randomBytes(32);
 
 export const SUPPORTED_ADAPTERS: readonly UsageProviderAdapter[] = [
+  {
+    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 → 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",
@@ -344,7 +371,7 @@ export async function resolveUsageAuth(
   const model = candidateModels(ctx, adapter.id).find((candidate) => hasOfficialOrigin(candidate, adapter.id));
   if (!model) return undefined;
   if (
-    ["github-copilot", "xai"].includes(adapter.id) &&
+    ["github-copilot", "xai", "openai"].includes(adapter.id) &&
     candidateReader?.waitUntilReady &&
     !(await candidateReader.waitUntilReady(ctx, adapter.id))
   ) {
@@ -463,12 +490,32 @@ export async function resolveUsageAuth(
   const secrets = [auth.apiKey, headerValue(auth.headers, "Authorization"), authorization].filter(
     (value): value is string => Boolean(value),
   );
+  let chatgptPlan: boolean | undefined;
+  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,
+    ...(chatgptPlan !== undefined ? { chatgptPlan } : {}),
   });
 }
 
@@ -576,130 +623,6 @@ function candidateModels(ctx: ExtensionContext, providerId: string): PiModel[] {
   return candidates;
 }
 
-export async function fetchProviderJson(
-  url: string,
-  auth: ResolvedUsageAuth,
-  signal: AbortSignal,
-  timeoutMs: number,
-  description: string,
-  request: {
-    method?: "GET" | "POST";
-    body?: Record<string, unknown>;
-    redirect?: RequestRedirect;
-    userAgent?: boolean;
-    responseError?: (status: number, text: string) => string | undefined;
-  } = {},
-): Promise<Record<string, unknown>> {
-  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: unknown;
-    try {
-      parsed = JSON.parse(text) as unknown;
-    } 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 as Record<string, unknown>;
-  } catch (error) {
-    if (timedOut) {
-      throw new Error(`Timed out after ${Math.round(timeoutMs / 1000)}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: Response,
-  maxBytes: number,
-  truncateOverflow: boolean,
-  description: string,
-  signal: AbortSignal,
-): Promise<string> {
-  if (!response.body) return "";
-  const reader = response.body.getReader();
-  const chunks: Uint8Array[] = [];
-  let total = 0;
-  let truncated = false;
-  const abort = () => void reader.cancel().catch(() => undefined);
-  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}…` : text;
-}
-
 type RequestAuth = {
   apiKey?: string;
   headers?: Record<string, string | null>;
@@ -898,6 +821,7 @@ function hasOfficialUrlOrigin(value: string, providerId: string): boolean {
       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";
@@ -925,10 +849,6 @@ function headerValue(headers: Record<string, string | null> | undefined, name: s
   return entry?.[1] ?? undefined;
 }
 
-function hasHeader(headers: Record<string, string>, name: string): boolean {
-  return Object.keys(headers).some((key) => key.toLowerCase() === name.toLowerCase());
-}
-
 function validatedXaiUserId(value: unknown): string {
   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.");

package/src/types.ts

@@ -48,6 +48,7 @@ export interface UsageReport {
 }
 
 export interface ResolvedUsageAuth {
+  chatgptPlan?: boolean;
   apiKey?: string;
   headers: Record<string, string>;
   fingerprint: string;

package/src/usage-http.ts

@@ -0,0 +1,133 @@
+import { errorMessage, redactUsageError } from "./core.js";
+import type { ResolvedUsageAuth } from "./types.js";
+
+const MAX_SUCCESS_BODY_BYTES = 64 * 1024;
+const MAX_ERROR_BODY_BYTES = 4 * 1024;
+
+export async function fetchProviderJson(
+  url: string,
+  auth: ResolvedUsageAuth,
+  signal: AbortSignal,
+  timeoutMs: number,
+  description: string,
+  request: {
+    method?: "GET" | "POST";
+    body?: Record<string, unknown>;
+    redirect?: RequestRedirect;
+    userAgent?: boolean;
+    responseError?: (status: number, text: string) => string | undefined;
+  } = {},
+): Promise<Record<string, unknown>> {
+  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: unknown;
+    try {
+      parsed = JSON.parse(text) as unknown;
+    } 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 as Record<string, unknown>;
+  } catch (error) {
+    if (timedOut) {
+      throw new Error(`Timed out after ${Math.round(timeoutMs / 1000)}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: Response,
+  maxBytes: number,
+  truncateOverflow: boolean,
+  description: string,
+  signal: AbortSignal,
+): Promise<string> {
+  if (!response.body) return "";
+  const reader = response.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let total = 0;
+  let truncated = false;
+  const abort = () => void reader.cancel().catch(() => undefined);
+  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}…` : text;
+}
+
+function hasHeader(headers: Record<string, string>, name: string): boolean {
+  return Object.keys(headers).some((key) => key.toLowerCase() === name.toLowerCase());
+}