@oh-my-pi/pi-ai 16.5.0 → 16.5.2

package/src/usage/cursor.ts

@@ -0,0 +1,192 @@
+import type {
+	UsageAmount,
+	UsageFetchContext,
+	UsageFetchParams,
+	UsageLimit,
+	UsageProvider,
+	UsageReport,
+	UsageStatus,
+	UsageWindow,
+} from "../usage";
+import { toNumber } from "./shared";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function parseTimestamp(value: unknown): number | undefined {
+	const numeric = toNumber(value);
+	if (numeric !== undefined) return numeric < 1_000_000_000_000 ? numeric * 1000 : numeric;
+	if (typeof value !== "string" || !value.trim()) return undefined;
+	const parsed = Date.parse(value);
+	return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+function normalizeCursorBaseUrl(baseUrl?: string): string {
+	if (!baseUrl) return "https://api2.cursor.sh";
+	return baseUrl.replace(/\/+$/, "");
+}
+
+function deriveResetsAt(payload: Record<string, unknown>): number | undefined {
+	const endKeys = ["billingCycleEnd", "endOfMonth", "resetsAt", "nextReset"];
+	for (const key of endKeys) {
+		const parsed = parseTimestamp(payload[key]);
+		if (parsed !== undefined) return parsed;
+	}
+
+	const startKeys = ["startOfMonth", "billingCycleStart", "startOfBillingCycle"];
+	for (const key of startKeys) {
+		const parsed = parseTimestamp(payload[key]);
+		if (parsed !== undefined) {
+			const date = new Date(parsed);
+			date.setUTCMonth(date.getUTCMonth() + 1);
+			return date.getTime();
+		}
+	}
+	return undefined;
+}
+
+export function parseCursorUsage(payload: unknown, fetchedAt = Date.now()): UsageReport | null {
+	if (!isRecord(payload)) return null;
+	const limits: UsageLimit[] = [];
+	const resetsAt = deriveResetsAt(payload);
+
+	const window: UsageWindow = {
+		id: "monthly",
+		label: "Monthly",
+		...(resetsAt !== undefined ? { resetsAt } : {}),
+	};
+
+	for (const [key, value] of Object.entries(payload)) {
+		if (!isRecord(value)) continue;
+
+		// used can be: numRequests, used, amountUsed, usdUsed
+		const usedVal =
+			toNumber(value.numRequests) ?? toNumber(value.used) ?? toNumber(value.amountUsed) ?? toNumber(value.usdUsed);
+
+		// limit can be: maxRequestUsage, limit, amountLimit, usdLimit
+		const limitVal =
+			toNumber(value.maxRequestUsage) ??
+			toNumber(value.limit) ??
+			toNumber(value.amountLimit) ??
+			toNumber(value.usdLimit);
+
+		if (usedVal !== undefined && limitVal !== undefined) {
+			const isUsd =
+				key === "planUsage" ||
+				key.toLowerCase().includes("usd") ||
+				key.toLowerCase().includes("billing") ||
+				key.toLowerCase().includes("stripe");
+
+			const unit = isUsd ? "usd" : "requests";
+			const cleanBucket = key.toLowerCase().trim();
+			const limitId = isUsd ? `cursor:usd:${cleanBucket}` : `cursor:requests:${cleanBucket}`;
+
+			const label = isUsd ? `${key} spend` : `${key} requests`;
+
+			const amount: UsageAmount = {
+				used: usedVal,
+				limit: limitVal,
+				remaining: Math.max(0, limitVal - usedVal),
+				usedFraction: limitVal > 0 ? usedVal / limitVal : 0,
+				remainingFraction: limitVal > 0 ? Math.max(0, limitVal - usedVal) / limitVal : 0,
+				unit,
+			};
+
+			const usedFraction = amount.usedFraction;
+			let status: UsageStatus = "unknown";
+			if (usedFraction !== undefined) {
+				if (usedFraction >= 1) {
+					status = "exhausted";
+				} else if (usedFraction >= 0.9) {
+					status = "warning";
+				} else {
+					status = "ok";
+				}
+			}
+
+			limits.push({
+				id: limitId,
+				label,
+				scope: {
+					provider: "cursor",
+					...(window ? { windowId: window.id } : {}),
+				},
+				...(window ? { window } : {}),
+				amount,
+				status,
+			});
+		}
+	}
+
+	if (limits.length === 0) {
+		return null;
+	}
+
+	return {
+		provider: "cursor",
+		fetchedAt,
+		limits,
+		raw: payload,
+	};
+}
+
+export const cursorUsageProvider: UsageProvider = {
+	id: "cursor",
+	supports(params: UsageFetchParams): boolean {
+		if (params.provider !== "cursor") return false;
+		const { credential } = params;
+		if (credential.type === "oauth") {
+			return Boolean(credential.accessToken);
+		}
+		if (credential.type === "api_key") {
+			return Boolean(credential.apiKey);
+		}
+		return false;
+	},
+	async fetchUsage(params: UsageFetchParams, ctx: UsageFetchContext): Promise<UsageReport | null> {
+		if (params.provider !== "cursor") return null;
+		const { credential } = params;
+		const token = credential.type === "oauth" ? credential.accessToken : credential.apiKey;
+		if (!token) return null;
+
+		const baseUrl = normalizeCursorBaseUrl(params.baseUrl ?? credential.apiEndpoint);
+		const url = `${baseUrl}/auth/usage`;
+
+		const headers: Record<string, string> = {
+			Accept: "application/json",
+			Authorization: `Bearer ${token}`,
+		};
+
+		try {
+			const response = await ctx.fetch(url, {
+				headers,
+				signal: params.signal,
+			});
+			if (!response.ok) {
+				ctx.logger?.warn("Cursor usage request failed", {
+					status: response.status,
+					provider: params.provider,
+				});
+				return null;
+			}
+			const payload = await response.json();
+			const report = parseCursorUsage(payload);
+			if (report) {
+				const metadata = {
+					...(credential.email ? { email: credential.email } : {}),
+					...(credential.accountId ? { accountId: credential.accountId } : {}),
+					...(credential.projectId ? { projectId: credential.projectId } : {}),
+				};
+				if (Object.keys(metadata).length > 0) report.metadata = metadata;
+			}
+			return report;
+		} catch (error) {
+			ctx.logger?.warn("Cursor usage request error", {
+				provider: params.provider,
+				error: String(error),
+			});
+			return null;
+		}
+	},
+};

package/src/usage/openai-codex-reset.ts

@@ -8,7 +8,7 @@
  *
  *   GET  /wham/rate-limit-reset-credits           → list redeemable credits
  *   POST /wham/rate-limit-reset-credits/consume   → spend one credit
- *        body: { credit_id, redeem_request_id }
+ *        body: { credit_id, redeem_request_id, account_id? }
  *
  * `redeem_request_id` is a client-generated idempotency key (UUID). The consume
  * response carries a `code`: `"reset"` on success, otherwise a business reason
@@ -159,7 +159,11 @@ export async function consumeCodexResetCredit(
 	const response = await auth.fetch(url, {
 		method: "POST",
 		headers: buildHeaders(auth, true),
-		body: JSON.stringify({ credit_id: auth.creditId, redeem_request_id: redeemRequestId }),
+		body: JSON.stringify({
+			credit_id: auth.creditId,
+			redeem_request_id: redeemRequestId,
+			account_id: auth.accountId,
+		}),
 		signal: auth.signal,
 	});
 	let body: unknown;

package/src/usage/openai-codex.ts

@@ -344,11 +344,44 @@ function buildAdditionalUsageLimit(args: {
 	};
 }
 
+/**
+ * Parse Codex `x-codex-{primary,secondary}-*` rate-limit response headers into
+ * a usage report. The backend attaches these snapshots to every response, so
+ * ingesting them lets credential selection block an exhausted account before
+ * the next request burns a wire 429.
+ */
+export function parseCodexRateLimitHeaders(headers: Record<string, string>, now = Date.now()): UsageReport | null {
+	const parseWindow = (key: "primary" | "secondary"): ParsedUsageWindow | undefined => {
+		const usedPercent = toNumber(headers[`x-codex-${key}-used-percent`]);
+		if (usedPercent === undefined) return undefined;
+		const windowMinutes = toNumber(headers[`x-codex-${key}-window-minutes`]);
+		const resetAt = toNumber(headers[`x-codex-${key}-reset-at`]);
+		return {
+			usedPercent,
+			limitWindowSeconds: windowMinutes === undefined ? undefined : windowMinutes * 60,
+			resetAt,
+		};
+	};
+	const primary = parseWindow("primary");
+	const secondary = parseWindow("secondary");
+	if (!primary && !secondary) return null;
+	const limits: UsageLimit[] = [];
+	if (primary) limits.push(buildUsageLimit({ key: "primary", window: primary, nowMs: now }));
+	if (secondary) limits.push(buildUsageLimit({ key: "secondary", window: secondary, nowMs: now }));
+	return {
+		provider: "openai-codex",
+		fetchedAt: now,
+		limits,
+		metadata: { source: "ratelimit-headers" },
+	};
+}
+
 export const openaiCodexUsageProvider: UsageProvider = {
 	id: "openai-codex",
 	supports(params: UsageFetchParams): boolean {
 		return params.provider === "openai-codex" && params.credential.type === "oauth";
 	},
+	parseRateLimitHeaders: parseCodexRateLimitHeaders,
 	async fetchUsage(params: UsageFetchParams, ctx: UsageFetchContext): Promise<UsageReport | null> {
 		if (params.provider !== "openai-codex") return null;
 		const { credential } = params;

package/src/usage/zai.ts

@@ -1,5 +1,6 @@
 import { toNumber } from "@oh-my-pi/pi-catalog/utils";
 import type {
+	CredentialRankingStrategy,
 	UsageAmount,
 	UsageFetchContext,
 	UsageFetchParams,
@@ -175,12 +176,14 @@ function buildZaiWindow(parsed: ZaiUsageLimitItem): UsageWindow {
 	};
 }
 
-function requestQuotaLabel(parsed: ZaiUsageLimitItem): string {
+function isZaiFeatureRequestLimit(parsed: ZaiUsageLimitItem): boolean {
 	const detailCodes =
 		parsed.usageDetails?.map(detail => detail.modelCode).filter((code): code is string => !!code) ?? [];
-	if (detailCodes.includes("search-prime") && detailCodes.includes("web-reader") && detailCodes.includes("zread")) {
-		return "ZAI Web Search / Reader / Zread Quota";
-	}
+	return detailCodes.includes("search-prime") && detailCodes.includes("web-reader") && detailCodes.includes("zread");
+}
+
+function requestQuotaLabel(parsed: ZaiUsageLimitItem): string {
+	if (isZaiFeatureRequestLimit(parsed)) return "ZAI Web Search / Reader / Zread Quota";
 	return "ZAI Request Quota";
 }
 
@@ -191,6 +194,29 @@ function buildModelUsageUrl(baseUrl: string, now: Date): string {
 	return `${baseUrl}${MODEL_USAGE_PATH}?startTime=${encodeURIComponent(startTime)}&endTime=${encodeURIComponent(endTime)}`;
 }
 
+function getZaiCredentialLimits(report: UsageReport): UsageLimit[] {
+	const limits = report.limits.filter(
+		limit => limit.id.startsWith("zai:requests:") || limit.id.startsWith("zai:tokens:"),
+	);
+	return limits;
+}
+
+function rankZaiRequestLimits(report: UsageReport): UsageLimit[] {
+	const requestLimits = report.limits.filter(limit => limit.id.startsWith("zai:requests:"));
+	const credentialLimits = getZaiCredentialLimits(report);
+	const limits = requestLimits.length > 0 ? requestLimits : credentialLimits;
+	const ranked = [...limits];
+	ranked.sort((left, right) => {
+		const leftDuration = left.window?.durationMs ?? Number.POSITIVE_INFINITY;
+		const rightDuration = right.window?.durationMs ?? Number.POSITIVE_INFINITY;
+		if (leftDuration !== rightDuration) return leftDuration - rightDuration;
+		const leftReset = left.window?.resetsAt ?? Number.POSITIVE_INFINITY;
+		const rightReset = right.window?.resetsAt ?? Number.POSITIVE_INFINITY;
+		return leftReset - rightReset;
+	});
+	return ranked;
+}
+
 async function fetchZaiUsage(params: UsageFetchParams, ctx: UsageFetchContext): Promise<UsageReport | null> {
 	if (params.provider !== "zai") return null;
 	const credential = params.credential;
@@ -263,13 +289,15 @@ async function fetchZaiUsage(params: UsageFetchParams, ctx: UsageFetchContext):
 				percentage: parsed.percentage,
 				unit: "requests",
 			});
+			const featureLimit = isZaiFeatureRequestLimit(parsed);
 			limits.push({
-				id: `zai:requests:${window.id}`,
+				id: featureLimit ? `zai:features:web-search-reader-zread:${window.id}` : `zai:requests:${window.id}`,
 				label: requestQuotaLabel(parsed),
 				scope: {
 					provider: params.provider,
 					windowId: window.id,
-					shared: true,
+					shared: !featureLimit,
+					...(featureLimit ? { tier: "web-search-reader-zread" } : {}),
 				},
 				window,
 				amount,
@@ -319,3 +347,18 @@ export const zaiUsageProvider: UsageProvider = {
 	fetchUsage: fetchZaiUsage,
 	supports: params => params.provider === "zai" && params.credential.type === "api_key",
 };
+
+export const zaiRankingStrategy: CredentialRankingStrategy = {
+	findWindowLimits(report) {
+		const ranked = rankZaiRequestLimits(report);
+		return { primary: ranked[0], secondary: ranked[1] };
+	},
+	scopeLimits(report) {
+		const limits = getZaiCredentialLimits(report);
+		return limits;
+	},
+	windowDefaults: {
+		primaryMs: 5 * HOUR_MS,
+		secondaryMs: WEEK_MS,
+	},
+};

package/src/usage.ts

@@ -260,6 +260,10 @@ export interface UsageCredential {
 	accountId?: string;
 	projectId?: string;
 	email?: string;
+	/** Organization/workspace the credential is scoped to (see OAuthCredentials.orgId). */
+	orgId?: string;
+	/** Human-readable organization name for display. */
+	orgName?: string;
 	enterpriseUrl?: string;
 	metadata?: Record<string, unknown>;
 	apiEndpoint?: string;

package/src/utils/idle-iterator.ts

@@ -98,12 +98,12 @@ export function getOpenAIStreamFirstEventTimeoutMs(
  * pre-response request (issue #2422 regression: large `write` tool-call streams
  * died at the budget with `TimeoutError: The operation timed out.` despite
  * deltas actively flowing). This arms a `clearTimeout`-able timer instead;
- * callers MUST `clear()` as soon as `fetchWithRetry` resolves (headers in) so
- * the body stream is left to the iterator-level idle watchdog. The timer aborts
- * with a `TimeoutError` matching `AbortSignal.timeout`, so a genuine pre-response
- * stall behaves exactly as the prior code did — `fetchWithRetry` normalizes the
- * abort to "Request was aborted" either way (only a post-headers abort ever
- * surfaced the raw `"The operation timed out."`, which clearing now prevents).
+ * callers MUST `clear()` as soon as the guarded transport attempt settles so
+ * the body stream is left to the iterator-level idle watchdog.
+ *
+ * Retrying callers MUST arm a fresh guard for each transport attempt and keep
+ * the retry loop's base signal reserved for caller cancellation. Reusing the
+ * guard as the loop signal makes its timeout indistinguishable from cancellation.
  *
  * Returns the caller signal unchanged (and a no-op `clear`) when no positive
  * timeout is configured.