@astrosheep/pi-quota 0.12.0 → 0.12.2

package/dist/query/alias.d.ts

@@ -0,0 +1,3 @@
+import type { QuotaAdapter } from './types.js';
+export declare function createAliasAdapter(provider: string, target: QuotaAdapter): QuotaAdapter;
+export declare function createDanglingAliasAdapter(provider: string): QuotaAdapter;

package/dist/query/alias.js

@@ -0,0 +1,17 @@
+import { QuotaError } from "./types.js";
+// An alias provider shares another provider's account: the query runs under
+// the target's identity, so auth and endpoints resolve exactly as a direct
+// query of the target would. The alias never queries on its own behalf.
+export function createAliasAdapter(provider, target) {
+    return {
+        provider, label: target.label,
+        query: context => target.query({ ...context, provider: target.provider }),
+    };
+}
+// A dangling alias stays visible as an error instead of silently vanishing.
+export function createDanglingAliasAdapter(provider) {
+    return {
+        provider, label: provider,
+        query: () => Promise.reject(new QuotaError('unsupported-auth')),
+    };
+}

package/dist/query/codex.d.ts

@@ -0,0 +1,4 @@
+import type { QuotaAdapter, QuotaWindow } from './types.js';
+export declare function codexAccountId(token: string): string | undefined;
+export declare function parseCodex(payload: unknown, now: number): QuotaWindow[];
+export declare const codexAdapter: QuotaAdapter;

package/dist/query/codex.js

