@astrosheep/pi-quota 0.12.0 → 0.12.2

package/dist/query/new-api.js

@@ -0,0 +1,180 @@
+import { bearer } from "./http.js";
+import { numeric, object } from "./parse.js";
+import { QuotaError } from "./types.js";
+import { safeBaseUrl } from "./url.js";
+export function validateNewApiOptions(options) {
+    const quotaPerUnit = options.quotaPerUnit ?? 500000;
+    const currency = options.currency ?? 'USD';
+    if (!Number.isFinite(quotaPerUnit) || quotaPerUnit <= 0)
+        throw new Error('quotaPerUnit must be a positive number');
+    if (typeof currency !== 'string' || !/^[A-Z]{3}$/.test(currency))
+        throw new Error('currency must be a three-letter uppercase code');
+    return { quotaPerUnit, currency };
+}
+// Billing endpoints live at the deployment root, never under /v1.
+// https://host/v1 -> https://host, https://host/gateway/v1 -> https://host/gateway
+export function newApiRootUrl(baseUrl) {
+    const url = safeBaseUrl(baseUrl);
+    const path = url.pathname.replace(/\/+$/, '').replace(/\/v\d+(?:beta\d*)?$/i, '');
+    return url.origin + path;
+}
+// GET /api/usage/token (new-api >= v0.9.0-alpha.8, PR QuantumNous/new-api#1161):
+// accepts the sk- model key itself (TokenAuth), returns per-token quota in
+// the same unit as /api/user/self quota. Response shell: {code:true,data:{...}}.
+export function parseNewApiTokenUsage(payload, options = {}) {
+    const { quotaPerUnit, currency } = validateNewApiOptions(options);
+    const response = object(payload);
+    if (response.code !== true)
+        return null;
+    const data = object(response.data);
+    if (data.object !== 'token_usage')
+        return null;
+    const used = numeric(data.total_used);
+    if (used === null || !Number.isSafeInteger(used) || used < 0)
+        throw new QuotaError('schema');
+    if (data.unlimited_quota === true) {
+        return { balance: { currency, remaining: 0, unlimited: true },
+            spend: { currency, lifetime: used / quotaPerUnit } };
+    }
+    const remaining = numeric(data.total_available);
+    if (remaining === null || !Number.isSafeInteger(remaining))
+        throw new QuotaError('schema');
+    const moneyLeft = remaining / quotaPerUnit;
+    if (!Number.isFinite(moneyLeft))
+        throw new QuotaError('schema');
+    // New-api reports granted = key used + key remaining. Only draw a finite
+    // allocation bar when the server actually supplies that total.
+    if (data.total_granted !== undefined) {
+        const granted = numeric(data.total_granted);
+        if (granted === null || !Number.isSafeInteger(granted) || granted < 0
+            || !Number.isSafeInteger(used + remaining) || granted !== used + remaining)
+            throw new QuotaError('schema');
+        if (granted > 0)
+            return { allowance: { currency, limit: granted / quotaPerUnit,
+                    used: used / quotaPerUnit, remaining: moneyLeft } };
+    }
+    return { balance: { currency, remaining: moneyLeft },
+        spend: { currency, lifetime: used / quotaPerUnit } };
+}
+// GET /api/user/self (UserAuth): the console's own account quota, readable with
+// a dashboard access token (PAT), which sk- keys are not. Old forks also demand
+// a matching New-Api-User header. Response shell: {success:true,data:{...}}.
+export function parseNewApiUserSelf(payload, options = {}) {
+    const { quotaPerUnit, currency } = validateNewApiOptions(options);
+    const response = object(payload);
+    if (response.success !== true)
+        throw new QuotaError('schema');
+    const data = object(response.data);
+    const quota = numeric(data.quota);
+    const usedQuota = numeric(data.used_quota);
+    if (quota === null || usedQuota === null
+        || !Number.isSafeInteger(quota) || !Number.isSafeInteger(usedQuota)
+        || quota < 0 || usedQuota < 0)
+        throw new QuotaError('schema');
+    return { balance: { currency, remaining: quota / quotaPerUnit },
+        spend: { currency, lifetime: usedQuota / quotaPerUnit } };
+}
+// Legacy one-api billing pair, still the only option on older deployments.
+// total_usage is in cents (divide by 100, per one-api issue #1785); most
+// deployments report a fake 1e8 hard limit for unlimited quotas.
+export function parseNewApiBilling(subscription, usage, options = {}) {
+    const { currency } = validateNewApiOptions(options);
+    const sub = object(subscription);
+    const limit = numeric(sub.hard_limit_usd);
+    const list = object(usage);
+    const totalUsage = numeric(list.total_usage);
+    if (limit === null || !Number.isFinite(limit) || limit < 0
+        || totalUsage === null || !Number.isFinite(totalUsage) || totalUsage < 0)
+        throw new QuotaError('schema');
+    const used = totalUsage / 100;
+    // This endpoint reports account remaining + lifetime usage as its hard limit.
+    // Top-ups change that total, so it is a wallet balance, not a fixed allowance.
+    if (limit >= 1e7)
+        return { balance: { currency, remaining: 0, unlimited: true },
+            spend: { currency, lifetime: used } };
+    return { balance: { currency, remaining: limit - used },
+        spend: { currency, lifetime: used } };
+}
+export function createNewApiAdapter(provider, options = {}) {
+    const settings = validateNewApiOptions(options);
+    const { dashboardAccessToken, dashboardUserId } = options;
+    if (dashboardAccessToken !== undefined
+        && (typeof dashboardAccessToken !== 'string' || dashboardAccessToken.trim() === '')) {
+        throw new Error('dashboardAccessToken must be a non-empty string');
+    }
+    if (dashboardUserId !== undefined
+        && (!Number.isSafeInteger(dashboardUserId) || dashboardUserId <= 0)) {
+        throw new Error('dashboardUserId must be a positive integer');
+    }
+    return {
+        provider, label: provider,
+        async query(context) {
+            let auth;
+            try {
+                auth = await context.getAuth(context.provider);
+            }
+            catch {
+                throw new QuotaError('auth');
+            }
+            context.signal.throwIfAborted();
+            if (!auth)
+                throw new QuotaError('auth');
+            const root = newApiRootUrl(auth.baseUrl);
+            // 0. Console account balance via PAT: the only view of real remaining
+            // account quota. Any failure falls through to the key-native paths.
+            if (dashboardAccessToken !== undefined) {
+                const headers = { Authorization: `Bearer ${dashboardAccessToken}` };
+                if (dashboardUserId !== undefined)
+                    headers['New-Api-User'] = String(dashboardUserId);
+                try {
+                    const payload = await context.getJson(`${root}/api/user/self`, headers, context.signal);
+                    return { windows: [], ...parseNewApiUserSelf(payload, settings), fetchedAt: context.now() };
+                }
+                catch (error) {
+                    if (!(error instanceof QuotaError))
+                        throw error;
+                }
+            }
+            const headers = { Authorization: `Bearer ${bearer(auth)}` };
+            // 1. Account billing (one-api legacy): a finite hard limit is the real
+            // account balance. 1e8 means unlimited — then the key quota may still
+            // be finite and more precise.
+            let billingBalance = null;
+            try {
+                const pair = await Promise.all([
+                    context.getJson(`${root}/v1/dashboard/billing/subscription`, headers, context.signal),
+                    context.getJson(`${root}/v1/dashboard/billing/usage?start_date=2020-01-01&end_date=2100-01-01`, headers, context.signal),
+                ]);
+                const billing = parseNewApiBilling(pair[0], pair[1], settings);
+                if (billing.balance?.unlimited !== true)
+                    return { windows: [], ...billing, fetchedAt: context.now() };
+                billingBalance = billing;
+            }
+            catch (error) {
+                // 404: deployment has no billing pair. 401: try the key-native endpoint
+                // below — some deployments accept sk- only there.
+                if (error instanceof QuotaError && (error.code === 'http' || error.code === 'auth')) { /* fall through */ }
+                else
+                    throw error;
+            }
+            // 2. Per-token usage (new-api ≥ v0.9.0-alpha.8): native sk- support.
+            try {
+                const payload = await context.getJson(`${root}/api/usage/token/`, headers, context.signal);
+                const parsed = parseNewApiTokenUsage(payload, settings);
+                if (parsed)
+                    return { windows: [], ...parsed, fetchedAt: context.now() };
+            }
+            catch (error) {
+                if (billingBalance && error instanceof QuotaError && error.code === 'http') {
+                    return { windows: [], ...billingBalance, fetchedAt: context.now() };
+                }
+                if (error instanceof QuotaError && error.code === 'auth')
+                    throw new QuotaError('account-access');
+                throw error;
+            }
+            if (billingBalance)
+                return { windows: [], ...billingBalance, fetchedAt: context.now() };
+            throw new QuotaError('schema');
+        },
+    };
+}

