@hyav/pi-provider 0.1.3 → 0.1.5

package/preflight/vercel-ai-gateway.ts

@@ -0,0 +1,81 @@
+import type { PreflightAdapter, PreflightSnapshot } from "@hyav/pi-provider";
+import { definePreflightExtension, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
+import { VERCEL_PROVIDER_ID } from "../status/vercel-ai-gateway/constants.ts";
+
+export const VERCEL_MODELS_URL = "https://ai-gateway.vercel.sh/v1/models";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export function parseVercelModelIds(payload: unknown): Set<string> {
+	if (!isRecord(payload) || !Array.isArray(payload.data)) {
+		throw new ProviderDataError("Vercel AI Gateway preflight returned invalid catalog data", "badjson");
+	}
+
+	const modelIds = new Set<string>();
+	for (const value of payload.data) {
+		if (!isRecord(value)) continue;
+		// Mixed-type gateway catalogs can include non-language entries.
+		if (value.type !== undefined && value.type !== "language") continue;
+		if (typeof value.id !== "string") continue;
+		const id = value.id.trim();
+		if (id !== "") modelIds.add(id);
+	}
+
+	if (modelIds.size === 0) {
+		throw new ProviderDataError("Vercel AI Gateway preflight returned an empty catalog", "badjson");
+	}
+	return modelIds;
+}
+
+export function createVercelAIGatewayPreflightAdapter(requestTimeoutMs: number): PreflightAdapter {
+	return {
+		id: "vercel-ai-gateway-preflight",
+		providerId: VERCEL_PROVIDER_ID,
+		name: "Vercel AI Gateway",
+		cacheTtlMs: 30_000,
+		requestTimeoutMs,
+		async fetch(context): Promise<PreflightSnapshot> {
+			const response = await context.fetch(VERCEL_MODELS_URL, {
+				headers: {
+					Accept: "application/json",
+					"Accept-Encoding": "identity",
+				},
+				signal: context.signal,
+			});
+			if (!response.ok) {
+				throw new ProviderDataError(
+					`Vercel AI Gateway preflight 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("Vercel AI Gateway preflight returned invalid JSON", "badjson");
+			}
+
+			return {
+				passed: parseVercelModelIds(payload).has(context.model.id),
+				checks: ["endpoint", "catalog"],
+				updatedAt: context.now(),
+				httpStatus: response.status,
+			};
+		},
+	};
+}
+
+export const vercelAIGatewayPreflightAdapter = createVercelAIGatewayPreflightAdapter(8_000);
+
+const vercelAIGatewayPreflightExtension = definePreflightExtension({
+	id: "vercel-ai-gateway-preflight",
+	providerId: VERCEL_PROVIDER_ID,
+	create: ({ statusRequestTimeoutMs }) => createVercelAIGatewayPreflightAdapter(statusRequestTimeoutMs),
+});
+
+export default vercelAIGatewayPreflightExtension;

package/preflight/xai.ts

@@ -0,0 +1,71 @@
+import type { PreflightAdapter } from "@hyav/pi-provider";
+import { definePreflightExtension, hasBaseUrlOrigin, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
+import { XAI_MODELS_URL } from "../status/xai.ts";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export const xaiPreflightAdapter: PreflightAdapter = {
+	id: "xai-preflight",
+	providerId: "xai",
+	name: "xAI",
+	cacheTtlMs: 30_000,
+	requestTimeoutMs: 8_000,
+	supportsModel: (model) => hasBaseUrlOrigin(model.baseUrl, XAI_MODELS_URL),
+	async fetch(context) {
+		const apiKey = await context.getApiKey();
+		const authHeaders: Record<string, string> = {
+			Accept: "application/json",
+			"Accept-Encoding": "identity",
+			"User-Agent": "@hyav/pi-provider",
+		};
+		if (apiKey && apiKey !== "proxy-managed") authHeaders.Authorization = `Bearer ${apiKey}`;
+		const response = await context.fetch(XAI_MODELS_URL, {
+			headers: authHeaders,
+			signal: context.signal,
+		});
+		if (!response.ok) {
+			throw new ProviderDataError(
+				`xAI preflight 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("xAI preflight returned invalid JSON", "badjson");
+		}
+		if (!isRecord(payload) || !Array.isArray(payload.data)) {
+			throw new ProviderDataError("xAI preflight returned invalid catalog data", "badjson");
+		}
+		const modelIds = new Set(
+			payload.data
+				.filter(isRecord)
+				.map((model) => (typeof model.id === "string" ? model.id.trim() : undefined))
+				.filter((id): id is string => id !== undefined && id !== ""),
+		);
+		const checks = apiKey && apiKey !== "proxy-managed" ? ["endpoint", "catalog", "auth"] : ["endpoint", "catalog"];
+		return {
+			passed: modelIds.has(context.model.id),
+			checks,
+			updatedAt: context.now(),
+			httpStatus: response.status,
+		};
+	},
+};
+
+export function createXaiPreflightAdapter(requestTimeoutMs: number): PreflightAdapter {
+	return { ...xaiPreflightAdapter, requestTimeoutMs };
+}
+
+const xaiPreflightExtension = definePreflightExtension({
+	id: "xai-preflight",
+	providerId: "xai",
+	create: ({ statusRequestTimeoutMs }) => createXaiPreflightAdapter(statusRequestTimeoutMs),
+});
+
+export default xaiPreflightExtension;

package/providers/charm-hyper.ts

@@ -9,6 +9,7 @@ import type {
 import {
 	defineProviderExtension,
 	isProviderDataError,
+	MAX_PROVIDER_MODEL_COUNT,
 	normalizeProviderModels,
 	ProviderDataError,
 	withDeadline,
@@ -242,6 +243,7 @@ function parseCurrentHyperModel(value: unknown): ProviderModelDraft | undefined
 
 function parseCurrentHyperModels(payload: Record<string, unknown>): ProviderModelDraft[] | undefined {
 	if (!Array.isArray(payload.models)) return undefined;
+	if (payload.models.length > MAX_PROVIDER_MODEL_COUNT) return [];
 	const models: ProviderModelDraft[] = [];
 	const seenIds = new Set<string>();
 	for (const value of payload.models) {
@@ -256,7 +258,7 @@ function parseCurrentHyperModels(payload: Record<string, unknown>): ProviderMode
 }
 
 function parseLegacyHyperModels(payload: Record<string, unknown>): ProviderModelDraft[] {
-	if (!Array.isArray(payload.data)) return [];
+	if (!Array.isArray(payload.data) || payload.data.length > MAX_PROVIDER_MODEL_COUNT) return [];
 	const models: ProviderModelDraft[] = [];
 	const seenIds = new Set<string>();
 
@@ -356,6 +358,7 @@ async function discoverHyperModels(
 			if (models.length === 0) {
 				throw new ProviderDataError("Charm Hyper model discovery returned no valid models", "badjson");
 			}
+			normalizeProviderModels(models);
 			return models;
 		},
 		timeoutMs,

package/status/anthropic.ts

@@ -0,0 +1,262 @@
+import type { StatusAdapter, StatusEntry, StatusSnapshot } from "@hyav/pi-provider";
+import { defineStatusExtension, hasBaseUrlOrigin, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
+
+/**
+ * Anthropic usage endpoint for subscription quotas (Claude Pro/Max) and extra
+ * usage credit. Not part of the public platform API contract, so the URL is
+ * overridable: ANTHROPIC_USAGE_URL, or set it to an empty string to disable.
+ */
+export const DEFAULT_ANTHROPIC_USAGE_URL = "https://claude.ai/api/usage";
+export const ANTHROPIC_USAGE_URL =
+	typeof process !== "undefined" && process.env.ANTHROPIC_USAGE_URL !== undefined
+		? process.env.ANTHROPIC_USAGE_URL
+		: DEFAULT_ANTHROPIC_USAGE_URL;
+
+/**
+ * Anthropic API keys are `sk-ant-api...`; subscription OAuth access tokens
+ * (used by Claude web / Claude Code) contain `sk-ant-oat...`. Only subscription
+ * tokens may be sent to the Claude web usage endpoint. This keeps API keys
+ * resolved from environment variables, models.json, or a runtime from ever
+ * reaching it.
+ */
+export function isAnthropicOAuthToken(key: string): boolean {
+	return key.includes("sk-ant-oat");
+}
+
+export function isAnthropicApiKey(key: string): boolean {
+	return (key.startsWith("sk-ant-api") || key.startsWith("sk-ant-")) && !isAnthropicOAuthToken(key);
+}
+
+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 safeLabel(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 AnthropicUsageWindow {
+	id: string;
+	label: string;
+	used: number;
+	limit: number;
+}
+
+export function parseAnthropicUsage(payload: unknown): {
+	plan?: string;
+	resetAt?: number;
+	windows: AnthropicUsageWindow[];
+	extraUsageBalanceUsd?: number;
+} {
+	if (!isRecord(payload)) {
+		throw new ProviderDataError("Anthropic status returned an invalid usage response", "badjson");
+	}
+	const subscribed = isRecord(payload.subscribedUsage) ? payload.subscribedUsage : payload;
+
+	/** History arrays use their latest entry as the current value. */
+	const read = (field: string): number | undefined => {
+		const value = subscribed[field];
+		if (Array.isArray(value)) {
+			const latest = value[value.length - 1];
+			return typeof latest === "number" && Number.isFinite(latest) ? latest : undefined;
+		}
+		return finiteNumber(value);
+	};
+	const readLimit = (field: string): number | undefined => {
+		const limitValue = finiteNumber(subscribed[`${field}Limit`]);
+		if (limitValue !== undefined && limitValue > 0) return limitValue;
+		const entriesValue = subscribed[field];
+		if (isRecord(entriesValue)) {
+			const nested = finiteNumber(entriesValue.limit);
+			if (nested !== undefined && nested > 0) return nested;
+		}
+		return undefined;
+	};
+
+	const windows: AnthropicUsageWindow[] = [];
+	for (const [field, id, label] of [
+		["session", "session-usage", "Session"],
+		["daily", "daily-usage", "Daily"],
+		["weekly", "weekly-usage", "Weekly"],
+		["monthly", "monthly-usage", "Monthly"],
+	] as const) {
+		const used = read(field);
+		const limit = readLimit(field);
+		if (used !== undefined && limit !== undefined) {
+			windows.push({ id, label, used, limit });
+		}
+	}
+
+	const resetAtValue = finiteNumber(payload.weeklyResetAt) ?? finiteNumber(subscribed.weeklyResetAt);
+	const resetAt = resetAtValue !== undefined && resetAtValue > 0 ? resetAtValue * 1_000 : undefined;
+
+	return {
+		plan: safeLabel(payload.plan) ?? safeLabel(payload.subscriptionPlan),
+		...(resetAt !== undefined ? { resetAt } : {}),
+		windows,
+		extraUsageBalanceUsd: finiteNumber(payload.extraUsageBalanceUsd) ?? finiteNumber(subscribed.extraUsageBalanceUsd),
+	};
+}
+
+function windowEntry(id: string, label: string, used: number, limit: number, resetAt: number | undefined): StatusEntry {
+	const percent = (used / limit) * 100;
+	return {
+		kind: "window",
+		id,
+		label,
+		remainingPercent: Math.max(0, Math.min(100, 100 - percent)),
+		...(resetAt !== undefined ? { resetAt } : {}),
+	};
+}
+
+function usageEntries(payload: unknown): StatusEntry[] {
+	const parsed = parseAnthropicUsage(payload);
+	const entries: StatusEntry[] = [{ kind: "text", id: "plan", label: "Plan", value: parsed.plan ?? "Unknown" }];
+	for (const window of parsed.windows) {
+		entries.push(windowEntry(window.id, window.label, window.used, window.limit, parsed.resetAt));
+	}
+	if (parsed.extraUsageBalanceUsd !== undefined) {
+		entries.push({
+			kind: "amount",
+			id: "extra-usage-balance",
+			label: "Extra usage balance",
+			value: parsed.extraUsageBalanceUsd,
+			unit: "USD",
+		});
+	}
+	if (entries.length === 1) {
+		entries.push({ kind: "text", id: "limits", label: "Limits", value: "not available" });
+	}
+	return entries;
+}
+
+async function credentialType(context: Parameters<StatusAdapter["fetch"]>[0]): Promise<string | undefined> {
+	try {
+		return await context.getCredentialType?.();
+	} catch {
+		return undefined;
+	}
+}
+
+function apiKeyEntries(): StatusEntry[] {
+	return [
+		{ kind: "text", id: "auth", label: "Auth", value: "API key" },
+		{ kind: "text", id: "usage", label: "Usage", value: "not available from the subscription endpoint" },
+	];
+}
+
+export interface AnthropicStatusOptions {
+	/** Usage endpoint override; defaults to ANTHROPIC_USAGE_URL. */
+	usageUrl?: string;
+}
+
+export function createAnthropicStatusAdapter(
+	requestTimeoutMs: number,
+	options: AnthropicStatusOptions = {},
+): StatusAdapter {
+	const usageUrl = (options.usageUrl ?? ANTHROPIC_USAGE_URL).trim();
+	return {
+		id: "anthropic-status",
+		providerId: "anthropic",
+		name: "Anthropic",
+		cacheTtlMs: 60_000,
+		requestTimeoutMs,
+		supportsModel: (model) =>
+			usageUrl === "" ||
+			usageUrl !== DEFAULT_ANTHROPIC_USAGE_URL ||
+			hasBaseUrlOrigin(model.baseUrl, "https://api.anthropic.com"),
+		async fetch(context): Promise<StatusSnapshot> {
+			const key = await context.getApiKey();
+			if (!key || key === "proxy-managed") {
+				throw new ProviderDataError("Anthropic status requires authentication", "auth");
+			}
+			const credential = await credentialType(context);
+			const isOAuth = credential === "oauth" ? !isAnthropicApiKey(key) : isAnthropicOAuthToken(key);
+			if (usageUrl === "") {
+				return {
+					entries: [{ kind: "text", id: "usage", label: "Usage", value: "disabled" }],
+					updatedAt: context.now(),
+				};
+			}
+
+			if (!isOAuth) {
+				if (usageUrl === DEFAULT_ANTHROPIC_USAGE_URL) {
+					// The default endpoint is subscription-only. Never send an
+					// API key there; the user can configure a custom endpoint
+					// via ANTHROPIC_USAGE_URL if they run their own queries.
+					return { entries: apiKeyEntries(), updatedAt: context.now() };
+				}
+				// Explicitly configured custom endpoint: send as x-api-key only.
+				const response = await context.fetch(usageUrl, {
+					headers: {
+						Accept: "application/json",
+						"Accept-Encoding": "identity",
+						"x-api-key": key,
+						"User-Agent": "@hyav/pi-provider",
+					},
+					signal: context.signal,
+				});
+				if (!response.ok) {
+					throw new ProviderDataError(
+						`Anthropic 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("Anthropic status returned invalid JSON", "badjson");
+				}
+				return { entries: usageEntries(payload), updatedAt: context.now() };
+			}
+
+			// OAuth (Claude Pro/Max) uses the usage endpoint with the subscription Bearer token.
+			const response = await context.fetch(usageUrl, {
+				headers: {
+					Accept: "application/json",
+					"Accept-Encoding": "identity",
+					Authorization: `Bearer ${key}`,
+					"User-Agent": "@hyav/pi-provider",
+				},
+				signal: context.signal,
+			});
+			if (!response.ok) {
+				throw new ProviderDataError(
+					`Anthropic 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("Anthropic status returned invalid JSON", "badjson");
+			}
+			return { entries: usageEntries(payload), updatedAt: context.now() };
+		},
+	};
+}
+
+export const anthropicStatusAdapter = createAnthropicStatusAdapter(8_000);
+
+const anthropicStatusExtension = defineStatusExtension({
+	id: "anthropic-status",
+	providerId: "anthropic",
+	create: ({ statusRequestTimeoutMs }) => createAnthropicStatusAdapter(statusRequestTimeoutMs),
+});
+
+export default anthropicStatusExtension;

package/status/charm-hyper.ts

@@ -1,5 +1,5 @@
 import type { StatusAdapter, StatusSnapshot } from "@hyav/pi-provider";
-import { defineStatusExtension, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
+import { defineStatusExtension, hasBaseUrlOrigin, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
 import { hyperJsonHeaders } from "../providers/charm-hyper/constants.ts";
 
 const CREDITS_URL = "https://hyper.charm.land/v1/credits";
@@ -21,8 +21,9 @@ export const hyperStatusAdapter: StatusAdapter = {
 	id: "charm-hyper-status",
 	providerId: "charm-hyper",
 	name: "Charm Hyper",
-	cacheTtlMs: 30_000,
+	cacheTtlMs: 60_000,
 	requestTimeoutMs: 8_000,
+	supportsModel: (model) => hasBaseUrlOrigin(model.baseUrl, CREDITS_URL),
 	async fetch(context): Promise<StatusSnapshot> {
 		const key = await context.getApiKey();
 		const headers = new Headers(hyperJsonHeaders({ "Accept-Encoding": "identity" }));

package/status/deepseek.ts

@@ -1,5 +1,5 @@
 import type { StatusAdapter, StatusSnapshot } from "@hyav/pi-provider";
-import { defineStatusExtension, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
+import { defineStatusExtension, hasBaseUrlOrigin, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
 
 export const DEEPSEEK_BALANCE_URL = "https://api.deepseek.com/user/balance";
 
@@ -41,6 +41,7 @@ export const deepSeekStatusAdapter: StatusAdapter = {
 	name: "DeepSeek",
 	cacheTtlMs: 30_000,
 	requestTimeoutMs: 8_000,
+	supportsModel: (model) => hasBaseUrlOrigin(model.baseUrl, DEEPSEEK_BALANCE_URL),
 	async fetch(context): Promise<StatusSnapshot> {
 		const key = await context.getApiKey();
 		if (!key || key === "proxy-managed") {

package/status/github-copilot.ts

@@ -0,0 +1,189 @@
+import type { StatusAdapter, StatusEntry, StatusSnapshot } from "@hyav/pi-provider";
+import {
+	appendBaseUrlPath,
+	authDefinesHeader,
+	defineStatusExtension,
+	getContextAuth,
+	mergeDiagnosticHeaders,
+	ProviderDataError,
+	parseRetryAfter,
+} from "@hyav/pi-provider";
+
+/**
+ * GitHub Copilot Individual usage. These endpoints are not part of public
+ * GitHub documentation, so payload shapes are parsed defensively and a 404
+ * degrades to a single explanatory entry instead of an error state.
+ */
+export const COPILOT_BASE_URL = "https://api.individual.githubcopilot.com";
+export const COPILOT_USAGE_URL = `${COPILOT_BASE_URL}/usage`;
+
+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;
+}
+
+interface CopilotQuota {
+	id: string;
+	name?: string;
+	used: number;
+	limit: number;
+	resetAt?: number;
+}
+
+function labelValue(value: unknown): string | undefined {
+	if (typeof value === "string") return safeText(value);
+	if (isRecord(value)) return safeText(value.value) ?? safeText(value.label);
+	return undefined;
+}
+
+function planName(value: unknown): string | undefined {
+	return labelValue(isRecord(value) ? value.planName : undefined);
+}
+
+/** Preferred shape: `modelCatalog.usage.modelQuotas`. */
+function parseModelCatalog(catalog: unknown): CopilotQuota[] {
+	if (!isRecord(catalog) || !isRecord(catalog.usage) || !isRecord(catalog.usage.modelQuotas)) return [];
+	const quotas: CopilotQuota[] = [];
+	for (const [key, value] of Object.entries(catalog.usage.modelQuotas)) {
+		if (!isRecord(value)) continue;
+		const used =
+			finiteNumber(value.usedRequestsQuantity) ?? finiteNumber(value.usedRequests) ?? finiteNumber(value.used);
+		const limit = finiteNumber(value.allowedRequestsQuantity);
+		if (used === undefined || limit === undefined || limit <= 0) continue;
+		const resetAt = finiteNumber(value.resetAt);
+		quotas.push({
+			id: key,
+			name: safeText(value.modelCopilotName),
+			used,
+			limit,
+			...(resetAt !== undefined ? { resetAt: resetAt * 1_000 } : {}),
+		});
+	}
+	return quotas;
+}
+
+/** Fallback shape: `modelQuotaByFeature[]` with nested payload. */
+function parseQuotaByFeature(payload: unknown): CopilotQuota[] {
+	if (!isRecord(payload) || !Array.isArray(payload.modelQuotaByFeature)) return [];
+	const quotas: CopilotQuota[] = [];
+	for (const [index, entry] of payload.modelQuotaByFeature.entries()) {
+		if (!isRecord(entry)) continue;
+		const quota =
+			(isRecord(entry.modelQuotaPayload) && entry.modelQuotaPayload) ||
+			(isRecord(entry.modelQuotaForFeature) && entry.modelQuotaForFeature);
+		if (!quota) continue;
+		const used = finiteNumber(quota.usedRequestsQuantity) ?? finiteNumber(quota.usedRequests);
+		const limit = finiteNumber(quota.allowedRequestsQuantity);
+		if (used === undefined || limit === undefined) continue;
+		const resetAt = finiteNumber(quota.resetAt);
+		const name = safeText(quota.modelCopilotName);
+		quotas.push({
+			id: typeof quota.quotaId === "string" && quota.quotaId.trim() !== "" ? quota.quotaId.trim() : `quota-${index}`,
+			...(name !== undefined ? { name } : {}),
+			used,
+			limit,
+			...(resetAt !== undefined ? { resetAt: resetAt * 1_000 } : {}),
+		});
+	}
+	return quotas;
+}
+
+function windowEntry(quota: CopilotQuota): StatusEntry {
+	const percent = (quota.used / quota.limit) * 100;
+	return {
+		kind: "window",
+		id: `quota-${quota.id}`,
+		label: quota.name ?? quota.id,
+		remainingPercent: Math.max(0, Math.min(100, 100 - percent)),
+		...(quota.resetAt !== undefined ? { resetAt: quota.resetAt } : {}),
+	};
+}
+
+export const githubCopilotStatusAdapter: StatusAdapter = {
+	id: "github-copilot-status",
+	providerId: "github-copilot",
+	name: "GitHub Copilot",
+	cacheTtlMs: 60_000,
+	requestTimeoutMs: 8_000,
+	async fetch(context): Promise<StatusSnapshot> {
+		const auth = await getContextAuth(context);
+		const key = auth.apiKey;
+		if (!key || key === "proxy-managed") {
+			throw new ProviderDataError("GitHub Copilot status requires Copilot OAuth", "auth");
+		}
+		const url = appendBaseUrlPath(context.model?.baseUrl ?? auth.baseUrl, "usage", COPILOT_BASE_URL);
+		if (!url) throw new ProviderDataError("GitHub Copilot usage endpoint is unavailable", "unsupported");
+		const headers = mergeDiagnosticHeaders(auth, {
+			Accept: "application/json",
+			"Accept-Encoding": "identity",
+			"User-Agent": "@hyav/pi-provider",
+		});
+		if (!authDefinesHeader(auth, "Authorization")) headers.set("Authorization", `Bearer ${key}`);
+		const response = await context.fetch(url, {
+			headers,
+			signal: context.signal,
+		});
+		if (response.status === 404) {
+			return {
+				entries: [{ kind: "text", id: "usage", label: "Usage", value: "unavailable for this plan" }],
+				updatedAt: context.now(),
+			};
+		}
+		if (!response.ok) {
+			throw new ProviderDataError(
+				`GitHub Copilot 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("GitHub Copilot status returned invalid JSON", "badjson");
+		}
+		if (!isRecord(payload)) {
+			throw new ProviderDataError("GitHub Copilot status returned an invalid usage response", "badjson");
+		}
+		const quotas = parseModelCatalog(isRecord(payload.modelCatalog) ? payload.modelCatalog : payload);
+		const modelQuotas = quotas.length > 0 ? quotas : parseQuotaByFeature(payload);
+		const entries: StatusEntry[] = [
+			{
+				kind: "text",
+				id: "plan",
+				label: "Plan",
+				value: isRecord(payload.modelCatalog) ? (planName(payload.modelCatalog) ?? "Unknown") : "Unknown",
+			},
+		];
+		for (const quota of modelQuotas) entries.push(windowEntry(quota));
+		if (entries.length === 1) {
+			entries.push({ kind: "text", id: "limits", label: "Limits", value: "not available" });
+		}
+		return { entries, updatedAt: context.now() };
+	},
+};
+
+export function createGithubCopilotStatusAdapter(requestTimeoutMs: number): StatusAdapter {
+	return { ...githubCopilotStatusAdapter, requestTimeoutMs };
+}
+
+const githubCopilotStatusExtension = defineStatusExtension({
+	id: "github-copilot-status",
+	providerId: "github-copilot",
+	create: ({ statusRequestTimeoutMs }) => createGithubCopilotStatusAdapter(statusRequestTimeoutMs),
+});
+
+export default githubCopilotStatusExtension;