@buyi1net/pi-toolkit 0.0.1

package/modules/tui/kernel/pkg/shared/zhipu.ts

@@ -0,0 +1,149 @@
+// 智谱取数与解析。端点细节来自两个已核验来源（见 docs/共享能力/供应商余额与订阅查询适配指南.md）：
+// - Coding Plan 额度：cc-switch src-tauri/src/services/coding_plan.rs:313-380
+//   裸 key 鉴权（不加 Bearer）；percentage 是已用百分比；type 兼容 TOKENS_LIMIT/CREDIT_LIMIT；
+//   窗口只认 unit（3=5h，6=周），不能用 reset 时间排序（官方 issue #3036 会标反）
+// - API 余额：cc-toolkit src/usage-query/custom/Zhipu-GLM/index.js（Bearer 鉴权，code!=200 视为失败）
+
+import type { QuotaInfo, QuotaWindow } from './provider-contracts.ts';
+
+export interface ZhipuLimit {
+  type?: string;
+  unit?: number;
+  number?: number;
+  percentage?: number;
+  nextResetTime?: number;
+}
+
+/** 额度响应 → QuotaInfo。解析失败返回 null（上层收起行 3） */
+export function parseZhipuQuota(json: any): QuotaInfo | null {
+  const limits: ZhipuLimit[] = json?.data?.limits;
+  if (!Array.isArray(limits) || limits.length === 0) return null;
+
+  const valid = limits.filter((l) => {
+    const t = (l.type ?? '').toUpperCase();
+    return t === 'TOKENS_LIMIT' || t === 'CREDIT_LIMIT';
+  });
+  if (valid.length === 0) return null;
+
+  const toWindow = (label: string, l: ZhipuLimit | null): QuotaWindow | null => {
+    if (!l || typeof l.percentage !== 'number') return null;
+    return {
+      label,
+      remainingPercent: Math.max(0, Math.min(100, 100 - l.percentage)),
+      resetMs: typeof l.nextResetTime === 'number' ? l.nextResetTime : null,
+    };
+  };
+
+  let w5 = valid.find((l) => l.unit === 3) ?? null;
+  let w7 = valid.find((l) => l.unit === 6) ?? null;
+
+  // unit 缺失的老套餐兜底：单条视为 5h；多条按「无 reset 归 5h，其余 reset 升序填空」
+  if (!w5 && !w7) {
+    if (valid.length === 1) {
+      w5 = valid[0];
+    } else {
+      const sorted = [...valid].sort((a, b) => (a.nextResetTime ?? 0) - (b.nextResetTime ?? 0));
+      w5 = sorted.find((l) => l.nextResetTime == null) ?? sorted[0];
+      w7 = sorted.filter((l) => l !== w5)[0] ?? null;
+    }
+  }
+
+  const windows = [toWindow('5h', w5), toWindow('7d', w7)].filter(
+    (window): window is QuotaWindow => window != null,
+  );
+  return windows.length > 0 ? { provider: 'zhipu', windows } : null;
+}
+
+/** 余额响应 → 数值。失败返回 null */
+export function parseZhipuBalance(json: any): number | null {
+  if (json?.code !== 200 || typeof json?.data?.balance !== 'number') return null;
+  return json.data.balance;
+}
+
+/** host 路由（借 cc-switch zhipu_quota_base 规则）：bigmodel.cn → 国内站，api.z.ai → 国际站 */
+export function zhipuHost(baseUrl: string): string {
+  try {
+    const hostname = new URL(baseUrl).hostname;
+    if (hostname === 'bigmodel.cn' || hostname.endsWith('.bigmodel.cn')) return 'https://open.bigmodel.cn';
+  } catch {
+    /* 无效地址不走国内站 */
+  }
+  return 'https://api.z.ai';
+}
+
+export async function fetchZhipuQuota(
+  baseUrl: string,
+  apiKey: string,
+  request: typeof fetch = fetch,
+): Promise<QuotaInfo | null> {
+  const url = `${zhipuHost(baseUrl)}/api/monitor/usage/quota/limit`;
+  const res = await request(url, {
+    headers: {
+      Authorization: apiKey, // 裸 key：智谱监控端点不带 Bearer 前缀
+      'Content-Type': 'application/json',
+      'Accept-Language': 'en-US,en',
+    },
+    signal: AbortSignal.timeout(15_000),
+  });
+  if (!res.ok) return null;
+  const quota = parseZhipuQuota(await res.json().catch(() => null));
+  return quota && zhipuHost(baseUrl) === 'https://api.z.ai' ? { ...quota, provider: 'z.ai' } : quota;
+}
+
+/** 智谱团队套餐：固定国内站，type=2，并附加组织/项目头。 */
+export async function fetchZhipuTeamQuota(
+  apiKey: string,
+  organizationId: string,
+  projectId: string,
+  request: typeof fetch = fetch,
+): Promise<QuotaInfo | null> {
+  if (!apiKey || !organizationId || !projectId) return null;
+  const res = await request('https://open.bigmodel.cn/api/monitor/usage/quota/limit?type=2', {
+    headers: {
+      Authorization: apiKey,
+      'bigmodel-organization': organizationId,
+      'bigmodel-project': projectId,
+      'Content-Type': 'application/json',
+      'Accept-Language': 'en-US,en',
+    },
+    signal: AbortSignal.timeout(15_000),
+  });
+  if (!res.ok) return null;
+  return parseZhipuQuota(await res.json().catch(() => null));
+}
+
+export async function fetchZhipuBalance(apiKey: string, request: typeof fetch = fetch): Promise<number | null> {
+  const res = await request('https://bigmodel.cn/api/biz/account/query-customer-account-report', {
+    headers: { Authorization: `Bearer ${apiKey}` },
+    signal: AbortSignal.timeout(15_000),
+  });
+  if (!res.ok) return null;
+  return parseZhipuBalance(await res.json().catch(() => null));
+}
+
+export interface DeepSeekBalance {
+  amount: number;
+  currency: 'CNY' | 'USD';
+}
+
+export function parseDeepSeekBalance(json: any): DeepSeekBalance | null {
+  const infos = json?.balance_infos;
+  if (!Array.isArray(infos) || infos.length === 0) return null;
+  const pick = infos.find((i: any) => i?.currency === 'CNY') ?? infos[0];
+  const amount = Number(pick?.total_balance);
+  if (!Number.isFinite(amount)) return null;
+  return { amount, currency: pick?.currency === 'USD' ? 'USD' : 'CNY' };
+}
+
+/** DeepSeek 余额：官方 GET /user/balance，balance_infos[] 多币种行，状态栏优先显示主账户常用的 CNY 行。 */
+export async function fetchDeepSeekBalance(
+  apiKey: string,
+  request: typeof fetch = fetch,
+): Promise<DeepSeekBalance | null> {
+  const res = await request('https://api.deepseek.com/user/balance', {
+    headers: { Authorization: `Bearer ${apiKey}` },
+    signal: AbortSignal.timeout(15_000),
+  });
+  if (!res.ok) return null;
+  return parseDeepSeekBalance(await res.json().catch(() => null));
+}