package/dist/query/opencode-go.d.ts

@@ -0,0 +1,4 @@
+import type { QuotaAdapter, QuotaWindow } from './types.js';
+export declare function parseOpenCodeGo(payload: unknown): QuotaWindow[];
+export declare function createOpenCodeGoAdapter(provider: string): QuotaAdapter;
+export declare const openCodeGoAdapter: QuotaAdapter;

package/dist/query/opencode-go.js

@@ -0,0 +1,46 @@
+import { bearer, officialAuth } from "./http.js";
+import { numeric, object, percent, timestamp, windowLabel } from "./parse.js";
+import { QuotaError } from "./types.js";
+// OpenCode Go (opencode.ai Zen Go plan) is a single official deployment, so the
+// window keys are fixed and undecorated: percent is already "used", and there is
+// no dollar balance — only the console shows money.
+const WINDOWS = [
+    { key: 'rolling', duration: 18000 }, // 5 hours
+    { key: 'weekly', duration: 604800 }, // 7 days
+    { key: 'monthly', duration: 2592000 }, // 30 days
+];
+export function parseOpenCodeGo(payload) {
+    const usage = object(object(payload).usage);
+    const windows = [];
+    for (const { key, duration } of WINDOWS) {
+        if (usage[key] === undefined)
+            continue;
+        const detail = object(usage[key]);
+        const used = numeric(detail.percent);
+        windows.push({
+            id: key, label: windowLabel(duration), durationSeconds: duration,
+            // Absent or malformed percent stays unknown; never fabricate a window.
+            remainingPercent: used === null ? null : percent(100 - used),
+            resetAt: timestamp(detail.resetsAt),
+        });
+    }
+    if (windows.length === 0)
+        throw new QuotaError('schema');
+    return windows;
+}
+// A second OpenCode Go account is just another Pi provider ID (configured in
+// models.json with its own apiKey); auth and endpoint stay official regardless.
+export function createOpenCodeGoAdapter(provider) {
+    return {
+        provider,
+        label: provider === 'opencode-go' ? 'OpenCode Go' : `OpenCode Go (${provider})`,
+        async query(context) {
+            const auth = await officialAuth(context, 'https://opencode.ai');
+            const data = await context.getJson('https://opencode.ai/zen/go/v1/usage', {
+                Authorization: `Bearer ${bearer(auth)}`,
+            }, context.signal);
+            return { windows: parseOpenCodeGo(data), fetchedAt: context.now() };
+        },
+    };
+}
+export const openCodeGoAdapter = createOpenCodeGoAdapter('opencode-go');

