@oh-my-pi/pi-ai 16.3.0 → 16.3.3

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## [Unreleased]
 
+## [16.3.3] - 2026-07-02
+
+### Added
+
+- Added comprehensive tracking and credential-ranking support for Anthropic per-tier and weekly usage limits, including Claude Fable weekly caps. This prevents a single exhausted model-scoped cap from blocking the entire OAuth credential and improves credential selection based on drain-rate pressure.
+
+### Changed
+
+- Updated Claude Fable reasoning replay to use bare text instead of wrapped thinking tags
+
+### Fixed
+
+- Improved robustness of single-argument tool calls by automatically remapping mislabeled string arguments.
+- Fixed Anthropic OAuth usage reporting to stop retrying on 429 rate-limit errors.
+- Fixed usage cache to correctly persist null values during cold-start failure backoff windows.
+- Fixed cursor-agent persisted transcripts losing tool-call structure for native execution tools, ensuring replayed tool results are correctly paired with their corresponding calls.
+- Fixed OpenAI-compatible streaming usage parsing to prefer non-zero nested cached token counts when the root cached_tokens value is zero.
+- Added automatic detection and remediation for custom proxies returning signature errors on Anthropic thinking blocks, allowing the client to automatically retry with unsigned blocks and prompt the user to adjust their configuration.
+- Fixed potential hangs in GitLab Duo Workflow setup by adding proper timeout and abort signal handling to REST fetches.
+- Fixed Cursor proxy tunnel setup hanging indefinitely by adding abort and timeout handling.
+- Fixed Devin Connect streaming reader vulnerability to corrupt frame lengths by capping payloads at 16 MiB and throwing an envelope error immediately.
+
+## [16.3.1] - 2026-07-02
+
+### Changed
+
+- Removed automated injection of reasoning suppression prompts in OpenAI responses
+
 ## [16.3.0] - 2026-07-02
 
 ### Added

package/dist/types/auth-broker/remote-store.d.ts

@@ -91,12 +91,13 @@ export declare class RemoteAuthCredentialStore implements AuthCredentialStore {
     /**
      * Per-credential usage hook consumed by `AuthStorage.#getUsageReport`. Pulls
      * the aggregate broker `/v1/usage` once and serves all callers from the
-     * same response (coalesced + cached), then matches the credential to a
-     * report by provider + identity (accountId / email / projectId).
+     * same response (coalesced + cached), then overlays any client-observed
+     * header hints for the matching credential.
      *
      * The broker already aggregates with its own 30s TTL on the server side; our
      * 15s client TTL is below that so we usually re-use the broker's cache too.
      */
     getUsageReport(provider: Provider, credential: OAuthCredential, signal?: AbortSignal): Promise<UsageReport | null>;
+    ingestUsageReport(provider: Provider, credential: OAuthCredential, report: UsageReport): boolean;
     close(): void;
 }

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

