@oh-my-pi/pi-ai 18.4.2 → 18.4.4

package/src/usage/commandcode.ts

@@ -0,0 +1,209 @@
+import { ProviderHttpError } from "../error";
+import type {
+	CredentialRankingStrategy,
+	UsageFetchContext,
+	UsageFetchParams,
+	UsageLimit,
+	UsageProvider,
+	UsageReport,
+} from "../usage";
+import { isRecord } from "../utils";
+import { HOUR_MS, parsePositiveTimestamp, usageStatus, WEEK_MS } from "./shared";
+
+const PROVIDER = "commandcode";
+const DEFAULT_ORIGIN = "https://api.commandcode.ai";
+// The CLI also sends `?limits=1` for its org spend-limit panel; omp reads no
+// field from that, so the plain identity route is enough.
+const WHOAMI_PATH = "/alpha/whoami";
+const CREDITS_PATH = "/alpha/billing/credits";
+
+/**
+ * Command Code's inference base carries `/provider` or `/provider/v1`, while the
+ * account routes sit at the host root, so only the configured origin is kept.
+ * A blank or unparseable override means "not configured".
+ */
+function resolveOrigin(baseUrl: string | undefined): string {
+	const trimmed = baseUrl?.trim();
+	if (!trimmed) return DEFAULT_ORIGIN;
+	try {
+		return new URL(trimmed).origin;
+	} catch {
+		return DEFAULT_ORIGIN;
+	}
+}
+
+function nonEmptyString(value: unknown): string | undefined {
+	return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function finiteNumber(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+/**
+ * Returns the unwrapped JSON body, or `null` for any failure that should read
+ * as "no data", 403 included. Only a 401 throws, so a revoked key purges the
+ * cached report instead of re-serving it.
+ */
+async function getJson(
+	url: string,
+	apiKey: string,
+	signal: AbortSignal | undefined,
+	ctx: UsageFetchContext,
+): Promise<Record<string, unknown> | null> {
+	try {
+		const response = await ctx.fetch(url, {
+			headers: {
+				Authorization: `Bearer ${apiKey}`,
+				Accept: "application/json",
+			},
+			signal,
+		});
+		if (!response.ok) {
+			if (response.status === 401) {
+				throw new ProviderHttpError(
+					`Command Code usage endpoint returned ${response.status} ${response.statusText}`.trim(),
+					response.status,
+				);
+			}
+			ctx.logger?.warn("Command Code usage fetch failed", {
+				url,
+				status: response.status,
+				statusText: response.statusText,
+			});
+			return null;
+		}
+		const json: unknown = await response.json();
+		if (!isRecord(json)) return null;
+		return isRecord(json.data) ? json.data : json;
+	} catch (error) {
+		if (error instanceof ProviderHttpError) throw error;
+		ctx.logger?.warn("Command Code usage fetch error", { url, error: String(error) });
+		return null;
+	}
+}
+
+interface WindowSpec {
+	key: "fiveHour" | "weekly";
+	id: "5h" | "7d";
+	limitLabel: string;
+	windowLabel: string;
+	durationMs: number;
+}
+
+const WINDOWS: readonly WindowSpec[] = [
+	{ key: "fiveHour", id: "5h", limitLabel: "5-hour limit", windowLabel: "5-hour", durationMs: 5 * HOUR_MS },
+	{ key: "weekly", id: "7d", limitLabel: "Weekly limit", windowLabel: "Weekly", durationMs: WEEK_MS },
+];
+
+function buildWindowLimit(
+	spec: WindowSpec,
+	raw: unknown,
+	accountId: string,
+	orgId: string | undefined,
+): UsageLimit | undefined {
+	if (!isRecord(raw)) return undefined;
+	const used = finiteNumber(raw.used);
+	if (used === undefined) return undefined;
+	const cap = finiteNumber(raw.cap);
+	const usedFraction = cap !== undefined && cap > 0 ? used / cap : undefined;
+	const resetsAt = parsePositiveTimestamp(raw.resetAt);
+	// Absent fields are omitted, not set to `undefined`: the usage wire schema
+	// rejects an explicit `undefined` for an optional key.
+	return {
+		id: `${PROVIDER}:${spec.id}`,
+		label: spec.limitLabel,
+		scope: { provider: PROVIDER, accountId, ...(orgId ? { orgId } : {}), windowId: spec.id, shared: true },
+		window: {
+			id: spec.id,
+			label: spec.windowLabel,
+			durationMs: spec.durationMs,
+			...(resetsAt !== undefined ? { resetsAt } : {}),
+		},
+		amount: {
+			used,
+			...(cap !== undefined ? { limit: cap } : {}),
+			...(usedFraction !== undefined ? { usedFraction } : {}),
+			unit: "credits",
+		},
+		status: raw.exceeded === true ? "exhausted" : usageStatus(usedFraction),
+	};
+}
+
+/**
+ * Reads the account routes that the Command Code CLI calls with the same API
+ * key; the Provider API documents no usage endpoint. Pay-as-you-go accounts
+ * carry no `windowLimits`, so they report only the credit balance. Credits
+ * are queried per org, as the CLI does, so each limit records the org that
+ * owns the pool alongside the user.
+ */
+async function fetchCommandCodeUsage(params: UsageFetchParams, ctx: UsageFetchContext): Promise<UsageReport | null> {
+	if (params.provider !== PROVIDER) return null;
+	if (params.credential.type !== "api_key" || !params.credential.apiKey) return null;
+	const origin = resolveOrigin(params.baseUrl);
+
+	const whoami = await getJson(`${origin}${WHOAMI_PATH}`, params.credential.apiKey, params.signal, ctx);
+	if (!whoami) return null;
+	const user = isRecord(whoami.user) ? whoami.user : undefined;
+	const org = isRecord(whoami.org) ? whoami.org : undefined;
+	const userId = nonEmptyString(user?.id);
+	if (!userId) return null;
+	const orgId = nonEmptyString(org?.id);
+	const orgLogin = nonEmptyString(org?.login);
+
+	const creditsUrl = `${origin}${CREDITS_PATH}${orgId ? `?orgId=${encodeURIComponent(orgId)}` : ""}`;
+	const creditsBody = await getJson(creditsUrl, params.credential.apiKey, params.signal, ctx);
+	if (!creditsBody) return null;
+	const credits = isRecord(creditsBody.credits) ? creditsBody.credits : undefined;
+	if (!credits) return null;
+	const monthly = finiteNumber(credits.monthlyCredits);
+	const purchased = finiteNumber(credits.purchasedCredits);
+	const free = finiteNumber(credits.freeCredits);
+	if (monthly === undefined && purchased === undefined && free === undefined) return null;
+
+	const limits: UsageLimit[] = [];
+	const windowLimits = isRecord(creditsBody.windowLimits) ? creditsBody.windowLimits : undefined;
+	for (const spec of WINDOWS) {
+		const limit = buildWindowLimit(spec, windowLimits?.[spec.key], userId, orgId);
+		if (limit) limits.push(limit);
+	}
+	limits.push({
+		id: `${PROVIDER}:balance`,
+		label: "Credit balance",
+		scope: { provider: PROVIDER, accountId: userId, ...(orgId ? { orgId } : {}), windowId: "balance", shared: true },
+		amount: { remaining: (monthly ?? 0) + (purchased ?? 0) + (free ?? 0), unit: "credits" },
+	});
+
+	return {
+		provider: PROVIDER,
+		fetchedAt: Date.now(),
+		limits,
+		metadata: {
+			accountId: userId,
+			email: nonEmptyString(user?.email),
+			orgId,
+			orgName: orgLogin,
+			planType: nonEmptyString(credits.planId),
+		},
+		raw: { whoami, credits: creditsBody },
+	};
+}
+
+export const commandCodeUsageProvider: UsageProvider = {
+	id: PROVIDER,
+	fetchUsage: fetchCommandCodeUsage,
+	supports: params => params.provider === PROVIDER && params.credential.type === "api_key",
+	validatesCredentials: true,
+};
+
+/** Ranks Command Code accounts by the 5-hour and weekly credit windows. */
+export const commandCodeRankingStrategy: CredentialRankingStrategy = {
+	findWindowLimits: report => ({
+		primary: report.limits.find(limit => limit.window?.id === "5h"),
+		secondary: report.limits.find(limit => limit.window?.id === "7d"),
+	}),
+	windowDefaults: {
+		primaryMs: 5 * HOUR_MS,
+		secondaryMs: WEEK_MS,
+	},
+};

package/src/usage/cursor.ts

@@ -478,10 +478,18 @@ export const cursorUsageProvider: UsageProvider = {
 		]);
 		let report: UsageReport | null;
 		if (legacyReport && summaryReport) {
+			// `/auth/usage` is Cursor's request-count API from before usage-based
+			// plans. Current plans answer it with an uncapped, always-zero `gpt-4`
+			// bucket; beside the summary's dollar rails an uncapped, unused bucket
+			// carries nothing, so it is dropped. Capped buckets and uncapped buckets
+			// with recorded requests stay. Without a summary it stays the fallback.
+			const legacyLimits = legacyReport.limits.filter(
+				limit => limit.amount.limit !== undefined || (limit.amount.used ?? 0) > 0,
+			);
 			report = {
 				provider: "cursor",
 				fetchedAt,
-				limits: [...legacyReport.limits, ...summaryReport.limits],
+				limits: [...legacyLimits, ...summaryReport.limits],
 				raw: {
 					authUsage: legacyReport.raw,
 					usageSummary: summaryReport.raw,

package/src/usage/openai-codex.ts

@@ -18,7 +18,7 @@ import type {
 import { isRecord } from "../utils";
 import { normalizeCodexBaseUrl } from "./openai-codex-base-url";
 import { listCodexResetCredits } from "./openai-codex-reset";
-import { HOUR_MS } from "./shared";
+import { HOUR_MS, usageStatus } from "./shared";
 
 const CODEX_USAGE_PATH = "wham/usage";
 const CODEX_VERIFIED_ACCESS_PATH = "accounts/verified_access";
@@ -341,10 +341,8 @@ function buildUsageAmount(window: ParsedUsageWindow): UsageAmount {
 }
 
 function buildUsageStatus(args: { usedFraction?: number; explicitlyAllowed: boolean }): UsageLimit["status"] {
-	if (args.usedFraction === undefined) return "unknown";
-	if (args.usedFraction >= 1) return args.explicitlyAllowed ? "warning" : "exhausted";
-	if (args.usedFraction >= 0.9) return "warning";
-	return "ok";
+	const status = usageStatus(args.usedFraction);
+	return status === "exhausted" && args.explicitlyAllowed ? "warning" : status;
 }
 
 /**

package/src/usage/registry.ts

@@ -4,6 +4,7 @@ import { alibabaTokenPlanRankingStrategy, alibabaTokenPlanUsageProvider } from "
 import { charmHyperUsageProvider } from "./charm-hyper";
 import { claudeRankingStrategy, claudeUsageProvider } from "./claude";
 import { clinePassUsageProvider } from "./cline-pass";
+import { commandCodeRankingStrategy, commandCodeUsageProvider } from "./commandcode";
 import { cursorRankingStrategy, cursorUsageProvider } from "./cursor";
 import { devinUsageProvider } from "./devin";
 import { googleGeminiCliUsageProvider } from "./gemini";
@@ -45,6 +46,7 @@ export const DEFAULT_USAGE_PROVIDERS: readonly UsageProvider[] = [
 	xaiOauthUsageProvider,
 	devinUsageProvider,
 	charmHyperUsageProvider,
+	commandCodeUsageProvider,
 ];
 
 const DEFAULT_USAGE_PROVIDER_MAP = new Map<Provider, UsageProvider>(
@@ -66,6 +68,7 @@ const DEFAULT_RANKING_STRATEGIES = new Map<Provider, CredentialRankingStrategy>(
 	["zai", zaiRankingStrategy],
 	["opencode-go", opencodeGoRankingStrategy],
 	["xai-oauth", xaiOauthRankingStrategy],
+	["commandcode", commandCodeRankingStrategy],
 ]);
 
 /** Built-in ranking strategy for `provider`. */

package/src/usage/shared.ts

@@ -1,5 +1,5 @@
 import { toNumber } from "@oh-my-pi/pi-catalog/utils";
-import type { UsageStatus } from "../usage";
+import type { UsageAmount, UsageStatus } from "../usage";
 
 /** Milliseconds in one hour. */
 export const HOUR_MS = 60 * 60 * 1000;
@@ -31,3 +31,30 @@ export function usageStatus(usedFraction: number | undefined): UsageStatus {
 	if (usedFraction >= 0.9) return "warning";
 	return "ok";
 }
+
+/**
+ * Builds an amount from absolute counters. Without an authoritative
+ * `usedFraction`, it derives one from `used / limit` (capped at 1).
+ * Undefined fields are omitted rather than emitted as `undefined` keys.
+ */
+export function buildUsageAmount(args: {
+	used: number | undefined;
+	limit: number | undefined;
+	remaining: number | undefined;
+	usedFraction?: number;
+	unit: UsageAmount["unit"];
+}): UsageAmount {
+	let usedFraction = args.usedFraction;
+	if (usedFraction === undefined && args.used !== undefined && args.limit !== undefined && args.limit > 0) {
+		usedFraction = Math.min(args.used / args.limit, 1);
+	}
+	const remainingFraction = usedFraction !== undefined ? Math.max(1 - usedFraction, 0) : undefined;
+	return {
+		...(args.used !== undefined ? { used: args.used } : {}),
+		...(args.limit !== undefined ? { limit: args.limit } : {}),
+		...(args.remaining !== undefined ? { remaining: args.remaining } : {}),
+		...(usedFraction !== undefined ? { usedFraction } : {}),
+		...(remainingFraction !== undefined ? { remainingFraction } : {}),
+		unit: args.unit,
+	};
+}

package/src/usage/synthetic.ts

@@ -1,6 +1,5 @@
 import { isRecord } from "@oh-my-pi/pi-utils/type-guards";
 import type {
-	UsageAmount,
 	UsageFetchContext,
 	UsageFetchParams,
 	UsageLimit,
@@ -9,7 +8,7 @@ import type {
 	UsageStatus,
 	UsageWindow,
 } from "../usage";
-import { HOUR_MS, parseIsoTimestamp, WEEK_MS } from "./shared";
+import { buildUsageAmount, HOUR_MS, parseIsoTimestamp, usageStatus, WEEK_MS } from "./shared";
 
 const QUOTAS_URL = "https://api.synthetic.new/v2/quotas";
 
@@ -20,35 +19,6 @@ function parseDollarAmount(value: unknown): number | undefined {
 	return Number.isFinite(parsed) ? parsed : undefined;
 }
 
-function buildUsageAmount(args: {
-	used: number | undefined;
-	limit: number | undefined;
-	remaining: number | undefined;
-	usedFraction: number | undefined;
-	unit: UsageAmount["unit"];
-}): UsageAmount {
-	let usedFraction = args.usedFraction;
-	if (usedFraction === undefined && args.used !== undefined && args.limit !== undefined && args.limit > 0) {
-		usedFraction = Math.min(args.used / args.limit, 1);
-	}
-	const remainingFraction = usedFraction !== undefined ? Math.max(1 - usedFraction, 0) : undefined;
-	return {
-		...(args.used !== undefined ? { used: args.used } : {}),
-		...(args.limit !== undefined ? { limit: args.limit } : {}),
-		...(args.remaining !== undefined ? { remaining: args.remaining } : {}),
-		...(usedFraction !== undefined ? { usedFraction } : {}),
-		...(remainingFraction !== undefined ? { remainingFraction } : {}),
-		unit: args.unit,
-	};
-}
-
-function getUsageStatus(usedFraction: number | undefined): UsageStatus | undefined {
-	if (usedFraction === undefined) return undefined;
-	if (usedFraction >= 1) return "exhausted";
-	if (usedFraction >= 0.9) return "warning";
-	return "ok";
-}
-
 function parseRollingFiveHourLimit(raw: unknown, provider: UsageFetchParams["provider"]): UsageLimit | null {
 	if (!isRecord(raw)) return null;
 	const remaining = typeof raw.remaining === "number" ? raw.remaining : undefined;
@@ -67,14 +37,8 @@ function parseRollingFiveHourLimit(raw: unknown, provider: UsageFetchParams["pro
 		durationMs: 5 * HOUR_MS,
 		...(nextTickAt !== undefined ? { resetsAt: nextTickAt, resetLabel: "tick" } : {}),
 	};
-	const amount = buildUsageAmount({
-		used,
-		limit: max,
-		remaining,
-		usedFraction: undefined,
-		unit: "requests",
-	});
-	const status: UsageStatus = limited ? "exhausted" : (getUsageStatus(amount.usedFraction) ?? "ok");
+	const amount = buildUsageAmount({ used, limit: max, remaining, unit: "requests" });
+	const status: UsageStatus = limited ? "exhausted" : usageStatus(amount.usedFraction ?? 0);
 	return {
 		id: "synthetic:requests:5h",
 		label: "Synthetic Requests",
@@ -117,7 +81,7 @@ function parseWeeklyTokenLimit(raw: unknown, provider: UsageFetchParams["provide
 		scope: { provider, windowId: "7d", shared: true },
 		window,
 		amount,
-		status: getUsageStatus(amount.usedFraction),
+		status: amount.usedFraction === undefined ? undefined : usageStatus(amount.usedFraction),
 	};
 }
 

package/src/usage/umans.ts

@@ -1,6 +1,5 @@
 import { ProviderHttpError } from "../error";
 import type {
-	UsageAmount,
 	UsageFetchContext,
 	UsageFetchParams,
 	UsageLimit,
@@ -10,7 +9,7 @@ import type {
 	UsageWindow,
 } from "../usage";
 import { isRecord } from "../utils";
-import { HOUR_MS } from "./shared";
+import { buildUsageAmount, HOUR_MS, usageStatus } from "./shared";
 
 const UMANS_PROVIDER = "umans";
 const DEFAULT_ENDPOINT = "https://api.code.umans.ai";
@@ -53,13 +52,6 @@ function toFiniteNumber(value: unknown): number | undefined {
 	return value;
 }
 
-function resolveStatus(usedFraction: number | undefined): UsageStatus | undefined {
-	if (usedFraction === undefined) return undefined;
-	if (usedFraction >= 1) return "exhausted";
-	if (usedFraction >= 0.9) return "warning";
-	return "ok";
-}
-
 /**
  * Soft-cap status never reaches `exhausted`: hitting the effective-request
  * limit only means burst headroom is being consumed — Umans throttles (429)
@@ -72,26 +64,6 @@ function softCapStatus(usedFraction: number | undefined): UsageStatus | undefine
 	return "ok";
 }
 
-function buildAmount(args: {
-	used: number | undefined;
-	limit: number | undefined;
-	remaining: number | undefined;
-	unit: UsageAmount["unit"];
-}): UsageAmount {
-	const used = args.used;
-	const limit = args.limit;
-	const usedFraction = used !== undefined && limit !== undefined && limit > 0 ? Math.min(used / limit, 1) : undefined;
-	const remainingFraction = usedFraction !== undefined ? Math.max(1 - usedFraction, 0) : undefined;
-	return {
-		used,
-		limit,
-		remaining: args.remaining,
-		usedFraction,
-		remainingFraction,
-		unit: args.unit,
-	};
-}
-
 function buildRequestsLimits(payload: UmansUsagePayload, provider: string): UsageLimit[] {
 	const limit = toFiniteNumber(payload.limits?.requests?.limit);
 	const hardCap = toFiniteNumber(payload.limits?.requests?.hard_cap);
@@ -127,7 +99,7 @@ function buildRequestsLimits(payload: UmansUsagePayload, provider: string): Usag
 	// limit still never drives exhaustion on its own: weighted headroom stays
 	// decisive (https://github.com/can1357/oh-my-pi/issues/7858).
 	if (weightedUsed === undefined || hardCap === undefined) {
-		const amount = buildAmount({
+		const amount = buildUsageAmount({
 			used: weightedUsed ?? rawUsed,
 			limit,
 			remaining: weightedUsed !== undefined ? weightedRemaining : rawRemaining,
@@ -140,7 +112,7 @@ function buildRequestsLimits(payload: UmansUsagePayload, provider: string): Usag
 				scope: { provider, windowId: window.id, shared: true },
 				window,
 				amount,
-				status: resolveStatus(amount.usedFraction),
+				status: amount.usedFraction === undefined ? undefined : usageStatus(amount.usedFraction),
 			},
 		];
 	}
@@ -151,7 +123,7 @@ function buildRequestsLimits(payload: UmansUsagePayload, provider: string): Usag
 	// read as exhausted mid-window while the account still has weighted
 	// headroom (https://github.com/can1357/oh-my-pi/issues/7858). Soft cap hits
 	// warn; only the burst ceiling (`hard_cap`, raw counts) can exhaust.
-	const softAmount = buildAmount({ used: weightedUsed, limit, remaining: weightedRemaining, unit: "requests" });
+	const softAmount = buildUsageAmount({ used: weightedUsed, limit, remaining: weightedRemaining, unit: "requests" });
 	const limits: UsageLimit[] = [
 		{
 			id: "umans:requests:soft",
@@ -163,14 +135,14 @@ function buildRequestsLimits(payload: UmansUsagePayload, provider: string): Usag
 		},
 	];
 	if (hardCap !== undefined && rawUsed !== undefined) {
-		const hardAmount = buildAmount({ used: rawUsed, limit: hardCap, remaining: undefined, unit: "requests" });
+		const hardAmount = buildUsageAmount({ used: rawUsed, limit: hardCap, remaining: undefined, unit: "requests" });
 		limits.push({
 			id: "umans:requests:hard",
 			label: "Requests (burst ceiling)",
 			scope: { provider, windowId: window.id, shared: true },
 			window,
 			amount: hardAmount,
-			status: resolveStatus(hardAmount.usedFraction),
+			status: hardAmount.usedFraction === undefined ? undefined : usageStatus(hardAmount.usedFraction),
 		});
 	}
 	return limits;
@@ -180,14 +152,14 @@ function buildConcurrencyLimit(payload: UmansUsagePayload, provider: string): Us
 	const limit = toFiniteNumber(payload.limits?.concurrency?.limit);
 	const used = toFiniteNumber(payload.usage?.concurrent_sessions);
 	if (limit === undefined && used === undefined) return null;
-	const amount = buildAmount({ used, limit, remaining: undefined, unit: "requests" });
+	const amount = buildUsageAmount({ used, limit, remaining: undefined, unit: "requests" });
 	return {
 		id: "umans:concurrency",
 		label: "Concurrency",
 		// Concurrency is instantaneous, not windowed.
 		scope: { provider, windowId: "concurrency" },
 		amount,
-		status: resolveStatus(amount.usedFraction),
+		status: amount.usedFraction === undefined ? undefined : usageStatus(amount.usedFraction),
 	};
 }
 

package/src/usage/zai.ts

@@ -2,17 +2,15 @@ import { toNumber } from "@oh-my-pi/pi-catalog/utils";
 import { USER_AGENT } from "@oh-my-pi/pi-utils";
 import type {
 	CredentialRankingStrategy,
-	UsageAmount,
 	UsageFetchContext,
 	UsageFetchParams,
 	UsageLimit,
 	UsageProvider,
 	UsageReport,
-	UsageStatus,
 	UsageWindow,
 } from "../usage";
 import { isRecord } from "../utils";
-import { DAY_MS, HOUR_MS, WEEK_MS } from "./shared";
+import { buildUsageAmount, DAY_MS, HOUR_MS, usageStatus, WEEK_MS } from "./shared";
 
 const DEFAULT_ENDPOINT = "https://api.z.ai";
 const QUOTA_PATH = "/api/monitor/usage/quota/limit";
@@ -94,35 +92,9 @@ function parseLimitItem(value: unknown): ZaiUsageLimitItem | null {
 	};
 }
 
-function buildUsageAmount(args: {
-	used: number | undefined;
-	limit: number | undefined;
-	remaining: number | undefined;
-	unit: UsageAmount["unit"];
-	percentage?: number;
-}): UsageAmount {
-	const usedFraction =
-		args.percentage !== undefined
-			? Math.min(Math.max(args.percentage / 100, 0), 1)
-			: args.used !== undefined && args.limit !== undefined && args.limit > 0
-				? Math.min(args.used / args.limit, 1)
-				: undefined;
-	const remainingFraction = usedFraction !== undefined ? Math.max(1 - usedFraction, 0) : undefined;
-	return {
-		used: args.used,
-		limit: args.limit,
-		remaining: args.remaining,
-		usedFraction,
-		remainingFraction,
-		unit: args.unit,
-	};
-}
-
-function getUsageStatus(usedFraction: number | undefined): UsageStatus | undefined {
-	if (usedFraction === undefined) return undefined;
-	if (usedFraction >= 1) return "exhausted";
-	if (usedFraction >= 0.9) return "warning";
-	return "ok";
+/** Z.AI `percentage` is 0-100 and may overshoot; clamp it to a used fraction. */
+function percentageFraction(percentage: number | undefined): number | undefined {
+	return percentage === undefined ? undefined : Math.min(Math.max(percentage / 100, 0), 1);
 }
 
 function formatDate(value: Date): string {
@@ -283,7 +255,7 @@ async function fetchZaiUsage(params: UsageFetchParams, ctx: UsageFetchContext):
 				used: parsed.currentValue,
 				limit: parsed.usage,
 				remaining: parsed.remaining,
-				percentage: parsed.percentage,
+				usedFraction: percentageFraction(parsed.percentage),
 				unit: "tokens",
 			});
 			const window = buildZaiWindow(parsed);
@@ -297,7 +269,7 @@ async function fetchZaiUsage(params: UsageFetchParams, ctx: UsageFetchContext):
 				},
 				window,
 				amount,
-				status: getUsageStatus(amount.usedFraction),
+				status: amount.usedFraction === undefined ? undefined : usageStatus(amount.usedFraction),
 			});
 		}
 		if (parsed.type === "TIME_LIMIT") {
@@ -306,7 +278,7 @@ async function fetchZaiUsage(params: UsageFetchParams, ctx: UsageFetchContext):
 				used: parsed.currentValue,
 				limit: parsed.usage,
 				remaining: parsed.remaining,
-				percentage: parsed.percentage,
+				usedFraction: percentageFraction(parsed.percentage),
 				unit: "requests",
 			});
 			const featureLimit = isZaiFeatureRequestLimit(parsed);
@@ -321,7 +293,7 @@ async function fetchZaiUsage(params: UsageFetchParams, ctx: UsageFetchContext):
 				},
 				window,
 				amount,
-				status: getUsageStatus(amount.usedFraction),
+				status: amount.usedFraction === undefined ? undefined : usageStatus(amount.usedFraction),
 			});
 		}
 		if (parsed.type === "CREDIT_LIMIT") {
@@ -335,7 +307,7 @@ async function fetchZaiUsage(params: UsageFetchParams, ctx: UsageFetchContext):
 				used: parsed.currentValue,
 				limit: parsed.usage,
 				remaining: parsed.remaining,
-				percentage: hasAbsoluteMeter ? undefined : parsed.percentage,
+				usedFraction: hasAbsoluteMeter ? undefined : percentageFraction(parsed.percentage),
 				unit: "credits",
 			});
 			limits.push({
@@ -348,7 +320,7 @@ async function fetchZaiUsage(params: UsageFetchParams, ctx: UsageFetchContext):
 				},
 				window,
 				amount,
-				status: getUsageStatus(amount.usedFraction),
+				status: amount.usedFraction === undefined ? undefined : usageStatus(amount.usedFraction),
 			});
 		}
 	}

