@love-moon/ai-sdk 0.3.2 → 0.4.1

package/dist/manager/quota/external.d.ts

@@ -0,0 +1,29 @@
+import type { ExternalQuota, ExternalQuotaList } from "../types.js";
+export interface GetExternalQuotaOptions {
+    /** External ai-sdk provider backend or alias. */
+    backend: string;
+    model?: string;
+    forceRefresh?: boolean;
+    ttlSeconds?: number;
+    timeoutMs?: number;
+    configPath?: string;
+}
+export interface GetExternalQuotaListOptions {
+    /** External ai-sdk provider backend or alias. */
+    backend: string;
+    forceRefresh?: boolean;
+    ttlSeconds?: number;
+    timeoutMs?: number;
+    configPath?: string;
+}
+export declare function normalizeExternalQuota(value: unknown, options: {
+    backend: string;
+    model?: string;
+    error?: string;
+}): ExternalQuota;
+export declare function normalizeExternalQuotaList(value: unknown, options: {
+    backend: string;
+    error?: string;
+}): ExternalQuotaList;
+export declare function getExternalQuota(opts: GetExternalQuotaOptions): Promise<ExternalQuota>;
+export declare function getExternalQuotaList(opts: GetExternalQuotaListOptions): Promise<ExternalQuotaList>;

package/dist/manager/quota/external.js

