@linxiraos/pi-ai 1.0.0

package/src/usage/kimi.ts

@@ -0,0 +1,277 @@
+import { $env } from "@linxiraos/pi-utils";
+import { getKimiCommonHeaders } from "../registry/oauth/kimi";
+import type {
+	UsageAmount,
+	UsageFetchContext,
+	UsageFetchParams,
+	UsageLimit,
+	UsageProvider,
+	UsageReport,
+	UsageStatus,
+	UsageWindow,
+} from "../usage";
+import { isRecord } from "../utils";
+// (Refresh is the sole responsibility of AuthStorage; no provider-direct refresh here.)
+import { toNumber } from "./shared";
+
+const DEFAULT_BASE_URL = "https://api.kimi.com/coding/v1";
+const USAGE_PATH = "usages";
+
+interface KimiUsagePayload {
+	usage?: unknown;
+	limits?: unknown;
+}
+
+type KimiUsageRow = {
+	label: string;
+	used?: number;
+	limit?: number;
+	remaining?: number;
+	resetsAt?: number;
+	window?: UsageWindow;
+};
+
+function normalizeBaseUrl(baseUrl?: string): string {
+	const envBase = $env.KIMI_CODE_BASE_URL?.trim();
+	const candidate = baseUrl?.trim() || envBase || DEFAULT_BASE_URL;
+	return candidate.replace(/\/+$/, "");
+}
+
+function buildUsageUrl(baseUrl: string): string {
+	const normalized = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+	return `${normalized}${USAGE_PATH}`;
+}
+
+function parseResetTime(data: Record<string, unknown>, nowMs: number): number | undefined {
+	const timeKeys = ["reset_at", "resetAt", "reset_time", "resetTime"] as const;
+	for (const key of timeKeys) {
+		const value = data[key];
+		if (typeof value === "string" && value.trim()) {
+			const parsed = Date.parse(value);
+			if (Number.isFinite(parsed)) return parsed;
+		}
+		if (typeof value === "number" && Number.isFinite(value)) {
+			return value > 1_000_000_000_000 ? value : value * 1000;
+		}
+	}
+
+	const secondsKeys = ["reset_in", "resetIn", "ttl", "window"] as const;
+	for (const key of secondsKeys) {
+		const seconds = toNumber(data[key]);
+		if (seconds !== undefined) return nowMs + seconds * 1000;
+	}
+
+	return undefined;
+}
+
+function formatDurationLabel(duration: number, timeUnit: string): string | undefined {
+	const upper = timeUnit.toUpperCase();
+	if (upper.includes("MINUTE")) {
+		if (duration >= 60 && duration % 60 === 0) return `${duration / 60}h limit`;
+		return `${duration}m limit`;
+	}
+	if (upper.includes("HOUR")) return `${duration}h limit`;
+	if (upper.includes("DAY")) return `${duration}d limit`;
+	if (upper.includes("SECOND")) return `${duration}s limit`;
+	return undefined;
+}
+
+function buildWindow(windowData: Record<string, unknown>, nowMs: number): UsageWindow | undefined {
+	const duration = toNumber(windowData.duration);
+	const timeUnit = typeof windowData.timeUnit === "string" ? windowData.timeUnit : "";
+	const label = duration !== undefined && timeUnit ? formatDurationLabel(duration, timeUnit) : undefined;
+	const resetsAt = parseResetTime(windowData, nowMs);
+
+	if (duration === undefined && !label && !resetsAt) return undefined;
+	let durationMs: number | undefined;
+	if (duration !== undefined) {
+		if (timeUnit.toUpperCase().includes("MINUTE")) durationMs = duration * 60_000;
+		else if (timeUnit.toUpperCase().includes("HOUR")) durationMs = duration * 3_600_000;
+		else if (timeUnit.toUpperCase().includes("DAY")) durationMs = duration * 86_400_000;
+		else if (timeUnit.toUpperCase().includes("SECOND")) durationMs = duration * 1000;
+	}
+
+	return {
+		id: duration !== undefined && timeUnit ? `${duration}${timeUnit.toLowerCase()}` : "default",
+		label: label ?? "Usage window",
+		durationMs,
+		resetsAt,
+	};
+}
+
+function buildUsageRow(data: Record<string, unknown>, defaultLabel: string, nowMs: number): KimiUsageRow | null {
+	const limit = toNumber(data.limit);
+	let used = toNumber(data.used);
+	const remaining = toNumber(data.remaining);
+	if (used === undefined && remaining !== undefined && limit !== undefined) {
+		used = limit - remaining;
+	}
+
+	if (used === undefined && limit === undefined) return null;
+	const resetsAt = parseResetTime(data, nowMs);
+	return {
+		label:
+			typeof data.name === "string" && data.name
+				? data.name
+				: typeof data.title === "string" && data.title
+					? data.title
+					: defaultLabel,
+		used,
+		limit,
+		remaining,
+		resetsAt,
+	};
+}
+
+function buildUsageAmount(row: KimiUsageRow): UsageAmount {
+	const amount: UsageAmount = { unit: "unknown" };
+	if (row.limit !== undefined) amount.limit = row.limit;
+	if (row.used !== undefined) amount.used = row.used;
+	if (row.remaining !== undefined) amount.remaining = row.remaining;
+	if (row.limit !== undefined && row.used !== undefined && row.limit > 0) {
+		amount.usedFraction = Math.min(Math.max(row.used / row.limit, 0), 1);
+		amount.remainingFraction = Math.min(Math.max((row.limit - row.used) / row.limit, 0), 1);
+		amount.remaining = amount.remaining ?? row.limit - row.used;
+	}
+	return amount;
+}
+
+function buildUsageStatus(amount: UsageAmount): UsageStatus {
+	if (amount.usedFraction === undefined) return "unknown";
+	if (amount.usedFraction >= 1) return "exhausted";
+	if (amount.usedFraction >= 0.9) return "warning";
+	return "ok";
+}
+
+function toUsageLimit(row: KimiUsageRow, provider: string, index: number, accountId?: string): UsageLimit {
+	// Kimi puts `resetTime` on the limit `detail`, not on `window`, so a
+	// window built from `duration`/`timeUnit` alone carries no resetsAt.
+	// Fall back to the row-level reset so `omp usage` can render
+	// "resets in …" for the 5h window too.
+	const window: UsageWindow | undefined = row.window
+		? row.window.resetsAt !== undefined || row.resetsAt === undefined
+			? row.window
+			: { ...row.window, resetsAt: row.resetsAt }
+		: row.resetsAt
+			? {
+					id: "default",
+					label: "Usage window",
+					resetsAt: row.resetsAt,
+				}
+			: undefined;
+
+	const amount = buildUsageAmount(row);
+	return {
+		id: `${provider}:${index}`,
+		label: row.label,
+		scope: {
+			provider,
+			accountId,
+			windowId: window?.id,
+			shared: true,
+		},
+		window,
+		amount,
+		status: buildUsageStatus(amount),
+	};
+}
+
+function parseUsagePayload(payload: unknown, nowMs: number): { rows: KimiUsageRow[]; raw: KimiUsagePayload } | null {
+	if (!isRecord(payload)) return null;
+	const data = payload as KimiUsagePayload;
+	const rows: KimiUsageRow[] = [];
+
+	if (isRecord(data.usage)) {
+		const summary = buildUsageRow(data.usage, "Total quota", nowMs);
+		if (summary) rows.push(summary);
+	}
+
+	if (Array.isArray(data.limits)) {
+		data.limits.forEach((item, idx) => {
+			if (!isRecord(item)) return;
+			const detail = isRecord(item.detail) ? item.detail : item;
+			const windowData = isRecord(item.window) ? item.window : {};
+			const label =
+				(typeof item.name === "string" && item.name) ||
+				(typeof item.title === "string" && item.title) ||
+				(typeof item.scope === "string" && item.scope) ||
+				(typeof detail.name === "string" && detail.name) ||
+				(typeof detail.title === "string" && detail.title) ||
+				formatDurationLabel(toNumber(windowData.duration) ?? 0, String(windowData.timeUnit || "")) ||
+				`Limit #${idx + 1}`;
+			const row = buildUsageRow(detail, label, nowMs);
+			if (row) {
+				row.window = buildWindow(windowData, nowMs);
+				rows.push(row);
+			}
+		});
+	}
+
+	return { rows, raw: data };
+}
+
+export const kimiUsageProvider: UsageProvider = {
+	id: "kimi-code",
+	supports(params: UsageFetchParams): boolean {
+		return params.provider === "kimi-code" && params.credential.type === "oauth";
+	},
+	async fetchUsage(params: UsageFetchParams, ctx: UsageFetchContext): Promise<UsageReport | null> {
+		if (params.provider !== "kimi-code") return null;
+		const { credential } = params;
+		if (credential.type !== "oauth") return null;
+
+		const accessToken = credential.accessToken;
+		if (!accessToken) return null;
+
+		const nowMs = Date.now();
+		// AuthStorage refreshes OAuth credentials pre-emptively (60s skew). If the
+		// usage probe lands with an expired token, short-circuit rather than POST
+		// the broker sentinel back to Kimi — the next cycle will carry a freshly
+		// refreshed credential.
+		if (credential.expiresAt !== undefined && credential.expiresAt <= nowMs) {
+			ctx.logger?.debug("Kimi usage token expired; skipping probe", { provider: params.provider });
+			return null;
+		}
+
+		const baseUrl = normalizeBaseUrl(params.baseUrl);
+		const url = buildUsageUrl(baseUrl);
+		let payload: unknown;
+		try {
+			const response = await ctx.fetch(url, {
+				headers: {
+					...getKimiCommonHeaders(),
+					Authorization: `Bearer ${accessToken}`,
+				},
+				signal: params.signal,
+			});
+			if (!response.ok) {
+				ctx.logger?.warn("Kimi usage request failed", { status: response.status, provider: params.provider });
+				return null;
+			}
+			payload = await response.json();
+		} catch (error) {
+			ctx.logger?.warn("Kimi usage request error", { provider: params.provider, error: String(error) });
+			return null;
+		}
+
+		const parsed = parseUsagePayload(payload, nowMs);
+		if (!parsed || parsed.rows.length === 0) {
+			ctx.logger?.warn("Kimi usage response invalid", { provider: params.provider });
+			return null;
+		}
+
+		const limits = parsed.rows.map((row, index) => toUsageLimit(row, params.provider, index, credential.accountId));
+
+		const report: UsageReport = {
+			provider: params.provider,
+			fetchedAt: nowMs,
+			limits,
+			metadata: {
+				endpoint: url,
+			},
+			raw: parsed.raw,
+		};
+
+		return report;
+	},
+};

