@oh-my-pi/pi-ai 17.2.10 → 17.2.11

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## [Unreleased]
 
+## [17.2.11] - 2026-08-07
+
+### Breaking Changes
+
+- Fixed handling of GitHub Copilot's model_not_available_for_integrator error to prevent unnecessary retries, preserving the actionable available models list.
+
+### Added
+
+- Added support for reporting Cursor personal monthly USD quotas and remaining balances, labeled by verified profile email accounts.
+
+### Fixed
+
+- Fixed an issue where ANTHROPIC_BASE_URL was ignored for Anthropic chat requests, ensuring requests are routed to the configured host and forwarding ANTHROPIC_CUSTOM_HEADERS to non-official gateways.
+- Fixed an issue where a legacy pre-organization login credential could persist and cause a permanent error row in omp usage even after a successful organization-scoped re-login.
+- Fixed an issue where lazy provider streams (including Amazon Bedrock, Google, Cursor, Devin, and Ollama) ignored model-specific idle timeouts, which previously caused healthy but slow reasoning turns to prematurely time out.
+- Improved error classification for Simplified Chinese quota-exhaustion and rate-limit messages, ensuring affected credentials are correctly rotated or backed off instead of being treated as unknown errors.
+- Classified subscription and plan-cap 429 responses as rotatable usage limits rather than transient rate-limit throttles, enabling smoother credential rotation.
+
 ## [17.2.10] - 2026-08-06
 
 ### Breaking Changes

package/dist/types/error/flags.d.ts

