@oh-my-pi/pi-ai 16.2.3 → 16.2.5

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## [Unreleased]
 
+## [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
+
+- Enabled freeform tool patch support for Azure OpenAI and Codex models
+
+### Fixed
+
+- Fixed usage reporting for Antigravity and Z.AI to correctly surface and preserve distinct quota windows (daily, weekly, monthly) instead of collapsing or duplicating them
+- Fixed an issue where `/usage show` returned "No usage data available" when using a custom proxy base URL for Codex
+- Fixed OpenAI stream read errors being incorrectly classified as non-transient, enabling the coding agent to automatically retry after recoverable stream failures
+
 ## [16.2.3] - 2026-06-28
 
 ### Changed

package/dist/types/error/flags.d.ts

@@ -21,6 +21,7 @@ export declare const Flag: {
     readonly OAuthExpiry: 1073741824;
 };
 export type Flag = (typeof Flag)[keyof typeof Flag];
+export declare const STREAM_READ_ERROR_PATTERN: RegExp;
 export declare const TRANSIENT_TRANSPORT_PATTERN: RegExp;
 /** Whether an OAuth refresh error message means the grant is definitively dead. */
 export declare function isOAuthExpiry(errorMessage: string): boolean;
@@ -30,6 +31,7 @@ export declare function retriable(id: number | undefined, opts?: {
     replayUnsafe?: boolean;
 }): boolean;
 export declare function status(error: unknown): number | undefined;
+export declare function isStreamReadErrorText(text: string): boolean;
 export declare function classify(error: unknown, api?: Api): number;
 /**
  * Whether an error (or message string) classifies as an account usage/quota

package/dist/types/usage/google-antigravity.d.ts

@@ -1,16 +1,15 @@
 import type { CredentialRankingStrategy, UsageProvider } from "../usage";
 export declare const antigravityUsageProvider: UsageProvider;
 /**
- * Antigravity quotas reset daily and are returned per backend counter
- * (Anthropic / Google / OpenAI) without a fixed "primary vs secondary"
- * split. `fetchAntigravityUsage` already sorts `limits` ascending by
- * `remainingFraction`; after model-family scoping, the most-pressured
- * relevant counter is index 0.
+ * Antigravity quotas are returned per backend counter (Anthropic / Google /
+ * OpenAI) and can include both daily and weekly windows. `fetchAntigravityUsage`
+ * sorts `limits` ascending by `remainingFraction`; after model-family scoping,
+ * the most-pressured relevant counter/window is index 0.
  *
  * Leave `secondary` unset: AuthStorage compares secondary metrics before
- * primary metrics, which is correct for providers with explicit long-window
- * limits but wrong here. Ranking Antigravity by the bottleneck counter first
- * avoids preferring an account at 95% Gemini / 0% Claude over one at
- * 80% Gemini / 70% Claude.
+ * primary metrics, which is correct for providers with a fixed short/long
+ * split but wrong here. Ranking Antigravity by the bottleneck counter first
+ * avoids preferring an account at 95% Gemini daily / 0% Claude weekly over one
+ * with healthier Gemini headroom.
  */
 export declare const antigravityRankingStrategy: CredentialRankingStrategy;

package/package.json

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

package/src/auth-storage.ts