package/src/utils/event-stream.ts

@@ -6,9 +6,21 @@ export interface LocalWorkSource {
 	readonly hasPendingLocalWork: boolean;
 }
 
+/** Consumed head slots tolerated before the backlog is compacted (see {@link EventStream.queue}). */
+const QUEUE_COMPACT_MIN_HEAD = 64;
+
 // Generic event stream class for async iteration
 export class EventStream<T, R = T> implements AsyncIterable<T> {
+	/**
+	 * Events pushed while no consumer was waiting. The iterator dequeues by
+	 * advancing {@link #queueHead} instead of `shift()` — O(remaining) per event,
+	 * quadratic for a consumer draining a backlog — so while it drains, the
+	 * slots before the head are consumed (cleared) placeholders. Do not mutate
+	 * the array while the stream is being iterated.
+	 */
 	queue: T[] = [];
+	/** Index of the next undelivered event in {@link queue}; 0 whenever the queue is empty. */
+	#queueHead = 0;
 	waiting: Array<{ resolve: (value: IteratorResult<T>) => void; reject: (err: unknown) => void }> = [];
 	done = false;
 	/** True once finalResultPromise has been resolved or rejected. */
@@ -115,10 +127,34 @@ export class EventStream<T, R = T> implements AsyncIterable<T> {
 		}
 	}
 
+	/**
+	 * Take the event at the queue head. Clears the consumed slot so it stops
+	 * retaining the event, resets the queue once drained, and compacts it once
+	 * consumed slots are at least half of it (amortized O(1) per event).
+	 */
+	#dequeue(): T {
+		const queue = this.queue;
+		const head = this.#queueHead;
+		const event = queue[head];
+		if (head + 1 === queue.length) {
+			queue.length = 0;
+			this.#queueHead = 0;
+			return event;
+		}
+		// The slot is dead once the head moves past it; `undefined` only drops the reference.
+		queue[head] = undefined as T;
+		this.#queueHead = head + 1;
+		if (this.#queueHead >= QUEUE_COMPACT_MIN_HEAD && this.#queueHead * 2 >= queue.length) {
+			queue.splice(0, this.#queueHead);
+			this.#queueHead = 0;
+		}
+		return event;
+	}
+
 	async *[Symbol.asyncIterator](): AsyncIterator<T> {
 		while (true) {
-			if (this.queue.length > 0) {
-				yield this.queue.shift()!;
+			if (this.#queueHead < this.queue.length) {
+				yield this.#dequeue();
 			} else if (this.#failed) {
 				throw this.#error;
 			} else if (this.done) {