@@ -0,0 +1,176 @@
+import { getExternalProviderDescriptor } from "../../external-provider-registry.js";
+function nowSeconds() {
+    return Math.floor(Date.now() / 1000);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+function normalizeNumber(value) {
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? value : undefined;
+    }
+    if (typeof value === "string" && value.trim()) {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    return undefined;
+}
+function normalizeSource(value) {
+    return value === "fresh" || value === "cached" || value === "stale" || value === "unknown"
+        ? value
+        : "unknown";
+}
+function normalizeWindow(value) {
+    const record = isRecord(value) ? value : {};
+    const usedPercent = normalizeNumber(record.usedPercent) ?? 0;
+    const remainingPercent = normalizeNumber(record.remainingPercent) ?? Math.max(0, 100 - usedPercent);
+    const window = {
+        usedPercent,
+        remainingPercent,
+    };
+    const resetAfterSeconds = normalizeNumber(record.resetAfterSeconds);
+    if (resetAfterSeconds !== undefined)
+        window.resetAfterSeconds = resetAfterSeconds;
+    const resetAt = normalizeNumber(record.resetAt);
+    if (resetAt !== undefined)
+        window.resetAt = resetAt;
+    const resetOnDate = normalizeString(record.resetOnDate);
+    if (resetOnDate)
+        window.resetOnDate = resetOnDate;
+    const status = normalizeString(record.status);
+    if (status)
+        window.status = status;
+    const windowMinutes = normalizeNumber(record.windowMinutes);
+    if (windowMinutes !== undefined)
+        window.windowMinutes = windowMinutes;
+    const limit = normalizeNumber(record.limit);
+    if (limit !== undefined)
+        window.limit = limit;
+    const used = normalizeNumber(record.used);
+    if (used !== undefined)
+        window.used = used;
+    const remaining = normalizeNumber(record.remaining);
+    if (remaining !== undefined)
+        window.remaining = remaining;
+    return window;
+}
+export function normalizeExternalQuota(value, options) {
+    const record = isRecord(value) ? value : {};
+    const model = normalizeString(record.model) ?? normalizeString(options.model) ?? "";
+    return {
+        backend: options.backend,
+        model,
+        daily: normalizeWindow(record.daily),
+        fetchedAt: normalizeNumber(record.fetchedAt) ?? nowSeconds(),
+        source: normalizeSource(record.source),
+        username: normalizeString(record.username),
+        organization: normalizeString(record.organization),
+        label: normalizeString(record.label),
+        limitSource: normalizeString(record.limitSource),
+        quotaReleaseMode: normalizeString(record.quotaReleaseMode),
+        quotaResetTime: normalizeString(record.quotaResetTime),
+        error: normalizeString(record.error) ?? options.error,
+        raw: isRecord(record.raw) ? record.raw : undefined,
+    };
+}
+export function normalizeExternalQuotaList(value, options) {
+    const record = isRecord(value) ? value : {};
+    const quotas = Array.isArray(record.quotas)
+        ? record.quotas.map((item) => normalizeExternalQuota(item, { backend: options.backend }))
+        : [];
+    const quotaByModel = {};
+    for (const quota of quotas) {
+        if (quota.model) {
+            quotaByModel[quota.model] = quota;
+        }
+    }
+    return {
+        backend: options.backend,
+        fetchedAt: normalizeNumber(record.fetchedAt) ?? nowSeconds(),
+        source: normalizeSource(record.source),
+        username: normalizeString(record.username),
+        organization: normalizeString(record.organization),
+        label: normalizeString(record.label),
+        count: normalizeNumber(record.count) ?? quotas.length,
+        quotas,
+        quotaByModel,
+        error: normalizeString(record.error) ?? options.error,
+        raw: isRecord(record.raw) ? record.raw : undefined,
+    };
+}
+function emptyQuota(error, options) {
+    return {
+        backend: options.backend,
+        model: options.model ?? "",
+        daily: { usedPercent: 0, remainingPercent: 0 },
+        fetchedAt: nowSeconds(),
+        source: "unknown",
+        error,
+    };
+}
+function emptyQuotaList(error, options) {
+    return {
+        backend: options.backend,
+        fetchedAt: nowSeconds(),
+        source: "unknown",
+        count: 0,
+        quotas: [],
+        quotaByModel: {},
+        error,
+    };
+}
+async function getExternalDescriptor(backend, configPath) {
+    return getExternalProviderDescriptor(backend, configPath ? { configFile: configPath } : {});
+}
+function providerOptions(opts) {
+    return {
+        backend: opts.backend,
+        model: "model" in opts ? opts.model : undefined,
+        forceRefresh: opts.forceRefresh,
+        ttlSeconds: opts.ttlSeconds,
+        timeoutMs: opts.timeoutMs,
+        configPath: opts.configPath,
+    };
+}
+export async function getExternalQuota(opts) {
+    const backend = normalizeString(opts.backend);
+    if (!backend) {
+        return emptyQuota("external provider backend is required", { backend: "", model: opts.model });
+    }
+    try {
+        const descriptor = await getExternalDescriptor(backend, opts.configPath);
+        if (!descriptor?.getQuota) {
+            return emptyQuota("external provider quota hook unavailable", { backend, model: opts.model });
+        }
+        const result = await descriptor.getQuota(providerOptions({ ...opts, backend }));
+        return normalizeExternalQuota(result, { backend: descriptor.backend || backend, model: opts.model });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return emptyQuota(message, { backend, model: opts.model });
+    }
+}
+export async function getExternalQuotaList(opts) {
+    const backend = normalizeString(opts.backend);
+    if (!backend) {
+        return emptyQuotaList("external provider backend is required", { backend: "" });
+    }
+    try {
+        const descriptor = await getExternalDescriptor(backend, opts.configPath);
+        if (!descriptor?.getQuotaList) {
+            return emptyQuotaList("external provider quota list hook unavailable", { backend });
+        }
+        const result = await descriptor.getQuotaList(providerOptions({ ...opts, backend }));
+        return normalizeExternalQuotaList(result, { backend: descriptor.backend || backend });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return emptyQuotaList(message, { backend });
+    }
+}

package/dist/manager/quota/headers.d.ts

@@ -0,0 +1,5 @@
+/** Convert fetch Headers to a case-insensitive plain map. */
+export declare function headersToMap(h: Headers): Record<string, string>;
+export declare function num(map: Record<string, string>, key: string): number | undefined;
+export declare function str(map: Record<string, string>, key: string): string | undefined;
+export declare function bool(map: Record<string, string>, key: string): boolean | undefined;

package/dist/manager/quota/headers.js

@@ -0,0 +1,29 @@
+/** Convert fetch Headers to a case-insensitive plain map. */
+export function headersToMap(h) {
+    const out = {};
+    h.forEach((value, key) => {
+        out[key.toLowerCase()] = value;
+    });
+    return out;
+}
+export function num(map, key) {
+    const v = map[key.toLowerCase()];
+    if (v === undefined || v === "")
+        return undefined;
+    const n = Number(v);
+    return Number.isFinite(n) ? n : undefined;
+}
+export function str(map, key) {
+    const v = map[key.toLowerCase()];
+    return v === undefined || v === "" ? undefined : v;
+}
+export function bool(map, key) {
+    const v = map[key.toLowerCase()];
+    if (v === undefined)
+        return undefined;
+    if (/^true$/i.test(v))
+        return true;
+    if (/^false$/i.test(v))
+        return false;
+    return undefined;
+}

package/dist/manager/quota/kimi.d.ts

@@ -0,0 +1,24 @@
+import type { KimiQuota } from "../types.js";
+export interface KimiCredential {
+    access_token: string;
+    refresh_token: string;
+    expires_at: number;
+    scope?: string;
+    token_type?: string;
+}
+export interface GetKimiQuotaOptions {
+    credentialPath?: string;
+    ttlSeconds?: number;
+    forceRefresh?: boolean;
+    timeoutMs?: number;
+    cacheDir?: string;
+    /** Override the global fetch (test-only). */
+    fetcher?: typeof fetch;
+}
+export declare function getKimiQuota(opts?: GetKimiQuotaOptions): Promise<KimiQuota>;
+/** Exported for tests. */
+export declare function refreshKimiToken(cred: KimiCredential, credentialPath: string, timeoutMs: number, doFetch?: typeof fetch): Promise<KimiCredential>;
+/** Exported for tests. */
+export declare function parseUsagePayload(payload: any): KimiQuota;
+/** Exported for tests. */
+export declare function parseResetTime(value: any): number | undefined;

package/dist/manager/quota/kimi.js

@@ -0,0 +1,230 @@
+import { readFile, writeFile, rename } from "node:fs/promises";
+import { DEFAULT_KIMI_CREDENTIAL } from "../paths.js";
+import { cacheFile, fingerprintKey, isFresh, readCache, writeCache } from "./cache.js";
+const USAGE_URL = "https://api.kimi.com/coding/v1/usages";
+const OAUTH_TOKEN_URL = "https://auth.kimi.com/api/oauth/token";
+const KIMI_CODE_CLIENT_ID = "17e5f671-d194-4dfb-9706-5516cb48c098";
+const DEFAULT_TTL = 60;
+const DEFAULT_TIMEOUT_MS = 15_000;
+const REFRESH_LEEWAY_SECONDS = 60;
+export async function getKimiQuota(opts = {}) {
+    const credentialPath = opts.credentialPath ?? DEFAULT_KIMI_CREDENTIAL;
+    const ttl = opts.ttlSeconds ?? DEFAULT_TTL;
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const doFetch = opts.fetcher ?? fetch;
+    let cred;
+    try {
+        cred = JSON.parse(await readFile(credentialPath, "utf8"));
+    }
+    catch (err) {
+        return emptyQuota("unknown", `kimi credential not readable: ${err?.message ?? err}`);
+    }
+    if (!cred.access_token) {
+        return emptyQuota("unknown", "kimi credential missing access_token");
+    }
+    const fp = fingerprintKey(["kimi", cred.access_token.slice(-32)]);
+    const file = cacheFile("kimi", fp, opts.cacheDir);
+    if (!opts.forceRefresh && ttl > 0) {
+        const cached = await readCache(file);
+        if (isFresh(cached, ttl) && cached) {
+            return { ...cached.value, source: "cached" };
+        }
+    }
+    // Refresh proactively if access_token is expired or about to.
+    const nowSec = Math.floor(Date.now() / 1000);
+    if (cred.expires_at && cred.expires_at - nowSec < REFRESH_LEEWAY_SECONDS) {
+        try {
+            cred = await refreshKimiToken(cred, credentialPath, timeoutMs, doFetch);
+        }
+        catch (err) {
+            return await fallbackFromCache(file, ttl, `kimi token refresh failed: ${err?.message ?? err}`);
+        }
+    }
+    let res = await fetchUsage(cred.access_token, timeoutMs, doFetch);
+    if (res.status === 401 || res.status === 403) {
+        // Token may have been invalidated mid-flight; try one refresh + retry.
+        try {
+            cred = await refreshKimiToken(cred, credentialPath, timeoutMs, doFetch);
+            res = await fetchUsage(cred.access_token, timeoutMs, doFetch);
+        }
+        catch (err) {
+            return await fallbackFromCache(file, ttl, `kimi auth failed: ${err?.message ?? err}`);
+        }
+    }
+    if (!res.ok) {
+        return await fallbackFromCache(file, ttl, `kimi usage HTTP ${res.status}`);
+    }
+    const fresh = parseUsagePayload(res.payload);
+    await writeCache(file, fresh);
+    return fresh;
+}
+async function fetchUsage(token, timeoutMs, doFetch) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const r = await doFetch(USAGE_URL, {
+            method: "GET",
+            headers: { Authorization: `Bearer ${token}`, Accept: "application/json" },
+            signal: controller.signal,
+        });
+        let payload = null;
+        try {
+            payload = await r.json();
+        }
+        catch {
+            // ignore body parse errors
+        }
+        return { ok: r.ok, status: r.status, payload };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** Exported for tests. */
+export async function refreshKimiToken(cred, credentialPath, timeoutMs, doFetch = fetch) {
+    if (!cred.refresh_token)
+        throw new Error("missing refresh_token");
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const body = new URLSearchParams({
+            client_id: KIMI_CODE_CLIENT_ID,
+            grant_type: "refresh_token",
+            refresh_token: cred.refresh_token,
+        });
+        const r = await doFetch(OAUTH_TOKEN_URL, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded",
+                Accept: "application/json",
+            },
+            body: body.toString(),
+            signal: controller.signal,
+        });
+        if (!r.ok) {
+            const text = await r.text().catch(() => "");
+            throw new Error(`HTTP ${r.status}: ${text.slice(0, 200)}`);
+        }
+        const data = (await r.json());
+        const next = {
+            access_token: String(data.access_token ?? ""),
+            refresh_token: String(data.refresh_token ?? cred.refresh_token),
+            expires_at: typeof data.expires_at === "number"
+                ? data.expires_at
+                : Math.floor(Date.now() / 1000) + (data.expires_in ?? 0),
+            scope: data.scope ?? cred.scope,
+            token_type: data.token_type ?? cred.token_type,
+        };
+        if (!next.access_token)
+            throw new Error("refresh response missing access_token");
+        await persistCredential(credentialPath, next);
+        return next;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function persistCredential(path, cred) {
+    const tmp = `${path}.tmp`;
+    await writeFile(tmp, JSON.stringify(cred), { mode: 0o600 });
+    await rename(tmp, path);
+}
+/** Exported for tests. */
+export function parseUsagePayload(payload) {
+    const user = payload?.user ?? {};
+    const usage = payload?.user && payload?.usage ? payload.usage : payload?.usage ?? {};
+    const limits = Array.isArray(payload?.limits) ? payload.limits : [];
+    const fiveHourEntry = limits.find((entry) => {
+        const w = entry?.window;
+        if (!w)
+            return false;
+        if (w.timeUnit === "TIME_UNIT_MINUTE" && Number(w.duration) === 300)
+            return true;
+        if (w.timeUnit === "TIME_UNIT_HOUR" && Number(w.duration) === 5)
+            return true;
+        return false;
+    });
+    const fiveHourDetail = fiveHourEntry?.detail ?? fiveHourEntry ?? {};
+    return {
+        tool: "kimi",
+        userId: typeof user.userId === "string" ? user.userId : undefined,
+        region: typeof user.region === "string" ? user.region : undefined,
+        membership: typeof user?.membership?.level === "string" ? user.membership.level : undefined,
+        fiveHour: windowFromKimi(fiveHourDetail, 300),
+        weekly: windowFromKimi(usage, 10080),
+        parallelLimit: toInt(payload?.parallel?.limit),
+        fetchedAt: Math.floor(Date.now() / 1000),
+        source: "fresh",
+        raw: payload && typeof payload === "object" ? payload : undefined,
+    };
+}
+function windowFromKimi(entry, windowMinutes) {
+    const limit = toInt(entry?.limit);
+    let used = toInt(entry?.used);
+    let remaining = toInt(entry?.remaining);
+    if (limit !== undefined) {
+        if (used === undefined && remaining !== undefined)
+            used = limit - remaining;
+        if (remaining === undefined && used !== undefined)
+            remaining = limit - used;
+    }
+    const usedPercent = limit && limit > 0 && used !== undefined ? (used / limit) * 100 : 0;
+    const remainingPercent = limit && limit > 0 && remaining !== undefined
+        ? (remaining / limit) * 100
+        : Math.max(0, 100 - usedPercent);
+    const resetAt = parseResetTime(entry?.resetTime ?? entry?.reset_time ?? entry?.resetAt);
+    return {
+        usedPercent: round1(usedPercent),
+        remainingPercent: round1(remainingPercent),
+        resetAt,
+        windowMinutes,
+        limit,
+        used,
+        remaining,
+    };
+}
+/** Exported for tests. */
+export function parseResetTime(value) {
+    if (typeof value !== "string" || !value)
+        return undefined;
+    // Trim sub-microsecond fraction so Date can parse it (Kimi sends nanoseconds).
+    let v = value;
+    if (v.endsWith("Z") && v.includes(".")) {
+        const [base, frac] = v.slice(0, -1).split(".");
+        v = `${base}.${frac.slice(0, 6)}Z`;
+    }
+    const t = Date.parse(v);
+    if (Number.isNaN(t))
+        return undefined;
+    return Math.floor(t / 1000);
+}
+function toInt(value) {
+    if (value === null || value === undefined)
+        return undefined;
+    const n = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(n) ? Math.trunc(n) : undefined;
+}
+function round1(n) {
+    return Math.round(n * 10) / 10;
+}
+async function fallbackFromCache(file, ttl, error) {
+    const cached = await readCache(file);
+    if (cached) {
+        return {
+            ...cached.value,
+            source: isFresh(cached, ttl) ? "cached" : "stale",
+            error,
+        };
+    }
+    return emptyQuota("unknown", error);
+}
+function emptyQuota(source, error) {
+    return {
+        tool: "kimi",
+        source,
+        error,
+        fetchedAt: Math.floor(Date.now() / 1000),
+        fiveHour: { usedPercent: 0, remainingPercent: 0 },
+        weekly: { usedPercent: 0, remainingPercent: 0 },
+    };
+}

