@openclaw/codex 2026.9.4 → 2026.9.6

package/dist/{rate-limits-CBMmWBr9.js → .setup/rate-limits-CMU3DUD0.mjs}

@@ -1,32 +1,122 @@
-import { o as isJsonObject } from "./protocol-5bh1G-H7.js";
-import { asBoolean, asFiniteNumber, normalizeOptionalString, parseStrictFiniteNumber } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
+import { normalizeOptionalString, parseStrictFiniteNumber } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { z } from "zod";
 import { MAX_DATE_TIMESTAMP_MS, resolveExpiresAtMsFromEpochSeconds } from "openclaw/plugin-sdk/number-runtime";
-import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { PROVIDER_LABELS, clampPercent } from "openclaw/plugin-sdk/provider-usage";
+//#region extensions/codex/src/app-server/rate-limit-time.ts
+/** Human-readable Codex quota reset times; no account or routing decisions. */
+const ONE_SECOND_MS = 1e3;
+const ONE_MINUTE_MS = 6e4;
+const ONE_HOUR_MS = 60 * ONE_MINUTE_MS;
+const ONE_DAY_MS$1 = 24 * ONE_HOUR_MS;
+function formatCalendarResetTime(resetsAtMs, nowMs) {
+	const resetDate = new Date(resetsAtMs);
+	const resetParts = new Intl.DateTimeFormat("en-US", {
+		month: "short",
+		day: "numeric",
+		...resetDate.getFullYear() === new Date(nowMs).getFullYear() ? {} : { year: "numeric" },
+		hour: "numeric",
+		minute: "2-digit",
+		timeZoneName: "short"
+	}).formatToParts(resetDate);
+	const part = (type) => resetParts.find((entry) => entry.type === type)?.value;
+	const dateParts = [
+		part("month"),
+		part("day"),
+		part("year")
+	].filter(Boolean);
+	return [
+		dateParts.length > 1 ? `${dateParts[0]} ${dateParts.slice(1).join(", ")}` : dateParts[0],
+		"at",
+		[
+			[part("hour"), part("minute")].filter(Boolean).join(":"),
+			part("dayPeriod"),
+			part("timeZoneName")
+		].filter(Boolean).join(" ")
+	].filter(Boolean).join(" ");
+}
+function formatRelativeDuration(durationMs) {
+	const safeMs = Math.max(1e3, durationMs);
+	if (safeMs < ONE_MINUTE_MS) return `${Math.ceil(safeMs / 1e3)} seconds`;
+	if (safeMs < ONE_HOUR_MS) {
+		const minutes = Math.ceil(safeMs / ONE_MINUTE_MS);
+		return `${minutes} ${minutes === 1 ? "minute" : "minutes"}`;
+	}
+	if (safeMs < ONE_DAY_MS$1) {
+		const hours = Math.ceil(safeMs / ONE_HOUR_MS);
+		return `${hours} ${hours === 1 ? "hour" : "hours"}`;
+	}
+	const days = Math.ceil(safeMs / ONE_DAY_MS$1);
+	return `${days} ${days === 1 ? "day" : "days"}`;
+}
+function formatResetDuration(resetsAtMs, nowMs) {
+	const durationMs = Math.round(Math.max(ONE_SECOND_MS, resetsAtMs - nowMs) / ONE_SECOND_MS) * ONE_SECOND_MS;
+	const days = Math.floor(durationMs / ONE_DAY_MS$1);
+	const hours = Math.floor(durationMs % ONE_DAY_MS$1 / ONE_HOUR_MS);
+	const minutes = Math.floor(durationMs % ONE_HOUR_MS / ONE_MINUTE_MS);
+	const seconds = Math.floor(durationMs % ONE_MINUTE_MS / ONE_SECOND_MS);
+	if (days > 0) return hours > 0 ? `${days}d ${hours}h` : `${days}d`;
+	if (hours > 0) return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
+	if (minutes > 0) return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
+	return `${seconds}s`;
+}
+//#endregion
 //#region extensions/codex/src/app-server/rate-limits.ts
 /**
 * Parses Codex account rate-limit payloads into user-facing usage summaries,
 * reset hints, and enriched usage-limit error messages.
 */
 const CODEX_LIMIT_ID = "codex";