package/modules/tui/kernel/pkg/usage-core/index.ts

@@ -0,0 +1,335 @@
+import {
+	CC_SWITCH_CLAUDE_PRESET_COUNT,
+	findProviderById,
+	findProviderByUrl,
+	OFFICIAL_PROVIDERS,
+	PROVIDER_BRANDS,
+	PROVIDER_CATALOG,
+	RELAY_PROVIDERS,
+} from "../shared/provider-catalog.ts";
+import {
+	displayProviderName,
+	inferModelProviderName,
+} from "../shared/provider-display.ts";
+
+// 供应商目录与品牌展示是共享领域层公开词汇，宿主不得深路径直连 shared 内部模块。
+export {
+	CC_SWITCH_CLAUDE_PRESET_COUNT,
+	findProviderById,
+	findProviderByUrl,
+	OFFICIAL_PROVIDERS,
+	PROVIDER_BRANDS,
+	PROVIDER_CATALOG,
+	RELAY_PROVIDERS,
+	displayProviderName,
+	inferModelProviderName,
+};
+import type {
+	BillingMode as SharedBillingMode,
+	ProviderCredentials,
+	ProviderQueryConfig,
+	QuotaWindow as SharedQuotaWindow,
+} from "../shared/provider-contracts.ts";
+
+export {
+	parseProviderCredentials,
+	parseProviderQueries,
+	ProviderConfigValidationError,
+} from "../shared/provider-contracts.ts";
+export type {
+	BalanceValue,
+	ProviderCredentials,
+	ProviderQueryConfig,
+	QuotaInfo,
+	RelayQueryProtocol,
+} from "../shared/provider-contracts.ts";
+
+export type BillingMode = SharedBillingMode;
+export type UsageFreshness = "fresh" | "stale";
+
+export interface ProviderIdentity {
+	providerId: string;
+	endpoint: string;
+	accountFingerprint: string;
+}
+
+export interface ProviderAccess {
+	identity: ProviderIdentity;
+	credential: string;
+	options?: ProviderAccessOptions;
+}
+
+export type ProviderQueryAccess = ProviderQueryConfig;
+
+export interface ProviderAccessOptions {
+	modelId?: string;
+	authKind?: "api-key" | "oauth";
+	accountId?: string;
+	githubDomain?: string;
+	query?: ProviderQueryAccess | null;
+	credentials?: ProviderCredentials;
+}
+
+export interface Balance {
+	amount: number;
+	currency: "CNY" | "USD";
+}
+
+export type QuotaWindow = SharedQuotaWindow;
+
+export interface UsageSnapshot {
+	provider: {
+		id: string;
+		brandName: string;
+	};
+	billingMode: BillingMode;
+	balance: Balance | null;
+	windows: QuotaWindow[];
+	fetchedAt: number;
+	freshness: UsageFreshness;
+}
+
+export interface NormalizedUsageInput {
+	providerId: string;
+	brandName?: string;
+	billingMode: Exclude<BillingMode, "unknown">;
+	balance?: Balance;
+	windows?: readonly QuotaWindow[];
+	fetchedAt?: number;
+}
+
+export function normalizeEndpoint(endpoint: string): string {
+	const raw = endpoint.trim();
+	if (!raw) return "";
+	try {
+		const url = new URL(raw);
+		const path = url.pathname.replace(/\/+$/, "");
+		return `${url.protocol.toLowerCase()}//${url.host.toLowerCase()}${path}`;
+	} catch {
+		return raw.toLowerCase().replace(/\/+$/, "");
+	}
+}
+
+export function resolveProviderMetadata(
+	endpoint: string,
+	providerHint = "",
+	modelId = "",
+): { providerId: string; brandName: string } {
+	const normalizedEndpoint = normalizeEndpoint(endpoint);
+	const catalog =
+		(normalizedEndpoint ? findProviderByUrl(normalizedEndpoint) : undefined) ??
+		(providerHint ? findProviderById(providerHint) : undefined);
+	const inferredProviderId = !catalog ? inferModelProviderName(modelId) : undefined;
+	const providerId = catalog?.brandId ?? inferredProviderId ?? (providerHint.trim() || "unknown");
+	return {
+		providerId,
+		brandName: catalog?.displayName ?? (inferredProviderId ? displayProviderName(providerId) : ""),
+	};
+}
+
+function clampPercent(value: number): number {
+	return Math.max(0, Math.min(100, value));
+}
+
+export const MAX_QUOTA_WINDOW_LABEL_LENGTH = 24;
+
+export function sanitizeQuotaWindowLabel(label: unknown): string {
+	const safe = String(label ?? "")
+		.replace(/(?:\x1b[\]PX^_]|[\u0090\u009d\u009e\u009f])[\s\S]*?(?:\x07|\x1b\\|\u009c)/g, "")
+		.replace(/(?:\x1b[\]PX^_]|[\u0090\u009d\u009e\u009f])[\s\S]*$/g, "")
+		.replace(/(?:\x1b\[|\u009b)[0-?]*[ -\/]*[@-~]/g, "")
+		.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ")
+		.replace(/\s+/g, " ")
+		.trim();
+	return [...(safe || "Quota")].slice(0, MAX_QUOTA_WINDOW_LABEL_LENGTH).join("");
+}
+
+export function normalizeUsageSnapshot(input: NormalizedUsageInput): UsageSnapshot {
+	return {
+		provider: {
+			id: input.providerId,
+			brandName: input.brandName ?? displayProviderName(input.providerId),
+		},
+		billingMode: input.billingMode,
+		balance: input.balance ?? null,
+		windows: (input.windows ?? []).map((window) => ({
+			label: sanitizeQuotaWindowLabel(window.label),
+			remainingPercent: clampPercent(window.remainingPercent),
+			resetMs: window.resetMs,
+		})),
+		fetchedAt: input.fetchedAt ?? Date.now(),
+		freshness: "fresh",
+	};
+}
+
+export function markUsageSnapshotStale(snapshot: UsageSnapshot): UsageSnapshot {
+	return snapshot.freshness === "stale" ? snapshot : { ...snapshot, freshness: "stale" };
+}
+
+// —— 刷新状态机与缓存时效判定（零 IO 纯函数；文件读写由查询运行层承担） ——
+
+export interface CacheEntry<T> {
+	ts: number;
+	value: T;
+}
+
+/** 缓存条目是否超过 TTL；缺失视为过期。 */
+export function isCacheStale<T>(entry: CacheEntry<T> | null, ttlMs: number, now = Date.now()): boolean {
+	return !entry || now - entry.ts > ttlMs;
+}
+
+export interface SourceIdentity {
+	providerKey: string;
+}
+
+export interface SourceState extends SourceIdentity {
+	status: "pending" | "backoff" | "ready";
+	/** 最近一次启动刷新进程的时间，用于失败退避 */
+	attemptTs: number;
+}
+
+export interface SourceRefreshPlan {
+	/** 当前缓存是否属于当前供应商，可以用于布局 */
+	usable: boolean;
+	/** 本轮是否启动一次旁路刷新 */
+	refresh: boolean;
+	/** 需要先落盘的新状态；null 表示状态不变 */
+	nextState: SourceState | null;
+}
+
+export const SOURCE_RETRY_MS = 30_000;
+
+export function usageRetryDue(retryAfter: number, now: number): boolean {
+	return !(retryAfter > now);
+}
+
+export function isLastGoodUsable(
+	fetchedAt: number | null,
+	keepLastGoodMs: number,
+	now: number,
+): boolean {
+	return fetchedAt !== null && now - fetchedAt <= keepLastGoodMs;
+}
+
+export interface UsageFailurePlan {
+	status: "stale" | "error";
+	retryAfter: number;
+}
+
+export function planUsageFailure(
+	lastGoodAt: number | null,
+	keepLastGoodMs: number,
+	retryMs: number,
+	now: number,
+): UsageFailurePlan {
+	return {
+		status: isLastGoodUsable(lastGoodAt, keepLastGoodMs, now) ? "stale" : "error",
+		retryAfter: now + retryMs,
+	};
+}
+
+export interface ScopedSnapshots {
+	[scopeKey: string]: string;
+}
+
+export type ModelSnapshots = ScopedSnapshots;
+
+function recordScopedValue(
+	cached: ScopedSnapshots,
+	scopeKey: string,
+	valueKey: string,
+	maxEntries: number,
+): { changed: boolean; value: ScopedSnapshots } {
+	if (cached[scopeKey] === valueKey) return { changed: false, value: cached };
+	const value = { ...cached };
+	delete value[scopeKey];
+	value[scopeKey] = valueKey;
+	const keys = Object.keys(value);
+	for (const key of keys.slice(0, Math.max(0, keys.length - maxEntries))) delete value[key];
+	return { changed: true, value };
+}
+
+/** 按会话记录模型，避免多个并行会话使用不同模型时互相触发变化。 */
+export function recordModel(
+	cached: ModelSnapshots,
+	scopeKey: string,
+	modelKey: string,
+	maxEntries = 20,
+): { changed: boolean; value: ModelSnapshots } {
+	return recordScopedValue(cached, scopeKey, modelKey, maxEntries);
+}
+
+/** 宿主提供稳定事件键；同一会话的同一轮结束只触发一次刷新。 */
+export function recordRefreshEvent(
+	cached: ScopedSnapshots,
+	scopeKey: string,
+	eventKey: string | null,
+	maxEntries = 20,
+): { changed: boolean; value: ScopedSnapshots } {
+	return eventKey ? recordScopedValue(cached, scopeKey, eventKey, maxEntries) : { changed: false, value: cached };
+}
+
+/** 按计费模式判断当前所需的余额或订阅额度缓存是否超龄。 */
+export function usageRefreshDue(
+	mode: BillingMode | null,
+	quotaStale: boolean,
+	balanceStale: boolean,
+): boolean {
+	if (!mode) return true;
+	return (
+		((mode === "subscription" || mode === "hybrid") && quotaStale) ||
+		((mode === "api" || mode === "hybrid") && balanceStale)
+	);
+}
+
+function matches(current: SourceIdentity, cached: SourceState): boolean {
+	return current.providerKey === cached.providerKey;
+}
+
+/**
+ * 数据源变化时立刻隔离旧缓存；同一数据源的 TTL 过期只后台更新，继续显示旧值。
+ * pending 会每秒尝试抢刷新锁；只有实际请求失败进入 backoff 后才按 retryMs 退避。
+ */
+export function planSourceRefresh(
+	current: SourceIdentity,
+	cached: SourceState | null,
+	dataStale: boolean,
+	now = Date.now(),
+	retryMs = SOURCE_RETRY_MS,
+	forceRefresh = false,
+): SourceRefreshPlan {
+	if (
+		!cached ||
+		!matches(current, cached) ||
+		(cached.status !== "pending" && cached.status !== "backoff" && cached.status !== "ready")
+	) {
+		return {
+			usable: false,
+			refresh: true,
+			nextState: { ...current, status: "pending", attemptTs: now },
+		};
+	}
+
+	const retryDue = !Number.isFinite(cached.attemptTs) || usageRetryDue(cached.attemptTs + retryMs, now);
+	if (cached.status === "pending") {
+		return { usable: false, refresh: true, nextState: null };
+	}
+
+	if (cached.status === "backoff") {
+		return {
+			usable: false,
+			refresh: retryDue,
+			nextState: retryDue ? { ...cached, status: "pending", attemptTs: now } : null,
+		};
+	}
+
+	if (dataStale && (forceRefresh || retryDue)) {
+		return {
+			usable: true,
+			refresh: true,
+			nextState: { ...cached, attemptTs: now },
+		};
+	}
+
+	return { usable: true, refresh: false, nextState: null };
+}

