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

package/CHANGELOG.md

@@ -2,9 +2,30 @@
 
 ## [Unreleased]
 
+## [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
 
-- Default reasoning context to `all_turns` for all Codex requests
+- Enabled automatic removal of leaked reasoning tags for all models
+- Prevented reasoning text duplication when models emit both structured and inline thinking
+- Defaulted reasoning context to all turns for all Codex requests.
+
+### Fixed
+
+- Enabled freeform tool patch support for Azure OpenAI and Codex models.
+- Fixed an issue where the `/usage show` command returned "No usage data available" when using a custom proxy base URL for Codex.
 
 ## [16.2.2] - 2026-06-27
 

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/providers/openai-responses.d.ts

@@ -118,9 +118,9 @@ export declare function buildParams(model: Model<"openai-responses">, context: C
  * runtime path only consumes that metadata.
  * @internal Exported for tests.
  */
-export declare function supportsFreeformApplyPatch(model: Model<"openai-responses">): boolean;
+export declare function supportsFreeformApplyPatch(model: Model<"openai-responses" | "azure-openai-responses" | "openai-codex-responses">): boolean;
 /** @internal Exported for tests. */
 export declare function mapOpenAIResponsesToolChoiceForTools(choice: ToolChoice | undefined, tools: Tool[], model: Model<"openai-responses">): OpenAIResponsesToolChoice;
 /** @internal Exported for tests. */
-export declare function convertTools(tools: Tool[], strictMode: boolean, model: Model<"openai-responses">, onQuarantine?: (toolName: string, schemaPath: string) => void): OpenAITool[];
+export declare function convertTools(tools: Tool[], strictMode: boolean, model: Model<"openai-responses" | "azure-openai-responses" | "openai-codex-responses">, onQuarantine?: (toolName: string, schemaPath: string) => void): OpenAITool[];
 export {};

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/dist/types/usage/openai-codex-base-url.d.ts

@@ -1 +1,18 @@
+/**
+ * Resolve the base URL for ChatGPT account-API requests (`wham/usage`,
+ * `wham/rate-limit-reset-credits`).
+ *
+ * These endpoints live on the canonical ChatGPT origin and authenticate with
+ * the Codex OAuth bearer minted for that origin. They are NOT part of the
+ * `/responses` API surface that streaming proxies (Headroom, 9router, etc.)
+ * forward, so a `providers.openai-codex.baseUrl` override pointed at such a
+ * proxy MUST NOT be used here — doing so 404s and silently breaks
+ * `/usage show` (issue #3679).
+ *
+ * Accepted overrides are the canonical `chatgpt.com` / `chat.openai.com`
+ * origins. Any extra path (e.g. a streaming override like
+ * `/backend-api/codex/responses`) is normalized to `${origin}/backend-api`,
+ * since the account endpoints always live directly under `/backend-api`. Any
+ * other host falls back to {@link CODEX_BASE_URL}.
+ */
 export declare function normalizeCodexBaseUrl(baseUrl?: string): string;

package/dist/types/utils/stream-markup-healing.d.ts

@@ -29,6 +29,12 @@ export type StreamMarkupHealingEvent = {
  * State machine that consumes streamed visible text and emits cleaned text,
  * thinking deltas, and reconstructed tool calls.
  *
+ * A {@link ThinkingInbandScanner} always heals leaked reasoning idioms
+ * (`<think>`, `<thinking>`, ` ```thinking `, Gemma/Harmony channels, …) out of
+ * the visible channel. For Kimi / DeepSeek-DSML the provider tool-call grammar
+ * runs first and its cleaned text is piped through that thinking healer, so a
+ * model can leak tool-call markup and reasoning in the same stream.
+ *
  * Feed only one stream channel (usually `delta.content` / `message.content`).
  * Mixing reasoning and visible text into the same instance can corrupt held-back
  * partial tag buffers.
@@ -71,8 +77,11 @@ export declare class StreamMarkupHealing {
 export declare function modelMayLeakKimiToolCalls(provider: string, modelId: string): boolean;
 /** Cheap model/provider gate for DeepSeek DSML envelope leaks. */
 export declare function modelMayLeakDsmlToolCalls(provider: string, modelId: string): boolean;
-/** Cheap model/provider gate for MiniMax plain thinking tag leaks. */
-export declare function modelMayLeakThinkingTags(provider: string, modelId: string): boolean;
-export declare function getStreamMarkupHealingPattern(provider: string, modelId: string, options?: {
-    readonly parseThinkingTags?: boolean;
-}): StreamMarkupHealingPattern | undefined;
+/**
+ * Pick the leaked-markup healer for an OpenAI-compatible / Ollama visible-text
+ * stream. Kimi chat-template tokens and DeepSeek DSML envelopes need their
+ * dedicated tool-call grammars; every other model uses `"thinking"`. All three
+ * patterns run the generic {@link ThinkingInbandScanner}, so leaked reasoning
+ * idioms (e.g. a Gemini ` ```thinking ` fence on OpenRouter) are always healed.
+ */
+export declare function getStreamMarkupHealingPattern(provider: string, modelId: string): StreamMarkupHealingPattern;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "16.2.2",
+	"version": "16.2.4",
 	"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.2",
-		"@oh-my-pi/pi-utils": "16.2.2",
-		"@oh-my-pi/pi-wire": "16.2.2",
+		"@oh-my-pi/pi-catalog": "16.2.4",
+		"@oh-my-pi/pi-utils": "16.2.4",
+		"@oh-my-pi/pi-wire": "16.2.4",
 		"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/providers/ollama.ts

@@ -465,6 +465,10 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 			? new StreamMarkupHealing({ pattern: streamMarkupHealingPattern })
 			: undefined;
 		let healedToolCallEmitted = false;
+		// Once the provider streams native reasoning (`message.thinking`), drop any
+		// thinking the text-channel healer also recovers so a model that emits both
+		// does not double-count its reasoning.
+		let suppressHealedThinking = false;
 		const endActiveTextBlock = (): void => {
 			if (activeTextIndex === undefined) return;
 			endTextBlock(stream, output, activeTextIndex);
@@ -542,7 +546,7 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 			if (event.type === "text") {
 				appendVisibleText(event.text);
 			} else if (event.type === "thinking") {
-				appendVisibleThinking(event.thinking);
+				if (!suppressHealedThinking) appendVisibleThinking(event.thinking);
 			} else {
 				emitHealedToolCall(event.call);
 			}
@@ -614,6 +618,7 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 			stream.push({ type: "start", partial: output });
 			for await (const chunk of iterateNdjson(response.body)) {
 				if (chunk.message?.thinking) {
+					suppressHealedThinking = true;
 					endActiveTextBlock();
 					if (activeThinkingIndex === undefined) {
 						output.content.push({ type: "thinking", thinking: "" });

package/src/providers/openai-responses.ts

@@ -936,7 +936,9 @@ export function buildParams(
  * runtime path only consumes that metadata.
  * @internal Exported for tests.
  */
-export function supportsFreeformApplyPatch(model: Model<"openai-responses">): boolean {
+export function supportsFreeformApplyPatch(
+	model: Model<"openai-responses" | "azure-openai-responses" | "openai-codex-responses">,
+): boolean {
 	return model.applyPatchToolType === "freeform";
 }
 
@@ -970,7 +972,7 @@ export function mapOpenAIResponsesToolChoiceForTools(
 export function convertTools(
 	tools: Tool[],
 	strictMode: boolean,
-	model: Model<"openai-responses">,
+	model: Model<"openai-responses" | "azure-openai-responses" | "openai-codex-responses">,
 	onQuarantine: (toolName: string, schemaPath: string) => void = (toolName, schemaPath) =>
 		logger.warn(
 			`Tool "${toolName}" omitted from the openai-responses request: its parameter schema is invalid for this provider at ${schemaPath} (an enum/const value cannot match its declared type). Other tools are unaffected.`,

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/openai-codex-base-url.ts

@@ -1,15 +1,35 @@
 import { CODEX_BASE_URL } from "@oh-my-pi/pi-catalog/wire/codex";
 
+/**
+ * Resolve the base URL for ChatGPT account-API requests (`wham/usage`,
+ * `wham/rate-limit-reset-credits`).
+ *
+ * These endpoints live on the canonical ChatGPT origin and authenticate with
+ * the Codex OAuth bearer minted for that origin. They are NOT part of the
+ * `/responses` API surface that streaming proxies (Headroom, 9router, etc.)
+ * forward, so a `providers.openai-codex.baseUrl` override pointed at such a
+ * proxy MUST NOT be used here — doing so 404s and silently breaks
+ * `/usage show` (issue #3679).
+ *
+ * Accepted overrides are the canonical `chatgpt.com` / `chat.openai.com`
+ * origins. Any extra path (e.g. a streaming override like
+ * `/backend-api/codex/responses`) is normalized to `${origin}/backend-api`,
+ * since the account endpoints always live directly under `/backend-api`. Any
+ * other host falls back to {@link CODEX_BASE_URL}.
+ */
 export function normalizeCodexBaseUrl(baseUrl?: string): string {
-	const fallback = CODEX_BASE_URL;
-	const trimmed = baseUrl?.trim() ? baseUrl.trim() : fallback;
-	const base = trimmed.replace(/\/+$/, "");
-	const lower = base.toLowerCase();
-	if (
-		(lower.startsWith("https://chatgpt.com") || lower.startsWith("https://chat.openai.com")) &&
-		!lower.includes("/backend-api")
-	) {
-		return `${base}/backend-api`;
+	const trimmed = baseUrl?.trim().replace(/\/+$/, "");
+	if (!trimmed) return CODEX_BASE_URL;
+	let parsed: URL;
+	try {
+		parsed = new URL(trimmed);
+	} catch {
+		return CODEX_BASE_URL;
 	}
-	return base;
+	const host = parsed.host.toLowerCase();
+	if (host !== "chatgpt.com" && host !== "chat.openai.com") return CODEX_BASE_URL;
+	// wham/usage always lives at `${origin}/backend-api/...` on the canonical
+	// ChatGPT origin, so ignore any extra path (e.g. `/backend-api/codex/responses`
+	// from a streaming baseUrl) — otherwise we'd build `.../codex/responses/wham/usage`.
+	return `${parsed.origin}/backend-api`;
 }

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,

package/src/utils/stream-markup-healing.ts

@@ -38,24 +38,33 @@ export type StreamMarkupHealingEvent =
  * State machine that consumes streamed visible text and emits cleaned text,
  * thinking deltas, and reconstructed tool calls.
  *
+ * A {@link ThinkingInbandScanner} always heals leaked reasoning idioms
+ * (`<think>`, `<thinking>`, ` ```thinking `, Gemma/Harmony channels, …) out of
+ * the visible channel. For Kimi / DeepSeek-DSML the provider tool-call grammar
+ * runs first and its cleaned text is piped through that thinking healer, so a
+ * model can leak tool-call markup and reasoning in the same stream.
+ *
  * Feed only one stream channel (usually `delta.content` / `message.content`).
  * Mixing reasoning and visible text into the same instance can corrupt held-back
  * partial tag buffers.
  */
 export class StreamMarkupHealing {
 	readonly #pattern: StreamMarkupHealingPattern;
-	readonly #scanner: InbandScanner;
+	/** Provider tool-call grammar (Kimi tokens / DSML envelope); absent for plain text streams. */
+	readonly #toolScanner: InbandScanner | undefined;
+	/** Always-on healer for leaked reasoning idioms in the visible text channel. */
+	readonly #thinkingScanner = new ThinkingInbandScanner();
 	#sectionTerminated = false;
 	readonly #completed: HealedToolCall[] = [];
 
 	constructor(options: StreamMarkupHealingOptions) {
 		this.#pattern = options.pattern;
-		this.#scanner =
+		this.#toolScanner =
 			options.pattern === "kimi"
 				? createInbandScanner("kimi")
 				: options.pattern === "dsml"
 					? createInbandScanner("xml", { xmlTagset: "dsml" })
-					: new ThinkingInbandScanner();
+					: undefined;
 	}
 
 	get pattern(): StreamMarkupHealingPattern {
@@ -84,7 +93,8 @@ export class StreamMarkupHealing {
 	feedEvents(text: string): StreamMarkupHealingEvent[] {
 		if (text.length === 0) return [];
 		this.#markSectionClosed(text);
-		return this.#convertScannerEvents(this.#scanner.feed(text));
+		if (!this.#toolScanner) return this.#convertScannerEvents(this.#thinkingScanner.feed(text));
+		return this.#convertScannerEvents(this.#healThinking(this.#toolScanner.feed(text)));
 	}
 
 	/**
@@ -120,7 +130,9 @@ export class StreamMarkupHealing {
 	 * behavior.
 	 */
 	flushEvents(): StreamMarkupHealingEvent[] {
-		return this.#convertScannerEvents(this.#scanner.flush());
+		const tail = this.#toolScanner ? this.#healThinking(this.#toolScanner.flush()) : [];
+		tail.push(...this.#thinkingScanner.flush());
+		return this.#convertScannerEvents(tail);
 	}
 
 	/** Flush held-back text only. Reconstructed calls are retained for {@link drainCompleted}. */
@@ -142,7 +154,7 @@ export class StreamMarkupHealing {
 	}
 
 	#markSectionClosed(text: string): void {
-		if (this.#sectionTerminated) return;
+		if (this.#sectionTerminated || !this.#toolScanner) return;
 		if (this.#pattern === "kimi") {
 			this.#sectionTerminated = text.includes(KIMI_SECTION_END);
 			return;
@@ -151,6 +163,20 @@ export class StreamMarkupHealing {
 			text.includes(DSML_TOOL_CALLS_CLOSE_FULLWIDTH) || text.includes(DSML_TOOL_CALLS_CLOSE_ASCII);
 	}
 
+	/**
+	 * Re-scan the tool scanner's visible text through the always-on thinking
+	 * healer: `text` events are healed for leaked reasoning idioms, while the tool
+	 * scanner's own thinking / tool-call events pass through in stream order.
+	 */
+	#healThinking(toolEvents: readonly InbandScanEvent[]): InbandScanEvent[] {
+		const out: InbandScanEvent[] = [];
+		for (const event of toolEvents) {
+			if (event.type === "text") out.push(...this.#thinkingScanner.feed(event.text));
+			else out.push(event);
+		}
+		return out;
+	}
+
 	#convertScannerEvents(events: readonly InbandScanEvent[]): StreamMarkupHealingEvent[] {
 		const out: StreamMarkupHealingEvent[] = [];
 		for (const event of events) {
@@ -207,18 +233,15 @@ export function modelMayLeakDsmlToolCalls(provider: string, modelId: string): bo
 	);
 }
 
-/** Cheap model/provider gate for MiniMax plain thinking tag leaks. */
-export function modelMayLeakThinkingTags(provider: string, modelId: string): boolean {
-	return /minimax/i.test(provider) || /minimax/i.test(modelId);
-}
-
-export function getStreamMarkupHealingPattern(
-	provider: string,
-	modelId: string,
-	options?: { readonly parseThinkingTags?: boolean },
-): StreamMarkupHealingPattern | undefined {
-	if (options?.parseThinkingTags || modelMayLeakThinkingTags(provider, modelId)) return "thinking";
+/**
+ * Pick the leaked-markup healer for an OpenAI-compatible / Ollama visible-text
+ * stream. Kimi chat-template tokens and DeepSeek DSML envelopes need their
+ * dedicated tool-call grammars; every other model uses `"thinking"`. All three
+ * patterns run the generic {@link ThinkingInbandScanner}, so leaked reasoning
+ * idioms (e.g. a Gemini ` ```thinking ` fence on OpenRouter) are always healed.
+ */
+export function getStreamMarkupHealingPattern(provider: string, modelId: string): StreamMarkupHealingPattern {
 	if (modelMayLeakKimiToolCalls(provider, modelId)) return "kimi";
 	if (modelMayLeakDsmlToolCalls(provider, modelId)) return "dsml";
-	return undefined;
+	return "thinking";
 }