@oh-my-pi/pi-ai 12.14.2 → 12.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-ai",
-	"version": "12.14.2",
+	"version": "12.15.0",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -63,7 +63,7 @@
 		"@connectrpc/connect-node": "^2.1.1",
 		"@google/genai": "^1.41.0",
 		"@mistralai/mistralai": "^1.14.0",
-		"@oh-my-pi/pi-utils": "12.14.2",
+		"@oh-my-pi/pi-utils": "12.15.0",
 		"@sinclair/typebox": "^0.34.48",
 		"@smithy/node-http-handler": "^4.4.10",
 		"ajv": "^8.18.0",

package/src/providers/anthropic.ts

@@ -629,6 +629,7 @@ function createClient(
 		baseURL: config.baseURL,
 		defaultHeaders: config.defaultHeaders,
 		dangerouslyAllowBrowser: config.dangerouslyAllowBrowser,
+		maxRetries: 5,
 	});
 
 	return { client, isOAuthToken: config.isOAuthToken };

package/src/providers/azure-openai-responses.ts

@@ -424,6 +424,7 @@ function createClient(model: Model<"azure-openai-responses">, apiKey: string, op
 		apiKey,
 		apiVersion,
 		dangerouslyAllowBrowser: true,
+		maxRetries: 5,
 		defaultHeaders: headers,
 		baseURL: baseUrl,
 	});

package/src/providers/google-gemini-cli.ts

@@ -99,6 +99,7 @@ const MAX_RETRIES = 3;
 const BASE_DELAY_MS = 1000;
 const MAX_EMPTY_STREAM_RETRIES = 2;
 const EMPTY_STREAM_BASE_DELAY_MS = 500;
