@oh-my-pi/pi-ai 17.1.2 → 17.1.4

package/src/usage/alibaba-token-plan.ts

@@ -14,13 +14,21 @@ const PROVIDER = "alibaba-token-plan";
 const CONSOLE_ORIGIN = "https://home.qwencloud.com";
 const DASHBOARD_URL = `${CONSOLE_ORIGIN}/billing/subscription/token-plan-individual`;
 const USER_INFO_URL = `${CONSOLE_ORIGIN}/tool/user/info.json`;
-const USAGE_URL = `${CONSOLE_ORIGIN}/data/api.json?product=sfm_bailian&action=IntlBroadScopeAspnGateway`;
 const GATEWAY_ACTION = "IntlBroadScopeAspnGateway";
 const USAGE_API = "zeldaHttp.apikeyMgr./tokenplan/personal/api/v2/usage";
+const USAGE_URL = `https://cs-data.qwencloud.com/data/api.json?product=sfm_bailian&action=${GATEWAY_ACTION}&api=${encodeURIComponent(USAGE_API)}`;
 const BROWSER_USER_AGENT =
 	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36";
 const FIVE_HOURS_MS = 5 * 60 * 60 * 1000;
 const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
+const CONSOLE_CORNERSTONE_PARAM = {
+	domain: "home.qwencloud.com",
+	consoleSite: "QWENCLOUD",
+	console: "ONE_CONSOLE",
+	xsp_lang: "en-US",
+	protocol: "V2",
+	productCode: "p_efm",
+} as const;
 
 function extractCookieValue(header: string, name: string): string | undefined {
 	for (const segment of header.split(";")) {
@@ -32,6 +40,21 @@ function extractCookieValue(header: string, name: string): string | undefined {
 	return undefined;
 }
 
+function unwrapGatewayData(value: Record<string, unknown>): Record<string, unknown> {
+	let current = value;
+	if (typeof current.Data === "string") {
+		try {
+			const parsed: unknown = JSON.parse(current.Data);
+			if (isRecord(parsed)) current = parsed;
+		} catch {
+			return current;
+		}
+	}
+	if (isRecord(current.DataV2) && isRecord(current.DataV2.data)) current = current.DataV2.data;
+	if (isRecord(current.data)) current = current.data;
+	return current;
+}
+
 function parseResetTime(value: unknown): number | undefined {
 	const parsed = toNumber(value);
 	if (parsed === undefined || parsed <= 0) return undefined;
@@ -127,7 +150,11 @@ async function fetchAlibabaTokenPlanUsage(
 			action: GATEWAY_ACTION,
 			region: "ap-southeast-1",
 			sec_token: secToken,
-			params: JSON.stringify({ Api: USAGE_API, Data: {} }),
+			params: JSON.stringify({
+				Api: USAGE_API,
+				Data: { cornerstoneParam: CONSOLE_CORNERSTONE_PARAM },
+				V: "1.0",
+			}),
 		});
 		const usageResponse = await ctx.fetch(USAGE_URL, {
 			method: "POST",
@@ -145,22 +172,23 @@ async function fetchAlibabaTokenPlanUsage(
 			ctx.logger?.warn("QwenCloud usage response invalid", { provider: PROVIDER });
 			return null;
 		}
+		const responseData = unwrapGatewayData(payload.data);
 		const accountId = accountIdFromUserData(userPayload.data);
 		const limits = [
 			buildLimit(
 				"5h",
 				"5 Hour Credits",
 				FIVE_HOURS_MS,
-				parseUsedFraction(payload.data.per5HourPercentage),
-				parseResetTime(payload.data.per5HourResetTime),
+				parseUsedFraction(responseData.per5HourPercentage),
+				parseResetTime(responseData.per5HourResetTime),
 				accountId,
 			),
 			buildLimit(
 				"7d",
 				"7 Day Credits",
 				SEVEN_DAYS_MS,
-				parseUsedFraction(payload.data.per1WeekPercentage),
-				parseResetTime(payload.data.per1WeekResetTime),
+				parseUsedFraction(responseData.per1WeekPercentage),
+				parseResetTime(responseData.per1WeekResetTime),
 				accountId,
 			),
 		].filter((limit): limit is UsageLimit => limit !== undefined);

package/src/usage/claude.ts

@@ -2,7 +2,7 @@ import { scheduler } from "node:timers/promises";
 import { bareModelId, parseAnthropicModel } from "@oh-my-pi/pi-catalog/identity";
 import { toNumber } from "@oh-my-pi/pi-catalog/utils";
 import * as AIError from "../error";
-import { claudeCodeVersion } from "../providers/anthropic";
+import { claudeCodeVersion } from "../providers/claude-code-fingerprint";
 import {
 	type CredentialRankingContext,
 	type CredentialRankingStrategy,
@@ -153,6 +153,12 @@ function getApiLimitDisplayName(scope: unknown): string | undefined {
  * `seven_day_sonnet`) are permanently null. Model-scoped weekly caps now arrive
  * only through generic `limits[]` entries (`kind: "weekly_scoped"`) with the
  * model family named by `scope.model.display_name`.
+ *
+ * `is_active` is deliberately ignored: live payloads mark only the currently
+ * binding limit active (an account pinned at a 100% Fable cap reports its 77%
+ * shared weekly row as `is_active: false`), so it signals severity ranking,
+ * not bucket existence. Filtering on it hid real utilization — a scoped row
+ * at 5% with a live reset rendered as `not reported` in `omp usage`.
  */
 function parseApiLimitEntries(raw: unknown): ParsedApiLimitEntry[] {
 	if (!Array.isArray(raw)) return [];
@@ -161,7 +167,6 @@ function parseApiLimitEntries(raw: unknown): ParsedApiLimitEntry[] {
 		if (!isRecord(rawEntry)) continue;
 		const entry = rawEntry as ClaudeApiLimitEntry;
 		if (typeof entry.kind !== "string") continue;
-		if (entry.is_active === false) continue;
 		const utilization = toNumber(entry.percent);
 		const resetsAt = parseIsoTime(typeof entry.resets_at === "string" ? entry.resets_at : undefined);
 		if (utilization === undefined && resetsAt === undefined) continue;

package/src/usage/minimax-code.ts

@@ -1,30 +1,291 @@
-import type { UsageFetchContext, UsageFetchParams, UsageProvider, UsageReport } from "../usage";
+import type {
+	UsageFetchContext,
+	UsageFetchParams,
+	UsageLimit,
+	UsageProvider,
+	UsageReport,
+	UsageStatus,
+} from "../usage";
+import { isRecord } from "../utils";
+import { toNumber } from "./shared";
 
+const INTL_PROVIDER = "minimax-code";
+const INTL_BASE_URL = "https://api.minimax.io";
+const REMAINS_PATH = "/v1/token_plan/remains";
+const HOUR_MS = 60 * 60 * 1000;
+/** `current_*_status` enum reported per window: 1 normal, 2 exhausted, 3 unlimited. */
+const STATUS_EXHAUSTED = 2;
+const STATUS_UNLIMITED = 3;
 /**
- * MiniMax Token Plan usage provider.
- *
- * MiniMax Token Plan is a subscription-based service with a rolling quota system.
- *
- * Currently, MiniMax does not expose a usage/quota API endpoint for the Token Plan.
- * Usage is tracked via the web dashboard at https://platform.minimax.io/user-center/payment/token-plan
+ * The plan-wide token quota every chat model draws from. It is a quota category,
+ * not a catalog model id, so its limits are scoped `shared`: `AuthStorage` has no
+ * MiniMax ranking strategy and would otherwise match `scope.modelId` against ids
+ * like `MiniMax-M3` and drop the "models with usage data" mapping. Category
+ * buckets such as `video` meter a separate quota and keep their own model scope.
+ */
+const SHARED_BUCKET = "general";
+
+/** One `model_remains[]` bucket: a plan quota tracked over a rolling interval plus a weekly window. */
+interface TokenPlanBucket {
+	modelName: string;
+	intervalStart?: number;
+	intervalEnd?: number;
+	intervalRemainingPercent?: number;
+	intervalTotalCount?: number;
+	intervalUsageCount?: number;
+	intervalStatus?: number;
+	weeklyStart?: number;
+	weeklyEnd?: number;
+	weeklyRemainingPercent?: number;
+	weeklyTotalCount?: number;
+	weeklyUsageCount?: number;
+	weeklyStatus?: number;
+}
+
+/** MiniMax reports epoch milliseconds; tolerate seconds in case a deployment differs. */
+function parseTimestamp(value: unknown): number | undefined {
+	const parsed = toNumber(value);
+	if (parsed === undefined || parsed <= 0) return undefined;
+	return parsed < 1_000_000_000_000 ? parsed * 1000 : parsed;
+}
+
+/** `current_*_remaining_percent` is 0..100 remaining; usage fractions are 0..1 used. */
+function usedFractionFromRemainingPercent(value: unknown): number | undefined {
+	const parsed = toNumber(value);
+	if (parsed === undefined || !Number.isFinite(parsed)) return undefined;
+	// (100 - p) / 100 keeps whole percentages exact; 1 - p / 100 does not (90 → 0.09999999999999998).
+	return Math.min(1, Math.max(0, (100 - parsed) / 100));
+}
+
+function usageStatus(usedFraction: number): UsageStatus {
+	if (usedFraction >= 1) return "exhausted";
+	if (usedFraction >= 0.9) return "warning";
+	return "ok";
+}
+
+function parseBucket(value: unknown): TokenPlanBucket | null {
+	if (!isRecord(value)) return null;
+	const modelName = typeof value.model_name === "string" ? value.model_name.trim() : "";
+	if (!modelName) return null;
+	return {
+		modelName,
+		intervalStart: parseTimestamp(value.start_time),
+		intervalEnd: parseTimestamp(value.end_time),
+		intervalRemainingPercent: toNumber(value.current_interval_remaining_percent),
+		intervalTotalCount: toNumber(value.current_interval_total_count),
+		intervalUsageCount: toNumber(value.current_interval_usage_count),
+		intervalStatus: toNumber(value.current_interval_status),
+		weeklyStart: parseTimestamp(value.weekly_start_time),
+		weeklyEnd: parseTimestamp(value.weekly_end_time),
+		weeklyRemainingPercent: toNumber(value.current_weekly_remaining_percent),
+		weeklyTotalCount: toNumber(value.current_weekly_total_count),
+		weeklyUsageCount: toNumber(value.current_weekly_usage_count),
+		weeklyStatus: toNumber(value.current_weekly_status),
+	};
+}
+
+/**
+ * A model outside the current plan is reported as both windows "unlimited"
+ * with zero totals and 100% remaining, which would otherwise read as a pristine
+ * quota. MiniMax's own CLI treats exactly this shape as "not in plan"
+ * ([MiniMax-AI/cli#173](https://github.com/MiniMax-AI/cli/issues/173)), so the
+ * bucket is kept out of the limits and named in `metadata.unavailableModels`.
+ * Zero totals alone are not enough: a live plan reports `0/0` with status 1 and
+ * a real remaining percentage.
+ */
+function isUnavailablePlan(bucket: TokenPlanBucket): boolean {
+	return (
+		bucket.intervalTotalCount === 0 &&
+		bucket.weeklyTotalCount === 0 &&
+		bucket.intervalStatus === STATUS_UNLIMITED &&
+		bucket.weeklyStatus === STATUS_UNLIMITED
+	);
+}
+
+/**
+ * Interval length varies per bucket (text quotas roll every few hours, media
+ * quotas daily), so the window id follows the reported span instead of a
+ * hardcoded tier. Spans that are not whole hours are labelled in minutes
+ * rather than rounded into a wrong hour count.
+ */
+function intervalWindowId(durationMs: number | undefined): { id: string; label: string } {
+	if (durationMs === undefined || durationMs <= 0) return { id: "interval", label: "Interval" };
+	if (durationMs % HOUR_MS === 0) {
+		const hours = durationMs / HOUR_MS;
+		return { id: `${hours}h`, label: `${hours} Hour` };
+	}
+	const minutes = Math.round(durationMs / 60_000);
+	if (minutes <= 0) return { id: "interval", label: "Interval" };
+	return { id: `${minutes}m`, label: `${minutes} Minute` };
+}
+
+function buildLimit(args: {
+	provider: string;
+	bucket: TokenPlanBucket;
+	windowId: string;
+	windowLabel: string;
+	durationMs?: number;
+	resetsAt?: number;
+	usedFraction: number | undefined;
+	windowStatus?: number;
+	usageCount?: number;
+	totalCount?: number;
+	accountId?: string;
+}): UsageLimit | undefined {
+	// The endpoint's own status outranks the percentage: an exhausted window may
+	// omit it, or keep a stale one that would otherwise render as healthy quota.
+	const usedFraction = args.windowStatus === STATUS_EXHAUSTED ? 1 : args.usedFraction;
+	if (usedFraction === undefined) return undefined;
+	const totalCount = args.totalCount;
+	return {
+		id: `${args.bucket.modelName}:${args.windowId}`,
+		label: `${args.bucket.modelName.charAt(0).toUpperCase()}${args.bucket.modelName.slice(1)} ${args.windowLabel}`,
+		scope: {
+			provider: args.provider,
+			...(args.accountId ? { accountId: args.accountId } : {}),
+			...(args.bucket.modelName === SHARED_BUCKET ? { shared: true as const } : { modelId: args.bucket.modelName }),
+			windowId: args.windowId,
+		},
+		window: {
+			id: args.windowId,
+			label: args.windowLabel,
+			...(args.durationMs !== undefined && args.durationMs > 0 ? { durationMs: args.durationMs } : {}),
+			...(args.resetsAt ? { resetsAt: args.resetsAt } : {}),
+		},
+		amount: {
+			used: usedFraction * 100,
+			usedFraction,
+			remaining: 100 - usedFraction * 100,
+			remainingFraction: 1 - usedFraction,
+			unit: "percent",
+		},
+		status: usageStatus(usedFraction),
+		...(totalCount !== undefined && totalCount > 0
+			? { notes: [`Requests: ${args.usageCount ?? 0}/${totalCount}`] }
+			: {}),
+	};
+}
+
+function buildBucketLimits(provider: string, bucket: TokenPlanBucket, accountId: string | undefined): UsageLimit[] {
+	const intervalDuration =
+		bucket.intervalStart !== undefined && bucket.intervalEnd !== undefined
+			? bucket.intervalEnd - bucket.intervalStart
+			: undefined;
+	const weeklyDuration =
+		bucket.weeklyStart !== undefined && bucket.weeklyEnd !== undefined
+			? bucket.weeklyEnd - bucket.weeklyStart
+			: undefined;
+	const interval = intervalWindowId(intervalDuration);
+	return [
+		buildLimit({
+			provider,
+			bucket,
+			windowId: interval.id,
+			windowLabel: interval.label,
+			durationMs: intervalDuration,
+			resetsAt: bucket.intervalEnd,
+			usedFraction: usedFractionFromRemainingPercent(bucket.intervalRemainingPercent),
+			windowStatus: bucket.intervalStatus,
+			usageCount: bucket.intervalUsageCount,
+			totalCount: bucket.intervalTotalCount,
+			accountId,
+		}),
+		buildLimit({
+			provider,
+			bucket,
+			windowId: "7d",
+			windowLabel: "7 Day",
+			durationMs: weeklyDuration,
+			resetsAt: bucket.weeklyEnd,
+			usedFraction: usedFractionFromRemainingPercent(bucket.weeklyRemainingPercent),
+			windowStatus: bucket.weeklyStatus,
+			usageCount: bucket.weeklyUsageCount,
+			totalCount: bucket.weeklyTotalCount,
+			accountId,
+		}),
+	].filter((limit): limit is UsageLimit => limit !== undefined);
+}
+
+/**
+ * MiniMax Token Plan usage provider (international, `api.minimax.io`).
  *
- * 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.
+ * `GET /v1/token_plan/remains` returns one `model_remains[]` bucket per plan
+ * quota (text, media, …), each carrying a rolling interval window and a weekly
+ * window with the remaining percentage. MiniMax answers HTTP 200 even for
+ * rejected credentials, so `base_resp.status_code` is the real success signal.
  */
-async function fetchMiniMaxCodeUsage(params: UsageFetchParams, _ctx: UsageFetchContext): Promise<UsageReport | null> {
-	if (params.provider !== "minimax-code" && params.provider !== "minimax-code-cn") {
+async function fetchMiniMaxCodeUsage(params: UsageFetchParams, ctx: UsageFetchContext): Promise<UsageReport | null> {
+	if (params.provider !== INTL_PROVIDER) return null;
+	const apiKey = params.credential.apiKey;
+	if (params.credential.type !== "api_key" || !apiKey) return null;
+
+	try {
+		const configuredBaseUrl = params.baseUrl?.trim();
+		const baseUrl = configuredBaseUrl ? configuredBaseUrl.replace(/\/+$/, "").replace(/\/v1$/, "") : INTL_BASE_URL;
+		const response = await ctx.fetch(`${baseUrl}${REMAINS_PATH}`, {
+			headers: { Accept: "application/json", Authorization: `Bearer ${apiKey}` },
+			signal: params.signal,
+		});
+		if (!response.ok) {
+			ctx.logger?.warn("MiniMax Token Plan usage fetch failed", {
+				provider: params.provider,
+				status: response.status,
+			});
+			return null;
+		}
+		const payload: unknown = await response.json();
+		if (!isRecord(payload)) return null;
+		const statusCode = isRecord(payload.base_resp) ? toNumber(payload.base_resp.status_code) : undefined;
+		if (statusCode !== 0) {
+			ctx.logger?.warn("MiniMax Token Plan usage response rejected", {
+				provider: params.provider,
+				statusCode: statusCode ?? "missing",
+			});
+			return null;
+		}
+		if (!Array.isArray(payload.model_remains)) return null;
+
+		const accountId = params.credential.accountId;
+		const limits: UsageLimit[] = [];
+		const models: string[] = [];
+		const unavailableModels: string[] = [];
+		for (const entry of payload.model_remains) {
+			const bucket = parseBucket(entry);
+			if (!bucket) continue;
+			models.push(bucket.modelName);
+			if (isUnavailablePlan(bucket)) {
+				unavailableModels.push(bucket.modelName);
+				continue;
+			}
+			limits.push(...buildBucketLimits(params.provider, bucket, accountId));
+		}
+		if (limits.length === 0) return null;
+
+		return {
+			provider: params.provider,
+			fetchedAt: Date.now(),
+			limits,
+			metadata: {
+				source: "minimax-token-plan",
+				models,
+				...(unavailableModels.length > 0 ? { unavailableModels } : {}),
+				...(accountId ? { accountId } : {}),
+			},
+			raw: payload,
+		};
+	} catch (error) {
+		ctx.logger?.warn("MiniMax Token Plan usage request failed", {
+			provider: params.provider,
+			error: error instanceof Error ? error.name : "unknown",
+		});
 		return null;
 	}
-
-	// MiniMax Token Plan does not currently expose a usage API
-	// Users can check their usage via the web dashboard
-	return null;
 }
 
+/** MiniMax Token Plan (international, `api.minimax.io`). */
 export const minimaxCodeUsageProvider: UsageProvider = {
-	id: "minimax-code",
+	id: INTL_PROVIDER,
 	fetchUsage: fetchMiniMaxCodeUsage,
-	supports: (params: UsageFetchParams) =>
-		(params.provider === "minimax-code" || params.provider === "minimax-code-cn") &&
-		params.credential.type === "api_key",
+	supports: params =>
+		params.provider === INTL_PROVIDER && params.credential.type === "api_key" && Boolean(params.credential.apiKey),
 };

package/src/usage/openai-codex.ts

@@ -1,5 +1,6 @@
 import { Buffer } from "node:buffer";
 import type {
+	CredentialRankingContext,
 	CredentialRankingStrategy,
 	UsageAmount,
 	UsageFetchContext,
@@ -275,7 +276,6 @@ function buildUsageLimit(args: {
 	window: ParsedUsageWindow;
 	accountId?: string;
 	planType?: string;
-	limitReached?: boolean;
 	nowMs: number;
 }): UsageLimit {
 	const usageWindow = buildUsageWindow(args.window, args.key, args.nowMs);
@@ -290,7 +290,16 @@ function buildUsageLimit(args: {
 		},
 		window: usageWindow,
 		amount,
-		status: buildUsageStatus(amount.usedFraction, args.limitReached),
+		// Each chat window's status reflects ONLY its own usage. The account-level
+		// `rate_limit.limit_reached` flag is intentionally not applied here: Codex
+		// returns a single shared flag for the whole account, so threading it into
+		// both the primary (5h) and secondary (weekly) windows marked a window with
+		// real headroom `exhausted` purely because a different window (or a separate
+		// metered feature) was at its limit, which over-blocked sibling accounts
+		// during credential selection. `usedFraction >= 1` already marks a window
+		// that is genuinely full; a real enforced limit not reflected in
+		// `used_percent` is caught when the live request returns usage_limit_reached.
+		status: buildUsageStatus(amount.usedFraction),
 	};
 }
 function additionalLimitSlug(args: { limitName?: string; meteredFeature?: string }): string {
@@ -320,7 +329,6 @@ function buildAdditionalUsageLimit(args: {
 	displayName: string;
 	window: ParsedUsageWindow;
 	accountId?: string;
-	limitReached?: boolean;
 	limitName?: string;
 	meteredFeature?: string;
 	nowMs: number;
@@ -340,7 +348,10 @@ function buildAdditionalUsageLimit(args: {
 		},
 		window: usageWindow,
 		amount,
-		status: buildUsageStatus(amount.usedFraction, args.limitReached),
+		// The additional meter exposes one account-level flag for both windows.
+		// Status must follow this window's own usage or a full weekly meter marks
+		// the shorter window exhausted and schedules a premature retry.
+		status: buildUsageStatus(amount.usedFraction),
 	};
 }
 
@@ -428,6 +439,9 @@ export const openaiCodexUsageProvider: UsageProvider = {
 			(isRecord(payload) && typeof payload.plan_type === "string" ? payload.plan_type : undefined);
 
 		const limits: UsageLimit[] = [];
+		const meterStates: Record<string, { allowed?: boolean; limitReached?: boolean }> = {
+			chat: { allowed: parsed?.allowed, limitReached: parsed?.limitReached },
+		};
 		if (parsed?.primary) {
 			limits.push(
 				buildUsageLimit({
@@ -435,7 +449,6 @@ export const openaiCodexUsageProvider: UsageProvider = {
 					window: parsed.primary,
 					accountId,
 					planType,
-					limitReached: parsed.limitReached,
 					nowMs,
 				}),
 			);
@@ -447,7 +460,6 @@ export const openaiCodexUsageProvider: UsageProvider = {
 					window: parsed.secondary,
 					accountId,
 					planType,
-					limitReached: parsed.limitReached,
 					nowMs,
 				}),
 			);
@@ -455,6 +467,7 @@ export const openaiCodexUsageProvider: UsageProvider = {
 		for (const extra of parsed?.additional ?? []) {
 			const slug = additionalLimitSlug({ limitName: extra.limitName, meteredFeature: extra.meteredFeature });
 			const displayName = additionalDisplayName(slug, extra.limitName);
+			meterStates[slug] = { allowed: extra.allowed, limitReached: extra.limitReached };
 			if (extra.primary) {
 				limits.push(
 					buildAdditionalUsageLimit({
@@ -463,7 +476,6 @@ export const openaiCodexUsageProvider: UsageProvider = {
 						displayName,
 						window: extra.primary,
 						accountId,
-						limitReached: extra.limitReached,
 						limitName: extra.limitName,
 						meteredFeature: extra.meteredFeature,
 						nowMs,
@@ -478,7 +490,6 @@ export const openaiCodexUsageProvider: UsageProvider = {
 						displayName,
 						window: extra.secondary,
 						accountId,
-						limitReached: extra.limitReached,
 						limitName: extra.limitName,
 						meteredFeature: extra.meteredFeature,
 						nowMs,
@@ -527,6 +538,7 @@ export const openaiCodexUsageProvider: UsageProvider = {
 				limitReached: parsed?.limitReached,
 				email,
 				accountId,
+				meterStates,
 			},
 			raw: parsed?.raw ?? payload,
 		};
@@ -537,18 +549,53 @@ export const openaiCodexUsageProvider: UsageProvider = {
 
 const FIVE_HOUR_MS = 5 * 60 * 60 * 1000;
 
+// A Codex request gates only on the chat windows it actually consumes. A
+// "-spark" model spends the separate Spark meter; every other Codex model spends
+// the 5h/weekly chat windows. Scoping the gating set this way keeps an exhausted
+// Spark meter from blocking a normal chat request (and vice versa), instead of
+// OR-ing every window and meter in the report into one provider-wide block.
+function scopeCodexLimitsForRequest(report: UsageReport, context?: CredentialRankingContext): UsageLimit[] {
+	const isSparkRequest = isCodexSparkRequest(context);
+	return report.limits.filter(limit => {
+		if (limit.id === "openai-codex:primary" || limit.id === "openai-codex:secondary") {
+			return !isSparkRequest;
+		}
+		// Additional metered features have ids of the form `openai-codex:<slug>:<key>`.
+		const slug = limit.id.split(":")[1];
+		return slug === "spark" ? isSparkRequest : false;
+	});
+}
+
+/** True when the requested model spends the separate Spark meter. */
+function isCodexSparkRequest(context?: CredentialRankingContext): boolean {
+	return (context?.modelId ?? "").toLowerCase().includes("-spark");
+}
+
 export const codexRankingStrategy: CredentialRankingStrategy = {
-	blockScope() {
-		return "shared";
+	scopeLimits: scopeCodexLimitsForRequest,
+	// A `usage_limit_reached` from a Spark request means the Spark meter is
+	// spent, not the chat windows, so the two back off under separate scopes;
+	// one shared block would let an exhausted Spark meter stop ordinary chat
+	// requests, and the reverse.
+	blockScope(context) {
+		return isCodexSparkRequest(context) ? "spark" : "chat";
+	},
+	// "shared" is the scope earlier versions persisted under, and it meant "block
+	// everything", so it stays honoured by every request and healed by
+	// reconciliation. Without a context (reconciliation) this is the full set.
+	blockScopes(context) {
+		if (!context) return ["chat", "spark", "shared"];
+		return [isCodexSparkRequest(context) ? "spark" : "chat", "shared"];
 	},
-	findWindowLimits(report) {
+	findWindowLimits(report, context) {
+		const limits = scopeCodexLimitsForRequest(report, context);
 		const findLimit = (key: "primary" | "secondary"): UsageLimit | undefined => {
-			const direct = report.limits.find(l => l.id === `openai-codex:${key}`);
+			const direct = limits.find(l => l.id === `openai-codex:${key}`);
 			if (direct) return direct;
-			const byId = report.limits.find(l => l.id.toLowerCase().includes(key));
+			const byId = 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 limits.find(l => l.scope.windowId?.toLowerCase() === windowId);
 		};
 		return { primary: findLimit("primary"), secondary: findLimit("secondary") };
 	},

package/src/usage.ts

@@ -391,6 +391,16 @@ export interface CredentialRankingStrategy {
 	 * not block unrelated families on the same OAuth credential.
 	 */
 	blockScope?(context?: CredentialRankingContext): string | undefined;
+	/**
+	 * Scopes that apply to a request, most specific first. With a context, the
+	 * request's own scope plus any legacy catch-all scope whose blocks still
+	 * apply to everything. Without one — reconciliation runs with no request —
+	 * every scope whose blocks must be healed.
+	 *
+	 * A provider that scopes backoff by model family must implement this, or a
+	 * block written under one scope is invisible to requests and to healing.
+	 */
+	blockScopes?(context?: CredentialRankingContext): string[];
 	/** Fallback window durations (ms) when limits don't specify durationMs. */
 	windowDefaults: {
 		primaryMs: number;

package/src/utils/idle-iterator.ts

@@ -68,11 +68,13 @@ export function getStreamFirstEventTimeoutMs(
  * `"0"` disable) wins outright. Otherwise the resolved idle (caller-supplied
  * `idleTimeoutMs` — which itself already encompasses per-call
  * `streamIdleTimeoutMs` or `PI_OPENAI_STREAM_IDLE_TIMEOUT_MS` resolved
- * upstream) floors the first-event budget so slow local OpenAI-compatible
- * servers are not undercut by a shorter `PI_STREAM_FIRST_EVENT_TIMEOUT_MS`
- * or the global default during prompt processing.
+ * upstream) floors the first-event budget so slow OpenAI-compatible servers
+ * are not undercut by a shorter `PI_STREAM_FIRST_EVENT_TIMEOUT_MS` or the
+ * global default during prompt processing. A zero per-provider fallback
+ * disables the first-event watchdog unless an environment override is set.
  *
- * Returns `undefined` when an explicit env knob disables the watchdog.
+ * Returns `0` when an explicit env knob or per-provider fallback disables the
+ * watchdog, preserving the sentinel through iterator timeout resolution.
  */
 export function getOpenAIStreamFirstEventTimeoutMs(
 	idleTimeoutMs?: number,
@@ -80,10 +82,10 @@ export function getOpenAIStreamFirstEventTimeoutMs(
 ): number | undefined {
 	const openAIFirstEventRaw = $env.PI_OPENAI_STREAM_FIRST_EVENT_TIMEOUT_MS;
 	if (openAIFirstEventRaw !== undefined) {
-		return normalizeIdleTimeoutMs(openAIFirstEventRaw, fallbackMs);
+		return normalizeIdleTimeoutMs(openAIFirstEventRaw, fallbackMs) ?? 0;
 	}
 	const base = normalizeIdleTimeoutMs($env.PI_STREAM_FIRST_EVENT_TIMEOUT_MS, fallbackMs);
-	if (base === undefined) return undefined;
+	if (base === undefined || base <= 0) return 0;
 	if (idleTimeoutMs === undefined || idleTimeoutMs <= 0) return base;
 	return Math.max(base, idleTimeoutMs);
 }

package/src/utils.ts

@@ -203,9 +203,12 @@ function sanitizeOpenAIResponsesHistoryItemForReplay(
 	if (item.type === "image_generation_call") return sanitizeOpenAIResponsesImageGenerationCallForReplay(item);
 	if (item.type === "reasoning") return sanitizeOpenAIResponsesReasoningItemForReplay(item);
 
-	// Provider payload stores raw output items. Computer calls retain their stable
-	// provider item ID; other replay items strip IDs and normalize call_id.
+	// Strip status only from item types whose replay input rejects output
+	// lifecycle metadata. Hosted built-in tool items require status for replay.
 	const { id: _id, ...sanitizedItem } = item;
+	if (item.type === "message" || item.type === "function_call" || item.type === "custom_tool_call") {
+		delete sanitizedItem.status;
+	}
 	if (item.type === "computer_call" && typeof item.id === "string") sanitizedItem.id = item.id;
 	if (typeof item.call_id === "string") {
 		sanitizedItem.call_id = normalizeReplayedResponsesHistoryCallId(item.call_id, normalizedCallIds);
@@ -224,9 +227,6 @@ function sanitizeOpenAIResponsesReasoningItemForReplay(item: Record<string, unkn
 	if (typeof item.encrypted_content === "string" || item.encrypted_content === null) {
 		sanitizedItem.encrypted_content = item.encrypted_content;
 	}
-	if (item.status === "in_progress" || item.status === "completed" || item.status === "incomplete") {
-		sanitizedItem.status = item.status;
-	}
 	return sanitizedItem as unknown as OpenAIResponsesReplayItem;
 }