@oh-my-pi/pi-ai 18.1.18 → 18.1.20

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## [Unreleased]
 
+## [18.1.20] - 2026-09-13
+
+### Fixed
+
+- Fixed Windows OAuth sign-in failing on every attempt after an upgrade when a previous run left a stale native callback registration behind; handlers registered by older binaries are now recognized as owned and rolled back instead of blocking recovery ([#11967](https://github.com/can1357/oh-my-pi/pull/11967) by [@H4vC](https://github.com/H4vC)).
+
+## [18.1.19] - 2026-09-12
+
+### Added
+
+- Charm Hyper accounts now report their remaining prepaid credit balance in `/usage` ([#11656](https://github.com/can1357/oh-my-pi/pull/11656) by [@oldschoola](https://github.com/oldschoola)).
+
+### Fixed
+
+- Fixed Kimi Code's 7-day rate-limiting window being mislabeled as "Total quota" in `omp usage`, causing accounts whose monthly subscription pool is exhausted to appear 100% free while chat completions fail; parsed `totalQuota` add-on packs into the true "Total quota" row when present, and recognized Kimi's HTTP 403 `access_terminated_error` as a credential-rotatable usage limit. ([#11827](https://github.com/can1357/oh-my-pi/pull/11827) by [@revofusion](https://github.com/revofusion))
+- Fixed provider streams that die after emitting `toolcall_start` but before any argument content failing validation with empty `{}` arguments; the uncommitted attempt is now discarded and retried ([#11823](https://github.com/can1357/oh-my-pi/pull/11823) by [@justdoGIT](https://github.com/justdoGIT)).
+- Fixed Windows `zcode://` (Z.AI coding-plan) OAuth sign-in never completing after a successful browser authorization: the native callback handler is now registered with a path the Windows shell can launch, so the `zcode://zai-auth/callback` redirect reaches omp instead of being silently dropped by the browser ([#11907](https://github.com/can1357/oh-my-pi/pull/11907) by [@oldschoola](https://github.com/oldschoola)).
+- Codex OAuth login now accepts valid account tokens that expose an email but omit `chatgpt_account_id`, without fabricating a workspace header ([#11847](https://github.com/can1357/oh-my-pi/pull/11847) by [@nguyennguyenit](https://github.com/nguyennguyenit)).
+- Fixed Muse Code login failing when Meta returns no assigned subscription tier (`subs_tier_id`/`subs_tier_name` as null); sign-in now succeeds and usage is reported without a tier ([#11843](https://github.com/can1357/oh-my-pi/pull/11843) by [@John-Cusack](https://github.com/John-Cusack)).
+
 ## [18.1.18] - 2026-09-11
 
 ### Added
@@ -35,7 +55,9 @@
 
 ### Fixed
 
+- Anthropic `credits_required` responses now rotate to another account instead of retrying the same one: the entitlement wall is a quota outcome, so a session no longer repeats the request against an account that cannot serve the model ([#11333](https://github.com/can1357/oh-my-pi/pull/11333) by [@AshishKumar4](https://github.com/AshishKumar4)).
 - Codex SSE streams that end without a terminal completion event now retry when replay-safe and remain transient errors when partial output prevents replay ([#11349](https://github.com/can1357/oh-my-pi/issues/11349)).
+- Anthropic subscription usage now falls back to the canonical `api.anthropic.com` OAuth usage endpoint when a custom provider `baseUrl` does not serve it, instead of leaving the report to rate-limit headers — those carry the model-scoped weekly window only on responses for that model family, so `/usage` could report a scoped window far below its real utilization.
 
 ## [18.1.15] - 2026-09-08
 

package/dist/types/registry/oauth/muse-code.d.ts

@@ -6,8 +6,8 @@ declare const museCodeKeyResponseSchema: import("@oh-my-pi/omptype").FluentType<
     is_subs_active?: boolean | undefined;
     require_payment?: boolean | undefined;
     require_payment_action_url?: string | undefined;
-    subs_tier_id?: string | undefined;
-    subs_tier_name?: string | undefined;
+    subs_tier_id?: string | null | undefined;
+    subs_tier_name?: string | null | undefined;
     subs_usage?: {
         weekly?: {
             resets_at?: string | number | undefined;
@@ -28,8 +28,8 @@ declare const museCodeKeyResponseSchema: import("@oh-my-pi/omptype").FluentType<
     is_subs_active?: boolean | undefined;
     require_payment?: boolean | undefined;
     require_payment_action_url?: string | undefined;
-    subs_tier_id?: string | undefined;
-    subs_tier_name?: string | undefined;
+    subs_tier_id?: string | null | undefined;
+    subs_tier_name?: string | null | undefined;
     subs_usage?: {
         weekly?: {
             resets_at?: string | number | undefined;

package/dist/types/usage/charm-hyper.d.ts

@@ -0,0 +1,2 @@
+import type { UsageProvider } from "../usage.js";
+export declare const charmHyperUsageProvider: UsageProvider;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-ai",
-	"version": "18.1.18",
+	"version": "18.1.20",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"keywords": [
 		"ai",
@@ -124,11 +124,11 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.1.18",
-		"@oh-my-pi/pi-catalog": "18.1.18",
-		"@oh-my-pi/pi-natives": "18.1.18",
-		"@oh-my-pi/pi-utils": "18.1.18",
-		"@oh-my-pi/pi-wire": "18.1.18"
+		"@oh-my-pi/omptype": "18.1.20",
+		"@oh-my-pi/pi-catalog": "18.1.20",
+		"@oh-my-pi/pi-natives": "18.1.20",
+		"@oh-my-pi/pi-utils": "18.1.20",
+		"@oh-my-pi/pi-wire": "18.1.20"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/auth-storage.ts

@@ -51,6 +51,7 @@ import type {
 } from "./usage";
 import { resolveUsedFraction } from "./usage";
 import { alibabaTokenPlanRankingStrategy, alibabaTokenPlanUsageProvider } from "./usage/alibaba-token-plan";
+import { charmHyperUsageProvider } from "./usage/charm-hyper";
 import { claudeRankingStrategy, claudeUsageProvider } from "./usage/claude";
 import { clinePassUsageProvider } from "./usage/cline-pass";
 import { cursorUsageProvider } from "./usage/cursor";
@@ -677,6 +678,7 @@ const DEFAULT_USAGE_PROVIDERS: UsageProvider[] = [
 	syntheticUsageProvider,
 	xaiOauthUsageProvider,
 	devinUsageProvider,
+	charmHyperUsageProvider,
 ];
 
 const DEFAULT_USAGE_PROVIDER_MAP = new Map<Provider, UsageProvider>(

package/src/error/rate-limit.ts

@@ -30,6 +30,13 @@ const INSUFFICIENT_BALANCE_PATTERN = /insufficient.?balance/i;
 // "credits exhausted". Account-local, so rotate to a sibling credential.
 const CREDITS_EXHAUSTED_PATTERN =
 	/\b(?:exceed\w*|insufficient|not enough)\b[^\n]{0,40}\bcredits?\b|\bcredits?\b[^\n]{0,40}\b(?:exhausted|depleted)\b/i;
+// Anthropic subscription entitlement wall: "Usage credits are required for this
+// model" with `error_code: credits_required`. The account cannot serve the model
+// at all, so rotate to a sibling rather than backing off on this one. Bounded to
+// the documented sentence and the exact code: bare "usage credits" also appears
+// in unrelated diagnostics ("Failed to fetch usage credits from billing
+// service"), which must not rotate a healthy credential.
+const ANTHROPIC_CREDITS_REQUIRED_PATTERN = /\busage credits are required\b|\bcredits_required\b/i;
 const SPEND_LIMIT_PATTERN = /spend.?limit/i;
 const SUBSCRIPTION_CAP_PATTERN =
 	/\b(?:subscription|plan|membership)\b[^\n]{0,80}\b(?:rate.?limits?|quota|cap)\b|\b(?:rate.?limits?|quota|cap)\b[^\n]{0,80}\b(?:subscription|plan|membership)\b/i;
@@ -234,6 +241,10 @@ export function parseRateLimitReason(errorMessage: string): RateLimitReason {
 		return "QUOTA_EXHAUSTED";
 	}
 
+	if (ANTHROPIC_CREDITS_REQUIRED_PATTERN.test(errorMessage)) {
+		return "QUOTA_EXHAUSTED";
+	}
+
 	if (
 		lower.includes("per minute") ||
 		lower.includes("rate limit") ||
@@ -253,6 +264,7 @@ export function parseRateLimitReason(errorMessage: string): RateLimitReason {
 		lower.includes("out of credits") ||
 		lower.includes("spending-limit") ||
 		lower.includes("spending limit") ||
+		lower.includes("access_terminated_error") ||
 		INSUFFICIENT_BALANCE_PATTERN.test(errorMessage) ||
 		CREDITS_EXHAUSTED_PATTERN.test(errorMessage)
 	) {
@@ -294,7 +306,7 @@ export function calculateRateLimitBackoffMs(reason: RateLimitReason): number {
 
 /** Detect usage/quota limit errors in error messages (persistent, requires credential switch). */
 const USAGE_LIMIT_PATTERN =
-	/usage.?limit|usage_limit_reached|usage_not_included|limit_reached|quota.?(?:exceeded|reached|insufficient)|额度不足|额度耗尽|resource.?exhausted|exhausted your capacity|quota will reset|insufficient.?(?:balance|quota)|balance.?exhausted|run out of credits|out of credits|spending[- _]?limit|personal-team-blocked|clinepass limit|free limit reached on model/i;
+	/usage.?limit|usage_limit_reached|usage_not_included|limit_reached|quota.?(?:exceeded|reached|insufficient)|额度不足|额度耗尽|resource.?exhausted|exhausted your capacity|quota will reset|insufficient.?(?:balance|quota)|balance.?exhausted|run out of credits|out of credits|spending[- _]?limit|personal-team-blocked|clinepass limit|free limit reached on model|access_terminated_error/i;
 
 /**
  * HTTP status codes that, absent richer body classification, represent an
@@ -397,6 +409,7 @@ export function matchesUsageLimitText(errorMessage: string): boolean {
 	if (isDashScopeTokenLimitText(errorMessage)) return false;
 	return (
 		USAGE_LIMIT_PATTERN.test(errorMessage) ||
+		ANTHROPIC_CREDITS_REQUIRED_PATTERN.test(errorMessage) ||
 		CREDITS_EXHAUSTED_PATTERN.test(errorMessage) ||
 		(CN_QUOTA_EXHAUSTED_PATTERN.test(errorMessage) && !CN_TRANSIENT_CAP_PATTERN.test(errorMessage)) ||
 		SPEND_LIMIT_PATTERN.test(errorMessage) ||

package/src/registry/oauth/muse-code.ts

@@ -28,8 +28,8 @@ const museCodeKeyResponseSchema = type({
 	"user_email?": "string",
 	"user_id?": "string",
 	"is_subs_active?": "boolean",
-	"subs_tier_id?": "string",
-	"subs_tier_name?": "string",
+	"subs_tier_id?": "string | null",
+	"subs_tier_name?": "string | null",
 	"subs_usage?": subscriptionUsageSchema.or("null"),
 });
 export type MuseCodeKeyResponse = typeof museCodeKeyResponseSchema.infer;

package/src/registry/oauth/openai-codex.ts

@@ -90,8 +90,8 @@ function describeTokenEndpointValue(value: unknown): string | undefined {
 export const openAICodexProfileHook: AfterExchangeHook = async (credentials, context) => {
 	const idToken = isRecord(context.raw) && typeof context.raw.id_token === "string" ? context.raw.id_token : undefined;
 	const { accountId, email, planType } = getTokenProfile(credentials.access, idToken);
-	if (context.phase === "login" && !accountId) {
-		throw new AIError.OAuthError("Failed to extract accountId from token", {
+	if (context.phase === "login" && !accountId && !email) {
+		throw new AIError.OAuthError("Failed to extract account identity from token", {
 			kind: "validation",
 			provider: context.provider,
 		});
@@ -190,18 +190,17 @@ async function exchangeCodeForToken(
 	}
 
 	const { accountId, email, planType } = getTokenProfile(tokenData.access_token, tokenData.id_token);
-	if (!accountId) {
-		throw new AIError.OAuthError("Failed to extract accountId from token", { kind: "validation" });
+	if (!accountId && !email) {
+		throw new AIError.OAuthError("Failed to extract account identity from token", { kind: "validation" });
 	}
 
 	return {
 		access: tokenData.access_token,
 		refresh: tokenData.refresh_token,
 		expires: Date.now() + tokenData.expires_in * 1000,
-		accountId,
-		email,
-		orgId: accountId,
-		orgName: planType,
+		...(accountId ? { accountId, orgId: accountId } : {}),
+		...(email ? { email } : {}),
+		...(planType ? { orgName: planType } : {}),
 	};
 }
 

package/src/usage/charm-hyper.ts

@@ -0,0 +1,95 @@
+import { normalizeCharmHyperBaseUrl } from "@oh-my-pi/pi-catalog/wire/charm-hyper";
+import { ProviderHttpError } from "../error";
+import type { UsageFetchContext, UsageFetchParams, UsageLimit, UsageProvider, UsageReport } from "../usage";
+import { isRecord } from "../utils";
+
+const PROVIDER = "charm-hyper";
+const CREDITS_PATH = "/credits";
+
+/**
+ * Charm Hyper sells prepaid credits: `/v1/credits` answers `{"balance": N}` and
+ * nothing else — no allowance, no spend-to-date, no reset window — so the limit
+ * is remaining-only by construction. Synthesizing a total from the first
+ * observed balance would misreport every later top-up, so we report only what
+ * the API states.
+ *
+ * The balance is **account-wide**, not per-key: spending 1.216 credits through
+ * one key dropped a second key's reported balance from 95 to 94 (verified
+ * 2026-09-11), and Hyper issues several keys per account. The endpoint exposes
+ * no account identity to group them by, so the limit is marked
+ * `scope.shared` — every credential reports the same pool, and consumers must
+ * collapse rather than sum it.
+ */
+async function fetchCharmHyperUsage(params: UsageFetchParams, ctx: UsageFetchContext): Promise<UsageReport | null> {
+	if (params.provider !== PROVIDER) return null;
+	const credential = params.credential;
+	if (credential.type !== "api_key" || !credential.apiKey) return null;
+
+	// Honor a configured proxy base: inference and discovery already route
+	// through it, and sending the stored key to the canonical host would both
+	// fail for a proxy-scoped credential and disclose it off-site. Shared with
+	// discovery and the model-cache namespace so all three agree on the
+	// endpoint — including for a blank override, which means "not configured".
+	const creditsUrl = `${normalizeCharmHyperBaseUrl(params.baseUrl)}${CREDITS_PATH}`;
+
+	let payload: unknown;
+	try {
+		const response = await ctx.fetch(creditsUrl, {
+			headers: {
+				Authorization: `Bearer ${credential.apiKey}`,
+				Accept: "application/json",
+			},
+			signal: params.signal,
+		});
+		if (!response.ok) {
+			// A revoked key must invalidate the cached balance rather than let
+			// the last-good report be re-served: only a thrown auth status
+			// purges it, while `null` is the transient-failure path.
+			if (response.status === 401 || response.status === 403) {
+				throw new ProviderHttpError(
+					`Charm Hyper credits endpoint returned ${response.status} ${response.statusText}`.trim(),
+					response.status,
+				);
+			}
+			ctx.logger?.warn("Charm Hyper usage fetch failed", {
+				status: response.status,
+				statusText: response.statusText,
+			});
+			return null;
+		}
+		payload = await response.json();
+	} catch (error) {
+		if (error instanceof ProviderHttpError) throw error;
+		ctx.logger?.warn("Charm Hyper usage fetch error", { error: String(error) });
+		return null;
+	}
+
+	if (!isRecord(payload)) return null;
+	const balance = payload.balance;
+	if (typeof balance !== "number" || !Number.isFinite(balance)) return null;
+
+	const limit: UsageLimit = {
+		id: "charm-hyper:credits",
+		label: "Credit balance",
+		// Windowless and shared: the label already says "balance", and the
+		// shared flag tells renderers this is one account-level pool seen once
+		// per stored key.
+		scope: { provider: params.provider, windowId: "balance", shared: true },
+		amount: { remaining: balance, unit: "credits" },
+	};
+
+	return {
+		provider: params.provider,
+		fetchedAt: Date.now(),
+		limits: [limit],
+		metadata: { endpoint: creditsUrl },
+		raw: payload,
+	};
+}
+
+export const charmHyperUsageProvider: UsageProvider = {
+	id: PROVIDER,
+	fetchUsage: fetchCharmHyperUsage,
+	supports: params => params.provider === PROVIDER && params.credential.type === "api_key",
+	validatesCredentials: true,
+};

package/src/usage/claude.ts

@@ -53,6 +53,25 @@ function normalizeClaudeBaseUrl(baseUrl?: string): string {
 	return `${url.origin}${path}/api/oauth`;
 }
 
+/**
+ * Subscription usage is served by Anthropic's OAuth API, which a custom
+ * `baseUrl` pointed at a Messages-only endpoint does not expose. Probe the
+ * configured host first so a full mirror keeps answering (including its own
+ * `/profile` identity), then fall back to the canonical endpoint — but only
+ * when the configured host answered that it has no usage endpoint there (see
+ * {@link ClaudeUsagePayloadResult.endpointAbsent}), so a host that refuses the
+ * credential or fails transiently keeps the request.
+ *
+ * Without the fallback the report degrades to rate-limit headers, and those
+ * carry the model-scoped weekly row only on responses for that model family,
+ * so a scoped window can read far below its real utilization until a request
+ * hits the family again.
+ */
+function claudeUsageBaseUrls(baseUrl?: string): readonly string[] {
+	const configured = normalizeClaudeBaseUrl(baseUrl);
+	return configured === DEFAULT_ENDPOINT ? [DEFAULT_ENDPOINT] : [configured, DEFAULT_ENDPOINT];
+}
+
 interface ClaudeUsageBucket {
 	utilization?: number;
 	resets_at?: string;
@@ -274,38 +293,93 @@ async function waitBeforeRetry(
 	}
 }
 
+/** Statuses that answer "this host does not implement the endpoint". */
+const ENDPOINT_ABSENT_STATUSES = new Set([404, 405, 410, 501]);
+
+interface ClaudeUsagePayloadResult {
+	/** Best payload seen; may lack usage data when the retries gave up. */
+	payload: ClaudeUsageResponse | null;
+	/** The host answered, but does not serve subscription usage at this path. */
+	endpointAbsent: boolean;
+}
+
+/**
+ * A body with none of the usage keys is a host answering something else at this
+ * path (an error document, an index page), not an account whose windows are all
+ * empty — the latter still carries the keys.
+ */
+function looksLikeUsagePayload(payload: ClaudeUsageResponse): boolean {
+	return (
+		"five_hour" in payload ||
+		"seven_day" in payload ||
+		"limits" in payload ||
+		"extra_usage" in payload ||
+		"spend" in payload
+	);
+}
+
 async function fetchUsagePayload(
 	url: string,
 	headers: Record<string, string>,
 	ctx: UsageFetchContext,
 	signal?: AbortSignal,
-): Promise<ClaudeUsageResponse | null> {
-	if (signal?.aborted) return null;
+): Promise<ClaudeUsagePayloadResult> {
+	if (signal?.aborted) return { payload: null, endpointAbsent: false };
 
 	let lastPayload: ClaudeUsageResponse | null = null;
+	let endpointAbsent = false;
 	for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
 		try {
 			const response = await ctx.fetch(url, { headers, signal });
 
 			if (!response.ok) {
-				const retryable = isRetryableStatus(response.status);
+				// Absence outranks the generic transient classification: 501 is a 5xx,
+				// but "not implemented" does not become implemented on replay.
+				const absent = ENDPOINT_ABSENT_STATUSES.has(response.status);
+				const retryable = !absent && isRetryableStatus(response.status);
 				ctx.logger?.warn("Claude usage fetch failed", {
 					status: response.status,
 					statusText: response.statusText,
 					attempt,
 					willRetry: retryable && attempt < MAX_ATTEMPTS - 1,
 				});
-				if (!retryable) return null;
+				if (!retryable) return { payload: null, endpointAbsent: absent };
 				const retryAfter = response.headers.get("retry-after");
 				if (!(await waitBeforeRetry(attempt, retryAfter, signal, ctx.retryWait))) break;
 				continue;
 			}
 
-			const parsed = (await response.json()) as unknown;
+			const body = await response.text();
+			if (body.trim().length === 0) {
+				// An empty 2xx serves nothing here; a gateway answering unknown paths
+				// this way has no usage endpoint to poll.
+				return { payload: lastPayload, endpointAbsent: true };
+			}
+			let parsed: unknown;
+			try {
+				parsed = JSON.parse(body) as unknown;
+			} catch {
+				// A non-JSON 2xx is this host answering something else at this path
+				// (an index page, a plain-text notice). A body that claims JSON and
+				// fails to parse is truncated or garbled instead, so keep retrying it
+				// against this host rather than moving the request.
+				const claimsJson = /json/i.test(response.headers.get("content-type") ?? "");
+				ctx.logger?.warn("Claude usage response was not JSON", {
+					contentType: response.headers.get("content-type") ?? undefined,
+					attempt,
+					willRetry: claimsJson && attempt < MAX_ATTEMPTS - 1,
+				});
+				if (!claimsJson) return { payload: lastPayload, endpointAbsent: true };
+				if (!(await waitBeforeRetry(attempt, null, signal, ctx.retryWait))) break;
+				continue;
+			}
 			if (isRecord(parsed)) {
 				const payload = parsed as ClaudeUsageResponse;
 				lastPayload = payload;
-				if (hasUsageData(payload)) return payload;
+				if (hasUsageData(payload)) return { payload, endpointAbsent: false };
+				endpointAbsent = !looksLikeUsagePayload(payload);
+			} else {
+				endpointAbsent = true;
 			}
 
 			ctx.logger?.warn("Claude usage response missing usage data", {
@@ -314,7 +388,7 @@ async function fetchUsagePayload(
 			});
 			if (!(await waitBeforeRetry(attempt, null, signal, ctx.retryWait))) break;
 		} catch (error) {
-			if (isAbortError(error, signal)) return null;
+			if (isAbortError(error, signal)) return { payload: null, endpointAbsent: false };
 			ctx.logger?.warn("Claude usage fetch error", {
 				error: String(error),
 				attempt,
@@ -324,7 +398,7 @@ async function fetchUsagePayload(
 		}
 	}
 
-	return lastPayload;
+	return { payload: lastPayload, endpointAbsent };
 }
 
 interface ClaudeProfile {
@@ -608,15 +682,35 @@ async function fetchClaudeUsage(params: UsageFetchParams, ctx: UsageFetchContext
 	const credential = params.credential;
 	if (credential.type !== "oauth" || !credential.accessToken) return null;
 
-	const baseUrl = normalizeClaudeBaseUrl(params.baseUrl);
-	const url = `${baseUrl}/usage`;
 	const headers: Record<string, string> = {
 		...CLAUDE_HEADERS,
 		authorization: `Bearer ${credential.accessToken}`,
 	};
 
-	const payload = await fetchUsagePayload(url, headers, ctx, params.signal);
-	if (!payload || !isRecord(payload)) return null;
+	let baseUrl: string | undefined;
+	let payload: ClaudeUsageResponse | null = null;
+	for (const candidate of claudeUsageBaseUrls(params.baseUrl)) {
+		const result = await fetchUsagePayload(`${candidate}/usage`, headers, ctx, params.signal);
+		if (result.payload && hasUsageData(result.payload)) {
+			baseUrl = candidate;
+			payload = result.payload;
+			break;
+		}
+		// Usage-shaped body without numbers: retries already gave up on fresher
+		// numbers here, so hold it while the remaining candidate is probed.
+		if (result.payload && !payload) {
+			baseUrl = candidate;
+			payload = result.payload;
+		}
+		if (params.signal?.aborted) break;
+		// Only a host that answered "no usage endpoint here" justifies moving the
+		// request off the configured one. A refused credential (401/403) or a
+		// transient failure is that host's answer about this account, so it stands
+		// and the next poll retries it.
+		if (!result.endpointAbsent) break;
+	}
+	if (!payload || baseUrl === undefined) return null;
+	const url = `${baseUrl}/usage`;
 
 	const apiLimitEntries = parseApiLimitEntries(payload.limits);
 	const fiveHour = parseBucket(payload.five_hour) ?? apiLimitEntries.find(entry => entry.kind === "session")?.bucket;

package/src/usage/kimi.ts

@@ -22,6 +22,7 @@ const USAGE_PATH = "usages";
 interface KimiUsagePayload {
 	usage?: unknown;
 	limits?: unknown;
+	totalQuota?: unknown;
 }
 
 type KimiUsageRow = {
@@ -195,7 +196,7 @@ function parseUsagePayload(payload: unknown, nowMs: number): { rows: KimiUsageRo
 	const rows: KimiUsageRow[] = [];
 
 	if (isRecord(data.usage)) {
-		const summary = buildUsageRow(data.usage, "Total quota", nowMs);
+		const summary = buildUsageRow(data.usage, "Weekly limit", nowMs);
 		if (summary) {
 			// Kimi Code's aggregate quota resets weekly, but the payload carries
 			// only `resetTime` and no duration. Attach the canonical weekly
@@ -205,6 +206,15 @@ function parseUsagePayload(payload: unknown, nowMs: number): { rows: KimiUsageRo
 		}
 	}
 
+	if (isRecord(data.totalQuota)) {
+		const windowData = isRecord(data.totalQuota.window) ? data.totalQuota.window : {};
+		const total = buildUsageRow(data.totalQuota, "Total quota", nowMs);
+		if (total) {
+			total.window = buildWindow(windowData, nowMs);
+			rows.push(total);
+		}
+	}
+
 	if (Array.isArray(data.limits)) {
 		data.limits.forEach((item, idx) => {
 			if (!isRecord(item)) return;

package/src/utils/empty-completion-retry.ts

@@ -4,8 +4,10 @@
  * A provider attempt can be discarded only until meaningful assistant output is
  * emitted. Pre-output markers are buffered so transient transport failures and
  * benign empty completions can re-issue a fresh request without duplicating
- * content; the first text, thinking, image, or tool event commits the attempt
- * and restores live streaming.
+ * content; the first text, thinking, image, or tool-call-delta event commits
+ * the attempt and restores live streaming. `toolcall_start` and `toolcall_end`
+ * markers alone do not commit — if the stream dies before any argument content
+ * arrives, the buffered markers are discarded and the attempt retried.
  *
  * Empty-completion retries remain opt-in because a normal empty stop can be a
  * valid provider result. Transient-error retries use the shared provider error
@@ -35,7 +37,7 @@ export function hasVisibleAssistantContent(message: AssistantMessage): boolean {
 	return false;
 }
 
-/** A streamed event that delivers content worth committing the attempt for. */
+/** A streamed event that delivers content worth committing the attempt for. `toolcall_start` and `toolcall_end` markers are excluded: they carry no argument data, so a stream that dies after the start but before any delta content should be retried rather than committed. A `toolcall_delta` with a non-empty delta string is what commits a tool call — string-arg hosts emit `{}` itself as a delta, so completed zero-argument calls commit on their args. Object-arg hosts merge `{}` delta-free (the flush is suppressed and both sweeps finalize through the same `finishToolCallBlock`), so a completed call there is event-identical to an unfilled one and bounded-retries instead. Committing on `toolcall_end` would also commit mid-args transport failures that today recover invisibly via retry. Safe either way: buffered output never reached the consumer and the tool never executed. */
 function isMeaningfulCompletionEvent(event: AssistantMessageEvent): boolean {
 	switch (event.type) {
 		case "text_delta":
@@ -49,7 +51,7 @@ function isMeaningfulCompletionEvent(event: AssistantMessageEvent): boolean {
 			return true;
 		case "toolcall_start":
 		case "toolcall_end":
-			return true;
+			return false;
 		default:
 			return false;
 	}

package/src/utils/proxy.ts

@@ -380,14 +380,15 @@ export async function connectProxiedSocket(
 		}
 
 		const tlsOptions = options?.tls;
-		tunnelSocket = tls.connect({
+		const newTunnelSocket: tls.TLSSocket = tls.connect({
 			...tlsOptions,
 			socket: rawSocket,
 			servername: tlsOptions?.servername ?? targetHost,
 			ALPNProtocols: tlsOptions?.ALPNProtocols ?? ["h2"],
 		});
-		tunnelSocket.once("secureConnect", onTunnelReady);
-		tunnelSocket.once("error", onTunnelError);
+		tunnelSocket = newTunnelSocket;
+		newTunnelSocket.once("secureConnect", onTunnelReady);
+		newTunnelSocket.once("error", onTunnelError);
 	};
 	const onProxyReady = (): void => {
 		if (!rawSocket) return;