@oh-my-pi/pi-ai 17.0.0 → 17.0.2

package/src/auth-storage.ts

@@ -797,6 +797,8 @@ export interface InvalidateCredentialMatchingOptions {
 
 /** Options for refreshing one stored OAuth row through durable ownership. */
 export interface StoredOAuthRefreshOptions<T extends OAuthCredential = OAuthCredential> {
+	/** Stable row id when a provider has multiple OAuth credentials. */
+	credentialId?: number;
 	observedCredential?: T;
 	credentialFromRow: (credential: OAuthCredential) => T | undefined;
 	forceRefresh?: boolean;
@@ -2007,17 +2009,32 @@ export class AuthStorage {
 	}
 
 	/**
-	 * Persist a refreshed credential addressed by id, not a positional index.
-	 * A concurrent disable can reorder/shrink the provider's row array while an
-	 * async refresh is in flight, so a pre-await index is unsafe; resolving the
-	 * row by id at write time lands the rotated token on the correct row. Returns
-	 * the row's current index, or -1 when it was disabled/removed mid-refresh.
+	 * Persist a refreshed credential by id only while the row still matches this
+	 * process's snapshot. A peer rotation wins the CAS and is reloaded instead of
+	 * being overwritten after this process releases its refresh lease.
+	 *
+	 * Returns the row's current index, or -1 when it was disabled or removed.
 	 */
 	#replaceCredentialById(provider: string, id: number, credential: AuthCredential): number {
 		const entries = this.#getStoredCredentials(provider);
 		const index = entries.findIndex(entry => entry.id === id);
 		if (index === -1) return -1;
-		this.#store.updateAuthCredential(id, credential);
+		const expected = serializeCredential(provider, entries[index]!.credential);
+		if (
+			expected &&
+			this.#store.tryUpdateAuthCredentialIfMatches &&
+			!this.#store.tryUpdateAuthCredentialIfMatches(id, expected.data, credential)
+		) {
+			const latest = this.#store.listAuthCredentials(provider);
+			this.#setStoredCredentials(
+				provider,
+				latest.map(row => ({ id: row.id, credential: row.credential })),
+			);
+			return latest.findIndex(row => row.id === id);
+		}
+		if (!expected || !this.#store.tryUpdateAuthCredentialIfMatches) {
+			this.#store.updateAuthCredential(id, credential);
+		}
 		const updated = [...entries];
 		updated[index] = { id, credential };
 		this.#setStoredCredentials(provider, updated);
@@ -2150,7 +2167,11 @@ export class AuthStorage {
 				provider,
 				rows.map(row => ({ id: row.id, credential: row.credential })),
 			);
-			const row = rows.find(entry => entry.credential.type === "oauth");
+			const row = rows.find(
+				entry =>
+					entry.credential.type === "oauth" &&
+					(options.credentialId === undefined || entry.id === options.credentialId),
+			);
 			if (row?.credential.type !== "oauth") {
 				return { credential: undefined, refreshed: false, removed: false };
 			}
@@ -2189,7 +2210,11 @@ export class AuthStorage {
 				provider,
 				rows.map(row => ({ id: row.id, credential: row.credential })),
 			);
-			const row = rows.find(entry => entry.credential.type === "oauth");
+			const row = rows.find(
+				entry =>
+					entry.credential.type === "oauth" &&
+					(options.credentialId === undefined || entry.id === options.credentialId),
+			);
 			if (row?.credential.type !== "oauth") {
 				return { credential: undefined, refreshed: false, removed: false };
 			}
@@ -2266,7 +2291,7 @@ export class AuthStorage {
 							return { credential: undefined, refreshed: false, removed: true };
 						}
 						await this.reload();
-						const latest = this.get(provider);
+						const latest = this.#getStoredCredentials(provider).find(entry => entry.id === row.id)?.credential;
 						return {
 							credential: latest?.type === "oauth" ? options.credentialFromRow(latest) : undefined,
 							refreshed: false,
@@ -2316,7 +2341,7 @@ export class AuthStorage {
 					)
 				) {
 					await this.reload();
-					const latest = this.get(provider);
+					const latest = this.#getStoredCredentials(provider).find(entry => entry.id === row.id)?.credential;
 					return {
 						credential: latest?.type === "oauth" ? options.credentialFromRow(latest) : undefined,
 						refreshed: false,
@@ -2808,37 +2833,27 @@ export class AuthStorage {
 		return match?.id;
 	}
 
-	#persistRefreshedUsageCredential(provider: Provider, previous: UsageCredential, next: UsageCredential): void {
-		const entries = this.#getStoredCredentials(provider);
-		// Same sentinel rule as #findStoredCredentialIdForUsageCredential above.
-		const previousRefresh =
-			previous.refreshToken && previous.refreshToken !== REMOTE_REFRESH_SENTINEL ? previous.refreshToken : undefined;
-		const index = entries.findIndex(entry => {
-			if (entry.credential.type !== "oauth") return false;
-			if (previousRefresh && entry.credential.refresh === previousRefresh) return true;
-			if (previous.accessToken && entry.credential.access === previous.accessToken) return true;
-			return (
-				entry.credential.accountId === previous.accountId &&
-				entry.credential.email === previous.email &&
-				entry.credential.projectId === previous.projectId &&
-				entry.credential.orgId === previous.orgId
-			);
-		});
-		if (index === -1) return;
-		const existing = entries[index]!.credential;
-		if (existing.type !== "oauth") return;
-		this.#replaceCredentialAt(provider, index, {
+	#persistRefreshedUsageCredential(
+		provider: Provider,
+		previous: UsageCredential,
+		next: UsageCredential,
+		credentialId = this.#findStoredCredentialIdForUsageCredential(provider, previous),
+	): void {
+		if (credentialId === undefined) return;
+		const entry = this.#getStoredCredentials(provider).find(candidate => candidate.id === credentialId);
+		if (entry?.credential.type !== "oauth") return;
+		this.#replaceCredentialById(provider, credentialId, {
 			type: "oauth",
-			access: next.accessToken ?? existing.access,
-			refresh: next.refreshToken ?? existing.refresh,
-			expires: next.expiresAt ?? existing.expires,
+			access: next.accessToken ?? entry.credential.access,
+			refresh: next.refreshToken ?? entry.credential.refresh,
+			expires: next.expiresAt ?? entry.credential.expires,
 			accountId: next.accountId,
 			projectId: next.projectId,
 			email: next.email,
 			enterpriseUrl: next.enterpriseUrl,
 			apiEndpoint: next.apiEndpoint,
-			orgId: next.orgId ?? existing.orgId,
-			orgName: next.orgName ?? existing.orgName,
+			orgId: next.orgId ?? entry.credential.orgId,
+			orgName: next.orgName ?? entry.credential.orgName,
 		});
 	}
 
