pi-myusage 0.1.0

package/src/auth.ts

@@ -0,0 +1,104 @@
+import { getAgentDir, readStoredCredential, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { Credentials, ProviderTarget } from "./types.ts";
+
+function bearerOf(headers: Record<string, string> | undefined, apiKey: string | undefined): string | undefined {
+  const auth = headers?.Authorization ?? headers?.authorization;
+  if (auth) return auth.startsWith("Bearer ") ? auth.slice(7) : auth;
+  return apiKey;
+}
+
+function normalizeHeaders(headers: unknown): Record<string, string> | undefined {
+  if (!headers || typeof headers !== "object") return undefined;
+  const out: Record<string, string> = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (typeof value === "string") out[key] = value;
+  }
+  return Object.keys(out).length ? out : undefined;
+}
+
+async function readAuthJson(): Promise<Record<string, Record<string, unknown>>> {
+  try {
+    return JSON.parse(await readFile(join(getAgentDir(), "auth.json"), "utf8")) as never;
+  } catch {
+    return {};
+  }
+}
+
+const STATIC_CREDENTIAL_TTL_MS = 30_000;
+const credentialMemo = new Map<string, { value: Credentials | undefined; at: number }>();
+
+export async function resolveCredentials(
+  ctx: ExtensionContext,
+  target: ProviderTarget,
+): Promise<Credentials | undefined> {
+  const memo = credentialMemo.get(target.providerId);
+  if (memo && Date.now() - memo.at <= STATIC_CREDENTIAL_TTL_MS) return memo.value;
+  const resolved = await resolveCredentialsUncached(ctx, target);
+  const oauth = Boolean(target.model && ctx.modelRegistry.isUsingOAuth(target.model));
+  if (resolved === undefined || (resolved.source === "model" && !oauth)) {
+    credentialMemo.set(target.providerId, { value: resolved, at: Date.now() });
+  }
+  return resolved;
+}
+
+async function attempt<T>(step: () => Promise<T>): Promise<T | undefined> {
+  try {
+    return await step();
+  } catch {
+    return undefined;
+  }
+}
+
+async function resolveCredentialsUncached(
+  ctx: ExtensionContext,
+  target: ProviderTarget,
+): Promise<Credentials | undefined> {
+  const model = target.model;
+  if (model) {
+    const resolved = await attempt(() => ctx.modelRegistry.getApiKeyAndHeaders(model));
+    if (resolved?.ok) {
+      const headers = normalizeHeaders(resolved.headers);
+      const apiKey = bearerOf(headers, resolved.apiKey);
+      if (apiKey || headers) {
+        return { apiKey, headers, baseUrl: resolved.baseUrl ?? model.baseUrl, source: "model" };
+      }
+    }
+  }
+
+  const providerAuth = await attempt(() => ctx.modelRegistry.getProviderAuth(target.providerId));
+  if (providerAuth) {
+    const auth = providerAuth.auth;
+    const headers = normalizeHeaders(auth?.headers);
+    const apiKey = auth ? bearerOf(headers, auth.apiKey) : undefined;
+    if (apiKey || headers) {
+      return { apiKey, headers, baseUrl: auth?.baseUrl ?? target.baseUrl, source: "provider" };
+    }
+  }
+
+  const stored = readStoredCredential(target.providerId);
+  if (stored && typeof stored === "object") {
+    const record = stored as Record<string, unknown>;
+    const headers = normalizeHeaders(record.headers);
+    const apiKey = bearerOf(headers, record.apiKey as string | undefined);
+    if (apiKey) return { apiKey, headers, source: "stored" };
+  }
+
+  const raw = (await readAuthJson())[target.providerId];
+  if (raw) {
+    const headers = normalizeHeaders(raw.headers);
+    const apiKey = bearerOf(headers, raw.apiKey as string | undefined);
+    if (apiKey) return { apiKey, headers, source: "stored" };
+  }
+  return undefined;
+}
+
+export async function codexAccountId(_ctx: ExtensionContext, creds: Credentials | undefined): Promise<string | undefined> {
+  if (creds?.headers?.["chatgpt-account-id"] ?? creds?.headers?.["ChatGPT-Account-Id"]) {
+    return (creds.headers["chatgpt-account-id"] ?? creds.headers["ChatGPT-Account-Id"]) as string;
+  }
+  const raw = (await readAuthJson())["openai-codex"];
+  const id = raw?.accountId ?? raw?.chatgpt_account_id ?? raw?.account_id;
+  return typeof id === "string" ? id : undefined;
+}

