@narumitw/pi-usage 0.52.3 → 0.53.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@narumitw/pi-usage",
-	"version": "0.52.3",
-	"description": "Pi extension that shows current-account usage for Codex, GitHub Copilot, OpenRouter, and OpenCode Zen.",
+	"version": "0.53.0",
+	"description": "Pi extension that shows current-account usage for Codex, GitHub Copilot, OpenRouter, OpenCode Zen, and Z.AI.",
 	"type": "module",
 	"license": "MIT",
 	"private": false,
@@ -15,7 +15,9 @@
 		"copilot",
 		"openrouter",
 		"opencode",
-		"zen"
+		"zen",
+		"zai",
+		"glm"
 	],
 	"files": [
 		"src",

package/src/format.ts

@@ -19,7 +19,9 @@ export function formatUsageReport(report: UsageReport, displayState: UsageDispla
 	else if (report.providerId === "github-copilot") formatGitHubCopilotReport(lines, report);
 	else if (report.providerId === "openrouter") formatOpenRouterReport(lines, report);
 	else if (report.providerId === "opencode-go") formatOpenCodeZenReport(lines, report);
-	else formatGenericReport(lines, report);
+	else if (report.providerId === "zai" || report.providerId === "zai-coding-cn") {
+		formatZaiReport(lines, report);
+	} else formatGenericReport(lines, report);
 
 	if (report.notes) {
 		for (const note of report.notes) lines.push(note);
@@ -160,6 +162,30 @@ function formatOpenCodeZenStatusline(report: UsageReport): string | undefined {
 	return parts.length > 1 ? parts.join(" ") : undefined;
 }
 
+function formatZaiReport(lines: string[], report: UsageReport): void {
+	for (const bucket of report.buckets) {
+		const reset = bucket.resetsAt ? ` (resets ${formatReset(bucket.resetsAt)})` : "";
+		let value = "unavailable";
+		if (bucket.unit === "percent" && bucket.used !== undefined) {
+			value = `${bucket.used}% used`;
+			if (bucket.remaining !== undefined) value += ` · ${bucket.remaining}% left`;
+		} else if (bucket.used !== undefined && bucket.limit !== undefined) {
+			value = `${bucket.used} of ${bucket.limit} used`;
+			if (bucket.remaining !== undefined) value += ` · ${bucket.remaining} left`;
+		} else if (bucket.used !== undefined) {
+			value = `${bucket.used} used`;
+		} else if (bucket.remaining !== undefined) {
+			value = `${bucket.remaining} left`;
+		}
+		lines.push(`${`${bucket.label}:`.padEnd(VALUE_COLUMN)}${value}${reset}`);
+	}
+	for (const metric of report.metrics) {
+		lines.push(
+			`${`${metric.label}:`.padEnd(VALUE_COLUMN)}${formatMetricValue(metric.value, metric.unit)}`,
+		);
+	}
+}
+
 function formatGenericReport(lines: string[], report: UsageReport): void {
 	for (const bucket of report.buckets) {
 		lines.push(

package/src/index.ts

@@ -36,6 +36,7 @@ export { normalizeCodexBackendPayload } from "./providers/codex.js";
 export { normalizeGitHubCopilotUsagePayload } from "./providers/github-copilot.js";
 export { normalizeOpenCodeZenPayload } from "./providers/opencode-zen.js";
 export { normalizeOpenRouterKeyPayload } from "./providers/openrouter.js";
+export { normalizeZaiQuotaPayload } from "./providers/zai.js";
 export {
 	adapterForProvider,
 	isStaleExtensionContextError,

package/src/providers/zai.ts

@@ -0,0 +1,150 @@
+import { sanitizeDisplayText } from "../core.js";
+import type { UsageBucket, UsageMetric, UsageReport, ZaiQuotaPayload } from "../types.js";
+
+const FIVE_HOUR_WINDOW_MINUTES = 300;
+const WEEKLY_WINDOW_MINUTES = 10_080;
+
+export function normalizeZaiQuotaPayload(
+	providerId: string,
+	providerName: string,
+	payload: ZaiQuotaPayload,
+	capturedAt: number,
+): UsageReport {
+	const data = asObject(payload.data);
+	if (!data) throw new Error("Z.AI quota response data was not an object.");
+	const limits = Array.isArray(data.limits) ? (data.limits as unknown[]) : [];
+
+	const buckets: UsageBucket[] = [];
+	const metrics: UsageMetric[] = [];
+	for (const raw of limits) {
+		const limit = asObject(raw);
+		if (!limit) continue;
+		const type = asString(limit.type);
+		const unit = asNonnegativeNumber(limit.unit);
+		const isPlanUsage = type === "TOKENS_LIMIT" || type === "CREDIT_LIMIT";
+		if (type === "TIME_LIMIT") {
+			addCountBucket(buckets, limit, "mcp-monthly", "MCP monthly allowance");
+			addUsageDetailMetrics(metrics, limit.usageDetails);
+		} else if (isPlanUsage && unit === 3) {
+			addPercentBucket(buckets, limit, "five-hour", "5h window", FIVE_HOUR_WINDOW_MINUTES);
+		} else if (isPlanUsage && unit === 6) {
+			const used = asNonnegativeNumber(limit.currentValue);
+			const quota = asNonnegativeNumber(limit.usage);
+			if (used !== undefined && quota !== undefined) {
+				addCountBucket(buckets, limit, "weekly", "Weekly window", WEEKLY_WINDOW_MINUTES);
+			} else {
+				addPercentBucket(buckets, limit, "weekly", "Weekly window", WEEKLY_WINDOW_MINUTES);
+			}
+		}
+	}
+	if (buckets.length === 0) {
+		throw new Error("Z.AI quota endpoint returned no displayable usage data.");
+	}
+
+	const notes: string[] = [];
+	const level = asString(data.level);
+	if (level) notes.push(`Plan: ${level}`);
+
+	return {
+		providerId,
+		providerName,
+		capturedAt,
+		source: "zai-quota",
+		semantics: { kind: "consumer-subscription", label: "GLM Coding Plan usage" },
+		buckets,
+		metrics,
+		...(notes.length > 0 ? { notes } : {}),
+	};
+}
+
+function addPercentBucket(
+	buckets: UsageBucket[],
+	limit: Record<string, unknown>,
+	id: string,
+	label: string,
+	windowMinutes: number,
+): void {
+	const used = asNonnegativeNumber(limit.percentage);
+	if (used === undefined) return;
+	const percent = clampPercent(used);
+	const resetsAt = asEpochSeconds(limit.nextResetTime);
+	buckets.push({
+		id,
+		label,
+		used: percent,
+		remaining: 100 - percent,
+		limit: 100,
+		unit: "percent",
+		windowMinutes,
+		...(resetsAt !== undefined ? { resetsAt } : {}),
+	});
+}
+
+function addCountBucket(
+	buckets: UsageBucket[],
+	limit: Record<string, unknown>,
+	id: string,
+	label: string,
+	windowMinutes?: number,
+): void {
+	const used = asNonnegativeNumber(limit.currentValue);
+	const quota = asNonnegativeNumber(limit.usage);
+	if (used === undefined || quota === undefined) return;
+	const resetsAt = asEpochSeconds(limit.nextResetTime);
+	buckets.push({
+		id,
+		label,
+		used,
+		remaining: Math.max(0, quota - used),
+		limit: quota,
+		unit: "count",
+		...(windowMinutes !== undefined ? { windowMinutes } : {}),
+		...(resetsAt !== undefined ? { resetsAt } : {}),
+	});
+}
+
+function addUsageDetailMetrics(metrics: UsageMetric[], value: unknown): void {
+	if (!Array.isArray(value)) return;
+	for (const raw of value) {
+		const detail = asObject(raw);
+		if (!detail) continue;
+		const label = asString(detail.modelCode);
+		const usage = asNonnegativeNumber(detail.usage);
+		if (!label || usage === undefined) continue;
+		metrics.push({ id: `mcp-${kebabCase(label)}`, label, value: usage, unit: "count" });
+	}
+}
+
+function asObject(value: unknown): Record<string, unknown> | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	return value as Record<string, unknown>;
+}
+
+function asString(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	return sanitizeDisplayText(value, 80) || undefined;
+}
+
+function asNonnegativeNumber(value: unknown): number | undefined {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return undefined;
+	return value;
+}
+
+function asEpochSeconds(value: unknown): number | undefined {
+	const millis = asNonnegativeNumber(value);
+	if (millis === undefined) return undefined;
+	return Math.floor(millis / 1000);
+}
+
+function kebabCase(label: string): string {
+	return (
+		label
+			.toLowerCase()
+			.replace(/[^a-z0-9]+/gu, "-")
+			.replace(/^-+|-+$/gu, "") || "tool"
+	);
+}
+
+function clampPercent(value: number): number {
+	return Math.min(100, Math.max(0, value));
+}

package/src/query.ts

@@ -9,6 +9,7 @@ import { normalizeCodexBackendPayload } from "./providers/codex.js";
 import { normalizeGitHubCopilotUsagePayload } from "./providers/github-copilot.js";
 import { normalizeOpenCodeZenPayload } from "./providers/opencode-zen.js";
 import { normalizeOpenRouterKeyPayload } from "./providers/openrouter.js";
+import { normalizeZaiQuotaPayload } from "./providers/zai.js";
 import type {
 	CodexBackendPayload,
 	GitHubCopilotUsagePayload,
@@ -18,6 +19,7 @@ import type {
 	ResolvedUsageAuth,
 	UsageProviderAdapter,
 	UsageReport,
+	ZaiQuotaPayload,
 } from "./types.js";
 
 const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
@@ -96,6 +98,43 @@ export const SUPPORTED_ADAPTERS: readonly UsageProviderAdapter[] = [
 			return normalizeOpenCodeZenPayload(payload as OpenCodeZenPayload, Date.now());
 		},
 	},
+	{
+		id: "zai",
+		displayName: "Z.AI",
+		semantics: { kind: "consumer-subscription", label: "GLM Coding Plan usage" },
+		publishesStatusline: false,
+		async query(auth, signal, timeoutMs) {
+			const payload = await fetchProviderJson(
+				zaiMonitorUrl(auth.model.baseUrl),
+				zaiMonitorAuth(auth),
+				signal,
+				timeoutMs,
+				"Z.AI quota endpoint",
+			);
+			return normalizeZaiQuotaPayload("zai", "Z.AI", payload as ZaiQuotaPayload, Date.now());
+		},
+	},
+	{
+		id: "zai-coding-cn",
+		displayName: "Z.AI Coding CN",
+		semantics: { kind: "consumer-subscription", label: "GLM Coding Plan usage" },
+		publishesStatusline: false,
+		async query(auth, signal, timeoutMs) {
+			const payload = await fetchProviderJson(
+				zaiMonitorUrl(auth.model.baseUrl),
+				zaiMonitorAuth(auth),
+				signal,
+				timeoutMs,
+				"Z.AI Coding CN quota endpoint",
+			);
+			return normalizeZaiQuotaPayload(
+				"zai-coding-cn",
+				"Z.AI Coding CN",
+				payload as ZaiQuotaPayload,
+				Date.now(),
+			);
+		},
+	},
 ];
 
 export function adapterForProvider(
@@ -470,6 +509,8 @@ function hasOfficialUrlOrigin(value: string, providerId: string): boolean {
 		if (providerId === "openai-codex") return url.origin === "https://chatgpt.com";
 		if (providerId === "openrouter") return url.origin === "https://openrouter.ai";
 		if (providerId === "opencode-go") return url.origin === "https://opencode.ai";
+		if (providerId === "zai") return url.origin === "https://api.z.ai";
+		if (providerId === "zai-coding-cn") return url.origin === "https://open.bigmodel.cn";
 		if (providerId === "github-copilot") {
 			return (
 				url.protocol === "https:" && /^api\.[a-z0-9-]+\.githubcopilot\.com$/u.test(url.hostname)
@@ -495,6 +536,20 @@ function hasHeader(headers: Record<string, string>, name: string): boolean {
 	return Object.keys(headers).some((key) => key.toLowerCase() === name.toLowerCase());
 }
 
+function zaiMonitorUrl(baseUrl: string | undefined): string {
+	const base = baseUrl?.trim();
+	if (!base) throw new Error("Z.AI model base URL is unavailable.");
+	return `${new URL(base).origin}/api/monitor/usage/quota/limit`;
+}
+
+function zaiMonitorAuth(auth: ResolvedUsageAuth): ResolvedUsageAuth {
+	const authorization = headerValue(auth.headers, "Authorization");
+	const token =
+		authorization === undefined ? undefined : (bearerToken(authorization) ?? authorization);
+	if (token === undefined || token === authorization) return auth;
+	return { ...auth, headers: { ...auth.headers, Authorization: token } };
+}
+
 function isAbortError(error: unknown): boolean {
 	return error instanceof Error && error.name === "AbortError";
 }

package/src/types.ts

@@ -58,6 +58,7 @@ export interface UsageProviderAdapter {
 	id: string;
 	displayName: string;
 	semantics: UsageSemantics;
+	publishesStatusline?: boolean;
 	query(auth: ResolvedUsageAuth, signal: AbortSignal, timeoutMs: number): Promise<UsageReport>;
 }
 
@@ -97,6 +98,10 @@ export type OpenCodeZenPayload = {
 	usage?: unknown;
 };
 
+export type ZaiQuotaPayload = {
+	data?: unknown;
+};
+
 export type CodexBackendPayload = {
 	plan_type?: unknown;
 	rate_limit?: unknown;

package/src/usage.ts

@@ -136,6 +136,11 @@ export default function usageExtension(
 		model: PiModel,
 		shouldSchedule: boolean,
 	) => {
+		if (adapterForProvider(model.provider)?.publishesStatusline === false) {
+			clearStatusTimer();
+			safeSetStatus(ctx, undefined);
+			return;
+		}
 		if (outcome.state.status === "unsupported") {
 			clearStatusTimer();
 			safeSetStatus(ctx, undefined);
@@ -345,6 +350,10 @@ export default function usageExtension(
 			clearStatus(ctx);
 			return;
 		}
+		if (adapter.publishesStatusline === false) {
+			clearStatus(ctx);
+			return;
+		}
 		statusGeneration += 1;
 		const generation = statusGeneration;
 		statusController?.abort();