@@ -65,10 +65,10 @@ export declare function isGrammarError(error: unknown): boolean;
  */
 export declare function isFastModeUnsupported(error: unknown): boolean;
 /**
- * GitHub Copilot 400 rejecting a model its own `/models` catalog advertises —
- * transient fleet skew, not a malformed request. Reads the structural `code`
- * through the SDK/body envelopes, then falls back to the stringified body both
- * SDK families put in `message` (shapes drift; the wire text does not).
+ * GitHub Copilot 400 `model_not_supported` response for a model advertised by
+ * `/models` — transient fleet skew, not a malformed request. Reads the
+ * structural `code` through the SDK/body envelopes, then falls back to the
+ * stringified body both SDK families put in `message`.
  */
 export declare function isCopilotTransientModelError(error: unknown): boolean;
 export declare function classifyMessage(message: {

package/dist/types/registry/oauth/cursor.d.ts

@@ -12,4 +12,5 @@ export declare function pollCursorAuth(uuid: string, verifier: string): Promise<
 }>;
 export declare function loginCursor(onAuthUrl: (url: string) => void, onPollStart?: () => void): Promise<OAuthCredentials>;
 export declare function refreshCursorToken(apiKeyOrRefreshToken: string): Promise<OAuthCredentials>;
+export declare function extractCursorAccessTokenUserId(accessToken: string): string | undefined;
 export declare function isCursorTokenExpiringSoon(token: string, thresholdSeconds?: number): boolean;

package/dist/types/registry/oauth/index.d.ts

@@ -6,6 +6,10 @@ export type * from "./types.js";
  * Register a custom OAuth provider.
  */
 export declare function registerOAuthProvider(provider: OAuthProviderInterface): void;
+/**
+ * Remove a custom OAuth provider by ID.
+ */
+export declare function unregisterOAuthProvider(id: string): void;
 /**
  * Get a custom OAuth provider by ID.
  */

package/dist/types/types.d.ts

@@ -649,8 +649,10 @@ export interface DeveloperMessage {
     providerPayload?: ProviderPayload;
     timestamp: number;
 }
+/** How an automatic retry recovered or ultimately settled a failed attempt. */
 export type AssistantRetryRecoveryKind = "credential" | "model" | "wait" | "plain";
-export interface AssistantRetryRecovery {
+/** Persisted presentation state for an assistant error superseded by an automatic retry saga. */
+export type AssistantRetryRecovery = {
     kind: "auto-retry";
     status: "recovered";
     attempt: number;
@@ -663,7 +665,13 @@ export interface AssistantRetryRecovery {
         provider: string;
         model: string;
     };
-}
+} | {
+    kind: "auto-retry";
+    status: "superseded";
+    attempt: number;
+    recovery: AssistantRetryRecoveryKind;
+    note: string;
+};
 export interface ContextSnapshot {
     promptTokens: number;
     nonMessageTokens: number;

package/dist/types/usage/cursor.d.ts

@@ -1,3 +1,4 @@
 import type { UsageProvider, UsageReport } from "../usage.js";
+export declare function parseCursorIndividualUsage(payload: unknown, fetchedAt?: number): UsageReport | null;
 export declare function parseCursorUsage(payload: unknown, fetchedAt?: number): UsageReport | null;
 export declare const cursorUsageProvider: UsageProvider;

package/dist/types/utils/http-inspector.d.ts

@@ -38,11 +38,10 @@ export declare function finalizeErrorMessage(error: unknown, rawRequestDump: Raw
  * Rewrite error message for GitHub Copilot request failures.
  * Must run AFTER finalizeErrorMessage since it replaces the message entirely.
  *
- * 400 model-unavailable = Copilot fleet skew. A model that `/models` advertises
- *        (claude-sonnet-4.6, claude-opus-4.6, gpt-5.4, gpt-5.3-codex, ...)
- *        flaps between 200 and 400 because only part of Copilot's fleet has it
- *        in the integrator allowlist. After the in-request retry exhausts,
- *        surface guidance rather than the raw error.
+ * 400 `model_not_supported` = Copilot fleet skew. A model that `/models`
+ *        advertises can flap between 200 and 400 because only part of
+ *        Copilot's fleet has it in the integrator allowlist. After the
+ *        in-request retry exhausts, surface guidance rather than the raw error.
  * 401 = token invalid/expired → credential removal is safe, prompt re-login.
  * 403 = token valid but access denied (plan, model policy, org restriction) →
  *       do NOT reuse the auth-failed string (which triggers credential removal).

package/dist/types/utils/retry.d.ts

@@ -1,9 +1,8 @@
 import { isCopilotTransientModelError } from "../error/flags.js";
 export { isCopilotTransientModelError };
 /**
- * Wrap an initial Copilot request so transient model-availability 400s
- * (`model_not_supported`, `model_not_available_for_integrator`) are retried a
- * small number of times. No-op for non-Copilot providers.
+ * Wrap an initial Copilot request so transient `model_not_supported` 400s are
+ * retried a small number of times. No-op for non-Copilot providers.
  *
  * The callback **MUST** create a fresh in-flight request each invocation — a
  * once-consumed AsyncIterable cannot be re-iterated.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "17.2.10",
+	"version": "17.2.11",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -38,10 +38,10 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.1",
-		"@oh-my-pi/omptype": "17.2.10",
-		"@oh-my-pi/pi-catalog": "17.2.10",
-		"@oh-my-pi/pi-utils": "17.2.10",
-		"@oh-my-pi/pi-wire": "17.2.10"
+		"@oh-my-pi/omptype": "17.2.11",
+		"@oh-my-pi/pi-catalog": "17.2.11",
+		"@oh-my-pi/pi-utils": "17.2.11",
+		"@oh-my-pi/pi-wire": "17.2.11"
 	},
 	"devDependencies": {
 		"@bufbuild/protoc-gen-es": "^2.12.1",

package/src/auth/sqlite-credential-store.ts

@@ -1374,11 +1374,13 @@ export class SqliteAuthCredentialStore implements AuthCredentialStore {
 		try {
 			let hasActiveApiKey = false;
 			const activeIdentityKeys = new Set<string>();
+			const activeOAuthCredentials: AuthCredential[] = [];
 			for (const row of activeRows) {
 				if (row.credential.type === "api_key") {
 					hasActiveApiKey = true;
 					continue;
 				}
+				activeOAuthCredentials.push(row.credential);
 				const identityKey = resolveCredentialIdentityKey(provider, row.credential);
 				if (identityKey) activeIdentityKeys.add(identityKey);
 			}
@@ -1393,7 +1395,22 @@ export class SqliteAuthCredentialStore implements AuthCredentialStore {
 				const identityKey = resolveRowCredentialIdentityKey(provider, row);
 				if (identityKey && activeIdentityKeys.has(identityKey)) {
 					this.#hardDeleteStmt.run(row.id);
+					continue;
 				}
+				// Exact key equality misses a tombstone whose key predates a format
+				// the active row now uses (pre-org `<b>` vs `<b>|org:<o>`). An active
+				// credential that WOULD have replaced this row had it still been
+				// active supersedes its tombstone too, so mirror the replacement
+				// matcher rather than restating a weaker rule. The one-way upgrade
+				// and shared-workspace guards in matchesReplacementCredential carry
+				// over, so this never over-deletes another member's or subscription's
+				// row.
+				const disabledCredential = deserializeCredential(row);
+				if (disabledCredential === null) continue;
+				const superseded = activeOAuthCredentials.some(active =>
+					matchesReplacementCredential(provider, disabledCredential, identityKey, active),
+				);
+				if (superseded) this.#hardDeleteStmt.run(row.id);
 			}
 		} catch {
 			// Best-effort cleanup; don't let it break the main operation

package/src/error/flags.ts

@@ -113,17 +113,15 @@ const STALE_RESPONSE_ITEM_DETAIL_PATTERN = /not[ _]?found|invalid|expired|stale|
 export const LLAMA_CPP_TOOL_CALL_PARSE_PATTERN =
 	/failed to parse tool call arguments as json|\[json\.exception\.parse_error\.101\]/i;
 
-// Copilot fleet skew: HTTP 400 rejecting a model that `/models` advertised on
-// the very same host. Two codes appear in the wild — `model_not_supported`
-// (per-OAuth-client rollout gap) and `model_not_available_for_integrator`
-// (replicas whose integrator allowlist predates the model). Both flap
-// request-to-request, so a retry usually lands on a backend that has the model.
+// Copilot fleet skew: HTTP 400 `model_not_supported` can reject a model that
+// `/models` advertised on the same host when the request lands on a stale
+// replica. `model_not_available_for_integrator` is deliberately excluded:
+// GitHub also uses it for stable per-integrator entitlement denials and includes
+// that integrator's actionable `Available models` list in the response.
 const COPILOT_TRANSIENT_MODEL_CODES: Record<string, true> = {
 	model_not_supported: true,
-	model_not_available_for_integrator: true,
 };
-const COPILOT_MODEL_UNAVAILABLE_PATTERN =
-	/model_not_supported|model_not_available_for_integrator|not available for integrator/i;
+const COPILOT_TRANSIENT_MODEL_PATTERN = /model_not_supported/i;
 // Anthropic strict-tool grammar too large / schema too complex (400 invalid_request_error).
 // Feature-gated deployments (Azure Foundry, Baseten, …) reject `strict: true`
 // tools outright when the hosted model lacks structured outputs, e.g.
@@ -377,8 +375,8 @@ function classifyText(errorMessage: string | undefined, errorStatus: number | un
 			kinds |= Flag.StaleResponsesItem;
 		}
 
-		// Copilot fleet-skew model rejection is transient.
-		if (statusClean === 400 && COPILOT_MODEL_UNAVAILABLE_PATTERN.test(cleanMessage)) kinds |= Flag.Transient;
+		// Copilot's `model_not_supported` fleet-skew rejection is transient.
+		if (statusClean === 400 && COPILOT_TRANSIENT_MODEL_PATTERN.test(cleanMessage)) kinds |= Flag.Transient;
 		if (matchesStrictToolsRejection(cleanMessage, statusClean)) kinds |= Flag.Grammar;
 		if (matchesFastModeUnsupported(cleanMessage, statusClean)) kinds |= Flag.FastModeUnsupported;
 	}
@@ -513,10 +511,10 @@ function providerErrorCode(error: object): string | undefined {
 }
 
 /**
- * GitHub Copilot 400 rejecting a model its own `/models` catalog advertises —
- * transient fleet skew, not a malformed request. Reads the structural `code`
- * through the SDK/body envelopes, then falls back to the stringified body both
- * SDK families put in `message` (shapes drift; the wire text does not).
+ * GitHub Copilot 400 `model_not_supported` response for a model advertised by
+ * `/models` — transient fleet skew, not a malformed request. Reads the
+ * structural `code` through the SDK/body envelopes, then falls back to the
+ * stringified body both SDK families put in `message`.
  */
 export function isCopilotTransientModelError(error: unknown): boolean {
 	if (!error || typeof error !== "object" || status(error) !== 400) return false;
@@ -525,7 +523,7 @@ export function isCopilotTransientModelError(error: unknown): boolean {
 	// prototype key (`__proto__`, `toString`, …) would otherwise read truthy.
 	if (code !== undefined && Object.hasOwn(COPILOT_TRANSIENT_MODEL_CODES, code)) return true;
 	const message: unknown = "message" in error ? error.message : undefined;
-	return typeof message === "string" && COPILOT_MODEL_UNAVAILABLE_PATTERN.test(message);
+	return typeof message === "string" && COPILOT_TRANSIENT_MODEL_PATTERN.test(message);
 }
 
 export function classifyMessage(message: {

package/src/error/rate-limit.ts

@@ -22,6 +22,13 @@ const ACCOUNT_RATE_LIMIT_PATTERN =
 	/\baccount(?:'s)?\b[^\n]{0,80}\brate.?limit\b|\brate.?limit\b[^\n]{0,80}\baccount\b/i;
 const INSUFFICIENT_BALANCE_PATTERN = /insufficient.?balance/i;
 const SPEND_LIMIT_PATTERN = /spend.?limit/i;
+const SUBSCRIPTION_CAP_PATTERN =
+	/\b(?:subscription|plan|membership)\b[^\n]{0,80}\b(?:rate.?limits?|quota|cap)\b|\b(?:rate.?limits?|quota|cap)\b[^\n]{0,80}\b(?:subscription|plan|membership)\b/i;
+const TRANSIENT_INTERVAL_RATE_LIMIT_PATTERN = /\bper\s+(?:second|minute)\b/i;
+
+function matchesSubscriptionCapText(errorMessage: string): boolean {
+	return SUBSCRIPTION_CAP_PATTERN.test(errorMessage) && !TRANSIENT_INTERVAL_RATE_LIMIT_PATTERN.test(errorMessage);
+}
 const OPENROUTER_DAILY_FREE_LIMIT_PATTERN = /\bfree[-_ ]models[-_ ]per[-_ ]day\b/i;
 // gRPC/Connect end-streams carry the status as its name (`resource_exhausted`),
 // while HTTP bodies use the phrase ("resource exhausted"). Strip either form
@@ -40,6 +47,25 @@ const ACCOUNT_SCOPED_403_PATTERN =
 	// "Your limit will reset in …"); the overall/account qualifiers arm above
 	// already covers the rest.
 	/\b(?:overall|account|organization|team|workspace)\b[^\n]{0,40}\b(?:message |request )?rate.?limit\b|\byour\b[^\n]{0,30}\b(?:limit )?will reset\b/i;
+// Simplified Chinese account-quota exhaustion phrasing. Zhipu Coding Plan
+// returns e.g. "429 已达到 5 小时的使用上限。您的限额将在 2026-08-06 20:06:00 重置。"
+// (type=1308) when the 5h window is spent; other CN providers use 额度已用完 /
+// 配额已耗尽 / 余额不足. These are persistent account-local caps that must
+// rotate to a sibling credential, not transient rate limits, so they are
+// matched before the RATE_LIMIT_EXCEEDED branch. The 上限 arm is anchored on
+// the 使用 token: a rate/concurrency cap phrased as 每分钟请求数已达上限 /
+// 并发请求数已达上限 / 速率达到上限 (no 使用) must NOT match, or it would burn a
+// healthy sibling credential as a false quota. "速率限制" is absent for the
+// same reason.
+const CN_QUOTA_EXHAUSTED_PATTERN = /使用.{0,30}?上限|(?:额度|配额)已?(?:用|耗)(?:完|尽)|限额.{0,30}重置|余额不足/;
+// Simplified Chinese rate/concurrency caps can contain both 使用 and 上限, but
+// remain transient rather than account quota exhaustion.
+const CN_TRANSIENT_CAP_PATTERN =
+	/速率.{0,30}上限|频率.{0,30}上限|每分钟.{0,30}上限|并发.{0,30}上限|使用.{0,30}(?:速率|频率|每分钟|并发).{0,30}上限/;
+// Common Simplified Chinese throttle phrasing. Consulted by
+// isOpaqueStatusBody so CN transients stay in the provider backoff lane instead
+// of rotating through the opaque-429 fallback.
+const CN_THROTTLE_PATTERN = /速率(?:限制|过快)|频率(?:过高|过快)|过于频繁|稍后[重再]试/;
 
 /**
  * Classify a rate-limit error message into a reason category.
@@ -64,6 +90,13 @@ export function parseRateLimitReason(errorMessage: string): RateLimitReason {
 		return "QUOTA_EXHAUSTED";
 	}
 
+	// Simplified Chinese quota-exhaustion phrasing (Zhipu Coding Plan and other
+	// CN providers). Must precede the MODEL_CAPACITY / RATE_LIMIT branches so an
+	// account-local cap rotates instead of backing off as a transient.
+	if (CN_QUOTA_EXHAUSTED_PATTERN.test(errorMessage) && !CN_TRANSIENT_CAP_PATTERN.test(errorMessage)) {
+		return "QUOTA_EXHAUSTED";
+	}
+
 	if (CONCURRENT_LIMIT_PATTERN.test(errorMessage)) {
 		return "CONCURRENT_LIMIT";
 	}
@@ -80,6 +113,10 @@ export function parseRateLimitReason(errorMessage: string): RateLimitReason {
 		return "QUOTA_EXHAUSTED";
 	}
 
+	if (matchesSubscriptionCapText(errorMessage)) {
+		return "QUOTA_EXHAUSTED";
+	}
+
 	if (OPENROUTER_DAILY_FREE_LIMIT_PATTERN.test(errorMessage)) {
 		return "QUOTA_EXHAUSTED";
 	}
@@ -212,7 +249,20 @@ export function isOpaqueStatusBody(message: string): boolean {
 	const cleaned = message
 		.replace(/\b(?:429|402)\b/g, "")
 		.replace(/\b(?:http|https|status|error|code|response|message)\b/gi, "");
-	return !/[a-z\d]{3,}/i.test(cleaned);
+	// A body is informative when the text classifier can act on it. Any Latin
+	// word or Simplified Chinese phrasing the classifier recognizes (quota
+	// exhaustion or a throttle) defers to parseRateLimitReason; a body that
+	// is only status digits / HTTP framing is opaque and rotates conservatively.
+	// A Han-only body the classifier cannot interpret (e.g. Japanese Kanji
+	// quota text, since Japanese is out of scope) must stay opaque so the
+	// opaque-429 fallback still rotates. This keeps the exception scoped to
+	// text we actually classify, rather than to any Han ideograph.
+	return (
+		!/[a-z\d]{3,}/i.test(cleaned) &&
+		!CN_QUOTA_EXHAUSTED_PATTERN.test(cleaned) &&
+		!CN_TRANSIENT_CAP_PATTERN.test(cleaned) &&
+		!CN_THROTTLE_PATTERN.test(cleaned)
+	);
 }
 
 /**
@@ -224,8 +274,10 @@ export function isOpaqueStatusBody(message: string): boolean {
 export function matchesUsageLimitText(errorMessage: string): boolean {
 	return (
 		USAGE_LIMIT_PATTERN.test(errorMessage) ||
+		(CN_QUOTA_EXHAUSTED_PATTERN.test(errorMessage) && !CN_TRANSIENT_CAP_PATTERN.test(errorMessage)) ||
 		SPEND_LIMIT_PATTERN.test(errorMessage) ||
 		ACCOUNT_RATE_LIMIT_PATTERN.test(errorMessage) ||
+		matchesSubscriptionCapText(errorMessage) ||
 		OPENROUTER_DAILY_FREE_LIMIT_PATTERN.test(errorMessage)
 	);
 }

package/src/providers/anthropic.ts

@@ -1212,7 +1212,14 @@ function resolveAnthropicBaseUrl(model: Model<"anthropic-messages">, apiKey?: st
 		}
 	}
 	if (model.provider === "anthropic") {
-		return normalizeAnthropicBaseUrl(model.baseUrl) ?? "https://api.anthropic.com";
+		const configured = normalizeAnthropicBaseUrl(model.baseUrl);
+		// An explicitly configured non-official baseUrl (e.g. a models.yml provider
+		// override) is more specific than the generic env fallback and wins.
+		if (configured && !isOfficialAnthropicApiUrl(configured)) return configured;
+		// Otherwise ANTHROPIC_BASE_URL routes chat through an enterprise gateway
+		// (docs/environment-variables.md), ahead of the official default. The
+		// Foundry redirect is already handled above.
+		return normalizeAnthropicBaseUrl($env.ANTHROPIC_BASE_URL) ?? configured ?? "https://api.anthropic.com";
 	}
 	return normalizeAnthropicBaseUrl(model.baseUrl);
 }
@@ -1272,9 +1279,12 @@ export function resolveAnthropicCustomHeadersForBaseUrl(
 	return parseAnthropicCustomHeaders($env.ANTHROPIC_CUSTOM_HEADERS);
 }
 
-function resolveAnthropicCustomHeaders(model: Model<"anthropic-messages">): Record<string, string> | undefined {
+function resolveAnthropicCustomHeaders(
+	model: Model<"anthropic-messages">,
+	baseUrl: string | undefined,
+): Record<string, string> | undefined {
 	if (model.provider !== "anthropic") return undefined;
-	return resolveAnthropicCustomHeadersForBaseUrl(model.baseUrl);
+	return resolveAnthropicCustomHeadersForBaseUrl(baseUrl);
 }
 
 function looksLikeFilePath(value: string): boolean {
@@ -2944,7 +2954,7 @@ export function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): A
 	const supportsEagerToolInputStreaming = resolveEagerToolInputStreamingSupport(model, baseUrl);
 	const needsFineGrainedToolStreamingBeta =
 		hasTools && isOfficialAnthropicApiUrl(baseUrl) && !supportsEagerToolInputStreaming;
-	const foundryCustomHeaders = resolveAnthropicCustomHeaders(model);
+	const foundryCustomHeaders = resolveAnthropicCustomHeaders(model, baseUrl);
 	const tlsFetchOptions = buildCoworkTlsFetchOptions(model, baseUrl);
 	// Disable Bun's native ~300s pre-response fetch timeout (issue #2422).
 	// `AnthropicMessagesClient` already arms its own DEFAULT_TIMEOUT_MS timer

package/src/providers/register-builtins.ts

@@ -11,6 +11,7 @@
  * loading that can be integrated when stream.ts is refactored.
  */
 
+import type { CompatOf } from "@oh-my-pi/pi-catalog/types";
 import * as AIError from "../error";
 import type {
 	Api,
@@ -240,12 +241,23 @@ function forwardStream<TApi extends Api>(
 	(async () => {
 		try {
 			const providerHandlesStreamTimeouts = limits?.providerHandlesStreamTimeouts === true;
+			// Per-model catalog compat can widen the fallback watchdog for hosts
+			// with no keepalive events (e.g. Bedrock reasoning models that go
+			// quiet for minutes mid-thinking, issue #4758). Caller options and
+			// env overrides still take precedence over the compat fallback. The
+			// annotated local up-casts the generic CompatOf<TApi> by assignment,
+			// so any compat shape redeclaring `streamIdleTimeoutMs` with another
+			// type is a compile error here.
+			const compat: CompatOf<Api> | undefined = model.compat;
+			const compatIdleTimeoutMs =
+				compat !== undefined && "streamIdleTimeoutMs" in compat ? compat.streamIdleTimeoutMs : undefined;
+			const idleTimeoutFallbackMs = compatIdleTimeoutMs ?? limits?.defaultIdleTimeoutMs;
 			const idleTimeoutMs = providerHandlesStreamTimeouts
 				? undefined
 				: (options.streamIdleTimeoutMs ??
 					(limits?.openAIIdleEnvFloorsFirstEvent
-						? getOpenAIStreamIdleTimeoutMs(limits.defaultIdleTimeoutMs)
-						: getStreamIdleTimeoutMs(limits?.defaultIdleTimeoutMs)));
+						? getOpenAIStreamIdleTimeoutMs(idleTimeoutFallbackMs)
+						: getStreamIdleTimeoutMs(idleTimeoutFallbackMs)));
 			const firstItemTimeoutMs = providerHandlesStreamTimeouts
 				? 0
 				: (options.streamFirstEventTimeoutMs ??
@@ -311,6 +323,7 @@ function createLazyLoadErrorMessage<TApi extends Api>(
 			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
 		},
 		stopReason,
+		errorId: stopReason === "error" ? AIError.classify(error, model.api) || undefined : undefined,
 		errorMessage:
 			stopReason === "aborted" ? "Request was aborted" : error instanceof Error ? error.message : String(error),
 		timestamp: Date.now(),

package/src/registry/oauth/cursor.ts

@@ -138,18 +138,33 @@ export async function refreshCursorToken(apiKeyOrRefreshToken: string): Promise<
 	};
 }
 
-function getTokenExpiry(token: string): number {
+function decodeCursorAccessTokenPayload(token: string): unknown | undefined {
+	const parts = token.split(".");
+	if (parts.length !== 3) return undefined;
+	const payload = parts[1];
+	if (!payload) return undefined;
+	return JSON.parse(atob(payload.replace(/-/g, "+").replace(/_/g, "/")));
+}
+
+export function extractCursorAccessTokenUserId(accessToken: string): string | undefined {
 	try {
-		const parts = token.split(".");
-		if (parts.length !== 3) {
-			return Date.now() + 3600 * 1000;
+		const payload = decodeCursorAccessTokenPayload(accessToken);
+		if (!payload || typeof payload !== "object" || !("sub" in payload) || typeof payload.sub !== "string") {
+			return undefined;
 		}
-		const payload = parts[1];
-		if (!payload) {
-			return Date.now() + 3600 * 1000;
-		}
-		const decoded = JSON.parse(atob(payload.replace(/-/g, "+").replace(/_/g, "/")));
-		if (decoded && typeof decoded === "object" && typeof decoded.exp === "number") {
+		const { sub } = payload;
+		const parts = sub.split("|");
+		const userId = (parts.length > 1 ? parts[1] : sub).trim();
+		return userId || undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function getTokenExpiry(token: string): number {
+	try {
+		const decoded = decodeCursorAccessTokenPayload(token);
+		if (decoded && typeof decoded === "object" && "exp" in decoded && typeof decoded.exp === "number") {
 			return decoded.exp * 1000 - 5 * 60 * 1000;
 		}
 	} catch {
@@ -160,9 +175,10 @@ function getTokenExpiry(token: string): number {
 
 export function isCursorTokenExpiringSoon(token: string, thresholdSeconds = 300): boolean {
 	try {
-		const [, payload] = token.split(".");
-		if (!payload) return true;
-		const decoded = JSON.parse(atob(payload.replace(/-/g, "+").replace(/_/g, "/")));
+		const decoded = decodeCursorAccessTokenPayload(token);
+		if (!decoded || typeof decoded !== "object" || !("exp" in decoded) || typeof decoded.exp !== "number") {
+			return true;
+		}
 		const currentTime = Math.floor(Date.now() / 1000);
 		return decoded.exp - currentTime < thresholdSeconds;
 	} catch {

package/src/registry/oauth/index.ts

@@ -34,6 +34,13 @@ export function registerOAuthProvider(provider: OAuthProviderInterface): void {
 	customOAuthProviders.set(provider.id, provider);
 }
 
+/**
+ * Remove a custom OAuth provider by ID.
+ */
+export function unregisterOAuthProvider(id: string): void {
+	customOAuthProviders.delete(id);
+}
+
 /**
  * Get a custom OAuth provider by ID.
  */

package/src/stream.ts

@@ -112,10 +112,18 @@ function isGoogleVertexAuthenticatedModel(model: Model<Api>): boolean {
  */
 function isLeakedThinkingHealExempt(model: Model<Api>): boolean {
 	switch (model.provider) {
-		case "anthropic":
-			// Mirror resolveAnthropicBaseUrl: Foundry redirects an empty baseUrl to
-			// FOUNDRY_BASE_URL, so exempt only when the effective endpoint is official.
-			return isOfficialAnthropicApiUrl((isFoundryEnabled() && $env.FOUNDRY_BASE_URL?.trim()) || model.baseUrl);
+		case "anthropic": {
+			// Mirror resolveAnthropicBaseUrl's effective endpoint: Foundry redirects
+			// an empty baseUrl to FOUNDRY_BASE_URL; otherwise an explicit non-official
+			// model.baseUrl wins, then the ANTHROPIC_BASE_URL gateway fallback, then
+			// the official default. Exempt only when the effective endpoint is official.
+			if (isFoundryEnabled()) {
+				const foundry = $env.FOUNDRY_BASE_URL?.trim();
+				if (foundry) return isOfficialAnthropicApiUrl(foundry);
+			}
+			if (model.baseUrl && !isOfficialAnthropicApiUrl(model.baseUrl)) return false;
+			return isOfficialAnthropicApiUrl($env.ANTHROPIC_BASE_URL?.trim() || model.baseUrl);
+		}
 		case "openai":
 			return isOfficialOpenAIApiUrl(model.baseUrl);
 		case "openai-codex":

package/src/types.ts

@@ -830,22 +830,32 @@ export interface DeveloperMessage {
 	timestamp: number; // Unix timestamp in milliseconds
 }
 
+/** How an automatic retry recovered or ultimately settled a failed attempt. */
 export type AssistantRetryRecoveryKind = "credential" | "model" | "wait" | "plain";
 
-export interface AssistantRetryRecovery {
-	kind: "auto-retry";
-	status: "recovered";
-	attempt: number;
-	recoveredAt: string;
-	recovery: AssistantRetryRecoveryKind;
-	note: string;
-	supersededBy?: {
-		timestamp: number;
-		responseId?: string;
-		provider: string;
-		model: string;
-	};
-}
+/** Persisted presentation state for an assistant error superseded by an automatic retry saga. */
+export type AssistantRetryRecovery =
+	| {
+			kind: "auto-retry";
+			status: "recovered";
+			attempt: number;
+			recoveredAt: string;
+			recovery: AssistantRetryRecoveryKind;
+			note: string;
+			supersededBy?: {
+				timestamp: number;
+				responseId?: string;
+				provider: string;
+				model: string;
+			};
+	  }
+	| {
+			kind: "auto-retry";
+			status: "superseded";
+			attempt: number;
+			recovery: AssistantRetryRecoveryKind;
+			note: string;
+	  };
 
 export interface ContextSnapshot {
 	promptTokens: number; // authoritative provider prompt/input tokens

package/src/usage/cursor.ts

@@ -1,3 +1,4 @@
+import { extractCursorAccessTokenUserId } from "../registry/oauth/cursor";
 import type {
 	UsageAmount,
 	UsageFetchContext,
@@ -22,11 +23,42 @@ function parseTimestamp(value: unknown): number | undefined {
 	return Number.isFinite(parsed) ? parsed : undefined;
 }
 
+const DEFAULT_CURSOR_BASE_URL = "https://api2.cursor.sh";
+
 function normalizeCursorBaseUrl(baseUrl?: string): string {
-	if (!baseUrl) return "https://api2.cursor.sh";
+	if (!baseUrl) return DEFAULT_CURSOR_BASE_URL;
 	return baseUrl.replace(/\/+$/, "");
 }
 
+type CursorUsageSource = "auth-usage" | "usage-summary" | "auth-me";
+
+async function fetchCursorJson(
+	ctx: UsageFetchContext,
+	url: string,
+	init: RequestInit,
+	source: CursorUsageSource,
+): Promise<unknown | undefined> {
+	try {
+		const response = await ctx.fetch(url, init);
+		if (!response.ok) {
+			ctx.logger?.warn("Cursor usage request failed", {
+				status: response.status,
+				provider: "cursor",
+				source,
+			});
+			return undefined;
+		}
+		return await response.json();
+	} catch (error) {
+		ctx.logger?.warn("Cursor usage request error", {
+			provider: "cursor",
+			source,
+			error: String(error),
+		});
+		return undefined;
+	}
+}
+
 function deriveResetsAt(payload: Record<string, unknown>): number | undefined {
 	const endKeys = ["billingCycleEnd", "endOfMonth", "resetsAt", "nextReset"];
 	for (const key of endKeys) {
@@ -46,6 +78,78 @@ function deriveResetsAt(payload: Record<string, unknown>): number | undefined {
 	return undefined;
 }
 
+function resolveCursorStatus(usedFraction: number | undefined): UsageStatus {
+	if (usedFraction === undefined) return "unknown";
+	if (usedFraction >= 1) return "exhausted";
+	if (usedFraction >= 0.9) return "warning";
+	return "ok";
+}
+
+export function parseCursorIndividualUsage(payload: unknown, fetchedAt = Date.now()): UsageReport | null {
+	if (!isRecord(payload) || !isRecord(payload.individualUsage) || !isRecord(payload.individualUsage.overall)) {
+		return null;
+	}
+	const individual = payload.individualUsage.overall;
+	if (individual.enabled === false) return null;
+
+	const reportedUsed = toNumber(individual.used);
+	const reportedRemaining = toNumber(individual.remaining);
+	const hasValidUsed = reportedUsed !== undefined && reportedUsed >= 0;
+	const hasValidRemaining = reportedRemaining !== undefined && reportedRemaining >= 0;
+	const limit = toNumber(individual.limit);
+
+	let amount: UsageAmount;
+	if (individual.limit === null || individual.limit === undefined) {
+		if (!hasValidUsed) return null;
+		amount = { used: reportedUsed / 100, unit: "usd" };
+	} else {
+		if (limit === undefined || limit <= 0) return null;
+		let used: number;
+		if (reportedUsed !== undefined && reportedUsed > 0) {
+			used = reportedUsed;
+		} else if (hasValidRemaining && reportedRemaining < limit) {
+			used = Math.max(0, limit - reportedRemaining);
+		} else if (hasValidUsed) {
+			used = reportedUsed;
+		} else {
+			return null;
+		}
+		const remaining = Math.max(0, limit - used);
+		amount = {
+			used: used / 100,
+			limit: limit / 100,
+			remaining: remaining / 100,
+			usedFraction: used / limit,
+			remainingFraction: remaining / limit,
+			unit: "usd",
+		};
+	}
+
+	const resetsAt = deriveResetsAt(payload);
+	const window: UsageWindow = {
+		id: "monthly",
+		label: "Monthly",
+		...(resetsAt !== undefined ? { resetsAt } : {}),
+	};
+	const limitEntry: UsageLimit = {
+		id: "cursor:usd:individual-overall",
+		label: "Personal Usage",
+		scope: {
+			provider: "cursor",
+			windowId: window.id,
+		},
+		window,
+		amount,
+		...(amount.usedFraction !== undefined ? { status: resolveCursorStatus(amount.usedFraction) } : {}),
+	};
+	return {
+		provider: "cursor",
+		fetchedAt,
+		limits: [limitEntry],
+		raw: payload,
+	};
+}
+
 export function parseCursorUsage(payload: unknown, fetchedAt = Date.now()): UsageReport | null {
 	if (!isRecord(payload)) return null;
 	const limits: UsageLimit[] = [];
@@ -93,17 +197,7 @@ export function parseCursorUsage(payload: unknown, fetchedAt = Date.now()): Usag
 				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";
-				}
-			}
+			const status = resolveCursorStatus(amount.usedFraction);
 
 			limits.push({
 				id: limitId,
@@ -152,41 +246,90 @@ export const cursorUsageProvider: UsageProvider = {
 
 		const baseUrl = normalizeCursorBaseUrl(params.baseUrl ?? credential.apiEndpoint);
 		const url = `${baseUrl}/auth/usage`;
-
 		const headers: Record<string, string> = {
 			Accept: "application/json",
 			Authorization: `Bearer ${token}`,
 		};
+		const fetchedAt = Date.now();
 
-		try {
-			const response = await ctx.fetch(url, {
+		const legacyReportPromise = fetchCursorJson(
+			ctx,
+			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 } : {}),
+			},
+			"auth-usage",
+		).then(payload => parseCursorUsage(payload, fetchedAt));
+
+		let summaryReportPromise = Promise.resolve<UsageReport | null>(null);
+		let profileEmailPromise = Promise.resolve<string | undefined>(undefined);
+		if (credential.type === "oauth" && baseUrl === DEFAULT_CURSOR_BASE_URL) {
+			const userId = extractCursorAccessTokenUserId(token);
+			if (userId) {
+				const sessionHeaders: Record<string, string> = {
+					Accept: "application/json",
+					Cookie: `WorkosCursorSessionToken=${encodeURIComponent(`${userId}::${token}`)}`,
 				};
-				if (Object.keys(metadata).length > 0) report.metadata = metadata;
+				summaryReportPromise = fetchCursorJson(
+					ctx,
+					"https://cursor.com/api/usage-summary",
+					{
+						headers: sessionHeaders,
+						signal: params.signal,
+					},
+					"usage-summary",
+				).then(payload => parseCursorIndividualUsage(payload, fetchedAt));
+				profileEmailPromise = fetchCursorJson(
+					ctx,
+					"https://cursor.com/api/auth/me",
+					{
+						headers: sessionHeaders,
+						signal: params.signal,
+					},
+					"auth-me",
+				).then(payload => {
+					if (
+						!isRecord(payload) ||
+						payload.sub !== userId ||
+						typeof payload.email !== "string" ||
+						!payload.email.trim()
+					) {
+						return undefined;
+					}
+					return payload.email.trim();
+				});
 			}
-			return report;
-		} catch (error) {
-			ctx.logger?.warn("Cursor usage request error", {
-				provider: params.provider,
-				error: String(error),
-			});
-			return null;
 		}
+
+		const [legacyReport, summaryReport, profileEmail] = await Promise.all([
+			legacyReportPromise,
+			summaryReportPromise,
+			profileEmailPromise,
+		]);
+		let report: UsageReport | null;
+		if (legacyReport && summaryReport) {
+			report = {
+				provider: "cursor",
+				fetchedAt,
+				limits: [...legacyReport.limits, ...summaryReport.limits],
+				raw: {
+					authUsage: legacyReport.raw,
+					usageSummary: summaryReport.raw,
+				},
+			};
+		} else {
+			report = legacyReport ?? summaryReport;
+		}
+		if (!report) return null;
+
+		const email = profileEmail ?? credential.email?.trim();
+		const metadata = {
+			...(email ? { email } : {}),
+			...(credential.accountId ? { accountId: credential.accountId } : {}),
+			...(credential.projectId ? { projectId: credential.projectId } : {}),
+		};
+		if (Object.keys(metadata).length > 0) report.metadata = metadata;
+		return report;
 	},
 };

package/src/utils/http-inspector.ts

@@ -95,11 +95,10 @@ export async function finalizeErrorMessage(
  * Rewrite error message for GitHub Copilot request failures.
  * Must run AFTER finalizeErrorMessage since it replaces the message entirely.
  *
- * 400 model-unavailable = Copilot fleet skew. A model that `/models` advertises
- *        (claude-sonnet-4.6, claude-opus-4.6, gpt-5.4, gpt-5.3-codex, ...)
- *        flaps between 200 and 400 because only part of Copilot's fleet has it
- *        in the integrator allowlist. After the in-request retry exhausts,
- *        surface guidance rather than the raw error.
+ * 400 `model_not_supported` = Copilot fleet skew. A model that `/models`
+ *        advertises can flap between 200 and 400 because only part of
+ *        Copilot's fleet has it in the integrator allowlist. After the
+ *        in-request retry exhausts, surface guidance rather than the raw error.
  * 401 = token invalid/expired → credential removal is safe, prompt re-login.
  * 403 = token valid but access denied (plan, model policy, org restriction) →
  *       do NOT reuse the auth-failed string (which triggers credential removal).

package/src/utils/retry.ts

@@ -23,9 +23,8 @@ const COPILOT_MODEL_RETRY_BASE_DELAY_MS = 400;
 const COPILOT_RETRY_AFTER_MAX_WAIT_MS = 30_000;
 
 /**
- * Wrap an initial Copilot request so transient model-availability 400s
- * (`model_not_supported`, `model_not_available_for_integrator`) are retried a
- * small number of times. No-op for non-Copilot providers.
+ * Wrap an initial Copilot request so transient `model_not_supported` 400s are
+ * retried a small number of times. No-op for non-Copilot providers.
  *
  * The callback **MUST** create a fresh in-flight request each invocation — a
  * once-consumed AsyncIterable cannot be re-iterated.