package/dist/query/parse.d.ts

@@ -0,0 +1,6 @@
+export declare function object(value: unknown): Record<string, unknown>;
+export declare function numeric(value: unknown): number | null;
+export declare function percent(value: number): number;
+export declare function timestamp(value: unknown): number | null;
+export declare function windowLabel(seconds: number): string;
+export declare function safeLabel(value: string): string;

package/dist/query/parse.js

@@ -0,0 +1,35 @@
+export function object(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value : {};
+}
+export function numeric(value) {
+    if (typeof value !== 'number' && !(typeof value === 'string' && value.trim() !== ''))
+        return null;
+    const result = Number(value);
+    return Number.isFinite(result) ? result : null;
+}
+export function percent(value) {
+    return Math.max(0, Math.min(100, value));
+}
+export function timestamp(value) {
+    const number = numeric(value);
+    const parsed = number !== null
+        ? (number < 1e12 ? number * 1000 : number)
+        : typeof value === 'string' ? Date.parse(value) : NaN;
+    return Number.isFinite(parsed) && parsed > 0 && parsed <= 8.64e15 ? parsed : null;
+}
+export function windowLabel(seconds) {
+    if (seconds === 604800)
+        return '1w';
+    if (seconds % 86400 === 0)
+        return `${seconds / 86400}d`;
+    if (seconds % 3600 === 0)
+        return `${seconds / 3600}h`;
+    if (seconds % 60 === 0)
+        return `${seconds / 60}m`;
+    return `${seconds}s`;
+}
+// API-controlled labels may not inject terminal controls, ANSI, or newlines.
+export function safeLabel(value) {
+    return value.replace(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu, '').slice(0, 64);
+}

