@f5-sales-demo/pi-ai 19.51.2

package/src/usage/kimi.ts

@@ -0,0 +1,286 @@
+import { $env } from "@f5xc-salesdemos/pi-utils";
+import type {
+	UsageAmount,
+	UsageFetchContext,
+	UsageFetchParams,
+	UsageLimit,
+	UsageProvider,
+	UsageReport,
+	UsageStatus,
+	UsageWindow,
+} from "../usage";
+import { isRecord } from "../utils";
+import { getKimiCommonHeaders, refreshKimiToken } from "../utils/oauth/kimi";
+
+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;
+};
+
+const toNumber = (value: unknown): number | undefined => {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (!trimmed) return undefined;
+		const parsed = Number(trimmed);
+		if (Number.isFinite(parsed)) return parsed;
+	}
+	return undefined;
+};
+
+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;
+
+		let accessToken = credential.accessToken;
+		if (!accessToken) return null;
+
+		const nowMs = Date.now();
+		if (credential.expiresAt !== undefined && credential.expiresAt <= nowMs) {
+			if (!credential.refreshToken) {
+				ctx.logger?.warn("Kimi usage token expired, no refresh token", { provider: params.provider });
+				return null;
+			}
+			try {
+				ctx.logger?.debug("Kimi usage token expired, refreshing", { provider: params.provider });
+				const refreshed = await refreshKimiToken(credential.refreshToken);
+				accessToken = refreshed.access;
+			} catch (error) {
+				ctx.logger?.warn("Kimi usage token refresh failed", { provider: params.provider, error: String(error) });
+				return null;
+			}
+		}
+
+		const baseUrl = normalizeBaseUrl(params.baseUrl);
+		const url = buildUsageUrl(baseUrl);
+		let payload: unknown;
+		try {
+			const response = await ctx.fetch(url, {
+				headers: {
+					...(await 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",
+};

package/src/usage/openai-codex.ts

@@ -0,0 +1,387 @@
+import { Buffer } from "node:buffer";
+import { CODEX_BASE_URL } from "../providers/openai-codex/constants";
+import type {
+	CredentialRankingStrategy,
+	UsageAmount,
+	UsageFetchContext,
+	UsageFetchParams,
+	UsageLimit,
+	UsageProvider,
+	UsageReport,
+	UsageWindow,
+} from "../usage";
+import { isRecord } from "../utils";
+
+const CODEX_USAGE_PATH = "wham/usage";
+const JWT_AUTH_CLAIM = "https://api.openai.com/auth";
+const JWT_PROFILE_CLAIM = "https://api.openai.com/profile";
+
+interface CodexUsageWindowPayload {
+	used_percent?: number;
+	limit_window_seconds?: number;
+	reset_after_seconds?: number;
+	reset_at?: number;
+}
+
+interface CodexUsageRateLimitPayload {
+	allowed?: boolean;
+	limit_reached?: boolean;
+	primary_window?: CodexUsageWindowPayload | null;
+	secondary_window?: CodexUsageWindowPayload | null;
+}
+
+interface CodexUsagePayload {
+	plan_type?: string;
+	rate_limit?: CodexUsageRateLimitPayload | null;
+}
+
+interface ParsedUsageWindow {
+	usedPercent?: number;
+	limitWindowSeconds?: number;
+	resetAfterSeconds?: number;
+	resetAt?: number;
+}
+
+interface ParsedUsage {
+	planType?: string;
+	allowed?: boolean;
+	limitReached?: boolean;
+	primary?: ParsedUsageWindow;
+	secondary?: ParsedUsageWindow;
+	raw: CodexUsagePayload;
+}
+
+interface JwtPayload {
+	[JWT_AUTH_CLAIM]?: {
+		chatgpt_account_id?: string;
+	};
+	[JWT_PROFILE_CLAIM]?: {
+		email?: string;
+	};
+}
+
+const toNumber = (value: unknown): number | undefined => {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (!trimmed) return undefined;
+		const parsed = Number(trimmed);
+		if (Number.isFinite(parsed)) return parsed;
+	}
+	return undefined;
+};
+
+const toBoolean = (value: unknown): boolean | undefined => {
+	if (typeof value === "boolean") return value;
+	return undefined;
+};
+
+function base64UrlDecode(input: string): string {
+	const base64 = input.replace(/-/g, "+").replace(/_/g, "/");
+	const padLen = (4 - (base64.length % 4)) % 4;
+	const padded = base64 + "=".repeat(padLen);
+	return Buffer.from(padded, "base64").toString("utf8");
+}
+
+function parseJwt(token: string): JwtPayload | null {
+	const parts = token.split(".");
+	if (parts.length !== 3) return null;
+	try {
+		const payloadJson = base64UrlDecode(parts[1]);
+		return JSON.parse(payloadJson) as JwtPayload;
+	} catch {
+		return null;
+	}
+}
+
+function normalizeEmail(email: string | undefined): string | undefined {
+	if (!email) return undefined;
+	const normalized = email.trim().toLowerCase();
+	return normalized || undefined;
+}
+
+function extractAccountId(token: string | undefined): string | undefined {
+	if (!token) return undefined;
+	const payload = parseJwt(token);
+	return payload?.[JWT_AUTH_CLAIM]?.chatgpt_account_id ?? undefined;
+}
+
+function extractEmail(token: string | undefined): string | undefined {
+	if (!token) return undefined;
+	const payload = parseJwt(token);
+	return normalizeEmail(payload?.[JWT_PROFILE_CLAIM]?.email);
+}
+
+function parseUsageWindow(payload: unknown): ParsedUsageWindow | undefined {
+	if (!isRecord(payload)) return undefined;
+	const usedPercent = toNumber(payload.used_percent);
+	const limitWindowSeconds = toNumber(payload.limit_window_seconds);
+	const resetAfterSeconds = toNumber(payload.reset_after_seconds);
+	const resetAt = toNumber(payload.reset_at);
+	if (
+		usedPercent === undefined &&
+		limitWindowSeconds === undefined &&
+		resetAfterSeconds === undefined &&
+		resetAt === undefined
+	) {
+		return undefined;
+	}
+	return {
+		usedPercent,
+		limitWindowSeconds,
+		resetAfterSeconds,
+		resetAt,
+	};
+}
+
+function parseUsagePayload(payload: unknown): ParsedUsage | null {
+	if (!isRecord(payload)) return null;
+	const planType = typeof payload.plan_type === "string" ? payload.plan_type : undefined;
+	const rateLimit = isRecord(payload.rate_limit) ? payload.rate_limit : undefined;
+	if (!rateLimit) return null;
+	const parsed: ParsedUsage = {
+		planType,
+		allowed: toBoolean(rateLimit.allowed),
+		limitReached: toBoolean(rateLimit.limit_reached),
+		primary: parseUsageWindow(rateLimit.primary_window),
+		secondary: parseUsageWindow(rateLimit.secondary_window),
+		raw: payload as CodexUsagePayload,
+	};
+	if (!parsed.primary && !parsed.secondary && parsed.allowed === undefined && parsed.limitReached === undefined) {
+		return null;
+	}
+	return parsed;
+}
+
+function normalizeCodexBaseUrl(baseUrl?: string): string {
+	const fallback = CODEX_BASE_URL;
+	const trimmed = baseUrl?.trim() ? baseUrl.trim() : fallback;
+	const base = trimmed.replace(/\/+$/, "");
+	const lower = base.toLowerCase();
+	if (
+		(lower.startsWith("https://chatgpt.com") || lower.startsWith("https://chat.openai.com")) &&
+		!lower.includes("/backend-api")
+	) {
+		return `${base}/backend-api`;
+	}
+	return base;
+}
+
+function buildCodexUsageUrl(baseUrl: string): string {
+	const normalized = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+	return `${normalized}${CODEX_USAGE_PATH}`;
+}
+
+function formatWindowLabel(value: number, unit: "hour" | "day"): string {
+	const rounded = Math.round(value);
+	const suffix = rounded === 1 ? unit : `${unit}s`;
+	return `${rounded} ${suffix}`;
+}
+
+function buildWindowLabel(seconds: number): { id: string; label: string } {
+	const daySeconds = 86_400;
+	if (seconds >= daySeconds) {
+		const days = Math.round(seconds / daySeconds);
+		return { id: `${days}d`, label: formatWindowLabel(days, "day") };
+	}
+	const hours = Math.max(1, Math.round(seconds / 3600));
+	return { id: `${hours}h`, label: formatWindowLabel(hours, "hour") };
+}
+
+function resolveResetTime(window: ParsedUsageWindow, nowMs: number): number | undefined {
+	const resetAt = window.resetAt;
+	if (resetAt !== undefined) {
+		const resetAtMs = resetAt > 1_000_000_000_000 ? resetAt : resetAt * 1000;
+		if (Number.isFinite(resetAtMs)) return resetAtMs;
+	}
+	if (window.resetAfterSeconds !== undefined) {
+		return nowMs + window.resetAfterSeconds * 1000;
+	}
+	return undefined;
+}
+
+function buildUsageWindow(window: ParsedUsageWindow, key: string, nowMs: number): UsageWindow {
+	const resetsAt = resolveResetTime(window, nowMs);
+	if (window.limitWindowSeconds !== undefined) {
+		const { id, label } = buildWindowLabel(window.limitWindowSeconds);
+		const durationMs = window.limitWindowSeconds * 1000;
+		return { id, label, durationMs, ...(resetsAt !== undefined ? { resetsAt } : {}) };
+	}
+	const fallbackLabel = key === "primary" ? "Primary window" : "Secondary window";
+	return { id: key, label: fallbackLabel, ...(resetsAt !== undefined ? { resetsAt } : {}) };
+}
+
+function buildUsageAmount(window: ParsedUsageWindow): UsageAmount {
+	const usedPercent = window.usedPercent;
+	if (usedPercent === undefined) {
+		return { unit: "percent" };
+	}
+	const clamped = Math.min(Math.max(usedPercent, 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, limitReached?: boolean): UsageLimit["status"] {
+	if (limitReached) return "exhausted";
+	if (usedFraction === undefined) return "unknown";
+	if (usedFraction >= 1) return "exhausted";
+	if (usedFraction >= 0.9) return "warning";
+	return "ok";
+}
+
+function buildUsageLimit(args: {
+	key: "primary" | "secondary";
+	window: ParsedUsageWindow;
+	accountId?: string;
+	planType?: string;
+	limitReached?: boolean;
+	nowMs: number;
+}): UsageLimit {
+	const usageWindow = buildUsageWindow(args.window, args.key, args.nowMs);
+	const amount = buildUsageAmount(args.window);
+	return {
+		id: `openai-codex:${args.key}`,
+		label: usageWindow.label,
+		scope: {
+			provider: "openai-codex",
+			accountId: args.accountId,
+			tier: args.planType,
+			windowId: usageWindow.id,
+			shared: true,
+		},
+		window: usageWindow,
+		amount,
+		status: buildUsageStatus(amount.usedFraction, args.limitReached),
+	};
+}
+
+export const openaiCodexUsageProvider: UsageProvider = {
+	id: "openai-codex",
+	supports(params: UsageFetchParams): boolean {
+		return params.provider === "openai-codex" && params.credential.type === "oauth";
+	},
+	async fetchUsage(params: UsageFetchParams, ctx: UsageFetchContext): Promise<UsageReport | null> {
+		if (params.provider !== "openai-codex") return null;
+		const { credential } = params;
+		if (credential.type !== "oauth") return null;
+
+		const accessToken = credential.accessToken;
+		if (!accessToken) return null;
+
+		const nowMs = Date.now();
+		if (credential.expiresAt !== undefined && credential.expiresAt <= nowMs) {
+			ctx.logger?.warn("Codex usage token expired", { provider: params.provider });
+			return null;
+		}
+
+		const baseUrl = normalizeCodexBaseUrl(params.baseUrl);
+		const accountId = credential.accountId ?? extractAccountId(accessToken);
+		const email = normalizeEmail(credential.email ?? extractEmail(accessToken));
+
+		const headers: Record<string, string> = {
+			Authorization: `Bearer ${accessToken}`,
+			"User-Agent": "OpenCode-Status-Plugin/1.0",
+		};
+		if (accountId) {
+			headers["ChatGPT-Account-Id"] = accountId;
+		}
+
+		const url = buildCodexUsageUrl(baseUrl);
+		let payload: unknown;
+		try {
+			const response = await ctx.fetch(url, { headers, signal: params.signal });
+			if (!response.ok) {
+				ctx.logger?.warn("Codex usage request failed", { status: response.status, provider: params.provider });
+				return null;
+			}
+			payload = await response.json();
+		} catch (error) {
+			ctx.logger?.warn("Codex usage request error", { provider: params.provider, error: String(error) });
+			return null;
+		}
+
+		const parsed = parseUsagePayload(payload);
+		const planType =
+			parsed?.planType ??
+			(isRecord(payload) && typeof payload.plan_type === "string" ? payload.plan_type : undefined);
+
+		const limits: UsageLimit[] = [];
+		if (parsed?.primary) {
+			limits.push(
+				buildUsageLimit({
+					key: "primary",
+					window: parsed.primary,
+					accountId,
+					planType,
+					limitReached: parsed.limitReached,
+					nowMs,
+				}),
+			);
+		}
+		if (parsed?.secondary) {
+			limits.push(
+				buildUsageLimit({
+					key: "secondary",
+					window: parsed.secondary,
+					accountId,
+					planType,
+					limitReached: parsed.limitReached,
+					nowMs,
+				}),
+			);
+		}
+
+		const report: UsageReport = {
+			provider: "openai-codex",
+			fetchedAt: nowMs,
+			limits,
+			metadata: {
+				planType,
+				allowed: parsed?.allowed,
+				limitReached: parsed?.limitReached,
+				email,
+				accountId,
+			},
+			raw: parsed?.raw ?? payload,
+		};
+
+		return report;
+	},
+};
+
+const FIVE_HOUR_MS = 5 * 60 * 60 * 1000;
+
+export const codexRankingStrategy: CredentialRankingStrategy = {
+	findWindowLimits(report) {
+		const findLimit = (key: "primary" | "secondary"): UsageLimit | undefined => {
+			const direct = report.limits.find(l => l.id === `openai-codex:${key}`);
+			if (direct) return direct;
+			const byId = report.limits.find(l => l.id.toLowerCase().includes(key));
+			if (byId) return byId;
+			const windowId = key === "secondary" ? "7d" : "1h";
+			return report.limits.find(l => l.scope.windowId?.toLowerCase() === windowId);
+		};
+		return { primary: findLimit("primary"), secondary: findLimit("secondary") };
+	},
+	windowDefaults: { primaryMs: 60 * 60 * 1000, secondaryMs: 7 * 24 * 60 * 60 * 1000 },
+	hasPriorityBoost(primary) {
+		if (!primary) return false;
+		const windowId = primary.scope.windowId?.toLowerCase();
+		const durationMs = primary.window?.durationMs;
+		const isFiveHourWindow =
+			windowId === "5h" ||
+			(typeof durationMs === "number" &&
+				Number.isFinite(durationMs) &&
+				Math.abs(durationMs - FIVE_HOUR_MS) <= 60_000);
+		if (!isFiveHourWindow) return false;
+		const usedFraction = primary.amount.usedFraction;
+		return typeof usedFraction === "number" && Number.isFinite(usedFraction) && usedFraction === 0;
+	},
+};