package/src/usage/minimax-code.ts

@@ -0,0 +1,291 @@
+import type {
+	UsageFetchContext,
+	UsageFetchParams,
+	UsageLimit,
+	UsageProvider,
+	UsageReport,
+	UsageStatus,
+} from "../usage";
+import { isRecord } from "../utils";
+import { toNumber } from "./shared";
+
+const INTL_PROVIDER = "minimax-code";
+const INTL_BASE_URL = "https://api.minimax.io";
+const REMAINS_PATH = "/v1/token_plan/remains";
+const HOUR_MS = 60 * 60 * 1000;
+/** `current_*_status` enum reported per window: 1 normal, 2 exhausted, 3 unlimited. */
+const STATUS_EXHAUSTED = 2;
+const STATUS_UNLIMITED = 3;
+/**
+ * The plan-wide token quota every chat model draws from. It is a quota category,
+ * not a catalog model id, so its limits are scoped `shared`: `AuthStorage` has no
+ * MiniMax ranking strategy and would otherwise match `scope.modelId` against ids
+ * like `MiniMax-M3` and drop the "models with usage data" mapping. Category
+ * buckets such as `video` meter a separate quota and keep their own model scope.
+ */
+const SHARED_BUCKET = "general";
+
+/** One `model_remains[]` bucket: a plan quota tracked over a rolling interval plus a weekly window. */
+interface TokenPlanBucket {
+	modelName: string;
+	intervalStart?: number;
+	intervalEnd?: number;
+	intervalRemainingPercent?: number;
+	intervalTotalCount?: number;
+	intervalUsageCount?: number;
+	intervalStatus?: number;
+	weeklyStart?: number;
+	weeklyEnd?: number;
+	weeklyRemainingPercent?: number;
+	weeklyTotalCount?: number;
+	weeklyUsageCount?: number;
+	weeklyStatus?: number;
+}
+
+/** MiniMax reports epoch milliseconds; tolerate seconds in case a deployment differs. */
+function parseTimestamp(value: unknown): number | undefined {
+	const parsed = toNumber(value);
+	if (parsed === undefined || parsed <= 0) return undefined;
+	return parsed < 1_000_000_000_000 ? parsed * 1000 : parsed;
+}
+
+/** `current_*_remaining_percent` is 0..100 remaining; usage fractions are 0..1 used. */
+function usedFractionFromRemainingPercent(value: unknown): number | undefined {
+	const parsed = toNumber(value);
+	if (parsed === undefined || !Number.isFinite(parsed)) return undefined;
+	// (100 - p) / 100 keeps whole percentages exact; 1 - p / 100 does not (90 → 0.09999999999999998).
+	return Math.min(1, Math.max(0, (100 - parsed) / 100));
+}
+
+function usageStatus(usedFraction: number): UsageStatus {
+	if (usedFraction >= 1) return "exhausted";
+	if (usedFraction >= 0.9) return "warning";
+	return "ok";
+}
+
+function parseBucket(value: unknown): TokenPlanBucket | null {
+	if (!isRecord(value)) return null;
+	const modelName = typeof value.model_name === "string" ? value.model_name.trim() : "";
+	if (!modelName) return null;
+	return {
+		modelName,
+		intervalStart: parseTimestamp(value.start_time),
+		intervalEnd: parseTimestamp(value.end_time),
+		intervalRemainingPercent: toNumber(value.current_interval_remaining_percent),
+		intervalTotalCount: toNumber(value.current_interval_total_count),
+		intervalUsageCount: toNumber(value.current_interval_usage_count),
+		intervalStatus: toNumber(value.current_interval_status),
+		weeklyStart: parseTimestamp(value.weekly_start_time),
+		weeklyEnd: parseTimestamp(value.weekly_end_time),
+		weeklyRemainingPercent: toNumber(value.current_weekly_remaining_percent),
+		weeklyTotalCount: toNumber(value.current_weekly_total_count),
+		weeklyUsageCount: toNumber(value.current_weekly_usage_count),
+		weeklyStatus: toNumber(value.current_weekly_status),
+	};
+}
+
+/**
+ * A model outside the current plan is reported as both windows "unlimited"
+ * with zero totals and 100% remaining, which would otherwise read as a pristine
+ * quota. MiniMax's own CLI treats exactly this shape as "not in plan"
+ * ([MiniMax-AI/cli#173](https://github.com/MiniMax-AI/cli/issues/173)), so the
+ * bucket is kept out of the limits and named in `metadata.unavailableModels`.
+ * Zero totals alone are not enough: a live plan reports `0/0` with status 1 and
+ * a real remaining percentage.
+ */
+function isUnavailablePlan(bucket: TokenPlanBucket): boolean {
+	return (
+		bucket.intervalTotalCount === 0 &&
+		bucket.weeklyTotalCount === 0 &&
+		bucket.intervalStatus === STATUS_UNLIMITED &&
+		bucket.weeklyStatus === STATUS_UNLIMITED
+	);
+}
+
+/**
+ * Interval length varies per bucket (text quotas roll every few hours, media
+ * quotas daily), so the window id follows the reported span instead of a
+ * hardcoded tier. Spans that are not whole hours are labelled in minutes
+ * rather than rounded into a wrong hour count.
+ */
+function intervalWindowId(durationMs: number | undefined): { id: string; label: string } {
+	if (durationMs === undefined || durationMs <= 0) return { id: "interval", label: "Interval" };
+	if (durationMs % HOUR_MS === 0) {
+		const hours = durationMs / HOUR_MS;
+		return { id: `${hours}h`, label: `${hours} Hour` };
+	}
+	const minutes = Math.round(durationMs / 60_000);
+	if (minutes <= 0) return { id: "interval", label: "Interval" };
+	return { id: `${minutes}m`, label: `${minutes} Minute` };
+}
+
+function buildLimit(args: {
+	provider: string;
+	bucket: TokenPlanBucket;
+	windowId: string;
+	windowLabel: string;
+	durationMs?: number;
+	resetsAt?: number;
+	usedFraction: number | undefined;
+	windowStatus?: number;
+	usageCount?: number;
+	totalCount?: number;
+	accountId?: string;
+}): UsageLimit | undefined {
+	// The endpoint's own status outranks the percentage: an exhausted window may
+	// omit it, or keep a stale one that would otherwise render as healthy quota.
+	const usedFraction = args.windowStatus === STATUS_EXHAUSTED ? 1 : args.usedFraction;
+	if (usedFraction === undefined) return undefined;
+	const totalCount = args.totalCount;
+	return {
+		id: `${args.bucket.modelName}:${args.windowId}`,
+		label: `${args.bucket.modelName.charAt(0).toUpperCase()}${args.bucket.modelName.slice(1)} ${args.windowLabel}`,
+		scope: {
+			provider: args.provider,
+			...(args.accountId ? { accountId: args.accountId } : {}),
+			...(args.bucket.modelName === SHARED_BUCKET ? { shared: true as const } : { modelId: args.bucket.modelName }),
+			windowId: args.windowId,
+		},
+		window: {
+			id: args.windowId,
+			label: args.windowLabel,
+			...(args.durationMs !== undefined && args.durationMs > 0 ? { durationMs: args.durationMs } : {}),
+			...(args.resetsAt ? { resetsAt: args.resetsAt } : {}),
+		},
+		amount: {
+			used: usedFraction * 100,
+			usedFraction,
+			remaining: 100 - usedFraction * 100,
+			remainingFraction: 1 - usedFraction,
+			unit: "percent",
+		},
+		status: usageStatus(usedFraction),
+		...(totalCount !== undefined && totalCount > 0
+			? { notes: [`Requests: ${args.usageCount ?? 0}/${totalCount}`] }
+			: {}),
+	};
+}
+
+function buildBucketLimits(provider: string, bucket: TokenPlanBucket, accountId: string | undefined): UsageLimit[] {
+	const intervalDuration =
+		bucket.intervalStart !== undefined && bucket.intervalEnd !== undefined
+			? bucket.intervalEnd - bucket.intervalStart
+			: undefined;
+	const weeklyDuration =
+		bucket.weeklyStart !== undefined && bucket.weeklyEnd !== undefined
+			? bucket.weeklyEnd - bucket.weeklyStart
+			: undefined;
+	const interval = intervalWindowId(intervalDuration);
+	return [
+		buildLimit({
+			provider,
+			bucket,
+			windowId: interval.id,
+			windowLabel: interval.label,
+			durationMs: intervalDuration,
+			resetsAt: bucket.intervalEnd,
+			usedFraction: usedFractionFromRemainingPercent(bucket.intervalRemainingPercent),
+			windowStatus: bucket.intervalStatus,
+			usageCount: bucket.intervalUsageCount,
+			totalCount: bucket.intervalTotalCount,
+			accountId,
+		}),
+		buildLimit({
+			provider,
+			bucket,
+			windowId: "7d",
+			windowLabel: "7 Day",
+			durationMs: weeklyDuration,
+			resetsAt: bucket.weeklyEnd,
+			usedFraction: usedFractionFromRemainingPercent(bucket.weeklyRemainingPercent),
+			windowStatus: bucket.weeklyStatus,
+			usageCount: bucket.weeklyUsageCount,
+			totalCount: bucket.weeklyTotalCount,
+			accountId,
+		}),
+	].filter((limit): limit is UsageLimit => limit !== undefined);
+}
+
+/**
+ * MiniMax Token Plan usage provider (international, `api.minimax.io`).
+ *
+ * `GET /v1/token_plan/remains` returns one `model_remains[]` bucket per plan
+ * quota (text, media, …), each carrying a rolling interval window and a weekly
+ * window with the remaining percentage. MiniMax answers HTTP 200 even for
+ * rejected credentials, so `base_resp.status_code` is the real success signal.
+ */
+async function fetchMiniMaxCodeUsage(params: UsageFetchParams, ctx: UsageFetchContext): Promise<UsageReport | null> {
+	if (params.provider !== INTL_PROVIDER) return null;
+	const apiKey = params.credential.apiKey;
+	if (params.credential.type !== "api_key" || !apiKey) return null;
+
+	try {
+		const configuredBaseUrl = params.baseUrl?.trim();
+		const baseUrl = configuredBaseUrl ? configuredBaseUrl.replace(/\/+$/, "").replace(/\/v1$/, "") : INTL_BASE_URL;
+		const response = await ctx.fetch(`${baseUrl}${REMAINS_PATH}`, {
+			headers: { Accept: "application/json", Authorization: `Bearer ${apiKey}` },
+			signal: params.signal,
+		});
+		if (!response.ok) {
+			ctx.logger?.warn("MiniMax Token Plan usage fetch failed", {
+				provider: params.provider,
+				status: response.status,
+			});
+			return null;
+		}
+		const payload: unknown = await response.json();
+		if (!isRecord(payload)) return null;
+		const statusCode = isRecord(payload.base_resp) ? toNumber(payload.base_resp.status_code) : undefined;
+		if (statusCode !== 0) {
+			ctx.logger?.warn("MiniMax Token Plan usage response rejected", {
+				provider: params.provider,
+				statusCode: statusCode ?? "missing",
+			});
+			return null;
+		}
+		if (!Array.isArray(payload.model_remains)) return null;
+
+		const accountId = params.credential.accountId;
+		const limits: UsageLimit[] = [];
+		const models: string[] = [];
+		const unavailableModels: string[] = [];
+		for (const entry of payload.model_remains) {
+			const bucket = parseBucket(entry);
+			if (!bucket) continue;
+			models.push(bucket.modelName);
+			if (isUnavailablePlan(bucket)) {
+				unavailableModels.push(bucket.modelName);
+				continue;
+			}
+			limits.push(...buildBucketLimits(params.provider, bucket, accountId));
+		}
+		if (limits.length === 0) return null;
+
+		return {
+			provider: params.provider,
+			fetchedAt: Date.now(),
+			limits,
+			metadata: {
+				source: "minimax-token-plan",
+				models,
+				...(unavailableModels.length > 0 ? { unavailableModels } : {}),
+				...(accountId ? { accountId } : {}),
+			},
+			raw: payload,
+		};
+	} catch (error) {
+		ctx.logger?.warn("MiniMax Token Plan usage request failed", {
+			provider: params.provider,
+			error: error instanceof Error ? error.name : "unknown",
+		});
+		return null;
+	}
+}
+
+/** MiniMax Token Plan (international, `api.minimax.io`). */
+export const minimaxCodeUsageProvider: UsageProvider = {
+	id: INTL_PROVIDER,
+	fetchUsage: fetchMiniMaxCodeUsage,
+	supports: params =>
+		params.provider === INTL_PROVIDER && params.credential.type === "api_key" && Boolean(params.credential.apiKey),
+};