@@ -0,0 +1,68 @@
+import { bearer, header, officialAuth } from "./http.js";
+import { numeric, object, percent, safeLabel, timestamp, windowLabel } from "./parse.js";
+import { QuotaError } from "./types.js";
+// Decode only to obtain routing metadata from the same resolved token.
+// This does not verify a JWT; the official server verifies authentication.
+export function codexAccountId(token) {
+    try {
+        const payload = object(JSON.parse(Buffer.from(token.split('.')[1] ?? '', 'base64url').toString('utf8')));
+        const id = object(payload['https://api.openai.com/auth']).chatgpt_account_id;
+        return typeof id === 'string' && id.length > 0 ? id : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function parseCodex(payload, now) {
+    const data = object(payload);
+    const windows = [];
+    const addDomain = (raw, domain, scope) => {
+        const rate = object(raw);
+        for (const [key, fallback] of [['primary_window', 18000], ['secondary_window', 604800]]) {
+            if (rate[key] == null)
+                continue;
+            const window = object(rate[key]);
+            const duration = numeric(window.limit_window_seconds) ?? fallback;
+            if (duration <= 0)
+                throw new QuotaError('schema');
+            const remaining = numeric(window.remaining_percent) ?? numeric(window.percent_left);
+            const used = numeric(window.used_percent);
+            const resetAfter = numeric(window.reset_after_seconds);
+            const resetAt = timestamp(window.reset_at ?? window.reset_time_ms)
+                ?? (resetAfter !== null && resetAfter >= 0 ? now + resetAfter * 1000 : null);
+            windows.push({
+                id: `${domain}/${key}`, label: windowLabel(duration), durationSeconds: duration,
+                remainingPercent: remaining !== null ? percent(remaining) : used !== null ? percent(100 - used) : null,
+                resetAt, ...(scope ? { scope } : {}),
+            });
+        }
+    };
+    addDomain(data.rate_limit, 'shared');
+    if (Array.isArray(data.additional_rate_limits)) {
+        for (const [index, entry] of data.additional_rate_limits.entries()) {
+            const item = object(entry);
+            const name = item.limit_name ?? item.metered_feature;
+            const scope = typeof name === 'string' ? safeLabel(name) : `Model ${index + 1}`;
+            addDomain(item.rate_limit, `additional-${index}`, scope);
+        }
+    }
+    if (windows.length === 0)
+        throw new QuotaError('schema');
+    return windows;
+}
+export const codexAdapter = {
+    provider: 'openai-codex', label: 'Codex',
+    async query(context) {
+        const auth = await officialAuth(context, 'https://chatgpt.com');
+        const token = bearer(auth);
+        const account = header(auth, 'chatgpt-account-id') ?? codexAccountId(token);
+        if (!account)
+            throw new QuotaError('unsupported-auth');
+        const data = await context.getJson('https://chatgpt.com/backend-api/wham/usage', {
+            Authorization: `Bearer ${token}`, 'ChatGPT-Account-Id': account,
+            Origin: 'https://chatgpt.com', Referer: 'https://chatgpt.com/',
+        }, context.signal);
+        const now = context.now();
+        return { windows: parseCodex(data, now), fetchedAt: now };
+    },
+};

package/dist/query/controller.d.ts

@@ -0,0 +1,30 @@
+import { AdapterRegistry } from './registry.js';
+import type { QueryContext, QuotaState } from './types.js';
+type AuthResolver = QueryContext['getAuth'];
+interface ControllerOptions {
+    registry: AdapterRegistry;
+    getJson: QueryContext['getJson'];
+    postJson: QueryContext['postJson'];
+    onState(state: QuotaState): void;
+    now?: () => number;
+    intervalMs?: number;
+    timeoutMs?: number;
+}
+export declare class QuotaController {
+    state: QuotaState;
+    private provider?;
+    private generation;
+    private request?;
+    private nextAttempt;
+    private failures;
+    private readonly options;
+    private readonly now;
+    private readonly interval;
+    private readonly timeout;
+    constructor(options: ControllerOptions);
+    private publish;
+    select(provider: string | undefined): void;
+    stop(): void;
+    refresh(getAuth: AuthResolver, force?: boolean): Promise<void>;
+}
+export {};

package/dist/query/controller.js

@@ -0,0 +1,110 @@
+import { AdapterRegistry, validateSnapshot } from "./registry.js";
+import { QuotaError } from "./types.js";
+// Waiting is bounded even if a custom adapter or auth resolver ignores abort.
+async function abortable(work, signal) {
+    signal.throwIfAborted();
+    let rejectAbort = () => { };
+    const aborted = new Promise((_resolve, reject) => {
+        rejectAbort = () => reject(signal.reason);
+        signal.addEventListener('abort', rejectAbort, { once: true });
+    });
+    try {
+        return await Promise.race([work, aborted]);
+    }
+    finally {
+        signal.removeEventListener('abort', rejectAbort);
+    }
+}
+export class QuotaController {
+    state = { kind: 'hidden' };
+    provider;
+    generation = 0;
+    request;
+    nextAttempt = 0;
+    failures = 0;
+    options;
+    now;
+    interval;
+    timeout;
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? Date.now;
+        this.interval = options.intervalMs ?? 60000;
+        this.timeout = options.timeoutMs ?? 10000;
+        if (!Number.isFinite(this.interval) || this.interval <= 0
+            || !Number.isFinite(this.timeout) || this.timeout <= 0)
+            throw new Error('Invalid quota timing');
+    }
+    publish(state) {
+        this.state = state;
+        this.options.onState(state);
+    }
+    select(provider) {
+        this.generation++;
+        this.request?.abort.abort();
+        this.request = undefined;
+        this.provider = provider;
+        this.nextAttempt = 0;
+        this.failures = 0;
+        const adapter = this.options.registry.get(provider);
+        // Clear old values synchronously, before auth resolution or any network I/O.
+        this.publish(adapter
+            ? { kind: 'loading', provider: adapter.provider, label: adapter.label }
+            : { kind: 'hidden' });
+    }
+    stop() { this.select(undefined); }
+    refresh(getAuth, force = false) {
+        const adapter = this.options.registry.get(this.provider);
+        if (!adapter)
+            return Promise.resolve();
+        if (this.request && !force)
+            return this.request.promise;
+        if (!force && this.now() < this.nextAttempt)
+            return Promise.resolve();
+        if (force) {
+            this.generation++;
+            this.request?.abort.abort();
+            this.request = undefined;
+        }
+        const generation = this.generation;
+        const abort = new AbortController();
+        const active = () => this.generation === generation && this.request?.abort === abort;
+        // Keep the last result visible during refresh; selection already clears it.
+        if (this.state.kind !== 'ready' && this.state.kind !== 'loading') {
+            this.publish({ kind: 'loading', provider: adapter.provider, label: adapter.label });
+        }
+        const deadline = setTimeout(() => abort.abort(new QuotaError('timeout')), this.timeout);
+        const promise = Promise.resolve().then(async () => {
+            try {
+                abort.signal.throwIfAborted();
+                const result = await abortable(adapter.query({
+                    provider: adapter.provider, signal: abort.signal, now: this.now,
+                    getAuth, getJson: this.options.getJson, postJson: this.options.postJson,
+                }), abort.signal);
+                if (!active())
+                    return;
+                const snapshot = validateSnapshot(result);
+                this.failures = 0;
+                this.nextAttempt = this.now() + this.interval;
+                this.publish({ kind: 'ready', provider: adapter.provider, label: adapter.label, snapshot });
+            }
+            catch (error) {
+                if (!active())
+                    return;
+                const safe = error instanceof QuotaError ? error : new QuotaError('network');
+                this.failures++;
+                const backoff = Math.min(900000, this.interval * 2 ** Math.min(this.failures - 1, 4));
+                this.nextAttempt = this.now() + Math.max(backoff, safe.retryAfterMs ?? 0);
+                // Do not retain a prior account's cached quota after auth changes/errors.
+                this.publish({ kind: 'error', provider: adapter.provider, label: adapter.label, code: safe.code });
+            }
+            finally {
+                clearTimeout(deadline);
+                if (active())
+                    this.request = undefined;
+            }
+        });
+        this.request = { abort, promise };
+        return promise;
+    }
+}

package/dist/query/deepseek.d.ts

@@ -0,0 +1,4 @@
+import type { AccountBalance, QuotaAdapter } from './types.js';
+export declare const DEEPSEEK_ORIGIN = "https://api.deepseek.com";
+export declare function parseDeepSeekBalance(payload: unknown): AccountBalance;
+export declare function createDeepSeekAdapter(provider: string): QuotaAdapter;

package/dist/query/deepseek.js

@@ -0,0 +1,32 @@
+import { bearer, officialAuth } from "./http.js";
+import { numeric, object } from "./parse.js";
+import { QuotaError } from "./types.js";
+export const DEEPSEEK_ORIGIN = 'https://api.deepseek.com';
+// https://api-docs.deepseek.com/api/get-user-balance
+// GET /user/balance (also mounted under /v1/). The sk- key works directly.
+// Amounts arrive as strings in yuan; balance_infos may list several currencies.
+export function parseDeepSeekBalance(payload) {
+    const body = object(payload);
+    if (!Array.isArray(body.balance_infos) || body.balance_infos.length === 0)
+        throw new QuotaError('schema');
+    for (const entry of body.balance_infos) {
+        const info = object(entry);
+        const remaining = numeric(info.total_balance);
+        if (typeof info.currency !== 'string' || !/^[A-Z]{3}$/.test(info.currency)
+            || remaining === null || remaining < 0)
+            continue;
+        // The endpoint exposes no usage total; only return the actual balance.
+        return { currency: info.currency, remaining };
+    }
+    throw new QuotaError('schema');
+}
+export function createDeepSeekAdapter(provider) {
+    return {
+        provider, label: provider === 'deepseek' ? 'DeepSeek' : provider,
+        async query(context) {
+            const auth = await officialAuth(context, DEEPSEEK_ORIGIN);
+            const payload = await context.getJson(`${DEEPSEEK_ORIGIN}/user/balance`, { Authorization: `Bearer ${bearer(auth)}` }, context.signal);
+            return { windows: [], balance: parseDeepSeekBalance(payload), fetchedAt: context.now() };
+        },
+    };
+}

package/dist/query/exec.d.ts

@@ -0,0 +1,10 @@
+import type { QuotaAdapter } from './types.js';
+export interface ExecOptions {
+    command: string[];
+    label: string;
+}
+export declare function validateExecOptions(options: {
+    command?: unknown;
+    label?: unknown;
+}): ExecOptions;
+export declare function createExecAdapter(provider: string, options: ExecOptions): QuotaAdapter;

package/dist/query/exec.js

@@ -0,0 +1,75 @@
+import { spawn } from 'node:child_process';
+import { QuotaError } from "./types.js";
+export function validateExecOptions(options) {
+    const { command, label } = options;
+    if (!Array.isArray(command) || command.length === 0 || command.length > 16
+        || command.some(part => typeof part !== 'string' || part.trim() === '' || part.length > 512)) {
+        throw new Error('Invalid exec options');
+    }
+    if (typeof label !== 'string' || label.trim() === '' || label.length > 64)
+        throw new Error('Invalid exec options');
+    return { command: [...command], label };
+}
+// Same bound as the HTTP clients: quota payloads are small.
+const MAX_OUTPUT_BYTES = 256 * 1024;
+function runCommand(command, signal) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const fail = (error) => { if (!settled) {
+            settled = true;
+            reject(error);
+        } };
+        const done = (text) => { if (!settled) {
+            settled = true;
+            resolve(text);
+        } };
+        let child;
+        try {
+            // No shell: argv passes verbatim; settings.json is the only trust boundary.
+            // The controller bounds the wait via the signal even if the child hangs.
+            child = spawn(command[0], command.slice(1), { signal, stdio: ['ignore', 'pipe', 'ignore'] });
+        }
+        catch {
+            fail(new QuotaError('network'));
+            return;
+        }
+        let output = '';
+        child.stdout?.setEncoding('utf8');
+        child.stdout?.on('data', (chunk) => {
+            output += chunk;
+            if (output.length > MAX_OUTPUT_BYTES) {
+                child.kill();
+                fail(new QuotaError('schema'));
+            }
+        });
+        child.on('error', () => fail(signal.aborted ? signal.reason : new QuotaError('network')));
+        child.on('close', code => {
+            if (signal.aborted)
+                fail(signal.reason);
+            else if (code !== 0)
+                fail(new QuotaError('network'));
+            else
+                done(output);
+        });
+    });
+}
+export function createExecAdapter(provider, options) {
+    return {
+        provider, label: options.label,
+        async query(context) {
+            const text = await runCommand(options.command, context.signal);
+            let payload;
+            try {
+                payload = JSON.parse(text);
+            }
+            catch {
+                throw new QuotaError('schema');
+            }
+            if (payload === null || typeof payload !== 'object' || Array.isArray(payload))
+                throw new QuotaError('schema');
+            // fetchedAt is stamped here, never trusted from the command; the
+            // controller's validateSnapshot performs the real schema check.
+            return { ...payload, fetchedAt: context.now() };
+        },
+    };
+}