@@ -2878,7 +2893,12 @@ export class AuthStorage {
 						timeoutSignal,
 					);
 					const refreshedCredential = this.#mergeRefreshedUsageCredential(request.credential, refreshed);
-					this.#persistRefreshedUsageCredential(request.provider, request.credential, refreshedCredential);
+					this.#persistRefreshedUsageCredential(
+						request.provider,
+						request.credential,
+						refreshedCredential,
+						refreshableCredentialId,
+					);
 					params = {
 						...request,
 						credential: refreshedCredential,
@@ -2887,46 +2907,16 @@ export class AuthStorage {
 					};
 				} catch (error) {
 					const errorMsg = String(error);
-					// Definitive failure (invalid_grant / 401 not from a network blip) means
-					// the refresh token itself is dead — probing with the original credential
-					// will 401, the catch below will return null, and #fetchUsageCached's
-					// last-good fallback will surface yesterday's report indefinitely
-					// (including its already-elapsed `resetsAt`). CAS-disable the row and
-					// clear the cache so the credential drops out of the report instead of
-					// freezing in place until the user notices and re-logs in.
-					if (AIError.isDefinitiveOAuthFailure(errorMsg)) {
-						const credentialId = this.#findStoredCredentialIdForUsageCredential(
-							request.provider,
-							request.credential,
-						);
-						if (credentialId !== undefined) {
-							const entries = this.#getStoredCredentials(request.provider);
-							const index = entries.findIndex(entry => entry.id === credentialId);
-							if (index !== -1) {
-								const disabled = this.#tryDisableCredentialAtIfMatches(
-									request.provider,
-									index,
-									refreshableCredential,
-									`oauth refresh failed during usage probe: ${errorMsg}`,
-								);
-								if (disabled) {
-									this.#usageLogger?.warn(
-										"Usage credential refresh failed definitively; credential disabled",
-										{ provider: request.provider, credentialId, error: errorMsg },
-									);
-									// Neutralize last-good for this cache key: write a null
-									// entry with an immediately-elapsed expiry so a future
-									// getStale lookup (e.g. on re-login under the same
-									// account identity) can't replay the stale report.
-									this.#usageCache.set(this.#buildUsageReportCacheKey(request), {
-										value: null,
-										expiresAt: 0,
-									});
-									return null;
-								}
-							}
-						}
+					if (request.credential.expiresAt <= Date.now() && AIError.isDefinitiveOAuthFailure(errorMsg)) {
+						// The current access token is unusable, so don't replay an
+						// old usage report after its rotating refresh token is revoked.
+						// This changes cache state only; usage polling remains
+						// non-authoritative about the credential lifecycle.
+						this.#usageCache.set(this.#buildUsageReportCacheKey(request), { value: null, expiresAt: 0 });
 					}
