@oh-my-pi/pi-ai 16.2.4 → 16.2.6

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [16.2.6] - 2026-06-29
+
+### Fixed
+
+- Fixed Antigravity usage reporting to correctly infer daily and weekly quota windows from unlabeled reset-only rows, preventing Cloud Code Assist payloads from collapsing these counters into the default category.
+
+## [16.2.5] - 2026-06-28
+
+### Fixed
+
+- Fixed Google and Cloud Code Assist streams that end without a finish reason (dropped connections or truncated responses) being treated as fatal; they are now classified as transient so the coding agent automatically retries.
+
 ## [16.2.4] - 2026-06-28
 
 ### Added

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "16.2.4",
+	"version": "16.2.6",
 	"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.2.4",
-		"@oh-my-pi/pi-utils": "16.2.4",
-		"@oh-my-pi/pi-wire": "16.2.4",
+		"@oh-my-pi/pi-catalog": "16.2.6",
+		"@oh-my-pi/pi-utils": "16.2.6",
+		"@oh-my-pi/pi-wire": "16.2.6",
 		"arktype": "^2.2.0",
 		"zod": "^4"
 	},

package/src/error/provider.ts

@@ -36,7 +36,13 @@ export class ProviderResponseError extends Error {
 		this.name = "ProviderResponseError";
 		this.provider = options.provider;
 		this.kind = options.kind ?? "output";
+		// A safety filter block is a terminal provider finish, not a transient fault.
 		if (this.kind === "content-blocked") attach(this, create(Flag.ProviderFinishError));
+		// An incomplete stream (connection dropped / truncated before any terminal
+		// event) never produced a finish reason — the request didn't complete, so it
+		// is safe to retry. The retry layer's replay-unsafe guard still blocks a
+		// retry when partial tool output was already emitted.
+		else if (this.kind === "incomplete-stream") attach(this, create(Flag.Transient));
 	}
 }
 

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

@@ -2151,14 +2151,29 @@ function recordCodexWebSocketFailure(state: CodexWebSocketSessionState, activate
 	}
 }
 
