jeopi-ai 16.2.13

package/src/usage/kimi.ts

@@ -0,0 +1,271 @@
+import { $env } from "jeopi-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 {
+	const window: UsageWindow | undefined =
+		row.window ??
+		(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,30 @@
+import type { UsageFetchContext, UsageFetchParams, UsageProvider, UsageReport } from "../usage";
+
+/**
+ * MiniMax Token Plan usage provider.
+ *
+ * MiniMax Token Plan is a subscription-based service with a rolling quota system.
+ *
+ * Currently, MiniMax does not expose a usage/quota API endpoint for the Token Plan.
+ * Usage is tracked via the web dashboard at https://platform.minimax.io/user-center/payment/token-plan
+ *
+ * This provider exists to register support for the minimax-code provider in the
+ * usage system. When MiniMax adds a usage API, this can be implemented.
+ */
+async function fetchMiniMaxCodeUsage(params: UsageFetchParams, _ctx: UsageFetchContext): Promise<UsageReport | null> {
+	if (params.provider !== "minimax-code" && params.provider !== "minimax-code-cn") {
+		return null;
+	}
+
+	// MiniMax Token Plan does not currently expose a usage API
+	// Users can check their usage via the web dashboard
+	return null;
+}
+
+export const minimaxCodeUsageProvider: UsageProvider = {
+	id: "minimax-code",
+	fetchUsage: fetchMiniMaxCodeUsage,
+	supports: (params: UsageFetchParams) =>
+		(params.provider === "minimax-code" || params.provider === "minimax-code-cn") &&
+		params.credential.type === "api_key",
+};

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 "jeopi-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`;
+}

package/src/usage/openai-codex-reset.ts

