@prometheus-ai/ai 0.5.4 → 0.5.8

package/src/usage/google-antigravity.ts

@@ -1,5 +1,7 @@
-import { getAntigravityUserAgent } from "../providers/google-gemini-headers";
+import { getAntigravityUserAgent } from "@prometheus-ai/catalog/wire/gemini-headers";
 import type {
+	CredentialRankingContext,
+	CredentialRankingStrategy,
 	UsageAmount,
 	UsageFetchContext,
 	UsageFetchParams,
@@ -18,6 +20,8 @@ interface AntigravityQuotaInfo {
 	tier?: string;
 	windowId?: string;
 	windowLabel?: string;
+	apiProvider?: string;
+	modelProvider?: string;
 }
 
 interface AntigravityModelInfo {
@@ -25,6 +29,8 @@ interface AntigravityModelInfo {
 	quotaInfo?: AntigravityQuotaInfo | AntigravityQuotaInfo[];
 	quotaInfos?: AntigravityQuotaInfo[];
 	quotaInfoByTier?: Record<string, AntigravityQuotaInfo | AntigravityQuotaInfo[]>;
+	apiProvider?: string;
+	modelProvider?: string;
 }
 
 interface AntigravityUsageResponse {
@@ -60,22 +66,47 @@ function parseWindow(info: AntigravityQuotaInfo): UsageWindow | undefined {
 }
 
 function buildAmount(info: AntigravityQuotaInfo): UsageAmount {
-	const remainingFraction = clampFraction(info.remainingFraction);
+	const apiRemainingFraction = clampFraction(info.remainingFraction);
+	// Observed Antigravity responses omit remainingFraction for exhausted
+	// Google/Gemini counters and keep only resetTime. Treat that shape as
+	// "blocked until reset" rather than unknown so a healthy sibling backend
+	// counter cannot mask it during dedupe.
+	const remainingFraction = apiRemainingFraction ?? (info.resetTime ? 0 : undefined);
 	const amount: UsageAmount = { unit: "percent" };
 	if (remainingFraction === undefined) return amount;
-	const usedFraction = clampFraction(1 - remainingFraction);
+	const usedFraction = 1 - remainingFraction;
 	amount.remainingFraction = remainingFraction;
 	amount.usedFraction = usedFraction;
 	amount.remaining = remainingFraction * 100;
-	amount.used = usedFraction !== undefined ? usedFraction * 100 : undefined;
+	amount.used = usedFraction * 100;
 	amount.limit = 100;
 	return amount;
 }
 
+function formatCounterName(info: AntigravityQuotaInfo): string | undefined {
+	switch (info.modelProvider ?? info.apiProvider) {
+		case "MODEL_PROVIDER_ANTHROPIC":
+		case "API_PROVIDER_ANTHROPIC_VERTEX":
+			return "Anthropic";
+		case "MODEL_PROVIDER_GOOGLE":
+		case "API_PROVIDER_GOOGLE_GEMINI":
+			return "Google";
+		case "MODEL_PROVIDER_OPENAI":
+		case "API_PROVIDER_OPENAI_VERTEX":
+			return "OpenAI";
+		default:
+			return undefined;
+	}
+}
+
 function normalizeQuotaInfos(info: AntigravityModelInfo): AntigravityQuotaInfo[] {
 	const results: AntigravityQuotaInfo[] = [];
+	const source = {
+		...(info.apiProvider ? { apiProvider: info.apiProvider } : {}),
+		...(info.modelProvider ? { modelProvider: info.modelProvider } : {}),
+	};
 	const addInfo = (value: AntigravityQuotaInfo, tier?: string) => {
-		results.push({ ...value, ...(tier ? { tier } : {}) });
+		results.push({ ...source, ...value, ...(tier ? { tier } : {}) });
 	};
 	const addArray = (values?: AntigravityQuotaInfo[]) => {
 		if (!values) return;
@@ -148,10 +179,26 @@ async function fetchAntigravityUsage(params: UsageFetchParams, ctx: UsageFetchCo
 	}
 
 	const data = (await response.json()) as AntigravityUsageResponse;
-	const limits: UsageLimit[] = [];
+
+	// The API returns per-model quota entries, but quota is shared across
+	// models within the same backend counter, tier, and reset window. Keep
+	// Google and Anthropic-backed Antigravity models separate so a healthy
+	// Claude counter cannot mask an exhausted Gemini counter.
+	const deduped = new Map<
+		string,
+		{
+			amount: UsageAmount;
+			window: UsageWindow | undefined;
+			tier: string | undefined;
+			tierKey: string;
+			windowId: string;
+			counterName: string | undefined;
+			counterKey: string;
+		}
+	>();
 	let earliestReset: number | undefined;
 
-	for (const [modelId, modelInfo] of Object.entries(data.models ?? {})) {
+	for (const [_modelId, modelInfo] of Object.entries(data.models ?? {})) {
 		const quotaInfos = normalizeQuotaInfos(modelInfo);
 		for (const quotaInfo of quotaInfos) {
 			const amount = buildAmount(quotaInfo);
@@ -159,35 +206,90 @@ async function fetchAntigravityUsage(params: UsageFetchParams, ctx: UsageFetchCo
 			if (window?.resetsAt) {
 				earliestReset = earliestReset ? Math.min(earliestReset, window.resetsAt) : window.resetsAt;
 			}
-			const labelBase = modelInfo.displayName || modelId;
-			const label = quotaInfo.tier ? `${labelBase} (${quotaInfo.tier})` : labelBase;
-			const windowId = window?.id ?? "default";
-			limits.push({
-				id: `${modelId}:${quotaInfo.tier ?? "default"}:${windowId}`,
-				label,
-				scope: {
-					provider: params.provider,
-					accountId: credential.accountId,
-					projectId: credential.projectId,
-					modelId,
-					tier: quotaInfo.tier,
-					windowId,
-				},
-				window,
-				amount,
-				status: getUsageStatus(amount.remainingFraction),
+			const tierKey = (quotaInfo.tier ?? "default").toLowerCase();
+			const counterName = formatCounterName(quotaInfo);
+			const counterKey = counterName?.toLowerCase() ?? "default";
+			// Use quotaInfo.windowId even when parseWindow returns undefined
+			// (no resetTime) — separate windows must not collapse to "default".
+			const windowId = quotaInfo.windowId ?? window?.id ?? "default";
+			const key = `${counterKey}|${tierKey}|${windowId}`;
+			const existing = deduped.get(key);
+			if (!existing) {
+				deduped.set(key, { amount, window, tier: quotaInfo.tier, tierKey, windowId, counterName, counterKey });
+				continue;
+			}
+			// Merge: keep the entry with fraction data for the bar, but
+			// also keep any window with a reset time so "resets in…" survives.
+			const eFrac = existing.amount.remainingFraction;
+			const cFrac = amount.remainingFraction;
+			const eHasFrac = eFrac !== undefined;
+			const cHasFrac = cFrac !== undefined;
+
+			let bestAmount = existing.amount;
+			let bestWindow = existing.window?.resetsAt ? existing.window : (window ?? existing.window);
+			let bestTier = existing.tier ?? quotaInfo.tier;
+
+			if (!eHasFrac && cHasFrac) {
+				bestAmount = amount;
+				bestTier = quotaInfo.tier ?? existing.tier;
+			} else if (eFrac !== undefined && cFrac !== undefined && cFrac < eFrac) {
+				bestAmount = amount;
+				bestTier = quotaInfo.tier ?? existing.tier;
+			}
+			// Always merge in window with reset time if the current
+			// best doesn't have one.
+			if (!bestWindow?.resetsAt && window?.resetsAt) {
+				bestWindow = window;
+			}
+			deduped.set(key, {
+				amount: bestAmount,
+				window: bestWindow,
+				tier: bestTier,
+				tierKey: existing.tierKey,
+				windowId: existing.windowId,
+				counterName: existing.counterName,
+				counterKey: existing.counterKey,
 			});
 		}
 	}
 
+	const limits: UsageLimit[] = [];
+	for (const entry of deduped.values()) {
+		const label = entry.counterName ? `Usage (${entry.counterName})` : "Usage";
+		limits.push({
+			id: `${params.provider}:${entry.counterKey}:${entry.tierKey}:${entry.windowId}`,
+			label,
+			scope: {
+				provider: params.provider,
+				accountId: credential.accountId,
+				projectId: credential.projectId,
+				tier: entry.tier,
+				windowId: entry.windowId,
+			},
+			window: entry.window,
+			amount: entry.amount,
+			status: getUsageStatus(entry.amount.remainingFraction),
+		});
+	}
+
+	limits.sort((a, b) => {
+		const aFraction = a.amount.remainingFraction ?? 1;
+		const bFraction = b.amount.remainingFraction ?? 1;
+		return aFraction - bFraction;
+	});
+
+	const metadata: UsageReport["metadata"] = {
+		endpoint: url,
+		projectId: credential.projectId,
+	};
+	if (credential.email) metadata.email = credential.email;
+	if (credential.accountId) metadata.accountId = credential.accountId;
+
 	const report: UsageReport = {
 		provider: params.provider,
 		fetchedAt: nowMs,
 		limits,
-		metadata: {
-			endpoint: url,
-			projectId: credential.projectId,
-		},
+		metadata,
 		raw: data,
 	};
 
@@ -199,3 +301,69 @@ export const antigravityUsageProvider: UsageProvider = {
 	fetchUsage: fetchAntigravityUsage,
 	supports: params => params.provider === "google-antigravity",
 };
+
+const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+
+function getAntigravityCounterKeyForModel(context: CredentialRankingContext | undefined): string | undefined {
+	const modelId = context?.modelId?.toLowerCase();
+	if (!modelId) return undefined;
+	if (modelId.startsWith("claude-")) return "anthropic";
+	if (modelId.startsWith("gemini-") || modelId.startsWith("gemma-")) return "google";
+	if (modelId.startsWith("gpt-") || modelId.startsWith("openai/")) return "openai";
+	return undefined;
+}
+
+function getAntigravityCounterLimits(report: UsageReport, counterKey: string): UsageLimit[] {
+	const prefix = `${report.provider}:${counterKey}:`;
+	return report.limits.filter(limit => limit.id.toLowerCase().startsWith(prefix));
+}
+
+// Exhaustion checks are only safe with a concrete backend counter. A no-model
+// Antigravity credential lookup (for example image-provider discovery) must
+// not turn one exhausted family into a provider-wide block.
+function scopeAntigravityLimitsForModel(
+	report: UsageReport,
+	context: CredentialRankingContext | undefined,
+): UsageLimit[] {
+	const counterKey = getAntigravityCounterKeyForModel(context);
+	if (!counterKey) return [];
+	const backendLimits = getAntigravityCounterLimits(report, counterKey);
+	if (backendLimits.length > 0) return backendLimits;
+	return getAntigravityCounterLimits(report, "default");
+}
+
+function rankAntigravityLimits(report: UsageReport, context: CredentialRankingContext | undefined): UsageLimit[] {
+	const counterKey = getAntigravityCounterKeyForModel(context);
+	if (!counterKey) return report.limits;
+	return scopeAntigravityLimitsForModel(report, context);
+}
+
+/**
+ * Antigravity quotas reset daily and are returned per backend counter
+ * (Anthropic / Google / OpenAI) without a fixed "primary vs secondary"
+ * split. `fetchAntigravityUsage` already sorts `limits` ascending by
+ * `remainingFraction`; after model-family scoping, the most-pressured
+ * relevant counter is index 0.
+ *
+ * Leave `secondary` unset: AuthStorage compares secondary metrics before
+ * primary metrics, which is correct for providers with explicit long-window
+ * limits but wrong here. Ranking Antigravity by the bottleneck counter first
+ * avoids preferring an account at 95% Gemini / 0% Claude over one at
+ * 80% Gemini / 70% Claude.
+ */
+export const antigravityRankingStrategy: CredentialRankingStrategy = {
+	findWindowLimits(report, context) {
+		return { primary: rankAntigravityLimits(report, context)[0] };
+	},
+	scopeLimits: scopeAntigravityLimitsForModel,
+	// Always return a scope for Antigravity so missing/unknown model context
+	// cannot fall through to AuthStorage's provider-wide block bucket.
+	blockScope(context) {
+		const counterKey = getAntigravityCounterKeyForModel(context);
+		return `counter:${counterKey ?? "unknown"}`;
+	},
+	// Antigravity windows omit `durationMs`; the endpoint is
+	// `daily-cloudcode-pa.googleapis.com`, so fall back to 24h when computing
+	// drain rate.
+	windowDefaults: { primaryMs: ONE_DAY_MS, secondaryMs: ONE_DAY_MS },
+};

package/src/usage/kimi.ts

@@ -1,4 +1,5 @@
 import { $env } from "@prometheus-ai/utils";
+import { getKimiCommonHeaders } from "../registry/oauth/kimi";
 import type {
 	UsageAmount,
 	UsageFetchContext,
@@ -10,7 +11,6 @@ import type {
 	UsageWindow,
 } from "../usage";
 import { isRecord } from "../utils";
-import { getKimiCommonHeaders } from "../utils/oauth/kimi";
 // (Refresh is the sole responsibility of AuthStorage; no provider-direct refresh here.)
 import { toNumber } from "./shared";
 

package/src/usage/minimax-code.ts

@@ -1,13 +1,12 @@
 import type { UsageFetchContext, UsageFetchParams, UsageProvider, UsageReport } from "../usage";
 
 /**
- * MiniMax Coding Plan usage provider.
+ * MiniMax Token Plan usage provider.
  *
- * MiniMax Coding Plan is a subscription-based service with a 5-hour rolling window
- * quota system. The quota resets automatically based on a rolling window.
+ * MiniMax Token Plan is a subscription-based service with a rolling quota system.
  *
- * Currently, MiniMax does not expose a usage/quota API endpoint for the Coding Plan.
- * Usage is tracked via the web dashboard at https://platform.minimax.io/user-center/payment/coding-plan
+ * Currently, MiniMax does not expose a usage/quota API endpoint for the Token Plan.
+ * Usage is tracked via the web dashboard at https://platform.minimax.io/user-center/payment/token-plan
  *
  * This provider exists to register support for the minimax-code provider in the
  * usage system. When MiniMax adds a usage API, this can be implemented.
@@ -17,7 +16,7 @@ async function fetchMiniMaxCodeUsage(params: UsageFetchParams, _ctx: UsageFetchC
 		return null;
 	}
 
-	// MiniMax Coding Plan does not currently expose a usage API
+	// MiniMax Token Plan does not currently expose a usage API
 	// Users can check their usage via the web dashboard
 	return null;
 }

package/src/usage/openai-codex-reset.ts

@@ -0,0 +1,174 @@
+/**
+ * OpenAI Codex "saved rate limit reset" redemption client.
+ *
+ * OpenAI lets paid Codex accounts bank a usage-window reset and spend it on
+ * demand (announced 2026-06-11). The count is surfaced on `/wham/usage` as
+ * `rate_limit_reset_credits.available_count` (see `./openai-codex.ts`), but the
+ * actual credit objects and the redeem action live on two dedicated routes:
+ *
+ *   GET  /wham/rate-limit-reset-credits           → list redeemable credits
+ *   POST /wham/rate-limit-reset-credits/consume   → spend one credit
+ *        body: { credit_id, redeem_request_id }
+ *
+ * `redeem_request_id` is a client-generated idempotency key (UUID). The consume
+ * response carries a `code`: `"reset"` on success, otherwise a business reason
+ * (`already_redeemed`, `no_credit`, `nothing_to_reset`).
+ *
+ * These are thin, dependency-light functions so both the interactive session
+ * (the `/usage reset` command + auto-redeem) and any out-of-band tooling can
+ * share one wire contract.
+ */
+import type { FetchImpl } from "../types";
+import { isRecord } from "../utils";
+import { normalizeCodexBaseUrl } from "./openai-codex";
+import { toNumber } from "./shared";
+
+const RESET_CREDITS_PATH = "wham/rate-limit-reset-credits";
+const RESET_CREDITS_CONSUME_PATH = "wham/rate-limit-reset-credits/consume";
+
+/** A single redeemable (or already-spent) saved reset. */
+export interface CodexResetCredit {
+	/** Opaque credit id, e.g. `RateLimitResetCredit_…`. Pass to {@link consumeCodexResetCredit}. */
+	id: string;
+	/** Backend reset family, e.g. `codex_rate_limits`. */
+	resetType?: string;
+	/** `available`, `redeemed`, … */
+	status?: string;
+	grantedAt?: string;
+	expiresAt?: string;
+	redeemStartedAt?: string | null;
+	redeemedAt?: string | null;
+	/** Human-facing card title, e.g. "One free rate limit reset". */
+	title?: string;
+	description?: string;
+}
+
+/** Result of listing an account's saved resets. */
+export interface CodexResetCreditList {
+	credits: CodexResetCredit[];
+	/** Backend-reported count of credits redeemable right now. */
+	availableCount: number;
+}
+
+/**
+ * Consume outcome `code`. `reset` means a window was actually reset; the others
+ * are no-op business outcomes the caller should surface verbatim-ish to the user.
+ */
+export type CodexResetConsumeCode =
+	| "reset"
+	| "already_redeemed"
+	| "no_credit"
+	| "nothing_to_reset"
+	// Forward-compatible: unknown future codes pass through.
+	| (string & {});
+
+export interface CodexResetConsumeResult {
+	/** `true` only when `code === "reset"` (a reset was applied). */
+	ok: boolean;
+	code: CodexResetConsumeCode;
+	/** HTTP status of the consume call (for diagnostics). */
+	status: number;
+	raw?: unknown;
+}
+
+interface CodexResetAuth {
+	accessToken: string;
+	accountId?: string;
+	/** Provider base URL override; defaults to the Codex backend. */
+	baseUrl?: string;
+	fetch: FetchImpl;
+	signal?: AbortSignal;
+}
+
+function buildUrl(baseUrl: string | undefined, routePath: string): string {
+	const base = normalizeCodexBaseUrl(baseUrl);
+	const normalized = base.endsWith("/") ? base : `${base}/`;
+	return `${normalized}${routePath}`;
+}
+
+function buildHeaders(auth: CodexResetAuth, json: boolean): Record<string, string> {
+	const headers: Record<string, string> = {
+		Authorization: `Bearer ${auth.accessToken}`,
+		"User-Agent": "OpenCode-Status-Plugin/1.0",
+	};
+	if (auth.accountId) headers["ChatGPT-Account-Id"] = auth.accountId;
+	if (json) headers["Content-Type"] = "application/json";
+	return headers;
+}
+
+function parseCredit(value: unknown): CodexResetCredit | null {
+	if (!isRecord(value)) return null;
+	const id = typeof value.id === "string" ? value.id : undefined;
+	if (!id) return null;
+	const str = (key: string): string | undefined =>
+		typeof value[key] === "string" ? (value[key] as string) : undefined;
+	const nullableStr = (key: string): string | null | undefined => {
+		const raw = value[key];
+		if (raw === null) return null;
+		return typeof raw === "string" ? raw : undefined;
+	};
+	return {
+		id,
+		resetType: str("reset_type"),
+		status: str("status"),
+		grantedAt: str("granted_at"),
+		expiresAt: str("expires_at"),
+		redeemStartedAt: nullableStr("redeem_started_at"),
+		redeemedAt: nullableStr("redeemed_at"),
+		title: str("title"),
+		description: str("description"),
+	};
+}
+
+/**
+ * List the account's saved rate-limit resets. Returns `null` on transport/auth
+ * failure (non-2xx or thrown), letting callers treat it the same as "no data".
+ */
+export async function listCodexResetCredits(auth: CodexResetAuth): Promise<CodexResetCreditList | null> {
+	const url = buildUrl(auth.baseUrl, RESET_CREDITS_PATH);
+	let payload: unknown;
+	try {
+		const response = await auth.fetch(url, { headers: buildHeaders(auth, false), signal: auth.signal });
+		if (!response.ok) return null;
+		payload = await response.json();
+	} catch {
+		return null;
+	}
+	if (!isRecord(payload)) return null;
+	const credits = Array.isArray(payload.credits)
+		? payload.credits.map(parseCredit).filter((c): c is CodexResetCredit => c !== null)
+		: [];
+	const reported = toNumber(payload.available_count);
+	const availableCount =
+		reported !== undefined
+			? Math.max(0, Math.trunc(reported))
+			: credits.filter(c => (c.status ?? "available") === "available").length;
+	return { credits, availableCount };
+}
+
+/**
+ * Spend one saved reset. `redeemRequestId` is the idempotency key; one is
+ * generated when omitted, so retrying with the SAME id is safe and won't
+ * double-spend. The returned `code` is `"reset"` on success.
+ */
+export async function consumeCodexResetCredit(
+	auth: CodexResetAuth & { creditId: string; redeemRequestId?: string },
+): Promise<CodexResetConsumeResult> {
+	const redeemRequestId = auth.redeemRequestId ?? crypto.randomUUID();
+	const url = buildUrl(auth.baseUrl, RESET_CREDITS_CONSUME_PATH);
+	const response = await auth.fetch(url, {
+		method: "POST",
+		headers: buildHeaders(auth, true),
+		body: JSON.stringify({ credit_id: auth.creditId, redeem_request_id: redeemRequestId }),
+		signal: auth.signal,
+	});
+	let body: unknown;
+	try {
+		body = await response.json();
+	} catch {
+		body = undefined;
+	}
+	const code =
+		isRecord(body) && typeof body.code === "string" ? body.code : response.ok ? "reset" : `http_${response.status}`;
+	return { ok: code === "reset", code, status: response.status, raw: body };
+}

package/src/usage/openai-codex.ts

@@ -1,5 +1,5 @@
 import { Buffer } from "node:buffer";
-import { CODEX_BASE_URL } from "../providers/openai-codex/constants";
+import { CODEX_BASE_URL } from "@prometheus-ai/catalog/wire/codex";
 import type {
 	CredentialRankingStrategy,
 	UsageAmount,
@@ -8,6 +8,7 @@ import type {
 	UsageLimit,
 	UsageProvider,
 	UsageReport,
+	UsageResetCredits,
 	UsageWindow,
 } from "../usage";
 import { isRecord } from "../utils";
@@ -185,7 +186,21 @@ function parseUsagePayload(payload: unknown): ParsedUsage | null {
 	return parsed;
 }
 
-function normalizeCodexBaseUrl(baseUrl?: string): string {
+/**
+ * Parse the `rate_limit_reset_credits` block from `/wham/usage`. OpenAI Codex
+ * reports the count of saved rate-limit resets the account can redeem here; the
+ * redeem action itself lives in `./openai-codex-reset`.
+ */
+function parseResetCredits(payload: unknown): UsageResetCredits | undefined {
+	if (!isRecord(payload)) return undefined;
+	const block = payload.rate_limit_reset_credits;
+	if (!isRecord(block)) return undefined;
+	const availableCount = toNumber(block.available_count);
+	if (availableCount === undefined) return undefined;
+	return { availableCount: Math.max(0, Math.trunc(availableCount)) };
+}
+
+export function normalizeCodexBaseUrl(baseUrl?: string): string {
 	const fallback = CODEX_BASE_URL;
 	const trimmed = baseUrl?.trim() ? baseUrl.trim() : fallback;
 	const base = trimmed.replace(/\/+$/, "");
@@ -454,10 +469,12 @@ export const openaiCodexUsageProvider: UsageProvider = {
 			}
 		}
 
+		const resetCredits = parseResetCredits(payload);
 		const report: UsageReport = {
 			provider: "openai-codex",
 			fetchedAt: nowMs,
 			limits,
+			...(resetCredits ? { resetCredits } : {}),
 			metadata: {
 				planType,
 				allowed: parsed?.allowed,

package/src/usage/zai.ts

@@ -1,3 +1,4 @@
+import { toNumber } from "@prometheus-ai/catalog/utils";
 import type {
 	UsageAmount,
 	UsageFetchContext,
@@ -8,7 +9,7 @@ import type {
 	UsageStatus,
 	UsageWindow,
 } from "../usage";
-import { isRecord, toNumber } from "../utils";
+import { isRecord } from "../utils";
 
 const DEFAULT_ENDPOINT = "https://api.z.ai";
 const QUOTA_PATH = "/api/monitor/usage/quota/limit";