package/modules/tui/kernel/pkg/usage-core/provider-routes.ts

@@ -0,0 +1,187 @@
+// 声明式供应商查询路由表：每家供应商一条记录，新增供应商只需加一行。
+// 表内只放数据：解析器与专用连接器以字符串标识登记在查询运行层（usage-node），
+// 本文件因此保持零 IO，安全归属共享领域层。
+
+import type { BuiltinQueryKind } from "../shared/provider-catalog.ts";
+
+/** 查询步骤可依赖的凭据来源；任一缺失时该步骤被跳过，不发请求。 */
+export type CredentialSource =
+	| "token"
+	| "openrouter-management"
+	| "volcengine-aksk"
+	| "zhipu-team";
+
+/** 步骤执行条件；不满足时跳过该步骤（与凭据缺失同样视为不可执行）。 */
+export interface StepCondition {
+	/** baseUrl 的主机名不等于该值时才执行。 */
+	hostNot?: string;
+}
+
+interface RouteStepBase {
+	onlyWhen?: StepCondition;
+}
+
+/** 简单 JSON 查询步骤：运行层按声明构造请求，把响应交给绑定解析器。 */
+export interface JsonQueryStep extends RouteStepBase {
+	type: "json";
+	/** 固定端点，或取 baseUrl 的 origin 拼接路径。 */
+	url: { fixed: string } | { originPath: string };
+	/** Bearer 鉴权使用的凭据来源；为空时跳过该步骤。 */
+	credential: "token" | "openrouter-management";
+	/** 响应解析器标识；具体实现登记在查询运行层。 */
+	parser: JsonParserId;
+}
+
+/** 专用连接器步骤：OAuth 订阅、HMAC 签名、gRPC 等复杂协议由运行层连接器执行。 */
+export interface ConnectorStep extends RouteStepBase {
+	type: "connector";
+	/** 连接器标识；具体实现登记在查询运行层。 */
+	connector: ConnectorId;
+	/** 全部就绪才执行该步骤的凭据来源。 */
+	requires?: readonly CredentialSource[];
+}
+
+export type ProviderRouteStep = JsonQueryStep | ConnectorStep;
+
+export interface ProviderRouteRecord {
+	kind: BuiltinQueryKind;
+	/** 依次尝试的回退链：前一步成功即返回，全部失败返回 null。 */
+	steps: readonly ProviderRouteStep[];
+}
+
+/** 简单 JSON 端点的解析器标识；登记处见 usage-node/provider-usage.ts。 */
+export type JsonParserId =
+	| "stepfun-balance"
+	| "siliconflow-balance"
+	| "openrouter-balance"
+	| "novita-balance"
+	| "kimi-balance"
+	| "kimi-quota"
+	| "minimax-quota"
+	| "sub2api-usage";
+
+/** 专用协议连接器标识；登记处见 usage-node/provider-usage.ts。 */
+export type ConnectorId =
+	| "claude-subscription"
+	| "codex-subscription"
+	| "gemini-subscription"
+	| "copilot-subscription"
+	| "grok-subscription"
+	| "zhipu-quota"
+	| "zhipu-balance"
+	| "deepseek-balance"
+	| "volcengine-quota";
+
+export const PROVIDER_ROUTES: readonly ProviderRouteRecord[] = [
+	{
+		kind: "claude-subscription",
+		steps: [{ type: "connector", connector: "claude-subscription", requires: ["token"] }],
+	},
+	{
+		kind: "codex-subscription",
+		steps: [{ type: "connector", connector: "codex-subscription", requires: ["token"] }],
+	},
+	{
+		kind: "gemini-subscription",
+		steps: [{ type: "connector", connector: "gemini-subscription", requires: ["token"] }],
+	},
+	{
+		kind: "copilot-subscription",
+		steps: [{ type: "connector", connector: "copilot-subscription", requires: ["token"] }],
+	},
+	{
+		kind: "grok-subscription",
+		steps: [{ type: "connector", connector: "grok-subscription", requires: ["token"] }],
+	},
+	{
+		kind: "zhipu",
+		steps: [
+			{ type: "connector", connector: "zhipu-quota", requires: ["token"] },
+			// 国际站没有已确认的余额接口；不能把国际站 Key 发送到国内 bigmodel.cn
+			{ type: "connector", connector: "zhipu-balance", requires: ["token"], onlyWhen: { hostNot: "api.z.ai" } },
+		],
+	},
+	{
+		kind: "kimi-api",
+		steps: [
+			{ type: "json", url: { originPath: "/v1/users/me/balance" }, credential: "token", parser: "kimi-balance" },
+		],
+	},
+	{
+		kind: "kimi-coding",
+		steps: [
+			// Kimi Code 与开放平台是两套计费产品：套餐接口返回有效窗口即展示订阅，
+			// 失败时同一 Key 仍可能有普通余额，依次尝试开放平台余额接口。
+			{ type: "json", url: { fixed: "https://api.kimi.com/coding/v1/usages" }, credential: "token", parser: "kimi-quota" },
+			{ type: "json", url: { fixed: "https://api.moonshot.cn/v1/users/me/balance" }, credential: "token", parser: "kimi-balance" },
+		],
+	},
+	{
+		kind: "minimax-cn",
+		steps: [
+			// Token Plan 新接口优先；保留旧 Coding Plan 路径兼容仍使用旧版接口的账户
+			{ type: "json", url: { fixed: "https://www.minimaxi.com/v1/token_plan/remains" }, credential: "token", parser: "minimax-quota" },
+			{ type: "json", url: { fixed: "https://api.minimaxi.com/v1/api/openplatform/coding_plan/remains" }, credential: "token", parser: "minimax-quota" },
+		],
+	},
+	{
+		kind: "minimax-en",
+		steps: [
+			{ type: "json", url: { fixed: "https://www.minimax.io/v1/token_plan/remains" }, credential: "token", parser: "minimax-quota" },
+			{ type: "json", url: { fixed: "https://api.minimax.io/v1/api/openplatform/coding_plan/remains" }, credential: "token", parser: "minimax-quota" },
+		],
+	},
+	{
+		kind: "deepseek",
+		steps: [{ type: "connector", connector: "deepseek-balance", requires: ["token"] }],
+	},
+	{
+		kind: "stepfun",
+		steps: [
+			{ type: "json", url: { fixed: "https://api.stepfun.com/v1/accounts" }, credential: "token", parser: "stepfun-balance" },
+		],
+	},
+	{
+		kind: "siliconflow-cn",
+		steps: [
+			{ type: "json", url: { fixed: "https://api.siliconflow.cn/v1/user/info" }, credential: "token", parser: "siliconflow-balance" },
+		],
+	},
+	{
+		kind: "siliconflow-en",
+		steps: [
+			{ type: "json", url: { fixed: "https://api.siliconflow.com/v1/user/info" }, credential: "token", parser: "siliconflow-balance" },
+		],
+	},
+	{
+		kind: "openrouter",
+		steps: [
+			// 余额只使用独立 Management Key，不复用推理 Key
+			{ type: "json", url: { fixed: "https://openrouter.ai/api/v1/credits" }, credential: "openrouter-management", parser: "openrouter-balance" },
+		],
+	},
+	{
+		kind: "novita",
+		steps: [
+			{ type: "json", url: { fixed: "https://api.novita.ai/openapi/v1/billing/balance/detail" }, credential: "token", parser: "novita-balance" },
+		],
+	},
+	{
+		kind: "sub2api",
+		steps: [
+			{ type: "json", url: { originPath: "/v1/usage" }, credential: "token", parser: "sub2api-usage" },
+		],
+	},
+	{
+		kind: "volcengine-agent",
+		steps: [{ type: "connector", connector: "volcengine-quota", requires: ["volcengine-aksk"] }],
+	},
+	{
+		kind: "volcengine-coding",
+		steps: [{ type: "connector", connector: "volcengine-quota", requires: ["volcengine-aksk"] }],
+	},
+];
+
+export function findProviderRoute(kind: string): ProviderRouteRecord | null {
+	return PROVIDER_ROUTES.find((route) => route.kind === kind) ?? null;
+}