@hyav/pi-provider 0.1.3 → 0.1.5

package/status/groq.ts

@@ -0,0 +1,89 @@
+import type { StatusAdapter, StatusEntry, StatusSnapshot } from "@hyav/pi-provider";
+import { defineStatusExtension, hasBaseUrlOrigin, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
+import { parseRateLimitWindows } from "../core/ratelimit-headers.ts";
+
+export const GROQ_MODELS_URL = "https://api.groq.com/openai/v1/models";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function windowEntry(
+	id: string,
+	label: string,
+	window: { limit: number; remaining: number; resetAt?: number },
+): StatusEntry {
+	const percent = (window.remaining / window.limit) * 100;
+	return {
+		kind: "window",
+		id,
+		label,
+		remainingPercent: Math.max(0, Math.min(100, percent)),
+		...(window.resetAt !== undefined ? { resetAt: window.resetAt } : {}),
+	};
+}
+
+export const groqStatusAdapter: StatusAdapter = {
+	id: "groq-status",
+	providerId: "groq",
+	name: "Groq",
+	cacheTtlMs: 60_000,
+	requestTimeoutMs: 8_000,
+	supportsModel: (model) => hasBaseUrlOrigin(model.baseUrl, GROQ_MODELS_URL),
+	async fetch(context): Promise<StatusSnapshot> {
+		const key = await context.getApiKey();
+		if (!key || key === "proxy-managed") {
+			throw new ProviderDataError("Groq status requires an API key", "auth");
+		}
+		const response = await context.fetch(GROQ_MODELS_URL, {
+			headers: {
+				Accept: "application/json",
+				"Accept-Encoding": "identity",
+				Authorization: `Bearer ${key}`,
+				"User-Agent": "@hyav/pi-provider",
+			},
+			signal: context.signal,
+		});
+		if (!response.ok) {
+			throw new ProviderDataError(
+				`Groq status failed: HTTP ${response.status}`,
+				`http${response.status}`,
+				parseRetryAfter(response.headers.get("retry-after"), context.now()),
+				response.status,
+			);
+		}
+		let modelCount: string | undefined;
+		try {
+			const payload: unknown = await response.json();
+			modelCount = isRecord(payload) && Array.isArray(payload.data) ? `${payload.data.length} available` : undefined;
+		} catch {
+			modelCount = undefined;
+		}
+
+		const now = context.now();
+		const { requests, tokens } = parseRateLimitWindows(response.headers, now);
+		const entries: StatusEntry[] = [
+			modelCount === undefined
+				? { kind: "text", id: "models", label: "Models", value: "unavailable" }
+				: { kind: "text", id: "models", label: "Models", value: modelCount },
+		];
+		if (requests) entries.push(windowEntry("requests-per-day", "Requests per day", requests));
+		if (tokens) entries.push(windowEntry("tokens-per-minute", "Tokens per minute", tokens));
+		if (entries.length === 1) {
+			entries.push({ kind: "text", id: "limits", label: "Limits", value: "not available" });
+		}
+		return { entries, updatedAt: now };
+	},
+};
+
+export function createGroqStatusAdapter(requestTimeoutMs: number): StatusAdapter {
+	return { ...groqStatusAdapter, requestTimeoutMs };
+}
+
+const groqStatusExtension = defineStatusExtension({
+	id: "groq-status",
+	providerId: "groq",
+	create: ({ statusRequestTimeoutMs }) => createGroqStatusAdapter(statusRequestTimeoutMs),
+});
+
+export default groqStatusExtension;

package/status/huggingface.ts

@@ -0,0 +1,95 @@
+import type { StatusAdapter, StatusEntry, StatusSnapshot } from "@hyav/pi-provider";
+import { defineStatusExtension, hasBaseUrlOrigin, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
+
+export const HF_WHOAMI_URL = "https://huggingface.co/api/whoami-v2";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function finiteNumber(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+const MAX_LABEL_LENGTH = 64;
+
+function safeText(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	if (trimmed === "" || trimmed.length > MAX_LABEL_LENGTH || /[\u0000-\u001f\u007f]/.test(trimmed)) return undefined;
+	return trimmed;
+}
+
+export interface HuggingFaceAccount {
+	plan?: string;
+	credits?: number;
+}
+
+export function parseHuggingFaceAccount(payload: unknown): HuggingFaceAccount {
+	if (!isRecord(payload)) {
+		throw new ProviderDataError("Hugging Face status returned an invalid account response", "badjson");
+	}
+	// Response envelope: { type, id, name, emailVerified, canPay, isPro, plan, periodEnd, credits, ... }
+	const plan = safeText(payload.plan);
+	// Older token generations omit the envelope fields entirely.
+	return {
+		...(plan !== undefined ? { plan } : {}),
+		...(finiteNumber(payload.credits) !== undefined ? { credits: finiteNumber(payload.credits) } : {}),
+	};
+}
+
+export const huggingFaceStatusAdapter: StatusAdapter = {
+	id: "huggingface-status",
+	providerId: "huggingface",
+	name: "Hugging Face",
+	cacheTtlMs: 60_000,
+	requestTimeoutMs: 8_000,
+	supportsModel: (model) => hasBaseUrlOrigin(model.baseUrl, "https://router.huggingface.co"),
+	async fetch(context): Promise<StatusSnapshot> {
+		const key = await context.getApiKey();
+		if (!key || key === "proxy-managed") {
+			throw new ProviderDataError("Hugging Face status requires a token", "auth");
+		}
+		const response = await context.fetch(HF_WHOAMI_URL, {
+			headers: {
+				Accept: "application/json",
+				"Accept-Encoding": "identity",
+				Authorization: `Bearer ${key}`,
+				"User-Agent": "@hyav/pi-provider",
+			},
+			signal: context.signal,
+		});
+		if (!response.ok) {
+			throw new ProviderDataError(
+				`Hugging Face status failed: HTTP ${response.status}`,
+				`http${response.status}`,
+				parseRetryAfter(response.headers.get("retry-after"), context.now()),
+				response.status,
+			);
+		}
+		let payload: unknown;
+		try {
+			payload = await response.json();
+		} catch {
+			throw new ProviderDataError("Hugging Face status returned invalid JSON", "badjson");
+		}
+		const account = parseHuggingFaceAccount(payload);
+		const entries: StatusEntry[] = [{ kind: "text", id: "plan", label: "Plan", value: account.plan ?? "Unknown" }];
+		if (account.credits !== undefined) {
+			entries.push({ kind: "amount", id: "credits", label: "Credits", value: account.credits, unit: "USD" });
+		}
+		return { entries, updatedAt: context.now() };
+	},
+};
+
+export function createHuggingFaceStatusAdapter(requestTimeoutMs: number): StatusAdapter {
+	return { ...huggingFaceStatusAdapter, requestTimeoutMs };
+}
+
+const huggingFaceStatusExtension = defineStatusExtension({
+	id: "huggingface-status",
+	providerId: "huggingface",
+	create: ({ statusRequestTimeoutMs }) => createHuggingFaceStatusAdapter(statusRequestTimeoutMs),
+});
+
+export default huggingFaceStatusExtension;

package/status/moonshotai-cn.ts

@@ -0,0 +1,26 @@
+import type { StatusAdapter } from "@hyav/pi-provider";
+import { defineStatusExtension } from "@hyav/pi-provider";
+import { createMoonshotStatusAdapter, MOONSHOT_CN_BALANCE_URL } from "./moonshotai.ts";
+
+export const moonshotaiCnStatusAdapter: StatusAdapter = createMoonshotStatusAdapter(
+	{
+		id: "moonshotai-cn-status",
+		providerId: "moonshotai-cn",
+		name: "Moonshot CN (Kimi)",
+		balanceUrl: MOONSHOT_CN_BALANCE_URL,
+		unit: "CNY",
+	},
+	8_000,
+);
+
+export function createMoonshotaiCnStatusAdapter(requestTimeoutMs: number): StatusAdapter {
+	return { ...moonshotaiCnStatusAdapter, requestTimeoutMs };
+}
+
+const moonshotaiCnStatusExtension = defineStatusExtension({
+	id: "moonshotai-cn-status",
+	providerId: "moonshotai-cn",
+	create: ({ statusRequestTimeoutMs }) => createMoonshotaiCnStatusAdapter(statusRequestTimeoutMs),
+});
+
+export default moonshotaiCnStatusExtension;

package/status/moonshotai.ts

@@ -0,0 +1,151 @@
+import type { StatusAdapter, StatusEntry, StatusSnapshot } from "@hyav/pi-provider";
+import { defineStatusExtension, hasBaseUrlOrigin, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
+
+/**
+ * Moonshot (Kimi) balance checks. International and China platforms keep
+ * fully independent API keys; the same response shape is shared by both
+ * endpoints, so the adapter body is factored once.
+ */
+export const MOONSHOT_BALANCE_URL = "https://api.moonshot.ai/v1/users/me/balance";
+export const MOONSHOT_CN_BALANCE_URL = "https://api.moonshot.cn/v1/users/me/balance";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function finiteNumber(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+export interface MoonshotBalance {
+	available: number;
+	voucher?: number;
+	cash?: number;
+}
+
+export function parseMoonshotBalance(payload: unknown): MoonshotBalance {
+	if (!isRecord(payload) || !isRecord(payload.data)) {
+		throw new ProviderDataError("Moonshot status returned an invalid balance response", "badjson");
+	}
+	const code = payload.code;
+	if (code !== 0 && code !== undefined) {
+		throw new ProviderDataError("Moonshot status returned an unsuccessful balance response", "provider");
+	}
+	const available = finiteNumber(payload.data.available_balance);
+	if (available === undefined) {
+		throw new ProviderDataError("Moonshot status returned an invalid balance response", "badjson");
+	}
+	const voucher = finiteNumber(payload.data.voucher_balance);
+	const cash = finiteNumber(payload.data.cash_balance);
+	// Voucher balances are documented as non-negative; cash may be negative.
+	if (voucher !== undefined && voucher < 0) {
+		throw new ProviderDataError("Moonshot status returned an invalid balance response", "badjson");
+	}
+	return {
+		available,
+		...(voucher !== undefined ? { voucher } : {}),
+		...(cash !== undefined ? { cash } : {}),
+	};
+}
+
+export interface MoonshotStatusConfig {
+	id: string;
+	providerId: string;
+	name: string;
+	balanceUrl: string;
+	/** Official docs: international balances are USD; China balances are CNY. */
+	unit: string;
+}
+
+export function createMoonshotStatusAdapter(config: MoonshotStatusConfig, requestTimeoutMs: number): StatusAdapter {
+	const unit = config.unit;
+	return {
+		id: config.id,
+		providerId: config.providerId,
+		name: config.name,
+		cacheTtlMs: 60_000,
+		requestTimeoutMs,
+		supportsModel: (model) => hasBaseUrlOrigin(model.baseUrl, config.balanceUrl),
+		async fetch(context): Promise<StatusSnapshot> {
+			const key = await context.getApiKey();
+			if (!key || key === "proxy-managed") {
+				throw new ProviderDataError(`${config.name} status requires an API key`, "auth");
+			}
+			const response = await context.fetch(config.balanceUrl, {
+				headers: {
+					Accept: "application/json",
+					"Accept-Encoding": "identity",
+					Authorization: `Bearer ${key}`,
+					"User-Agent": "@hyav/pi-provider",
+				},
+				signal: context.signal,
+			});
+			if (!response.ok) {
+				throw new ProviderDataError(
+					`${config.name} status failed: HTTP ${response.status}`,
+					`http${response.status}`,
+					parseRetryAfter(response.headers.get("retry-after"), context.now()),
+					response.status,
+				);
+			}
+			let payload: unknown;
+			try {
+				payload = await response.json();
+			} catch {
+				throw new ProviderDataError(`${config.name} status returned invalid JSON`, "badjson");
+			}
+			const balance = parseMoonshotBalance(payload);
+			const entries: StatusEntry[] = [
+				{
+					kind: "amount",
+					id: "available-balance",
+					label: "Available balance",
+					value: balance.available,
+					unit,
+				},
+			];
+			if (balance.voucher !== undefined) {
+				entries.push({
+					kind: "amount",
+					id: "voucher-balance",
+					label: "Voucher balance",
+					value: balance.voucher,
+					unit,
+				});
+			}
+			if (balance.cash !== undefined) {
+				entries.push({
+					kind: "amount",
+					id: "cash-balance",
+					label: "Cash balance",
+					value: balance.cash,
+					unit,
+				});
+			}
+			return { entries, updatedAt: context.now() };
+		},
+	};
+}
+
+export const moonshotaiStatusAdapter = createMoonshotStatusAdapter(
+	{
+		id: "moonshotai-status",
+		providerId: "moonshotai",
+		name: "Moonshot (Kimi)",
+		balanceUrl: MOONSHOT_BALANCE_URL,
+		unit: "USD",
+	},
+	8_000,
+);
+
+export function createMoonshotaiStatusAdapter(requestTimeoutMs: number): StatusAdapter {
+	return { ...moonshotaiStatusAdapter, requestTimeoutMs };
+}
+
+const moonshotaiStatusExtension = defineStatusExtension({
+	id: "moonshotai-status",
+	providerId: "moonshotai",
+	create: ({ statusRequestTimeoutMs }) => createMoonshotaiStatusAdapter(statusRequestTimeoutMs),
+});
+
+export default moonshotaiStatusExtension;

package/status/openai-codex.ts

@@ -1,5 +1,5 @@
 import type { StatusAdapter, StatusEntry, StatusSnapshot } from "@hyav/pi-provider";
-import { defineStatusExtension, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
+import { defineStatusExtension, hasBaseUrlOrigin, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
 
 export const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
 const ACCOUNT_ID_CLAIM = "https://api.openai.com/auth";
@@ -170,6 +170,7 @@ export const openAICodexStatusAdapter: StatusAdapter = {
 	name: "OpenAI Codex",
 	cacheTtlMs: 60_000,
 	requestTimeoutMs: 8_000,
+	supportsModel: (model) => hasBaseUrlOrigin(model.baseUrl, CODEX_USAGE_URL),
 	async fetch(context): Promise<StatusSnapshot> {
 		const key = await context.getApiKey();
 		if (!key || key === "proxy-managed") {

package/status/opencode-go.ts

@@ -1,5 +1,5 @@
 import type { StatusAdapter, StatusEntry, StatusSnapshot } from "@hyav/pi-provider";
-import { defineStatusExtension, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
+import { defineStatusExtension, hasBaseUrlOrigin, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
 
 export const OPENCODE_GO_USAGE_URL = "https://opencode.ai/zen/go/v1/usage";
 
@@ -70,6 +70,7 @@ export const openCodeGoStatusAdapter: StatusAdapter = {
 	name: "OpenCode Go",
 	cacheTtlMs: 60_000,
 	requestTimeoutMs: 8_000,
+	supportsModel: (model) => hasBaseUrlOrigin(model.baseUrl, OPENCODE_GO_USAGE_URL),
 	async fetch(context): Promise<StatusSnapshot> {
 		const key = await context.getApiKey();
 		if (!key || key === "proxy-managed") {

package/status/openrouter.ts

@@ -0,0 +1,173 @@
+import type { StatusAdapter, StatusEntry, StatusSnapshot } from "@hyav/pi-provider";
+import { defineStatusExtension, hasBaseUrlOrigin, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
+
+export const OPENROUTER_KEY_URL = "https://openrouter.ai/api/v1/auth/key";
+export const OPENROUTER_CREDITS_URL = "https://openrouter.ai/api/v1/credits";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function safeNumber(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function isErrorPayload(value: Record<string, unknown>): boolean {
+	return isRecord(value.error) && (typeof value.error.code === "number" || typeof value.error.message === "string");
+}
+
+interface OpenRouterKey {
+	label: string;
+	usage: number;
+	limit: number | null;
+	isFreeTier: boolean;
+}
+
+function parseKeyPayload(value: unknown): OpenRouterKey {
+	if (!isRecord(value) || !isRecord(value.data)) {
+		throw new ProviderDataError("OpenRouter status returned an invalid key response", "badjson");
+	}
+	const data = value.data;
+	const usage = safeNumber(data.usage);
+	if (
+		typeof data.label !== "string" ||
+		typeof data.is_free_tier !== "boolean" ||
+		usage === undefined ||
+		(data.limit !== null && safeNumber(data.limit) === undefined)
+	) {
+		throw new ProviderDataError("OpenRouter status returned an invalid key response", "badjson");
+	}
+	return {
+		label: data.label.replace(/[\u0000-\u001f\u007f]/g, "").trim() || "API key",
+		usage,
+		limit: data.limit === null ? null : (safeNumber(data.limit) as number),
+		isFreeTier: data.is_free_tier,
+	};
+}
+
+async function readJson(response: Response, providerName: string): Promise<unknown> {
+	let payload: unknown;
+	try {
+		payload = await response.json();
+	} catch {
+		throw new ProviderDataError(`${providerName} status returned invalid JSON`, "badjson");
+	}
+	return payload;
+}
+
+async function fetchWithAuth(
+	context: Parameters<StatusAdapter["fetch"]>[0],
+	key: string,
+	url: string,
+	providerName: string,
+): Promise<{ response: Response; payload: unknown }> {
+	const response = await context.fetch(url, {
+		headers: {
+			Accept: "application/json",
+			"Accept-Encoding": "identity",
+			Authorization: `Bearer ${key}`,
+			"User-Agent": "@hyav/pi-provider",
+		},
+		signal: context.signal,
+	});
+	if (!response.ok) {
+		throw new ProviderDataError(
+			`${providerName} status failed: HTTP ${response.status}`,
+			`http${response.status}`,
+			parseRetryAfter(response.headers.get("retry-after"), context.now()),
+			response.status,
+		);
+	}
+	return { response, payload: await readJson(response, providerName) };
+}
+
+function keyEntries(
+	key: OpenRouterKey,
+	limitEntry: StatusEntry | undefined,
+	freeTierEntry: StatusEntry,
+): StatusEntry[] {
+	const usageEntry: StatusEntry = {
+		kind: "amount",
+		id: "credits-used",
+		label: "Credits used",
+		value: key.usage,
+		unit: "USD",
+	};
+	const entries: StatusEntry[] = [{ kind: "text", id: "key", label: "Key", value: key.label }, usageEntry];
+	if (limitEntry) entries.push(limitEntry);
+	entries.push(freeTierEntry);
+	return entries;
+}
+
+function freeTierEntry(value: boolean): StatusEntry {
+	return { kind: "text", id: "account-tier", label: "Account", value: value ? "Free tier" : "Paid" };
+}
+
+export const openRouterStatusAdapter: StatusAdapter = {
+	id: "openrouter-status",
+	providerId: "openrouter",
+	name: "OpenRouter",
+	cacheTtlMs: 60_000,
+	requestTimeoutMs: 8_000,
+	supportsModel: (model) => hasBaseUrlOrigin(model.baseUrl, OPENROUTER_KEY_URL),
+	async fetch(context): Promise<StatusSnapshot> {
+		const key = await context.getApiKey();
+		if (!key || key === "proxy-managed") {
+			throw new ProviderDataError("OpenRouter status requires an API key", "auth");
+		}
+		const keyResult = await fetchWithAuth(context, key, OPENROUTER_KEY_URL, "OpenRouter");
+		const keyPayload = keyResult.payload;
+		if (isRecord(keyPayload) && isErrorPayload(keyPayload)) {
+			throw new ProviderDataError(
+				"OpenRouter status failed: invalid API key response",
+				"auth",
+				undefined,
+				keyResult.response.status,
+			);
+		}
+		const openRouterKey = parseKeyPayload(keyPayload);
+
+		// /credits requires a management key; only show the limit when resolved.
+		let limitEntry: StatusEntry | undefined;
+		try {
+			const creditsResult = await fetchWithAuth(context, key, OPENROUTER_CREDITS_URL, "OpenRouter");
+			const payload = creditsResult.payload;
+			if (!isRecord(payload) || !isRecord(payload.data)) {
+				throw new ProviderDataError("OpenRouter status returned an invalid credits response", "badjson");
+			}
+			const totalCredits = safeNumber(payload.data.total_credits);
+			const totalUsage = safeNumber(payload.data.total_usage);
+			if (totalCredits === undefined || totalUsage === undefined) {
+				throw new ProviderDataError("OpenRouter status returned an invalid credits response", "badjson");
+			}
+			const remaining = Math.max(0, totalCredits - totalUsage);
+			limitEntry = {
+				kind: "amount",
+				id: "credits-remaining",
+				label: "Credits remaining",
+				value: remaining,
+				unit: "USD",
+			};
+		} catch (error) {
+			// Safe fallback: key credits, free-tier, and key-level limit still display.
+			if (!(error instanceof ProviderDataError)) throw error;
+		}
+
+		return {
+			entries: keyEntries(openRouterKey, limitEntry, freeTierEntry(openRouterKey.isFreeTier)),
+			updatedAt: context.now(),
+		};
+	},
+};
+
+export function createOpenRouterStatusAdapter(requestTimeoutMs: number): StatusAdapter {
+	return { ...openRouterStatusAdapter, requestTimeoutMs };
+}
+
+const openRouterStatusExtension = defineStatusExtension({
+	id: "openrouter-status",
+	providerId: "openrouter",
+	create: ({ statusRequestTimeoutMs }) => createOpenRouterStatusAdapter(statusRequestTimeoutMs),
+});
+
+export default openRouterStatusExtension;

package/status/vercel-ai-gateway/constants.ts

@@ -0,0 +1,3 @@
+/** Shared identity constants for Vercel AI Gateway adapters. */
+
+export const VERCEL_PROVIDER_ID = "vercel-ai-gateway";

package/status/vercel-ai-gateway.ts

@@ -0,0 +1,95 @@
+import type { StatusAdapter, StatusSnapshot } from "@hyav/pi-provider";
+import { defineStatusExtension, hasBaseUrlOrigin, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
+import { VERCEL_PROVIDER_ID } from "./vercel-ai-gateway/constants.ts";
+
+export const VERCEL_CREDITS_URL = "https://ai-gateway.vercel.sh/v1/credits";
+
+interface VercelCredits {
+	balance: number;
+	totalUsed: number;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function parseFiniteAmount(value: unknown): number | undefined {
+	if (typeof value === "number") return Number.isFinite(value) ? value : undefined;
+	if (typeof value !== "string" || value.trim() === "") return undefined;
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+export function parseVercelCredits(payload: unknown): VercelCredits {
+	if (!isRecord(payload)) {
+		throw new ProviderDataError("Vercel AI Gateway status returned an invalid credits response", "badjson");
+	}
+
+	const balance = parseFiniteAmount(payload.balance);
+	const totalUsed = parseFiniteAmount(payload.total_used);
+	if (balance === undefined || totalUsed === undefined) {
+		throw new ProviderDataError("Vercel AI Gateway status returned an invalid credits response", "badjson");
+	}
+
+	return { balance, totalUsed };
+}
+
+export function createVercelAIGatewayStatusAdapter(requestTimeoutMs: number): StatusAdapter {
+	return {
+		id: "vercel-ai-gateway-status",
+		providerId: VERCEL_PROVIDER_ID,
+		name: "Vercel AI Gateway",
+		cacheTtlMs: 30_000,
+		requestTimeoutMs,
+		supportsModel: (model) => hasBaseUrlOrigin(model.baseUrl, VERCEL_CREDITS_URL),
+		async fetch(context): Promise<StatusSnapshot> {
+			const key = await context.getApiKey();
+			if (!key || key === "proxy-managed") {
+				throw new ProviderDataError("Vercel AI Gateway status requires an API key", "auth");
+			}
+
+			const response = await context.fetch(VERCEL_CREDITS_URL, {
+				headers: {
+					Accept: "application/json",
+					"Accept-Encoding": "identity",
+					Authorization: `Bearer ${key}`,
+				},
+				signal: context.signal,
+			});
+			if (!response.ok) {
+				throw new ProviderDataError(
+					`Vercel AI Gateway status failed: HTTP ${response.status}`,
+					response.status === 401 ? "auth" : `http${response.status}`,
+					parseRetryAfter(response.headers.get("retry-after"), context.now()),
+					response.status,
+				);
+			}
+
+			let payload: unknown;
+			try {
+				payload = await response.json();
+			} catch {
+				throw new ProviderDataError("Vercel AI Gateway status returned invalid JSON", "badjson");
+			}
+
+			const credits = parseVercelCredits(payload);
+			return {
+				entries: [
+					{ kind: "amount", id: "balance", label: "Balance", value: credits.balance, unit: "USD" },
+					{ kind: "amount", id: "total-used", label: "Total Used", value: credits.totalUsed, unit: "USD" },
+				],
+				updatedAt: context.now(),
+			};
+		},
+	};
+}
+
+export const vercelAIGatewayStatusAdapter = createVercelAIGatewayStatusAdapter(8_000);
+
+const vercelAIGatewayStatusExtension = defineStatusExtension({
+	id: "vercel-ai-gateway-status",
+	providerId: VERCEL_PROVIDER_ID,
+	create: ({ statusRequestTimeoutMs }) => createVercelAIGatewayStatusAdapter(statusRequestTimeoutMs),
+});
+
+export default vercelAIGatewayStatusExtension;