@oh-my-pi/pi-ai 17.4.0 → 17.4.2

package/src/auth-storage.ts

@@ -710,6 +710,7 @@ const USAGE_REPORT_CACHE_KEY_VERSION_OVERRIDES: Partial<Record<Provider, number>
 	anthropic: 3,
 };
 const DEFAULT_OAUTH_REFRESH_TIMEOUT_MS = 10_000;
+const OAUTH_REFRESH_FAILURE_BACKOFF_MS = 5 * 60 * 1000;
 /**
  * Refresh OAuth access tokens this many ms before their stated expiry. The
  * skew exists so callers downstream of {@link AuthStorage} (stream providers,
@@ -1313,6 +1314,9 @@ export class AuthStorage {
 	 */
 	#persistedBlockStoreDamaged = false;
 	#usageProviderResolver?: (provider: Provider) => UsageProvider | undefined;
+	/** Runtime extension providers take precedence over this configured/default resolver. */
+	#runtimeUsageProviderOverrides: Map<Provider, { provider: UsageProvider; apiKey?: string }> = new Map();
+	#usageReportCacheKeysByProvider: Map<Provider, Set<string>> = new Map();
 	#rankingStrategyResolver?: (provider: Provider) => CredentialRankingStrategy | undefined;
 	#usageCache: UsageCache;
 	#usageCacheEpoch = 0;
@@ -1492,6 +1496,26 @@ export class AuthStorage {
 		this.#runtimeOverrides.delete(provider);
 	}
 