+					// Usage polling is advisory. A refresh can fail while the current
+					// access token remains valid inside the refresh skew, so probe with
+					// that token and never mutate credential state from this path.
 					this.#usageLogger?.debug("Usage credential refresh failed, using original credential", {
 						provider: request.provider,
 						error: errorMsg,
@@ -3667,6 +3657,7 @@ export class AuthStorage {
 							row.provider as Provider,
 							initialRequest.credential,
 							refreshedCredential,
+							row.id,
 						);
 						params = {
 							...params,
@@ -4317,6 +4308,42 @@ export class AuthStorage {
 		credential: OAuthCredential,
 		credentialId: number | undefined,
 		signal?: AbortSignal,
+	): Promise<OAuthCredentials> {
+		const hasDurableLease =
+			!!this.#store.tryAcquireCredentialRefreshLease &&
+			!!this.#store.getCredentialRefreshLeaseExpiresAt &&
+			!!this.#store.releaseCredentialRefreshLease &&
+			!!this.#store.renewCredentialRefreshLease;
+		if (credentialId !== undefined && hasDurableLease) {
+			const forceRefresh = credential.expires === 0;
+			const result = await this.refreshStoredOAuthCredential(provider, {
+				credentialId,
+				observedCredential: forceRefresh ? undefined : credential,
+				credentialFromRow: row => row,
+				forceRefresh,
+				signal,
+				refresh: (current, refreshSignal) =>
+					this.#requestOAuthCredentialRefresh(
+						provider,
+						current,
+						credentialId,
+						signal && refreshSignal ? AbortSignal.any([signal, refreshSignal]) : (signal ?? refreshSignal),
+					),
+			});
+			if (result.credential) return result.credential;
+			throw new AIError.OAuthError(`OAuth credential no longer exists for provider: ${provider}`, {
+				kind: "token-refresh",
+				provider,
+			});
+		}
+		return this.#requestOAuthCredentialRefresh(provider, credential, credentialId, signal);
+	}
+
+	async #requestOAuthCredentialRefresh(
+		provider: Provider,
+		credential: OAuthCredential,
+		credentialId: number | undefined,
+		signal?: AbortSignal,
 	): Promise<OAuthCredentials> {
 		let refreshPromise: Promise<OAuthCredentials>;
 		// Caller override > store-level hook > local per-provider refresh.
@@ -4343,10 +4370,9 @@ export class AuthStorage {
 		// Bound the refresh so a slow/hanging token endpoint cannot stall credential selection.
 		// Caller-driven abort jumps the gun on the timeout — the agent's ESC must
 		// take priority over the floor timeout.
-		let timeout: NodeJS.Timeout | undefined;
-		let onAbort: (() => void) | undefined;
 		const cancellation = Promise.withResolvers<never>();
-		timeout = setTimeout(
+		let onAbort: (() => void) | undefined;
+		const timeout = setTimeout(
 			() =>
 				cancellation.reject(
 					new AIError.OAuthError(`OAuth token refresh timed out for provider: ${provider}`, {
@@ -4367,7 +4393,7 @@ export class AuthStorage {
 		try {
 			return await Promise.race([refreshPromise, cancellation.promise]);
 		} finally {
-			if (timeout) clearTimeout(timeout);
+			clearTimeout(timeout);
 			if (signal && onAbort) signal.removeEventListener("abort", onAbort);
 		}
 	}
@@ -5359,6 +5385,21 @@ export class AuthStorage {
 			Date.now() + AuthStorage.#defaultBackoffMs,
 		);
 
+		if (target && AIError.isInvalidatedOAuthTokenError(error)) {
+			const disabledCause = message ?? "upstream reported invalidated OAuth token";
+			const deleted = this.#store.deleteAuthCredentialRemote
+				? await this.#store.deleteAuthCredentialRemote(target.id, disabledCause)
+				: this.disableCredentialById(target.id, disabledCause);
+			if (deleted) {
+				const latestRows = this.#store.listAuthCredentials(provider);
+				this.#setStoredCredentials(
+					provider,
+					latestRows.map(row => ({ id: row.id, credential: row.credential })),
+				);
+			}
+			return deleted && hasSibling;
+		}
+
 		if (target) {
 			const markSuspect = this.#store.markCredentialSuspect?.bind(this.#store);
 			if (markSuspect) {

package/src/dialect/owned-stream.ts

@@ -109,6 +109,9 @@ export function wrapInbandToolStream(
 					case "thinking_end":
 						projector?.thinkingEnd();
 						break;
+					case "image_end":
+						projector?.keep(event.content);
+						break;
 					case "text_delta":
 						// `text()` returns true once the model starts fabricating its own
 						// tool result. In abort mode we cut the turn immediately so the
@@ -206,6 +209,14 @@ class InbandStreamProjector {
 		this.#closeText();
 		this.#closeThinking();
 		this.#partial.content.push(block);
+		if (this.#emitEvents && block.type === "image") {
+			this.#out.push({
+				type: "image_end",
+				contentIndex: this.#partial.content.length - 1,
+				content: block,
+				partial: this.#partial,
+			});
+		}
 	}
 
 	// Forward a native tool call's lifecycle live. `source` comes from the inner

package/src/dialect/thinking.ts

@@ -32,6 +32,16 @@ export class ThinkingInbandScanner implements InbandScanner {
 	#thinking = "";
 	/** Fence-aware close-matcher while inside a ` ```thinking ` block; undefined otherwise. */
 	#fenced: FencedThinkingScanner | undefined;
+	/** Backtick count that opened the Markdown code span/fence we are inside; 0 when not in code. */
+	#codeTicks = 0;
+	/** True when {@link #codeTicks} opened a fenced block (closes on a fence line), not an inline span. */
+	#codeFenced = false;
+	/**
+	 * Leading-space count on the current output line, or -1 once a non-space
+	 * character has appeared. Starts at 0 (line start) so a fence opening the
+	 * stream — or one indented ≤3 spaces, as CommonMark allows — is recognized.
+	 */
+	#lineIndent = 0;
 
 	feed(text: string): InbandScanEvent[] {
 		if (text.length === 0) return [];
@@ -86,25 +96,93 @@ export class ThinkingInbandScanner implements InbandScanner {
 				this.#closeTag = "";
 				continue;
 			}
+			if (this.#codeTicks > 0) {
+				if (this.#emitCode(final, events)) continue;
+				break;
+			}
 
-			const tag = findEarliestOpen(this.#buffer);
-			if (!tag) {
-				const hold = final ? 0 : partialSuffixOverlapAny(this.#buffer, OPENS);
-				const emit = this.#buffer.slice(0, this.#buffer.length - hold);
-				if (emit.length > 0) events.push({ type: "text", text: emit });
-				this.#buffer = this.#buffer.slice(this.#buffer.length - hold);
+			const hit = scanVisible(this.#buffer, final);
+			if (hit.kind === "none") {
+				this.#emitText(this.#buffer, events);
+				this.#buffer = "";
+				break;
+			}
+			if (hit.index > 0) this.#emitText(this.#buffer.slice(0, hit.index), events);
+			if (hit.kind === "hold") {
+				this.#buffer = this.#buffer.slice(hit.index);
 				break;
 			}
-			if (tag.index > 0) events.push({ type: "text", text: this.#buffer.slice(0, tag.index) });
-			this.#buffer = this.#buffer.slice(tag.index + tag.open.length);
-			this.#closeTag = tag.close;
+			if (hit.kind === "code") {
+				const fenced = hit.ticks >= 3 && this.#lineIndent >= 0 && this.#lineIndent <= 3;
+				this.#emitText(this.#buffer.slice(hit.index, hit.index + hit.ticks), events);
+				this.#buffer = this.#buffer.slice(hit.index + hit.ticks);
+				this.#codeTicks = hit.ticks;
+				this.#codeFenced = fenced;
+				continue;
+			}
+			this.#buffer = this.#buffer.slice(hit.index + hit.tag.open.length);
+			this.#closeTag = hit.tag.close;
 			this.#thinking = "";
-			if (tag.fenced) this.#fenced = new FencedThinkingScanner();
+			if (hit.tag.fenced) this.#fenced = new FencedThinkingScanner();
 			events.push({ type: "thinkingStart" });
 		}
 		return events;
 	}
 
+	/**
+	 * Emit buffered content while inside a Markdown code region, suppressing
+	 * reasoning-tag detection. A fenced block closes only on a fence line (a line
+	 * of backticks ≥ the opener); an inline span closes on the first backtick run
+	 * of exactly the opener length. Returns true when the region closed and the
+	 * loop should continue, false when it held back and should break.
+	 */
+	#emitCode(final: boolean, events: InbandScanEvent[]): boolean {
+		if (this.#codeFenced) {
+			const end = findFenceCloseEnd(this.#buffer, this.#codeTicks, final);
+			if (end !== -1) {
+				this.#emitText(this.#buffer.slice(0, end), events);
+				this.#buffer = this.#buffer.slice(end);
+				this.#codeTicks = 0;
+				this.#codeFenced = false;
+				return true;
+			}
+			if (final) {
+				this.#emitText(this.#buffer, events);
+				this.#buffer = "";
+				this.#codeTicks = 0;
+				this.#codeFenced = false;
+				return false;
+			}
+			// Stream committed lines; hold only the last (possibly partial) fence line.
+			const lastNl = this.#buffer.lastIndexOf("\n");
+			if (lastNl !== -1) {
+				this.#emitText(this.#buffer.slice(0, lastNl + 1), events);
+				this.#buffer = this.#buffer.slice(lastNl + 1);
+			}
+			return false;
+		}
+		const close = findBacktickRun(this.#buffer, 0, this.#codeTicks);
+		if (close !== -1 && (final || close + this.#codeTicks < this.#buffer.length)) {
+			this.#emitText(this.#buffer.slice(0, close + this.#codeTicks), events);
+			this.#buffer = this.#buffer.slice(close + this.#codeTicks);
+			this.#codeTicks = 0;
+			return true;
+		}
+		// No committed close yet: emit text, holding a trailing backtick run that
+		// may still grow into — or past — the closing delimiter.
+		const hold = final ? 0 : trailingBacktickRun(this.#buffer);
+		this.#emitText(this.#buffer.slice(0, this.#buffer.length - hold), events);
+		this.#buffer = this.#buffer.slice(this.#buffer.length - hold);
+		if (final) this.#codeTicks = 0;
+		return false;
+	}
+
+	#emitText(text: string, events: InbandScanEvent[]): void {
+		if (text.length === 0) return;
+		events.push({ type: "text", text });
+		this.#lineIndent = trailingLineIndent(text, this.#lineIndent);
+	}
+
 	#emitThinking(delta: string, events: InbandScanEvent[]): void {
 		if (delta.length === 0) return;
 		this.#thinking += delta;
@@ -112,11 +190,103 @@ export class ThinkingInbandScanner implements InbandScanner {
 	}
 }
 
-function findEarliestOpen(buffer: string): (Tag & { index: number }) | undefined {
-	let best: (Tag & { index: number }) | undefined;
-	for (const tag of TAGS) {
-		const index = buffer.indexOf(tag.open);
-		if (index !== -1 && (!best || index < best.index)) best = { ...tag, index };
+/** Outcome of scanning idle visible text for the next reasoning-tag or code-span boundary. */
+type VisibleHit =
+	| { readonly kind: "tag"; readonly index: number; readonly tag: Tag }
+	| { readonly kind: "code"; readonly index: number; readonly ticks: number }
+	| { readonly kind: "hold"; readonly index: number }
+	| { readonly kind: "none" };
+
+/**
+ * Walk idle visible text for the earliest boundary: a leaked reasoning-tag open,
+ * a Markdown code-span/fence opener (a backtick run), or — when more chunks may
+ * follow — a held partial delimiter at the buffer tail.
+ *
+ * Reasoning tags win at any position so the gemini ` ```thinking ` fence is
+ * healed instead of being read as a code fence. Backtick runs enter code mode so
+ * a literal `<think>` inside inline code or a fenced block stays visible text.
+ */
+function scanVisible(buffer: string, final: boolean): VisibleHit {
+	for (let i = 0; i < buffer.length; i++) {
+		const tag = TAGS.find(candidate => buffer.startsWith(candidate.open, i));
+		if (tag) return { kind: "tag", index: i, tag };
+		if (!final) {
+			const rest = buffer.slice(i);
+			if (OPENS.some(open => open.length > rest.length && open.startsWith(rest))) {
+				return { kind: "hold", index: i };
+			}
+		}
+		if (buffer[i] === "`") {
+			const ticks = backtickRun(buffer, i);
+			if (!final && i + ticks === buffer.length) return { kind: "hold", index: i };
+			return { kind: "code", index: i, ticks };
+		}
+	}
+	return { kind: "none" };
+}
+
+/** Length of the maximal backtick run beginning at `from`. */
+function backtickRun(buffer: string, from: number): number {
+	let end = from;
+	while (end < buffer.length && buffer[end] === "`") end++;
+	return end - from;
+}
+
+/** Index of the first maximal backtick run of exactly `ticks` at/after `from`, else -1. */
+function findBacktickRun(buffer: string, from: number, ticks: number): number {
+	for (let i = buffer.indexOf("`", from); i !== -1; i = buffer.indexOf("`", i)) {
+		const run = backtickRun(buffer, i);
+		if (run === ticks) return i;
+		i += run;
 	}
-	return best;
+	return -1;
+}
+
+/** Length of a backtick run that ends at the buffer tail; 0 when the tail is not a backtick. */
+function trailingBacktickRun(buffer: string): number {
+	let start = buffer.length;
+	while (start > 0 && buffer[start - 1] === "`") start--;
+	return buffer.length - start;
+}
+
+/**
+ * Leading-space count of the line at the tail of `text`, continuing from the
+ * prior line's `indent` state (see {@link ThinkingInbandScanner.#lineIndent}).
+ * Returns -1 once any non-space character has appeared on the current line.
+ */
+function trailingLineIndent(text: string, prior: number): number {
+	const lastNl = text.lastIndexOf("\n");
+	let indent = lastNl === -1 ? prior : 0;
+	for (let i = lastNl + 1; i < text.length; i++) {
+		if (indent === -1) break;
+		indent = text[i] === " " ? indent + 1 : -1;
+	}
+	return indent;
+}
+
+/**
+ * Index just past the first closing fence line for a fenced block opened with
+ * `ticks` backticks, or -1 when none is committed yet. A closing fence is a whole
+ * line whose trimmed content is only backticks, at least `ticks` of them. A line
+ * without a terminating newline is committed only when `final` (no more input can
+ * extend it into a non-fence line).
+ */
+function findFenceCloseEnd(buffer: string, ticks: number, final: boolean): number {
+	for (let start = 0; start <= buffer.length; ) {
+		const nl = buffer.indexOf("\n", start);
+		const terminated = nl !== -1;
+		const line = buffer.slice(start, terminated ? nl : buffer.length).trim();
+		if (line.length >= ticks && isAllBackticks(line) && (terminated || final)) {
+			return terminated ? nl + 1 : buffer.length;
+		}
+		if (!terminated) break;
+		start = nl + 1;
+	}
+	return -1;
+}
+
+/** True when `text` is non-empty and every character is a backtick. */
+function isAllBackticks(text: string): boolean {
+	for (let i = 0; i < text.length; i++) if (text[i] !== "`") return false;
+	return text.length > 0;
 }

package/src/error/auth-classify.ts

@@ -12,6 +12,18 @@ export function isDefinitiveOAuthFailure(errorMsg: string): boolean {
 	return isOAuthExpiry(errorMsg);
 }
 
+const INVALIDATED_OAUTH_TOKEN_PATTERN = /\binvalidated oauth token\b/i;
+
+/** Whether an upstream response explicitly says the supplied OAuth bearer was invalidated. */
+export function isInvalidatedOAuthTokenError(error: unknown): boolean {
+	if (typeof error === "object" && error !== null && "errorMessage" in error) {
+		const errorMessage = error.errorMessage;
+		if (typeof errorMessage === "string" && INVALIDATED_OAUTH_TOKEN_PATTERN.test(errorMessage)) return true;
+	}
+	const message = error instanceof Error ? error.message : typeof error === "string" ? error : undefined;
+	return message !== undefined && INVALIDATED_OAUTH_TOKEN_PATTERN.test(message);
+}
+
 /**
  * Whether an upstream failure should rotate to a sibling credential: a hard
  * `401`, a body-classified usage limit (Codex `usage_limit_reached`, Anthropic
@@ -22,6 +34,7 @@ export function isDefinitiveOAuthFailure(errorMsg: string): boolean {
  */
 export function isAuthRetryableError(error: unknown): boolean {
 	if (isUsageLimit(error)) return true;
+	if (isInvalidatedOAuthTokenError(error)) return true;
 	const httpStatus = extractHttpStatusFromError(error);
 	if (httpStatus === 401) return true;
 	const message = error instanceof Error ? error.message : typeof error === "string" ? error : undefined;

package/src/error/flags.ts

@@ -7,7 +7,7 @@ import {
 	ProviderHttpError,
 	STREAM_ENVELOPE_ERROR_PREFIX,
 } from "./classes";
-import { isOpaqueStatusBody, matchesUsageLimitText, parseRateLimitReason } from "./rate-limit";
+import { isOpaqueStatusBody, isUsageLimitStatus, matchesUsageLimitText, parseRateLimitReason } from "./rate-limit";
 
 export const Flag = {
 	Class: 0x1000,
@@ -318,7 +318,7 @@ function classifyText(errorMessage: string | undefined, errorStatus: number | un
 		const cleanMessage = errorMessage;
 		const isOpaque = isOpaqueStatusBody(cleanMessage);
 
-		const isLimitStatus = statusClean === 429;
+		const isLimitStatus = isUsageLimitStatus(statusClean);
 		if (
 			matchesUsageLimitText(cleanMessage) ||
 			(isLimitStatus && (isOpaque || parseRateLimitReason(cleanMessage) === "QUOTA_EXHAUSTED"))