@sayknow-cli/ai 0.3.6 → 0.3.8

package/package.json

@@ -1,9 +1,9 @@
 {
 	"type": "module",
 	"name": "@sayknow-cli/ai",
-	"version": "0.3.6",
+	"version": "0.3.8",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
-	"homepage": "https://github.com/jaybeyond/Sayknow_CLI",
+	"homepage": "https://sayknow-cli.com",
 	"author": "jaybeyond",
 	"contributors": [
 		"Mario Zechner"
@@ -27,7 +27,7 @@
 		"api"
 	],
 	"main": "./src/index.ts",
-	"types": "./src/index.ts",
+	"types": "./dist/types/index.d.ts",
 	"bin": {
 		"pi-ai": "./src/cli.ts"
 	},
@@ -43,7 +43,7 @@
 	"dependencies": {
 		"@anthropic-ai/sdk": "^0.94.0",
 		"@bufbuild/protobuf": "^2.12.0",
-		"@sayknow-cli/utils": "0.3.6",
+		"@sayknow-cli/utils": "0.3.8",
 		"openai": "^6.36.0",
 		"partial-json": "^0.1.7",
 		"zod": "4.4.3"
@@ -57,87 +57,88 @@
 	"files": [
 		"src",
 		"README.md",
-		"CHANGELOG.md"
+		"CHANGELOG.md",
+		"dist/types"
 	],
 	"exports": {
 		".": {
-			"types": "./src/index.ts",
+			"types": "./dist/types/index.d.ts",
 			"import": "./src/index.ts"
 		},
 		"./*": {
-			"types": "./src/*.ts",
+			"types": "./dist/types/*.d.ts",
 			"import": "./src/*.ts"
 		},
 		"./auth-broker": {
-			"types": "./src/auth-broker/index.ts",
+			"types": "./dist/types/auth-broker/index.d.ts",
 			"import": "./src/auth-broker/index.ts"
 		},
 		"./auth-broker/*": {
-			"types": "./src/auth-broker/*.ts",
+			"types": "./dist/types/auth-broker/*.d.ts",
 			"import": "./src/auth-broker/*.ts"
 		},
 		"./auth-gateway": {
-			"types": "./src/auth-gateway/index.ts",
+			"types": "./dist/types/auth-gateway/index.d.ts",
 			"import": "./src/auth-gateway/index.ts"
 		},
 		"./auth-gateway/*": {
-			"types": "./src/auth-gateway/*.ts",
+			"types": "./dist/types/auth-gateway/*.d.ts",
 			"import": "./src/auth-gateway/*.ts"
 		},
 		"./models.json": {
-			"types": "./src/models.json.d.ts",
+			"types": "./dist/types/models.json.d.d.ts",
 			"import": "./src/models.json"
 		},
 		"./provider-models": {
-			"types": "./src/provider-models/index.ts",
+			"types": "./dist/types/provider-models/index.d.ts",
 			"import": "./src/provider-models/index.ts"
 		},
 		"./provider-models/*": {
-			"types": "./src/provider-models/*.ts",
+			"types": "./dist/types/provider-models/*.d.ts",
 			"import": "./src/provider-models/*.ts"
 		},
 		"./providers/*": {
-			"types": "./src/providers/*.ts",
+			"types": "./dist/types/providers/*.d.ts",
 			"import": "./src/providers/*.ts"
 		},
 		"./providers/cursor/gen/*": {
-			"types": "./src/providers/cursor/gen/*.ts",
+			"types": "./dist/types/providers/cursor/gen/*.d.ts",
 			"import": "./src/providers/cursor/gen/*.ts"
 		},
 		"./providers/openai-codex/*": {
-			"types": "./src/providers/openai-codex/*.ts",
+			"types": "./dist/types/providers/openai-codex/*.d.ts",
 			"import": "./src/providers/openai-codex/*.ts"
 		},
 		"./usage/*": {
-			"types": "./src/usage/*.ts",
+			"types": "./dist/types/usage/*.d.ts",
 			"import": "./src/usage/*.ts"
 		},
 		"./utils/*": {
-			"types": "./src/utils/*.ts",
+			"types": "./dist/types/utils/*.d.ts",
 			"import": "./src/utils/*.ts"
 		},
 		"./utils/discovery": {
-			"types": "./src/utils/discovery/index.ts",
+			"types": "./dist/types/utils/discovery/index.d.ts",
 			"import": "./src/utils/discovery/index.ts"
 		},
 		"./utils/discovery/*": {
-			"types": "./src/utils/discovery/*.ts",
+			"types": "./dist/types/utils/discovery/*.d.ts",
 			"import": "./src/utils/discovery/*.ts"
 		},
 		"./utils/oauth": {
-			"types": "./src/utils/oauth/index.ts",
+			"types": "./dist/types/utils/oauth/index.d.ts",
 			"import": "./src/utils/oauth/index.ts"
 		},
 		"./utils/oauth/*": {
-			"types": "./src/utils/oauth/*.ts",
+			"types": "./dist/types/utils/oauth/*.d.ts",
 			"import": "./src/utils/oauth/*.ts"
 		},
 		"./utils/schema": {
-			"types": "./src/utils/schema/index.ts",
+			"types": "./dist/types/utils/schema/index.d.ts",
 			"import": "./src/utils/schema/index.ts"
 		},
 		"./utils/schema/*": {
-			"types": "./src/utils/schema/*.ts",
+			"types": "./dist/types/utils/schema/*.d.ts",
 			"import": "./src/utils/schema/*.ts"
 		},
 		"./*.js": "./src/*.ts"

package/src/auth-broker/remote-store.ts

@@ -86,6 +86,7 @@ export class RemoteAuthCredentialStore implements AuthCredentialStore {
 	#cache: Map<string, CacheEntry> = new Map();
 	#usageCache?: UsageCacheEntry;
 	#usageInflight?: Promise<UsageReport[] | null>;
+	#usageCacheEpoch = 0;
 	#closed = false;
 	/**
 	 * `true` once the SSE consumer received its first frame and hasn't dropped
@@ -465,6 +466,19 @@ export class RemoteAuthCredentialStore implements AuthCredentialStore {
 		}
 	}
 
+	deleteCachePrefix(prefix: string): void {
+		for (const key of this.#cache.keys()) {
+			if (key.startsWith(prefix)) this.#cache.delete(key);
+		}
+		if (prefix.startsWith("usage_cache:")) this.#invalidateUsageCache();
+	}
+
+	#invalidateUsageCache(): void {
+		this.#usageCache = undefined;
+		this.#usageInflight = undefined;
+		this.#usageCacheEpoch += 1;
+	}
+
 	/**
 	 * Store-level hook consumed by `AuthStorage` — routes refresh through the
 	 * broker so the actual refresh token never leaves the broker host. Returns
@@ -561,10 +575,11 @@ export class RemoteAuthCredentialStore implements AuthCredentialStore {
 			return Promise.resolve(cached.reports);
 		}
 		if (this.#usageInflight) return this.#usageInflight;
+		const epoch = this.#usageCacheEpoch;
 		const inflight = this.#client
 			.fetchUsage()
 			.then(body => {
-				this.#usageCache = { reports: body.reports, fetchedAt: Date.now() };
+				if (this.#usageCacheEpoch === epoch) this.#usageCache = { reports: body.reports, fetchedAt: Date.now() };
 				return body.reports;
 			})
 			.catch(error => {
@@ -572,7 +587,7 @@ export class RemoteAuthCredentialStore implements AuthCredentialStore {
 				return null;
 			})
 			.finally(() => {
-				this.#usageInflight = undefined;
+				if (this.#usageCacheEpoch === epoch) this.#usageInflight = undefined;
 			});
 		this.#usageInflight = inflight;
 		return inflight;

package/src/auth-broker/wire-schemas.ts

@@ -187,6 +187,7 @@ export const credentialDisableResponseSchema = z
 // ─── Upload ────────────────────────────────────────────────────────────────
 const credentialIfAbsentReasonSchema = z.enum([
 	"inserted",
+	"updated-existing",
 	"skipped-existing",
 	"skipped-existing-runtime",
 	"skipped-existing-config",

package/src/auth-storage.ts

@@ -32,6 +32,7 @@ import { kimiUsageProvider } from "./usage/kimi";
 import { codexRankingStrategy, openaiCodexUsageProvider } from "./usage/openai-codex";
 import { zaiUsageProvider } from "./usage/zai";
 import { getOAuthApiKey, getOAuthProvider, refreshOAuthToken, resolveOAuthStorageProvider } from "./utils/oauth";
+import { loginDeepInfra } from "./utils/oauth/deepinfra";
 import { loginDeepSeek } from "./utils/oauth/deepseek";
 import { loginOpenAICodexDevice } from "./utils/oauth/openai-codex";
 import type { OAuthController, OAuthCredentials, OAuthProvider, OAuthProviderId } from "./utils/oauth/types";
@@ -153,6 +154,7 @@ export interface AuthCredentialSnapshotEntry {
 
 export type AuthCredentialIfAbsentReason =
 	| "inserted"
+	| "updated-existing"
 	| "skipped-existing"
 	| "skipped-existing-runtime"
 	| "skipped-existing-config"
@@ -209,6 +211,7 @@ export interface AuthCredentialStore {
 	deleteAuthCredentialsForProvider(provider: string, disabledCause: string): void;
 	getCache(key: string, options?: { includeExpired?: boolean }): string | null;
 	setCache(key: string, value: string, expiresAtSec: number): void;
+	deleteCachePrefix?(prefix: string): void;
 	cleanExpiredCache(): void;
 	/**
 	 * Optional store-supplied OAuth refresh. When present, `AuthStorage` uses
@@ -471,6 +474,7 @@ interface UsageCache {
 	get<T>(key: string): UsageCacheEntry<T> | undefined;
 	getStale<T>(key: string): UsageCacheEntry<T> | undefined;
 	set<T>(key: string, entry: UsageCacheEntry<T>): void;
+	deletePrefix?(prefix: string): void;
 	cleanup?(): void;
 }
 
@@ -661,6 +665,10 @@ class AuthStorageUsageCache implements UsageCache {
 		this.store.setCache(`${USAGE_CACHE_PREFIX}${key}`, payload, Math.floor(durableExpiresAt / 1000));
 	}
 
+	deletePrefix(prefix: string): void {
+		this.store.deleteCachePrefix?.(`${USAGE_CACHE_PREFIX}${prefix}`);
+	}
+
 	cleanup(): void {
 		this.store.cleanExpiredCache();
 	}
@@ -1296,8 +1304,6 @@ export class AuthStorage {
 			return this.#snapshotSkipResult(storageProvider, "skipped-existing-runtime");
 		if (this.#configOverrides.has(storageProvider))
 			return this.#snapshotSkipResult(storageProvider, "skipped-existing-config");
-		if (this.#getCredentialsForProvider(storageProvider).length > 0)
-			return this.#snapshotSkipResult(storageProvider, "skipped-existing");
 		if (getEnvApiKey(storageProvider)) return this.#snapshotSkipResult(storageProvider, "skipped-existing-env");
 		if (this.#fallbackResolver?.(storageProvider))
 			return this.#snapshotSkipResult(storageProvider, "skipped-existing-fallback");
@@ -1310,6 +1316,7 @@ export class AuthStorage {
 			result.entries.map(entry => ({ id: entry.id, credential: entry.credential })),
 		);
 		this.#resetProviderAssignments(storageProvider);
+		if (result.inserted) this.#invalidateUsageCacheForProvider(storageProvider);
 		return {
 			inserted: result.inserted,
 			reason: result.reason,
@@ -1327,6 +1334,13 @@ export class AuthStorage {
 			stored.map(record => ({ id: record.id, credential: record.credential })),
 		);
 		this.#resetProviderAssignments(provider);
+		this.#invalidateUsageCacheForProvider(provider);
+	}
+
+	#invalidateUsageCacheForProvider(provider: string): void {
+		this.#usageRequestInFlight.clear();
+		this.#usageReportsInFlight.clear();
+		this.#usageCache.deletePrefix?.(`report:${provider}:`);
 	}
 
 	/**
@@ -1593,6 +1607,11 @@ export class AuthStorage {
 				await saveApiKeyCredential(apiKey);
 				return;
 			}
+			case "deepinfra": {
+				const apiKey = await loginDeepInfra(ctrl);
+				await saveApiKeyCredential(apiKey);
+				return;
+			}
 			case "xai": {
 				const { loginXai } = await import("./utils/oauth/xai");
 				credentials = await loginXai({
@@ -3699,6 +3718,7 @@ export class SqliteAuthCredentialStore implements AuthCredentialStore {
 	#getCacheStmt: Statement;
 	#getCacheIncludingExpiredStmt: Statement;
 	#upsertCacheStmt: Statement;
+	#deleteCachePrefixStmt: Statement;
 	#deleteExpiredCacheStmt: Statement;
 	#closed = false;
 
@@ -3738,6 +3758,7 @@ export class SqliteAuthCredentialStore implements AuthCredentialStore {
 		this.#upsertCacheStmt = this.#db.prepare(
 			"INSERT INTO cache (key, value, expires_at) VALUES (?, ?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value, expires_at = excluded.expires_at",
 		);
+		this.#deleteCachePrefixStmt = this.#db.prepare("DELETE FROM cache WHERE substr(key, 1, ?) = ?");
 		this.#deleteExpiredCacheStmt = this.#db.prepare(`DELETE FROM cache WHERE expires_at <= ${SQLITE_NOW_EPOCH}`);
 	}
 
@@ -4096,16 +4117,58 @@ export class SqliteAuthCredentialStore implements AuthCredentialStore {
 		}
 
 		const writeIfAbsent = this.#db.transaction(
-			(providerName: string, record: SerializedCredentialRecord): AuthCredentialIfAbsentResult => {
+			(
+				providerName: string,
+				item: AuthCredential,
+				record: SerializedCredentialRecord,
+			): AuthCredentialIfAbsentResult => {
 				const existingRows = this.#listActiveByProviderStmt.all(providerName) as AuthRow[];
-				const existing: StoredAuthCredential[] = [];
+				const existing: Array<{
+					id: number;
+					credential: AuthCredential;
+					identityKey: string | null;
+				}> = [];
 				for (const row of existingRows) {
 					const activeCredential = deserializeCredential(row);
 					if (!activeCredential) continue;
-					existing.push(toStoredAuthCredential(row, activeCredential));
+					existing.push({
+						id: row.id,
+						credential: activeCredential,
+						identityKey: resolveRowCredentialIdentityKey(providerName, row),
+					});
 				}
 				if (existing.length > 0) {
-					return { inserted: false, reason: "skipped-existing", provider: providerName, entries: existing };
+					let targetId: number | null = null;
+					for (const row of existing) {
+						if (!matchesReplacementCredential(providerName, row.credential, row.identityKey, item)) continue;
+						if (targetId === null) {
+							targetId = row.id;
+							this.#updateStmt.run(record.credentialType, record.data, record.identityKey, row.id);
+						} else {
+							this.#deleteStmt.run("replaced by newer credential", row.id);
+						}
+					}
+
+					if (targetId !== null) {
+						return {
+							inserted: true,
+							reason: "updated-existing",
+							provider: providerName,
+							entries: this.listAuthCredentials(providerName),
+						};
+					}
+
+					return {
+						inserted: false,
+						reason: "skipped-existing",
+						provider: providerName,
+						entries: existing.map(row => ({
+							id: row.id,
+							provider: providerName,
+							credential: row.credential,
+							disabledCause: null,
+						})),
+					};
 				}
 
 				this.#insertStmt.get(providerName, record.credentialType, record.data, record.identityKey);
@@ -4118,7 +4181,9 @@ export class SqliteAuthCredentialStore implements AuthCredentialStore {
 			},
 		);
 
-		return writeIfAbsent.immediate(provider, serialized);
+		const result = writeIfAbsent.immediate(provider, credential, serialized);
+		if (result.inserted) this.#purgeSupersededDisabledRows(provider, result.entries);
+		return result;
 	}
 
 	/**
@@ -4215,6 +4280,13 @@ export class SqliteAuthCredentialStore implements AuthCredentialStore {
 		}
 	}
 
+	deleteCachePrefix(prefix: string): void {
+		if (prefix.length === 0) return;
+		try {
+			this.#deleteCachePrefixStmt.run(prefix.length, prefix);
+		} catch {}
+	}
+
 	cleanExpiredCache(): void {
 		try {
 			this.#deleteExpiredCacheStmt.run();
@@ -4305,6 +4377,7 @@ export class SqliteAuthCredentialStore implements AuthCredentialStore {
 		this.#getCacheStmt.finalize();
 		this.#getCacheIncludingExpiredStmt.finalize();
 		this.#upsertCacheStmt.finalize();
+		this.#deleteCachePrefixStmt.finalize();
 		this.#deleteExpiredCacheStmt.finalize();
 		this.#db.close();
 	}

package/src/providers/amazon-bedrock.ts

@@ -28,7 +28,7 @@ import type {
 	ToolChoice,
 	ToolResultMessage,
 } from "../types";
-import { normalizeToolCallId, resolveCacheRetention } from "../utils";
+import { normalizeToolCallId, resolveCacheRetention, sanitizeJsonStrings } from "../utils";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { appendRawHttpRequestDumpFor400, type RawHttpRequestDump, withHttpStatus } from "../utils/http-inspector";
 import { parseStreamingJson } from "../utils/json-parse";
@@ -701,7 +701,7 @@ function convertMessages(
 								toolUse: {
 									toolUseId: normalizeToolCallId(c.id),
 									name: c.name,
-									input: c.arguments,
+									input: sanitizeJsonStrings(c.arguments),
 								},
 							});
 							break;

package/src/providers/anthropic-messages-server.ts

@@ -13,6 +13,7 @@ import type {
 	ToolResultMessage,
 	UserMessage,
 } from "../types";
+import { sanitizeJsonStrings } from "../utils";
 import {
 	type AnthropicAssistantContentBlock,
 	type AnthropicMessage,
@@ -433,7 +434,7 @@ function encodeContentBlocks(message: AssistantMessage): Record<string, unknown>
 				blocks.push({ type: "redacted_thinking", data: c.data });
 				break;
 			case "toolCall":
-				blocks.push({ type: "tool_use", id: c.id, name: c.name, input: c.arguments ?? {} });
+				blocks.push({ type: "tool_use", id: c.id, name: c.name, input: sanitizeJsonStrings(c.arguments ?? {}) });
 				break;
 		}
 	}

package/src/providers/anthropic.ts

@@ -21,6 +21,7 @@ import {
 } from "@sayknow-cli/utils";
 import { hasOpus47ApiRestrictions, mapEffortToAnthropicAdaptiveEffort } from "../model-thinking";
 import { calculateCost } from "../models";
+import { isUsageLimitError } from "../rate-limit-utils";
 import { getEnvApiKey, OUTPUT_FALLBACK_BUFFER } from "../stream";
 import type {
 	Api,
@@ -52,6 +53,7 @@ import {
 	normalizeSystemPrompts,
 	normalizeToolCallId,
 	resolveCacheRetention,
+	sanitizeJsonStrings,
 } from "../utils";
 import { createAbortSourceTracker } from "../utils/abort";
 import { AssistantMessageEventStream } from "../utils/event-stream";
@@ -62,6 +64,7 @@ import { parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse";
 import { parseGitHubCopilotApiKey } from "../utils/oauth/github-copilot";
 import { notifyProviderResponse } from "../utils/provider-response";
 import { isCopilotTransientModelError } from "../utils/retry";
+import { getRetryAfterMsFromHeaders } from "../utils/retry-after";
 import { resolveRetryBudget } from "../utils/retry-budget";
 import {
 	COMBINATOR_KEYS,
@@ -724,6 +727,7 @@ export type AnthropicClientOptionsArgs = {
 	onSseEvent?: AnthropicOptions["onSseEvent"];
 	fetch?: FetchImpl;
 	requestMaxRetries?: number;
+	maxRetryDelayMs?: number;
 };
 
 export type AnthropicClientOptionsResult = {
@@ -877,6 +881,101 @@ function mergeHeaders(...headerSources: (Record<string, string> | undefined)[]):
 	return merged;
 }
 
+const ANTHROPIC_RETRY_DELAY_CAP_MS = 60_000;
+const ANTHROPIC_RATE_LIMIT_HEADER_PREFIX = "anthropic-ratelimit-";
+
+function getSafeAnthropicHeaderEvidence(headers: Headers): string[] {
+	const evidence: string[] = [];
+	for (const [name, value] of headers) {
+		const lowerName = name.toLowerCase();
+		if (
+			lowerName === "retry-after" ||
+			lowerName === "retry-after-ms" ||
+			lowerName.startsWith(ANTHROPIC_RATE_LIMIT_HEADER_PREFIX)
+		) {
+			evidence.push(`${lowerName}=${value}`);
+		}
+	}
+	return evidence.sort();
+}
+
+function getStringProperty(source: unknown, key: string): string | undefined {
+	if (!isRecord(source)) return undefined;
+	const value = source[key];
+	return typeof value === "string" ? value : undefined;
+}
+
+function appendAnthropicRateLimitEvidence(bodyText: string, headers: Headers): string {
+	const evidence = getSafeAnthropicHeaderEvidence(headers);
+	if (evidence.length === 0) return bodyText;
+
+	const suffix = ` Anthropic rate-limit evidence: ${evidence.join(", ")}`;
+	try {
+		const parsed = JSON.parse(bodyText) as unknown;
+		if (isRecord(parsed)) {
+			const error = parsed.error;
+			if (isRecord(error) && typeof error.message === "string" && !error.message.includes(suffix)) {
+				return JSON.stringify({ ...parsed, error: { ...error, message: `${error.message}${suffix}` } });
+			}
+			if (typeof parsed.message === "string" && !parsed.message.includes(suffix)) {
+				return JSON.stringify({ ...parsed, message: `${parsed.message}${suffix}` });
+			}
+		}
+	} catch {}
+
+	return bodyText.includes(suffix) ? bodyText : `${bodyText}${suffix}`;
+}
+
+function isAnthropicUsageExhaustionResponse(
+	bodyText: string,
+	headers: Headers,
+	retryAfterMs: number | undefined,
+	retryDelayCapMs: number,
+): boolean {
+	const overageReason = headers.get("anthropic-ratelimit-unified-overage-disabled-reason")?.toLowerCase();
+	if (overageReason === "out_of_credits") return true;
+	if (retryAfterMs !== undefined && retryAfterMs > retryDelayCapMs) return true;
+
+	try {
+		const parsed = JSON.parse(bodyText) as unknown;
+		const error = isRecord(parsed) ? parsed.error : undefined;
+		const type = getStringProperty(error, "type") ?? getStringProperty(parsed, "type");
+		const message = getStringProperty(error, "message") ?? getStringProperty(parsed, "message") ?? bodyText;
+		return (
+			/rate_limit_error/i.test(type ?? "") &&
+			(/request would exceed your account.?s rate limit/i.test(message) || /out_of_credits/i.test(message))
+		);
+	} catch {
+		return /request would exceed your account.?s rate limit|out_of_credits/i.test(bodyText);
+	}
+}
+
+function wrapAnthropicFetchForBoundedRateLimits(baseFetch: FetchImpl, maxRetryDelayMs: number | undefined): FetchImpl {
+	const retryDelayCapMs = maxRetryDelayMs ?? ANTHROPIC_RETRY_DELAY_CAP_MS;
+	return Object.assign(
+		async (input: string | URL | Request, init?: RequestInit): Promise<Response> => {
+			const response = await baseFetch(input, init);
+			if (response.status !== 429 || retryDelayCapMs === 0) return response;
+
+			const headers = new Headers(response.headers);
+			const retryAfterMs = getRetryAfterMsFromHeaders(headers);
+			const bodyText = await response
+				.clone()
+				.text()
+				.catch(() => "");
+			if (!isAnthropicUsageExhaustionResponse(bodyText, headers, retryAfterMs, retryDelayCapMs)) return response;
+
+			headers.set("x-should-retry", "false");
+			return new Response(appendAnthropicRateLimitEvidence(bodyText, headers), {
+				status: response.status,
+				statusText: response.statusText,
+				headers,
+			});
+		},
+		baseFetch.preconnect ? { preconnect: baseFetch.preconnect } : {},
+	);
+}
+
 // The Anthropic SDK logs malformed SSE frames directly before rethrowing them.
 // We surface the resulting provider error ourselves, so keep the SDK quiet.
 const ANTHROPIC_SDK_LOG_LEVEL = "off" as const;
@@ -1042,6 +1141,7 @@ export function isProviderRetryableError(error: unknown, provider?: string): boo
 	if (!(error instanceof Error)) return false;
 	if (provider === "github-copilot" && isCopilotTransientModelError(error)) return true;
 	const msg = error.message.toLowerCase();
+	if (isUsageLimitError(error.message)) return false;
 	if (
 		isUnexpectedSocketCloseMessage(msg) ||
 		/rate.?limit|too many requests|overloaded|service.?unavailable|internal_error|stream error.*received from peer|1302|timed?\s*out while waiting for the first event|timeout waiting for first/i.test(
@@ -1166,6 +1266,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 					onSseEvent: options?.onSseEvent,
 					fetch: options?.fetch,
 					requestMaxRetries: options?.requestMaxRetries,
+					maxRetryDelayMs: options?.maxRetryDelayMs,
 				});
 				client = created.client;
 				isOAuthToken = created.isOAuthToken;
@@ -1723,11 +1824,8 @@ export function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): A
 	const foundryCustomHeaders = resolveAnthropicCustomHeaders(model);
 	const tlsFetchOptions = buildClaudeCodeTlsFetchOptions(model, baseUrl);
 	const baseFetch = args.fetch ?? fetch;
-	const debugFetch = onSseEvent
-		? wrapFetchForSseDebug(baseFetch, event => onSseEvent(event, model))
-		: args.fetch
-			? baseFetch
-			: undefined;
+	const boundedFetch = wrapAnthropicFetchForBoundedRateLimits(baseFetch, args.maxRetryDelayMs);
+	const debugFetch = onSseEvent ? wrapFetchForSseDebug(boundedFetch, event => onSseEvent(event, model)) : boundedFetch;
 	if (model.provider === "github-copilot") {
 		const copilotApiKey = parseGitHubCopilotApiKey(apiKey).accessToken;
 		const betaFeatures = [...extraBetas];
@@ -1755,7 +1853,7 @@ export function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): A
 			dangerouslyAllowBrowser: true,
 			defaultHeaders,
 			logLevel: ANTHROPIC_SDK_LOG_LEVEL,
-			...(debugFetch ? { fetch: debugFetch } : {}),
+			fetch: debugFetch,
 			...(tlsFetchOptions ? { fetchOptions: tlsFetchOptions } : {}),
 		};
 	}
@@ -1789,7 +1887,7 @@ export function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): A
 			dangerouslyAllowBrowser: true,
 			defaultHeaders,
 			logLevel: ANTHROPIC_SDK_LOG_LEVEL,
-			...(debugFetch ? { fetch: debugFetch } : {}),
+			fetch: debugFetch,
 		};
 	}
 
@@ -1802,7 +1900,7 @@ export function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): A
 		dangerouslyAllowBrowser: true,
 		defaultHeaders,
 		logLevel: ANTHROPIC_SDK_LOG_LEVEL,
-		...(debugFetch ? { fetch: debugFetch } : {}),
+		fetch: debugFetch,
 		...(tlsFetchOptions ? { fetchOptions: tlsFetchOptions } : {}),
 	};
 }
@@ -2183,8 +2281,6 @@ function buildParams(
 					params.output_config = { effort } as typeof params.output_config;
 				}
 			}
-		} else if (options?.thinkingEnabled === false) {
-			params.thinking = { type: "disabled" };
 		}
 	}
 
@@ -2394,7 +2490,7 @@ export function convertAnthropicMessages(
 						type: "tool_use",
 						id: block.id,
 						name: isOAuthToken ? applyClaudeToolPrefix(block.name) : block.name,
-						input: block.arguments ?? {},
+						input: sanitizeJsonStrings(block.arguments ?? {}),
 					});
 				}
 			}

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

@@ -35,6 +35,7 @@ import {
 	markToolChoiceIncapability,
 	resolveToolChoice,
 } from "../utils/tool-choice-capability";
+import { wrapOpenAIFetchForBoundedRateLimits } from "./openai-bounded-rate-limits";
 import { normalizeOpenAIResponsesPromptCacheKey, supportsDeveloperRole } from "./openai-responses";
 import {
 	appendResponsesToolResultMessages,
@@ -272,7 +273,7 @@ function createClient(model: Model<"azure-openai-responses">, apiKey: string, op
 
 	const { baseUrl, apiVersion } = resolveAzureConfig(model, options);
 
-	const baseFetch = options?.fetch ?? fetch;
+	const baseFetch = wrapOpenAIFetchForBoundedRateLimits(options?.fetch ?? fetch, options?.maxRetryDelayMs);
 	const onSseEvent = options?.onSseEvent;
 	return new AzureOpenAI({
 		apiKey,

package/src/providers/google-shared.ts

@@ -18,7 +18,7 @@ import type {
 	Tool,
 	ToolCall,
 } from "../types";
-import { normalizeSystemPrompts } from "../utils";
+import { normalizeSystemPrompts, sanitizeJsonStrings } from "../utils";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { finalizeErrorMessage, type RawHttpRequestDump, withHttpStatus } from "../utils/http-inspector";
 import { normalizeSchemaForCCA, normalizeSchemaForGoogle, toolWireSchema } from "../utils/schema";
@@ -237,7 +237,7 @@ export function convertMessages<T extends GoogleApiType>(model: Model<T>, contex
 					const part: Part = {
 						functionCall: {
 							name: block.name,
-							args: block.arguments ?? {},
+							args: sanitizeJsonStrings(block.arguments ?? {}) as Record<string, unknown>,
 							...(requiresToolCallId(model.id) ? { id: block.id } : {}),
 						},
 					};
@@ -467,7 +467,7 @@ export function pushToolCallEvents(
 	stream.push({
 		type: "toolcall_delta",
 		contentIndex,
-		delta: JSON.stringify(toolCall.arguments),
+		delta: JSON.stringify(sanitizeJsonStrings(toolCall.arguments)),
 		partial: output,
 	});
 	stream.push({ type: "toolcall_end", contentIndex, toolCall, partial: output });