+	/**
+	 * Install a runtime usage provider override (not persisted to disk).
+	 *
+	 * Runtime overrides are checked before the configured resolver, including its
+	 * built-in fallback. Removing the override restores that resolver unchanged.
+	 */
+	setRuntimeUsageProvider(provider: Provider, usageProvider: UsageProvider, apiKey?: string): void {
+		this.#runtimeUsageProviderOverrides.set(provider, { provider: usageProvider, apiKey });
+		this.#invalidateUsageReportCacheForProvider(provider);
+	}
+	/** Remove a runtime usage provider override and restore configured/default resolution. */
+	removeRuntimeUsageProvider(provider: Provider): void {
+		if (!this.#runtimeUsageProviderOverrides.has(provider)) return;
+		this.#invalidateUsageReportCacheForProvider(provider);
+		this.#runtimeUsageProviderOverrides.delete(provider);
+	}
+	#resolveUsageProvider(provider: Provider): UsageProvider | undefined {
+		return this.#runtimeUsageProviderOverrides.get(provider)?.provider ?? this.#usageProviderResolver?.(provider);
+	}
+
 	/**
 	 * Register a per-provider API key sourced from user configuration
 	 * (e.g. `models.yml` `providers.<name>.apiKey`). Higher priority than
@@ -3072,14 +3096,16 @@ export class AuthStorage {
 			this.#usageCache.set(this.#usageForceRefreshCacheKey(provider), { value: null, expiresAt: 0 });
 		}
 	}
-
 	#buildUsageReportCacheKey(request: UsageRequestDescriptor): string {
 		const baseUrl = this.#normalizeUsageBaseUrl(request.baseUrl) || "default";
 		const identity = this.#buildUsageCacheIdentity(request.credential);
 		const providerKey = this.#usageCacheProviderKey(request.provider);
-		return `report:${providerKey}:${baseUrl}:${identity}`;
+		const cacheKey = `report:${providerKey}:${baseUrl}:${identity}`;
+		const cacheKeys = this.#usageReportCacheKeysByProvider.get(request.provider) ?? new Set<string>();
+		cacheKeys.add(cacheKey);
+		this.#usageReportCacheKeysByProvider.set(request.provider, cacheKeys);
+		return cacheKey;
 	}
-
 	#buildUsageReportsCacheKey(requests: ReadonlyArray<UsageRequestDescriptor>): string {
 		const snapshot = requests
 			.map(request => {
@@ -3216,10 +3242,7 @@ export class AuthStorage {
 	}
 
 	async #fetchUsageUncached(request: UsageRequestDescriptor, timeoutMs?: number): Promise<UsageReport | null> {
-		const resolver = this.#usageProviderResolver;
-		if (!resolver) return null;
-
-		const providerImpl = resolver(request.provider);
+		const providerImpl = this.#resolveUsageProvider(request.provider);
 		if (!providerImpl) return null;
 
 		const timeoutSignal =
@@ -3324,7 +3347,6 @@ export class AuthStorage {
 			return null;
 		}
 	}
-
 	async #fetchUsageCached(
 		request: UsageRequestDescriptor,
 		options: { timeoutMs?: number; forceRefresh?: boolean } = {},
@@ -3332,6 +3354,7 @@ export class AuthStorage {
 		const timeoutMs = options.timeoutMs;
 		const forceRefresh = options.forceRefresh ?? false;
 		const cacheKey = this.#buildUsageReportCacheKey(request);
+
 		const now = Date.now();
 		const cached = forceRefresh ? undefined : this.#usageCache.get<UsageReport | null>(cacheKey);
 		// Fresh cache hit: return whatever's there (success or null fallback).
@@ -3363,7 +3386,7 @@ export class AuthStorage {
 			// value through transient failures. Session-cookie providers can opt out
 			// so an expired login does not display stale quota indefinitely.
 			const retainLastGood =
-				!forceRefresh && this.#usageProviderResolver?.(request.provider)?.retainLastGoodOnFailure !== false;
+				!forceRefresh && this.#resolveUsageProvider(request.provider)?.retainLastGoodOnFailure !== false;
 			const lastGood = retainLastGood
 				? (this.#usageCache.getStale<UsageReport | null>(cacheKey)?.value ?? null)
 				: null;
@@ -3378,7 +3401,6 @@ export class AuthStorage {
 		this.#usageRequestInFlight.set(inFlightKey, promise);
 		return promise;
 	}
-
 	/**
 	 * Append a freshly fetched report to durable usage history (when the store
 	 * supports it). The usage cache is latest-snapshot-only — these rows are
@@ -3479,7 +3501,7 @@ export class AuthStorage {
 		options?: { sessionId?: string; baseUrl?: string },
 	): boolean {
 		if (this.#fetchUsageReportsOverride) return false;
-		const parseHeaders = this.#usageProviderResolver?.(provider)?.parseRateLimitHeaders;
+		const parseHeaders = this.#resolveUsageProvider(provider)?.parseRateLimitHeaders;
 		if (!parseHeaders) return false;
 
 		const credential = this.#resolveActiveOAuthCredential(provider, options?.sessionId);
@@ -3559,18 +3581,16 @@ export class AuthStorage {
 	async #collectUsageRequests(options?: {
 		baseUrlResolver?: (provider: Provider) => string | undefined;
 	}): Promise<UsageRequestDescriptor[]> {
-		const resolver = this.#usageProviderResolver;
-		if (!resolver) return [];
-
 		const requests: UsageRequestDescriptor[] = [];
 		const providers = new Set<string>([
 			...this.#data.keys(),
+			...this.#runtimeUsageProviderOverrides.keys(),
 			...DEFAULT_USAGE_PROVIDERS.map(provider => provider.id),
 		]);
 
 		for (const providerId of providers) {
 			const provider = providerId as Provider;
-			const providerImpl = resolver(provider);
+			const providerImpl = this.#resolveUsageProvider(provider);
 			if (!providerImpl) continue;
 			const baseUrl = options?.baseUrlResolver?.(provider);
 			let entries = this.#getStoredCredentials(providerId);
@@ -3607,8 +3627,12 @@ export class AuthStorage {
 
 			if (entries.length === 0) {
 				const runtimeKey = this.#runtimeOverrides.get(providerId);
-				const envKey = getEnvApiKey(providerId);
-				const apiKey = runtimeKey ?? envKey;
+				const extensionUsageKeyConfig = this.#runtimeUsageProviderOverrides.get(provider)?.apiKey,
+					extensionUsageKey = extensionUsageKeyConfig
+						? await this.#configValueResolver(extensionUsageKeyConfig)
+						: undefined,
+					envKey = getEnvApiKey(providerId);
+				const apiKey = runtimeKey ?? extensionUsageKey ?? envKey;
 				if (!apiKey) continue;
 				const request = this.#buildUsageRequest(provider, { type: "api_key", apiKey }, baseUrl);
 				if (providerImpl.supports && !providerImpl.supports(request)) continue;
@@ -3864,7 +3888,7 @@ export class AuthStorage {
 	 * providers without a usage API) — the latter never warrants a usage row.
 	 */
 	usageProviderFor(provider: Provider): UsageProvider | undefined {
-		return this.#usageProviderResolver?.(provider);
+		return this.#resolveUsageProvider(provider);
 	}
 
 	/**
@@ -4115,7 +4139,7 @@ export class AuthStorage {
 			if (shouldReconcileStoreHookReports && reports) this.#reconcileCodexUsageBlocksFromReports(reports);
 			return reports;
 		}
-		if (!this.#usageProviderResolver) return null;
+		if (!this.#usageProviderResolver && this.#runtimeUsageProviderOverrides.size === 0) return null;
 
 		const requests = await this.#collectUsageRequests(options);
 		if (requests.length === 0) return [];
@@ -4206,7 +4230,7 @@ export class AuthStorage {
 	async checkCredentials(options?: CheckCredentialsOptions): Promise<CredentialHealthResult[]> {
 		options?.signal?.throwIfAborted();
 		const stored = this.#store.listAuthCredentials();
-		const resolver = this.#usageProviderResolver;
+
 		const timeoutMs = options?.timeoutMs ?? this.#usageRequestTimeoutMs;
 		const completionProbe = options?.completionProbe;
 		const completionTimeoutMs = options?.completionTimeoutMs ?? timeoutMs;
@@ -4307,7 +4331,7 @@ export class AuthStorage {
 				continue;
 			}
 
-			const providerImpl = resolver?.(row.provider as Provider);
+			const providerImpl = this.#resolveUsageProvider(row.provider as Provider);
 			if (!providerImpl) {
 				base.reason = `no usage probe configured for provider ${row.provider}`;
 			} else if (providerImpl.supports && !providerImpl.supports(initialRequest)) {
@@ -4853,6 +4877,7 @@ export class AuthStorage {
 					.map(idx => credentials[idx])
 					.filter((selection): selection is { credential: OAuthCredential; index: number } => Boolean(selection))
 					.map(selection => ({ selection, usage: null, usageChecked: false }));
+		const preflightFailures = new Set<OAuthCandidate>();
 
 		// On the warm skip path the candidate list follows the round-robin `order`, not the pin, so
 		// hoist the pinned credential to the front to actually reuse it. When ranking ran, the pin is
@@ -4896,8 +4921,8 @@ export class AuthStorage {
 					candidate.selection.credential = latestCredential;
 					return;
 				}
+				const credentialId = this.#getStoredCredentials(provider)[candidate.selection.index]?.id;
 				try {
-					const credentialId = this.#getStoredCredentials(provider)[candidate.selection.index]?.id;
 					// Hand #refreshOAuthCredential a stale clone (expires:0) so its
 					// not-yet-expired short-circuit doesn't suppress the forced
 					// re-mint; an in-flight peer refresh is still awaited via the
@@ -4924,15 +4949,60 @@ export class AuthStorage {
 						this.#replaceCredentialAt(provider, candidate.selection.index, updated);
 					}
 				} catch (error) {
-					// Recovery for definitive failures (incl. peer rotation) lives in
-					// #tryOAuthCredential; log instead of swallowing silently — a bare
-					// catch here hid stale-refresh-token replays from concurrent
-					// sessions (one-turn 401 "Invalid authentication credentials").
+					// A failed preflight already exercised the provider refresh path.
+					// Do not replay the same refresh token in the final candidate pass.
+					const errorMsg = String(error);
+					const isDefinitiveFailure = AIError.isDefinitiveOAuthFailure(errorMsg);
 					logger.debug("OAuth preflight refresh failed", {
 						provider,
 						index: candidate.selection.index,
-						error: String(error),
+						error: errorMsg,
+						isDefinitiveFailure,
 					});
+					if (isDefinitiveFailure) {
+						// A dead grant discovered during preflight must be disabled here too —
+						// the final candidate pass below skips every `preflightFailures` entry,
+						// so if this branch only blocked the row (like the transient case), the
+						// definitive failure would never reach `#tryOAuthCredential`'s own
+						// disable logic and the row would be retried forever instead of torn down.
+						const outcome = await this.#disableDefinitiveOAuthFailure(
+							provider,
+							credentialId,
+							candidate.selection.credential,
+							candidate.selection.index,
+							errorMsg,
+						);
+						if (
+							outcome !== "disabled" &&
+							credentialId !== undefined &&
+							this.#syncOAuthSelectionFromStore(provider, candidate.selection, credentialId)
+						) {
+							// A peer rotated this row (or won the disable CAS) between our
+							// snapshot and the refresh; the helper reloaded storage and the row
+							// still exists, so it now holds a valid, freshly rotated credential.
+							// Re-sync the candidate onto it and leave it eligible so the final
+							// pass retries with the live token instead of stranding it (mirrors
+							// #tryOAuthCredential's peer-rotated re-resolve). If the peer instead
+							// deleted/disabled the row, the re-sync fails and we fall through to
+							// preflightFailures — leaving a stale index could rebind the candidate
+							// to a sibling account with the wrong prefetched usage/plan.
+							return;
+						}
+					} else if (credentialId !== undefined) {
+						const latestIndex = this.#getStoredCredentials(provider).findIndex(
+							entry => entry.id === credentialId,
+						);
+						if (latestIndex !== -1) {
+							this.#markCredentialBlocked(
+								provider,
+								providerKey,
+								latestIndex,
+								Date.now() + OAUTH_REFRESH_FAILURE_BACKOFF_MS,
+								blockScope,
+							);
+						}
+					}
+					preflightFailures.add(candidate);
 				}
 			}),
 		);
@@ -4975,6 +5045,7 @@ export class AuthStorage {
 
 		for (const pass of passes) {
 			for (const candidate of candidates) {
+				if (preflightFailures.has(candidate)) continue;
 				const resolved = await this.#tryOAuthCredential(
 					provider,
 					candidate.selection,
@@ -5001,6 +5072,73 @@ export class AuthStorage {
 		return undefined;
 	}
 
+	/**
+	 * Handles a definitively-dead OAuth grant discovered during refresh (`invalid_grant`,
+	 * `revoked`, …): checks for a peer rotation that raced the failure, then CAS-disables
+	 * the row and emits `credential_disabled`. Shared by the eager preflight refresh in
+	 * {@link AuthStorage.#resolveOAuthSelection} and the final-candidate refresh in
+	 * {@link AuthStorage.#tryOAuthCredential} so both actually disable the credential — not
+	 * just temporarily block it — on a definitive failure.
+	 *
+	 * Returns `"disabled"` once the row is torn down, `"peer-rotated"` when a concurrent
+	 * process refreshed the same row first (the persisted refresh token no longer matches
+	 * what we attempted — the caller should reload and retry with the new credential), or
+	 * `"cas-lost"` when the disable itself lost a race and the caller should reload before
+	 * continuing.
+	 */
+	async #disableDefinitiveOAuthFailure(
+		provider: string,
+		credentialId: number | undefined,
+		attemptedCredential: OAuthCredential,
+		index: number,
+		errorMsg: string,
+	): Promise<"disabled" | "peer-rotated" | "cas-lost"> {
+		// The credential at this index may have been rotated by another process between
+		// our in-memory snapshot and the refresh attempt: Anthropic rotates refresh
+		// tokens on every use, so the peer's success leaves our stored token invalid.
+		// Re-read the row from disk before marking it disabled — if the persisted
+		// refresh token has changed, the peer rotation succeeded and we should pick
+		// up the new credential instead of soft-deleting the row that the peer just
+		// updated.
+		if (credentialId !== undefined) {
+			const latestRow = this.#store.listAuthCredentials(provider).find(row => row.id === credentialId);
+			const latestCredential = latestRow?.credential;
+			if (latestCredential?.type === "oauth" && latestCredential.refresh !== attemptedCredential.refresh) {
+				logger.debug("OAuth refresh race detected; another process rotated token first", {
+					provider,
+					index,
+					credentialId,
+				});
+				await this.reload();
+				return "peer-rotated";
+			}
+		}
+		// Permanently disable invalid credentials with an explicit cause for inspection/debugging.
+		// Use a CAS-style disable conditioned on the row still containing the stale credential
+		// we tried to refresh, so a peer rotation that lands between the pre-check above and
+		// this disable doesn't soft-delete the freshly-rotated row.
+		const disabled =
+			credentialId !== undefined
+				? this.#disableCredentialByIdIfMatches(
+						provider,
+						credentialId,
+						attemptedCredential,
+						`oauth refresh failed: ${errorMsg}`,
+					)
+				: this.#tryDisableCredentialAtIfMatches(
+						provider,
+						index,
+						attemptedCredential,
+						`oauth refresh failed: ${errorMsg}`,
+					);
+		if (!disabled) {
+			logger.debug("OAuth refresh disable lost CAS; reloading after peer rotation", { provider, index });
+			await this.reload();
+			return "cas-lost";
+		}
+		return "disabled";
+	}
+
 	async #refreshOAuthCredential(
 		provider: Provider,
 		credential: OAuthCredential,