package/dist/query/registry.d.ts

@@ -0,0 +1,9 @@
+import type { QuotaAdapter, QuotaSnapshot } from './types.js';
+export declare class AdapterRegistry {
+    private readonly adapters;
+    constructor(adapters?: readonly QuotaAdapter[]);
+    register(adapter: QuotaAdapter): void;
+    get(provider: string | undefined): QuotaAdapter | undefined;
+    list(): readonly QuotaAdapter[];
+}
+export declare function validateSnapshot(snapshot: QuotaSnapshot): QuotaSnapshot;

package/dist/query/registry.js

@@ -0,0 +1,78 @@
+import { safeLabel } from "./parse.js";
+import { QuotaError } from "./types.js";
+export class AdapterRegistry {
+    adapters = new Map();
+    constructor(adapters = []) {
+        for (const adapter of adapters)
+            this.register(adapter);
+    }
+    register(adapter) {
+        if (!adapter.provider || !adapter.label || this.adapters.has(adapter.provider)) {
+            throw new Error('Quota adapter must have a unique provider ID and a label');
+        }
+        this.adapters.set(adapter.provider, { ...adapter, label: safeLabel(adapter.label) });
+    }
+    get(provider) {
+        return provider ? this.adapters.get(provider) : undefined;
+    }
+    list() {
+        return [...this.adapters.values()];
+    }
+}
+// Validate even custom adapter output before it reaches the bar.
+export function validateSnapshot(snapshot) {
+    if (!snapshot || !Number.isFinite(snapshot.fetchedAt) || !Array.isArray(snapshot.windows)
+        || (snapshot.windows.length === 0 && snapshot.balance === undefined
+            && snapshot.allowance === undefined)
+        || snapshot.windows.length > 64)
+        throw new QuotaError('schema');
+    let balance;
+    if (snapshot.balance !== undefined) {
+        const data = snapshot.balance;
+        if (!data || typeof data.currency !== 'string' || !/^[A-Z]{3}$/.test(data.currency)
+            || !Number.isFinite(data.remaining)
+            || (data.unlimited !== undefined && typeof data.unlimited !== 'boolean'))
+            throw new QuotaError('schema');
+        balance = { currency: data.currency, remaining: data.remaining,
+            ...(data.unlimited === true ? { unlimited: true } : {}) };
+    }
+    const allowance = snapshot.allowance === undefined ? undefined : validateAllowance(snapshot.allowance);
+    let spend;
+    if (snapshot.spend !== undefined) {
+        const data = snapshot.spend;
+        if (!data || typeof data.currency !== 'string' || !/^[A-Z]{3}$/.test(data.currency)
+            || (data.today === undefined && data.lifetime === undefined)
+            || (data.today !== undefined && (!Number.isFinite(data.today) || data.today < 0))
+            || (data.lifetime !== undefined && (!Number.isFinite(data.lifetime) || data.lifetime < 0))) {
+            throw new QuotaError('schema');
+        }
+        spend = { currency: data.currency, ...(data.today !== undefined ? { today: data.today } : {}),
+            ...(data.lifetime !== undefined ? { lifetime: data.lifetime } : {}) };
+    }
+    const ids = new Set();
+    const windows = snapshot.windows.map(window => {
+        if (!window || typeof window.id !== 'string' || ids.has(window.id)
+            || typeof window.label !== 'string'
+            || (window.scope !== undefined && typeof window.scope !== 'string')
+            || !Number.isFinite(window.durationSeconds) || window.durationSeconds <= 0
+            || (window.remainingPercent !== null && (!Number.isFinite(window.remainingPercent)
+                || window.remainingPercent < 0 || window.remainingPercent > 100))
+            || (window.resetAt !== null && (!Number.isFinite(window.resetAt) || window.resetAt <= 0))) {
+            throw new QuotaError('schema');
+        }
+        ids.add(window.id);
+        return { ...window, label: safeLabel(window.label),
+            ...(window.amounts !== undefined ? { amounts: validateAllowance(window.amounts) } : {}),
+            ...(window.scope !== undefined ? { scope: safeLabel(window.scope) } : {}) };
+    });
+    return { fetchedAt: snapshot.fetchedAt, windows, ...(balance ? { balance } : {}),
+        ...(allowance ? { allowance } : {}), ...(spend ? { spend } : {}) };
+}
+function validateAllowance(data) {
+    if (!data || typeof data.currency !== 'string' || !/^[A-Z]{3}$/.test(data.currency)
+        || !Number.isFinite(data.limit) || data.limit <= 0
+        || !Number.isFinite(data.used) || data.used < 0
+        || !Number.isFinite(data.remaining))
+        throw new QuotaError('schema');
+    return { currency: data.currency, limit: data.limit, used: data.used, remaining: data.remaining };
+}

