@oh-my-pi/pi-ai 18.0.3 → 18.0.5

package/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 ## [Unreleased]
 
+## [18.0.5] - 2026-08-25
+
+### Breaking Changes
+
+- Renamed the exported stream-retry helper from `withEmptyCompletionRetry` to `withReplaySafeStreamRetry` and added retry policy options for empty completions and provider errors. Consumers using the old helper must migrate.
+
+### Added
+
+- Added browser-based Sign in with OpenRouter using OAuth PKCE, while retaining support for pasted OpenRouter API keys and redirect URLs for remote sessions.
+- Added `/login` API-key authentication for DeepInfra and Yolo-Auto, including validation against each provider before the credentials are accepted.
+
+### Fixed
+
+- Fixed DeepSeek vision models from losing image input while keeping image parts stripped for text-only DeepSeek endpoints.
+- Fixed OpenAI-compatible gateways that report uppercase completion reasons such as `STOP` or `MAX_TOKENS`; these are now classified correctly, including mapping `MAX_TOKENS` to a length limit.
+- Fixed provider message-count limit errors being treated as unrecoverable payload errors instead of recoverable context overflows.
+- Improved Codex WebSocket continuations so rate limits, throttling, and compatible mode changes preserve valid response continuations instead of unnecessarily replaying the full context.
+- Fixed Codex WebSocket cleanup failures caused by already-closed sockets.
+- Added safe retries for transient mid-stream socket closures across OpenAI Responses, Chat Completions, Azure OpenAI Responses, and Codex SSE when no replay-unsafe output has been emitted.
+- Fixed usage and cost reporting for OpenAI-compatible gateways backed by Vertex AI or Gemini by recognizing cached prompt tokens reported through `cachedContentTokenCount`.
+
+## [18.0.4] - 2026-08-24
+
+### Fixed
+
+- Fixed Cursor tool calls through OpenAI-compatible authentication gateways losing arguments when complete argument maps are sent without streaming deltas ([#9479](https://github.com/can1357/oh-my-pi/issues/9479)).
+- Fixed Cursor plan entitlement refusals repeatedly selecting ineligible accounts by scoping credential blocks to the requested model during rotation ([#9488](https://github.com/can1357/oh-my-pi/issues/9488)).
+- Improved HTTP 413 error classification to accurately distinguish between payload/media size limits and token context window overflows, preventing inappropriate token compaction attempts and routing to correct recovery/fallback strategies ([#9235](https://github.com/can1357/oh-my-pi/issues/9235)).
+- Fixed Cursor conversation rotation after aborts or mid-turn restarts to properly replay the last user message on a fresh conversation.
+
 ## [18.0.3] - 2026-08-23
 
 ### Fixed

package/README.md

@@ -60,6 +60,7 @@ Unified LLM API with automatic model discovery, provider configuration, token an
 - **NVIDIA** (requires `NVIDIA_API_KEY`)
 - **NanoGPT** (requires `NANO_GPT_API_KEY`)
 - **Novita** (requires `NOVITA_API_KEY`)
+- **DeepInfra** (requires `DEEPINFRA_API_KEY`)
 - **Hugging Face Inference**
 - **xAI**
 - **Venice** (requires `VENICE_API_KEY`)
@@ -943,6 +944,7 @@ In Node.js environments, you can set environment variables to avoid passing API
 | NVIDIA         | `NVIDIA_API_KEY`                                                             |
 | NanoGPT        | `NANO_GPT_API_KEY`                                                          |
 | Novita         | `NOVITA_API_KEY`                                                           |
+| DeepInfra      | `DEEPINFRA_API_KEY`                                                          |
 | Venice         | `VENICE_API_KEY`                                                             |
 | Moonshot       | `MOONSHOT_API_KEY`                                                           |
 | xAI            | `XAI_API_KEY`                                                                |
@@ -983,6 +985,7 @@ Provider endpoint defaults for the current OpenAI-compatible integrations:
 - NVIDIA: `https://integrate.api.nvidia.com/v1`
 - NanoGPT: `https://nano-gpt.com/api/v1`
 - Novita: `https://api.novita.ai/openai/v1`
+- DeepInfra: `https://api.deepinfra.com/v1/openai`
 - Hugging Face Inference: `https://router.huggingface.co/v1`
 - Venice: `https://api.venice.ai/api/v1`
 - Xiaomi MiMo: `https://api.xiaomimimo.com/anthropic`
@@ -1084,7 +1087,7 @@ Credentials are saved to `agent.db` in the agent directory. `/login qianfan` ope
 
 `login` supports OAuth providers (Anthropic, OpenAI Codex, GitHub Copilot, Gemini CLI, Antigravity) and API-key onboarding flows.
 
-For the current API-key onboarding flows, the library covers Together, Moonshot, Qianfan, NVIDIA, NanoGPT, Novita, Hugging Face, Venice, Xiaomi, vLLM, LiteLLM, Cloudflare AI Gateway, Qwen Portal, and Ollama Cloud. Ollama remains the local runtime integration; set `OLLAMA_API_KEY` only when your local or self-hosted deployment enforces bearer auth.
+For the current API-key onboarding flows, the library covers Together, Moonshot, Qianfan, NVIDIA, NanoGPT, Novita, DeepInfra, Hugging Face, Venice, Xiaomi, vLLM, LiteLLM, Cloudflare AI Gateway, Qwen Portal, and Ollama Cloud. Ollama remains the local runtime integration; set `OLLAMA_API_KEY` only when your local or self-hosted deployment enforces bearer auth.
 
 ### Programmatic OAuth
 

package/dist/types/auth-storage.d.ts

@@ -1151,8 +1151,8 @@ export declare class AuthStorage {
      * - usage-limit / account-rate-limit error → {@link AuthStorage.markUsageLimitReached}
      *   (temporary block via its own backoff — default plus server usage-report
      *   reset; sticky left intact so the next resolve re-ranks around the block).
-     * - exact Codex model-entitlement denial → temporarily block only that
-     *   requested model after provider/model identity matches, then rotate.
+     * - exact model-entitlement denial (Codex ChatGPT account or Cursor plan) →
+     *   temporarily block only that requested model, then rotate.
      * - other account-scoped policy denial → temporarily block that account
      *   without marking its credential suspect, then rotate through siblings.
      * - otherwise (hard 401 / auth failure) → mark the credential suspect (or

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

@@ -23,6 +23,8 @@ export declare const Flag: {
     readonly FastModeUnsupported: 536870912;
     /** OAuth refresh failed definitively — the stored grant is dead, re-login required. */
     readonly OAuthExpiry: 1073741824;
+    /** HTTP 413 byte/media rejection — token compaction cannot shrink bytes or media budgets (#9235). */
+    readonly PayloadRejected: 2147483648;
 };
 export type Flag = (typeof Flag)[keyof typeof Flag];
 export declare const STREAM_READ_ERROR_PATTERN: RegExp;
@@ -65,6 +67,8 @@ export declare function isAccountPolicyError(error: unknown, api?: Api): boolean
 export declare function codexChatGPTAccountPolicyModel(error: unknown, depth?: number): string | undefined;
 /** Whether the exact Codex entitlement denial applies to this provider and requested model. */
 export declare function isCodexChatGPTAccountPolicyError(error: unknown, provider: string, modelId: string | undefined): boolean;
+/** Whether Cursor returned a non-retryable plan entitlement denial for this account. */
+export declare function isCursorPlanAccountPolicyError(error: unknown, provider: string, depth?: number): boolean;
 /**
  * Strict-tool rejection: grammar too large, schema too complex, or structured
  * outputs unsupported by the model/endpoint.
@@ -93,7 +97,16 @@ export declare function classifyMessage(message: {
     errorStatus?: number;
 }): number;
 export declare function attach<E extends object>(error: E, id: number): E;
+/** Provider-reported usage proves context-window excess — authoritative, compaction-owned (#9235). */
+export declare function isUsageBackedContextOverflow(message: AssistantMessage, contextWindow?: number): boolean;
 export declare function isContextOverflow(message: AssistantMessage, contextWindow?: number): boolean;
+/** HTTP 413 byte/media rejection (#9235); may co-occur with {@link isContextOverflow} for bare `413 (no body)`.
+ *  Callers with local headroom should skip compaction when this returns true. */
+export declare function isPayloadRejection(message: AssistantMessage): boolean;
+/** Dual-flagged 413 (PayloadRejected + ContextOverflow) with no provider-reported token excess (#9235).
+ *  The co-flag means a different provider's larger byte/media budget may accept the request.
+ *  Usage-backed overflows are authoritative window excesses and never ambiguous. */
+export declare function isTextAmbiguousContextOverflow(errorId: number, message: AssistantMessage | undefined, contextWindow?: number): boolean;
 export declare function stringify(id: number | undefined): string;
 /**
  * Transient stream corruption where the response was truncated mid-JSON.

package/dist/types/providers/anthropic.d.ts

@@ -218,11 +218,8 @@ export declare function isInvalidThinkingSignatureError(message: string): boolea
  */
 export declare function maybeAddReplayUnsignedThinkingHint(model: Model<"anthropic-messages">, message: string): string;
 /**
- * Public entry: wrap the single-attempt streamer with bounded empty-completion
- * retries (a benign terminal stop carrying no content/usage would otherwise
- * stall the agent loop). The inner attempt keeps its own provider-failure retry
- * loop; this layer only re-issues a fresh request on an empty success. Shared
- * with the OpenAI-completions provider via `withEmptyCompletionRetry`.
+ * Public entry: retry benign empty completions before they reach the agent
+ * loop. The inner attempt owns Anthropic provider-failure retries.
  */
 export declare const streamAnthropic: StreamFunction<"anthropic-messages">;
 export type AnthropicSystemBlock = {

package/dist/types/providers/azure-openai-responses.d.ts

@@ -12,6 +12,9 @@ export interface AzureOpenAIResponsesOptions extends StreamOptions {
     disableReasoning?: boolean;
 }
 /**
- * Generate function for Azure OpenAI Responses API
+ * Retries transient Azure stream failures only before assistant output commits
+ * the attempt. The unsupported explicit prompt-cache config is rejected
+ * synchronously here — callers of the direct entrypoint get the immediate
+ * `ConfigurationError` rather than a stream whose `.result()` rejects later.
  */
 export declare const streamAzureOpenAIResponses: StreamFunction<"azure-openai-responses">;

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

@@ -19,6 +19,7 @@ interface CursorRequestState {
     conversationId: string;
     blobStore: Map<string, Uint8Array>;
     conversationState?: ConversationStateStructure;
+    rotatedFresh?: boolean;
 }
 interface CursorGrpcRequest {
     requestBytes: Uint8Array;

package/dist/types/providers/openai-completions.d.ts

@@ -38,10 +38,8 @@ export interface OpenAICompletionsOptions extends StreamOptions {
     promptCache?: OpenAIPromptCacheOptions;
 }
 /**
- * Public entry: wrap the single-attempt streamer with bounded empty-completion
- * retries — flaky gateways occasionally 200 with `delta: {}` + `finish_reason:
- * "stop"` and no usage, which would otherwise stall the agent loop. Shared with
- * the Anthropic provider via `withEmptyCompletionRetry`.
+ * Retries benign empty completions and transient provider failures only before
+ * assistant output commits the attempt.
  */
 export declare const streamOpenAICompletions: StreamFunction<"openai-completions">;
 export declare function parseChunkUsage(rawUsage: object, model: Model<"openai-completions">, premiumRequests: number | undefined): AssistantMessage["usage"];

package/dist/types/providers/openai-responses.d.ts

@@ -106,10 +106,9 @@ type OpenAIResponsesSamplingParams = ResponseCreateParamsStreaming & {
     cache_ttl?: "5m" | "1h";
 };
 /**
- * Public entry: wrap the single-attempt Responses streamer with bounded
- * empty-completion retries — a `response.completed` carrying no content/usage
- * would otherwise stall the agent loop. Shared with the OpenAI-completions and
- * Anthropic providers via `withEmptyCompletionRetry`.
+ * Public entry: retry benign empty completions before they reach the agent
+ * loop. Transient stream failures are retried inside the attempt so stateful
+ * Responses request metadata remains stable.
  */
 export declare const streamOpenAIResponses: StreamFunction<"openai-responses">;
 export declare function buildParams(model: Model<"openai-responses">, context: Context, options: OpenAIResponsesOptions | undefined, providerSessionState: OpenAIResponsesProviderSessionState | undefined, strictToolsScope?: OpenAIStrictToolsScope, disableStrictToolsOverride?: boolean, statefulCacheBaseline?: ResponseInput): {

package/dist/types/providers/openai-shared.d.ts

@@ -234,6 +234,7 @@ export type OpenAICompletionsParams = Omit<ChatCompletionCreateParamsStreaming,
     preserve_thinking?: boolean;
     chat_template_kwargs?: {
         enable_thinking?: boolean;
+        thinking?: boolean;
         preserve_thinking?: boolean;
         reasoning_effort?: string;
     };
@@ -684,4 +685,4 @@ export declare function buildResponsesDeltaInput<TItem extends ResponseInputItem
     input?: TItem[];
 } | undefined, previousResponseItems: readonly TItem[] | undefined, current: {
     input?: TItem[];
-}): TItem[] | null;
+}, additionalTopLevelExcludeMap?: Readonly<Record<string, boolean>>): TItem[] | null;

package/dist/types/registry/deepinfra.d.ts

@@ -0,0 +1,6 @@
+export declare const loginDeepinfra: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
+export declare const deepinfraProvider: {
+    id: "deepinfra";
+    name: string;
+    login: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
+};

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

@@ -0,0 +1,36 @@
+/**
+ * Sign in with OpenRouter (OAuth PKCE).
+ *
+ * No client registration: the S256 PKCE challenge is the only proof of
+ * identity. The browser authorizes at `https://openrouter.ai/auth`, redirects
+ * back to the loopback callback with `?code=`, and the code + verifier
+ * exchange at `/api/v1/auth/keys` mints a durable `sk-or-…` API key.
+ *
+ * OpenRouter never echoes a `state` parameter (the redirect only appends
+ * `?code=` to the callback URL), so the flow runs with an empty expected
+ * state — callback-state validation is disabled and the PKCE verifier binds
+ * the exchange instead.
+ *
+ * The manual-input race doubles as the API-key paste path: pasted `sk-or-…`
+ * keys skip the PKCE exchange and are validated against `/api/v1/auth/key`
+ * (the canonical "who am I" endpoint — `/api/v1/models` returns 200 for any
+ * bearer), so one login entry covers both browser sign-in and key paste.
+ */
+import type { FetchImpl } from "../../types.js";
+import { OAuthCallbackFlow } from "./callback-server.js";
+import type { OAuthController, OAuthCredentials } from "./types.js";
+/** Exchange an authorization code + PKCE verifier for a durable OpenRouter API key. */
+export declare function exchangeOpenRouterCode(code: string, codeVerifier: string, fetchImpl?: FetchImpl): Promise<string>;
+export declare class OpenRouterOAuthFlow extends OAuthCallbackFlow {
+    #private;
+    constructor(ctrl: OAuthController);
+    /** OpenRouter never echoes `state`; empty state disables callback-state validation. */
+    generateState(): string;
+    generateAuthUrl(_state: string, redirectUri: string): Promise<{
+        url: string;
+        instructions?: string;
+    }>;
+    exchangeToken(code: string): Promise<OAuthCredentials>;
+}
+/** Log in with Sign in with OpenRouter (PKCE); mints a durable API key. */
+export declare function loginOpenRouterOAuth(ctrl: OAuthController): Promise<OAuthCredentials>;

package/dist/types/registry/openrouter.d.ts

@@ -1,13 +1,14 @@
 import type { OAuthLoginCallbacks } from "./oauth/types.js";
-/** OpenRouter login flow (API key paste, validated via /auth/key).
- *
- * `/api/v1/models` is public and returns 200 for any bearer (including bogus),
- * so it cannot validate auth. `/api/v1/auth/key` is the canonical "who am I"
- * endpoint — 200 for valid keys, 401 otherwise.
+/**
+ * OpenRouter login: Sign in with OpenRouter (OAuth PKCE) that mints a durable
+ * `sk-or-…` API key, with the manual-input race accepting a pasted existing
+ * key (validated via `/api/v1/auth/key`). Either path resolves to a plain API
+ * key string, stored as an `api_key` credential.
  */
-export declare const loginOpenRouter: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
 export declare const openrouterProvider: {
     readonly id: "openrouter";
     readonly name: "OpenRouter";
     readonly login: (cb: OAuthLoginCallbacks) => Promise<string>;
+    readonly callbackPort: 54549;
+    readonly pasteCodeFlow: true;
 };

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

@@ -82,6 +82,10 @@ declare const ALL: ({
     readonly name: "Cursor (Claude, GPT, etc.)";
     readonly login: (cb: import("./oauth/index.js").OAuthLoginCallbacks) => Promise<import("./oauth/index.js").OAuthCredentials>;
     readonly refreshToken: (credentials: import("./oauth/index.js").OAuthCredentials) => Promise<import("./oauth/index.js").OAuthCredentials>;
+} | {
+    id: "deepinfra";
+    name: string;
+    login: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
 } | {
     readonly id: "deepseek";
     readonly name: "DeepSeek";
@@ -254,6 +258,8 @@ declare const ALL: ({
     readonly id: "openrouter";
     readonly name: "OpenRouter";
     readonly login: (cb: import("./oauth/index.js").OAuthLoginCallbacks) => Promise<string>;
+    readonly callbackPort: 54549;
+    readonly pasteCodeFlow: true;
 } | {
     readonly id: "parallel";
     readonly name: "Parallel";
@@ -342,6 +348,10 @@ declare const ALL: ({
     readonly id: "xiaomi-token-plan-sgp";
     readonly name: "Xiaomi Token Plan (Singapore)";
     readonly login: (cb: import("./oauth/index.js").OAuthLoginCallbacks) => Promise<string>;
+} | {
+    readonly id: "yolo-auto";
+    readonly name: "Yolo-Auto";
+    readonly login: (cb: import("./oauth/index.js").OAuthLoginCallbacks) => Promise<string>;
 } | {
     readonly id: "zai";
     readonly name: "Z.AI (GLM Coding Plan)";

package/dist/types/registry/yolo-auto.d.ts

@@ -0,0 +1,15 @@
+import type { OAuthLoginCallbacks } from "./oauth/types.js";
+/**
+ * Yolo-Auto login flow (API key paste, validated via `/v1/models`).
+ *
+ * Yolo-Auto is a flat-rate OpenAI-compatible API. `GET /v1/models` 401s any
+ * missing or invalid bearer (verified against the live endpoint), so it doubles
+ * as the canonical "who am I" check — the same role OpenRouter's `/auth/key`
+ * plays there.
+ */
+export declare const loginYoloAuto: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
+export declare const yoloAutoProvider: {
+    readonly id: "yolo-auto";
+    readonly name: "Yolo-Auto";
+    readonly login: (cb: OAuthLoginCallbacks) => Promise<string>;
+};

package/dist/types/utils/empty-completion-retry.d.ts

@@ -8,15 +8,24 @@ export declare const EMPTY_COMPLETION_BASE_DELAY_MS = 500;
  * — or one that only ever produced thinking — is the "empty response" failure.
  */
 export declare function hasVisibleAssistantContent(message: AssistantMessage): boolean;
-interface EmptyCompletionRetryOptions {
+interface StreamRetryOptions {
     signal?: AbortSignal;
     providerRetryWait?: (delayMs: number, signal?: AbortSignal) => Promise<void>;
     acceptEmptyResponse?: boolean;
 }
+/** Controls which replay-safe provider results may issue a fresh request. */
+export interface ReplaySafeStreamRetryPolicy {
+    /** Retry benign terminal stops that contain no visible output. */
+    retryEmptyCompletion?: boolean;
+    /** Retry transient provider errors before output is committed. */
+    retryProviderErrors?: boolean;
+    /** Maximum transient provider-error retries; empty completions keep their shared fixed budget. */
+    maxProviderErrorRetries?: number;
+}
 /**
- * Wrap a single-attempt provider stream with bounded empty-completion retries.
- * `attempt` MUST create a fresh request (and its own output message) on each
- * call so a retry never inherits stale metadata from an empty attempt.
+ * Re-issues a fresh provider request only while the current attempt remains
+ * replay-safe. Buffered pre-output events from discarded attempts never reach
+ * consumers.
  */
-export declare function withEmptyCompletionRetry<M, O extends EmptyCompletionRetryOptions>(model: M, context: Context, options: O | undefined, attempt: (model: M, context: Context, options?: O) => AssistantMessageEventStream): AssistantMessageEventStream;
+export declare function withReplaySafeStreamRetry<M, O extends StreamRetryOptions>(model: M, context: Context, options: O | undefined, attempt: (model: M, context: Context, options?: O) => AssistantMessageEventStream, policy: ReplaySafeStreamRetryPolicy): AssistantMessageEventStream;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "18.0.3",
+	"version": "18.0.5",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Stencil Labs, Inc.",
@@ -37,10 +37,10 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.0.3",
-		"@oh-my-pi/pi-catalog": "18.0.3",
-		"@oh-my-pi/pi-utils": "18.0.3",
-		"@oh-my-pi/pi-wire": "18.0.3"
+		"@oh-my-pi/omptype": "18.0.5",
+		"@oh-my-pi/pi-catalog": "18.0.5",
+		"@oh-my-pi/pi-utils": "18.0.5",
+		"@oh-my-pi/pi-wire": "18.0.5"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/auth-storage.ts

@@ -1028,9 +1028,13 @@ function resolveOpenAICodexPlanRequirement(provider: string, modelId: string | u
 }
 
 const MODEL_ACCOUNT_POLICY_BLOCK_SCOPE_PREFIX = "model-policy:";
+const MODEL_ACCOUNT_POLICY_PROVIDERS: Readonly<Record<string, true>> = {
+	"openai-codex": true,
+	cursor: true,
+};
 
 function modelAccountPolicyBlockScope(provider: string, modelId: string | undefined): string | undefined {
-	if (provider !== "openai-codex" || typeof modelId !== "string") return undefined;
+	if (!Object.hasOwn(MODEL_ACCOUNT_POLICY_PROVIDERS, provider) || typeof modelId !== "string") return undefined;
 	const separator = modelId.lastIndexOf("/");
 	const bareModelId = (separator === -1 ? modelId : modelId.slice(separator + 1)).trim().toLowerCase();
 	if (!bareModelId || bareModelId.includes("\0")) return undefined;
@@ -6393,8 +6397,8 @@ export class AuthStorage {
 	 * - usage-limit / account-rate-limit error → {@link AuthStorage.markUsageLimitReached}
 	 *   (temporary block via its own backoff — default plus server usage-report
 	 *   reset; sticky left intact so the next resolve re-ranks around the block).
-	 * - exact Codex model-entitlement denial → temporarily block only that
-	 *   requested model after provider/model identity matches, then rotate.
+	 * - exact model-entitlement denial (Codex ChatGPT account or Cursor plan) →
+	 *   temporarily block only that requested model, then rotate.
 	 * - other account-scoped policy denial → temporarily block that account
 	 *   without marking its credential suspect, then rotate through siblings.
 	 * - otherwise (hard 401 / auth failure) → mark the credential suspect (or
@@ -6411,7 +6415,9 @@ export class AuthStorage {
 		const error = options?.error;
 		const status = AIError.status(error);
 		const message = error instanceof Error ? error.message : typeof error === "string" ? error : undefined;
-		if (AIError.isUsageLimit(error) || isUsageLimitOutcome(status, message)) {
+		const exactCursorModelPolicy = AIError.isCursorPlanAccountPolicyError(error, provider);
+		const accountPolicy = exactCursorModelPolicy || AIError.isAccountPolicyError(error);
+		if (!accountPolicy && (AIError.isUsageLimit(error) || isUsageLimitOutcome(status, message))) {
 			// Thread the provider-specified reset window (e.g. Devin "Your limit
 			// will reset in 13 minutes") into the block duration so the credential
 			// is not reselected and hammered while the cap remains active.
@@ -6436,15 +6442,16 @@ export class AuthStorage {
 		const deniedModel = AIError.codexChatGPTAccountPolicyModel(error);
 		const exactCodexModelPolicy =
 			deniedModel !== undefined && AIError.isCodexChatGPTAccountPolicyError(error, provider, options?.modelId);
+		const exactModelPolicy = exactCodexModelPolicy || exactCursorModelPolicy;
 		// The exact sentence is provider-controlled input. A non-Codex provider,
 		// absent request model, or mismatched model must not turn it into either a
 		// global block or a hard-auth invalidation.
 		if (deniedModel !== undefined && !exactCodexModelPolicy) return false;
-		if (exactCodexModelPolicy || AIError.isAccountPolicyError(error)) {
-			const modelPolicyScope = exactCodexModelPolicy
+		if (exactModelPolicy || accountPolicy) {
+			const modelPolicyScope = exactModelPolicy
 				? modelAccountPolicyBlockScope(provider, options?.modelId)
 				: undefined;
-			if (exactCodexModelPolicy && modelPolicyScope === undefined) return false;
+			if (exactModelPolicy && modelPolicyScope === undefined) return false;
 			const routing = this.#credentialBlockRouting(
 				provider,
 				sessionCredential.type,