@@ -5048,8 +5186,31 @@ export class AuthStorage {
 						credentialId,
 						signal && refreshSignal ? AbortSignal.any([signal, refreshSignal]) : (signal ?? refreshSignal),
 					),
+				isDefinitiveFailure: error => AIError.isDefinitiveOAuthFailure(String(error)),
+				disabledCause: error => `oauth refresh failed: ${String(error)}`,
 			});
-			if (result.credential) return result.credential;
+			if (result.credential) {
+				if (result.refreshed) {
+					// We performed this refresh ourselves — trust the provider's new token
+					// even when its lifetime is shorter than the refresh skew (some grants
+					// are legitimately short-lived); the next resolve simply treats it as
+					// due for refresh again instead of rejecting a token we just minted.
+					if (Date.now() < result.credential.expires) return result.credential;
+				} else if (Date.now() + OAUTH_REFRESH_SKEW_MS < result.credential.expires) {
+					// Reloaded (not refreshed by us) credential — match #refreshOAuthCredential's
+					// freshness contract: a reload within the refresh skew still counts as
+					// needing refresh, so returning it here would make the final candidate pass
+					// refresh the same row again and replay the token we just failed on.
+					return result.credential;
+				}
+				throw new AIError.OAuthError(
+					`OAuth refresh did not produce a usable credential for provider: ${provider}`,
+					{
+						kind: "token-refresh",
+						provider,
+					},
+				);
+			}
 			throw new AIError.OAuthError(`OAuth credential no longer exists for provider: ${provider}`, {
 				kind: "token-refresh",
 				provider,
@@ -5081,9 +5242,9 @@ export class AuthStorage {
 						provider,
 					});
 				}