@@ -287,6 +287,13 @@ export interface AuthCredentialStore {
      * `signal` propagates the agent's cancel down to the broker fetch.
      */
     getUsageReport?(provider: Provider, credential: OAuthCredential, signal?: AbortSignal): Promise<UsageReport | null>;
+    /**
+     * Optional store hook to ingest a parsed provider usage report for one OAuth
+     * credential. Remote broker stores use this to overlay header-derived limits
+     * onto their cached aggregate `/v1/usage` response without mutating broker
+     * state.
+     */
+    ingestUsageReport?(provider: Provider, credential: OAuthCredential, report: UsageReport): boolean;
     /**
      * Optional store hook to invalidate a specific credential after the upstream
      * provider returned 401 on a supposedly-fresh key. Remote stores force the

package/dist/types/dialect/demotion.d.ts

@@ -5,17 +5,22 @@
  * replayed unsigned `thought` part is schema-accepted but silently discarded —
  * neither recalled nor influencing generation).
  *
- * Fable is the exception: replaying prior reasoning inside `<thinking>` /
- * `antml:thinking`-style assistant text is treated as a reasoning-extraction
- * attempt and can train the next turn to leak thoughts, so Fable receives the
- * reasoning as markdown-italic assistant prose instead. Harmony and Gemma are
- * also exceptions: their `renderThinking` emits chat-template control tokens
- * (`<|channel|>analysis`, `<|channel>thought`) that must not appear inside a
- * structured native message, so they fall back to a plain `<think>` block. Every
- * other dialect's thinking form is inline-safe XML tags or a markdown fence.
+ * Fable is the exception: Anthropic's `reasoning_extraction` classifier blocks
+ * requests that replay prior reasoning inside `<thinking>` / `antml:thinking`
+ * tags OR the older `_Hmm. …_` italic envelope — it reads the wrapped
+ * chain-of-thought as an attempt to duplicate model outputs and refuses the
+ * whole turn. Fable therefore receives prior reasoning as bare assistant prose:
+ * no tag, no `_Hmm.` wrapper, no trailing newline.
+ * Heat is cumulative (block count and early-conversation position also raise
+ * it), so this lowers per-block signal but does not license unbounded replay.
+ * Harmony and Gemma are also exceptions: their `renderThinking` emits
+ * chat-template control tokens (`<|channel|>analysis`, `<|channel>thought`)
+ * that must not appear inside a structured native message, so they fall back to
+ * a plain `<think>` block. Every other dialect's thinking form is inline-safe
+ * XML tags or a markdown fence.
  *
- * The result ends with a trailing newline so the block stays separated from the
- * turn's reply text when the wire encoder concatenates parts.
+ * The result does not append a delimiter; callers that flatten adjacent blocks
+ * into a single string must insert their own separator.
  *
  * Distinct from {@link DialectDefinition.renderThinking}, which targets the
  * owned-dialect *text transport* where those control tokens are legal.

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

@@ -204,6 +204,16 @@ export type AnthropicUsageLike = {
  * zero-valued objects clear prior extras from earlier stream usage snapshots.
  */
 export declare function applyAnthropicUsageExtras(usage: Usage, source: AnthropicUsageLike): void;
+export declare function isInvalidThinkingSignatureError(message: string): boolean;
+/**
+ * Prepend a pointed remediation to Anthropic's `Invalid signature in thinking
+ * block` 400 when the model looks like an unmarked custom signing proxy
+ * (opaque baseUrl, `spec.reasoning: true`, no explicit
+ * `compat.replayUnsignedThinking` override). The default is native replay for
+ * the 3p reasoning majority (#2005); this hint turns the misconfigured-proxy
+ * case into a one-line fix instead of a silent retry loop (#4297).
+ */
+export declare function maybeAddReplayUnsignedThinkingHint(model: Model<"anthropic-messages">, message: string): string;
 /**
  * Public entry: wrap the single-attempt streamer with bounded empty-completion
  * retries (a benign terminal stop carrying no content/usage would otherwise

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

@@ -1,6 +1,6 @@
 import { type JsonValue } from "@bufbuild/protobuf";
 import type { AssistantMessage, CursorExecHandlerResult, CursorExecHandlers, CursorToolResultHandler, Message, StreamFunction, StreamOptions, TextContent, ThinkingContent, ToolCall, ToolResultMessage } from "../types";
-import { kStreamingBlockIndex, kStreamingBlockKind, kStreamingLastParseLen, kStreamingPartialJson } from "../utils/block-symbols";
+import { kCursorExecResolved, kStreamingBlockIndex, kStreamingBlockKind, kStreamingLastParseLen, kStreamingPartialJson } from "../utils/block-symbols";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 export declare const CURSOR_API_URL = "https://api2.cursor.sh";
 export declare const CURSOR_CLIENT_VERSION = "cli-2026.01.09-231024f";
@@ -15,7 +15,8 @@ export type ToolCallState = ToolCall & {
     [kStreamingBlockIndex]: number;
     [kStreamingPartialJson]?: string;
     [kStreamingLastParseLen]?: number;
-    [kStreamingBlockKind]: "mcp" | "todo";
+    [kStreamingBlockKind]: "mcp" | "todo" | "cursor-exec";
+    [kCursorExecResolved]?: true;
 };
 export interface BlockState {
     currentTextBlock: (TextContent & {
@@ -60,6 +61,26 @@ export declare function resolveExecHandler<TArgs, TResult>(args: TArgs, handler:
  * - otherwise               → completion wins.
  */
 export declare function mergeCursorMcpToolCallArgs(streamed: Record<string, unknown> | undefined, completion: Record<string, unknown> | undefined): Record<string, unknown>;
+/**
+ * Synthesize a completed `toolCall` content block for a Cursor exec-channel
+ * native tool (`shell`, `read`, `write`, `grep`, `ls`, `delete`, `diagnostics`).
+ *
+ * Args arrive complete on the exec message, so the block opens and closes in
+ * one step — no partial-JSON streaming path. Without this the persisted
+ * assistant message carries only text/thinking blocks, and on replay the
+ * following `toolResult` messages have no matching `toolCall.id` in
+ * `renderSessionContext`, so they render as header-less `⎿` lines beneath the
+ * last text block instead of proper tool components (issue #4348).
+ *
+ * The block is stamped with {@link kCursorExecResolved} so the shared
+ * `agent-loop.ts` execution pass skips it — Cursor's server-driven exec
+ * channel already ran the tool via the bridge and buffered the result, so
+ * treating this block as runnable would re-execute the same side-effecting
+ * tool a second time.
+ *
+ * Exported for tests to exercise ordering with adjacent text/thinking blocks.
+ */
+export declare function synthesizeCursorExecToolCall(output: AssistantMessage, stream: AssistantMessageEventStream, state: BlockState, toolCallId: string, toolName: string, args: Record<string, unknown>): void;
 /** Exported for tests: drives one Cursor interaction update through the streaming state machine. */
 export declare function processInteractionUpdate(update: any, output: AssistantMessage, stream: AssistantMessageEventStream, state: BlockState, usageState: UsageState): void;
 /**

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

@@ -64,8 +64,8 @@ interface OpenAIResponsesProviderSessionState extends ProviderSessionState, Open
 }
 interface OpenAIResponsesChainState {
     /**
-     * Wire params of the last successful turn, with per-turn trailing
-     * scaffolding stripped from `input` (never carries previous_response_id).
+     * Wire params of the last successful turn; never carries
+     * `previous_response_id`.
      */
     lastParams?: OpenAIResponsesSamplingParams;
     lastResponseId?: string;
@@ -108,7 +108,6 @@ type OpenAIResponsesSamplingParams = ResponseCreateParamsStreaming & {
 export declare const streamOpenAIResponses: StreamFunction<"openai-responses">;
 export declare function buildParams(model: Model<"openai-responses">, context: Context, options: OpenAIResponsesOptions | undefined, providerSessionState: OpenAIResponsesProviderSessionState | undefined, strictToolsScope?: OpenAIStrictToolsScope, disableStrictToolsOverride?: boolean): {
     params: OpenAIResponsesSamplingParams;
-    trailingScaffoldingItems: number;
     strictToolsApplied: boolean;
 };
 /**

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

@@ -465,12 +465,12 @@ export interface ApplyResponsesCompatPolicyOptions {
     reasoningSummary?: "auto" | "detailed" | "concise" | null;
     mapEffort?: (effort: string) => string;
 }
-export declare function applyResponsesCompatPolicy<P extends ResponseCreateParamsStreaming>(params: P, messages: ResponseInput, policy: OpenAICompatPolicy, options: ApplyResponsesCompatPolicyOptions | undefined): number;
+export declare function applyResponsesCompatPolicy<P extends ResponseCreateParamsStreaming>(params: P, policy: OpenAICompatPolicy, options: ApplyResponsesCompatPolicyOptions | undefined): void;
 /**
  * Apply reasoning-related Responses parameters. Default behavior comes from
  * catalog compat; include/omit arguments are explicit adapter-wrapper overrides.
  */
-export declare function applyResponsesReasoningParams<P extends ResponseCreateParamsStreaming>(params: P, model: Model<"openai-responses" | "azure-openai-responses" | "openai-codex-responses">, options: ReasoningOptions | undefined, messages: ResponseInput, mapEffort?: (effort: string) => string, includeEncryptedReasoning?: boolean, omitReasoningEffort?: boolean): number;
+export declare function applyResponsesReasoningParams<P extends ResponseCreateParamsStreaming>(params: P, model: Model<"openai-responses" | "azure-openai-responses" | "openai-codex-responses">, options: ReasoningOptions | undefined, mapEffort?: (effort: string) => string, includeEncryptedReasoning?: boolean, omitReasoningEffort?: boolean): void;
 /** Populate `output.usage` from a Responses-API `response.usage` payload. Does not invoke `calculateCost`. */
 export declare function populateResponsesUsageFromResponse(output: AssistantMessage, usage: {
     input_tokens?: number | null;

package/dist/types/usage/claude.d.ts

@@ -1,4 +1,4 @@
-import type { CredentialRankingStrategy, UsageProvider, UsageReport } from "../usage";
+import { type CredentialRankingStrategy, type UsageProvider, type UsageReport } from "../usage";
 export declare function parseClaudeRateLimitHeaders(headers: Record<string, string>, now?: number): UsageReport | null;
 export declare const claudeUsageProvider: UsageProvider;
 export declare const claudeRankingStrategy: CredentialRankingStrategy;

package/dist/types/utils/block-symbols.d.ts

@@ -18,3 +18,19 @@ export declare const kStreamingLastParseLen: unique symbol;
 export declare const kStreamingArgumentsDone: unique symbol;
 /** Classifies Cursor's in-flight tool-call kind without leaking provider-private state. */
 export declare const kStreamingBlockKind: unique symbol;
+/**
+ * Marks a `toolCall` content block that Cursor's exec channel already
+ * executed server-side (via the coding-agent bridge) and whose result is
+ * buffered separately for emission via the assistant-loop stream.
+ *
+ * `agent-loop.ts` MUST skip execution of blocks carrying this marker —
+ * treating them as a fresh runnable tool call would run the same
+ * side-effecting tool (bash, write, delete, …) a second time. Symbol-keyed
+ * so it never persists across the JSONL round-trip, where rebuild instead
+ * pairs the block with its already-persisted `toolResult` message by id.
+ */
+export declare const kCursorExecResolved: unique symbol;
+/** Carries the resolved marker without exposing a string-keyed property. */
+export type CursorExecResolvedCarrier = object & {
+    [kCursorExecResolved]?: true;
+};

package/dist/types/utils/proxy.d.ts

@@ -22,8 +22,14 @@ export declare function getProxyForProvider(provider: string): string | undefine
  * Wraps a fetch implementation to inject proxy options for non-local hosts.
  */
 export declare function wrapFetchForProxy(fetchImpl: FetchImpl, provider: string): FetchImpl;
+export interface ConnectProxiedSocketOptions {
+    /** Caller cancellation for the proxy TCP/TLS handshake and CONNECT tunnel. */
+    signal?: AbortSignal;
+    /** Maximum wall-clock time to establish the final TLS tunnel. Disabled when absent or non-positive. */
+    timeoutMs?: number;
+}
 /**
  * Tunnel a socket connection through an HTTP CONNECT proxy.
  * This is used specifically to wrap Node's `http2.connect(baseUrl, { createConnection })` for Cursor.
  */
-export declare function connectProxiedSocket(proxyUrlStr: string, targetUrlStr: string): Promise<tls.TLSSocket>;
+export declare function connectProxiedSocket(proxyUrlStr: string, targetUrlStr: string, options?: ConnectProxiedSocketOptions): Promise<tls.TLSSocket>;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "16.3.0",
+	"version": "16.3.3",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -38,9 +38,9 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.0",
-		"@oh-my-pi/pi-catalog": "16.3.0",
-		"@oh-my-pi/pi-utils": "16.3.0",
-		"@oh-my-pi/pi-wire": "16.3.0",
+		"@oh-my-pi/pi-catalog": "16.3.3",
+		"@oh-my-pi/pi-utils": "16.3.3",
+		"@oh-my-pi/pi-wire": "16.3.3",
 		"arktype": "^2.2.0",
 		"zod": "^4"
 	},

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

@@ -25,10 +25,11 @@ import { type AuthBrokerClient, AuthBrokerStreamUnsupportedError } from "./clien
 import type { RefresherSchedule, SnapshotEntry, SnapshotResponse, SnapshotStreamEvent } from "./types";
 
 /**
- * Client-side TTL for the aggregate `/v1/usage` response. Set below the
- * broker server's own 30s usage cache so we typically pick up the broker's
- * cached value instead of re-walking the network — but high enough to absorb
- * the parallel fan-out from `#rankOAuthSelections` into a single round-trip.
+ * Client-side TTL for the aggregate `/v1/usage` response. The broker dedups
+ * upstream `/usage` hits via AuthStorage's 5-minute per-credential cache plus
+ * single-flight, so this short client TTL mainly folds the parallel fan-out
+ * from `#rankOAuthSelections` into a single round-trip — a ranking pass issues
+ * one broker call instead of N.
  */
 const USAGE_CACHE_TTL_MS = 15_000;
 const WAIT_THRESHOLD_MS = 1_000;
@@ -68,6 +69,47 @@ interface UsageCacheEntry {
 	fetchedAt: number;
 }
 
+function usageOverlayKey(
+	provider: Provider,
+	ids: { accountId?: string; email?: string; projectId?: string },
+): string | undefined {
+	const accountId = ids.accountId?.trim().toLowerCase();
+	if (accountId) return `${provider}\0account:${accountId}`;
+	const email = ids.email?.trim().toLowerCase();
+	if (email) return `${provider}\0email:${email}`;
+	const projectId = ids.projectId?.trim().toLowerCase();
+	if (projectId) return `${provider}\0project:${projectId}`;
+	return undefined;
+}
+
+function mergeUsageReports(base: UsageReport, overlay: UsageReport): UsageReport {
+	const overlayLimitsById = new Map(overlay.limits.map(limit => [limit.id, limit]));
+	const limits = [];
+	for (const limit of base.limits) {
+		const replacement = overlayLimitsById.get(limit.id);
+		if (replacement) {
+			limits.push(replacement);
+			overlayLimitsById.delete(limit.id);
+		} else {
+			limits.push(limit);
+		}
+	}
+	for (const limit of overlayLimitsById.values()) limits.push(limit);
+	const overlayMetadata = (overlay.metadata ?? {}) as Record<string, unknown>;
+	return {
+		...base,
+		fetchedAt: Math.max(base.fetchedAt, overlay.fetchedAt),
+		limits,
+		metadata: {
+			...overlayMetadata,
+			...(base.metadata ?? {}),
+			...(overlayMetadata.headersUpdatedAt !== undefined
+				? { headersUpdatedAt: overlayMetadata.headersUpdatedAt }
+				: {}),
+		},
+	};
+}
+
 export interface RemoteAuthCredentialStoreOptions {
 	client: AuthBrokerClient;
 	/**
@@ -94,6 +136,7 @@ export class RemoteAuthCredentialStore implements AuthCredentialStore {
 	#snapshot: SnapshotResponse = emptySnapshot();
 	#snapshotReceivedAt = Date.now();
 	#generation = 0;
+	#usageOverlays: Map<string, UsageReport> = new Map();
 	#backgroundAbort = new AbortController();
 	#cache: Map<string, CacheEntry> = new Map();
 	#usageCache?: UsageCacheEntry;
@@ -515,14 +558,15 @@ export class RemoteAuthCredentialStore implements AuthCredentialStore {
 	 * residential laptop is, so all credentials surface every cycle.
 	 */
 	async fetchUsageReports(signal?: AbortSignal): Promise<UsageReport[] | null> {
-		return this.#raceWithSignal(this.#loadUsageReports(), signal);
+		const reports = await this.#raceWithSignal(this.#loadUsageReports(), signal);
+		return reports ? this.#applyUsageOverlays(reports) : null;
 	}
 
 	/**
 	 * Per-credential usage hook consumed by `AuthStorage.#getUsageReport`. Pulls
 	 * the aggregate broker `/v1/usage` once and serves all callers from the
-	 * same response (coalesced + cached), then matches the credential to a
-	 * report by provider + identity (accountId / email / projectId).
+	 * same response (coalesced + cached), then overlays any client-observed
+	 * header hints for the matching credential.
 	 *
 	 * The broker already aggregates with its own 30s TTL on the server side; our
 	 * 15s client TTL is below that so we usually re-use the broker's cache too.
@@ -533,8 +577,47 @@ export class RemoteAuthCredentialStore implements AuthCredentialStore {
 		signal?: AbortSignal,
 	): Promise<UsageReport | null> {
 		const reports = await this.#raceWithSignal(this.#loadUsageReports(), signal);
-		if (!reports) return null;
-		return matchUsageReport(reports, provider, credential);
+		const matched = reports ? matchUsageReport(reports, provider, credential) : null;
+		const overlay = this.#getActiveUsageOverlay(provider, credential);
+		if (matched && overlay) return mergeUsageReports(matched, overlay);
+		return overlay ?? matched;
+	}
+
+	ingestUsageReport(provider: Provider, credential: OAuthCredential, report: UsageReport): boolean {
+		const key = usageOverlayKey(provider, credential);
+		if (!key) return false;
+		const activeOverlay = this.#getActiveUsageOverlay(provider, credential);
+		this.#usageOverlays.set(key, activeOverlay ? mergeUsageReports(activeOverlay, report) : report);
+		return true;
+	}
+
+	#getActiveUsageOverlay(provider: Provider, credential: OAuthCredential): UsageReport | undefined {
+		const key = usageOverlayKey(provider, credential);
+		if (!key) return undefined;
+		const overlay = this.#usageOverlays.get(key);
+		if (!overlay) return undefined;
+		if (Date.now() - overlay.fetchedAt >= USAGE_CACHE_TTL_MS) {
+			this.#usageOverlays.delete(key);
+			return undefined;
+		}
+		return overlay;
+	}
+
+	#applyUsageOverlays(reports: UsageReport[]): UsageReport[] {
+		const overlays = [...this.#usageOverlays.values()].filter(
+			overlay => Date.now() - overlay.fetchedAt < USAGE_CACHE_TTL_MS,
+		);
+		if (overlays.length === 0) return reports;
+		const merged = [...reports];
+		for (const overlay of overlays) {
+			const matchIndex = findMatchingReportIndex(merged, overlay);
+			if (matchIndex === -1) {
+				merged.push(overlay);
+			} else {
+				merged[matchIndex] = mergeUsageReports(merged[matchIndex]!, overlay);
+			}
+		}
+		return merged;
 	}
 
 	/**
@@ -597,6 +680,7 @@ export class RemoteAuthCredentialStore implements AuthCredentialStore {
 		this.#closed = true;
 		this.#backgroundAbort.abort();
 		this.#cache.clear();
+		this.#usageOverlays.clear();
 	}
 }
 
@@ -623,6 +707,22 @@ function matchUsageReport(reports: UsageReport[], provider: Provider, credential
 	return null;
 }
 
+function findMatchingReportIndex(reports: UsageReport[], overlay: UsageReport): number {
+	const candidates = reports
+		.map((report, index) => ({ report, index }))
+		.filter(candidate => candidate.report.provider === overlay.provider);
+	if (candidates.length === 0) return -1;
+	if (candidates.length === 1) return candidates[0]!.index;
+	const metadata = (overlay.metadata ?? {}) as Record<string, unknown>;
+	const accountId = readMetadataString(metadata, "accountId")?.toLowerCase();
+	const email = readMetadataString(metadata, "email")?.toLowerCase();
+	const projectId = readMetadataString(metadata, "projectId")?.toLowerCase();
+	for (const candidate of candidates) {
+		if (reportMatchesIdentity(candidate.report, accountId, email, projectId)) return candidate.index;
+	}
+	return -1;
+}
+
 function reportMatchesIdentity(
 	report: UsageReport,
 	accountId: string | undefined,

package/src/auth-storage.ts

@@ -362,6 +362,13 @@ export interface AuthCredentialStore {
 	 * `signal` propagates the agent's cancel down to the broker fetch.
 	 */
 	getUsageReport?(provider: Provider, credential: OAuthCredential, signal?: AbortSignal): Promise<UsageReport | null>;
+	/**
+	 * Optional store hook to ingest a parsed provider usage report for one OAuth
+	 * credential. Remote broker stores use this to overlay header-derived limits
+	 * onto their cached aggregate `/v1/usage` response without mutating broker
+	 * state.
+	 */
+	ingestUsageReport?(provider: Provider, credential: OAuthCredential, report: UsageReport): boolean;
 	/**
 	 * Optional store hook to invalidate a specific credential after the upstream
 	 * provider returned 401 on a supposedly-fresh key. Remote stores force the
@@ -2234,16 +2241,15 @@ export class AuthStorage {
 				this.#recordUsageHistory(request, report);
 				return report;
 			}
-			// Failure: cache the LAST GOOD value (if any) with a short jittered TTL
-			// so the credential cools down briefly without dropping out of the
-			// report. If we never had a good value, return null this cycle and
-			// don't write — let the next poll retry.
+			// Failure: apply a short jittered cool-down so the credential doesn't
+			// re-hit the endpoint on every poll. Serve the last good value when we
+			// have one (keeps the credential in the report); otherwise cache null
+			// so a cold or throttled credential stops re-bursting until the window
+			// expires and the next poll retries.
 			const lastGood = this.#usageCache.getStale<UsageReport | null>(cacheKey)?.value ?? null;
-			if (lastGood !== null) {
-				const backoffJitter = USAGE_FAILURE_BACKOFF_MS * (Math.random() * 0.5 - 0.25);
-				const coolDown = Date.now() + USAGE_FAILURE_BACKOFF_MS + backoffJitter;
-				this.#usageCache.set(cacheKey, { value: lastGood, expiresAt: coolDown });
-			}
+			const backoffJitter = USAGE_FAILURE_BACKOFF_MS * (Math.random() * 0.5 - 0.25);
+			const coolDown = Date.now() + USAGE_FAILURE_BACKOFF_MS + backoffJitter;
+			this.#usageCache.set(cacheKey, { value: lastGood, expiresAt: coolDown });
 			return lastGood;
 		})().finally(() => {
 			this.#usageRequestInFlight.delete(cacheKey);
@@ -2360,7 +2366,7 @@ export class AuthStorage {
 		headers: Record<string, string>,
 		options?: { sessionId?: string; baseUrl?: string },
 	): boolean {
-		if (this.#fetchUsageReportsOverride || this.#store.fetchUsageReports) return false;
+		if (this.#fetchUsageReportsOverride) return false;
 
 		const credential = this.#resolveActiveOAuthCredential(provider, options?.sessionId);
 		if (!credential) return false;
@@ -2380,6 +2386,14 @@ export class AuthStorage {
 		if (credential.projectId && metadata.projectId === undefined) metadata.projectId = credential.projectId;
 		const report: UsageReport = { ...parsedReport, metadata };
 
+		const storeIngest = this.#store.ingestUsageReport?.bind(this.#store);
+		if (storeIngest) {
+			const ingested = storeIngest(provider, credential, report);
+			if (ingested) this.#usageHeaderIngestAt.set(cacheKey, now);
+			return ingested;
+		}
+
+		if (this.#fetchUsageReportsOverride || this.#store.fetchUsageReports) return false;
 		const prior = this.#usageCache.getStale<UsageReport | null>(cacheKey)?.value;
 		let merged = report;
 		if (prior && Array.isArray(prior.limits)) {

package/src/dialect/demotion.ts

@@ -10,17 +10,22 @@ const CLAUDE_FABLE_ID = /(?:^|[./])claude[-.]fable(?:[-.]|$)/i;
  * replayed unsigned `thought` part is schema-accepted but silently discarded —
  * neither recalled nor influencing generation).
  *
- * Fable is the exception: replaying prior reasoning inside `<thinking>` /
- * `antml:thinking`-style assistant text is treated as a reasoning-extraction
- * attempt and can train the next turn to leak thoughts, so Fable receives the
- * reasoning as markdown-italic assistant prose instead. Harmony and Gemma are
- * also exceptions: their `renderThinking` emits chat-template control tokens
- * (`<|channel|>analysis`, `<|channel>thought`) that must not appear inside a
- * structured native message, so they fall back to a plain `<think>` block. Every
- * other dialect's thinking form is inline-safe XML tags or a markdown fence.
+ * Fable is the exception: Anthropic's `reasoning_extraction` classifier blocks
+ * requests that replay prior reasoning inside `<thinking>` / `antml:thinking`
+ * tags OR the older `_Hmm. …_` italic envelope — it reads the wrapped
+ * chain-of-thought as an attempt to duplicate model outputs and refuses the
+ * whole turn. Fable therefore receives prior reasoning as bare assistant prose:
+ * no tag, no `_Hmm.` wrapper, no trailing newline.
+ * Heat is cumulative (block count and early-conversation position also raise
+ * it), so this lowers per-block signal but does not license unbounded replay.
+ * Harmony and Gemma are also exceptions: their `renderThinking` emits
+ * chat-template control tokens (`<|channel|>analysis`, `<|channel>thought`)
+ * that must not appear inside a structured native message, so they fall back to
+ * a plain `<think>` block. Every other dialect's thinking form is inline-safe
+ * XML tags or a markdown fence.
  *
- * The result ends with a trailing newline so the block stays separated from the
- * turn's reply text when the wire encoder concatenates parts.
+ * The result does not append a delimiter; callers that flatten adjacent blocks
+ * into a single string must insert their own separator.
  *
  * Distinct from {@link DialectDefinition.renderThinking}, which targets the
  * owned-dialect *text transport* where those control tokens are legal.
@@ -30,7 +35,7 @@ export function renderDemotedThinking(modelId: string, text: string): string {
 	text = text.toWellFormed();
 	const canonicalId = bareModelId(modelId);
 	const dialect = preferredDialect(modelId);
-	if (CLAUDE_FABLE_ID.test(canonicalId)) return `_Hmm. ${text}_\n`;
-	if (dialect === "harmony" || dialect === "gemma") return `<think>\n${text}\n</think>\n`;
-	return `${getDialectDefinition(dialect).renderThinking(text)}\n`;
+	if (CLAUDE_FABLE_ID.test(canonicalId)) return text;
+	if (dialect === "harmony" || dialect === "gemma") return `<think>\n${text}\n</think>`;
+	return getDialectDefinition(dialect).renderThinking(text);
 }