+const CODEX_RESERVE_ROUTE = "gpt-reserve";
+const CODEX_RESERVE_USAGE_NOTICE = "Luna Reserve is a separate, backend-authorized route. Ordinary Luna does not use this reserve, even with Fast off. An unused reserve does not establish eligibility or per-request billing. Ordinary usage may consume credits after included limits are reached.";
 const LIMIT_WINDOW_KEYS = ["primary", "secondary"];
-const ONE_SECOND_MS = 1e3;
-const ONE_MINUTE_MS = 6e4;
-const ONE_HOUR_MS = 60 * ONE_MINUTE_MS;
-const ONE_DAY_MS = 24 * ONE_HOUR_MS;
+const ONE_DAY_MS = 864e5;
 const DAY_WINDOW_MINUTES = 1440;
 const WEEKLY_WINDOW_MINUTES = 7 * DAY_WINDOW_MINUTES;
 const WEEKLY_RESET_GAP_MS = 3 * ONE_DAY_MS;
 const CODEX_USAGE_LIMIT_MESSAGE_PREFIX = "You've reached your Codex subscription usage limit.";
 const CODEX_USAGE_LIMIT_STATE_MISMATCH_MESSAGE = "Codex rejected the request with a usage-limit error, but its current account usage does not report an exhausted limit.";