package/src/codex-fast.ts

@@ -0,0 +1,94 @@
+import type { Api, Model } from "@earendil-works/pi-ai";
+
+export type FastMode = false | "fast" | "ultrafast";
+
+export const FAST_TIER = "priority";
+export const ULTRAFAST_TIER = "ultrafast";
+const STANDARD_TIER = "default";
+
+export function supportsCodexFastModelId(modelId: string): boolean {
+  return modelId.toLowerCase().startsWith("gpt-");
+}
+
+export function codexFastCostMultiplier(modelId: string): number {
+  return modelId === "gpt-5.5" ? 2.5 : 2;
+}
+
+export function tierForMode(mode: FastMode): string {
+  if (mode === "ultrafast") return ULTRAFAST_TIER;
+  if (mode === "fast") return FAST_TIER;
+  return STANDARD_TIER;
+}
+
+function isOpenAiApi(model: Model<Api> | undefined): boolean {
+  return typeof model?.api === "string" && model.api.startsWith("openai");
+}
+
+function isOfficialCodexModel(model: Model<Api> | undefined): boolean {
+  if (!model || model.provider !== "openai-codex") return false;
+  try {
+    return new URL(model.baseUrl).origin === "https://chatgpt.com";
+  } catch {
+    return false;
+  }
+}
+
+export type CodexFastAvailability =
+  | { kind: "available"; mode: FastMode }
+  | { kind: "unavailable"; reason: string };
+
+/** Fast and Ultrafast apply to any gpt-* model on an OpenAI-family API, regardless of provider or gateway. */
+export function codexFastAvailability(model: Model<Api> | undefined, mode: FastMode): CodexFastAvailability {
+  if (!model) return { kind: "unavailable", reason: "No active model." };
+  if (!supportsCodexFastModelId(model.id)) {
+    return { kind: "unavailable", reason: `${model.id} does not support Fast or Ultrafast.` };
+  }
+  if (!isOpenAiApi(model)) {
+    return { kind: "unavailable", reason: "Fast and Ultrafast require an OpenAI-family API." };
+  }
+  return { kind: "available", mode };
+}
+
+export function rewriteServiceTierPayload(
+  payload: unknown,
+  model: Model<Api> | undefined,
+  mode: FastMode,
+): unknown | undefined {
+  if (!model || !supportsCodexFastModelId(model.id) || !isOpenAiApi(model) || !isRecord(payload)) {
+    return undefined;
+  }
+  return { ...payload, service_tier: tierForMode(mode) };
+}
+
+export function fastSuffix(mode: FastMode): string | undefined {
+  return mode === false ? undefined : mode;
+}
+
+export function fastModeIsEffective(model: Model<Api> | undefined, mode: FastMode): boolean {
+  return mode !== false && codexFastAvailability(model, mode).kind === "available";
+}
+
+/** Cost correction (×2/×2.5 priority pricing) applies only to Fast on the official Codex endpoint. */
+export function correctCodexFastMessage(
+  message: unknown,
+  model: Model<Api> | undefined,
+  tier: string,
+): { message: unknown } | undefined {
+  if (tier !== FAST_TIER || !isOfficialCodexModel(model) || !isRecord(message) || message.role !== "assistant") {
+    return undefined;
+  }
+  const usage = isRecord(message.usage) ? message.usage : undefined;
+  const cost = usage && isRecord(usage.cost) ? usage.cost : undefined;
+  if (!usage || !cost) return undefined;
+  const multiplier = codexFastCostMultiplier(model?.id ?? "");
+  const corrected = structuredClone(usage) as Record<string, unknown>;
+  const correctedCost = corrected.cost as Record<string, number>;
+  for (const key of ["input", "output", "cacheRead", "cacheWrite", "total"] as const) {
+    if (typeof correctedCost[key] === "number") correctedCost[key] *= multiplier;
+  }
+  return { message: { ...message, usage: corrected } };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/format.ts

@@ -0,0 +1,94 @@
+import type { Metric, UsageSnapshot } from "./types.ts";
+
+export type QuotaWindowMetric = Extract<Metric, { kind: "quota-window" }>;
+
+export function windowsSummary(windows: readonly QuotaWindowMetric[]): string | undefined {
+  if (!windows.length) return undefined;
+  const firstWord = (windows[0].label.split(" ")[0] ?? "").trim();
+  const sharedPrefix =
+    windows.length > 1 && firstWord && windows.every((w) => w.label.startsWith(`${firstWord} `))
+      ? `${firstWord} `
+      : "";
+  const parts = windows.map((w, index) => {
+    const label = sharedPrefix && index > 0 ? w.label.slice(sharedPrefix.length) : w.label;
+    const reset = shortReset(w.resetAt);
+    return `${label} ${Math.round(w.remainingFraction * 100)}%${reset ? ` (${reset})` : ""}`;
+  });
+  return parts.join(" · ");
+}
+
+export function shortReset(resetAt: string | undefined): string | undefined {
+  const text = relativeTime(resetAt);
+  if (!text) return undefined;
+  if (text === "reset due") return "due";
+  return text.replace(/^resets in /, "");
+}
+
+export function percentBar(fraction: number, width = 10): string {
+  const clamped = Math.min(1, Math.max(0, fraction));
+  const count = Math.round(clamped * width);
+  return `${"━".repeat(count)}${"─".repeat(width - count)}`;
+}
+
+export function relativeTime(value?: string): string | undefined {
+  if (!value) return undefined;
+  const delta = new Date(value).getTime() - Date.now();
+  if (!Number.isFinite(delta)) return undefined;
+  if (delta <= 0) return "reset due";
+  const minutes = Math.ceil(delta / 60_000);
+  if (minutes < 60) return `resets in ${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  const mins = minutes % 60;
+  if (hours < 48) return `resets in ${hours}h${mins ? ` ${mins}m` : ""}`;
+  return `resets in ${Math.floor(hours / 24)}d ${hours % 24}h`;
+}
+
+export function metricText(metric: Metric): string {
+  switch (metric.kind) {
+    case "balance": {
+      const symbol =
+        metric.currency === "CNY" || metric.currency === "RMB"
+          ? "¥"
+          : metric.currency === "USD"
+            ? "$"
+            : `${metric.currency} `;
+      return `${metric.label}: ${symbol}${metric.amount.toFixed(2)}${metric.detail ? ` · ${metric.detail}` : ""}`;
+    }
+    case "quota-window": {
+      const reset = relativeTime(metric.resetAt);
+      return `${metric.label} ${percentBar(metric.remainingFraction)} ${Math.round(metric.remainingFraction * 100)}% left${reset ? ` · ${reset}` : ""}`;
+    }
+    case "usage-limit":
+      return `${metric.label}: ${metric.used}/${metric.limit} ${metric.unit}`;
+    case "status":
+      return `${metric.label}: ${metric.value}`;
+  }
+}
+
+export function compactStatus(snapshot: UsageSnapshot | undefined): string | undefined {
+  if (!snapshot) return undefined;
+  if (snapshot.summary) return snapshot.summary;
+  switch (snapshot.state) {
+    case "ok":
+    case "empty":
+      return undefined;
+    case "unauthorized":
+      return `${snapshot.displayName}: auth needed`;
+    case "unsupported":
+      return `${snapshot.displayName}: unsupported`;
+    default:
+      return `${snapshot.displayName}: unavailable`;
+  }
+}
+
+export function detailLines(snapshot: UsageSnapshot): string[] {
+  const lines = [`${snapshot.displayName} [${snapshot.state}]`];
+  if (snapshot.error) lines.push(`  Error: ${snapshot.error}`);
+  if (!snapshot.accounts.length) lines.push("  No data");
+  for (const account of snapshot.accounts) {
+    lines.push(`  ${account.label}`);
+    if (!account.metrics.length) lines.push("    No metrics reported");
+    for (const metric of account.metrics) lines.push(`    ${metricText(metric)}`);
+  }
+  return lines;
+}

package/src/http.ts

@@ -0,0 +1,62 @@
+export class HttpError extends Error {
+  constructor(
+    readonly status: number,
+    readonly body: string,
+  ) {
+    super(`HTTP ${status}: ${body.slice(0, 200)}`);
+    this.name = "HttpError";
+  }
+}
+
+export async function fetchJson<T>(
+  url: string | URL,
+  init: RequestInit & { timeoutMs?: number },
+  signal?: AbortSignal,
+): Promise<T> {
+  const { timeoutMs = 15_000, ...rest } = init;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const onAbort = () => controller.abort(signal?.reason);
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    const response = await fetch(url, {
+      redirect: "error",
+      ...rest,
+      signal: AbortSignal.any([rest.signal ?? controller.signal, controller.signal]),
+    });
+    const text = await response.text();
+    if (!response.ok) throw new HttpError(response.status, text);
+    try {
+      return text ? (JSON.parse(text) as T) : ({} as T);
+    } catch {
+      throw new Error(`Invalid JSON from ${new URL(url.toString()).origin}`);
+    }
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", onAbort);
+  }
+}
+
+export function urlOrigin(url: string | undefined): string | undefined {
+  if (!url) return undefined;
+  try {
+    return new URL(url).origin;
+  } catch {
+    return undefined;
+  }
+}
+
+export function urlOnDomain(url: string | undefined, domain: string): boolean {
+  const origin = urlOrigin(url);
+  if (!origin) return false;
+  try {
+    return new URL(origin).hostname === domain || new URL(origin).hostname.endsWith(`.${domain}`);
+  } catch {
+    return false;
+  }
+}
+
+export function safeError(error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.replace(/[A-Za-z0-9_-]{24,}/g, "…").slice(0, 300);
+}

package/src/match.ts

@@ -0,0 +1,83 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { Api, Model } from "@earendil-works/pi-ai";
+import { codexAccountId, resolveCredentials } from "./auth.ts";
+import { anthropicAdapter } from "./adapters/anthropic.ts";
+import { basetenAdapter } from "./adapters/baseten.ts";
+import { clineAdapter } from "./adapters/cline.ts";
+import { cliproxyAdapter } from "./adapters/cliproxy.ts";
+import { deepseekAdapter } from "./adapters/deepseek.ts";
+import { fireworksAdapter } from "./adapters/fireworks.ts";
+import { geminiAdapter } from "./adapters/gemini.ts";
+import { githubCopilotAdapter } from "./adapters/github-copilot.ts";
+import { glmAdapter } from "./adapters/glm.ts";
+import { kimiAdapter } from "./adapters/kimi.ts";
+import { minimaxAdapter } from "./adapters/minimax.ts";
+import { openaiCodexAdapter } from "./adapters/openai-codex.ts";
+import { opencodeGoAdapter } from "./adapters/opencode-go.ts";
+import { openrouterAdapter } from "./adapters/openrouter.ts";
+import { vertexAdapter } from "./adapters/vertex.ts";
+import { vercelGatewayAdapter } from "./adapters/vercel.ts";
+import { xaiAdapter } from "./adapters/xai.ts";
+import type { ProviderTarget, UsageAdapter } from "./types.ts";
+
+const adapters: readonly UsageAdapter[] = [
+  openaiCodexAdapter,
+  anthropicAdapter,
+  kimiAdapter,
+  openrouterAdapter,
+  opencodeGoAdapter,
+  minimaxAdapter,
+  glmAdapter,
+  deepseekAdapter,
+  xaiAdapter,
+  vertexAdapter,
+  geminiAdapter,
+  vercelGatewayAdapter,
+  cliproxyAdapter,
+  githubCopilotAdapter,
+  fireworksAdapter,
+  basetenAdapter,
+  clineAdapter,
+];
+
+export function adapterFor(target: ProviderTarget | undefined): UsageAdapter | undefined {
+  if (!target) return undefined;
+  return adapters.find((adapter) => {
+    try {
+      return adapter.canHandle(target);
+    } catch {
+      return false;
+    }
+  });
+}
+
+function targetFor(ctx: ExtensionContext, model: Model<Api>): ProviderTarget {
+  const provider = ctx.modelRegistry.getProvider(model.provider);
+  return {
+    providerId: model.provider,
+    model,
+    provider,
+    baseUrl: provider?.baseUrl ?? model.baseUrl,
+  };
+}
+
+export function currentTarget(ctx: ExtensionContext): ProviderTarget | undefined {
+  return ctx.model ? targetFor(ctx, ctx.model) : undefined;
+}
+
+export function configuredTargets(ctx: ExtensionContext): ProviderTarget[] {
+  const seen = new Map<string, Model<Api>>();
+  for (const model of ctx.modelRegistry.getAll()) {
+    if (!seen.has(model.provider)) seen.set(model.provider, model);
+  }
+  return [...seen.values()].map((model) => targetFor(ctx, model));
+}
+
+export async function withCredentials(ctx: ExtensionContext, target: ProviderTarget): Promise<ProviderTarget> {
+  const credentials = await resolveCredentials(ctx, target);
+  if (target.providerId === "openai-codex" && credentials) {
+    const accountId = await codexAccountId(ctx, credentials);
+    if (accountId) return { ...target, credentials: { ...credentials, accountId } };
+  }
+  return { ...target, credentials };
+}

package/src/types.ts

@@ -0,0 +1,79 @@
+import type { Api, AuthResult, Model, Provider } from "@earendil-works/pi-ai";
+
+export type UsageState =
+  | "ok"
+  | "unauthorized"
+  | "unsupported"
+  | "empty"
+  | "unavailable";
+
+export type Metric =
+  | { kind: "balance"; id: string; label: string; amount: number; currency: string; detail?: string }
+  | { kind: "quota-window"; id: string; label: string; remainingFraction: number; resetAt?: string; detail?: string }
+  | { kind: "usage-limit"; id: string; label: string; used: number; limit: number; unit: string; detail?: string }
+  | { kind: "status"; id: string; label: string; value: string; detail?: string };
+
+export interface UsageAccount {
+  id: string;
+  label: string;
+  metrics: Metric[];
+}
+
+export interface UsageSnapshot {
+  adapterId: string;
+  sourceProviderId: string;
+  displayName: string;
+  state: UsageState;
+  fetchedAt: string;
+  accounts: UsageAccount[];
+  summary?: string;
+  error?: string;
+}
+
+export interface Credentials {
+  apiKey?: string;
+  headers?: Record<string, string>;
+  baseUrl?: string;
+  accountId?: string;
+  source: "model" | "provider" | "stored";
+}
+
+export interface ProviderTarget {
+  providerId: string;
+  model?: Model<Api>;
+  provider?: Provider<Api>;
+  baseUrl?: string;
+  auth?: AuthResult;
+  authError?: string;
+  credentials?: Credentials;
+}
+
+export interface FetchContext {
+  target: ProviderTarget;
+  signal: AbortSignal;
+  force: boolean;
+}
+
+export interface UsageAdapter {
+  id: string;
+  label: string;
+  canHandle(target: ProviderTarget): boolean;
+  fetch(context: FetchContext): Promise<UsageSnapshot>;
+}
+
+export function snapshot(
+  adapter: UsageAdapter,
+  target: ProviderTarget,
+  state: UsageState,
+  extra?: Partial<Pick<UsageSnapshot, "accounts" | "error" | "summary">>,
+): UsageSnapshot {
+  return {
+    adapterId: adapter.id,
+    sourceProviderId: target.providerId,
+    displayName: adapter.label,
+    state,
+    fetchedAt: new Date().toISOString(),
+    accounts: [],
+    ...extra,
+  };
+}