package/dist/query/settings.d.ts

@@ -0,0 +1,50 @@
+import { AdapterRegistry } from './registry.js';
+import type { NewApiOptions } from './new-api.js';
+import type { YesCodeOptions } from './yescode.js';
+import type { QuotaAdapter } from './types.js';
+export type FooterWindows = number | 'all';
+export type ProviderQuotaConfig = ({
+    adapter: 'new-api';
+    quotaPerUnit: number;
+    currency: string;
+} & Pick<NewApiOptions, 'dashboardAccessToken' | 'dashboardUserId'>) | ({
+    adapter: 'yescode';
+} & YesCodeOptions) | {
+    adapter: 'exec';
+    command: string[];
+    label: string;
+} | {
+    adapter: 'alias';
+    of: string;
+} | {
+    adapter: 'deepseek' | 'sub2api' | 'opencode-go';
+};
+export interface QuotaConfig {
+    providers: Record<string, ProviderQuotaConfig>;
+    footerWindows?: FooterWindows;
+}
+export declare class QuotaConfigError extends Error {
+    constructor();
+}
+export declare function parseQuotaConfig(value: unknown): QuotaConfig;
+export declare function loadQuotaFooterWindows(settings: unknown): FooterWindows | undefined;
+export declare function loadQuotaAdaptersFromSettings(settings: unknown): QuotaAdapter[];
+export declare function loadQuotaAliasesFromSettings(settings: unknown): Record<string, string>;
+export interface ComposedQuota {
+    registry: AdapterRegistry;
+    aliases: Record<string, string>;
+    footerWindows: FooterWindows | undefined;
+}
+/**
+ * The full quota surface in one place: built-in adapters, settings-bound adapters
+ * and aliases wired exactly as the Pi extension does. Settings are deliberate user
+ * bindings, so they take precedence over defaults; AdapterRegistry still detects an
+ * ambiguous duplicate among explicit adapters. Alias providers share their target's
+ * account: one hop only, and a dangling alias stays visible as an error instead of
+ * vanishing silently.
+ */
+export declare function composeQuotaRegistry(input?: {
+    settings?: unknown;
+    adapters?: readonly QuotaAdapter[];
+    aliases?: Record<string, string>;
+}): ComposedQuota;

package/dist/query/settings.js