+function getCodexWebSocketEnvValue(): boolean | undefined {
+	const envVal = $env.PI_CODEX_WEBSOCKET;
+	if (envVal !== undefined) {
+		return $flag("PI_CODEX_WEBSOCKET");
+	}
+	return undefined;
+}
+
 function shouldUseCodexWebSocket(
 	model: Model<"openai-codex-responses">,
 	state: CodexWebSocketSessionState | undefined,
 	preferWebsockets?: boolean,
 ): boolean {
+	// Explicitly disabled by the model or session state.
+	if (model.preferWebsockets === false) return false;
+	// Explicitly disabled by the session state.
 	if (!state || state.disableWebsocket) return false;
+	// Env val > Preference
+	const envVal = getCodexWebSocketEnvValue();
+	if (envVal !== undefined) return envVal;
+	// Negative preference overrides model preference; otherwise use the model's preference.
 	if (preferWebsockets === false) return false;
-	return $flag("PI_CODEX_WEBSOCKET") || preferWebsockets === true || model.preferWebsockets === true;
+	return true;
 }
 
 export interface OpenAICodexTransportDetails {
@@ -2214,10 +2229,13 @@ export function getOpenAICodexTransportDetails(
 		providerSessionState?: Map<string, ProviderSessionState>;
 	},
 ): OpenAICodexTransportDetails {
+	const envVal = getCodexWebSocketEnvValue();
 	const websocketPreferred =
-		options?.preferWebsockets === false
-			? false
-			: $flag("PI_CODEX_WEBSOCKET") || options?.preferWebsockets === true || model.preferWebsockets === true;
+		envVal !== undefined
+			? envVal
+			: options?.preferWebsockets === false
+				? false
+				: options?.preferWebsockets === true || model.preferWebsockets === true;
 	const state = getCodexWebSocketStateForPublicSession(model, options);
 
 	return {

package/src/stream.ts

@@ -367,14 +367,17 @@ async function tryAcquireProviderInFlightLease(
 	}
 }
 
-async function signalProviderInFlightWaiters(provider: string): Promise<void> {
+async function signalProviderInFlightWaitersInDir(dir: string): Promise<void> {
 	try {
-		const dir = providerInFlightDir(provider);
 		await fs.mkdir(dir, { recursive: true });
-		await Bun.write(providerInFlightSignalPath(provider), String(Date.now()));
+		await Bun.write(path.join(dir, ".wakeup"), String(Date.now()));
 	} catch {}
 }
 
+async function signalProviderInFlightWaiters(provider: string): Promise<void> {
+	await signalProviderInFlightWaitersInDir(providerInFlightDir(provider));
+}
+
 function waitForProviderInFlightSignal(provider: string, signal?: AbortSignal): Promise<void> {
 	if (signal?.aborted)
 		return Promise.reject(signal.reason ?? new AIError.AbortError("Provider request aborted before dispatch"));
@@ -434,11 +437,15 @@ async function removeProviderInFlightLeaseDir(leasePath: string): Promise<void>
 	}
 }
 
-async function releaseProviderInFlightLease(provider: string, lease: ProviderInFlightLease): Promise<void> {
+// Signal into the lease's OWN provider directory (derived from `lease.path`)
+// rather than recomputing it from the current root. A release that lands after
+// the in-flight root has been repointed (only the test seam does that) must not
+// write `.wakeup` into an unrelated provider directory.
+async function releaseProviderInFlightLease(lease: ProviderInFlightLease): Promise<void> {
 	clearInterval(lease.heartbeat);
 	await lease.flushHeartbeat();
 	await removeProviderInFlightLeaseDir(lease.path);
-	await signalProviderInFlightWaiters(provider);
+	await signalProviderInFlightWaitersInDir(path.dirname(lease.path));
 }
 
 async function acquireProviderInFlightSlot(
@@ -451,7 +458,7 @@ async function acquireProviderInFlightSlot(
 	while (true) {
 		if (signal?.aborted) throw signal.reason ?? new AIError.AbortError("Provider request aborted before dispatch");
 		const lease = await tryAcquireProviderInFlightLease(provider, limit, signal);
-		if (lease) return () => releaseProviderInFlightLease(provider, lease);
+		if (lease) return () => releaseProviderInFlightLease(lease);
 		if (!loggedWait) {
 			loggedWait = true;
 			logger.debug("Provider in-flight limit blocked request", { provider, limit });

package/src/usage/google-antigravity.ts

@@ -68,6 +68,57 @@ function classifyWindow(id: string | undefined, label: string | undefined): Anti
 	return undefined;
 }
 
+function parseResetTime(info: AntigravityQuotaInfo): number | undefined {
+	const resetAt = info.resetTime ? Date.parse(info.resetTime) : undefined;
+	return resetAt !== undefined && Number.isFinite(resetAt) ? resetAt : undefined;
+}
+
+function inferWindowFromReset(resetAt: number | undefined, nowMs: number): AntigravityWindowDescriptor {
+	if (resetAt !== undefined && resetAt - nowMs > ONE_DAY_MS) {
+		return { id: "weekly", label: "Weekly", durationMs: ONE_WEEK_MS };
+	}
+	return { id: "daily", label: "Daily", durationMs: ONE_DAY_MS };
+}
+
+function quotaInferenceKey(info: AntigravityQuotaInfo): string {
+	return [info.modelProvider ?? "", info.apiProvider ?? "", info.tier ?? ""].join("|");
+}
+
+function inferWindowDescriptors(
+	quotaInfos: AntigravityQuotaInfo[],
+	nowMs: number,
+): WeakMap<AntigravityQuotaInfo, AntigravityWindowDescriptor> {
+	const descriptors = new WeakMap<AntigravityQuotaInfo, AntigravityWindowDescriptor>();
+	const groups = new Map<string, { info: AntigravityQuotaInfo; resetAt: number | undefined }[]>();
+
+	for (const info of quotaInfos) {
+		const explicitDescriptor = classifyWindow(info.windowId, info.windowLabel);
+		if (explicitDescriptor) {
+			descriptors.set(info, explicitDescriptor);
+			continue;
+		}
+		const group = groups.get(quotaInferenceKey(info)) ?? [];
+		group.push({ info, resetAt: parseResetTime(info) });
+		groups.set(quotaInferenceKey(info), group);
+	}
+
+	for (const group of groups.values()) {
+		const resetTimes = [...new Set(group.map(entry => entry.resetAt).filter(resetAt => resetAt !== undefined))].sort(
+			(a, b) => a - b,
+		);
+		const latestReset = resetTimes.length > 1 ? resetTimes.at(-1) : undefined;
+		for (const entry of group) {
+			const descriptor =
+				latestReset !== undefined && entry.resetAt === latestReset
+					? { id: "weekly", label: "Weekly", durationMs: ONE_WEEK_MS }
+					: inferWindowFromReset(entry.resetAt, nowMs);
+			descriptors.set(entry.info, descriptor);
+		}
+	}
+
+	return descriptors;
+}
+
 function withWindowDescriptor(
 	info: AntigravityQuotaInfo,
 	descriptor: AntigravityWindowDescriptor | undefined,
@@ -94,10 +145,12 @@ function getUsageStatus(remainingFraction: number | undefined): UsageStatus | un
 	return "ok";
 }
 
-function parseWindow(info: AntigravityQuotaInfo): UsageWindow | undefined {
-	const descriptor = classifyWindow(info.windowId, info.windowLabel);
-	const resetAt = info.resetTime ? Date.parse(info.resetTime) : undefined;
-	const hasResetAt = resetAt !== undefined && Number.isFinite(resetAt);
+function parseWindow(
+	info: AntigravityQuotaInfo,
+	descriptor: AntigravityWindowDescriptor | undefined,
+): UsageWindow | undefined {
+	const resetAt = parseResetTime(info);
+	const hasResetAt = resetAt !== undefined;
 	if (!descriptor && !hasResetAt) return undefined;
 	return {
 		id: descriptor?.id ?? info.windowId ?? "default",
@@ -276,9 +329,10 @@ async function fetchAntigravityUsage(params: UsageFetchParams, ctx: UsageFetchCo
 
 	for (const [_modelId, modelInfo] of Object.entries(data.models ?? {})) {
 		const quotaInfos = normalizeQuotaInfos(modelInfo);
+		const inferredDescriptors = inferWindowDescriptors(quotaInfos, nowMs);
 		for (const quotaInfo of quotaInfos) {
 			const amount = buildAmount(quotaInfo);
-			const window = parseWindow(quotaInfo);
+			const window = parseWindow(quotaInfo, inferredDescriptors.get(quotaInfo));
 			if (window?.resetsAt) {
 				earliestReset = earliestReset ? Math.min(earliestReset, window.resetsAt) : window.resetsAt;
 			}