package/src/usage/ollama.ts

@@ -0,0 +1,41 @@
+import type { UsageFetchContext, UsageFetchParams, UsageProvider, UsageReport } from "../usage";
+
+const OLLAMA_PROVIDER = "ollama";
+const OLLAMA_CLOUD_PROVIDER = "ollama-cloud";
+
+async function fetchOllamaUsage(params: UsageFetchParams, _ctx: UsageFetchContext): Promise<UsageReport | null> {
+	if (params.provider !== OLLAMA_PROVIDER && params.provider !== OLLAMA_CLOUD_PROVIDER) {
+		return null;
+	}
+
+	const metadata: Record<string, unknown> = {};
+	if (params.credential.email) metadata.email = params.credential.email;
+	if (params.credential.accountId) metadata.accountId = params.credential.accountId;
+	if (params.credential.projectId) metadata.projectId = params.credential.projectId;
+
+	return {
+		provider: params.provider,
+		fetchedAt: Date.now(),
+		limits: [],
+		notes: [
+			"Ollama does not expose a standalone quota usage API; per-response token usage is reported during requests.",
+		],
+		metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+	};
+}
+
+/** Registers Ollama accounts with usage views even though no quota endpoint is exposed. */
+export const ollamaUsageProvider: UsageProvider = {
+	id: OLLAMA_PROVIDER,
+	fetchUsage: fetchOllamaUsage,
+	supports: params => params.provider === OLLAMA_PROVIDER,
+	validatesCredentials: false,
+};
+
+/** Registers Ollama Cloud accounts with usage views until a quota endpoint is available. */
+export const ollamaCloudUsageProvider: UsageProvider = {
+	id: OLLAMA_CLOUD_PROVIDER,
+	fetchUsage: fetchOllamaUsage,
+	supports: params => params.provider === OLLAMA_CLOUD_PROVIDER,
+	validatesCredentials: false,
+};

package/src/usage/openai-codex-base-url.ts

@@ -0,0 +1,35 @@
+import { CODEX_BASE_URL } from "@linxiraos/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 trimmed = baseUrl?.trim().replace(/\/+$/, "");
+	if (!trimmed) return CODEX_BASE_URL;
+	let parsed: URL;
+	try {
+		parsed = new URL(trimmed);
+	} catch {
+		return CODEX_BASE_URL;
+	}
+	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`;
+}