@oh-my-pi/pi-ai 18.13.0 → 18.13.1

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## [Unreleased]
 
+## [18.13.1] - 2026-10-27
+
+### Fixed
+
+- Codex accounts whose spend cap is used up are no longer picked through credit overage or from usage cached before the upgrade ([#16973](https://github.com/can1357/oh-my-pi/pull/16973) by [@DusKing1](https://github.com/DusKing1))
+- Fixed Codex capacity 429s (`turn_rate_limit_exceeded`, "Codex is at capacity") reporting "Try again in ~N min" from the plan's usage-window reset, which made retries wait hours instead of the response's Retry-After ([#17087](https://github.com/can1357/oh-my-pi/pull/17087) by [@H4vC](https://github.com/H4vC))
+
 ## [18.13.0] - 2026-10-26
 
 ### Breaking Changes

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-ai",
-	"version": "18.13.0",
+	"version": "18.13.1",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"keywords": [
 		"ai",
@@ -155,11 +155,11 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.13.0",
-		"@oh-my-pi/pi-catalog": "18.13.0",
-		"@oh-my-pi/pi-natives": "18.13.0",
-		"@oh-my-pi/pi-utils": "18.13.0",
-		"@oh-my-pi/pi-wire": "18.13.0"
+		"@oh-my-pi/omptype": "18.13.1",
+		"@oh-my-pi/pi-catalog": "18.13.1",
+		"@oh-my-pi/pi-natives": "18.13.1",
+		"@oh-my-pi/pi-utils": "18.13.1",
+		"@oh-my-pi/pi-wire": "18.13.1"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/providers/openai-codex/response-handler.ts

@@ -66,15 +66,28 @@ export async function parseCodexError(response: Response): Promise<CodexErrorInf
 
 		const code = String((err as { code?: string; type?: string }).code ?? (err as { type?: string }).type ?? "");
 		errorCode = code || undefined;
-		const resetsAt = (err as { resets_at?: number }).resets_at ?? primary.resets_at ?? secondary.resets_at;
-		const mins = resetsAt ? Math.max(0, Math.round((resetsAt * 1000 - Date.now()) / 60000)) : undefined;
+		const errResetsAt = typeof err.resets_at === "number" ? err.resets_at : undefined;
+		const minutesUntil = (resetsAt: number | undefined): number | undefined =>
+			resetsAt ? Math.max(0, Math.round((resetsAt * 1000 - Date.now()) / 60000)) : undefined;
 
 		if (/usage_limit_reached|usage_not_included/i.test(code)) {
 			const planType = (err as { plan_type?: string }).plan_type;
 			const plan = planType ? ` (${String(planType).toLowerCase()} plan)` : "";
+			const mins = minutesUntil(errResetsAt ?? primary.resets_at ?? secondary.resets_at);
 			const when = mins !== undefined ? ` Try again in ~${mins} min.` : "";
 			friendlyMessage = `You have hit your ChatGPT usage limit${plan}.${when}`.trim();
 		} else if (/rate_limit_exceeded/i.test(code) || response.status === 429) {
+			// A rate limit (e.g. `turn_rate_limit_exceeded`, "Codex is at capacity")
+			// is not the plan window: a window with headroom would claim an
+			// hours-long wait that outranks the response's real Retry-After. Only
+			// the error's own `resets_at` or an exhausted window's reset applies;
+			// with both windows spent, the later reset is the one that unblocks.
+			let exhaustedResetsAt: number | undefined;
+			for (const window of [primary, secondary]) {
+				if (window.used_percent === undefined || window.used_percent < 100 || !window.resets_at) continue;
+				exhaustedResetsAt = Math.max(exhaustedResetsAt ?? 0, window.resets_at);
+			}
+			const mins = minutesUntil(errResetsAt ?? exhaustedResetsAt);
 			const when = mins !== undefined ? ` Try again in ~${mins} min.` : "";
 			friendlyMessage = `ChatGPT rate limit exceeded.${when}`.trim();
 		}

package/src/usage/openai-codex.ts

@@ -252,14 +252,22 @@ function parseAdditionalRateLimit(payload: unknown): ParsedAdditionalUsage | nul
  * not plan exhaustion is left alone for the same reason: credits answer
  * "allowance spent", not "request refused".
  */
-function hasPlanCreditOverage(payload: Record<string, unknown>, planLimitReached: boolean | undefined): boolean {
+function hasPlanCreditOverage(
+	payload: Record<string, unknown>,
+	planLimitReached: boolean | undefined,
+	spendCap: ParsedSpendCap | undefined,
+): boolean {
 	if (planLimitReached !== true) return false;
 	const credits = isRecord(payload.credits) ? payload.credits : undefined;
 	if (!credits) return false;
 	if (credits.unlimited !== true && credits.has_credits !== true) return false;
 	if (credits.overage_limit_reached === true) return false;
 	const spendControl = isRecord(payload.spend_control) ? payload.spend_control : undefined;
-	return spendControl?.reached !== true;
+	if (spendControl?.reached === true) return false;
+	// Without an explicit verdict, a spend cap whose counters show no headroom
+	// cannot fund overage either.
+	if (spendCap && spendCap.reached === undefined && (spendCap.usedFraction ?? 0) >= 1) return false;
+	return true;
 }
 
 function parseSpendCap(payload: Record<string, unknown>): ParsedSpendCap | undefined {
@@ -272,13 +280,16 @@ function parseSpendCap(payload: Record<string, unknown>): ParsedSpendCap | undef
 	const remaining = toNumber(individual.remaining);
 	const usedPercent = toNumber(individual.used_percent);
 	// The backend rounds `used_percent` to an integer; the absolute amounts
-	// keep sub-percent precision when both are present.
+	// keep sub-percent precision when both are present. A bare `remaining`
+	// of zero still proves the cap has no headroom.
 	const rawFraction =
 		used !== undefined && limit !== undefined && limit > 0
 			? used / limit
 			: usedPercent !== undefined
 				? usedPercent / 100
-				: undefined;
+				: remaining !== undefined && remaining <= 0
+					? 1
+					: undefined;
 	if (used === undefined && limit === undefined && remaining === undefined && rawFraction === undefined) {
 		return undefined;
 	}
@@ -316,7 +327,7 @@ function parseUsagePayload(payload: unknown): ParsedUsage | null {
 		secondary: rateLimit ? parseUsageWindow(rateLimit.secondary_window) : undefined,
 		additional,
 		...(spendCap ? { spendCap } : {}),
-		creditOverage: hasPlanCreditOverage(payload, planLimitReached),
+		creditOverage: hasPlanCreditOverage(payload, planLimitReached, spendCap),
 		raw: payload as CodexUsagePayload,
 	};
 	if (
@@ -602,6 +613,8 @@ function buildPlanMeterState(
 
 export const openaiCodexUsageProvider: UsageProvider = {
 	id: "openai-codex",
+	// v1: credit-billed seats gained the spend-cap limit; retire their limitless reports.
+	cacheVersion: 1,
 	supports(params: UsageFetchParams): boolean {
 		return params.provider === "openai-codex" && params.credential.type === "oauth";
 	},