@vib-rato/ai 0.16.0

package/src/usage/claude.ts

@@ -0,0 +1,449 @@
+import { scheduler } from "node:timers/promises";
+import { claudeCodeVersion } from "../providers/anthropic";
+import type {
+	CredentialRankingStrategy,
+	UsageAmount,
+	UsageFetchContext,
+	UsageFetchParams,
+	UsageLimit,
+	UsageProvider,
+	UsageReport,
+	UsageStatus,
+	UsageWindow,
+} from "../usage";
+import { isRecord, toNumber } from "../utils";
+
+const DEFAULT_ENDPOINT = "https://api.anthropic.com/api/oauth";
+const FIVE_HOURS_MS = 5 * 60 * 60 * 1000;
+const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
+const MAX_ATTEMPTS = 3;
+const BASE_RETRY_DELAY_MS = 500;
+/**
+ * Ceiling for a server-supplied `Retry-After`. Matches `OPENAI_RETRY_DELAY_CAP_MS`
+ * and `fetchWithRetry`'s `DEFAULT_MAX_DELAY_MS`. Without it a hostile or
+ * misconfigured endpoint stalls the usage fetch for as long as it likes
+ * (`Retry-After: 86400` previously produced a 24h sleep).
+ */
+const MAX_RETRY_DELAY_MS = 60_000;
+
+const CLAUDE_HEADERS = {
+	accept: "application/json, text/plain, */*",
+	"accept-encoding": "gzip, compress, deflate, br",
+	"anthropic-beta":
+		"claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,context-management-2025-06-27,prompt-caching-scope-2026-01-05",
+	"content-type": "application/json",
+	"user-agent": `claude-cli/${claudeCodeVersion} (external, cli)`,
+	connection: "keep-alive",
+} as const;
+
+function normalizeClaudeBaseUrl(baseUrl?: string): string {
+	if (!baseUrl?.trim()) return DEFAULT_ENDPOINT;
+	const trimmed = baseUrl.trim().replace(/\/+$/, "");
+	const lower = trimmed.toLowerCase();
+	if (lower.endsWith("/api/oauth")) return trimmed;
+	let url: URL;
+	try {
+		url = new URL(trimmed);
+	} catch {
+		return DEFAULT_ENDPOINT;
+	}
+	let path = url.pathname.replace(/\/+$/, "");
+	if (path === "/") path = "";
+	if (path.toLowerCase().endsWith("/v1")) {
+		path = path.slice(0, -3);
+	}
+	if (!path) return `${url.origin}/api/oauth`;
+	return `${url.origin}${path}/api/oauth`;
+}
+
+interface ClaudeUsageBucket {
+	utilization?: number;
+	resets_at?: string;
+}
+
+interface ParsedUsageBucket {
+	utilization?: number;
+	resetsAt?: number;
+}
+
+interface ClaudeUsageResponse {
+	five_hour?: ClaudeUsageBucket | null;
+	seven_day?: ClaudeUsageBucket | null;
+	seven_day_opus?: ClaudeUsageBucket | null;
+	seven_day_sonnet?: ClaudeUsageBucket | null;
+}
+
+type ClaudeUsagePayload = {
+	payload: ClaudeUsageResponse;
+	orgId?: string;
+};
+
+function parseIsoTime(value: string | undefined): number | undefined {
+	if (!value) return undefined;
+	const parsed = Date.parse(value);
+	return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+function parseBucket(bucket: unknown): ParsedUsageBucket | undefined {
+	if (!isRecord(bucket)) return undefined;
+	const utilization = toNumber(bucket.utilization);
+	const resetsAt = parseIsoTime(typeof bucket.resets_at === "string" ? bucket.resets_at : undefined);
+	if (utilization === undefined && resetsAt === undefined) {
+		return undefined;
+	}
+	return { utilization, resetsAt };
+}
+
+function getPayloadString(payload: Record<string, unknown>, key: string): string | undefined {
+	const value = payload[key];
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function getNestedPayloadString(payload: Record<string, unknown>, key: string, nestedKey: string): string | undefined {
+	const nested = payload[key];
+	return isRecord(nested) ? getPayloadString(nested, nestedKey) : undefined;
+}
+
+function extractUsageIdentity(payload: ClaudeUsageResponse, orgId?: string): { accountId?: string; email?: string } {
+	if (!isRecord(payload)) return { accountId: orgId };
+	const accountId =
+		getPayloadString(payload, "account_id") ??
+		getPayloadString(payload, "accountId") ??
+		getPayloadString(payload, "user_id") ??
+		getPayloadString(payload, "userId") ??
+		getPayloadString(payload, "org_id") ??
+		getPayloadString(payload, "orgId") ??
+		getNestedPayloadString(payload, "account", "uuid") ??
+		getNestedPayloadString(payload, "account", "id") ??
+		getNestedPayloadString(payload, "organization", "uuid") ??
+		getNestedPayloadString(payload, "organization", "id") ??
+		getNestedPayloadString(payload, "user", "uuid") ??
+		getNestedPayloadString(payload, "user", "id") ??
+		orgId;
+	const email =
+		getPayloadString(payload, "email") ??
+		getPayloadString(payload, "user_email") ??
+		getPayloadString(payload, "userEmail") ??
+		getNestedPayloadString(payload, "account", "email") ??
+		getNestedPayloadString(payload, "user", "email");
+	return { accountId, email };
+}
+
+function hasUsageData(payload: ClaudeUsageResponse): boolean {
+	return (
+		parseBucket(payload.five_hour)?.utilization !== undefined ||
+		parseBucket(payload.seven_day)?.utilization !== undefined ||
+		parseBucket(payload.seven_day_opus)?.utilization !== undefined ||
+		parseBucket(payload.seven_day_sonnet)?.utilization !== undefined
+	);
+}
+
+function isRetryableStatus(status: number): boolean {
+	return status === 429 || (status >= 500 && status < 600);
+}
+
+function isAbortError(error: unknown, signal?: AbortSignal): boolean {
+	if (signal?.aborted) return true;
+	if (!isRecord(error)) return false;
+	return error.name === "AbortError" || error.name === "TimeoutError";
+}
+
+/**
+ * Honour the server hint but never exceed `MAX_RETRY_DELAY_MS`, and never
+ * return a negative/non-finite delay. Keeps the sleep bounded so an abort has
+ * an upper bound to fire within.
+ */
+function clampRetryDelay(baseline: number, hintMs: number): number {
+	const hint = Number.isFinite(hintMs) ? Math.max(0, hintMs) : 0;
+	return Math.min(Math.max(baseline, hint), MAX_RETRY_DELAY_MS);
+}
+
+function retryDelayMs(attempt: number, retryAfter: string | null): number {
+	const baseline = BASE_RETRY_DELAY_MS * 2 ** attempt;
+	if (!retryAfter?.trim()) return baseline;
+	const seconds = Number.parseFloat(retryAfter);
+	if (Number.isFinite(seconds)) return clampRetryDelay(baseline, seconds * 1000);
+	const dateDelay = Date.parse(retryAfter) - Date.now();
+	return Number.isFinite(dateDelay) ? clampRetryDelay(baseline, dateDelay) : baseline;
+}
+
+async function waitBeforeRetry(
+	attempt: number,
+	retryAfter: string | null,
+	signal?: AbortSignal,
+	retryWait?: UsageFetchContext["retryWait"],
+): Promise<boolean> {
+	if (signal?.aborted) return false;
+	if (attempt >= MAX_ATTEMPTS - 1) return false;
+	try {
+		const delayMs = retryDelayMs(attempt, retryAfter);
+		if (retryWait) {
+			await retryWait(delayMs, signal);
+		} else {
+			await scheduler.wait(delayMs, { signal });
+		}
+		return !signal?.aborted;
+	} catch (error) {
+		if (isAbortError(error, signal)) return false;
+		throw error;
+	}
+}
+
+async function fetchUsagePayload(
+	url: string,
+	headers: Record<string, string>,
+	ctx: UsageFetchContext,
+	signal?: AbortSignal,
+): Promise<ClaudeUsagePayload | null> {
+	if (signal?.aborted) return null;
+
+	let lastPayload: ClaudeUsageResponse | null = null;
+	let lastOrgId: string | undefined;
+	for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+		try {
+			const response = await ctx.fetch(url, { headers, signal });
+			const orgId = response.headers.get("anthropic-organization-id")?.trim() || undefined;
+			lastOrgId = orgId ?? lastOrgId;
+
+			if (!response.ok) {
+				const retryable = isRetryableStatus(response.status);
+				ctx.logger?.warn("Claude usage fetch failed", {
+					status: response.status,
+					statusText: response.statusText,
+					attempt,
+					willRetry: retryable && attempt < MAX_ATTEMPTS - 1,
+				});
+				if (!retryable) return null;
+				const retryAfter = response.headers.get("retry-after");
+				if (!(await waitBeforeRetry(attempt, retryAfter, signal, ctx.retryWait))) break;
+				continue;
+			}
+
+			const parsed = (await response.json()) as unknown;
+			if (isRecord(parsed)) {
+				const payload = parsed as ClaudeUsageResponse;
+				lastPayload = payload;
+				if (hasUsageData(payload)) return { payload, orgId };
+			}
+
+			ctx.logger?.warn("Claude usage response missing usage data", {
+				attempt,
+				willRetry: attempt < MAX_ATTEMPTS - 1,
+			});
+			if (!(await waitBeforeRetry(attempt, null, signal, ctx.retryWait))) break;
+		} catch (error) {
+			if (isAbortError(error, signal)) return null;
+			ctx.logger?.warn("Claude usage fetch error", {
+				error: String(error),
+				attempt,
+				willRetry: attempt < MAX_ATTEMPTS - 1,
+			});
+			if (!(await waitBeforeRetry(attempt, null, signal, ctx.retryWait))) break;
+		}
+	}
+
+	return lastPayload ? { payload: lastPayload, orgId: lastOrgId } : null;
+}
+
+interface ClaudeProfile {
+	uuid?: string;
+	email?: string;
+	account?: {
+		uuid?: string;
+		email?: string;
+	};
+}
+
+function extractProfileIdentity(profile: ClaudeProfile | null): { accountId?: string; email?: string } {
+	if (!profile || !isRecord(profile)) return {};
+	const account = isRecord(profile.account) ? profile.account : undefined;
+	return {
+		accountId:
+			(typeof profile.uuid === "string" && profile.uuid.trim() ? profile.uuid.trim() : undefined) ??
+			(typeof account?.uuid === "string" && account.uuid.trim() ? account.uuid.trim() : undefined),
+		email:
+			(typeof profile.email === "string" && profile.email.trim() ? profile.email.trim() : undefined) ??
+			(typeof account?.email === "string" && account.email.trim() ? account.email.trim() : undefined),
+	};
+}
+
+async function fetchProfile(
+	baseUrl: string,
+	headers: Record<string, string>,
+	ctx: UsageFetchContext,
+	signal?: AbortSignal,
+): Promise<ClaudeProfile | null> {
+	if (signal?.aborted) return null;
+	const url = `${baseUrl}/profile`;
+	try {
+		const response = await ctx.fetch(url, { headers, signal });
+		if (!response.ok) return null;
+		const payload = (await response.json()) as unknown;
+		return isRecord(payload) ? (payload as ClaudeProfile) : null;
+	} catch (error) {
+		if (isAbortError(error, signal)) return null;
+		ctx.logger?.debug("Claude profile fetch error", { error: String(error) });
+		return null;
+	}
+}
+
+function buildUsageAmount(utilization: number | undefined): UsageAmount | undefined {
+	if (utilization === undefined) return undefined;
+	const clamped = Math.min(Math.max(utilization, 0), 100);
+	const usedFraction = clamped / 100;
+	return {
+		used: clamped,
+		limit: 100,
+		remaining: Math.max(0, 100 - clamped),
+		usedFraction,
+		remainingFraction: Math.max(0, 1 - usedFraction),
+		unit: "percent",
+	};
+}
+
+function buildUsageStatus(usedFraction: number | undefined): UsageStatus | undefined {
+	if (usedFraction === undefined) return undefined;
+	if (usedFraction >= 1) return "exhausted";
+	if (usedFraction >= 0.9) return "warning";
+	return "ok";
+}
+
+function buildUsageLimit(args: {
+	id: string;
+	label: string;
+	windowId: string;
+	windowLabel: string;
+	durationMs: number;
+	bucket: ParsedUsageBucket | undefined;
+	provider: "anthropic";
+	tier?: string;
+	shared?: boolean;
+}): UsageLimit | null {
+	if (!args.bucket) return null;
+	const amount = buildUsageAmount(args.bucket.utilization);
+	if (!amount) return null;
+	const window: UsageWindow = {
+		id: args.windowId,
+		label: args.windowLabel,
+		durationMs: args.durationMs,
+		...(args.bucket.resetsAt !== undefined ? { resetsAt: args.bucket.resetsAt } : {}),
+	};
+	return {
+		id: args.id,
+		label: args.label,
+		scope: {
+			provider: args.provider,
+			windowId: args.windowId,
+			tier: args.tier,
+			shared: args.shared,
+		},
+		window,
+		amount,
+		status: buildUsageStatus(amount.usedFraction),
+	};
+}
+
+async function fetchClaudeUsage(params: UsageFetchParams, ctx: UsageFetchContext): Promise<UsageReport | null> {
+	if (params.provider !== "anthropic") return null;
+	const credential = params.credential;
+	if (credential.type !== "oauth" || !credential.accessToken) return null;
+
+	const baseUrl = normalizeClaudeBaseUrl(params.baseUrl);
+	const url = `${baseUrl}/usage`;
+	const headers: Record<string, string> = {
+		...CLAUDE_HEADERS,
+		authorization: `Bearer ${credential.accessToken}`,
+	};
+
+	const payloadResult = await fetchUsagePayload(url, headers, ctx, params.signal);
+	if (!payloadResult || !isRecord(payloadResult.payload)) return null;
+	const { payload, orgId } = payloadResult;
+
+	const fiveHour = parseBucket(payload.five_hour);
+	const sevenDay = parseBucket(payload.seven_day);
+	const sevenDayOpus = parseBucket(payload.seven_day_opus);
+	const sevenDaySonnet = parseBucket(payload.seven_day_sonnet);
+
+	const limits = [
+		buildUsageLimit({
+			id: "anthropic:5h",
+			label: "Claude 5 Hour",
+			windowId: "5h",
+			windowLabel: "5 Hour",
+			durationMs: FIVE_HOURS_MS,
+			bucket: fiveHour,
+			provider: "anthropic",
+			shared: true,
+		}),
+		buildUsageLimit({
+			id: "anthropic:7d",
+			label: "Claude 7 Day",
+			windowId: "7d",
+			windowLabel: "7 Day",
+			durationMs: SEVEN_DAYS_MS,
+			bucket: sevenDay,
+			provider: "anthropic",
+			shared: true,
+		}),
+		buildUsageLimit({
+			id: "anthropic:7d:opus",
+			label: "Claude 7 Day (Opus)",
+			windowId: "7d",
+			windowLabel: "7 Day",
+			durationMs: SEVEN_DAYS_MS,
+			bucket: sevenDayOpus,
+			provider: "anthropic",
+			tier: "opus",
+		}),
+		buildUsageLimit({
+			id: "anthropic:7d:sonnet",
+			label: "Claude 7 Day (Sonnet)",
+			windowId: "7d",
+			windowLabel: "7 Day",
+			durationMs: SEVEN_DAYS_MS,
+			bucket: sevenDaySonnet,
+			provider: "anthropic",
+			tier: "sonnet",
+		}),
+	].filter((limit): limit is UsageLimit => limit !== null);
+
+	if (limits.length === 0) return null;
+	const identity = extractUsageIdentity(payload, orgId);
+	let accountId = identity.accountId ?? credential.accountId;
+	let email = identity.email ?? credential.email;
+	if ((!accountId || !email) && !params.signal?.aborted) {
+		const profileIdentity = extractProfileIdentity(await fetchProfile(baseUrl, headers, ctx, params.signal));
+		accountId = accountId ?? profileIdentity.accountId;
+		email = email ?? profileIdentity.email;
+	}
+
+	const report: UsageReport = {
+		provider: params.provider,
+		fetchedAt: Date.now(),
+		limits,
+		metadata: {
+			endpoint: url,
+			...(accountId ? { accountId } : {}),
+			...(email ? { email } : {}),
+			...(orgId ? { orgId } : {}),
+		},
+		raw: payload,
+	};
+
+	return report;
+}
+
+export const claudeUsageProvider: UsageProvider = {
+	id: "anthropic",
+	fetchUsage: fetchClaudeUsage,
+	supports: params => params.provider === "anthropic" && params.credential.type === "oauth",
+};
+
+export const claudeRankingStrategy: CredentialRankingStrategy = {
+	findWindowLimits(report) {
+		const primary = report.limits.find(l => l.id === "anthropic:5h");
+		const secondary = report.limits.find(l => l.id === "anthropic:7d");
+		return { primary, secondary };
+	},
+	windowDefaults: { primaryMs: 5 * 60 * 60 * 1000, secondaryMs: 7 * 24 * 60 * 60 * 1000 },
+};

package/src/usage/gemini.ts

@@ -0,0 +1,250 @@
+import { getGeminiCliHeaders } from "../providers/google-gemini-cli";
+import type {
+	UsageAmount,
+	UsageFetchContext,
+	UsageFetchParams,
+	UsageLimit,
+	UsageProvider,
+	UsageReport,
+	UsageWindow,
+} from "../usage";
+
+// (Refresh is the sole responsibility of AuthStorage; no provider-direct refresh here.)
+
+const DEFAULT_ENDPOINT = "https://cloudcode-pa.googleapis.com";
+
+const GEMINI_TIER_MAP: Array<{ tier: string; models: string[] }> = [
+	{
+		tier: "3-Flash",
+		models: ["gemini-3-flash-preview", "gemini-3-flash"],
+	},
+	{
+		tier: "Flash",
+		models: ["gemini-2.5-flash", "gemini-2.5-flash-lite", "gemini-2.0-flash", "gemini-1.5-flash"],
+	},
+	{
+		tier: "Pro",
+		models: ["gemini-2.5-pro", "gemini-3-pro-preview", "gemini-3.1-pro-preview", "gemini-3-pro", "gemini-1.5-pro"],
+	},
+];
+
+interface LoadCodeAssistResponse {
+	cloudaicompanionProject?: string | { id?: string };
+	currentTier?: { id?: string; name?: string };
+}
+
+interface RetrieveUserQuotaResponse {
+	buckets?: Array<{
+		modelId?: string;
+		remainingFraction?: number;
+		resetTime?: string;
+	}>;
+}
+
+function getProjectId(payload: LoadCodeAssistResponse | undefined): string | undefined {
+	if (!payload) return undefined;
+	if (typeof payload.cloudaicompanionProject === "string") {
+		return payload.cloudaicompanionProject;
+	}
+	if (payload.cloudaicompanionProject && typeof payload.cloudaicompanionProject === "object") {
+		return payload.cloudaicompanionProject.id;
+	}
+	return undefined;
+}
+
+function getModelTier(modelId: string): string | undefined {
+	for (const entry of GEMINI_TIER_MAP) {
+		if (entry.models.includes(modelId)) {
+			return entry.tier;
+		}
+	}
+	const normalized = modelId.toLowerCase();
+	if (normalized.includes("flash")) return "Flash";
+	if (normalized.includes("pro")) return "Pro";
+	return undefined;
+}
+
+function parseWindow(resetTime: string | undefined): UsageWindow {
+	if (!resetTime) {
+		return {
+			id: "quota",
+			label: "Quota window",
+		};
+	}
+	const resetsAt = Date.parse(resetTime);
+	if (Number.isNaN(resetsAt)) {
+		return {
+			id: "quota",
+			label: "Quota window",
+		};
+	}
+	return {
+		id: `reset-${resetsAt}`,
+		label: "Quota window",
+		resetsAt,
+	};
+}
+
+function buildAmount(remainingFraction: number | undefined): UsageAmount {
+	if (remainingFraction === undefined || !Number.isFinite(remainingFraction)) {
+		return { unit: "percent" };
+	}
+	const remaining = Math.min(Math.max(remainingFraction, 0), 1);
+	const used = Math.min(Math.max(1 - remaining, 0), 1);
+	return {
+		unit: "percent",
+		used: Math.round(used * 1000) / 10,
+		remaining: Math.round(remaining * 1000) / 10,
+		limit: 100,
+		usedFraction: used,
+		remainingFraction: remaining,
+	};
+}
+
+/**
+ * Return the OAuth access token to use against `/v1internal:*`. AuthStorage is
+ * the sole refresh authority (broker-aware, single-flighted, rotation-safe);
+ * if the token landed here expired or near-expired, the next usage cycle will
+ * carry a freshly-refreshed credential. Returning `undefined` short-circuits
+ * the probe rather than POSTing a stale token to Google.
+ */
+function resolveAccessToken(params: UsageFetchParams): string | undefined {
+	const { credential } = params;
+	if (credential.type !== "oauth") return undefined;
+	if (!credential.accessToken) return undefined;
+	if (credential.expiresAt !== undefined && credential.expiresAt <= Date.now()) {
+		return undefined;
+	}
+	return credential.accessToken;
+}
+
+async function loadCodeAssist(
+	params: UsageFetchParams,
+	ctx: UsageFetchContext,
+	accessToken: string,
+	baseUrl: string,
+	projectId?: string,
+): Promise<LoadCodeAssistResponse | undefined> {
+	const response = await ctx.fetch(`${baseUrl}/v1internal:loadCodeAssist`, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${accessToken}`,
+			"Content-Type": "application/json",
+			...getGeminiCliHeaders(),
+		},
+		body: JSON.stringify({
+			...(projectId ? { cloudaicompanionProject: projectId } : {}),
+			metadata: {
+				ideType: "IDE_UNSPECIFIED",
+				platform: "PLATFORM_UNSPECIFIED",
+				pluginType: "GEMINI",
+			},
+		}),
+		signal: params.signal,
+	});
+
+	if (!response.ok) {
+		const errorText = await response.text();
+		ctx.logger?.warn("Gemini CLI loadCodeAssist failed", {
+			status: response.status,
+			error: errorText,
+		});
+		return undefined;
+	}
+
+	return (await response.json()) as LoadCodeAssistResponse;
+}
+
+async function fetchQuota(
+	params: UsageFetchParams,
+	ctx: UsageFetchContext,
+	accessToken: string,
+	baseUrl: string,
+	projectId?: string,
+): Promise<RetrieveUserQuotaResponse | undefined> {
+	const response = await ctx.fetch(`${baseUrl}/v1internal:retrieveUserQuota`, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${accessToken}`,
+			"Content-Type": "application/json",
+			...getGeminiCliHeaders(),
+		},
+		body: JSON.stringify(projectId ? { project: projectId } : {}),
+		signal: params.signal,
+	});
+
+	if (!response.ok) {
+		const errorText = await response.text();
+		ctx.logger?.warn("Gemini CLI retrieveUserQuota failed", {
+			status: response.status,
+			error: errorText,
+		});
+		return undefined;
+	}
+
+	return (await response.json()) as RetrieveUserQuotaResponse;
+}
+
+export const googleGeminiCliUsageProvider: UsageProvider = {
+	id: "google-gemini-cli",
+	supports: ({ credential }) => credential.type === "oauth" && !!credential.accessToken,
+	async fetchUsage(params, ctx) {
+		const { credential } = params;
+		if (credential.type !== "oauth") {
+			return null;
+		}
+		const accessToken = resolveAccessToken(params);
+		if (!accessToken) {
+			return null;
+		}
+
+		const baseUrl = (params.baseUrl?.trim() || DEFAULT_ENDPOINT).replace(/\/$/, "");
+
+		const loadResponse = await loadCodeAssist(params, ctx, accessToken, baseUrl, credential.projectId);
+		const projectId = credential.projectId ?? getProjectId(loadResponse);
+		const quotaResponse = await fetchQuota(params, ctx, accessToken, baseUrl, projectId);
+		if (!quotaResponse) {
+			return null;
+		}
+
+		const limits: UsageLimit[] = [];
+		const buckets = quotaResponse.buckets ?? [];
+
+		buckets.forEach((bucket, index) => {
+			const modelId = bucket.modelId;
+			const window = parseWindow(bucket.resetTime);
+			const amount = buildAmount(bucket.remainingFraction);
+			const tier = modelId ? getModelTier(modelId) : undefined;
+			const label = modelId ? `Gemini ${modelId}` : "Gemini quota";
+			const id = `${modelId ?? "unknown"}:${window?.id ?? index}`;
+
+			limits.push({
+				id,
+				label,
+				scope: {
+					provider: params.provider,
+					accountId: credential.accountId,
+					projectId,
+					modelId,
+					tier,
+					windowId: window?.id,
+				},
+				window,
+				amount,
+			});
+		});
+
+		const report: UsageReport = {
+			provider: params.provider,
+			fetchedAt: Date.now(),
+			limits,
+			metadata: {
+				currentTierId: loadResponse?.currentTier?.id,
+				currentTierName: loadResponse?.currentTier?.name,
+			},
+			raw: quotaResponse,
+		};
+
+		return report;
+	},
+};