package/dist/manager/types.d.ts

@@ -0,0 +1,166 @@
+export type Tool = "codex" | "claude" | "kimi" | "copilot";
+export type QuotaSource = "fresh" | "cached" | "stale" | "unknown";
+export interface InstallStatus {
+    installed: boolean;
+    path?: string;
+    version?: string;
+    error?: string;
+}
+export interface NetworkStatus {
+    reachable: boolean;
+    latencyMs?: number;
+    httpStatus?: number;
+    error?: string;
+    endpoint: string;
+}
+export interface QuotaWindow {
+    /** Percentage of the window already used, 0-100. */
+    usedPercent: number;
+    /** Percentage of the window remaining, 0-100. */
+    remainingPercent: number;
+    /** Seconds until the window resets. */
+    resetAfterSeconds?: number;
+    /** Unix timestamp (seconds) at which the window resets. */
+    resetAt?: number;
+    /** Calendar date when the provider only exposes day-level reset semantics. */
+    resetOnDate?: string;
+    /** Status label from the provider (allowed/warning/blocked), if any. */
+    status?: string;
+    /** Window length in minutes, if known (300 = 5h, 10080 = 7d). */
+    windowMinutes?: number;
+    /** Absolute counts when the provider exposes them (Kimi). */
+    limit?: number;
+    used?: number;
+    remaining?: number;
+}
+export interface CodexQuota {
+    tool: "codex";
+    plan?: string;
+    activeLimit?: string;
+    fiveHour: QuotaWindow;
+    weekly: QuotaWindow;
+    credits?: {
+        hasCredits: boolean;
+        balance?: string;
+        unlimited: boolean;
+    };
+    fetchedAt: number;
+    source: QuotaSource;
+    email?: string;
+    accountId?: string;
+    raw?: Record<string, string>;
+    error?: string;
+}
+export interface ClaudeQuota {
+    tool: "claude";
+    plan?: string;
+    overallStatus?: string;
+    fiveHour: QuotaWindow;
+    weekly: QuotaWindow;
+    weeklySonnet?: QuotaWindow;
+    overage?: {
+        status?: string;
+        disabledReason?: string;
+    };
+    fetchedAt: number;
+    source: QuotaSource;
+    raw?: Record<string, string>;
+    error?: string;
+}
+export interface KimiQuota {
+    tool: "kimi";
+    userId?: string;
+    region?: string;
+    membership?: string;
+    fiveHour: QuotaWindow;
+    weekly: QuotaWindow;
+    parallelLimit?: number;
+    fetchedAt: number;
+    source: QuotaSource;
+    raw?: Record<string, unknown>;
+    error?: string;
+}
+export interface CopilotQuotaSnapshot {
+    entitlementRequests: number;
+    usedRequests: number;
+    remainingPercentage: number;
+    overage: number;
+    overageAllowedWithExhaustedQuota: boolean;
+    resetDate?: string;
+    isUnlimitedEntitlement?: boolean;
+    usageAllowedWithExhaustedQuota?: boolean;
+}
+export interface CopilotQuota {
+    tool: "copilot";
+    /** Best single quota window to show when callers do not care about quota type. */
+    primary?: QuotaWindow;
+    chat?: QuotaWindow;
+    completions?: QuotaWindow;
+    premiumInteractions?: QuotaWindow;
+    login?: string;
+    authType?: string;
+    host?: string;
+    loginSource?: "sdk" | "github_token";
+    snapshots: Record<string, CopilotQuotaSnapshot>;
+    fetchedAt: number;
+    source: QuotaSource;
+    raw?: Record<string, unknown>;
+    error?: string;
+}
+export interface ExternalQuota {
+    backend?: string;
+    model: string;
+    daily: QuotaWindow;
+    fetchedAt: number;
+    source: QuotaSource;
+    username?: string;
+    organization?: string;
+    label?: string;
+    limitSource?: string;
+    quotaReleaseMode?: string;
+    quotaResetTime?: string;
+    raw?: Record<string, unknown>;
+    error?: string;
+}
+export interface ExternalQuotaList {
+    backend?: string;
+    fetchedAt: number;
+    source: QuotaSource;
+    username?: string;
+    organization?: string;
+    label?: string;
+    count: number;
+    quotas: ExternalQuota[];
+    quotaByModel: Record<string, ExternalQuota>;
+    raw?: Record<string, unknown>;
+    error?: string;
+}
+export interface CodexAccount {
+    /** Short label derived from file name (strip `auth_` prefix and `.json` suffix). */
+    name: string;
+    /** Absolute path to the auth.json file. */
+    path: string;
+    email?: string;
+    accountId?: string;
+    planType?: string;
+    lastRefresh?: string;
+    isCurrent: boolean;
+    /**
+     * Last-known quota snapshot for this account read from the daemon's on-disk
+     * cache. Populated by `list_accounts` so web clients can restore an
+     * inactive account's bars across page refreshes without a network call.
+     * Absent when the daemon has never successfully fetched quota for this
+     * account.
+     */
+    cachedQuota?: CodexQuota;
+}
+export interface SwitchResult {
+    previousName?: string;
+    newName: string;
+    backupPath: string;
+}
+export interface AiManagerConfig {
+    codex: {
+        authJson: string[];
+    };
+}

package/dist/manager/types.js

@@ -0,0 +1 @@
+export {};