-				refreshPromise = customProvider.refreshToken(credential);
+				refreshPromise = customProvider.refreshToken(credential, signal);
 			} else {
-				refreshPromise = refreshOAuthToken(provider as OAuthProvider, credential);
+				refreshPromise = refreshOAuthToken(provider as OAuthProvider, credential, signal);
 			}
 		}
 		// Bound the refresh so a slow/hanging token endpoint cannot stall credential selection.
@@ -5335,58 +5496,29 @@ export class AuthStorage {
 			});
 
 			if (isDefinitiveFailure) {
-				// The credential at this index may have been rotated by another process between
-				// our in-memory snapshot and the refresh attempt: Anthropic rotates refresh
-				// tokens on every use, so the peer's success leaves our stored token invalid.
-				// Re-read the row from disk before marking it disabled — if the persisted
-				// refresh token has changed, the peer rotation succeeded and we should pick
-				// up the new credential instead of soft-deleting the row that the peer just
-				// updated.
-				if (credentialId !== undefined) {
-					const latestRow = this.#store.listAuthCredentials(provider).find(row => row.id === credentialId);
-					const latestCredential = latestRow?.credential;
-					if (latestCredential?.type === "oauth" && latestCredential.refresh !== selection.credential.refresh) {
-						logger.debug("OAuth refresh race detected; another process rotated token first", {
-							provider,
-							index: selection.index,
-							credentialId,
-						});
-						await this.reload();
-						if (allowFallback) return this.#resolveOAuthSelection(provider, sessionId, options);
-					}
-				}
-				// Permanently disable invalid credentials with an explicit cause for inspection/debugging.
-				// Use a CAS-style disable conditioned on the row still containing the stale credential
-				// we tried to refresh, so a peer rotation that lands between the pre-check above and
-				// this disable doesn't soft-delete the freshly-rotated row.
-				const disabled =
-					credentialId !== undefined
-						? this.#disableCredentialByIdIfMatches(
-								provider,
-								credentialId,
-								selection.credential,
-								`oauth refresh failed: ${errorMsg}`,
-							)
-						: this.#tryDisableCredentialAtIfMatches(
-								provider,
-								selection.index,
-								selection.credential,
-								`oauth refresh failed: ${errorMsg}`,
-							);
-				if (!disabled) {
-					logger.debug("OAuth refresh disable lost CAS; reloading after peer rotation", {
-						provider,
-						index: selection.index,
-					});
-					await this.reload();
+				const outcome = await this.#disableDefinitiveOAuthFailure(
+					provider,
+					credentialId,
+					selection.credential,
+					selection.index,
+					errorMsg,
+				);
+				if (outcome === "peer-rotated") {
 					if (allowFallback) return this.#resolveOAuthSelection(provider, sessionId, options);
+					return undefined;
 				}
