@oh-my-pi/pi-ai 18.3.4 → 18.4.0

package/src/stream.ts

@@ -24,7 +24,6 @@ import { isConcurrencyCapExclusion, isUsageLimitOutcome } from "./error/rate-lim
 import type { BedrockOptions } from "./providers/amazon-bedrock";
 import type { AnthropicOptions } from "./providers/anthropic";
 import type { AppleFoundationModelsOptions } from "./providers/apple-foundation-models";
-import type { MessageCreateParamsStreaming } from "./providers/anthropic-wire";
 import type { CursorOptions } from "./providers/cursor";
 import type { DevinOptions } from "./providers/devin";
 import { streamGitLabDuo } from "./providers/gitlab-duo";
@@ -62,7 +61,6 @@ import type {
 	FetchImpl,
 	Model,
 	OptionsForApi,
-	ProviderSessionState,
 	SimpleStreamOptions,
 	StreamOptions,
 	ThinkingBudgets,
@@ -1205,285 +1203,6 @@ function emitBufferedEvents(stream: AssistantMessageEventStream, events: Assista
 		stream.push(event);
 	}
 }
-
-const ANTHROPIC_CACHE_TTL_MS = 5 * 60_000;
-const ANTHROPIC_CACHE_REFRESH_LEAD_MS = 15_000;
-const ANTHROPIC_CACHE_REFRESH_LIMIT = 3;
-const ANTHROPIC_CACHE_REFRESH_STATE_KEY = "anthropic-cache-refresh";
-
-interface AnthropicCacheRefreshPlan {
-	refresh(controller: AbortController): Promise<number | undefined>;
-}
-
-class AnthropicCacheRefreshState implements ProviderSessionState {
-	#controller: AbortController | undefined;
-	#generation = 0;
-	#plan: AnthropicCacheRefreshPlan | undefined;
-	#refreshesRemaining = 0;
-	#timer: NodeJS.Timeout | undefined;
-
-	cancel(): void {
-		this.#generation++;
-		if (this.#timer !== undefined) {
-			clearTimeout(this.#timer);
-			this.#timer = undefined;
-		}
-		this.#controller?.abort();
-		this.#controller = undefined;
-		this.#plan = undefined;
-		this.#refreshesRemaining = 0;
-	}
-
-	arm(plan: AnthropicCacheRefreshPlan, cacheTouchedAtMs: number): void {
-		this.cancel();
-		this.#plan = plan;
-		this.#refreshesRemaining = ANTHROPIC_CACHE_REFRESH_LIMIT;
-		this.#schedule(cacheTouchedAtMs, this.#generation);
-	}
-
-	close(): void {
-		this.cancel();
-	}
-
-	#schedule(cacheTouchedAtMs: number, generation: number): void {
-		const refreshAtMs = cacheTouchedAtMs + ANTHROPIC_CACHE_TTL_MS - ANTHROPIC_CACHE_REFRESH_LEAD_MS;
-		this.#timer = setTimeout(
-			() => {
-				this.#timer = undefined;
-				void this.#refresh(generation);
-			},
-			Math.max(0, refreshAtMs - Date.now()),
-		);
-		this.#timer.unref?.();
-	}
-
-	async #refresh(generation: number): Promise<void> {
-		const plan = this.#plan;
-		if (generation !== this.#generation || !plan || this.#refreshesRemaining <= 0) return;
-
-		const controller = new AbortController();
-		this.#controller = controller;
-		let cacheTouchedAtMs: number | undefined;
-		try {
-			cacheTouchedAtMs = await plan.refresh(controller);
-		} catch (error) {
-			if (generation === this.#generation && !controller.signal.aborted) {
-				logger.debug("Anthropic prompt-cache refresh failed", { error: String(error) });
-			}
-		}
-		if (generation !== this.#generation) return;
-
-		this.#controller = undefined;
-		if (cacheTouchedAtMs === undefined) {
-			this.#plan = undefined;
-			this.#refreshesRemaining = 0;
-			return;
-		}
-
-		this.#refreshesRemaining--;
-		if (this.#refreshesRemaining <= 0) {
-			this.#plan = undefined;
-			return;
-		}
-		this.#schedule(cacheTouchedAtMs, generation);
-	}
-}
-
-function supportsAnthropicCacheRefresh<TApi extends Api>(model: Model<TApi>): boolean {
-	return (
-		model.api === "anthropic-messages" &&
-		model.provider === "anthropic" &&
-		model.transport !== "pi-native" &&
-		isLeakedThinkingHealExempt(model)
-	);
-}
-
-function isAnthropicRefreshPayload(payload: unknown): payload is MessageCreateParamsStreaming {
-	return (
-		typeof payload === "object" &&
-		payload !== null &&
-		"messages" in payload &&
-		Array.isArray(payload.messages) &&
-		"max_tokens" in payload &&
-		typeof payload.max_tokens === "number"
-	);
-}
-
-function isShortAnthropicCacheControl(cacheControl: unknown): boolean {
-	return (
-		typeof cacheControl === "object" &&
-		cacheControl !== null &&
-		"type" in cacheControl &&
-		cacheControl.type === "ephemeral" &&
-		(!("ttl" in cacheControl) || cacheControl.ttl !== "1h")
-	);
-}
-
-function hasShortAnthropicMessageBreakpoint(payload: MessageCreateParamsStreaming): boolean {
-	for (const message of payload.messages) {
-		if (!Array.isArray(message.content)) continue;
-		for (const block of message.content) {
-			if ("cache_control" in block && isShortAnthropicCacheControl(block.cache_control)) return true;
-		}
-	}
-	return false;
-}
-
-function isAnthropicGenerationEvent(event: AssistantMessageEvent): boolean {
-	switch (event.type) {
-		case "text_start":
-		case "thinking_start":
-		case "toolcall_start":
-		case "image_end":
-			return true;
-		case "text_delta":
-		case "thinking_delta":
-		case "toolcall_delta":
-			return event.delta.length > 0;
-		default:
-			return false;
-	}
-}
-
-function isAnthropicThinkingActive(model: Model<Api>, payload: MessageCreateParamsStreaming): boolean {
-	if (payload.thinking) return payload.thinking.type !== "disabled";
-	return model.thinking?.mode === "anthropic-adaptive" && payload.output_config?.effort != null;
-}
-
-function createAnthropicCacheRefreshPlan<TApi extends Api>(
-	model: Model<TApi>,
-	context: Context,
-	options: SimpleStreamOptions | undefined,
-	payload: MessageCreateParamsStreaming,
-): AnthropicCacheRefreshPlan {
-	const thinkingEnabled = isAnthropicThinkingActive(model, payload);
-	return {
-		async refresh(controller) {
-			let cacheRead = 0;
-			let cacheWrite = 0;
-			let cacheTouchedAtMs: number | undefined;
-			let canceledAfterGenerationStarted = false;
-			const response = streamSimpleRequest(model, context, {
-				...options,
-				acceptEmptyResponse: true,
-				anthropicCacheRefreshRequest: !thinkingEnabled,
-				cacheRetention: "short",
-				maxTokens: thinkingEnabled ? options?.maxTokens : 0,
-				onPayload: () => ({
-					...payload,
-					max_tokens: thinkingEnabled ? payload.max_tokens : 0,
-				}),
-				onResponse: () => {
-					cacheTouchedAtMs = Date.now();
-				},
-				onSseEvent: undefined,
-				signal: controller.signal,
-			});
-
-			for await (const event of response) {
-				if ("partial" in event) {
-					cacheRead = event.partial.usage.cacheRead;
-					cacheWrite = event.partial.usage.cacheWrite;
-				}
-				if (event.type === "error") return undefined;
-				if (event.type === "done") {
-					cacheRead = event.message.usage.cacheRead;
-					cacheWrite = event.message.usage.cacheWrite;
-					return cacheTouchedAtMs !== undefined && cacheRead > 0 && cacheWrite === 0
-						? cacheTouchedAtMs
-						: undefined;
-				}
-				if (thinkingEnabled && isAnthropicGenerationEvent(event)) {
-					canceledAfterGenerationStarted = true;
-					controller.abort();
-					break;
-				}
-			}
-
-			if (canceledAfterGenerationStarted) {
-				try {
-					await response.result();
-				} catch (error) {
-					if (!controller.signal.aborted) throw error;
-				}
-			}
-			return cacheTouchedAtMs !== undefined && cacheRead > 0 && cacheWrite === 0 ? cacheTouchedAtMs : undefined;
-		},
-	};
-}
-
-function streamSimpleWithAnthropicCacheRefresh<TApi extends Api>(
-	model: Model<TApi>,
-	context: Context,
-	options: SimpleStreamOptions | undefined,
-): AssistantMessageEventStream {
-	const providerSessionState = options?.providerSessionState;
-	if (!options?.anthropicCacheRefresh || !providerSessionState) {
-		return streamSimpleRequest(model, context, options);
-	}
-
-	const existingState = providerSessionState.get(ANTHROPIC_CACHE_REFRESH_STATE_KEY);
-	if (existingState instanceof AnthropicCacheRefreshState) {
-		existingState.cancel();
-	} else if (existingState) {
-		return streamSimpleRequest(model, context, options);
-	}
-	if (!supportsAnthropicCacheRefresh(model) || resolveCacheRetention(options.cacheRetention) !== "short") {
-		return streamSimpleRequest(model, context, options);
-	}
-
-	const refreshState = existingState ?? new AnthropicCacheRefreshState();
-	if (!existingState) providerSessionState.set(ANTHROPIC_CACHE_REFRESH_STATE_KEY, refreshState);
-
-	let cacheTouchedAtMs: number | undefined;
-	let capturedPayload: MessageCreateParamsStreaming | undefined;
-	const inner = streamSimpleRequest(model, context, {
-		...options,
-		onPayload: async (payload, payloadModel) => {
-			const replacement = await options?.onPayload?.(payload, payloadModel);
-			const finalPayload = replacement ?? payload;
-			if (isAnthropicRefreshPayload(finalPayload)) capturedPayload = finalPayload;
-			return replacement;
-		},
-		onResponse: async (response, responseModel) => {
-			cacheTouchedAtMs = Date.now();
-			await options?.onResponse?.(response, responseModel);
-		},
-	});
-	const outer = new AssistantMessageEventStream();
-	const armRefresh = (message: AssistantMessage): void => {
-		if (
-			message.stopReason === "error" ||
-			message.stopReason === "aborted" ||
-			message.usage.cacheRead + message.usage.cacheWrite <= 0 ||
-			cacheTouchedAtMs === undefined ||
-			capturedPayload === undefined ||
-			!hasShortAnthropicMessageBreakpoint(capturedPayload)
-		) {
-			return;
-		}
-		refreshState.arm(createAnthropicCacheRefreshPlan(model, context, options, capturedPayload), cacheTouchedAtMs);
-	};
-
-	void (async () => {
-		try {
-			for await (const event of inner) {
-				if (event.type === "done") armRefresh(event.message);
-				outer.push(event);
-				if (outer.done) return;
-			}
-			if (!outer.done) {
-				const result = await inner.result();
-				armRefresh(result);
-				outer.end(result);
-			}
-		} catch (error) {
-			outer.fail(error);
-		}
-	})();
-	return outer;
-}
-
 function withInferenceSessionId(options?: SimpleStreamOptions): SimpleStreamOptions {
 	if (options?.sessionId) return options;
 	return { ...options, sessionId: crypto.randomUUID() };
@@ -1496,7 +1215,7 @@ export function streamSimple<TApi extends Api>(
 ): AssistantMessageEventStream {
 	const sessionOptions = withInferenceSessionId(options);
 	if (!model.requiresGlyphTokenization) {
-		return streamSimpleWithAnthropicCacheRefresh(model, context, sessionOptions);
+		return streamSimpleRequest(model, context, sessionOptions);
 	}
 	const codec = applyGlyphCodec(context);
 	const execHandlers = sessionOptions.cursorExecHandlers ?? sessionOptions.execHandlers;
@@ -1509,7 +1228,7 @@ export function streamSimple<TApi extends Api>(
 					execHandlers: wrappedExecHandlers,
 					cursorExecHandlers: wrappedExecHandlers,
 				};
-	return codec.wrap(streamSimpleWithAnthropicCacheRefresh(model, codec.context, wireOptions));
+	return codec.wrap(streamSimpleRequest(model, codec.context, wireOptions));
 }
 
 /**
@@ -2093,7 +1812,6 @@ function mapOptionsForApi<TApi extends Api>(
 		fetch: options?.fetch,
 		fallbacks: options?.fallbacks,
 		acceptEmptyResponse: options?.acceptEmptyResponse,
-		anthropicCacheRefreshRequest: options?.anthropicCacheRefreshRequest,
 		anthropicPrefixMismatchBehavior: options?.anthropicPrefixMismatchBehavior,
 		anthropicCompaction: options?.anthropicCompaction,
 		anthropicSlowMode: options?.anthropicSlowMode,

package/src/types.ts

@@ -428,21 +428,11 @@ export interface StreamOptions {
 	/** @internal Stored credential row serving this request, when known. */
 	credentialId?: number;
 	cacheRetention?: CacheRetention;
-	/**
-	 * Keep Anthropic's 5-minute prompt cache warm across bounded idle gaps.
-	 *
-	 * This is an ownership flag, not a general provider default: exactly one
-	 * primary agent loop sharing `providerSessionState` should enable it.
-	 * Side-channel and advisor requests must leave it unset.
-	 */
-	anthropicCacheRefresh?: boolean;
 	/**
 	 * Anthropic preserved-thinking behavior when a signed block no longer matches
 	 * its conversation prefix. Binding-capable models default to `"drop_block"`.
 	 */
 	anthropicPrefixMismatchBehavior?: "drop_block" | "error";
-	/** @internal Marks a replay-only Anthropic request that must use non-streaming `max_tokens: 0`. */
-	anthropicCacheRefreshRequest?: boolean;
 	/**
 	 * Anthropic on-demand compaction (`compact-2026-09-04` beta). Sends a
 	 * top-level `compaction: { type: "summarize", instructions? }` request; the

package/src/usage/claude-reset.ts

@@ -1,6 +1,7 @@
+import { extractRetryHint } from "@oh-my-pi/pi-utils/fetch-retry";
 import type { UsageReport, UsageResetCredit, UsageResetCredits } from "../usage";
 import { isUsageLimitReached } from "../auth/usage-report";
-import { claudeRankingStrategy } from "./claude";
+import { claudeRankingStrategy, parseClaudeUsagePayload } from "./claude";
 import type { FetchImpl } from "../types";
 import { isRecord } from "../utils";
 import {
@@ -30,12 +31,20 @@ const CLAUDE_RESET_WINDOW_IDS: Readonly<Record<string, string>> = {
 export function claudeResetClearedBlockScopes(cleared: readonly string[], report: UsageReport): (string | undefined)[] {
 	const shared = report.limits.filter(limit => limit.scope.shared);
 	if (!["anthropic:5h", "anthropic:7d"].every(id => shared.some(limit => limit.id === id))) return [];
-	const unscoped = report.limits.filter(
-		limit => limit.scope.shared || limit.scope.tier === "opus" || limit.scope.tier === "sonnet",
-	);
+	const unscoped = report.limits.filter(limit => {
+		if (limit.scope.shared) return true;
+		if (!limit.scope.tier) return false;
+		// Fable/Mythos have independent block scopes. A live deadline lets
+		// redemption retain their uncovered exhaustion in that exact scope.
+		if (limit.scope.tier === "fable" || limit.scope.tier === "mythos") {
+			const reset = limit.window?.resetsAt;
+			return typeof reset !== "number" || !Number.isFinite(reset) || reset <= Date.now();
+		}
+		return true;
+	});
 	const scopes = [
 		{ blockScope: undefined, limits: unscoped },
-		...(claudeRankingStrategy.healableBlockScopes?.(report) ?? []),
+		...(claudeRankingStrategy.healableBlockScopes?.(report) ?? []).filter(scope => scope.blockScope.length > 0),
 	];
 	return scopes
 		.filter(scope => scope.limits.some(limit => cleared.includes(limit.id)))
@@ -46,6 +55,10 @@ export function claudeResetClearedBlockScopes(cleared: readonly string[], report
 /** OAuth credential and transport used for an account's Claude reset operations. */
 export interface ClaudeResetAuth {
 	accessToken: string;
+	/** Observe a safe discovery read's throttle without retrying any mutation. */
+	onRateLimited?: (retryAfterMs: number | undefined) => void;
+	accountId?: string;
+	email?: string;
 	orgId?: string;
 	baseUrl?: string;
 	fetch: FetchImpl;
@@ -55,6 +68,8 @@ export interface ClaudeResetAuth {
 /** Live reset eligibility plus the exact organization and host used for redemption. */
 export interface ClaudeResetCreditList extends UsageResetCredits {
 	credits: UsageResetCredit[];
+	/** Quota evidence parsed from the same successful discovery response. */
+	report?: UsageReport;
 	orgId?: string;
 	/** OAuth API base that answered discovery; pass back as consume `baseUrl`. */
 	baseUrl?: string;
@@ -102,7 +117,7 @@ interface JuniperStatus {
 }
 
 type ParsedStatus<T> = { ok: true; status: T | null } | { ok: false };
-type Discovery<T> = { kind: "answered"; status: T | null; baseUrl: string } | { kind: "failed" };
+type Discovery<T> = { kind: "answered"; status: T | null; baseUrl: string; report?: UsageReport } | { kind: "failed" };
 
 function optionalString(value: unknown): string | undefined | null {
 	if (value === undefined || value === null) return undefined;
@@ -290,6 +305,7 @@ async function discoverStatus<T>(
 			return { kind: "failed" };
 		}
 		if (!response.ok) {
+			if (response.status === 429) auth.onRateLimited?.(extractRetryHint(response));
 			const canFallback =
 				ENDPOINT_ABSENT_STATUSES[response.status] === true && baseUrl !== DEFAULT_CLAUDE_OAUTH_BASE_URL;
 			if (canFallback) continue;
@@ -302,11 +318,12 @@ async function discoverStatus<T>(
 			return { kind: "failed" };
 		}
 		if (!isRecord(payload)) return { kind: "failed" };
+		const report = parseClaudeUsagePayload(payload, auth, `${baseUrl}/usage?${query}`) ?? undefined;
 		if (field in payload) {
 			const parsed = parse(payload[field]);
-			return parsed.ok ? { kind: "answered", status: parsed.status, baseUrl } : { kind: "failed" };
+			return parsed.ok ? { kind: "answered", status: parsed.status, baseUrl, report } : { kind: "failed" };
 		}
-		if (isUsageEnvelope(payload)) return { kind: "answered", status: null, baseUrl };
+		if (isUsageEnvelope(payload)) return { kind: "answered", status: null, baseUrl, report };
 		const canFallback = baseUrl !== DEFAULT_CLAUDE_OAUTH_BASE_URL;
 		if (!canFallback) return { kind: "failed" };
 	}
@@ -463,7 +480,14 @@ async function withResolvedOrganization(
 ): Promise<ClaudeResetCreditList> {
 	if (list.orgId || list.credits.length === 0) return list;
 	const resolution = await resolveOrganization({ ...auth, baseUrl: list.baseUrl ?? auth.baseUrl });
-	return resolution.orgId ? { ...list, orgId: resolution.orgId } : list;
+	if (!resolution.orgId) return list;
+	return {
+		...list,
+		orgId: resolution.orgId,
+		...(list.report
+			? { report: { ...list.report, metadata: { ...list.report.metadata, orgId: resolution.orgId } } }
+			: {}),
+	};
 }
 
 /**
@@ -514,7 +538,10 @@ export async function listClaudeResetCredits(auth: ClaudeResetAuth): Promise<Cla
 	if (cedar.kind === "failed") return null;
 	let cedarList: ClaudeResetCreditList | undefined;
 	if (cedar.status) {
-		cedarList = normalizeCedarList(cedar.status, orgId, cedar.baseUrl);
+		cedarList = {
+			...normalizeCedarList(cedar.status, orgId, cedar.baseUrl),
+			...(cedar.report ? { report: cedar.report } : {}),
+		};
 		if (cedarList.availableCount > 0 || cedarList.nextCreditId) {
 			return withResolvedOrganization(cedarList, auth);
 		}
@@ -522,7 +549,13 @@ export async function listClaudeResetCredits(auth: ClaudeResetAuth): Promise<Cla
 
 	const juniper = await discoverStatus(auth, "at_wall=1&skip_spend=1", JUNIPER_PROGRAM, parseJuniperStatus);
 	if (juniper.kind === "answered" && juniper.status) {
-		return withResolvedOrganization(normalizeJuniperList(juniper.status, orgId, juniper.baseUrl), auth);
+		return withResolvedOrganization(
+			{
+				...normalizeJuniperList(juniper.status, orgId, juniper.baseUrl),
+				...(juniper.report ? { report: juniper.report } : {}),
+			},
+			auth,
+		);
 	}
 	if (cedarList && juniper.kind === "answered") return cedarList;
 	if (juniper.kind === "answered") {
@@ -533,6 +566,7 @@ export async function listClaudeResetCredits(auth: ClaudeResetAuth): Promise<Cla
 			credits: [],
 			...(orgId ? { orgId } : {}),
 			baseUrl: juniper.baseUrl,
+			...(juniper.report ? { report: juniper.report } : {}),
 		};
 	}
 	return null;

package/src/usage/claude.ts

@@ -12,7 +12,6 @@ import {
 	type UsageLimit,
 	type UsageProvider,
 	type UsageReport,
-	type UsageResetCredits,
 	type UsageStatus,
 	type UsageWindow,
 } from "../usage";
@@ -667,8 +666,61 @@ async function fetchClaudeUsage(params: UsageFetchParams, ctx: UsageFetchContext
 		if (!result.endpointAbsent) break;
 	}
 	if (!payload || baseUrl === undefined) return null;
-	const url = `${baseUrl}/usage`;
-
+	const report = parseClaudeUsagePayload(payload, credential, `${baseUrl}/usage`);
+	const resetCreditList =
+		parseClaudeResetCreditsFromUsagePayload(payload, credential.orgId, baseUrl) ??
+		(await listClaudeResetCredits({
+			accessToken: credential.accessToken,
+			accountId: credential.accountId,
+			email: credential.email,
+			orgId: credential.orgId,
+			baseUrl: params.baseUrl,
+			fetch: ctx.fetch,
+			signal: params.signal,
+		}));
+	const hasResetInventory =
+		resetCreditList !== null &&
+		(resetCreditList.availableCount > 0 ||
+			resetCreditList.nextCreditId !== undefined ||
+			resetCreditList.credits.length > 0);
+	if (!report && !hasResetInventory) return null;
+	const result: UsageReport = report ?? {
+		provider: "anthropic",
+		fetchedAt: Date.now(),
+		limits: [],
+		metadata: { endpoint: `${baseUrl}/usage`, ...extractUsageIdentity(payload) },
+		raw: payload,
+	};
+	let accountId = result.metadata?.accountId ?? credential.accountId;
+	let email = result.metadata?.email ?? credential.email;
+	if ((!accountId || !email) && !params.signal?.aborted) {
+		const profileIdentity = extractProfileIdentity(await fetchProfile(baseUrl, headers, ctx, params.signal));
+		accountId ??= profileIdentity.accountId;
+		email ??= profileIdentity.email;
+	}
+	if (resetCreditList) {
+		const { orgId, baseUrl: _baseUrl, report: _report, ...resetCredits } = resetCreditList;
+		result.resetCredits = resetCredits;
+		if (orgId) result.metadata = { ...result.metadata, orgId };
+	}
+	result.metadata = {
+		...result.metadata,
+		...(accountId ? { accountId } : {}),
+		...(email ? { email } : {}),
+		...(credential.orgId ? { orgId: credential.orgId } : {}),
+	};
+	return result;
+}
+
+/** Parse the quota evidence in one live usage response, without any additional requests. */
+export function parseClaudeUsagePayload(
+	raw: unknown,
+	identity: { accountId?: string; email?: string; orgId?: string } = {},
+	endpoint?: string,
+	fetchedAt = Date.now(),
+): UsageReport | null {
+	if (!isRecord(raw)) return null;
+	const payload: ClaudeUsageResponse = raw;
 	const apiLimitEntries = parseApiLimitEntries(payload.limits);
 	const fiveHour = parseBucket(payload.five_hour) ?? apiLimitEntries.find(entry => entry.kind === "session")?.bucket;
 	const sevenDay =
@@ -721,53 +773,23 @@ async function fetchClaudeUsage(params: UsageFetchParams, ctx: UsageFetchContext
 		buildClaudeExtraUsageLimit(payload),
 	].filter((limit): limit is UsageLimit => limit !== null);
 
-	const resetCreditList =
-		parseClaudeResetCreditsFromUsagePayload(payload, credential.orgId, baseUrl) ??
-		(await listClaudeResetCredits({
-			accessToken: credential.accessToken,
-			...(credential.orgId ? { orgId: credential.orgId } : {}),
-			...(params.baseUrl ? { baseUrl: params.baseUrl } : {}),
-			fetch: ctx.fetch,
-			...(params.signal ? { signal: params.signal } : {}),
-		}));
-	const hasResetInventory =
-		resetCreditList !== null &&
-		(resetCreditList.availableCount > 0 ||
-			resetCreditList.nextCreditId !== undefined ||
-			resetCreditList.credits.length > 0);
-	if (limits.length === 0 && !hasResetInventory) return null;
-
-	const identity = extractUsageIdentity(payload);
-	let accountId = identity.accountId ?? credential.accountId;
-	let email = identity.email ?? credential.email;
-	if ((!accountId || !email) && !params.signal?.aborted) {
-		const profileIdentity = extractProfileIdentity(await fetchProfile(baseUrl, headers, ctx, params.signal));
-		accountId = accountId ?? profileIdentity.accountId;
-		email = email ?? profileIdentity.email;
-	}
-	let resetCredits: UsageResetCredits | undefined;
-	let reportOrgId = credential.orgId;
-	if (resetCreditList) {
-		const { orgId, baseUrl: _baseUrl, ...usageResetCredits } = resetCreditList;
-		resetCredits = usageResetCredits;
-		reportOrgId ??= orgId;
-	}
-
-	const report: UsageReport = {
-		provider: params.provider,
-		fetchedAt: Date.now(),
+	if (limits.length === 0) return null;
+	// The response speaks for the token that fetched it; stored metadata may be stale.
+	const payloadIdentity = extractUsageIdentity(payload);
+	const accountId = payloadIdentity.accountId ?? identity.accountId;
+	const email = payloadIdentity.email ?? identity.email;
+	return {
+		provider: "anthropic",
+		fetchedAt,
 		limits,
-		...(resetCredits ? { resetCredits } : {}),
 		metadata: {
-			endpoint: url,
+			...(endpoint ? { endpoint } : {}),
 			...(accountId ? { accountId } : {}),
 			...(email ? { email } : {}),
-			...(reportOrgId ? { orgId: reportOrgId } : {}),
+			...(identity.orgId ? { orgId: identity.orgId } : {}),
 		},
 		raw: payload,
 	};
-
-	return report;
 }
 
 export const claudeUsageProvider: UsageProvider = {
@@ -886,6 +908,7 @@ function findClaudeSecondaryLimit(
 }
 
 export const claudeRankingStrategy: CredentialRankingStrategy = {
+	healsGlobalBlocks: true,
 	/**
 	 * Anthropic-only idle window after which a session's pinned credential no
 	 * longer suppresses usage-based re-ranking. Anthropic caps OAuth prompt-cache
@@ -923,8 +946,8 @@ export const claudeRankingStrategy: CredentialRankingStrategy = {
 	 * weekly row plus the shared umbrella windows — so a healthy report lifts
 	 * the block while a spent shared 5-hour wall keeps it.
 	 *
-	 * Only Fable/Mythos appear: {@link blockScope} scopes reactive blocks for
-	 * those tiers alone, so no other scope can exist to heal.
+	 * Legacy and shared quota errors also leave account-wide blocks. Only a
+	 * complete report with every reported quota healthy can heal that scope.
 	 */
 	healableBlockScopes(report) {
 		const sharedLimits = report.limits.filter(limit => limit.scope.shared === true);
@@ -941,10 +964,17 @@ export const claudeRankingStrategy: CredentialRankingStrategy = {
 			const tier = limit.scope.tier;
 			if (tier === "fable" || tier === "mythos") tiers.add(tier);
 		}
-		return [...tiers].map(tier => ({
-			blockScope: `tier:${tier}`,
-			limits: [...sharedLimits, ...report.limits.filter(limit => limit.scope.tier === tier)],
-		}));
+		return [
+			{
+				blockScope: "",
+				limits: report.limits.filter(limit => limit.scope.shared === true || limit.scope.tier !== undefined),
+				healthy: report.metadata?.source === "ratelimit-headers" ? false : undefined,
+			},
+			...[...tiers].map(tier => ({
+				blockScope: `tier:${tier}`,
+				limits: [...sharedLimits, ...report.limits.filter(limit => limit.scope.tier === tier)],
+			})),
+		];
 	},
 	windowDefaults: { primaryMs: 5 * 60 * 60 * 1000, secondaryMs: 7 * 24 * 60 * 60 * 1000 },
 };

package/src/usage.ts

@@ -490,6 +490,8 @@ export interface CredentialRankingStrategy {
 	 * non-empty limits with none exhausted.
 	 */
 	healableBlockScopes?(report: UsageReport): { blockScope: string; limits: UsageLimit[]; healthy?: boolean }[];
+	/** Whether fresh reports can heal legacy account-wide quota backoffs. */
+	healsGlobalBlocks?: boolean;
 	/** Fallback window durations (ms) when limits don't specify durationMs. */
 	windowDefaults: {
 		primaryMs: number;

package/src/utils/proxy.ts

@@ -164,15 +164,15 @@ export function getProxyForUrl(provider: string, url: URL): string | undefined {
 /**
  * Return `init` with `proxy: proxyUrl` set when the request should tunnel.
  * A caller-supplied `init.proxy` always wins (the innermost, most specific
- * decision); local/metadata hosts, NO_PROXY matches, and unparseable URLs
- * pass through unchanged.
+ * decision); Unix sockets, local/metadata hosts, NO_PROXY matches, and
+ * unparseable URLs pass through unchanged.
  */
 export function withProxyInit(
 	input: string | URL | Request,
 	init: RequestInit | undefined,
 	proxyUrl: string,
 ): RequestInit | undefined {
-	if ((init as { proxy?: unknown } | undefined)?.proxy) return init;
+	if (init && (("unix" in init && init.unix) || ("proxy" in init && init.proxy))) return init;
 	const urlStr = input instanceof Request ? input.url : input.toString();
 	let urlObj: URL;
 	try {