@oh-my-pi/pi-ai 15.10.6 → 15.10.7

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+## [15.10.7] - 2026-06-08
+
+### Fixed
+
+- Fixed first-party Anthropic requests returning HTTP 400 "Invalid `signature` in `thinking` block" after interrupting the model during its visible output. `transformMessages` stripped the signature from every `thinking` block of an `aborted`/`error` turn, including blocks that had already finished streaming — Anthropic delivers a block's signature at `content_block_stop` before the next block starts, so a thinking block followed by `text`/`tool_use` is fully signed. The valid signature was then replayed empty (`signature: ""`), which signature-enforcing Anthropic rejects, including when the provider is routed through an LLM gateway baseUrl. Only the single mid-stream block at the abort point is now treated as untrustworthy; completed thinking blocks keep their replayable signatures ([#2144](https://github.com/can1357/oh-my-pi/issues/2144)).
+- Pinned a regression test against issue [#2123](https://github.com/can1357/oh-my-pi/issues/2123): OAuth requests to adaptive-thinking Claude Opus models (4.6+) ship a `context_management.edits[clear_thinking_20251015]` block paired with the `thinking` field, but the eager-todo prelude (and other paths that force `tool_choice` to `tool`/`any` on the first user turn) route through `disableThinkingIfToolChoiceForced`, which would strip `params.thinking` while leaving the orphan `context_management` behind. The Anthropic API then rejected the request with `400 ... clear_thinking_20251015 strategy requires thinking to be enabled or adaptive`. The fix that lands in [15.10.5] now drops both fields together; the new test locks the contract so the strategy can never outlive its enabling `thinking` payload again.
+- Fixed Antigravity usage counters so exhausted Google/Gemini quota renders as `0% free` while separate Anthropic/OpenAI-backed Antigravity model counters remain visible independently, without replaying stale pre-fix cached usage reports.
+
 ## [15.10.6] - 2026-06-08
 
 ### Added

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "15.10.6",
+	"version": "15.10.7",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -39,7 +39,7 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.0",
-		"@oh-my-pi/pi-utils": "15.10.6",
+		"@oh-my-pi/pi-utils": "15.10.7",
 		"openai": "^6.39.0",
 		"partial-json": "^0.1.7",
 		"zod": "4.4.3"

package/src/auth-storage.ts

@@ -492,6 +492,9 @@ const USAGE_FAILURE_BACKOFF_MS = 10_000;
 // Bumped from 3s — Claude usage retries up to 3 times with exponential backoff
 // (~3.5s total worst case); a tight per-request budget aborts retries mid-cycle.
 const DEFAULT_USAGE_REQUEST_TIMEOUT_MS = 10_000;
+const USAGE_REPORT_CACHE_KEY_VERSION_OVERRIDES: Partial<Record<Provider, number>> = {
+	"google-antigravity": 2,
+};
 const DEFAULT_OAUTH_REFRESH_TIMEOUT_MS = 10_000;
 /**
  * Refresh OAuth access tokens this many ms before their stated expiry. The
@@ -1638,15 +1641,19 @@ export class AuthStorage {
 	#buildUsageReportCacheKey(request: UsageRequestDescriptor): string {
 		const baseUrl = this.#normalizeUsageBaseUrl(request.baseUrl) || "default";
 		const identity = this.#buildUsageCacheIdentity(request.credential);
-		return `report:${request.provider}:${baseUrl}:${identity}`;
+		const versionOverride = USAGE_REPORT_CACHE_KEY_VERSION_OVERRIDES[request.provider];
+		const providerKey = versionOverride === undefined ? request.provider : `${versionOverride}:${request.provider}`;
+		return `report:${providerKey}:${baseUrl}:${identity}`;
 	}
 
 	#buildUsageReportsCacheKey(requests: ReadonlyArray<UsageRequestDescriptor>): string {
 		const snapshot = requests
-			.map(
-				request =>
-					`${request.provider}:${this.#normalizeUsageBaseUrl(request.baseUrl) || "default"}:${this.#buildUsageCacheIdentity(request.credential)}`,
-			)
+			.map(request => {
+				const versionOverride = USAGE_REPORT_CACHE_KEY_VERSION_OVERRIDES[request.provider];
+				const providerKey =
+					versionOverride === undefined ? request.provider : `${versionOverride}:${request.provider}`;
+				return `${providerKey}:${this.#normalizeUsageBaseUrl(request.baseUrl) || "default"}:${this.#buildUsageCacheIdentity(request.credential)}`;
+			})
 			.sort()
 			.join("\n");
 		return `reports:${Bun.hash(snapshot).toString(16)}`;

package/src/providers/transform-messages.ts

@@ -173,32 +173,46 @@ export function transformMessages<TApi extends Api>(
 					index === latestSurvivingAssistantIndex &&
 					model.api === "anthropic-messages" &&
 					assistantMsg.api === "anthropic-messages";
-				// Aborted/errored messages may have partially-streamed thinking signatures.
-				// A partial signature is invalid and will be rejected by the API, so we must
-				// strip signatures from thinking blocks in these messages.
+				// Thinking signatures can be untrustworthy for two distinct reasons with very
+				// different blast radii:
 				//
-				// Abandoned tool-use turns get the same treatment once they are no longer
-				// the latest assistant message. When a turn carries toolCall blocks but did
-				// NOT request tool execution (stopReason !== "toolUse" — e.g.
-				// adaptive-thinking Opus emitting tool calls and then ending the turn on
-				// `end_turn`/`stop`), the agent loop pairs those calls with placeholder
-				// tool_results to keep the tool_use/tool_result contract valid. Historical
-				// abandoned turns cannot safely replay their end_turn-bound signatures in
-				// that continuation, so stripping downgrades them to plain text downstream.
-				// Latest abandoned turns are exempt because Anthropic requires thinking
-				// blocks from its most recent response to remain byte-for-byte unmodified.
+				// 1. Aborted/errored turns: the stream stopped mid-block, so only the block
+				//    that was streaming at the abort point — always the FINAL content block —
+				//    can carry a partially-streamed (invalid) signature. Every earlier block
+				//    completed: Anthropic delivers a block's signature at its
+				//    `content_block_stop`, which necessarily fired before the next block began,
+				//    so those signatures are whole and valid. Stripping them would needlessly
+				//    discard a replayable thinking chain — e.g. interrupting during the visible
+				//    text output after thinking already finished leaves a fully-signed thinking
+				//    block that must be kept, or Anthropic rejects the replay with HTTP 400
+				//    "Invalid `signature` in `thinking` block".
+				//
+				// 2. Abandoned tool-use turns: a turn that carries toolCall blocks but did NOT
+				//    request tool execution (stopReason !== "toolUse" — e.g. adaptive-thinking
+				//    Opus emitting tool calls and then ending on `end_turn`/`stop`). The agent
+				//    loop pairs those calls with placeholder tool_results to keep the
+				//    tool_use/tool_result contract valid. The turn completed cleanly, but its
+				//    signatures are end_turn-bound and cannot be replayed in that synthesized
+				//    continuation, so EVERY thinking signature is stripped.
+				//
+				// Latest abandoned turns are exempt because Anthropic requires thinking blocks
+				// from its most recent response to remain byte-for-byte unmodified.
 				const invalidStopReason = assistantMsg.stopReason === "aborted" || assistantMsg.stopReason === "error";
 				const abandonedToolUse =
 					!invalidStopReason &&
 					assistantMsg.stopReason !== "toolUse" &&
 					assistantMsg.content.some(b => b.type === "toolCall");
-				const hasInvalidSignatures = invalidStopReason || abandonedToolUse;
+				const lastBlockIndex = assistantMsg.content.length - 1;
 
-				const transformedContent = assistantMsg.content.flatMap(block => {
+				const transformedContent = assistantMsg.content.flatMap((block, blockIndex) => {
 					if (block.type === "thinking") {
-						// Strip untrustworthy signatures so the encoder can downgrade to text.
+						// Only an aborted/errored turn's final (mid-stream) block can hold a
+						// partial signature; abandoned tool-use turns strip all. Drop the
+						// untrustworthy signature so the encoder can downgrade the block to text.
+						const signatureUntrustworthy =
+							abandonedToolUse || (invalidStopReason && blockIndex === lastBlockIndex);
 						const sanitized =
-							hasInvalidSignatures && block.thinkingSignature
+							signatureUntrustworthy && block.thinkingSignature
 								? { ...block, thinkingSignature: undefined }
 								: block;
 						if (mustPreserveLatestAnthropicThinking) return abandonedToolUse ? block : sanitized;

package/src/usage/google-antigravity.ts

@@ -18,6 +18,8 @@ interface AntigravityQuotaInfo {
 	tier?: string;
 	windowId?: string;
 	windowLabel?: string;
+	apiProvider?: string;
+	modelProvider?: string;
 }
 
 interface AntigravityModelInfo {
@@ -25,6 +27,8 @@ interface AntigravityModelInfo {
 	quotaInfo?: AntigravityQuotaInfo | AntigravityQuotaInfo[];
 	quotaInfos?: AntigravityQuotaInfo[];
 	quotaInfoByTier?: Record<string, AntigravityQuotaInfo | AntigravityQuotaInfo[]>;
+	apiProvider?: string;
+	modelProvider?: string;
 }
 
 interface AntigravityUsageResponse {
@@ -60,22 +64,47 @@ function parseWindow(info: AntigravityQuotaInfo): UsageWindow | undefined {
 }
 
 function buildAmount(info: AntigravityQuotaInfo): UsageAmount {
-	const remainingFraction = clampFraction(info.remainingFraction);
+	const apiRemainingFraction = clampFraction(info.remainingFraction);
+	// Observed Antigravity responses omit remainingFraction for exhausted
+	// Google/Gemini counters and keep only resetTime. Treat that shape as
+	// "blocked until reset" rather than unknown so a healthy sibling backend
+	// counter cannot mask it during dedupe.
+	const remainingFraction = apiRemainingFraction ?? (info.resetTime ? 0 : undefined);
 	const amount: UsageAmount = { unit: "percent" };
 	if (remainingFraction === undefined) return amount;
-	const usedFraction = clampFraction(1 - remainingFraction);
+	const usedFraction = 1 - remainingFraction;
 	amount.remainingFraction = remainingFraction;
 	amount.usedFraction = usedFraction;
 	amount.remaining = remainingFraction * 100;
-	amount.used = usedFraction !== undefined ? usedFraction * 100 : undefined;
+	amount.used = usedFraction * 100;
 	amount.limit = 100;
 	return amount;
 }
 
+function formatCounterName(info: AntigravityQuotaInfo): string | undefined {
+	switch (info.modelProvider ?? info.apiProvider) {
+		case "MODEL_PROVIDER_ANTHROPIC":
+		case "API_PROVIDER_ANTHROPIC_VERTEX":
+			return "Anthropic";
+		case "MODEL_PROVIDER_GOOGLE":
+		case "API_PROVIDER_GOOGLE_GEMINI":
+			return "Google";
+		case "MODEL_PROVIDER_OPENAI":
+		case "API_PROVIDER_OPENAI_VERTEX":
+			return "OpenAI";
+		default:
+			return undefined;
+	}
+}
+
 function normalizeQuotaInfos(info: AntigravityModelInfo): AntigravityQuotaInfo[] {
 	const results: AntigravityQuotaInfo[] = [];
+	const source = {
+		...(info.apiProvider ? { apiProvider: info.apiProvider } : {}),
+		...(info.modelProvider ? { modelProvider: info.modelProvider } : {}),
+	};
 	const addInfo = (value: AntigravityQuotaInfo, tier?: string) => {
-		results.push({ ...value, ...(tier ? { tier } : {}) });
+		results.push({ ...source, ...value, ...(tier ? { tier } : {}) });
 	};
 	const addArray = (values?: AntigravityQuotaInfo[]) => {
 		if (!values) return;
@@ -150,11 +179,20 @@ async function fetchAntigravityUsage(params: UsageFetchParams, ctx: UsageFetchCo
 	const data = (await response.json()) as AntigravityUsageResponse;
 
 	// The API returns per-model quota entries, but quota is shared across
-	// models within the same tier. Deduplicate by (tier, windowId) so one
-	// account doesn't produce 15 redundant bars.
+	// models within the same backend counter, tier, and reset window. Keep
+	// Google and Anthropic-backed Antigravity models separate so a healthy
+	// Claude counter cannot mask an exhausted Gemini counter.
 	const deduped = new Map<
 		string,
-		{ amount: UsageAmount; window: UsageWindow | undefined; tier: string | undefined }
+		{
+			amount: UsageAmount;
+			window: UsageWindow | undefined;
+			tier: string | undefined;
+			tierKey: string;
+			windowId: string;
+			counterName: string | undefined;
+			counterKey: string;
+		}
 	>();
 	let earliestReset: number | undefined;
 
@@ -166,14 +204,16 @@ async function fetchAntigravityUsage(params: UsageFetchParams, ctx: UsageFetchCo
 			if (window?.resetsAt) {
 				earliestReset = earliestReset ? Math.min(earliestReset, window.resetsAt) : window.resetsAt;
 			}
-			const tier = (quotaInfo.tier ?? "default").toLowerCase();
+			const tierKey = (quotaInfo.tier ?? "default").toLowerCase();
+			const counterName = formatCounterName(quotaInfo);
+			const counterKey = counterName?.toLowerCase() ?? "default";
 			// Use quotaInfo.windowId even when parseWindow returns undefined
 			// (no resetTime) — separate windows must not collapse to "default".
 			const windowId = quotaInfo.windowId ?? window?.id ?? "default";
-			const key = `${tier}|${windowId}`;
+			const key = `${counterKey}|${tierKey}|${windowId}`;
 			const existing = deduped.get(key);
 			if (!existing) {
-				deduped.set(key, { amount, window, tier: quotaInfo.tier });
+				deduped.set(key, { amount, window, tier: quotaInfo.tier, tierKey, windowId, counterName, counterKey });
 				continue;
 			}
 			// Merge: keep the entry with fraction data for the bar, but
@@ -190,7 +230,7 @@ async function fetchAntigravityUsage(params: UsageFetchParams, ctx: UsageFetchCo
 			if (!eHasFrac && cHasFrac) {
 				bestAmount = amount;
 				bestTier = quotaInfo.tier ?? existing.tier;
-			} else if (eHasFrac && cHasFrac && cFrac! < eFrac!) {
+			} else if (eFrac !== undefined && cFrac !== undefined && cFrac < eFrac) {
 				bestAmount = amount;
 				bestTier = quotaInfo.tier ?? existing.tier;
 			}
@@ -199,23 +239,30 @@ async function fetchAntigravityUsage(params: UsageFetchParams, ctx: UsageFetchCo
 			if (!bestWindow?.resetsAt && window?.resetsAt) {
 				bestWindow = window;
 			}
-			deduped.set(key, { amount: bestAmount, window: bestWindow, tier: bestTier });
+			deduped.set(key, {
+				amount: bestAmount,
+				window: bestWindow,
+				tier: bestTier,
+				tierKey: existing.tierKey,
+				windowId: existing.windowId,
+				counterName: existing.counterName,
+				counterKey: existing.counterKey,
+			});
 		}
 	}
 
 	const limits: UsageLimit[] = [];
-	for (const [key, entry] of deduped) {
-		const [tier, windowId] = key.split("|") as [string, string];
-		const label = "Usage";
+	for (const entry of deduped.values()) {
+		const label = entry.counterName ? `Usage (${entry.counterName})` : "Usage";
 		limits.push({
-			id: `${params.provider}:${tier}:${windowId}`,
+			id: `${params.provider}:${entry.counterKey}:${entry.tierKey}:${entry.windowId}`,
 			label,
 			scope: {
 				provider: params.provider,
 				accountId: credential.accountId,
 				projectId: credential.projectId,
 				tier: entry.tier,
-				windowId,
+				windowId: entry.windowId,
 			},
 			window: entry.window,
 			amount: entry.amount,