@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
1,568 lines • 75.1 kB
text/typescript
import { resolveProviderApiKey } from "../key-store";
import { getProviderRegistryEntry, registryEntryForProviderDestination } from "../registry";
import { isCanonicalOllamaCloudUrl } from "../../adapters/ollama-native-url";
import { providerEgressFetchInit, resolveProviderEgress } from "../../lib/provider-egress";
import { configuredOutboundFetch } from "../../lib/proxy-env";
import { QUOTA_JSON_READ_FAILURE, asRecord, normalizePercent, normalizeResetAt, readQuotaJson, REQUEST_TIMEOUT_MS, toFiniteNumber } from "../quota-wire";
import {
AUTHORITATIVE_EMPTY_QUOTA,
hasQuotaRows,
keyReport,
report,
TERMINAL_QUOTA_FAILURE,
type ProviderQuotaProbeResult,
type ProviderQuotaReport,
} from "./report-cache";
import { getTokenForAccountQuotaProbe } from "./account-cache";
import type { AccountQuotaMode, ProviderQuota, ProviderQuotaCreditsUsd } from "../quota-types";
import { markDisplayOnlyQuota } from "../quota-types";
import type { OcxProviderConfig } from "../../types";
// A quota probe must use the provider's inference route so it neither reports a false healthy path nor leaks a key through another exit.
async function quotaFetch(providerName: string, config: OcxProviderConfig, url: string, init: RequestInit): Promise<Response> {
const egress = resolveProviderEgress({ providerName, provider: config, url });
return configuredOutboundFetch(url, { ...init, ...providerEgressFetchInit(egress) });
}
const KIMI_CODE_BASE_URL = "https://api.kimi.com/coding/v1";
/**
* Kimi's regional (kimi.ai) Coding API. Its `/usages` answers a Coding Plan API key the same way
* the kimi.com origin does (#8332). Only key auth may use it: the probe then calls the origin that
* already receives this key for inference, so it adds no credential destination. OAuth tokens
* stay on the kimi.com origin they were issued for.
*/
const KIMI_CODE_REGIONAL_BASE_URL = "https://api.kimi.ai/coding/v1";
const COMMAND_CODE_BASE_URL = "https://api.commandcode.ai";
const COMMAND_CODE_WHOAMI_URL = `${COMMAND_CODE_BASE_URL}/alpha/whoami`;
const COMMAND_CODE_CREDITS_URL = `${COMMAND_CODE_BASE_URL}/alpha/billing/credits`;
const COMMAND_CODE_SUBSCRIPTIONS_URL = `${COMMAND_CODE_BASE_URL}/alpha/billing/subscriptions`;
const COMMAND_CODE_USAGE_URL = `${COMMAND_CODE_BASE_URL}/alpha/usage/summary`;
const A6API_BASE_URL = "https://api.a6api.com";
const OPENCODE_GO_BASE_URL = "https://opencode.ai/zen/go/v1";
const OPENCODE_GO_USAGE_URL = `${OPENCODE_GO_BASE_URL}/usage`;
const OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
const DEEPSEEK_BASE_URL = "https://api.deepseek.com";
const MISTRAL_BASE_URL = "https://api.mistral.ai";
const CLINE_BASE_URL = "https://api.cline.bot";
const OLLAMA_CLOUD_BASE_URL = "https://ollama.com";
const OLLAMA_CLOUD_USAGE_URL = `${OLLAMA_CLOUD_BASE_URL}/api/usage`;
const OLLAMA_CLOUD_BALANCE_URL = `${OLLAMA_CLOUD_BASE_URL}/api/balance`;
const ZAI_BASE_URL = "https://api.z.ai";
const ZAI_CN_BASE_URL = "https://open.bigmodel.cn";
const MINIMAX_REMAINS_PATH = "/v1/api/openplatform/coding_plan/remains";
const MOONSHOT_BASE_URL = "https://api.moonshot.ai/v1";
const VENICE_BASE_URL = "https://api.venice.ai/api/v1";
const SYNTHETIC_BASE_URL = "https://api.synthetic.new/v2";
const DEEPINFRA_BASE_URL = "https://api.deepinfra.com";
const NEURALWATT_BASE_URL = "https://api.neuralwatt.com/v1";
const ABLITERATION_BASE_URL = "https://api.abliteration.ai";
const ABLITERATION_CREDITS_URL = `${ABLITERATION_BASE_URL}/v1/credits`;
function isCanonicalA6apiBaseUrl(baseUrl: string): boolean {
const normalized = normalizedBaseUrl(baseUrl);
return normalized === A6API_BASE_URL || normalized === `${A6API_BASE_URL}/v1`;
}
function isCanonicalOpenCodeGoBaseUrl(baseUrl: string): boolean {
return normalizedBaseUrl(baseUrl) === OPENCODE_GO_BASE_URL;
}
function isCanonicalOpenRouterBaseUrl(baseUrl: string): boolean {
const normalized = normalizedBaseUrl(baseUrl);
return normalized === OPENROUTER_BASE_URL;
}
function isCanonicalDeepSeekBaseUrl(baseUrl: string): boolean {
const normalized = normalizedBaseUrl(baseUrl);
return normalized === DEEPSEEK_BASE_URL || normalized === `${DEEPSEEK_BASE_URL}/v1`;
}
/** Only the exact HTTPS origin, optionally with the `/v1` API root: no credentials, port, query or fragment. */
function isCanonicalMistralBaseUrl(baseUrl: string): boolean {
const normalized = normalizedBaseUrl(baseUrl);
return normalized === MISTRAL_BASE_URL || normalized === `${MISTRAL_BASE_URL}/v1`;
}
const MISTRAL_PLAN_NAMES = new Set(["FREE", "INDIVIDUAL", "EDU", "TEAM"]);
const MISTRAL_BUDGETS = [["api_budget", "API budget"], ["vibe_budget", "Vibe budget"]] as const;
/**
* Mistral Studio/Vibe budgets (#8290).
*
* Display-only: the result never carries routing evidence, so neither key ranking nor the
* passive quota pool may spend or order a key from it. The destination is fixed and canonical,
* the request rides the provider's own egress, redirects are refused, and the body is bounded
* by readQuotaJson. A denial (401/403 and other non-retryable client statuses) is terminal and
* suppresses the previous row; transport trouble, 408, 429 and 5xx are transient and keep it.
*/
async function fetchMistralQuota(provider: string, config: OcxProviderConfig): Promise<ProviderQuotaProbeResult> {
if (!isCanonicalMistralBaseUrl(config.baseUrl)) return null;
const apiKey = resolveProviderApiKey(config.apiKey)?.trim();
if (!apiKey) return null;
const init: RequestInit = {
headers: { Accept: "application/json", Authorization: `Bearer ${apiKey}` },
redirect: "error", signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
};
const settled = await Promise.allSettled([
quotaFetch(provider, config, `${MISTRAL_BASE_URL}/v1/billing/budget`, init),
quotaFetch(provider, config, `${MISTRAL_BASE_URL}/v1/billing/subscription`, init),
]);
const responses = settled.flatMap(result => result.status === "fulfilled" ? [result.value] : []);
// 402 is a billing refusal of the reading, not proof that the credential is invalid: the
// plan may be exhausted or the billing endpoint may be gated. Keep the last-good row, as for
// 408/429, instead of erasing the measured budgets on a payment-required response.
if (responses.some(response => response.status >= 400 && response.status < 500 && response.status !== 402 && response.status !== 408 && response.status !== 429)) return TERMINAL_QUOTA_FAILURE;
if (responses.length !== 2 || responses.some(response => !response.ok)) return null;
const [budgetResponse, subscriptionResponse] = responses as [Response, Response];
const [budgetValue, subscriptionValue] = await Promise.all([
readQuotaJson(budgetResponse), readQuotaJson(subscriptionResponse),
]);
if (budgetValue === QUOTA_JSON_READ_FAILURE || subscriptionValue === QUOTA_JSON_READ_FAILURE) return null;
const budget = asRecord(budgetValue);
const subscription = asRecord(subscriptionValue);
if (!budget || !subscription) return null;
const plan = typeof subscription.plan_name === "string" && MISTRAL_PLAN_NAMES.has(subscription.plan_name)
? subscription.plan_name : undefined;
const customWindows: NonNullable<ProviderQuota["customWindows"]> = [];
const unknownBudgetWindows: NonNullable<ProviderQuota["unknownBudgetWindows"]> = [];
for (const [key, label] of MISTRAL_BUDGETS) {
const row = asRecord(budget[key]);
const resetAt = normalizeResetAt(row?.reset_at);
const reset = resetAt === undefined ? {} : { resetAt };
const suffix = plan ? ` (${plan})` : "";
const initial = toFiniteNumber(row?.initial_budget);
const percent = toFiniteNumber(row?.usage_percentage);
const currency = typeof row?.currency === "string" && /^[A-Za-z]{3}$/.test(row.currency) ? row.currency.toUpperCase() : undefined;
if (initial === undefined || initial <= 0 || percent === undefined || percent < 0 || percent > 100 || !currency) {
unknownBudgetWindows.push({ label: `${label}${suffix}`, ...reset });
continue;
}
const used = initial * (percent / 100);
customWindows.push({ label, displayLabel: `${label} (${currency} ${used.toFixed(2)} of ${currency} ${initial.toFixed(2)} used${plan ? `; ${plan}` : ""})`, percent, ...reset });
}
const quota: ProviderQuota = { customWindows, unknownBudgetWindows, updatedAt: Date.now() };
// Vibe and PAYG entitlements are display information, not inference eligibility evidence.
return keyReport(provider, "mistral:budget", markDisplayOnlyQuota(quota), config, apiKey, undefined, { bindCredential: true });
}
function isCanonicalClineBaseUrl(baseUrl: string): boolean {
const normalized = normalizedBaseUrl(baseUrl);
return normalized === CLINE_BASE_URL || normalized === `${CLINE_BASE_URL}/api/v1`;
}
function isCanonicalOllamaCloudBaseUrl(baseUrl?: string): boolean {
if (!baseUrl) return false;
try {
return isCanonicalOllamaCloudUrl(baseUrl);
} catch {
return false;
}
}
function zaiQuotaMonitorHost(baseUrl: string): string | null {
// Admission and destination selection must share one mapping: admitting a new
// international wire must never fall through to the CN host/authentication scheme.
switch (normalizedBaseUrl(baseUrl)) {
case ZAI_BASE_URL:
case `${ZAI_BASE_URL}/api/coding/paas/v4`:
case `${ZAI_BASE_URL}/api/anthropic`:
case `${ZAI_BASE_URL}/api/v1`:
return ZAI_BASE_URL;
case ZAI_CN_BASE_URL:
case `${ZAI_CN_BASE_URL}/api/coding/paas/v4`:
case `${ZAI_CN_BASE_URL}/api/v1`:
return ZAI_CN_BASE_URL;
default:
return null;
}
}
function isCanonicalZaiBaseUrl(baseUrl: string): boolean {
return zaiQuotaMonitorHost(baseUrl) !== null;
}
function isCanonicalMinimaxBaseUrl(baseUrl: string): boolean {
const normalized = normalizedBaseUrl(baseUrl);
return normalized === "https://api.minimax.io/v1" || normalized === "https://api.minimaxi.com/v1";
}
function isCanonicalMoonshotBaseUrl(baseUrl: string): boolean {
const normalized = normalizedBaseUrl(baseUrl);
return normalized === MOONSHOT_BASE_URL || normalized === "https://api.moonshot.cn/v1";
}
function isCanonicalVeniceBaseUrl(baseUrl: string): boolean {
return normalizedBaseUrl(baseUrl) === VENICE_BASE_URL;
}
function isCanonicalSyntheticBaseUrl(baseUrl: string): boolean {
const normalized = normalizedBaseUrl(baseUrl);
return normalized === SYNTHETIC_BASE_URL || normalized === "https://api.synthetic.new/openai/v1";
}
function isCanonicalDeepInfraBaseUrl(baseUrl: string): boolean {
const normalized = normalizedBaseUrl(baseUrl);
return normalized === DEEPINFRA_BASE_URL || normalized === `${DEEPINFRA_BASE_URL}/v1/openai`;
}
function isCanonicalNeuralwattBaseUrl(baseUrl: string): boolean {
return normalizedBaseUrl(baseUrl) === NEURALWATT_BASE_URL;
}
function isCanonicalAbliterationBaseUrl(baseUrl: string): boolean {
const normalized = normalizedBaseUrl(baseUrl);
return normalized === ABLITERATION_BASE_URL || normalized === `${ABLITERATION_BASE_URL}/v1`;
}
function a6apiPayload(value: unknown): Record<string, unknown> | null {
const body = asRecord(value);
return asRecord(body?.data) ?? body;
}
function firstFinite(record: Record<string, unknown> | null, names: string[]): number | undefined {
if (!record) return undefined;
for (const name of names) {
const value = toFiniteNumber(record[name]);
if (value !== undefined) return value;
}
return undefined;
}
async function fetchA6apiQuota(provider: string, config: OcxProviderConfig): Promise<ProviderQuotaProbeResult> {
// Never send a configured API key to a lookalike host or through a redirect.
if (!isCanonicalA6apiBaseUrl(config.baseUrl)) return null;
const apiKey = resolveProviderApiKey(config.apiKey)?.trim();
if (!apiKey) return null;
const headers = { Accept: "application/json", Authorization: `Bearer ${apiKey}` } as const;
const [subscriptionResponse, tokenResponse] = await Promise.all([
quotaFetch(provider, config, `${A6API_BASE_URL}/dashboard/billing/subscription`, {
headers, redirect: "error", signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
}),
quotaFetch(provider, config, `${A6API_BASE_URL}/api/usage/token/`, {
headers, redirect: "error", signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
}),
]);
if (!subscriptionResponse.ok || !tokenResponse.ok) {
const statuses = [subscriptionResponse.status, tokenResponse.status];
// 408/429 are transient (timeout/throttle), not invalid-account signals: keep the
// last-good row like 5xx/network failures. 401/403 (bad key) and 404 (contract change)
// stay terminal.
return statuses.some(status => status >= 400 && status < 500 && status !== 429 && status !== 408)
? TERMINAL_QUOTA_FAILURE
: null;
}
const [subscriptionBody, tokenBody] = await Promise.all([
readQuotaJson(subscriptionResponse),
readQuotaJson(tokenResponse),
]);
if (subscriptionBody === QUOTA_JSON_READ_FAILURE || tokenBody === QUOTA_JSON_READ_FAILURE) return null;
const subscription = a6apiPayload(subscriptionBody);
const token = a6apiPayload(tokenBody);
const unlimited = token?.unlimited_quota === true
|| token?.unlimited_quota === 1
|| token?.unlimited_quota === "true";
const normalizedExpiry = normalizeResetAt(token?.expires_at);
const expiry = normalizedExpiry && normalizedExpiry > 0
? { expiresAt: normalizedExpiry }
: {};
if (unlimited) {
// Every row is an API-credit constraint on inference, so the display quota is also
// the routing projection. Passing it explicitly is the opt-in.
const quota: ProviderQuota = {
creditsUsd: {
used: 0,
limit: 0,
remaining: 0,
percent: 0,
unlimited: true,
...expiry,
},
customWindows: [{ label: "Unlimited API credits", percent: 0 }],
updatedAt: Date.now(),
};
return keyReport(provider, "a6api:billing", quota, config, apiKey, quota);
}
const limitUsd = firstFinite(subscription, ["hard_limit_usd"]);
const grantedUnits = firstFinite(token, ["total_granted"]);
const usedUnits = firstFinite(token, ["total_used"]);
const availableUnits = firstFinite(token, ["total_available"]);
const reconciledUnits = usedUnits !== undefined && availableUnits !== undefined
? usedUnits + availableUnits
: undefined;
const reconciliationTolerance = grantedUnits !== undefined
? Math.abs(grantedUnits) * 1e-9
: 0;
if (limitUsd === undefined || grantedUnits === undefined || usedUnits === undefined
|| availableUnits === undefined || limitUsd <= 0 || grantedUnits <= 0
|| usedUnits < 0 || availableUnits < 0
|| reconciledUnits === undefined
|| Math.abs(reconciledUnits - grantedUnits) > reconciliationTolerance) return TERMINAL_QUOTA_FAILURE;
const usdPerUnit = limitUsd / grantedUnits;
const usedUsd = usedUnits * usdPerUnit;
const remainingUsd = Math.max(0, availableUnits * usdPerUnit);
const percent = normalizePercent((usedUsd / limitUsd) * 100);
if (percent === undefined) return TERMINAL_QUOTA_FAILURE;
const label = `API credits ($${remainingUsd.toFixed(2)} of $${limitUsd.toFixed(2)} remaining)`;
const quota: ProviderQuota = {
creditsUsd: {
used: usedUsd,
limit: limitUsd,
remaining: remainingUsd,
percent,
...expiry,
},
customWindows: [{ label, percent }],
updatedAt: Date.now(),
};
// The credit balance funds inference itself, so display and routing scope agree.
return keyReport(provider, "a6api:billing", quota, config, apiKey, quota);
}
function parseOpenCodeGoUsageWindow(value: unknown): { percent: number; resetAt?: number } | null {
const row = asRecord(value);
if (!row) return null;
const percent = normalizePercent(row.percent);
if (percent === undefined) return null;
const resetAt = normalizeResetAt(row.resetsAt);
return { percent, ...(resetAt !== undefined ? { resetAt } : {}) };
}
async function fetchOpenCodeGoQuota(provider: string, config: OcxProviderConfig): Promise<ProviderQuotaProbeResult> {
// Never send a configured API key when the provider destination is not the built-in Go endpoint.
if (!isCanonicalOpenCodeGoBaseUrl(config.baseUrl)) return null;
const apiKey = resolveProviderApiKey(config.apiKey)?.trim();
if (!apiKey) return null;
const response = await quotaFetch(provider, config, OPENCODE_GO_USAGE_URL, {
headers: { Accept: "application/json", Authorization: `Bearer ${apiKey}` },
redirect: "error",
signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
});
if (!response.ok) {
return response.status >= 400 && response.status < 500 && response.status !== 408 && response.status !== 429
? TERMINAL_QUOTA_FAILURE
: null;
}
const body = asRecord(await readQuotaJson(response));
const usage = asRecord(body?.usage);
if (!usage) return null;
const rolling = parseOpenCodeGoUsageWindow(usage.rolling);
const weekly = parseOpenCodeGoUsageWindow(usage.weekly);
const monthly = parseOpenCodeGoUsageWindow(usage.monthly);
const quota: ProviderQuota = {
...(rolling ? {
fiveHourPercent: rolling.percent,
...(rolling.resetAt !== undefined ? { fiveHourResetAt: rolling.resetAt } : {}),
} : {}),
...(weekly ? {
weeklyPercent: weekly.percent,
...(weekly.resetAt !== undefined ? { weeklyResetAt: weekly.resetAt } : {}),
} : {}),
...(monthly ? {
monthlyPercent: monthly.percent,
...(monthly.resetAt !== undefined ? { monthlyResetAt: monthly.resetAt } : {}),
} : {}),
updatedAt: Date.now(),
};
return keyReport(provider, "opencode-go:usage", quota, config, apiKey, quota);
}
/**
* OpenRouter `GET /api/v1/key` — the key's own credit balance and optional
* per-key spending cap. `limit` is the configured cap (absent = uncapped);
* `usage` is lifetime spend; `limit_remaining` is what is left of the cap.
* When no cap is set there is no hard limit to meter against, so no bar is
* produced — the provider falls back to its documented reference.
*/
async function fetchOpenRouterQuota(provider: string, config: OcxProviderConfig): Promise<ProviderQuotaProbeResult> {
// Never send a configured API key to a lookalike host or through a redirect.
if (!isCanonicalOpenRouterBaseUrl(config.baseUrl)) return null;
const apiKey = resolveProviderApiKey(config.apiKey)?.trim();
if (!apiKey) return null;
const response = await quotaFetch(provider, config, `${OPENROUTER_BASE_URL}/key`, {
headers: { Accept: "application/json", Authorization: `Bearer ${apiKey}` },
redirect: "error",
signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
});
if (!response.ok) {
return response.status >= 400 && response.status < 500 && response.status !== 408 && response.status !== 429
? TERMINAL_QUOTA_FAILURE
: null;
}
const body = asRecord(await readQuotaJson(response));
const data = asRecord(body?.data) ?? body;
if (!data) return null;
const limit = toFiniteNumber(data.limit);
const limitRemaining = toFiniteNumber(data.limit_remaining);
const usage = toFiniteNumber(data.usage);
// A successful no-cap response is a DELIBERATE change, not a transient
// failure: the old capped row must be dropped, not preserved as last-good.
if (limit === undefined || limit <= 0) return TERMINAL_QUOTA_FAILURE;
// Prefer the authoritative remaining-cap value when present: `usage` is
// lifetime accumulated spend and overstates a reset or re-capped key.
const used = limitRemaining !== undefined
? Math.max(0, limit - limitRemaining)
: usage !== undefined && usage >= 0 ? usage : undefined;
if (used === undefined) return null;
const percent = normalizePercent((used / limit) * 100);
if (percent === undefined) return null;
const remaining = Math.max(0, limit - used);
const label = `API credits ($${remaining.toFixed(2)} of $${limit.toFixed(2)} remaining)`;
// The per-key spending cap stops every request this credential can make, so the
// whole report is inference-wide routing evidence.
const quota: ProviderQuota = {
customWindows: [{ label, percent }],
updatedAt: Date.now(),
};
return keyReport(provider, "openrouter:key-info", quota, config, apiKey, quota);
}
/**
* DeepSeek `GET /user/balance` — the account's granted + topped-up credit
* balance. The payload places `total_balance` / `granted_balance` inside
* entries of `balance_infos` (one row per currency); the row for the account's
* currency is selected by preference. `granted_balance` is a CURRENT balance
* component, not the original grant ceiling, so no consumed percentage is
* fabricated — the balance is reported as a balance-only window.
*/
async function fetchDeepSeekQuota(provider: string, config: OcxProviderConfig): Promise<ProviderQuotaProbeResult> {
if (!isCanonicalDeepSeekBaseUrl(config.baseUrl)) return null;
const apiKey = resolveProviderApiKey(config.apiKey)?.trim();
if (!apiKey) return null;
const response = await quotaFetch(provider, config, `${DEEPSEEK_BASE_URL}/user/balance`, {
headers: { Accept: "application/json", Authorization: `Bearer ${apiKey}` },
redirect: "error",
signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
});
if (!response.ok) {
return response.status >= 400 && response.status < 500 && response.status !== 408 && response.status !== 429
? TERMINAL_QUOTA_FAILURE
: null;
}
const body = asRecord(await readQuotaJson(response));
// The payload nests balances under `balance_infos` rows keyed by currency;
// prefer a USD row, then CNY, then the first row that parses.
const infos = Array.isArray(body?.balance_infos) ? body.balance_infos as unknown[] : null;
const rows = infos
? infos.map((raw): Record<string, unknown> | null => asRecord(raw)).filter((r): r is Record<string, unknown> => r !== null)
: [];
const pick = (currency: string): Record<string, unknown> | null =>
rows.find(row => String(row.currency ?? "").toUpperCase() === currency) ?? null;
const preferred = pick("USD") ?? pick("CNY") ?? rows[0] ?? null;
if (!preferred) return null;
const totalBalance = toFiniteNumber(preferred.total_balance);
const grantedBalance = toFiniteNumber(preferred.granted_balance);
const toppedUp = toFiniteNumber(preferred.topped_up_balance);
const balance = totalBalance ?? grantedBalance ?? toppedUp;
if (balance === undefined || balance < 0) return null;
// The rows are currency-scoped, so the symbol has to follow the row that was
// picked: the two glyph currencies keep their sign, any other ISO code
// prefixes the amount, and a row without one keeps the legacy dollar.
const currency = String(preferred.currency ?? "").trim().toUpperCase();
const sign = currency === "CNY" ? "¥" : currency === "" || currency === "USD" ? "$" : `${currency} `;
const amount = (value: number) => `${sign}${value.toFixed(2)}`;
const label = grantedBalance !== undefined && grantedBalance > 0
? `API balance (${amount(balance)} total, ${amount(grantedBalance)} granted)`
: `API balance (${amount(balance)})`;
return report(provider, "deepseek:balance", {
customWindows: [{ label, percent: 0 }],
updatedAt: Date.now(),
});
}
/**
* ClinePass `GET /api/v1/users/me/plan/usage-limits` — the subscription's
* rolling five-hour, weekly, and monthly utilization, matching the existing
* ProviderQuota windows directly. The endpoint 404s (or returns a null plan)
* for accounts without an active ClinePass, which is a no-report, not an error.
*/
async function fetchClineQuota(provider: string, config: OcxProviderConfig): Promise<ProviderQuotaProbeResult> {
if (!isCanonicalClineBaseUrl(config.baseUrl)) return null;
const apiKey = resolveProviderApiKey(config.apiKey)?.trim();
if (!apiKey) return null;
const response = await quotaFetch(provider, config, `${CLINE_BASE_URL}/api/v1/users/me/plan/usage-limits`, {
headers: { Accept: "application/json", Authorization: `Bearer ${apiKey}` },
redirect: "error",
signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
});
if (!response.ok) {
// 404 = no active plan; a plain "no plan" is a no-report, everything else
// 4xx (except 408/429) is a credential/contract problem.
if (response.status === 404) return null;
return response.status >= 400 && response.status < 500 && response.status !== 408 && response.status !== 429
? TERMINAL_QUOTA_FAILURE
: null;
}
const body = asRecord(await readQuotaJson(response));
const data = asRecord(body?.data) ?? body;
const limits = Array.isArray(data?.limits) ? data.limits : null;
if (!limits) return null;
const quota: ProviderQuota = { updatedAt: Date.now() };
let windows = 0;
for (const raw of limits) {
const row = asRecord(raw);
if (!row) continue;
const percent = normalizePercent(row.percentUsed);
if (percent === undefined) continue;
const resetAt = normalizeResetAt(row.resetsAt);
if (row.type === "five_hour") {
quota.fiveHourPercent = percent;
if (resetAt !== undefined) quota.fiveHourResetAt = resetAt;
windows += 1;
} else if (row.type === "weekly") {
quota.weeklyPercent = percent;
if (resetAt !== undefined) quota.weeklyResetAt = resetAt;
windows += 1;
} else if (row.type === "monthly") {
quota.monthlyPercent = percent;
if (resetAt !== undefined) quota.monthlyResetAt = resetAt;
windows += 1;
}
}
return windows > 0 ? keyReport(provider, "cline:plan-usage-limits", quota, config, apiKey, quota) : null;
}
/**
* Ollama Cloud quota. `GET https://ollama.com/api/balance` is the live source: it
* returns the included (plan) balance plus purchased credits. Legacy plans report
* rolling 5-hour `included.session.remaining_percent` and 7-day
* `included.weekly.remaining_percent` (remaining shares, so used = 100 - remaining);
* credit plans report `included.balance_usd`/`included.allowance_usd` over a
* `period`.
*
* `GET https://ollama.com/api/usage` used to carry `limits.{session,weekly,monthly}.usage`
* as normalized fractions but now returns only a request-count timeseries, so it is
* kept as a fallback for older deployments.
*/
function parseOllamaUsedPercent(row: Record<string, unknown>): number | undefined {
if (row.remaining_percent !== undefined) {
const remaining = toFiniteNumber(row.remaining_percent);
if (remaining === undefined) return undefined;
return normalizePercent(Math.round((100 - remaining) * 100) / 100);
}
return parseOllamaPercent(row.usage);
}
export function parseOllamaCloudBalance(body: Record<string, unknown> | null): ProviderQuota | null {
if (!body) return null;
const included = asRecord(body.included);
if (!included) return null;
const quota: ProviderQuota = { updatedAt: Date.now() };
let windows = 0;
const rows: Array<[string, "fiveHour" | "weekly" | "monthly"]> = [
["session", "fiveHour"],
["weekly", "weekly"],
["monthly", "monthly"],
];
for (const [key, window] of rows) {
const row = asRecord(included[key]);
if (!row) continue;
const percent = parseOllamaUsedPercent(row);
if (percent === undefined) continue;
const resetAt = normalizeResetAt(row.resets_at);
if (window === "fiveHour") {
quota.fiveHourPercent = percent;
if (resetAt !== undefined) quota.fiveHourResetAt = resetAt;
} else if (window === "weekly") {
quota.weeklyPercent = percent;
if (resetAt !== undefined) quota.weeklyResetAt = resetAt;
} else {
quota.monthlyPercent = percent;
if (resetAt !== undefined) quota.monthlyResetAt = resetAt;
}
windows += 1;
}
const allowance = toFiniteNumber(included.allowance_usd);
const balance = toFiniteNumber(included.balance_usd);
if (allowance !== undefined && allowance > 0 && balance !== undefined) {
const used = Math.max(0, allowance - balance);
const percent = normalizePercent(Math.round((used / allowance) * 10000) / 100);
if (percent !== undefined) {
const expiresAt = normalizeResetAt(asRecord(included.period)?.until);
// creditsUsd is the included allowance only; purchased credits are ignored.
quota.creditsUsd = {
used,
limit: allowance,
remaining: balance,
percent,
...(expiresAt !== undefined ? { expiresAt } : {}),
};
windows += 1;
}
}
return windows > 0 ? quota : null;
}
function parseOllamaPercent(usageValue: unknown): number | undefined {
const usage = toFiniteNumber(usageValue);
if (usage === undefined || usage < 0) return undefined;
const percent = Math.round(usage * 10000) / 100;
return normalizePercent(percent);
}
export function parseOllamaCloudQuota(body: Record<string, unknown> | null): ProviderQuota | null {
if (!body) return null;
const limits = asRecord(body.limits);
if (!limits) return null;
const quota: ProviderQuota = { updatedAt: Date.now() };
let windows = 0;
const session = asRecord(limits.session);
if (session) {
const percent = parseOllamaPercent(session.usage);
if (percent !== undefined) {
quota.fiveHourPercent = percent;
windows += 1;
}
}
const weekly = asRecord(limits.weekly);
if (weekly) {
const percent = parseOllamaPercent(weekly.usage);
if (percent !== undefined) {
quota.weeklyPercent = percent;
windows += 1;
}
}
const monthly = asRecord(limits.monthly);
if (monthly) {
const percent = parseOllamaPercent(monthly.usage);
if (percent !== undefined) {
quota.monthlyPercent = percent;
windows += 1;
}
}
return windows > 0 ? quota : null;
}
/**
* Routing projection for an `/api/balance` report. `creditsUsd` covers the included
* allowance only, so it may veto routing only when purchased credit is known to be empty;
* otherwise an exhausted allowance would block an account that still has paid balance.
*/
function ollamaBalanceInferenceQuota(quota: ProviderQuota, body: Record<string, unknown> | null): ProviderQuota {
if (!quota.creditsUsd) return quota;
const purchased = toFiniteNumber(asRecord(body?.purchased)?.balance_usd);
if (purchased !== undefined && purchased <= 0) return quota;
const { creditsUsd: _includedOnly, ...inference } = quota;
return inference;
}
async function fetchOllamaCloudQuota(provider: string, config: OcxProviderConfig): Promise<ProviderQuotaProbeResult> {
const effectiveBaseUrl = config.baseUrl ?? getProviderRegistryEntry(provider)?.baseUrl ?? "";
if (!isCanonicalOllamaCloudBaseUrl(effectiveBaseUrl)) return null;
const apiKey = resolveProviderApiKey(config.apiKey)?.trim();
if (!apiKey) return null;
const attempts: Array<{
url: string;
source: string;
parse: (body: Record<string, unknown> | null) => ProviderQuota | null;
}> = [
{ url: OLLAMA_CLOUD_BALANCE_URL, source: "ollama-cloud:balance", parse: parseOllamaCloudBalance },
{ url: OLLAMA_CLOUD_USAGE_URL, source: "ollama-cloud:usage", parse: parseOllamaCloudQuota },
];
let terminalFailure = false;
for (const attempt of attempts) {
let response: Response;
try {
response = await quotaFetch(provider, config, attempt.url, {
headers: { Accept: "application/json", Authorization: `Bearer ${apiKey}` },
redirect: "error",
signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
});
} catch {
continue;
}
if (!response.ok) {
if (response.status !== 404 && response.status >= 400 && response.status < 500 && response.status !== 408 && response.status !== 429) {
terminalFailure = true;
}
try {
void response.body?.cancel().catch(() => undefined);
} catch {
// Best-effort cancellation only.
}
continue;
}
const raw = await readQuotaJson(response);
if (raw === QUOTA_JSON_READ_FAILURE) return terminalFailure ? TERMINAL_QUOTA_FAILURE : null;
const body = asRecord(raw);
const quota = attempt.parse(body);
if (quota) {
const inference = attempt.url === OLLAMA_CLOUD_BALANCE_URL ? ollamaBalanceInferenceQuota(quota, body) : quota;
return keyReport(provider, attempt.source, quota, config, apiKey, inference);
}
}
return terminalFailure ? TERMINAL_QUOTA_FAILURE : null;
}
/**
* Z.AI GLM Coding Plan `GET /api/monitor/usage/quota/limit` — the coding-plan
* limits arrive as a `limits` array of `TOKENS_LIMIT` (newer plans call the
* same rows `CREDIT_LIMIT`) and `TIME_LIMIT` rows. `TOKENS_LIMIT`/`CREDIT_LIMIT`
* rows carry the window length as `unit`/`number`: unit 3 is hours (number 5 →
* the rolling five-hour window), unit 6 is weeks (number 1 → the weekly
* window). Every row's `percentage` is the consumed share (falling
* back to `currentValue`/`usage` when absent) and `nextResetTime` (unix ms)
* the window reset.
*
* `TIME_LIMIT` rows are deliberately ignored (issue #1168). They are the shared
* monthly MCP *call* allowance for Web Search / Web Reader / Zread — not a
* model-token budget — and `ProviderQuota.monthlyPercent` is consumed as a
* model-capacity signal: `headroomOf()` in `src/oauth/account-quota-rank.ts`
* takes the MAX across every window, so a user who spent their MCP search
* allowance would be ranked as having no model capacity left, and the dashboard
* would draw a full monthly bar for a plan whose model tokens are untouched.
* A payload carrying only `TIME_LIMIT` rows therefore reports no quota at all,
* which is the honest answer rather than a fabricated one.
*/
export function parseZaiQuotaLimits(data: Record<string, unknown> | null): ProviderQuota | null {
const limits = Array.isArray(data?.limits) ? data.limits as unknown[] : null;
if (!limits) return null;
const quota: ProviderQuota = { updatedAt: Date.now() };
let windows = 0;
for (const raw of limits) {
const row = asRecord(raw);
if (!row) continue;
// Gate on row type before deriving a percentage: an MCP row must not even
// contribute a parsed value to a model-quota report.
if (row.type !== "TOKENS_LIMIT" && row.type !== "CREDIT_LIMIT") continue;
const resetAt = normalizeResetAt(row.nextResetTime);
let percent = normalizePercent(row.percentage);
if (percent === undefined) {
const used = toFiniteNumber(row.currentValue);
const total = toFiniteNumber(row.usage);
if (used !== undefined && total !== undefined && total > 0) {
percent = normalizePercent((used / total) * 100);
}
}
if (percent === undefined) continue;
const unit = toFiniteNumber(row.unit);
const number = toFiniteNumber(row.number);
if (unit === 3 && number === 5) {
quota.fiveHourPercent = percent;
if (resetAt !== undefined) quota.fiveHourResetAt = resetAt;
windows += 1;
} else if (unit === 6 && number === 1) {
quota.weeklyPercent = percent;
if (resetAt !== undefined) quota.weeklyResetAt = resetAt;
windows += 1;
}
}
return windows > 0 ? quota : null;
}
/**
* Legacy Z.AI payload shape: percent fields with window identifiers directly on
* the data object (optionally nested under `quota`). Kept as a fallback so
* older responses keep rendering when the `limits` array is absent.
*/
function parseZaiQuotaLegacyFields(data: Record<string, unknown> | null): ProviderQuota | null {
if (!data) return null;
const quota: ProviderQuota = { updatedAt: Date.now() };
let windows = 0;
const percentAt = (key: string): number | undefined => {
const value = normalizePercent(data[key]);
if (value !== undefined) return value;
const nested = asRecord(data.quota);
return nested ? normalizePercent(nested[key]) : undefined;
};
const fiveHour = percentAt("fiveHourPercent") ?? percentAt("fiveHourUsage") ?? percentAt("fiveHourUsed");
const weekly = percentAt("weeklyPercent") ?? percentAt("weeklyUsage") ?? percentAt("weeklyUsed");
const monthly = percentAt("monthlyPercent") ?? percentAt("mcpPercent") ?? percentAt("monthlyMCPUsage");
if (fiveHour !== undefined) {
quota.fiveHourPercent = fiveHour;
windows += 1;
}
if (weekly !== undefined) {
quota.weeklyPercent = weekly;
windows += 1;
}
if (monthly !== undefined) {
quota.monthlyPercent = monthly;
windows += 1;
}
return windows > 0 ? quota : null;
}
/**
* Fetches the Z.AI GLM Coding Plan quota — on whichever region the provider
* points at (api.z.ai or open.bigmodel.cn). The `limits` array shape is
* preferred; older field-name payloads fall back to the legacy parser.
*
* Authentication differs by host (issue #1168). `api.z.ai` takes the API key as
* a Bearer token per Z.AI's API reference; `open.bigmodel.cn` expects the key
* directly in `Authorization` with no scheme prefix and answers a Bearer header
* with an auth error, which is why BigModel Coding Plan quota never rendered.
* The host is already canonicalized by `isCanonicalZaiBaseUrl` above and
* `redirect: "error"` stays set, so the bare key cannot travel to a lookalike
* host or follow a redirect off-origin.
*/
async function fetchZaiQuota(provider: string, config: OcxProviderConfig): Promise<ProviderQuotaProbeResult> {
const monitorHost = zaiQuotaMonitorHost(config.baseUrl);
if (!monitorHost) return null;
const apiKey = resolveProviderApiKey(config.apiKey)?.trim();
if (!apiKey) return null;
const authorization = monitorHost === ZAI_CN_BASE_URL ? apiKey : `Bearer ${apiKey}`;
const response = await quotaFetch(provider, config, `${monitorHost}/api/monitor/usage/quota/limit`, {
headers: { Accept: "application/json", Authorization: authorization },
redirect: "error",
signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
});
if (!response.ok) {
return response.status >= 400 && response.status < 500 && response.status !== 408 && response.status !== 429
? TERMINAL_QUOTA_FAILURE
: null;
}
const body = asRecord(await readQuotaJson(response));
if (!body || body.success === false) return null;
const data = asRecord(body.data) ?? body;
if (Array.isArray(data?.limits)) {
const quota = parseZaiQuotaLimits(data);
// A well-formed `limits[]` we fully understood is authoritative even when it yields no
// model window — for example a plan reporting only the monthly MCP `TIME_LIMIT` row.
// Returning `null` here would preserve the previous token windows for up to 30 minutes
// and keep quota-aware routing acting on a report the provider has already superseded.
return quota
? keyReport(provider, "zai:quota-limit", quota, config, apiKey, quota)
: AUTHORITATIVE_EMPTY_QUOTA;
}
const legacy = parseZaiQuotaLegacyFields(data);
if (!legacy) return null;
// The legacy monthly figure also carries MCP usage; it is display evidence, not
// proof that model inference is unavailable. Modern TOKEN_LIMIT rows above are scoped.
const inferenceQuota = { ...legacy };
delete inferenceQuota.monthlyPercent;
delete inferenceQuota.monthlyResetAt;
return keyReport(provider, "zai:quota-limit", legacy, config, apiKey, inferenceQuota);
}
/**
* MiniMax Coding Plan `GET /v1/api/openplatform/coding_plan/remains` reports
* remaining percentages per model/window. Only the `general` model is the
* Coding Plan quota; video remains are unrelated. Region selects the host.
*/
async function fetchMinimaxQuota(provider: string, config: OcxProviderConfig): Promise<ProviderQuotaProbeResult> {
if (!isCanonicalMinimaxBaseUrl(config.baseUrl)) return null;
const apiKey = resolveProviderApiKey(config.apiKey)?.trim();
if (!apiKey) return null;
const cnHost = normalizedBaseUrl(config.baseUrl)?.startsWith("https://api.minimaxi.com");
const canonicalHost = cnHost ? "https://api.minimaxi.com" : "https://api.minimax.io";
const remainsUrl = `${canonicalHost}${MINIMAX_REMAINS_PATH}`;
const response = await quotaFetch(provider, config, remainsUrl, {
headers: { Accept: "application/json", Authorization: `Bearer ${apiKey}` },
redirect: "error",
signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
});
if (!response.ok) {
return response.status >= 400 && response.status < 500 && response.status !== 408 && response.status !== 429
? TERMINAL_QUOTA_FAILURE
: null;
}
const body = asRecord(await readQuotaJson(response));
if (!body || asRecord(body.base_resp)?.status_code !== 0) return null;
const rows = Array.isArray(body.model_remains) ? body.model_remains : [];
const general = rows.map(asRecord).find(row => row?.model_name === "general");
if (!general) return null;
const customWindows: NonNullable<ProviderQuota["customWindows"]> = [];
const fiveHourRemaining = toFiniteNumber(general.current_interval_remaining_percent);
if (fiveHourRemaining !== undefined) {
const percent = normalizePercent(100 - fiveHourRemaining);
if (percent !== undefined) {
const resetAt = normalizeResetAt(general.end_time);
customWindows.push({ label: "Coding Plan 5-hour", percent, ...(resetAt ? { resetAt } : {}) });
}
}
if (general.current_weekly_status === 1) {
const weeklyRemaining = toFiniteNumber(general.current_weekly_remaining_percent);
if (weeklyRemaining !== undefined) {
const percent = normalizePercent(100 - weeklyRemaining);
if (percent !== undefined) {
const resetAt = normalizeResetAt(general.weekly_end_time);
customWindows.push({ label: "Coding Plan weekly", percent, ...(resetAt ? { resetAt } : {}) });
}
}
}
if (customWindows.length === 0) return null;
return report(provider, "minimax:token-plan-remains", {
customWindows,
updatedAt: Date.now(),
});
}
/**
* Moonshot/Kimi `GET /v1/users/me/balance` — the account's available balance
* (voucher + cash). Renders a single balance window against the sum of
* voucher + cash when positive (there is no per-window rate limit to meter).
*/
async function fetchMoonshotQuota(provider: string, config: OcxProviderConfig): Promise<ProviderQuotaProbeResult> {
if (!isCanonicalMoonshotBaseUrl(config.baseUrl)) return null;
const apiKey = resolveProviderApiKey(config.apiKey)?.trim();
if (!apiKey) return null;
const host = normalizedBaseUrl(config.baseUrl)?.startsWith("https://api.moonshot.cn") ? "https://api.moonshot.cn/v1" : MOONSHOT_BASE_URL;
const response = await quotaFetch(provider, config, `${host}/users/me/balance`, {
headers: { Accept: "application/json", Authorization: `Bearer ${apiKey}` },
redirect: "error",
signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
});
if (!response.ok) {
return response.status >= 400 && response.status < 500 && response.status !== 408 && response.status !== 429
? TERMINAL_QUOTA_FAILURE
: null;
}
const body = asRecord(await readQuotaJson(response));
const data = asRecord(body?.data) ?? body;
if (!data) return null;
const available = toFiniteNumber(data.available_balance);
const voucher = toFiniteNumber(data.voucher_balance);
const cash = toFiniteNumber(data.cash_balance);
if (available === undefined || available < 0) return null;
// Moonshot exposes no per-window quota ceiling, only a balance — report it
// as a balance-only window (percent 0) rather than a fabricated utilization.
// Currency is host-scoped: China platform (api.moonshot.cn) bills in CNY;
// the international platform (api.moonshot.ai) bills in USD. Do not force
// either side into the other unit — the number is correct, only the unit
// must match the host.
const isChinaHost = host.startsWith("https://api.moonshot.cn");
const money = (n: number) => isChinaHost ? `¥${n.toFixed(2)}` : `$${n.toFixed(2)}`;
const unit = isChinaHost ? "CNY" : "USD";
const label = voucher !== undefined && cash !== undefined
? `Balance (${money(available)} ${unit} available, ${money(voucher)} voucher)`
: `Balance (${money(available)} ${unit} available)`;
return report(provider, "moonshot:balance", {
customWindows: [{ label, percent: 0 }],
updatedAt: Date.now(),
});
}
/**
* Venice `GET /api/v1/billing/balance` — DIEM (native credits) or USD balance.
* Shows the remaining balance; epoch allocation progress when present.
*/
async function fetchVeniceQuota(provider: string, config: OcxProviderConfig): Promise<ProviderQuotaProbeResult> {
if (!isCanonicalVeniceBaseUrl(config.baseUrl)) return null;
const apiKey = resolveProviderApiKey(config.apiKey)?.trim();
if (!apiKey) return null;
const response = await quotaFetch(provider, config, `${VENICE_BASE_URL}/billing/balance`, {
headers: { Accept: "application/json", Authorization: `Bearer ${apiKey}` },
redirect: "error",
signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
});
if (!response.ok) {
return response.status >= 400 && response.status < 500 && response.status !== 408 && response.status !== 429
? TERMINAL_QUOTA_FAILURE
: null;
}
const body = asRecord(await readQuotaJson(response));
const data = asRecord(body?.data) ?? body;
if (!data) return null;
const diemBalance = toFiniteNumber(data.balance);
const usdBalance = toFiniteNumber(data.balance_usd);
const epochUsed = toFiniteNumber(data.diem_epoch_used);
const epochAllocated = toFiniteNumber(data.diem_epoch_allocated);
if (diemBalance === undefined && usdBalance === undefined) return null;
const label = diemBalance !== undefined
? `DIEM balance (${Math.round(diemBalance)})`
: `USD balance ($${usdBalance?.toFixed(2) ?? "?"})`;
if (epochAllocated !== undefined && epochAllocated > 0 && epochUsed !== undefined) {
const percent = normalizePercent((epochUsed / epochAllocated) * 100);
if (percent === undefined) return null;
return report(provider, "venice:billing-balance", {
customWindows: [{ label, percent }],
updatedAt: Date.now(),
});
}
return report(provider, "venice:billing-balance", {
customWindows: [{ label, percent: 0 }],
updatedAt: Date.now(),
});
}
/**
* Synthetic `GET /v2/quotas` — the known quota lanes (rolling 5-hour,
* weekly token, search-hourly) mapped onto the quota windows.
*/
async function fetchSyntheticQuota(provider: string, config: OcxProviderConfig): Promise<ProviderQuotaProbeResult> {
if (!isCanonicalSyntheticBaseUrl(config.baseUrl)) return null;
const apiKey = resolveProviderApiKey(config.apiKey)?.trim();
if (!apiKey) return null;
const response = await quotaFetch(provider, config, `${SYNTHETIC_BASE_URL}/quotas`, {
headers: { Accept: "application/json", Authorization: `Bearer ${apiKey}` },
redirect: "error",
signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
});
if (!response.ok) {
return response.status >= 400 && response.status < 500 && response.status !== 408 && response.status !== 429
? TERMINAL_QUOTA_FAILURE
: null;
}
const body = asRecord(await readQuotaJson(response));
const data = asRecord(body?.data) ?? body;
const quota: ProviderQuota = { updatedAt: Date.now() };
let windows = 0;
const percentAt = (key: string): number | undefined => {
const value = normalizePercent(data?.[key]);
if (value !== undefined) return value;
const nested = asRecord(data?.quota) ?? asRecord(data?.quotas);
return nested ? normalizePercent(nested[key]) : undefined;
};
const fiveHour = percentAt("rollingFiveHourLimit");
const weekly = percentAt("weeklyTokenLimit");
if (fiveHour !== undefined) {
quota.fiveHourPercent = fiveHour;
windows += 1;
}
if (weekly !== undefined) {
quota.weeklyPercent = weekly;
windows += 1;
}
const search = asRecord(data?.search);
const searchHourly = search ? normalizePercent(search.hourly) : undefined;
if (searchHourly !== undefined) {
quota.customWindows = [...(quota.customWindows ?? []), { label: "Search hourly", percent: searchHourly }];
windows += 1;
}
const inferenceQuota = { ...quota };
delete inferenceQuota.customWindows; // search.hourly does not constrain model inference.
return windows > 0 ? keyReport(provider, "synthetic:quotas", quota, config, apiKey, inferenceQuota) : null;
}
/**
* DeepInfra `GET /payment/checklist?compute_owed=true` — prepaid balance,
* recent spend, spending limit, and suspension state. Renders a balance
* window (prepaid funds are a negative `stripe_balance` → positive available).
*/
async function fetchDeepInfraQuota(provider: string, config: OcxProviderConfig): Promise<ProviderQuotaProbeResult> {
if (!isCanonicalDeepInfraBaseUrl(config.baseUrl)) return null;
const apiKey = resolveProviderApiKey(config.apiKey)?.trim();
if (!apiKey) return null;
const response = await quotaFetch(provider, config, `${DEEPINFRA_BASE_URL}/payment/checklist?compute_owed=true`, {
headers: { Accept: "application/json", Authorization: `Bearer ${apiKey}` },
redirect: "error",
signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
});
if (!response.ok) {
return response.status >= 400 && response.status < 500 && response.status !== 408 && response.status !== 429
? TERMINAL_QUOTA_FAILURE
: null;
}
const body = asRecord(await readQuotaJson(response));
const data = asRecord(body?.data) ?? body;
if (!data) return null;
const stripeBalance = toFiniteNumber(data.stripe_balance);
const spendLimit = toFiniteNumber(data.spending_limit);
const total = toFiniteNumber(data.total_amount_due);
if (stripeBalance === undefined) return null;
// Prepaid funds are negative; a positive value is money owed.
const available = stripeBalance < 0 ? -stripeBalance : 0;
if (spendLimit !== undefined && spendLimit > 0) {
const spent = total !== undefined && total > 0 ? total : Math.max(0, spendLimit - available);
const percent = normalizePercent((spent / spendLimit) * 100);
if (percent === undefined) return null;
return report(provider, "deepinfra:billing-checklist", {
customWindows: [{ label: `Billing cycle spend ($${spent.toFixed(2)} of $${spendLimit.toFixed(2)})`, percent }],
updatedAt: Date.now(),
});
}
return report(provider, "deepinfra:billing-checklist", {
customWindows: [{ label: `Prepaid balance ($${available.toFixed(2)})`, percent: 0 }],
updatedAt: Date.now(),
});
}
/**
* Neuralwatt `GET /v1/quota` — subscription kWh usage (primary window) and
* prepaid USD credit balance (secondary).
*/
async function fetchNeuralwattQuota(provider: string, config: OcxProviderConfig): Promise<ProviderQuotaProbeResult> {
if (!isCanonicalNeuralwattBaseUrl(config.baseUrl)) return null;
const apiKey = resolveProviderApiKey(config.apiKey)?.trim();
if (!apiKey) return null;
const response = await quotaFetch(provider, config, `${NEURALWATT_BASE_URL}/quota`, {
headers: { Accept: "application/json", Authorization: `Bearer ${apiKey}` },
redirect: "error",
signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
});
if (!response.ok) {
return response.status >= 400 && response.status < 500 && response.status !== 408 && response.status !== 429
? TERMINAL_QUOTA_FAILURE
: null;
}
const body = asRecord(await readQuotaJson(response));
const data = asRecord(body?.data) ?? body;
const quota: ProviderQuota = { updatedAt: Date.now() };
let windows = 0;
const subscription = asRecord(data?.subscription);
const kwhUsed = subscription ? toFiniteNumber(subscription.kwh_used) : undefined;
const kwhIncluded = subscription ? toFiniteNumber(subscription.kwh_included) : undefined;
if (kwhUsed !== undefined && kwhIncluded !== undefined && kwhIncluded > 0) {
const percent = normalizePercent((kwhUsed / kwhIncluded) * 100);
if (percent !== undefined) {
quota.fiveHourPercent = percent;
const periodEnd = subscription ? normalizeResetAt(subscription.current_period_end) : undefined;
if (periodEnd !== undefined) quota.fiveHourResetAt = periodEnd;
windows += 1;
}
}
const balance = asRecord(data?.balance);
const totalCredits = balance ? toFiniteNumber(balance.total_credits_usd) : undefined;
const remainingCredits = balance ? toFiniteNumber(balance.credits_remaining_usd) : undefined;
if (totalCredits !== undefined && totalCredits > 0 && remainingCredits !== undefined) {
// Utilization is CONSUMED credits, not the remaining share.
const used = Math.max(0, totalCredits - remainingCredits);
const percent = normalizePercent((used / totalCredits) * 100);
if (percent !== undefined) {
quota.customWindows = [...(quota.customWindows ?? []), { label: "Prepaid credits", percent }];
windows += 1;
}
}
return windows > 0 ? report(provider, "neuralwatt:quota", quota) : null;
}
/**
* Abliteration `GET /v1/credits` body: `{ data: { total_credits, total_usage } }`, both in USD.
* `total_credits` is everything granted or purchased and `total_usage` is finalized spend, so the
* balance is their difference. A well-formed reply with zero total credits is authoritative: it has
* no ceiling to meter against, so it clears any previous row instead of fabricating a bar. A
* malformed reply returns null and leaves the last-good row in place.
*/
export function parseAbliterationCredits(
body: Record<string, unknown> | null,
): ProviderQuota | typeof AUTHORITATIVE_EMPTY_QUOTA | null {
const data = asRecord(body?.data);
const total = toFiniteNumber(data?.total_credits);
const used = toFiniteNumber(data?.total_usage);
if (total === undefined || used === undefined || total < 0 || used < 0) return null;
if (total === 0) return AUTHORITATIVE_EMPTY_QUOTA;
const percent = normalizePercent((used / total) * 100);
if (percent === undefined) return null;
return {
creditsUsd: { used, limit: total, remaining: Math.max(0, total - used), percent },
updatedAt: Date.now(),
};
}
/**
* Abliteration `GET /v1/credits` — the organization credit balance for the active project key.
* The balance funds every inference request on this key, so display and routing scope agree.
* `503 credit_balance_unavailable`, 408 and 429 are transient and keep the last-good row.
*/
async function fetchAbliterationQuota(provider: string, config: OcxProviderConfig): Promise<ProviderQuotaProbeResult> {
// Never send a configured API key to a lookalike host or through a redirect.
if (!isCanonicalAbliterationBaseUrl(config.baseUrl)) return null;
const apiKey = resolveProviderApiKey(config.apiKey)?.trim();
if (!apiKey) return null;
const response = await quotaFetch(provider, config, ABLITERATION_CREDITS_URL, {
headers: { Accept: "application/json", Authorization: `Bearer ${apiKey}` },
redirect: "error",
signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
});
if (!response.ok) {
return response.status >= 400 && response.status < 500 && response.status !== 408 && response.status !== 429
? TERMINAL_QUOTA_FAILURE
: null;
}
const raw = await readQuotaJson(response);
if (raw === QUOTA_JSON_READ_FAILURE) return null;
const quota = parseAbliterationCredits(asRecord(raw));
if (quota === null || quota === AUTHORITATIVE_EMPTY_QUOTA) return quota;
return keyReport(provider, "abliteration:credits", quota, config, apiKey, quota);
}
export function normalizedBaseUrl(value: string): string | null {
try {
const url = new URL(value);
if (url.username || url.password || url.search || url.hash) return null;
return `${url.origin.toLowerCase()}${url.pathname.replace(/\/+$/, "")}`;
} catch {
return null;
}
}
function quotaResetAt(row: Record<string, unknown>): number | undefined {
return normalizeResetAt(row.resetTime ?? row.resetAt ?? row.reset_time ?? row.reset_at);
}
export function isCanonicalKimiCodeBaseUrl(baseUrl: string): boolean {
return normalizedBaseUrl(baseUrl) === KIMI_CODE_BASE_URL;
}
/**
* The Kimi Coding origin whose `/usages` a quota probe may call with this provider's bearer, or
* null. It is always the configured inference origin, matched exactly against Kimi's own origins,
* so a user-edited or lookalike host never receives the credential.
*/
function kimiCodeQuotaBaseUrl(config: Pick<OcxProviderConfig, "baseUrl" | "authMode">): string | null {
const normalized = normalizedBaseUrl(config.baseUrl);
if (normalized === KIMI_CODE_BASE_URL) return normalized;
if (normalized === KIMI_CODE_REGIONAL_BASE_URL && (config.authMode ?? "key") === "key") return normalized;
return null;
}
export function isCanonicalCommandCodeBaseUrl(baseUrl: string): boolean {
const normalized = normalizedBaseUrl(baseUrl);
// OAuth preset points at the API root; the Provider-API preset at /provider/v1.
return normalized === COMMAND_CODE_BASE_URL || normalized === `${COMMAND_CODE_BASE_URL}/provider/v1`;
}
/**
* Pick the envelope carrying the legacy windows (weekly, 5h, total credits). The monthly
* `usages` container is located separately, so its presence never hides a nested window.
*/
function kimiLegacyWindowBody(root: Record<string, unknown>): Record<string, unknown> {
const nested = asRecord(root.data);
if (!nested) return root;
// A null outer field is a placeholder, not data — { usage: null, data: { usage: {...} } } unwraps.
const usable = (field: unknown): boolean => field !== undefined && field !== null;
const hasLegacy = (body: Record<string, unknown>): boolean => usable(body.usage) || usable(body.limits) || usable(body.totalQuota);
return !hasLegacy(root) && hasLegacy(nested) ? nested : root;
}
function kimiLimitLabel(item: Record<string, unknown>, detail: Record<string, unknown>): string {
return [item.name, item.title, item.scope, detail.name, detail.title]
.filter((value): value is string => typeof value === "string")
.join(" ")
.toLowerCase();
}
/** Highest percentage a window with a positive remainder may report; 100 means exhausted. */
const KIMI_BELOW_EXHAUSTED_PERCENT = 99.999;
/**
* Counter-derived percentage, or undefined when the counters cannot be trusted. Any
* exhaustion signal (used at or past the limit, or remaining at or below zero) wins first,
* even beside an impossible companion counter: dropping it would let an over-quota account
* look available. Otherwise a negative used or a remaining above the limit is impossible.
* A positive remainder never rounds up to exhaustion.
*/
function kimiCounterPercent(row: Record<string, unknown>): number | undefined {
const limit = toFiniteNumber(row.limit);
if (limit === undefined || limit <= 0) return undefined;
const used = toFiniteNumber(row.used);
const remaining = toFiniteNumber(row.remaining);
if ((used !== undefined && used >= limit) || (remaining !== undefined && remaining <= 0)) return 100;
if ((used !== undefined && used < 0) || (remaining !== undefined && remaining > limit)) return undefined;
if (used !== undefined) return (used / limit) * 100;
if (remaining === undefined) return undefined;
return Math.min(((limit - remaining) / limit) * 100, KIMI_BELOW_EXHAUSTED_PERCENT);
}
/** Parse consumed usage, preferring valid counters, then a valid [0, 1] ratio, then direct percentages. */
function parseKimiQuotaRow(value: unknown, resetFallback?: Record<string, unknown>): { percent: number; resetAt?: number } | null {
const row = asRecord(value);
if (!row) return null;
const resetAt = quotaResetAt(row) ?? (resetFallback ? quotaResetAt(resetFallback) : undefined);
const counterPercent = kimiCounterPercent(row);
if (counterPercent !== undefined) {
const percent = normalizePercent(counterPercent);
if (percent !== undefined) return { percent, ...(resetAt !== undefined ? { resetAt } : {}) };
}
// Newer Kimi responses expose utilization as a fraction in [0, 1].
const ratio = toFiniteNumber(row.used_ratio ?? row.usedRatio);
if (ratio !== undefined && ratio >= 0 && ratio <= 1) {
const percent = normalizePercent(ratio * 100);
if (percent !== undefined) return { percent, ...(resetAt !== undefined ? { resetAt } : {}) };
}
// Some payloads expose utilisation directly when limit/used arithmetic is absent.
const direct = normalizePercent(row.utilization ?? row.percent ?? row.usedPercent ?? row.used_percent);
return direct === undefined ? null : { percent: direct, ...(resetAt !== undefined ? { resetAt } : {}) };
}
function isKimiFiveHourLimit(item: Record<string, unknown>, detail: Record<string, unknown>, window: Record<string, unknown>): boolean {
const duration = toFiniteNumber(window.duration ?? item.duration ?? detail.duration);
const unit = String(window.timeUnit ?? item.timeUnit ?? detail.timeUnit ?? "").toUpperCase();
if ((unit.includes("MINUTE") && duration === 300) || (unit.includes("HOUR") && duration === 5)) return true;
return /(^|\b)5\s*(?:h|hour)/.test(kimiLimitLabel(item, detail));
}
function isKimiWeeklyLimit(item: Record<string, unknown>, detail: Record<string, unknown>, window: Record<string, unknown>): boolean {
const duration = toFiniteNumber(window.duration ?? item.duration ?? detail.duration);
const unit = String(window.timeUnit ?? item.timeUnit ?? detail.timeUnit ?? "").toUpperCase();
if ((unit.includes("DAY") && duration === 7) || (unit.includes("HOUR") && duration === 168)) return true;
return /weekly|7\s*(?:d|day)/.test(kimiLimitLabel(item, detail));
}
/** Keep legacy windows separate and use the first parseable monthly row across supported envelopes. */
function parseKimiQuotaPayload(value: unknown): ProviderQuota | null {
const root = asRecord(value);
if (!root) return null;
const body = kimiLegacyWindowBody(root);
let weekly = parseKimiQuotaRow(body.usage);
const total = parseKimiQuotaRow(body.totalQuota);
const nested = asRecord(root.data);
let monthly: { percent: number; resetAt?: number } | null = null;
for (const container of [root, nested, asRecord(root.quota), asRecord(nested?.quota)]) {
const usages = asRecord(container?.usages);
if (!usages) continue;
monthly = parseKimiQuotaRow(usages.limit_month_total ?? usages.monthTotal)
?? parseKimiQuotaRow(usages.limit_month_code ?? usages.monthCode);
if (monthly) break;
}
let fiveHour: { percent: number; resetAt?: number } | null = null;
if (Array.isArray(body.limits)) {
for (const rawItem of body.limits) {
const item = asRecord(rawItem);
if (!item) continue;
const detail = asRecord(item.detail) ?? item;
const window = asRecord(item.window) ?? {};
if (!fiveHour && isKimiFiveHourLimit(item, detail, window)) {
fiveHour = parseKimiQuotaRow(detail, window);
}
if (!weekly && isKimiWeeklyLimit(item, detail, window)) {
weekly = parseKimiQuotaRow(detail, window);
}
if (fiveHour && weekly) break;
}
}
const quota: ProviderQuota = {
...(fiveHour ? {
fiveHourPercent: fiveHour.percent,
...(fiveHour.resetAt !== undefined ? { fiveHourResetAt: fiveHour.resetAt } : {}),
} : {}),
...(weekly ? {
weeklyPercent: weekly.percent,
...(weekly.resetAt !== undefined ? { weeklyResetAt: weekly.resetAt } : {}),
} : {}),
...(monthly ? {
monthlyPercent: monthly.percent,
...(monthly.resetAt !== undefined ? { monthlyResetAt: monthly.resetAt } : {}),
} : {}),
...(total ? { customWindows: [{ label: "Total subscription credits", percent: total.percent, ...(total.resetAt !== undefined ? { resetAt: total.resetAt } : {}) }] } : {}),
updatedAt: Date.now(),
};
return hasQuotaRows(quota) ? quota : null;
}
async function resolveKimiQuotaBearer(config: OcxProviderConfig, accountId?: string): Promise<string | null> {
if (config.authMode === "oauth") {
try {
return accountId ? await getTokenForAccountQuotaProbe("kimi", accountId) : null;
} catch {
return null;
}
}
// ACTIVE key only: silently walking apiKeyPool when the primary env reference is
// unresolved would render a quota bar for a DIFFERENT account than the one routing
// requests — a wrong meter is worse than no meter.
const primary = resolveProviderApiKey(config.apiKey)?.trim();
return primary || null;
}
export async function fetchKimiQuota(provider: string, config: OcxProviderConfig, accessToken: string): Promise<ProviderQuotaReport | null> {
// Never release credentials to a user-edited or lookalike provider host.
const baseUrl = kimiCodeQuotaBaseUrl(config);
if (!baseUrl) return null;
if (!accessToken) return null;
const response = await quotaFetch(provider, config, `${baseUrl}/usages`, {
headers: { Accept: "application/json", Authorization: `Bearer ${accessToken}` },
redirect: "error",
signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
});
if (!response.ok) return null;
const quota = parseKimiQuotaPayload(await readQuotaJson(response));
return quota ? keyReport(provider, "kimi:usages", quota, config, accessToken, quota) : null;
}
/**
* Command Code rolling window: `{ cap, used, resetAt }` off /alpha/billing/credits,
* normalized to a percent with an optional reset timestamp.
*/
function parseCommandCodeWindow(value: unknown): { percent: number; resetAt?: number } | null {
const row = asRecord(value);
if (!row) return null;
const cap = toFiniteNumber(row.cap);
const used = toFiniteNumber(row.used);
if (cap === undefined || used === undefined || cap <= 0 || used < 0) return null;
const percent = normalizePercent((used / cap) * 100);
if (percent === undefined) return null;
const resetAt = quotaResetAt(row);
return { percent, ...(resetAt !== undefined ? { resetAt } : {}) };
}
/** Soft-fail GET returning a parsed record, or null when unavailable. */
async function fetchCommandCodeJson(
provider: string,
config: OcxProviderConfig,
url: string,
bearer: string,
): Promise<Record<string, unknown> | null> {
try {
const response = await quotaFetch(provider, config, url, {
headers: { Accept: "application/json", Authorization: `Bearer ${bearer}` },
redirect: "error",
signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
});
if (!response.ok) return null;
return asRecord(await readQuotaJson(response));
} catch {
return null;
}
}
/**
* Soft-fail period spend (used) against the remaining credit pools → creditsUsd.
* Period scoping: `since=<currentPeriodStart>` keeps spend aligned with the
* pools' billing cycle, and `currentPeriodEnd` becomes expiresAt.
*/
async function fetchCommandCodeSpend(
provider: string,
config: OcxProviderConfig,
bearer: string,
credits: Record<string, unknown> | null,
orgQuery: string,
): Promise<ProviderQuotaCreditsUsd | undefined> {
if (!credits) return undefined;
const subscriptionBody = await fetchCommandCodeJson(provider, config, `${COMMAND_CODE_SUBSCRIPTIONS_URL}${orgQuery}`, bearer);
const subscription = asRecord(subscriptionBody?.data) ?? subscriptionBody;
const periodStart = typeof subscription?.currentPeriodStart === "string" ? subscription.currentPeriodStart.trim() : "";
// Unscoped /usage/summary is lifetime spend; mixing it with current-cycle
// remaining pools produces a wrong percent. Omit creditsUsd until a period exists.
if (!periodStart) return undefined;
const sinceQuery = `${orgQuery ? "&" : "?"}since=${encodeURIComponent(periodStart)}`;
const expiresAt = normalizeResetAt(subscription?.currentPeriodEnd);
const summaryBody = await fetchCommandCodeJson(provider, config, `${COMMAND_CODE_USAGE_URL}${orgQuery}${sinceQuery}`, bearer);
const summary = asRecord(summaryBody?.data) ?? summaryBody;
const used = toFiniteNumber(summary?.totalCost) ?? toFiniteNumber(summary?.totalMonthlyCredits);
if (used === undefined || used < 0) return undefined;
const pools = [credits.monthlyCredits, credits.purchasedCredits, credits.freeCredits]
.map(value => toFiniteNumber(value))
.filter((value): value is number => value !== undefined);
// Field presence is what separates a real balance from absent data: an exhausted
// all-zero account still reports remaining=0, while no remaining-credit field at
// all means there is nothing to meter.
if (pools.length === 0) return undefined;
const remaining = pools.reduce((sum, value) => sum + Math.max(0, value ?? 0), 0);
const limit = used + remaining;
const percent = normalizePercent(limit > 0 ? (used / limit) * 100 : 0);
// Purchased credits roll over past the subscription period end, so an expiry is
// only truthful when the aggregate contains no non-expiring purchased pool.
const purchased = toFiniteNumber(credits.purchasedCredits) ?? 0;
return percent === undefined
? undefined
: {
used,
limit,
remaining,
percent,
...(expiresAt !== undefined && purchased <= 0 ? { expiresAt } : {}),
};
}
/** OAuth access token or ACTIVE Provider-API key for the Command Code quota probe. */
async function resolveCommandCodeQuotaBearer(config: OcxProviderConfig, accountId?: string): Promise<string | null> {
if (config.authMode === "oauth") {
try {
return accountId ? await getTokenForAccountQuotaProbe("command-code", accountId) : null;
} catch {
return null;
}
}
// ACTIVE key only: a quota bar for a different account than the one routing
// requests is a wrong meter, not a helpful one.
return resolveProviderApiKey(config.apiKey)?.trim() || null;
}
/**
* Command Code `GET /alpha/billing/credits` — the same Bearer surface the CLI's
* usage view uses (windowLimits.fiveHour / windowLimits.weekly), plus soft
* whoami (team orgId scoping) and subscription-scoped spend for creditsUsd.
*/
export async function fetchCommandCodeQuota(provider: string, config: OcxProviderConfig, bearer: string): Promise<ProviderQuotaProbeResult> {
// Never release credentials to a user-edited or lookalike provider host.
if (!isCanonicalCommandCodeBaseUrl(config.baseUrl)) return null;
if (!bearer) return null;
const whoamiBody = await fetchCommandCodeJson(provider, config, COMMAND_CODE_WHOAMI_URL, bearer);
const whoami = asRecord(whoamiBody?.data) ?? whoamiBody;
const org = asRecord(whoami?.org);
const orgId = typeof org?.id === "string" && org.id.trim() ? org.id.trim() : null;
const orgQuery = orgId ? `?orgId=${encodeURIComponent(orgId)}` : "";
const response = await quotaFetch(provider, config, `${COMMAND_CODE_CREDITS_URL}${orgQuery}`, {
headers: { Accept: "application/json", Authorization: `Bearer ${bearer}` },
redirect: "error",
signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
});
if (!response.ok) {
return response.status >= 400 && response.status < 500 && response.status !== 408 && response.status !== 429
? TERMINAL_QUOTA_FAILURE
: null;
}
const raw = asRecord(await readQuotaJson(response));
const body = asRecord(raw?.data) ?? raw;
const credits = asRecord(body?.credits);
const limits = asRecord(body?.windowLimits);
if (!credits && !limits) return null;
const fiveHour = parseCommandCodeWindow(limits?.fiveHour);
const weekly = parseCommandCodeWindow(limits?.weekly);
const creditsUsd = await fetchCommandCodeSpend(provider, config, bearer, credits, orgQuery);
const quota: ProviderQuota = {
...(fiveHour ? {
fiveHourPercent: fiveHour.percent,
...(fiveHour.resetAt !== undefined ? { fiveHourResetAt: fiveHour.resetAt } : {}),
} : {}),
...(weekly ? {
weeklyPercent: weekly.percent,
...(weekly.resetAt !== undefined ? { weeklyResetAt: weekly.resetAt } : {}),
} : {}),
...(creditsUsd ? { creditsUsd } : {}),
updatedAt: Date.now(),
};
// Rolling windows and the credit balance both gate inference on this bearer.
return keyReport(provider, "command-code:credits", quota, config, bearer, quota);
}
type KeyQuotaReader = (name: string, provider: OcxProviderConfig) => Promise<ProviderQuotaProbeResult>;
/** Same selector drives cheap capabilities and uncached reads; never resolves credentials. */
export function keyQuotaReaderForProvider(name: string, provider: OcxProviderConfig): KeyQuotaReader | null {
if (provider.disabled === true || (provider.authMode ?? "key") !== "key") return null;
if (kimiCodeQuotaBaseUrl(provider)) {
return async (id, config) => {
const bearer = await resolveKimiQuotaBearer(config);
return bearer ? fetchKimiQuota(id, config, bearer) : null;
};
}
if (name === "commandcode" && isCanonicalCommandCodeBaseUrl(provider.baseUrl)) {
return async (id, config) => {
const bearer = await resolveCommandCodeQuotaBearer(config);
return bearer ? fetchCommandCodeQuota(id, config, bearer) : null;
};
}
if (registryEntryForProviderDestination(provider)?.id === "opencode-go") return fetchOpenCodeGoQuota;
if (isCanonicalA6apiBaseUrl(provider.baseUrl)) return fetchA6apiQuota;
if (name === "openrouter" && isCanonicalOpenRouterBaseUrl(provider.baseUrl)) return fetchOpenRouterQuota;
if (name === "deepseek" && isCanonicalDeepSeekBaseUrl(provider.baseUrl)) return fetchDeepSeekQuota;
// The canonical-URL guard alone decides eligibility, so a custom provider name that points
// at Mistral's own origin still probes, and a Mistral-named lookalike still dispatches nothing.
if (isCanonicalMistralBaseUrl(provider.baseUrl)) return fetchMistralQuota;
if (name === "cline-pass" && isCanonicalClineBaseUrl(provider.baseUrl)) return fetchClineQuota;
if (isCanonicalOllamaCloudBaseUrl(provider.baseUrl ?? getProviderRegistryEntry(name)?.baseUrl)) return fetchOllamaCloudQuota;
// #4201: the Responses preset is the same domestic GLM Coding Plan subscription on the OpenAI
// Responses wire, so it reads the same monitor endpoint. Eligibility stays a name list AND the
// canonical-URL guard: the guard is what keeps BigModel's bare-key Authorization from reaching a
// lookalike host, so a same-named custom destination still dispatches nothing.
if (["zai", "glm", "glm-cn", "zhipu-bigmodel-coding", "zhipu-bigmodel-responses"].includes(name) && isCanonicalZaiBaseUrl(provider.baseUrl)) return fetchZaiQuota;
if (["minimax", "minimax-cn"].includes(name) && isCanonicalMinimaxBaseUrl(provider.baseUrl)) return fetchMinimaxQuota;
if (name === "moonshot" && isCanonicalMoonshotBaseUrl(provider.baseUrl)) return fetchMoonshotQuota;
if (name === "venice" && isCanonicalVeniceBaseUrl(provider.baseUrl)) return fetchVeniceQuota;
if (name === "synthetic" && isCanonicalSyntheticBaseUrl(provider.baseUrl)) return fetchSyntheticQuota;
if (name === "deepinfra" && isCanonicalDeepInfraBaseUrl(provider.baseUrl)) return fetchDeepInfraQuota;
if (name === "neuralwatt" && isCanonicalNeuralwattBaseUrl(provider.baseUrl)) return fetchNeuralwattQuota;
// Abliteration has no registry preset, so it is usually a custom provider under any name; the
// canonical-URL guard alone decides eligibility and keeps the key off lookalike hosts.
if (isCanonicalAbliterationBaseUrl(provider.baseUrl)) return fetchAbliterationQuota;
return null;
}
export function providerApiKeyQuotaMode(name: string, provider: OcxProviderConfig): AccountQuotaMode {
return keyQuotaReaderForProvider(name, provider) ? "probe" : "unsupported";
}