@@ -0,0 +1,174 @@
+/**
+ * OpenAI Codex "saved rate limit reset" redemption client.
+ *
+ * OpenAI lets paid Codex accounts bank a usage-window reset and spend it on
+ * demand (announced 2026-06-11). The count is surfaced on `/wham/usage` as
+ * `rate_limit_reset_credits.available_count` (see `./openai-codex.ts`), but the
+ * actual credit objects and the redeem action live on two dedicated routes:
+ *
+ *   GET  /wham/rate-limit-reset-credits           → list redeemable credits
+ *   POST /wham/rate-limit-reset-credits/consume   → spend one credit
+ *        body: { credit_id, redeem_request_id }
+ *
+ * `redeem_request_id` is a client-generated idempotency key (UUID). The consume
+ * response carries a `code`: `"reset"` on success, otherwise a business reason
+ * (`already_redeemed`, `no_credit`, `nothing_to_reset`).
+ *
+ * These are thin, dependency-light functions so both the interactive session
+ * (the `/usage reset` command + auto-redeem) and any out-of-band tooling can
+ * share one wire contract.
+ */
+import type { FetchImpl } from "../types";
+import { isRecord } from "../utils";
+import { normalizeCodexBaseUrl } from "./openai-codex-base-url";
+import { toNumber } from "./shared";
+
+const RESET_CREDITS_PATH = "wham/rate-limit-reset-credits";
+const RESET_CREDITS_CONSUME_PATH = "wham/rate-limit-reset-credits/consume";
+
+/** A single redeemable (or already-spent) saved reset. */
+export interface CodexResetCredit {
+	/** Opaque credit id, e.g. `RateLimitResetCredit_…`. Pass to {@link consumeCodexResetCredit}. */
+	id: string;
+	/** Backend reset family, e.g. `codex_rate_limits`. */
+	resetType?: string;
+	/** `available`, `redeemed`, … */
+	status?: string;
+	grantedAt?: string;
+	expiresAt?: string;
+	redeemStartedAt?: string | null;
+	redeemedAt?: string | null;
+	/** Human-facing card title, e.g. "One free rate limit reset". */
+	title?: string;
+	description?: string;
+}
+
+/** Result of listing an account's saved resets. */
+export interface CodexResetCreditList {
+	credits: CodexResetCredit[];
+	/** Backend-reported count of credits redeemable right now. */
+	availableCount: number;
+}
+
+/**
+ * Consume outcome `code`. `reset` means a window was actually reset; the others
+ * are no-op business outcomes the caller should surface verbatim-ish to the user.
+ */
+export type CodexResetConsumeCode =
+	| "reset"
+	| "already_redeemed"
+	| "no_credit"
+	| "nothing_to_reset"
+	// Forward-compatible: unknown future codes pass through.
+	| (string & {});
+
+export interface CodexResetConsumeResult {
+	/** `true` only when `code === "reset"` (a reset was applied). */
+	ok: boolean;
+	code: CodexResetConsumeCode;
+	/** HTTP status of the consume call (for diagnostics). */
+	status: number;
+	raw?: unknown;
+}
+
+interface CodexResetAuth {
+	accessToken: string;
+	accountId?: string;
+	/** Provider base URL override; defaults to the Codex backend. */
+	baseUrl?: string;
+	fetch: FetchImpl;
+	signal?: AbortSignal;
+}
+
+function buildUrl(baseUrl: string | undefined, routePath: string): string {
+	const base = normalizeCodexBaseUrl(baseUrl);
+	const normalized = base.endsWith("/") ? base : `${base}/`;
+	return `${normalized}${routePath}`;
+}
+
+function buildHeaders(auth: CodexResetAuth, json: boolean): Record<string, string> {
+	const headers: Record<string, string> = {
+		Authorization: `Bearer ${auth.accessToken}`,
+		"User-Agent": "OpenCode-Status-Plugin/1.0",
+	};
+	if (auth.accountId) headers["ChatGPT-Account-Id"] = auth.accountId;
+	if (json) headers["Content-Type"] = "application/json";
+	return headers;
+}
+
+function parseCredit(value: unknown): CodexResetCredit | null {
+	if (!isRecord(value)) return null;
+	const id = typeof value.id === "string" ? value.id : undefined;
+	if (!id) return null;
+	const str = (key: string): string | undefined =>
+		typeof value[key] === "string" ? (value[key] as string) : undefined;
+	const nullableStr = (key: string): string | null | undefined => {
+		const raw = value[key];
+		if (raw === null) return null;
+		return typeof raw === "string" ? raw : undefined;
+	};
+	return {
+		id,
+		resetType: str("reset_type"),
+		status: str("status"),
+		grantedAt: str("granted_at"),
+		expiresAt: str("expires_at"),
+		redeemStartedAt: nullableStr("redeem_started_at"),
+		redeemedAt: nullableStr("redeemed_at"),
+		title: str("title"),
+		description: str("description"),
+	};
+}
+
+/**
+ * List the account's saved rate-limit resets. Returns `null` on transport/auth
+ * failure (non-2xx or thrown), letting callers treat it the same as "no data".
+ */
+export async function listCodexResetCredits(auth: CodexResetAuth): Promise<CodexResetCreditList | null> {
+	const url = buildUrl(auth.baseUrl, RESET_CREDITS_PATH);
+	let payload: unknown;
+	try {
+		const response = await auth.fetch(url, { headers: buildHeaders(auth, false), signal: auth.signal });
+		if (!response.ok) return null;
+		payload = await response.json();
+	} catch {
+		return null;
+	}
+	if (!isRecord(payload)) return null;
+	const credits = Array.isArray(payload.credits)
+		? payload.credits.map(parseCredit).filter((c): c is CodexResetCredit => c !== null)
+		: [];
+	const reported = toNumber(payload.available_count);
+	const availableCount =
+		reported !== undefined
+			? Math.max(0, Math.trunc(reported))
+			: credits.filter(c => (c.status ?? "available") === "available").length;
+	return { credits, availableCount };
+}
+
+/**
+ * Spend one saved reset. `redeemRequestId` is the idempotency key; one is
+ * generated when omitted, so retrying with the SAME id is safe and won't
+ * double-spend. The returned `code` is `"reset"` on success.
+ */
+export async function consumeCodexResetCredit(
+	auth: CodexResetAuth & { creditId: string; redeemRequestId?: string },
+): Promise<CodexResetConsumeResult> {
+	const redeemRequestId = auth.redeemRequestId ?? crypto.randomUUID();
+	const url = buildUrl(auth.baseUrl, RESET_CREDITS_CONSUME_PATH);
+	const response = await auth.fetch(url, {
+		method: "POST",
+		headers: buildHeaders(auth, true),
+		body: JSON.stringify({ credit_id: auth.creditId, redeem_request_id: redeemRequestId }),
+		signal: auth.signal,
+	});
+	let body: unknown;
+	try {
+		body = await response.json();
+	} catch {
+		body = undefined;
+	}
+	const code =
+		isRecord(body) && typeof body.code === "string" ? body.code : response.ok ? "reset" : `http_${response.status}`;
+	return { ok: code === "reset", code, status: response.status, raw: body };
+}