@prometheus-ai/ai 0.5.0

package/src/usage/google-antigravity.ts

@@ -0,0 +1,201 @@
+import { getAntigravityUserAgent } from "../providers/google-gemini-headers";
+import type {
+	UsageAmount,
+	UsageFetchContext,
+	UsageFetchParams,
+	UsageLimit,
+	UsageProvider,
+	UsageReport,
+	UsageStatus,
+	UsageWindow,
+} from "../usage";
+
+// (Refresh is the sole responsibility of AuthStorage; no provider-direct refresh here.)
+
+interface AntigravityQuotaInfo {
+	remainingFraction?: number;
+	resetTime?: string;
+	tier?: string;
+	windowId?: string;
+	windowLabel?: string;
+}
+
+interface AntigravityModelInfo {
+	displayName?: string;
+	quotaInfo?: AntigravityQuotaInfo | AntigravityQuotaInfo[];
+	quotaInfos?: AntigravityQuotaInfo[];
+	quotaInfoByTier?: Record<string, AntigravityQuotaInfo | AntigravityQuotaInfo[]>;
+}
+
+interface AntigravityUsageResponse {
+	models: Record<string, AntigravityModelInfo>;
+}
+
+const DEFAULT_ENDPOINT = "https://daily-cloudcode-pa.googleapis.com";
+const FETCH_AVAILABLE_MODELS_PATH = "/v1internal:fetchAvailableModels";
+
+function clampFraction(value: number | undefined): number | undefined {
+	if (value === undefined || !Number.isFinite(value)) return undefined;
+	if (value < 0) return 0;
+	if (value > 1) return 1;
+	return value;
+}
+
+function getUsageStatus(remainingFraction: number | undefined): UsageStatus | undefined {
+	if (remainingFraction === undefined) return "unknown";
+	if (remainingFraction <= 0) return "exhausted";
+	if (remainingFraction <= 0.1) return "warning";
+	return "ok";
+}
+
+function parseWindow(info: AntigravityQuotaInfo): UsageWindow | undefined {
+	if (!info.resetTime) return undefined;
+	const resetAt = Date.parse(info.resetTime);
+	if (!Number.isFinite(resetAt)) return undefined;
+	return {
+		id: info.windowId ?? "default",
+		label: info.windowLabel ?? "Default",
+		resetsAt: resetAt,
+	};
+}
+
+function buildAmount(info: AntigravityQuotaInfo): UsageAmount {
+	const remainingFraction = clampFraction(info.remainingFraction);
+	const amount: UsageAmount = { unit: "percent" };
+	if (remainingFraction === undefined) return amount;
+	const usedFraction = clampFraction(1 - remainingFraction);
+	amount.remainingFraction = remainingFraction;
+	amount.usedFraction = usedFraction;
+	amount.remaining = remainingFraction * 100;
+	amount.used = usedFraction !== undefined ? usedFraction * 100 : undefined;
+	amount.limit = 100;
+	return amount;
+}
+
+function normalizeQuotaInfos(info: AntigravityModelInfo): AntigravityQuotaInfo[] {
+	const results: AntigravityQuotaInfo[] = [];
+	const addInfo = (value: AntigravityQuotaInfo, tier?: string) => {
+		results.push({ ...value, ...(tier ? { tier } : {}) });
+	};
+	const addArray = (values?: AntigravityQuotaInfo[]) => {
+		if (!values) return;
+		for (const value of values) addInfo(value);
+	};
+
+	if (Array.isArray(info.quotaInfo)) {
+		addArray(info.quotaInfo);
+	} else if (info.quotaInfo) {
+		addInfo(info.quotaInfo);
+	}
+	addArray(info.quotaInfos);
+
+	if (info.quotaInfoByTier) {
+		for (const [tier, value] of Object.entries(info.quotaInfoByTier)) {
+			if (Array.isArray(value)) {
+				for (const entry of value) addInfo(entry, tier);
+			} else if (value) {
+				addInfo(value, tier);
+			}
+		}
+	}
+
+	return results;
+}
+
+/**
+ * Return the OAuth access token to use against `/v1internal:*`. AuthStorage is
+ * the sole refresh authority (broker-aware, single-flighted, rotation-safe);
+ * an expired token short-circuits the probe rather than POSTing the broker
+ * sentinel back to Google.
+ */
+function resolveAccessToken(params: UsageFetchParams): string | undefined {
+	const { credential } = params;
+	if (!credential.accessToken) return undefined;
+	if (credential.expiresAt !== undefined && credential.expiresAt <= Date.now()) {
+		return undefined;
+	}
+	return credential.accessToken;
+}
+
+async function fetchAntigravityUsage(params: UsageFetchParams, ctx: UsageFetchContext): Promise<UsageReport | null> {
+	const credential = params.credential;
+	if (!credential.projectId) return null;
+
+	const nowMs = Date.now();
+
+	const accessToken = resolveAccessToken(params);
+	if (!accessToken) return null;
+
+	const baseUrl = params.baseUrl?.replace(/\/+$/, "") || DEFAULT_ENDPOINT;
+	const url = `${baseUrl}${FETCH_AVAILABLE_MODELS_PATH}`;
+	const response = await ctx.fetch(url, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${accessToken}`,
+			"Content-Type": "application/json",
+			"User-Agent": getAntigravityUserAgent(),
+		},
+		body: JSON.stringify({ project: credential.projectId }),
+		signal: params.signal,
+	});
+
+	if (!response.ok) {
+		ctx.logger?.warn("Antigravity usage fetch failed", {
+			status: response.status,
+			statusText: response.statusText,
+		});
+		return null;
+	}
+
+	const data = (await response.json()) as AntigravityUsageResponse;
+	const limits: UsageLimit[] = [];
+	let earliestReset: number | undefined;
+
+	for (const [modelId, modelInfo] of Object.entries(data.models ?? {})) {
+		const quotaInfos = normalizeQuotaInfos(modelInfo);
+		for (const quotaInfo of quotaInfos) {
+			const amount = buildAmount(quotaInfo);
+			const window = parseWindow(quotaInfo);
+			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 report: UsageReport = {
+		provider: params.provider,
+		fetchedAt: nowMs,
+		limits,
+		metadata: {
+			endpoint: url,
+			projectId: credential.projectId,
+		},
+		raw: data,
+	};
+
+	return report;
+}
+
+export const antigravityUsageProvider: UsageProvider = {
+	id: "google-antigravity",
+	fetchUsage: fetchAntigravityUsage,
+	supports: params => params.provider === "google-antigravity",
+};

package/src/usage/kimi.ts

@@ -0,0 +1,271 @@
+import { $env } from "@prometheus-ai/utils";
+import type {
+	UsageAmount,
+	UsageFetchContext,
+	UsageFetchParams,
+	UsageLimit,
+	UsageProvider,
+	UsageReport,
+	UsageStatus,
+	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";
+
+const DEFAULT_BASE_URL = "https://api.kimi.com/coding/v1";
+const USAGE_PATH = "usages";
+
+interface KimiUsagePayload {
+	usage?: unknown;
+	limits?: unknown;
+}
+
+type KimiUsageRow = {
+	label: string;
+	used?: number;
+	limit?: number;
+	remaining?: number;
+	resetsAt?: number;
+	window?: UsageWindow;
+};
+
+function normalizeBaseUrl(baseUrl?: string): string {
+	const envBase = $env.KIMI_CODE_BASE_URL?.trim();
+	const candidate = baseUrl?.trim() || envBase || DEFAULT_BASE_URL;
+	return candidate.replace(/\/+$/, "");
+}
+
+function buildUsageUrl(baseUrl: string): string {
+	const normalized = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+	return `${normalized}${USAGE_PATH}`;
+}
+
+function parseResetTime(data: Record<string, unknown>, nowMs: number): number | undefined {
+	const timeKeys = ["reset_at", "resetAt", "reset_time", "resetTime"] as const;
+	for (const key of timeKeys) {
+		const value = data[key];
+		if (typeof value === "string" && value.trim()) {
+			const parsed = Date.parse(value);
+			if (Number.isFinite(parsed)) return parsed;
+		}
+		if (typeof value === "number" && Number.isFinite(value)) {
+			return value > 1_000_000_000_000 ? value : value * 1000;
+		}
+	}
+
+	const secondsKeys = ["reset_in", "resetIn", "ttl", "window"] as const;
+	for (const key of secondsKeys) {
+		const seconds = toNumber(data[key]);
+		if (seconds !== undefined) return nowMs + seconds * 1000;
+	}
+
+	return undefined;
+}
+
+function formatDurationLabel(duration: number, timeUnit: string): string | undefined {
+	const upper = timeUnit.toUpperCase();
+	if (upper.includes("MINUTE")) {
+		if (duration >= 60 && duration % 60 === 0) return `${duration / 60}h limit`;
+		return `${duration}m limit`;
+	}
+	if (upper.includes("HOUR")) return `${duration}h limit`;
+	if (upper.includes("DAY")) return `${duration}d limit`;
+	if (upper.includes("SECOND")) return `${duration}s limit`;
+	return undefined;
+}
+
+function buildWindow(windowData: Record<string, unknown>, nowMs: number): UsageWindow | undefined {
+	const duration = toNumber(windowData.duration);
+	const timeUnit = typeof windowData.timeUnit === "string" ? windowData.timeUnit : "";
+	const label = duration !== undefined && timeUnit ? formatDurationLabel(duration, timeUnit) : undefined;
+	const resetsAt = parseResetTime(windowData, nowMs);
+
+	if (duration === undefined && !label && !resetsAt) return undefined;
+	let durationMs: number | undefined;
+	if (duration !== undefined) {
+		if (timeUnit.toUpperCase().includes("MINUTE")) durationMs = duration * 60_000;
+		else if (timeUnit.toUpperCase().includes("HOUR")) durationMs = duration * 3_600_000;
+		else if (timeUnit.toUpperCase().includes("DAY")) durationMs = duration * 86_400_000;
+		else if (timeUnit.toUpperCase().includes("SECOND")) durationMs = duration * 1000;
+	}
+
+	return {
+		id: duration !== undefined && timeUnit ? `${duration}${timeUnit.toLowerCase()}` : "default",
+		label: label ?? "Usage window",
+		durationMs,
+		resetsAt,
+	};
+}
+
+function buildUsageRow(data: Record<string, unknown>, defaultLabel: string, nowMs: number): KimiUsageRow | null {
+	const limit = toNumber(data.limit);
+	let used = toNumber(data.used);
+	const remaining = toNumber(data.remaining);
+	if (used === undefined && remaining !== undefined && limit !== undefined) {
+		used = limit - remaining;
+	}
+
+	if (used === undefined && limit === undefined) return null;
+	const resetsAt = parseResetTime(data, nowMs);
+	return {
+		label:
+			typeof data.name === "string" && data.name
+				? data.name
+				: typeof data.title === "string" && data.title
+					? data.title
+					: defaultLabel,
+		used,
+		limit,
+		remaining,
+		resetsAt,
+	};
+}
+
+function buildUsageAmount(row: KimiUsageRow): UsageAmount {
+	const amount: UsageAmount = { unit: "unknown" };
+	if (row.limit !== undefined) amount.limit = row.limit;
+	if (row.used !== undefined) amount.used = row.used;
+	if (row.remaining !== undefined) amount.remaining = row.remaining;
+	if (row.limit !== undefined && row.used !== undefined && row.limit > 0) {
+		amount.usedFraction = Math.min(Math.max(row.used / row.limit, 0), 1);
+		amount.remainingFraction = Math.min(Math.max((row.limit - row.used) / row.limit, 0), 1);
+		amount.remaining = amount.remaining ?? row.limit - row.used;
+	}
+	return amount;
+}
+
+function buildUsageStatus(amount: UsageAmount): UsageStatus {
+	if (amount.usedFraction === undefined) return "unknown";
+	if (amount.usedFraction >= 1) return "exhausted";
+	if (amount.usedFraction >= 0.9) return "warning";
+	return "ok";
+}
+
+function toUsageLimit(row: KimiUsageRow, provider: string, index: number, accountId?: string): UsageLimit {
+	const window: UsageWindow | undefined =
+		row.window ??
+		(row.resetsAt
+			? {
+					id: "default",
+					label: "Usage window",
+					resetsAt: row.resetsAt,
+				}
+			: undefined);
+
+	const amount = buildUsageAmount(row);
+	return {
+		id: `${provider}:${index}`,
+		label: row.label,
+		scope: {
+			provider,
+			accountId,
+			windowId: window?.id,
+			shared: true,
+		},
+		window,
+		amount,
+		status: buildUsageStatus(amount),
+	};
+}
+
+function parseUsagePayload(payload: unknown, nowMs: number): { rows: KimiUsageRow[]; raw: KimiUsagePayload } | null {
+	if (!isRecord(payload)) return null;
+	const data = payload as KimiUsagePayload;
+	const rows: KimiUsageRow[] = [];
+
+	if (isRecord(data.usage)) {
+		const summary = buildUsageRow(data.usage, "Total quota", nowMs);
+		if (summary) rows.push(summary);
+	}
+
+	if (Array.isArray(data.limits)) {
+		data.limits.forEach((item, idx) => {
+			if (!isRecord(item)) return;
+			const detail = isRecord(item.detail) ? item.detail : item;
+			const windowData = isRecord(item.window) ? item.window : {};
+			const label =
+				(typeof item.name === "string" && item.name) ||
+				(typeof item.title === "string" && item.title) ||
+				(typeof item.scope === "string" && item.scope) ||
+				(typeof detail.name === "string" && detail.name) ||
+				(typeof detail.title === "string" && detail.title) ||
+				formatDurationLabel(toNumber(windowData.duration) ?? 0, String(windowData.timeUnit || "")) ||
+				`Limit #${idx + 1}`;
+			const row = buildUsageRow(detail, label, nowMs);
+			if (row) {
+				row.window = buildWindow(windowData, nowMs);
+				rows.push(row);
+			}
+		});
+	}
+
+	return { rows, raw: data };
+}
+
+export const kimiUsageProvider: UsageProvider = {
+	id: "kimi-code",
+	supports(params: UsageFetchParams): boolean {
+		return params.provider === "kimi-code" && params.credential.type === "oauth";
+	},
+	async fetchUsage(params: UsageFetchParams, ctx: UsageFetchContext): Promise<UsageReport | null> {
+		if (params.provider !== "kimi-code") return null;
+		const { credential } = params;
+		if (credential.type !== "oauth") return null;
+
+		const accessToken = credential.accessToken;
+		if (!accessToken) return null;
+
+		const nowMs = Date.now();
+		// AuthStorage refreshes OAuth credentials pre-emptively (60s skew). If the
+		// usage probe lands with an expired token, short-circuit rather than POST
+		// the broker sentinel back to Kimi — the next cycle will carry a freshly
+		// refreshed credential.
+		if (credential.expiresAt !== undefined && credential.expiresAt <= nowMs) {
+			ctx.logger?.debug("Kimi usage token expired; skipping probe", { provider: params.provider });
+			return null;
+		}
+
+		const baseUrl = normalizeBaseUrl(params.baseUrl);
+		const url = buildUsageUrl(baseUrl);
+		let payload: unknown;
+		try {
+			const response = await ctx.fetch(url, {
+				headers: {
+					...getKimiCommonHeaders(),
+					Authorization: `Bearer ${accessToken}`,
+				},
+				signal: params.signal,
+			});
+			if (!response.ok) {
+				ctx.logger?.warn("Kimi usage request failed", { status: response.status, provider: params.provider });
+				return null;
+			}
+			payload = await response.json();
+		} catch (error) {
+			ctx.logger?.warn("Kimi usage request error", { provider: params.provider, error: String(error) });
+			return null;
+		}
+
+		const parsed = parseUsagePayload(payload, nowMs);
+		if (!parsed || parsed.rows.length === 0) {
+			ctx.logger?.warn("Kimi usage response invalid", { provider: params.provider });
+			return null;
+		}
+
+		const limits = parsed.rows.map((row, index) => toUsageLimit(row, params.provider, index, credential.accountId));
+
+		const report: UsageReport = {
+			provider: params.provider,
+			fetchedAt: nowMs,
+			limits,
+			metadata: {
+				endpoint: url,
+			},
+			raw: parsed.raw,
+		};
+
+		return report;
+	},
+};

package/src/usage/minimax-code.ts

@@ -0,0 +1,31 @@
+import type { UsageFetchContext, UsageFetchParams, UsageProvider, UsageReport } from "../usage";
+
+/**
+ * MiniMax Coding 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.
+ *
+ * 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
+ *
+ * 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.
+ */
+async function fetchMiniMaxCodeUsage(params: UsageFetchParams, _ctx: UsageFetchContext): Promise<UsageReport | null> {
+	if (params.provider !== "minimax-code" && params.provider !== "minimax-code-cn") {
+		return null;
+	}
+
+	// MiniMax Coding Plan does not currently expose a usage API
+	// Users can check their usage via the web dashboard
+	return null;
+}
+
+export const minimaxCodeUsageProvider: UsageProvider = {
+	id: "minimax-code",
+	fetchUsage: fetchMiniMaxCodeUsage,
+	supports: (params: UsageFetchParams) =>
+		(params.provider === "minimax-code" || params.provider === "minimax-code-cn") &&
+		params.credential.type === "api_key",
+};