+				if (outcome === "cas-lost") return undefined;
 				if (this.#getCredentialsForProvider(provider).some(credential => credential.type === "oauth")) {
 					if (allowFallback) return this.#resolveOAuthSelection(provider, sessionId, options);
 				}
 			} else {
 				// Block temporarily for transient failures (5 minutes)
-				this.#markCredentialBlocked(provider, providerKey, selection.index, Date.now() + 5 * 60 * 1000);
+				this.#markCredentialBlocked(
+					provider,
+					providerKey,
+					selection.index,
+					Date.now() + OAUTH_REFRESH_FAILURE_BACKOFF_MS,
+				);
 			}
 		}
 
@@ -5891,6 +6023,28 @@ export class AuthStorage {
 		}
 	}
 
+	/**
+	 * Expire cached reports for a provider after its runtime usage implementation changes.
+	 * This keeps a newly installed extension provider from serving a built-in snapshot.
+	 */
+	#invalidateUsageReportCacheForProvider(provider: Provider): void {
+		this.#usageCacheEpoch += 1;
+		const expired = Date.now() - 1;
+		const prefix = `report:${this.#usageCacheProviderKey(provider)}:`;
+		if (this.#usageCache.deletePrefix(prefix)) return;
+		const cacheKeys = new Set(this.#usageReportCacheKeysByProvider.get(provider));
+		for (const entry of this.#getStoredCredentials(provider)) {
+			cacheKeys.add(
+				this.#buildUsageReportCacheKey({
+					provider,
+					credential: this.#buildUsageCredential(entry.credential),
+				}),
+			);
+		}
+		for (const cacheKey of cacheKeys) {
+			this.#usageCache.set(cacheKey, { value: null, expiresAt: expired });
+		}
+	}
 	/**
 	 * Drop report snapshots for a user-requested refresh so a failed probe
 	 * cannot replay the pre-invalidation last-good value. The persisted marker

package/src/dialect/qwen-xml.ts

@@ -0,0 +1,82 @@
+import type { InbandScanEvent, InbandScanner } from "./types";
+
+const SECTION_OPEN = "<tool_calls>";
+const SECTION_CLOSE = "</tool_calls>";
+const TOOL_ELEMENT = /^<([A-Za-z_][\w.-]*)(\s[^<>]*?)?\s*\/>$/s;
+const ATTRIBUTE = /([A-Za-z_][\w.-]*)\s*=\s*("([^"]*)"|'([^']*)')/g;
+
+export class QwenXmlInbandScanner implements InbandScanner {
+	#buffer = "";
+	#insideSection = false;
+
+	feed(chunk: string): InbandScanEvent[] {
+		this.#buffer += chunk;
+		return this.#drain(false);
+	}
+
+	flush(): InbandScanEvent[] {
+		return this.#drain(true);
+	}
+
+	#drain(flush: boolean): InbandScanEvent[] {
+		const events: InbandScanEvent[] = [];
+		while (this.#buffer.length > 0) {
+			if (!this.#insideSection) {
+				const open = this.#buffer.indexOf(SECTION_OPEN);
+				if (open >= 0) {
+					if (open > 0) events.push({ type: "text", text: this.#buffer.slice(0, open) });
+					this.#buffer = this.#buffer.slice(open + SECTION_OPEN.length);
+					this.#insideSection = true;
+					continue;
+				}
+				if (flush) {
+					events.push({ type: "text", text: this.#buffer });
+					this.#buffer = "";
+					break;
+				}
+				const held = longestSuffixPrefix(this.#buffer, SECTION_OPEN);
+				const visibleLength = this.#buffer.length - held;
+				if (visibleLength > 0) {
+					events.push({ type: "text", text: this.#buffer.slice(0, visibleLength) });
+					this.#buffer = this.#buffer.slice(visibleLength);
+				}
+				break;
+			}
+
+			const close = this.#buffer.indexOf(SECTION_CLOSE);
+			if (close < 0) {
+				if (flush) this.#buffer = "";
+				break;
+			}
+			const section = this.#buffer.slice(0, close);
+			for (const element of section.match(/<[^<>]+\/>/gs) ?? []) {
+				const call = parseToolElement(element);
+				if (!call) continue;
+				const id = `call_${crypto.randomUUID().replace(/-/g, "").slice(0, 24)}`;
+				events.push({ type: "toolStart", id, name: call.name });
+				events.push({ type: "toolEnd", id, name: call.name, arguments: call.arguments, rawBlock: element });
+			}
+			this.#buffer = this.#buffer.slice(close + SECTION_CLOSE.length);
+			this.#insideSection = false;
+		}
+		return events;
+	}
+}
+
+function parseToolElement(element: string): { name: string; arguments: Record<string, unknown> } | undefined {
+	const match = TOOL_ELEMENT.exec(element);
+	if (!match) return undefined;
+	const args: Record<string, unknown> = {};
+	for (const attribute of match[2]?.matchAll(ATTRIBUTE) ?? []) {
+		args[attribute[1]!] = attribute[3] ?? attribute[4] ?? "";
+	}
+	return { name: match[1]!, arguments: args };
+}
+
+function longestSuffixPrefix(text: string, target: string): number {
+	const max = Math.min(text.length, target.length - 1);
+	for (let length = max; length > 0; length--) {
+		if (text.endsWith(target.slice(0, length))) return length;
+	}
+	return 0;
+}

package/src/error/auth-classify.ts

@@ -1,5 +1,6 @@
 import { extractHttpStatusFromError } from "@oh-my-pi/pi-utils";
 import { isAccountPolicyError, isOAuthExpiry, isUsageLimit } from "./flags";
+import { OAuthError } from "./oauth";
 import { isConcurrencyCapExclusion, isUsageLimitOutcome } from "./rate-limit";
 
 /**
@@ -25,16 +26,17 @@ export function isInvalidatedOAuthTokenError(error: unknown): boolean {
 }
 
 /**
- * Whether an upstream failure should rotate to a sibling credential: a hard
- * `401`, a `403` (token valid but access denied — plan, model policy, or org
- * restriction a sibling account may not share), an account-scoped policy
- * denial such as Codex `cyber_policy`, a body-classified usage limit (Codex
- * `usage_limit_reached`, Anthropic account rate-limit, Google
- * `resource_exhausted`, OpenAI `insufficient_quota`, …), or a bare `429`
- * whose payload did not preserve a richer quota code. Transient 429s
- * (`Too many requests`, per-minute caps) stay in the upstream-backoff lane.
+ * Whether an upstream failure should retry through the credential resolver: a
+ * typed token-refresh request, a hard `401`, a `403` (token valid but access
+ * denied — plan, model policy, or org restriction a sibling account may not
+ * share), an account-scoped policy denial such as Codex `cyber_policy`, a
+ * body-classified usage limit (Codex `usage_limit_reached`, Anthropic account
+ * rate-limit, Google `resource_exhausted`, OpenAI `insufficient_quota`, …), or
+ * a bare `429` whose payload did not preserve a richer quota code. Transient
+ * 429s (`Too many requests`, per-minute caps) stay in the upstream-backoff lane.
  */
 export function isAuthRetryableError(error: unknown): boolean {
+	if (error instanceof OAuthError && error.kind === "token-refresh") return true;
 	if (isUsageLimit(error)) return true;
 	if (isAccountPolicyError(error)) return true;
 	if (isInvalidatedOAuthTokenError(error)) return true;

package/src/error/oauth.ts

@@ -37,7 +37,8 @@ export interface OAuthErrorOptions {
 /**
  * A failure inside an interactive OAuth / device-code login flow. The `kind`
  * pinpoints the stage. Timeout/polling are classified transient; everything
- * else is a hard auth failure so the credential layer does not silently retry.
+ * else is a hard auth failure. The auth-retry classifier separately treats
+ * `token-refresh` as an explicit request to refresh and replay once.
  */
 export class OAuthError extends Error {
 	readonly kind: OAuthErrorKind;

package/src/providers/amazon-bedrock.ts

@@ -779,17 +779,6 @@ function takeCachePoint(policy: BedrockPromptCachePolicy): CachePoint | undefine
 	return { cachePoint: { type: "default", ...(policy.ttl ? { ttl: policy.ttl } : {}) } };
 }
 
-/**
- * Check if the model supports thinking signatures in reasoningContent.
- * Only Anthropic Claude models support the signature field.
- * Other models (Nova, Titan, Mistral, Llama, etc.) reject it with:
- * "This model doesn't support the reasoningContent.reasoningText.signature field"
- */
-function supportsThinkingSignature(model: Model<"bedrock-converse-stream">): boolean {
-	const id = model.id.toLowerCase();
-	return id.includes("anthropic.claude") || id.includes("anthropic/claude");
-}
-
 function buildSystemPrompt(
 	systemPrompt: readonly string[] | string | undefined,
 	promptCachePolicy: BedrockPromptCachePolicy,
@@ -869,21 +858,25 @@ function convertMessages(
 						case "thinking":
 							// Skip empty thinking blocks
 							if (c.thinking.trim().length === 0) continue;
-							// A captured signature is authoritative even when the model id is an opaque ARN.
-							// Without one, known non-Claude families use unsigned reasoning; known Claude ids demote to text.
+							// A captured signature is authoritative even when the model id is an opaque ARN:
+							// only a model that itself streamed a signature (Claude) can have one, so replay
+							// it as signed reasoningContent regardless of how the id is spelled.
 							if (c.thinkingSignature) {
 								contentBlocks.push({
 									reasoningContent: {
 										reasoningText: { text: c.thinking.toWellFormed(), signature: c.thinkingSignature },
 									},
 								});
-							} else if (!supportsThinkingSignature(model)) {
-								// Model doesn't support signatures at all — send as unsigned reasoning
-								contentBlocks.push({
-									reasoningContent: { reasoningText: { text: c.thinking.toWellFormed() } },
-								});
 							} else {
-								// Model requires signature but we don't have one — demote to text
+								// No signature was captured. Do NOT fall back to unsigned reasoningContent here:
+								// a model streaming reasoningContent does not imply it accepts reasoningContent
+								// echoed back in a request. Amazon Nova streams unsigned reasoning just fine but
+								// rejects it on replay with HTTP 400 "User messages cannot contain reasoning
+								// content. Please remove the reasoning content and try again.", which wedges the
+								// agent loop on every turn after the first. Demote to plain text instead — the
+								// content survives, just no longer typed as a reasoning block. This matches how
+								// every other provider (Anthropic, Google, OpenAI-completions) handles thinking
+								// blocks it can't safely replay.
 								contentBlocks.push({ text: renderDemotedThinking(model.id, c.thinking) });
 							}
 							break;