+const RATE_LIMIT_BUDGET_MS = 5 * 60 * 1000;
 const CLAUDE_THINKING_BETA_HEADER = "interleaved-thinking-2025-05-14";
 
 /**
@@ -360,8 +361,9 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 			let response: Response | undefined;
 			let lastError: Error | undefined;
 			let requestUrl: string | undefined;
+			let rateLimitTimeSpent = 0;
 
-			for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+			for (let attempt = 0; ; attempt++) {
 				if (options?.signal?.aborted) {
 					throw new Error("Request was aborted");
 				}
@@ -382,13 +384,25 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 
 					const errorText = await response.text();
 
-					// Check if retryable
-					if (attempt < MAX_RETRIES && isRetryableError(response.status, errorText)) {
-						// Use server-provided delay or exponential backoff
+					// Handle 429 rate limits with time budget
+					if (response.status === 429) {
+						const serverDelay = extractRetryDelay(errorText, response);
+						if (serverDelay && rateLimitTimeSpent + serverDelay <= RATE_LIMIT_BUDGET_MS) {
+							rateLimitTimeSpent += serverDelay;
+							await abortableSleep(serverDelay, options?.signal);
+							continue;
+						}
+						// Fallback: use exponential backoff if no server delay, up to MAX_RETRIES
+						if (!serverDelay && attempt < MAX_RETRIES) {
+							await abortableSleep(BASE_DELAY_MS * 2 ** attempt, options?.signal);
+							continue;
+						}
+					} else if (attempt < MAX_RETRIES && isRetryableError(response.status, errorText)) {
+						// Non-429 retryable errors use standard attempt cap
 						const serverDelay = extractRetryDelay(errorText, response);
 						const delayMs = serverDelay ?? BASE_DELAY_MS * 2 ** attempt;
 
-						// Check if server delay exceeds max allowed (default: 60s)
+						// Check if server delay exceeds max allowed (default: 60s) for non-429 errors
 						const maxDelayMs = options?.maxRetryDelayMs ?? 60000;
 						if (maxDelayMs > 0 && serverDelay && serverDelay > maxDelayMs) {
 							const delaySeconds = Math.ceil(serverDelay / 1000);
@@ -401,7 +415,7 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 						continue;
 					}
 
-					// Not retryable or max retries exceeded
+					// Not retryable or budget exceeded
 					throw new Error(`Cloud Code Assist API error (${response.status}): ${extractErrorMessage(errorText)}`);
 				} catch (error) {
 					// Check for abort - fetch throws AbortError, our code throws "Request was aborted"

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

@@ -47,11 +47,14 @@ export async function parseCodexError(response: Response): Promise<CodexErrorInf
 		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;
 
-		if (/usage_limit_reached|usage_not_included|rate_limit_exceeded/i.test(code) || response.status === 429) {
+		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 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) {
+			const when = mins !== undefined ? ` Try again in ~${mins} min.` : "";
+			friendlyMessage = `ChatGPT rate limit exceeded.${when}`.trim();
 		}
 
 		const errMessage = (err as { message?: string }).message;

package/src/providers/openai-codex-responses.ts

@@ -1377,16 +1377,20 @@ function logCodexDebug(message: string, details?: Record<string, unknown>): void
 	console.error(`[codex] ${message}`);
 }
 
-function getRetryDelayMs(response: Response | null, attempt: number, errorBody?: string): number {
+function getRetryDelayMs(
+	response: Response | null,
+	attempt: number,
+	errorBody?: string,
+): { delay: number; serverProvided: boolean } {
 	const retryAfter = response?.headers?.get("retry-after") || null;
 	if (retryAfter) {
 		const seconds = Number(retryAfter);
 		if (Number.isFinite(seconds)) {
-			return Math.max(0, seconds * 1000);
+			return { delay: Math.max(0, seconds * 1000), serverProvided: true };
 		}
 		const parsedDate = Date.parse(retryAfter);
 		if (!Number.isNaN(parsedDate)) {
-			return Math.max(0, parsedDate - Date.now());
+			return { delay: Math.max(0, parsedDate - Date.now()), serverProvided: true };
 		}
 	}
 	// Parse retry delay from error body (e.g., "Please try again in 225ms" or "Please try again in 1.5s")
@@ -1394,28 +1398,41 @@ function getRetryDelayMs(response: Response | null, attempt: number, errorBody?:
 		const msMatch = /try again in\s+(\d+(?:\.\d+)?)\s*ms/i.exec(errorBody);
 		if (msMatch) {
 			const ms = Number(msMatch[1]);
-			if (Number.isFinite(ms)) return Math.max(ms, 100);
+			if (Number.isFinite(ms)) return { delay: Math.max(ms, 100), serverProvided: true };
 		}
 		const sMatch = /try again in\s+(\d+(?:\.\d+)?)\s*s(?:ec)?/i.exec(errorBody);
 		if (sMatch) {
 			const s = Number(sMatch[1]);
-			if (Number.isFinite(s)) return Math.max(s * 1000, 100);
+			if (Number.isFinite(s)) return { delay: Math.max(s * 1000, 100), serverProvided: true };
 		}
 	}
-	return CODEX_RETRY_DELAY_MS * (attempt + 1);
+	return { delay: CODEX_RETRY_DELAY_MS * (attempt + 1), serverProvided: false };
 }
+/** Max total time to spend retrying 429s with server-provided delays (5 minutes). */
+const CODEX_RATE_LIMIT_BUDGET_MS = 5 * 60 * 1000;
+
 async function fetchWithRetry(url: string, init: RequestInit, signal?: AbortSignal): Promise<Response> {
 	let attempt = 0;
+	let rateLimitTimeSpent = 0;
 	while (true) {
 		try {
 			const response = await fetch(url, { ...init, signal: signal ?? init.signal });
-			if (!CODEX_RETRYABLE_STATUS.has(response.status) || attempt >= CODEX_MAX_RETRIES) {
+			if (!CODEX_RETRYABLE_STATUS.has(response.status)) {
 				return response;
 			}
 			if (signal?.aborted) return response;
 			// Read error body for retry delay parsing
 			const errorBody = await response.text();
-			const delay = getRetryDelayMs(response, attempt, errorBody);
+			const { delay, serverProvided } = getRetryDelayMs(response, attempt, errorBody);
+			// For 429s with a server-provided delay, use a time budget instead of attempt count
+			if (response.status === 429 && serverProvided) {
+				if (rateLimitTimeSpent + delay > CODEX_RATE_LIMIT_BUDGET_MS) {
+					return response;
+				}
+				rateLimitTimeSpent += delay;
+			} else if (attempt >= CODEX_MAX_RETRIES) {
+				return response;
+			}
 			await abortableSleep(delay, signal);
 		} catch (error) {
 			if (attempt >= CODEX_MAX_RETRIES || signal?.aborted) {

package/src/providers/openai-completions.ts

@@ -480,6 +480,7 @@ async function createClient(
 		apiKey,
 		baseURL: model.baseUrl,
 		dangerouslyAllowBrowser: true,
+		maxRetries: 5,
 		defaultHeaders: headers,
 	});
 }

package/src/providers/openai-responses.ts

@@ -397,6 +397,7 @@ function createClient(
 		apiKey,
 		baseURL: model.baseUrl,
 		dangerouslyAllowBrowser: true,
+		maxRetries: 5,
 		defaultHeaders: headers,
 	});
 }

package/src/utils/oauth/index.ts

@@ -380,7 +380,7 @@ export async function getOAuthApiKey(
 	if (Date.now() >= creds.expires) {
 		try {
 			creds = await refreshOAuthToken(provider, creds);
-		} catch {
+		} catch (refreshError) {
 			if (provider === "perplexity") {
 				const jwtExpiry = getPerplexityJwtExpiryMs(creds.access);
 				if (jwtExpiry && Date.now() < jwtExpiry) {
@@ -388,7 +388,8 @@ export async function getOAuthApiKey(
 					return { newCredentials: fallbackCredentials, apiKey: fallbackCredentials.access };
 				}
 			}
-			throw new Error(`Failed to refresh OAuth token for ${provider}`);
+			const reason = refreshError instanceof Error ? refreshError.message : String(refreshError);
+			throw new Error(`Failed to refresh OAuth token for ${provider}: ${reason}`);
 		}
 	}
 	// For providers that need projectId, return JSON

package/src/utils/oauth/openai-codex.ts

@@ -147,7 +147,13 @@ export async function refreshOpenAICodexToken(refreshToken: string): Promise<OAu
 	});
 
 	if (!response.ok) {
-		throw new Error(`OpenAI Codex token refresh failed: ${response.status}`);
+		let detail = `${response.status}`;
+		try {
+			const body = (await response.json()) as { error?: string; error_description?: string };
+			if (body.error)
+				detail = `${response.status} ${body.error}${body.error_description ? `: ${body.error_description}` : ""}`;
+		} catch {}
+		throw new Error(`OpenAI Codex token refresh failed: ${detail}`);
 	}
 
 	const tokenData = (await response.json()) as {