package/dist/query/http.d.ts

@@ -0,0 +1,6 @@
+import type { ProviderAuth, QueryContext } from './types.js';
+export declare function createJsonClient(fetcher?: typeof fetch): QueryContext['getJson'];
+export declare function createPostJsonClient(fetcher?: typeof fetch): QueryContext['postJson'];
+export declare function header(auth: ProviderAuth, name: string): string | undefined;
+export declare function officialAuth(context: QueryContext, origin: string): Promise<ProviderAuth>;
+export declare function bearer(auth: ProviderAuth): string;

package/dist/query/http.js

@@ -0,0 +1,160 @@
+import { QuotaError } from "./types.js";
+export function createJsonClient(fetcher = globalThis.fetch) {
+    return async (url, headers, signal) => {
+        try {
+            const response = await fetcher(url, {
+                method: 'GET', headers: { Accept: 'application/json', ...headers },
+                signal, redirect: 'error', // Never forward credentials to a redirected endpoint.
+            });
+            if (!response.ok) {
+                const retry = response.headers.get('retry-after');
+                const seconds = retry && /^\d+(\.\d+)?$/.test(retry) ? Number(retry) : NaN;
+                const delay = Number.isFinite(seconds) ? seconds * 1000
+                    : retry ? Date.parse(retry) - Date.now() : NaN;
+                await response.body?.cancel();
+                if (response.status === 401 || response.status === 403)
+                    throw new QuotaError('auth');
+                if (response.status === 429) {
+                    throw new QuotaError('rate-limit', Number.isFinite(delay) ? Math.max(0, delay) : undefined);
+                }
+                throw new QuotaError('http');
+            }
+            // Quota responses are small. Bound memory and reject unexpected HTML/proxy pages.
+            const reader = response.body?.getReader();
+            if (!reader)
+                throw new QuotaError('schema');
+            const chunks = [];
+            let size = 0;
+            try {
+                while (true) {
+                    const part = await reader.read();
+                    if (part.done)
+                        break;
+                    size += part.value.length;
+                    if (size > 256 * 1024) {
+                        await reader.cancel();
+                        throw new QuotaError('schema');
+                    }
+                    chunks.push(part.value);
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            try {
+                return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+            }
+            catch {
+                throw new QuotaError('schema');
+            }
+        }
+        catch (error) {
+            if (error instanceof QuotaError)
+                throw error;
+            if (signal.aborted)
+                throw signal.reason;
+            throw new QuotaError('network');
+        }
+    };
+}
+export function createPostJsonClient(fetcher = globalThis.fetch) {
+    return async (url, body, headers, signal) => {
+        try {
+            const response = await fetcher(url, {
+                method: 'POST',
+                headers: { Accept: 'application/json', 'Content-Type': 'application/json', ...headers },
+                body: JSON.stringify(body),
+                signal, redirect: 'error', // Never forward credentials to a redirected endpoint.
+            });
+            if (!response.ok) {
+                const retry = response.headers.get('retry-after');
+                const seconds = retry && /^\d+(\.\d+)?$/.test(retry) ? Number(retry) : NaN;
+                const delay = Number.isFinite(seconds) ? seconds * 1000
+                    : retry ? Date.parse(retry) - Date.now() : NaN;
+                await response.body?.cancel();
+                if (response.status === 401 || response.status === 403)
+                    throw new QuotaError('auth');
+                if (response.status === 429) {
+                    throw new QuotaError('rate-limit', Number.isFinite(delay) ? Math.max(0, delay) : undefined);
+                }
+                throw new QuotaError('http');
+            }
+            const setCookie = typeof response.headers.getSetCookie === 'function'
+                ? response.headers.getSetCookie() : [];
+            const reader = response.body?.getReader();
+            if (!reader)
+                throw new QuotaError('schema');
+            const chunks = [];
+            let size = 0;
+            try {
+                while (true) {
+                    const part = await reader.read();
+                    if (part.done)
+                        break;
+                    size += part.value.length;
+                    if (size > 256 * 1024) {
+                        await reader.cancel();
+                        throw new QuotaError('schema');
+                    }
+                    chunks.push(part.value);
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            try {
+                return { body: JSON.parse(Buffer.concat(chunks).toString('utf8')), setCookie };
+            }
+            catch {
+                throw new QuotaError('schema');
+            }
+        }
+        catch (error) {
+            if (error instanceof QuotaError)
+                throw error;
+            if (signal.aborted)
+                throw signal.reason;
+            throw new QuotaError('network');
+        }
+    };
+}
+export function header(auth, name) {
+    return Object.entries(auth.headers ?? {}).find(([key]) => key.toLowerCase() === name.toLowerCase())?.[1];
+}
+export async function officialAuth(context, origin) {
+    let auth;
+    try {
+        auth = await context.getAuth(context.provider);
+    }
+    catch {
+        throw new QuotaError('auth');
+    }
+    context.signal.throwIfAborted();
+    if (!auth)
+        throw new QuotaError('auth');
+    if (auth.baseUrl) {
+        let actual;
+        try {
+            actual = new URL(auth.baseUrl);
+        }
+        catch {
+            throw new QuotaError('unsupported-auth');
+        }
+        if (actual.origin !== origin || actual.username || actual.password)
+            throw new QuotaError('unsupported-auth');
+    }
+    return auth;
+}
+export function bearer(auth) {
+    const authorization = header(auth, 'authorization');
+    // A runtime Authorization header overrides apiKey, just as it does for requests.
+    if (authorization !== undefined) {
+        const token = /^Bearer\s+(\S+)$/i.exec(authorization)?.[1];
+        if (!token)
+            throw new QuotaError('unsupported-auth');
+        return token;
+    }
+    if (!auth.apiKey)
+        throw new QuotaError('auth');
+    return auth.apiKey;
+}

package/dist/query/index.d.ts

@@ -0,0 +1,18 @@
+export * from './types.js';
+export { AdapterRegistry, validateSnapshot } from './registry.js';
+export { QuotaController } from './controller.js';
+export { createJsonClient, createPostJsonClient, officialAuth, bearer, header } from './http.js';
+export { createAliasAdapter, createDanglingAliasAdapter } from './alias.js';
+export { createExecAdapter, validateExecOptions } from './exec.js';
+export type { ExecOptions } from './exec.js';
+export { codexAccountId, codexAdapter } from './codex.js';
+export { kimiAdapter } from './kimi.js';
+export { openCodeGoAdapter, createOpenCodeGoAdapter } from './opencode-go.js';
+export { createDeepSeekAdapter, DEEPSEEK_ORIGIN } from './deepseek.js';
+export { createNewApiAdapter, validateNewApiOptions } from './new-api.js';
+export type { NewApiOptions } from './new-api.js';
+export { createSub2ApiAdapter } from './sub2api.js';
+export { createYesCodeAdapter, validateYesCodeOptions, YESCODE_ORIGIN } from './yescode.js';
+export type { YesCodeOptions } from './yescode.js';
+export { composeQuotaRegistry, loadQuotaAdaptersFromSettings, loadQuotaAliasesFromSettings, loadQuotaFooterWindows, parseQuotaConfig, QuotaConfigError, } from './settings.js';
+export type { ComposedQuota, FooterWindows, ProviderQuotaConfig, QuotaConfig } from './settings.js';

package/dist/query/index.js

@@ -0,0 +1,16 @@
+// Public entry for the standalone query layer — no Pi, terminal, or rendering
+// dependencies. Consumers supply auth and transport through QueryContext.
+export * from "./types.js";
+export { AdapterRegistry, validateSnapshot } from "./registry.js";
+export { QuotaController } from "./controller.js";
+export { createJsonClient, createPostJsonClient, officialAuth, bearer, header } from "./http.js";
+export { createAliasAdapter, createDanglingAliasAdapter } from "./alias.js";
+export { createExecAdapter, validateExecOptions } from "./exec.js";
+export { codexAccountId, codexAdapter } from "./codex.js";
+export { kimiAdapter } from "./kimi.js";
+export { openCodeGoAdapter, createOpenCodeGoAdapter } from "./opencode-go.js";
+export { createDeepSeekAdapter, DEEPSEEK_ORIGIN } from "./deepseek.js";
+export { createNewApiAdapter, validateNewApiOptions } from "./new-api.js";
+export { createSub2ApiAdapter } from "./sub2api.js";
+export { createYesCodeAdapter, validateYesCodeOptions, YESCODE_ORIGIN } from "./yescode.js";
+export { composeQuotaRegistry, loadQuotaAdaptersFromSettings, loadQuotaAliasesFromSettings, loadQuotaFooterWindows, parseQuotaConfig, QuotaConfigError, } from "./settings.js";

package/dist/query/kimi.d.ts

@@ -0,0 +1,3 @@
+import type { QuotaAdapter, QuotaWindow } from './types.js';
+export declare function parseKimi(payload: unknown): QuotaWindow[];
+export declare const kimiAdapter: QuotaAdapter;

package/dist/query/kimi.js

@@ -0,0 +1,52 @@
+import { bearer, officialAuth } from "./http.js";
+import { numeric, object, percent, timestamp, windowLabel } from "./parse.js";
+import { QuotaError } from "./types.js";
+const units = {
+    TIME_UNIT_SECOND: 1, TIME_UNIT_MINUTE: 60, TIME_UNIT_HOUR: 3600, TIME_UNIT_DAY: 86400,
+};
+export function parseKimi(payload) {
+    const data = object(payload);
+    const windows = [];
+    const add = (raw, duration, id) => {
+        const detail = object(raw);
+        const limit = numeric(detail.limit);
+        const used = numeric(detail.used);
+        const remaining = numeric(detail.remaining);
+        // No default for omitted counts: absence is not proof of zero usage.
+        const fraction = limit !== null && limit > 0
+            ? remaining !== null && remaining >= 0 ? remaining / limit
+                : used !== null && used >= 0 ? 1 - used / limit : null
+            : null;
+        windows.push({
+            id, label: windowLabel(duration), durationSeconds: duration,
+            remainingPercent: fraction === null ? null : percent(fraction * 100),
+            resetAt: timestamp(detail.resetTime ?? detail.reset_at),
+        });
+    };
+    if (data.usage != null && typeof data.usage === 'object')
+        add(data.usage, 604800, 'weekly');
+    if (Array.isArray(data.limits)) {
+        for (const [index, raw] of data.limits.entries()) {
+            const entry = object(raw);
+            const window = object(entry.window);
+            const multiplier = typeof window.timeUnit === 'string' ? units[window.timeUnit] : undefined;
+            const duration = numeric(window.duration);
+            if (!entry.detail || !multiplier || duration === null || duration <= 0)
+                continue;
+            add(entry.detail, duration * multiplier, `limit-${index}`);
+        }
+    }
+    if (windows.length === 0)
+        throw new QuotaError('schema');
+    return windows.sort((a, b) => a.durationSeconds - b.durationSeconds);
+}
+export const kimiAdapter = {
+    provider: 'kimi-coding', label: 'Kimi',
+    async query(context) {
+        const auth = await officialAuth(context, 'https://api.kimi.com');
+        const data = await context.getJson('https://api.kimi.com/coding/v1/usages', {
+            Authorization: `Bearer ${bearer(auth)}`,
+        }, context.signal);
+        return { windows: parseKimi(data), fetchedAt: context.now() };
+    },
+};

package/dist/query/new-api.d.ts

@@ -0,0 +1,18 @@
+import type { QuotaAdapter, QuotaSnapshot } from './types.js';
+type Amounts = Pick<QuotaSnapshot, 'balance' | 'allowance' | 'spend'>;
+export interface NewApiOptions {
+    quotaPerUnit?: number;
+    currency?: string;
+    dashboardAccessToken?: string;
+    dashboardUserId?: number;
+}
+export declare function validateNewApiOptions(options: NewApiOptions): {
+    quotaPerUnit: number;
+    currency: string;
+};
+export declare function newApiRootUrl(baseUrl: string | undefined): string;
+export declare function parseNewApiTokenUsage(payload: unknown, options?: NewApiOptions): Amounts | null;
+export declare function parseNewApiUserSelf(payload: unknown, options?: NewApiOptions): Amounts;
+export declare function parseNewApiBilling(subscription: unknown, usage: unknown, options?: NewApiOptions): Amounts;
+export declare function createNewApiAdapter(provider: string, options?: NewApiOptions): QuotaAdapter;
+export {};