@@ -0,0 +1,172 @@
+import { createAliasAdapter, createDanglingAliasAdapter } from "./alias.js";
+import { codexAdapter } from "./codex.js";
+import { createDeepSeekAdapter } from "./deepseek.js";
+import { createExecAdapter, validateExecOptions } from "./exec.js";
+import { kimiAdapter } from "./kimi.js";
+import { createNewApiAdapter, validateNewApiOptions } from "./new-api.js";
+import { createOpenCodeGoAdapter, openCodeGoAdapter } from "./opencode-go.js";
+import { AdapterRegistry } from "./registry.js";
+import { createSub2ApiAdapter } from "./sub2api.js";
+import { createYesCodeAdapter, validateYesCodeOptions } from "./yescode.js";
+const DASHBOARD_KEYS = ['dashboardAccessToken', 'dashboardUserId'];
+function parseDashboardOptions(item) {
+    const result = {};
+    if (item.dashboardAccessToken !== undefined) {
+        if (typeof item.dashboardAccessToken !== 'string' || item.dashboardAccessToken.trim() === '')
+            throw new QuotaConfigError();
+        result.dashboardAccessToken = item.dashboardAccessToken;
+    }
+    if (item.dashboardUserId !== undefined) {
+        if (typeof item.dashboardUserId !== 'number'
+            || !Number.isSafeInteger(item.dashboardUserId) || item.dashboardUserId <= 0)
+            throw new QuotaConfigError();
+        result.dashboardUserId = item.dashboardUserId;
+    }
+    return result;
+}
+function parseFooterWindows(value) {
+    if (value === 'all')
+        return value;
+    if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 1)
+        return value;
+    throw new QuotaConfigError();
+}
+export class QuotaConfigError extends Error {
+    constructor() {
+        // Settings may accidentally contain secrets. Never echo content/values.
+        super('Invalid settings.json quotaUsage. Use providers with adapter "new-api", "deepseek", "sub2api", "opencode-go", "yescode", "exec" or "alias", and optionally footerWindows as a positive integer or "all".');
+    }
+}
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+export function parseQuotaConfig(value) {
+    if (!record(value) || Object.keys(value).some(key => key !== 'providers' && key !== 'footerWindows')
+        || !record(value.providers) || Object.keys(value.providers).length > 64)
+        throw new QuotaConfigError();
+    const providers = Object.create(null);
+    for (const [provider, item] of Object.entries(value.providers)) {
+        if (!/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/.test(provider)
+            || ['openai-codex', 'kimi-coding', 'opencode-go'].includes(provider)
+            || !record(item))
+            throw new QuotaConfigError();
+        if (item.adapter === 'deepseek') {
+            if (Object.keys(item).some(key => key !== 'adapter'))
+                throw new QuotaConfigError();
+            providers[provider] = { adapter: 'deepseek' };
+            continue;
+        }
+        if (item.adapter === 'sub2api' || item.adapter === 'opencode-go') {
+            if (Object.keys(item).length !== 1)
+                throw new QuotaConfigError();
+            providers[provider] = { adapter: item.adapter };
+            continue;
+        }
+        if (item.adapter === 'yescode') {
+            if (Object.keys(item).some(key => !['adapter', 'username', 'password'].includes(key))
+                || typeof item.username !== 'string' || typeof item.password !== 'string')
+                throw new QuotaConfigError();
+            try {
+                providers[provider] = { adapter: 'yescode',
+                    ...validateYesCodeOptions({ username: item.username, password: item.password }) };
+            }
+            catch {
+                throw new QuotaConfigError();
+            }
+            continue;
+        }
+        if (item.adapter === 'exec') {
+            if (Object.keys(item).some(key => !['adapter', 'command', 'label'].includes(key)))
+                throw new QuotaConfigError();
+            try {
+                providers[provider] = { adapter: 'exec', ...validateExecOptions(item) };
+            }
+            catch {
+                throw new QuotaConfigError();
+            }
+            continue;
+        }
+        if (item.adapter === 'alias') {
+            if (Object.keys(item).some(key => key !== 'adapter' && key !== 'of')
+                || typeof item.of !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/.test(item.of)
+                || item.of === provider)
+                throw new QuotaConfigError();
+            providers[provider] = { adapter: 'alias', of: item.of };
+            continue;
+        }
+        if (item.adapter !== 'new-api'
+            || Object.keys(item).some(key => !['adapter', 'quotaPerUnit', 'currency', ...DASHBOARD_KEYS].includes(key))
+            || (item.quotaPerUnit !== undefined && typeof item.quotaPerUnit !== 'number')
+            || (item.currency !== undefined && typeof item.currency !== 'string'))
+            throw new QuotaConfigError();
+        try {
+            const settings = validateNewApiOptions({ quotaPerUnit: item.quotaPerUnit, currency: item.currency });
+            providers[provider] = { adapter: 'new-api', ...settings, ...parseDashboardOptions(item) };
+        }
+        catch {
+            throw new QuotaConfigError();
+        }
+    }
+    const config = { providers };
+    if (value.footerWindows !== undefined)
+        config.footerWindows = parseFooterWindows(value.footerWindows);
+    return config;
+}
+export function loadQuotaFooterWindows(settings) {
+    if (!record(settings) || settings.quotaUsage === undefined)
+        return undefined;
+    return parseQuotaConfig(settings.quotaUsage).footerWindows;
+}
+export function loadQuotaAdaptersFromSettings(settings) {
+    if (!record(settings) || settings.quotaUsage === undefined)
+        return [];
+    const config = parseQuotaConfig(settings.quotaUsage);
+    return Object.entries(config.providers).flatMap(([provider, options]) => {
+        switch (options.adapter) {
+            case 'alias': return []; // Aliases declare no adapter; extension.ts wires them.
+            case 'deepseek': return createDeepSeekAdapter(provider);
+            case 'sub2api': return createSub2ApiAdapter(provider);
+            case 'opencode-go': return createOpenCodeGoAdapter(provider);
+            case 'yescode': return createYesCodeAdapter(provider, options);
+            case 'exec': return createExecAdapter(provider, options);
+            case 'new-api': return createNewApiAdapter(provider, options);
+        }
+    });
+}
+export function loadQuotaAliasesFromSettings(settings) {
+    if (!record(settings) || settings.quotaUsage === undefined)
+        return {};
+    const config = parseQuotaConfig(settings.quotaUsage);
+    const aliases = Object.create(null);
+    for (const [provider, options] of Object.entries(config.providers)) {
+        if (options.adapter === 'alias')
+            aliases[provider] = options.of;
+    }
+    return aliases;
+}
+/**
+ * The full quota surface in one place: built-in adapters, settings-bound adapters
+ * and aliases wired exactly as the Pi extension does. Settings are deliberate user
+ * bindings, so they take precedence over defaults; AdapterRegistry still detects an
+ * ambiguous duplicate among explicit adapters. Alias providers share their target's
+ * account: one hop only, and a dangling alias stays visible as an error instead of
+ * vanishing silently.
+ */
+export function composeQuotaRegistry(input = {}) {
+    const settingsAdapters = input.settings === undefined ? [] : loadQuotaAdaptersFromSettings(input.settings);
+    const explicitAdapters = [...settingsAdapters, ...(input.adapters ?? [])];
+    const aliases = { ...loadQuotaAliasesFromSettings(input.settings ?? {}), ...(input.aliases ?? {}) };
+    const explicitProviderIds = new Set([...explicitAdapters.map(adapter => adapter.provider), ...Object.keys(aliases)]);
+    const registry = new AdapterRegistry([
+        codexAdapter, kimiAdapter, openCodeGoAdapter, createDeepSeekAdapter('deepseek'),
+    ].filter(adapter => !explicitProviderIds.has(adapter.provider)).concat(explicitAdapters));
+    for (const [alias, targetId] of Object.entries(aliases)) {
+        const target = aliases[targetId] === undefined ? registry.get(targetId) : undefined;
+        registry.register(target ? createAliasAdapter(alias, target) : createDanglingAliasAdapter(alias));
+    }
+    return {
+        registry,
+        aliases,
+        footerWindows: input.settings === undefined ? undefined : loadQuotaFooterWindows(input.settings),
+    };
+}

package/dist/query/sub2api.d.ts

@@ -0,0 +1,4 @@
+import type { QuotaAdapter, QuotaSnapshot } from './types.js';
+export declare function sub2ApiUsageUrl(baseUrl: string | undefined): string;
+export declare function parseSub2ApiUsage(payload: unknown): Omit<QuotaSnapshot, 'fetchedAt'>;
+export declare function createSub2ApiAdapter(provider: string): QuotaAdapter;