+const optionalNumber = z.number().optional().catch(void 0);
+const optionalBoolean = z.boolean().optional().catch(void 0);
+const rateLimitWindowSchema = z.object({
+	usedPercent: optionalNumber,
+	resetsAt: optionalNumber,
+	windowDurationMins: optionalNumber
+}).transform((window) => ({
+	usedPercent: window.usedPercent,
+	resetsAtMs: resolveExpiresAtMsFromEpochSeconds(window.resetsAt, { maxMs: MAX_DATE_TIMESTAMP_MS }) ?? 0,
+	windowDurationMins: window.windowDurationMins
+})).optional().catch(void 0);
+const creditsSchema = z.object({
+	hasCredits: optionalBoolean,
+	unlimited: optionalBoolean,
+	balance: z.preprocess(parseStrictFiniteNumber, optionalNumber)
+}).optional().catch(void 0);
+const rateLimitSnapshotSchema = z.looseObject({
+	primary: rateLimitWindowSchema,
+	secondary: rateLimitWindowSchema,
+	credits: creditsSchema
+}).transform((snapshot) => ({
+	primary: snapshot.primary,
+	secondary: snapshot.secondary,
+	credits: snapshot.credits,
+	limitId: normalizeOptionalString(snapshot.limitId),
+	limitName: normalizeOptionalString(snapshot.limitName),
+	planType: normalizeOptionalString(snapshot.planType),
+	rateLimitReachedType: normalizeOptionalString(snapshot.rateLimitReachedType)
+}));
 /** Enriches Codex usage-limit failures with reset timing and recovery guidance. */
 function formatCodexUsageLimitErrorMessage(params) {
 	const message = normalizeOptionalString(params.message);
-	if (!isCodexUsageLimitError(params.codexErrorInfo)) return;
+	if (params.codexErrorInfo !== "usageLimitExceeded") return;
 	const nowMs = params.nowMs ?? Date.now();
-	const usageSummary = summarizeCodexAccountUsage(params.rateLimits, nowMs);
-	if (params.rateLimitsAuthoritative && hasCodexRateLimitSnapshots(params.rateLimits) && !usageSummary?.blocked) return [CODEX_USAGE_LIMIT_STATE_MISMATCH_MESSAGE, "Retry the request, use another Codex account if available, or switch to another configured model/provider."].join(" ");
-	const nextReset = selectBlockingRateLimitReset(params.rateLimits, nowMs) ?? (usageSummary?.blocked ? void 0 : selectNextRateLimitReset(params.rateLimits, nowMs));
+	const ordinaryUsageAllowed = readOrdinaryUsageAllowed(params.rateLimits);
+	const snapshots = collectCodexRateLimitSnapshots(params.rateLimits).filter(snapshotHasDisplayableData);
+	const usageSnapshot = snapshots.find(isCodexLimitSnapshot) ?? snapshots[0];
+	const blockingSnapshot = selectBlockingRateLimitSnapshot(snapshots, ordinaryUsageAllowed);
+	const usageSummary = usageSnapshot ? summarizeRateLimitUsage(usageSnapshot, blockingSnapshot, nowMs) : void 0;
+	if (params.rateLimitsAuthoritative && (ordinaryUsageAllowed === true && !blockingSnapshot || ordinaryUsageAllowed === void 0 && usageSummary?.blocked === false)) return [CODEX_USAGE_LIMIT_STATE_MISMATCH_MESSAGE, "Retry the request, use another Codex account if available, or switch to another configured model/provider."].join(" ");
+	const nextReset = (blockingSnapshot ? selectSnapshotBlockingReset(blockingSnapshot, nowMs) : void 0) ?? (ordinaryUsageAllowed === void 0 && !usageSummary?.blocked ? selectNextRateLimitReset(params.rateLimits, nowMs) : void 0);
 	const parts = [CODEX_USAGE_LIMIT_MESSAGE_PREFIX];
 	let recoveryAction = "Wait until Codex becomes available";
 	if (nextReset) {
@@ -55,7 +145,8 @@ function summarizeCodexRateLimits(value, nowMs = Date.now()) {
 	const snapshots = collectCodexRateLimitSnapshots(value).filter(snapshotHasDisplayableData);
 	if (snapshots.length === 0) return;
 	const summaries = snapshots.slice(0, 4).map((snapshot) => summarizeRateLimitSnapshot(snapshot, nowMs)).filter((summary) => summary !== void 0);
-	return summaries.length > 0 ? summaries.join("; ") : void 0;
+	if (summaries.length === 0) return;
+	return [summaries.join("; "), reserveUsageNotice(snapshots)].filter(Boolean).join(". ");
 }
 /** Returns true when a value contains any recognizable Codex rate-limit snapshots. */
 function hasCodexRateLimitSnapshots(value) {
@@ -74,11 +165,17 @@ function resolveCodexUsageLimitResetAtMs(value, nowMs = Date.now()) {
 }
 /** Summarizes account availability, blocking reason, and reset time from rate-limit data. */
 function summarizeCodexAccountUsage(value, nowMs = Date.now()) {
-	const snapshots = collectCodexRateLimitSnapshots(value).filter(snapshotHasDisplayableData);
-	if (snapshots.length === 0) return;
-	const usageSnapshot = snapshots.find(isCodexLimitSnapshot) ?? expectDefined(snapshots[0], "displayable Codex rate-limit snapshot");
-	const blockedSnapshots = snapshots.filter(snapshotHasLimitBlock);
-	const blockingSnapshot = blockedSnapshots.find(isCodexLimitSnapshot) ?? blockedSnapshots[0] ?? void 0;
+	const ordinaryUsageAllowed = readOrdinaryUsageAllowed(value);
+	if (ordinaryUsageAllowed === null) return;
+	const snapshot = collectCodexRateLimitSnapshots(value).find(isCodexLimitSnapshot);
+	if (ordinaryUsageAllowed !== void 0) return {
+		usageLine: snapshot ? formatUsageLine(snapshot) : void 0,
+		blocked: !ordinaryUsageAllowed,
+		...!ordinaryUsageAllowed ? { blockingReason: "Codex usage limit is reached" } : {}
+	};
+	return snapshot && snapshotHasDisplayableData(snapshot) ? summarizeRateLimitUsage(snapshot, snapshotHasLimitBlock(snapshot) ? snapshot : void 0, nowMs) : void 0;
+}
+function summarizeRateLimitUsage(usageSnapshot, blockingSnapshot, nowMs) {
 	const blockingEntries = blockingSnapshot ? readWindowEntries(blockingSnapshot) : [];
 	const blockingWindowEntry = selectBlockingWindowEntry(blockingEntries, nowMs);
 	const blockingWindow = blockingWindowEntry?.window;
@@ -98,69 +195,76 @@ function summarizeCodexAccountUsage(value, nowMs = Date.now()) {
 	};
 }
 /** Converts Codex app-server rate-limit payloads into OpenAI/Codex usage windows. */
-function buildCodexAppServerUsageSnapshot(value) {
-	const snapshot = selectCodexProviderUsageSnapshot(value);
+function buildCodexAppServerUsageSnapshot(value, options = {}) {
+	const snapshots = collectCodexRateLimitSnapshots(value);
+	const snapshot = snapshots.find(isCodexLimitSnapshot) ?? snapshots[0];
 	const entries = snapshot ? readWindowEntries(snapshot) : [];
 	const windows = entries.map((entry) => readProviderUsageWindow(entry, entries)).filter((window) => Boolean(window));
-	return {
+	const summary = reserveUsageNotice(snapshots);
+	const result = {
+		...summary ? { summary } : {},
 		provider: "openai",
 		displayName: PROVIDER_LABELS.openai,
 		windows,
 		...snapshot ? { plan: resolveCodexProviderUsagePlan(snapshot) } : {}
 	};
-}
-function isCodexUsageLimitError(codexErrorInfo) {
-	if (codexErrorInfo === "usageLimitExceeded") return true;
-	if (typeof codexErrorInfo === "string") {
-		if (codexErrorInfo.replace(/[_\s-]/gu, "").toLowerCase() === "usagelimitexceeded") return true;
+	if (options.accountDetails && snapshot) {
+		result.plan = snapshot.planType;
+		for (const extra of snapshots) {
+			if (extra === snapshot) continue;
+			const extraEntries = readWindowEntries(extra);
+			for (const entry of extraEntries) {
+				const window = readProviderUsageWindow(entry, extraEntries);
+				if (window) windows.push({
+					...window,
+					groupLabel: formatLimitLabel(extra)
+				});
+			}
+		}
+		const credits = snapshot.credits;
+		const balance = credits?.balance;
+		if (balance !== void 0 && balance >= 0 && credits?.unlimited !== true) result.billing = [{
+			type: "balance",
+			amount: balance,
+			unit: "credits"
+		}];
 	}
-	return false;
+	return result;
 }
 function selectNextRateLimitReset(value, nowMs) {
-	const futureWindows = collectCodexRateLimitSnapshots(value).flatMap((snapshot) => LIMIT_WINDOW_KEYS.flatMap((key) => readRateLimitWindow(snapshot, key) ?? [])).filter((window) => window.resetsAtMs > nowMs);
+	const futureWindows = collectCodexRateLimitSnapshots(value).flatMap((snapshot) => LIMIT_WINDOW_KEYS.flatMap((key) => snapshot[key] ?? [])).filter((window) => window.resetsAtMs > nowMs);
 	if (futureWindows.length === 0) return;
 	const exhaustedWindows = futureWindows.filter((window) => window.usedPercent !== void 0 && window.usedPercent >= 100);
 	return (exhaustedWindows.length > 0 ? exhaustedWindows : futureWindows).toSorted((left, right) => left.resetsAtMs - right.resetsAtMs)[0];
 }
 function selectBlockingRateLimitReset(value, nowMs) {
-	const blockedSnapshots = collectCodexRateLimitSnapshots(value).filter(snapshotHasLimitBlock);
-	const blockingSnapshot = blockedSnapshots.find(isCodexLimitSnapshot) ?? blockedSnapshots[0] ?? void 0;
+	const blockingSnapshot = selectBlockingRateLimitSnapshot(collectCodexRateLimitSnapshots(value), readOrdinaryUsageAllowed(value));
 	return blockingSnapshot ? selectSnapshotBlockingReset(blockingSnapshot, nowMs) : void 0;
 }
+function selectBlockingRateLimitSnapshot(snapshots, ordinaryUsageAllowed) {
+	const blockedSnapshots = snapshots.filter((snapshot) => snapshotHasLimitBlock(snapshot) && (ordinaryUsageAllowed !== true && ordinaryUsageAllowed !== null || !isCodexLimitSnapshot(snapshot)));
+	return blockedSnapshots.find(isCodexLimitSnapshot) ?? blockedSnapshots[0];
+}
 function summarizeRateLimitSnapshot(snapshot, nowMs) {
 	const label = formatLimitLabel(snapshot);
 	const windows = LIMIT_WINDOW_KEYS.flatMap((key) => {
-		const window = readRateLimitWindow(snapshot, key);
+		const window = snapshot[key];
 		return window ? [formatRateLimitWindow(key, window, nowMs)] : [];
 	});
-	const reachedType = normalizeOptionalString(snapshot.rateLimitReachedType) ?? normalizeOptionalString(snapshot.rate_limit_reached_type);
+	const reachedType = snapshot.rateLimitReachedType;
 	const suffix = reachedType ? ` (${formatReachedType(reachedType)})` : "";
 	if (windows.length > 0) return `${label}: ${windows.join(" · ")}${suffix}`;
 	if (reachedType) return `${label}: ${formatReachedType(reachedType)}`;
 }
 function collectCodexRateLimitSnapshots(value) {
-	const snapshots = [];
-	collectRateLimitSnapshots(value, snapshots, /* @__PURE__ */ new Set());
-	return snapshots;
-}
-function collectRateLimitSnapshots(value, snapshots, seen) {
-	if (Array.isArray(value)) {
-		for (const entry of value) collectRateLimitSnapshots(entry, snapshots, seen);
-		return;
-	}
-	if (!isJsonObject(value)) return;
-	if (isRateLimitSnapshot(value)) {
-		addRateLimitSnapshot(value, snapshots, seen);
-		return;
-	}
+	if (!isJsonObject(value)) return [];
+	if (isRateLimitSnapshot(value)) return [rateLimitSnapshotSchema.parse(value)];
 	const byLimitId = value.rateLimitsByLimitId;
-	if (isJsonObject(byLimitId)) for (const key of sortedRateLimitKeys(Object.keys(byLimitId))) collectRateLimitSnapshots(byLimitId[key], snapshots, seen);
-	const snakeByLimitId = value.rate_limits_by_limit_id;
-	if (isJsonObject(snakeByLimitId)) for (const key of sortedRateLimitKeys(Object.keys(snakeByLimitId))) collectRateLimitSnapshots(snakeByLimitId[key], snapshots, seen);
-	collectRateLimitSnapshots(value.rateLimits, snapshots, seen);
-	collectRateLimitSnapshots(value.rate_limits, snapshots, seen);
-	collectRateLimitSnapshots(value.data, snapshots, seen);
-	collectRateLimitSnapshots(value.items, snapshots, seen);
+	return (isJsonObject(byLimitId) ? sortedRateLimitKeys(Object.keys(byLimitId)).map((key) => byLimitId[key]) : [value.rateLimits]).filter(isJsonObject).filter(isRateLimitSnapshot).map((snapshot) => rateLimitSnapshotSchema.parse(snapshot));
+}
+function readOrdinaryUsageAllowed(value) {
+	const allowed = isJsonObject(value) ? value.ordinaryUsageAllowed : void 0;
+	return allowed === null || typeof allowed === "boolean" ? allowed : void 0;
 }
 function sortedRateLimitKeys(keys) {
 	return keys.toSorted((left, right) => {
@@ -169,38 +273,11 @@ function sortedRateLimitKeys(keys) {
 		return left.localeCompare(right);
 	});
 }
-function addRateLimitSnapshot(snapshot, snapshots, seen) {
-	const signature = [
-		normalizeOptionalString(snapshot.limitId) ?? normalizeOptionalString(snapshot.limit_id) ?? "",
-		normalizeOptionalString(snapshot.limitName) ?? normalizeOptionalString(snapshot.limit_name) ?? "",
-		formatWindowSignature(snapshot.primary),
-		formatWindowSignature(snapshot.secondary)
-	].join("|");
-	if (seen.has(signature)) return;
-	seen.add(signature);
-	snapshots.push(snapshot);
-}
 function isRateLimitSnapshot(value) {
-	return isJsonObject(value.primary) || isJsonObject(value.secondary) || value.rateLimitReachedType !== void 0 || value.rate_limit_reached_type !== void 0 || value.limitId !== void 0 || value.limit_id !== void 0 || value.limitName !== void 0 || value.limit_name !== void 0;
-}
-function readRateLimitWindow(snapshot, key) {
-	const window = snapshot[key];
-	if (!isJsonObject(window)) return;
-	const resetsAt = asFiniteNumber(window.resetsAt) ?? asFiniteNumber(window.resets_at);
-	return {
-		resetsAtMs: resolveExpiresAtMsFromEpochSeconds(resetsAt, { maxMs: MAX_DATE_TIMESTAMP_MS }) ?? 0,
-		...readOptionalNumberField(window, "usedPercent", "used_percent"),
-		...readOptionalNumberField(window, "windowDurationMins", "window_duration_mins", "windowMinutes", "window_minutes")
-	};
+	return isJsonObject(value.primary) || isJsonObject(value.secondary) || value.rateLimitReachedType !== void 0 || value.limitId !== void 0 || value.limitName !== void 0;
 }
 function snapshotHasDisplayableData(snapshot) {
-	if (normalizeOptionalString(snapshot.rateLimitReachedType) ?? normalizeOptionalString(snapshot.rate_limit_reached_type)) return true;
-	return readWindowEntries(snapshot).some((entry) => entry.window.usedPercent !== void 0 || entry.window.resetsAtMs > 0);
-}
-function readOptionalNumberField(record, ...keys) {
-	const value = keys.map((key) => asFiniteNumber(record[key])).find((entry) => entry !== void 0);
-	if (value === void 0) return {};
-	return keys.some((key) => key.toLowerCase().includes("window")) ? { windowDurationMins: value } : { usedPercent: value };
+	return Boolean(snapshot.rateLimitReachedType) || readWindowEntries(snapshot).some((entry) => entry.window.usedPercent !== void 0 || entry.window.resetsAtMs > 0);
 }
 function formatRateLimitWindow(key, window, nowMs) {
 	return `${key} ${formatRateLimitWindowDetails(window, nowMs)}`;
@@ -208,8 +285,15 @@ function formatRateLimitWindow(key, window, nowMs) {
 function formatRateLimitWindowDetails(window, nowMs) {
 	return `${window.usedPercent === void 0 ? "usage unknown" : `${Math.max(0, 100 - Math.round(window.usedPercent))}% left`}${window.resetsAtMs > nowMs ? ` ⏱${formatResetDuration(window.resetsAtMs, nowMs)}` : ""}`;
 }
+function reserveUsageNotice(snapshots) {
+	return snapshots.some(isReserveSnapshot) ? CODEX_RESERVE_USAGE_NOTICE : void 0;
+}
+function isReserveSnapshot(snapshot) {
+	return snapshot.limitName === CODEX_RESERVE_ROUTE || snapshot.limitId === CODEX_RESERVE_ROUTE;
+}
 function formatLimitLabel(snapshot) {
-	const label = normalizeOptionalString(snapshot.limitName) ?? normalizeOptionalString(snapshot.limit_name) ?? normalizeOptionalString(snapshot.limitId) ?? normalizeOptionalString(snapshot.limit_id);
+	if (isReserveSnapshot(snapshot)) return "Luna Reserve (separate route)";
+	const label = snapshot.limitName ?? snapshot.limitId;
 	if (!label || label === CODEX_LIMIT_ID) return "Codex";
 	return label.replace(/[_-]+/gu, " ").replace(/\s+/gu, " ").trim();
 }
@@ -223,15 +307,10 @@ function formatAccountResetTime(resetsAtMs, nowMs) {
 	return `${formatCalendarResetTime(resetsAtMs, nowMs)} (in ${formatRelativeDuration(resetsAtMs - nowMs)})`;
 }
 function snapshotHasLimitBlock(snapshot) {
-	return Boolean(normalizeOptionalString(snapshot.rateLimitReachedType) ?? normalizeOptionalString(snapshot.rate_limit_reached_type) ?? readWindowEntries(snapshot).some((entry) => entry.window.usedPercent !== void 0 && entry.window.usedPercent >= 100));
+	return Boolean(snapshot.rateLimitReachedType ?? readWindowEntries(snapshot).some((entry) => entry.window.usedPercent !== void 0 && entry.window.usedPercent >= 100));
 }
 function isCodexLimitSnapshot(snapshot) {
-	const id = normalizeOptionalString(snapshot.limitId) ?? normalizeOptionalString(snapshot.limit_id);
-	return !id || id === CODEX_LIMIT_ID;
-}
-function selectCodexProviderUsageSnapshot(value) {
-	const snapshots = collectCodexRateLimitSnapshots(value);
-	return snapshots.find(isCodexLimitSnapshot) ?? snapshots[0];
+	return !snapshot.limitId || snapshot.limitId === CODEX_LIMIT_ID;
 }
 function readProviderUsageWindow(entry, entries) {
 	const { window } = entry;
@@ -252,16 +331,15 @@ function formatProviderUsageWindowLabel(entry, entries) {
 	return entry.key === "primary" ? "Short" : "Long";
 }
 function resolveCodexProviderUsagePlan(snapshot) {
-	const plan = normalizeOptionalString(snapshot.planType) ?? normalizeOptionalString(snapshot.plan_type);
-	const creditSummary = formatCodexCreditSummary(isJsonObject(snapshot.credits) ? snapshot.credits : void 0);
+	const plan = snapshot.planType;
+	const creditSummary = formatCodexCreditSummary(snapshot.credits);
 	if (!creditSummary) return plan;
 	return plan ? `${plan} (${creditSummary})` : creditSummary;
 }
 function formatCodexCreditSummary(credits) {
-	if (!credits) return;
-	if ((asBoolean(credits.hasCredits) ?? asBoolean(credits.has_credits)) === false) return;
-	if (asBoolean(credits.unlimited)) return "Unlimited credits";
-	const balance = typeof credits.balance === "string" ? parseStrictFiniteNumber(credits.balance) : asFiniteNumber(credits.balance);
+	if (!credits || credits.hasCredits === false) return;
+	if (credits.unlimited) return "Unlimited credits";
+	const balance = credits.balance;
 	if (balance === void 0 || balance <= 0) return;
 	const roundedBalance = Math.round(balance);
 	return roundedBalance > 0 ? `${roundedBalance} credits` : void 0;
@@ -285,7 +363,7 @@ function selectBlockingWindowEntry(entries, nowMs) {
 }
 function readWindowEntries(snapshot) {
 	return LIMIT_WINDOW_KEYS.flatMap((key) => {
-		const window = readRateLimitWindow(snapshot, key);
+		const window = snapshot[key];
 		return window ? [{
 			key,
 			window
@@ -319,61 +397,6 @@ function hasWeeklySecondaryResetCadence(entry, entries) {
 	const primaryResetMs = entries.find((candidate) => candidate.key === "primary")?.window.resetsAtMs;
 	return typeof primaryResetMs === "number" && primaryResetMs > 0 && entry.window.resetsAtMs > 0 && entry.window.resetsAtMs - primaryResetMs >= WEEKLY_RESET_GAP_MS;
 }
-function formatCalendarResetTime(resetsAtMs, nowMs) {
-	const resetDate = new Date(resetsAtMs);
-	const resetParts = new Intl.DateTimeFormat("en-US", {
-		month: "short",
-		day: "numeric",
-		...resetDate.getFullYear() === new Date(nowMs).getFullYear() ? {} : { year: "numeric" },
-		hour: "numeric",
-		minute: "2-digit",
-		timeZoneName: "short"
-	}).formatToParts(resetDate);
-	const part = (type) => resetParts.find((entry) => entry.type === type)?.value;
-	const dateParts = [
-		part("month"),
-		part("day"),
-		part("year")
-	].filter(Boolean);
-	return [
-		dateParts.length > 1 ? `${dateParts[0]} ${dateParts.slice(1).join(", ")}` : dateParts[0],
-		"at",
-		[
-			[part("hour"), part("minute")].filter(Boolean).join(":"),
-			part("dayPeriod"),
-			part("timeZoneName")
-		].filter(Boolean).join(" ")
-	].filter(Boolean).join(" ");
-}
-function formatRelativeDuration(durationMs) {
-	const safeMs = Math.max(1e3, durationMs);
-	if (safeMs < ONE_MINUTE_MS) return `${Math.ceil(safeMs / 1e3)} seconds`;
-	if (safeMs < ONE_HOUR_MS) {
-		const minutes = Math.ceil(safeMs / ONE_MINUTE_MS);
-		return `${minutes} ${minutes === 1 ? "minute" : "minutes"}`;
-	}
-	if (safeMs < ONE_DAY_MS) {
-		const hours = Math.ceil(safeMs / ONE_HOUR_MS);
-		return `${hours} ${hours === 1 ? "hour" : "hours"}`;
-	}
-	const days = Math.ceil(safeMs / ONE_DAY_MS);
-	return `${days} ${days === 1 ? "day" : "days"}`;
-}
-function formatResetDuration(resetsAtMs, nowMs) {
-	const durationMs = Math.round(Math.max(ONE_SECOND_MS, resetsAtMs - nowMs) / ONE_SECOND_MS) * ONE_SECOND_MS;
-	const days = Math.floor(durationMs / ONE_DAY_MS);
-	const hours = Math.floor(durationMs % ONE_DAY_MS / ONE_HOUR_MS);
-	const minutes = Math.floor(durationMs % ONE_HOUR_MS / ONE_MINUTE_MS);
-	const seconds = Math.floor(durationMs % ONE_MINUTE_MS / ONE_SECOND_MS);
-	if (days > 0) return hours > 0 ? `${days}d ${hours}h` : `${days}d`;
-	if (hours > 0) return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
-	if (minutes > 0) return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
-	return `${seconds}s`;
-}
-function formatWindowSignature(value) {
-	if (!isJsonObject(value)) return "";
-	return `${asFiniteNumber(value.usedPercent) ?? asFiniteNumber(value.used_percent) ?? ""}:${asFiniteNumber(value.resetsAt) ?? asFiniteNumber(value.resets_at) ?? ""}`;
-}
 function extractCodexRetryHint(message) {
 	if (!message) return;
 	const tryAgainAt = /\btry again\s+(at\s+[^.!?\n]+)(?:[.!?]|$)/iu.exec(message);