@@ -537,6 +537,7 @@ const USAGE_FAILURE_BACKOFF_MS = 10_000;
 const DEFAULT_USAGE_REQUEST_TIMEOUT_MS = 10_000;
 const USAGE_REPORT_CACHE_KEY_VERSION_OVERRIDES: Partial<Record<Provider, number>> = {
 	"google-antigravity": 2,
+	zai: 2,
 };
 const DEFAULT_OAUTH_REFRESH_TIMEOUT_MS = 10_000;
 /**

package/src/error/flags.ts

@@ -85,6 +85,7 @@ const OVERFLOW_NO_BODY_PATTERN = /\b4(00|13)\s*(status code)?\s*\(no body\)/i;
 const TIMEOUT_PATTERN = /\b(?:operation\s+)?timed?\s*out\b|\btimeout\b|\bstream stall\b/i;
 const TRANSIENT_ENVELOPE_PATTERN = /anthropic stream envelope error:/i;
 const TRANSIENT_ENVELOPE_BEFORE_START_PATTERN = /before message_start/i;
+export const STREAM_READ_ERROR_PATTERN = /stream[_ -]?read[_ -]?error/i;
 export const TRANSIENT_TRANSPORT_PATTERN =
 	/overloaded|provider.?returned.?error|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server.?error|internal.?error|retry your request|network.?error|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|upstream.?request.?failed|reset before headers|socket hang up|timed? out|timeout|terminated|retry delay|stream stall|no error details in response|HTTP2(?:StreamReset|RefusedStream|EnhanceYourCalm)|malformed.?function.?call/i;
 const AUTH_FAILURE_PATTERN =
@@ -240,9 +241,14 @@ function statusInternal(error: unknown, depth: number): number | undefined {
 	return undefined;
 }
 
+export function isStreamReadErrorText(text: string): boolean {
+	return STREAM_READ_ERROR_PATTERN.test(text);
+}
+
 function isTransientErrorText(text: string): boolean {
 	return (
 		isUnexpectedSocketCloseMessage(text) ||
+		isStreamReadErrorText(text) ||
 		(TRANSIENT_ENVELOPE_PATTERN.test(text) && TRANSIENT_ENVELOPE_BEFORE_START_PATTERN.test(text)) ||
 		TRANSIENT_TRANSPORT_PATTERN.test(text)
 	);

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/usage/google-antigravity.ts

@@ -29,7 +29,13 @@ interface AntigravityModelInfo {
 	displayName?: string;
 	quotaInfo?: AntigravityQuotaInfo | AntigravityQuotaInfo[];
 	quotaInfos?: AntigravityQuotaInfo[];
+	dailyQuotaInfo?: AntigravityQuotaInfo | AntigravityQuotaInfo[];
+	dailyQuotaInfos?: AntigravityQuotaInfo[];
+	weeklyQuotaInfo?: AntigravityQuotaInfo | AntigravityQuotaInfo[];
+	weeklyQuotaInfos?: AntigravityQuotaInfo[];
 	quotaInfoByTier?: Record<string, AntigravityQuotaInfo | AntigravityQuotaInfo[]>;
+	quotaInfoByWindow?: Record<string, AntigravityQuotaInfo | AntigravityQuotaInfo[]>;
+	quotaInfosByWindow?: Record<string, AntigravityQuotaInfo | AntigravityQuotaInfo[]>;
 	apiProvider?: string;
 	modelProvider?: string;
 }
@@ -41,6 +47,39 @@ interface AntigravityUsageResponse {
 const DEFAULT_ENDPOINT = "https://daily-cloudcode-pa.googleapis.com";
 const FETCH_AVAILABLE_MODELS_PATH = "/v1internal:fetchAvailableModels";
 
+const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+const ONE_WEEK_MS = 7 * ONE_DAY_MS;
+
+interface AntigravityWindowDescriptor {
+	id: string;
+	label: string;
+	durationMs?: number;
+}
+
+function classifyWindow(id: string | undefined, label: string | undefined): AntigravityWindowDescriptor | undefined {
+	const source = `${id ?? ""} ${label ?? ""}`.toLowerCase();
+	if (source.includes("week") || source.includes("7d") || /7[\s_-]*day/.test(source)) {
+		return { id: "weekly", label: "Weekly", durationMs: ONE_WEEK_MS };
+	}
+	if (source.includes("day") || source.includes("daily") || source.includes("24h")) {
+		return { id: "daily", label: "Daily", durationMs: ONE_DAY_MS };
+	}
+	if (id || label) return { id: id ?? label ?? "default", label: label ?? id ?? "Default" };
+	return undefined;
+}
+
+function withWindowDescriptor(
+	info: AntigravityQuotaInfo,
+	descriptor: AntigravityWindowDescriptor | undefined,
+): AntigravityQuotaInfo {
+	if (!descriptor) return info;
+	return {
+		...info,
+		windowId: info.windowId ?? descriptor.id,
+		windowLabel: info.windowLabel ?? descriptor.label,
+	};
+}
+
 function clampFraction(value: number | undefined): number | undefined {
 	if (value === undefined || !Number.isFinite(value)) return undefined;
 	if (value < 0) return 0;
@@ -56,13 +95,15 @@ function getUsageStatus(remainingFraction: number | undefined): UsageStatus | un
 }
 
 function parseWindow(info: AntigravityQuotaInfo): UsageWindow | undefined {
-	if (!info.resetTime) return undefined;
-	const resetAt = Date.parse(info.resetTime);
-	if (!Number.isFinite(resetAt)) return undefined;
+	const descriptor = classifyWindow(info.windowId, info.windowLabel);
+	const resetAt = info.resetTime ? Date.parse(info.resetTime) : undefined;
+	const hasResetAt = resetAt !== undefined && Number.isFinite(resetAt);
+	if (!descriptor && !hasResetAt) return undefined;
 	return {
-		id: info.windowId ?? "default",
-		label: info.windowLabel ?? "Default",
-		resetsAt: resetAt,
+		id: descriptor?.id ?? info.windowId ?? "default",
+		label: info.windowLabel ?? descriptor?.label ?? "Default",
+		...(descriptor?.durationMs !== undefined ? { durationMs: descriptor.durationMs } : {}),
+		...(hasResetAt ? { resetsAt: resetAt } : {}),
 	};
 }
 
@@ -106,31 +147,44 @@ function normalizeQuotaInfos(info: AntigravityModelInfo): AntigravityQuotaInfo[]
 		...(info.apiProvider ? { apiProvider: info.apiProvider } : {}),
 		...(info.modelProvider ? { modelProvider: info.modelProvider } : {}),
 	};
-	const addInfo = (value: AntigravityQuotaInfo, tier?: string) => {
-		results.push({ ...source, ...value, ...(tier ? { tier } : {}) });
+	const addInfo = (value: AntigravityQuotaInfo, tier?: string, windowDescriptor?: AntigravityWindowDescriptor) => {
+		results.push({ ...source, ...withWindowDescriptor(value, windowDescriptor), ...(tier ? { tier } : {}) });
 	};
-	const addArray = (values?: AntigravityQuotaInfo[]) => {
-		if (!values) return;
-		for (const value of values) addInfo(value);
+	const addValue = (
+		value: AntigravityQuotaInfo | AntigravityQuotaInfo[] | undefined,
+		tier?: string,
+		windowDescriptor?: AntigravityWindowDescriptor,
+	) => {
+		if (!value) return;
+		if (Array.isArray(value)) {
+			for (const entry of value) addInfo(entry, tier, windowDescriptor);
+			return;
+		}
+		addInfo(value, tier, windowDescriptor);
 	};
 
-	if (Array.isArray(info.quotaInfo)) {
-		addArray(info.quotaInfo);
-	} else if (info.quotaInfo) {
-		addInfo(info.quotaInfo);
-	}
-	addArray(info.quotaInfos);
+	addValue(info.quotaInfo);
+	addValue(info.quotaInfos);
+	addValue(info.dailyQuotaInfo, undefined, classifyWindow("daily", "Daily"));
+	addValue(info.dailyQuotaInfos, undefined, classifyWindow("daily", "Daily"));
+	addValue(info.weeklyQuotaInfo, undefined, classifyWindow("weekly", "Weekly"));
+	addValue(info.weeklyQuotaInfos, undefined, classifyWindow("weekly", "Weekly"));
 
 	if (info.quotaInfoByTier) {
 		for (const [tier, value] of Object.entries(info.quotaInfoByTier)) {
-			if (Array.isArray(value)) {
-				for (const entry of value) addInfo(entry, tier);
-			} else if (value) {
-				addInfo(value, tier);
-			}
+			addValue(value, tier);
 		}
 	}
 
+	const addWindowMap = (values?: Record<string, AntigravityQuotaInfo | AntigravityQuotaInfo[]>) => {
+		if (!values) return;
+		for (const [windowId, value] of Object.entries(values)) {
+			addValue(value, undefined, classifyWindow(windowId, undefined));
+		}
+	};
+	addWindowMap(info.quotaInfoByWindow);
+	addWindowMap(info.quotaInfosByWindow);
+
 	return results;
 }
 
@@ -231,9 +285,10 @@ async function fetchAntigravityUsage(params: UsageFetchParams, ctx: UsageFetchCo
 			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";
+			// Use the parsed window id when available so provider enum names like
+			// WINDOW_WEEKLY normalize into the same visible `/usage` group as
+			// weeklyQuotaInfo entries.
+			const windowId = window?.id ?? quotaInfo.windowId ?? "default";
 			const key = `${counterKey}|${tierKey}|${windowId}`;
 			const existing = deduped.get(key);
 			if (!existing) {
@@ -324,8 +379,6 @@ export const antigravityUsageProvider: UsageProvider = {
 	supports: params => params.provider === "google-antigravity",
 };
 
-const ONE_DAY_MS = 24 * 60 * 60 * 1000;
-
 function getAntigravityCounterKeyForModel(context: CredentialRankingContext | undefined): string | undefined {
 	const modelId = context?.modelId?.toLowerCase();
 	if (!modelId) return undefined;
@@ -361,17 +414,16 @@ function rankAntigravityLimits(report: UsageReport, context: CredentialRankingCo
 }
 
 /**
- * Antigravity quotas reset daily and are returned per backend counter
- * (Anthropic / Google / OpenAI) without a fixed "primary vs secondary"
- * split. `fetchAntigravityUsage` already sorts `limits` ascending by
- * `remainingFraction`; after model-family scoping, the most-pressured
- * relevant counter is index 0.
+ * Antigravity quotas are returned per backend counter (Anthropic / Google /
+ * OpenAI) and can include both daily and weekly windows. `fetchAntigravityUsage`
+ * sorts `limits` ascending by `remainingFraction`; after model-family scoping,
+ * the most-pressured relevant counter/window is index 0.
  *
  * Leave `secondary` unset: AuthStorage compares secondary metrics before
- * primary metrics, which is correct for providers with explicit long-window
- * limits but wrong here. Ranking Antigravity by the bottleneck counter first
- * avoids preferring an account at 95% Gemini / 0% Claude over one at
- * 80% Gemini / 70% Claude.
+ * primary metrics, which is correct for providers with a fixed short/long
+ * split but wrong here. Ranking Antigravity by the bottleneck counter first
+ * avoids preferring an account at 95% Gemini daily / 0% Claude weekly over one
+ * with healthier Gemini headroom.
  */
 export const antigravityRankingStrategy: CredentialRankingStrategy = {
 	findWindowLimits(report, context) {
@@ -384,8 +436,8 @@ export const antigravityRankingStrategy: CredentialRankingStrategy = {
 		const counterKey = getAntigravityCounterKeyForModel(context);
 		return `counter:${counterKey ?? "unknown"}`;
 	},
-	// Antigravity windows omit `durationMs`; the endpoint is
-	// `daily-cloudcode-pa.googleapis.com`, so fall back to 24h when computing
-	// drain rate.
+	// Antigravity windows carry `durationMs` when the response identifies them
+	// as daily/weekly. Fall back to daily for legacy unlabelled quotaInfo
+	// entries from `daily-cloudcode-pa.googleapis.com`.
 	windowDefaults: { primaryMs: ONE_DAY_MS, secondaryMs: ONE_DAY_MS },
 };

package/src/usage/zai.ts

@@ -15,6 +15,15 @@ const DEFAULT_ENDPOINT = "https://api.z.ai";
 const QUOTA_PATH = "/api/monitor/usage/quota/limit";
 const MODEL_USAGE_PATH = "/api/monitor/usage/model-usage";
 const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
+const HOUR_MS = 60 * 60 * 1000;
+const DAY_MS = 24 * HOUR_MS;
+const WEEK_MS = 7 * DAY_MS;
+const MONTH_MS = 30 * DAY_MS;
+
+interface ZaiUsageDetail {
+	modelCode?: string;
+	usage?: number;
+}
 
 function normalizeZaiBaseUrl(baseUrl?: string): string {
 	if (!baseUrl?.trim()) return DEFAULT_ENDPOINT;
@@ -32,6 +41,9 @@ interface ZaiUsageLimitItem {
 	percentage?: number;
 	remaining?: number;
 	nextResetTime?: number;
+	unit?: number;
+	number?: number;
+	usageDetails?: ZaiUsageDetail[];
 }
 
 interface ZaiQuotaPayload {
@@ -49,6 +61,21 @@ function parseMillis(value: unknown): number | undefined {
 	return parsed > 1_000_000_000_000 ? parsed : parsed * 1000;
 }
 
+function parseUsageDetails(value: unknown): ZaiUsageDetail[] | undefined {
+	if (!Array.isArray(value)) return undefined;
+	const details: ZaiUsageDetail[] = [];
+	for (const item of value) {
+		if (!isRecord(item)) continue;
+		const modelCode = typeof item.modelCode === "string" && item.modelCode ? item.modelCode : undefined;
+		const usage = toNumber(item.usage);
+		details.push({
+			...(modelCode !== undefined ? { modelCode } : {}),
+			...(usage !== undefined ? { usage } : {}),
+		});
+	}
+	return details.length > 0 ? details : undefined;
+}
+
 function parseLimitItem(value: unknown): ZaiUsageLimitItem | null {
 	if (!isRecord(value)) return null;
 	const type = typeof value.type === "string" ? value.type : undefined;
@@ -60,6 +87,9 @@ function parseLimitItem(value: unknown): ZaiUsageLimitItem | null {
 		percentage: toNumber(value.percentage),
 		remaining: toNumber(value.remaining),
 		nextResetTime: parseMillis(value.nextResetTime),
+		unit: toNumber(value.unit),
+		number: toNumber(value.number),
+		usageDetails: parseUsageDetails(value.usageDetails),
 	};
 }
 
@@ -101,6 +131,59 @@ function formatDate(value: Date): string {
 	)}:${pad(value.getSeconds())}`;
 }
 
+function formatCountedUnit(count: number, singular: string): string {
+	const suffix = count === 1 ? "" : "s";
+	return `${count} ${singular}${suffix}`;
+}
+
+function buildZaiWindow(parsed: ZaiUsageLimitItem): UsageWindow {
+	const count = parsed.number !== undefined && parsed.number > 0 ? parsed.number : 1;
+	let id: string;
+	let label: string;
+	let durationMs: number | undefined;
+	switch (parsed.unit) {
+		case 3:
+			id = `${count}h`;
+			label = formatCountedUnit(count, "Hour");
+			durationMs = count * HOUR_MS;
+			break;
+		case 4:
+			id = `${count}d`;
+			label = formatCountedUnit(count, "Day");
+			durationMs = count * DAY_MS;
+			break;
+		case 5:
+			id = `${count}mo`;
+			label = count === 1 ? "Monthly" : formatCountedUnit(count, "Month");
+			durationMs = count * MONTH_MS;
+			break;
+		case 6:
+			id = "1w";
+			label = "Weekly";
+			durationMs = WEEK_MS;
+			break;
+		default:
+			id = parsed.unit !== undefined ? `${count}u${parsed.unit}` : "quota";
+			label = "Quota";
+			break;
+	}
+	return {
+		id,
+		label,
+		...(durationMs !== undefined ? { durationMs } : {}),
+		...(parsed.nextResetTime !== undefined ? { resetsAt: parsed.nextResetTime } : {}),
+	};
+}
+
+function requestQuotaLabel(parsed: ZaiUsageLimitItem): string {
+	const detailCodes =
+		parsed.usageDetails?.map(detail => detail.modelCode).filter((code): code is string => !!code) ?? [];
+	if (detailCodes.includes("search-prime") && detailCodes.includes("web-reader") && detailCodes.includes("zread")) {
+		return "ZAI Web Search / Reader / Zread Quota";
+	}
+	return "ZAI Request Quota";
+}
+
 function buildModelUsageUrl(baseUrl: string, now: Date): string {
 	const start = new Date(now.getTime() - SEVEN_DAYS_MS);
 	const startTime = formatDate(start);
@@ -157,18 +240,13 @@ async function fetchZaiUsage(params: UsageFetchParams, ctx: UsageFetchContext):
 				percentage: parsed.percentage,
 				unit: "tokens",
 			});
-			const window: UsageWindow = {
-				id: "quota",
-				label: "Quota",
-				durationMs: SEVEN_DAYS_MS,
-				resetsAt: parsed.nextResetTime,
-			};
+			const window = buildZaiWindow(parsed);
 			limits.push({
-				id: "zai:tokens",
-				label: "ZAI Token Quota",
+				id: `zai:tokens:${window.id}`,
+				label: `ZAI ${window.label} Token Quota`,
 				scope: {
 					provider: params.provider,
-					windowId: window?.id ?? "quota",
+					windowId: window.id,
 					shared: true,
 				},
 				window,
@@ -177,12 +255,7 @@ async function fetchZaiUsage(params: UsageFetchParams, ctx: UsageFetchContext):
 			});
 		}
 		if (parsed.type === "TIME_LIMIT") {
-			const window: UsageWindow = {
-				id: "quota",
-				label: "Quota",
-				durationMs: SEVEN_DAYS_MS,
-				resetsAt: parsed.nextResetTime,
-			};
+			const window = buildZaiWindow(parsed);
 			const amount = buildUsageAmount({
 				used: parsed.currentValue,
 				limit: parsed.usage,
@@ -191,11 +264,11 @@ async function fetchZaiUsage(params: UsageFetchParams, ctx: UsageFetchContext):
 				unit: "requests",
 			});
 			limits.push({
-				id: "zai:requests",
-				label: "ZAI Request Quota",
+				id: `zai:requests:${window.id}`,
+				label: requestQuotaLabel(parsed),
 				scope: {
 					provider: params.provider,
-					windowId: "quota",
+					windowId: window.id,
 					shared: true,
 				},
 				window,