@bytetrue/byspace 0.1.0

package/node_modules/@bytetrue/byspace-server/dist/server/services/quota-fetcher/providers/cursor.js

@@ -0,0 +1,123 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { z } from "zod";
+import { ApiNullableNumberSchema, balanceToneFromRemaining, fetchProviderApi, toIsoStringOrNull, unavailableUsage, } from "../usage.js";
+const execFileAsync = promisify(execFile);
+const CURSOR_SQLITE_TIMEOUT_MS = 2000;
+const CursorBillingCycleTimestampSchema = z.preprocess((value) => (typeof value === "string" || typeof value === "number" ? value : null), z.union([z.string(), z.number()]).nullable());
+const CursorUsageResponseSchema = z.object({
+    planUsage: z
+        .object({
+        totalSpend: ApiNullableNumberSchema,
+        includedSpend: ApiNullableNumberSchema,
+        bonusSpend: ApiNullableNumberSchema,
+        remaining: ApiNullableNumberSchema,
+        limit: ApiNullableNumberSchema,
+    })
+        .nullish(),
+    billingCycleStart: CursorBillingCycleTimestampSchema,
+    billingCycleEnd: CursorBillingCycleTimestampSchema,
+});
+const CursorAuthStatusSchema = z.object({
+    accessToken: z.string().optional(),
+});
+function parseCursorBillingCycleTimestamp(value) {
+    if (value === null)
+        return null;
+    const raw = String(value).trim();
+    if (!raw)
+        return null;
+    const numeric = Number(raw);
+    if (Number.isFinite(numeric)) {
+        const timestampMs = Math.abs(numeric) < 10000000000 ? numeric * 1000 : numeric;
+        return toIsoStringOrNull(timestampMs);
+    }
+    return toIsoStringOrNull(new Date(raw).getTime());
+}
+function centsToDollars(value) {
+    return value === null ? null : value / 100;
+}
+async function readCursorTokenFromSqlite() {
+    const dbPaths = [];
+    if (process.env["APPDATA"]) {
+        dbPaths.push(join(process.env["APPDATA"], "Cursor", "User", "globalStorage", "state.vscdb"));
+    }
+    dbPaths.push(join(homedir(), "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb"));
+    dbPaths.push(join(homedir(), ".config", "Cursor", "User", "globalStorage", "state.vscdb"));
+    for (const path of dbPaths) {
+        if (!existsSync(path))
+            continue;
+        try {
+            const { stdout } = await execFileAsync("sqlite3", [path, "SELECT value FROM ItemTable WHERE key = 'cursorAuthStatus'"], { timeout: CURSOR_SQLITE_TIMEOUT_MS });
+            if (stdout) {
+                const parsed = CursorAuthStatusSchema.parse(JSON.parse(stdout.trim()));
+                if (parsed.accessToken)
+                    return parsed.accessToken;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+export class CursorQuotaProvider {
+    constructor(options) {
+        this.providerId = "cursor";
+        this.displayName = "Cursor";
+        this.logger = options.logger;
+        this.fetchApi = options.fetch ?? fetch;
+    }
+    async fetchUsage() {
+        const token = process.env["CURSOR_ACCESS_TOKEN"] ||
+            process.env["CURSOR_TOKEN"] ||
+            (await readCursorTokenFromSqlite());
+        if (!token)
+            return unavailableUsage(this);
+        const res = await fetchProviderApi(this.fetchApi, "https://api2.cursor.sh/aiserver.v1.DashboardService/GetCurrentPeriodUsage", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json",
+                "Connect-Protocol-Version": "1",
+            },
+            body: JSON.stringify({}),
+        });
+        if (!res.ok) {
+            this.logger.debug({ status: res.status }, "Cursor usage fetch failed");
+            return unavailableUsage(this);
+        }
+        const resp = CursorUsageResponseSchema.parse(await res.json());
+        const billingCycleEnd = parseCursorBillingCycleTimestamp(resp.billingCycleEnd);
+        const balances = [];
+        if (resp.planUsage) {
+            const totalSpend = centsToDollars(resp.planUsage.totalSpend);
+            const remaining = centsToDollars(resp.planUsage.remaining);
+            const limit = centsToDollars(resp.planUsage.limit);
+            balances.push({
+                id: "plan_usage",
+                label: "Plan usage",
+                used: totalSpend,
+                remaining,
+                limit,
+                unit: "usd",
+                resetsAt: billingCycleEnd,
+                tone: balanceToneFromRemaining(remaining),
+            });
+        }
+        return {
+            providerId: this.providerId,
+            displayName: this.displayName,
+            status: "available",
+            planLabel: null,
+            windows: [],
+            balances,
+            details: [],
+            error: null,
+        };
+    }
+}
+//# sourceMappingURL=cursor.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/services/quota-fetcher/providers/grok.d.ts

@@ -0,0 +1,18 @@
+import type { Logger } from "pino";
+import type { ProviderUsage } from "../../../server/messages.js";
+import type { ProviderApiFetch, ProviderUsageFetcher } from "../provider.js";
+interface GrokQuotaProviderOptions {
+    logger: Logger;
+    fetch?: ProviderApiFetch;
+}
+export declare class GrokQuotaProvider implements ProviderUsageFetcher {
+    readonly providerId = "grok";
+    readonly displayName = "Grok";
+    private readonly logger;
+    private readonly fetchApi;
+    constructor(options: GrokQuotaProviderOptions);
+    fetchUsage(): Promise<ProviderUsage>;
+    private readGrokToken;
+}
+export {};
+//# sourceMappingURL=grok.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/services/quota-fetcher/providers/grok.js

@@ -0,0 +1,89 @@
+import { existsSync, promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { ApiNumberSchema, balanceToneFromRemaining, fetchProviderApi, unavailableUsage, } from "../usage.js";
+const GrokUsageResponseSchema = z.object({
+    config: z
+        .object({
+        monthlyLimit: z
+            .object({
+            val: ApiNumberSchema.optional(),
+        })
+            .nullish(),
+    })
+        .nullish(),
+    usage: z
+        .object({
+        creditUsage: ApiNumberSchema.optional(),
+    })
+        .nullish(),
+});
+const GrokAuthSchema = z.object({
+    access_token: z.string().optional(),
+});
+export class GrokQuotaProvider {
+    constructor(options) {
+        this.providerId = "grok";
+        this.displayName = "Grok";
+        this.logger = options.logger;
+        this.fetchApi = options.fetch ?? fetch;
+    }
+    async fetchUsage() {
+        const token = process.env["GROK_API_KEY"] || process.env["GROK_TOKEN"] || (await this.readGrokToken());
+        if (!token)
+            return unavailableUsage(this);
+        const res = await fetchProviderApi(this.fetchApi, "https://cli-chat-proxy.grok.com/v1/billing", {
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "X-XAI-Token-Auth": "xai-grok-cli",
+                Accept: "application/json",
+            },
+        });
+        if (!res.ok) {
+            this.logger.debug({ status: res.status }, "Grok usage fetch failed");
+            return unavailableUsage(this);
+        }
+        const resp = GrokUsageResponseSchema.parse(await res.json());
+        const monthlyLimit = resp.config?.monthlyLimit?.val ?? null;
+        const creditUsage = resp.usage?.creditUsage ?? null;
+        const balances = [];
+        if (monthlyLimit !== null || creditUsage !== null) {
+            const remaining = monthlyLimit !== null && creditUsage !== null
+                ? Math.max(0, monthlyLimit - creditUsage)
+                : null;
+            balances.push({
+                id: "monthly_credits",
+                label: "Monthly credits",
+                used: creditUsage,
+                remaining,
+                limit: monthlyLimit,
+                unit: "credits",
+                tone: balanceToneFromRemaining(remaining),
+            });
+        }
+        return {
+            providerId: this.providerId,
+            displayName: this.displayName,
+            status: "available",
+            planLabel: null,
+            windows: [],
+            balances,
+            details: [],
+            error: null,
+        };
+    }
+    async readGrokToken() {
+        const path = join(homedir(), ".grok", "auth.json");
+        if (!existsSync(path))
+            return null;
+        try {
+            const auth = GrokAuthSchema.parse(JSON.parse(await fs.readFile(path, "utf8")));
+            return auth.access_token ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=grok.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/services/quota-fetcher/providers/kimi.d.ts

@@ -0,0 +1,20 @@
+import type { Logger } from "pino";
+import type { ProviderUsage } from "../../../server/messages.js";
+import type { ProviderApiFetch, ProviderUsageFetcher } from "../provider.js";
+interface KimiQuotaProviderOptions {
+    logger: Logger;
+    fetch?: ProviderApiFetch;
+    homeDir?: string;
+}
+export declare class KimiQuotaProvider implements ProviderUsageFetcher {
+    readonly providerId = "kimi";
+    readonly displayName = "Kimi";
+    private readonly logger;
+    private readonly fetchApi;
+    private readonly homeDir?;
+    constructor(options: KimiQuotaProviderOptions);
+    fetchUsage(): Promise<ProviderUsage>;
+    private readKimiToken;
+}
+export {};
+//# sourceMappingURL=kimi.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/services/quota-fetcher/providers/kimi.js

@@ -0,0 +1,89 @@
+import { existsSync, promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { ApiOptionalStringSchema, fetchProviderApi, unavailableUsage } from "../usage.js";
+const KimiUsageResponseSchema = z.object({
+    usage: z
+        .object({
+        limit: ApiOptionalStringSchema,
+        remaining: ApiOptionalStringSchema,
+        resetTime: ApiOptionalStringSchema,
+    })
+        .nullish(),
+});
+const KimiAuthSchema = z.object({
+    access_token: z.string().optional(),
+});
+export class KimiQuotaProvider {
+    constructor(options) {
+        this.providerId = "kimi";
+        this.displayName = "Kimi";
+        this.logger = options.logger;
+        this.fetchApi = options.fetch ?? fetch;
+        this.homeDir = options.homeDir;
+    }
+    async fetchUsage() {
+        const token = process.env["KIMI_TOKEN"] || process.env["KIMI_API_KEY"] || (await this.readKimiToken());
+        if (!token)
+            return unavailableUsage(this);
+        const res = await fetchProviderApi(this.fetchApi, "https://api.kimi.com/coding/v1/usages", {
+            headers: {
+                Authorization: `Bearer ${token}`,
+                Accept: "application/json",
+            },
+        });
+        if (!res.ok) {
+            this.logger.debug({ status: res.status }, "Kimi usage fetch failed");
+            return unavailableUsage(this);
+        }
+        const resp = KimiUsageResponseSchema.parse(await res.json());
+        const limit = resp.usage?.limit === undefined ? null : Number(resp.usage.limit);
+        const remaining = resp.usage?.remaining === undefined ? null : Number(resp.usage.remaining);
+        const hasFiniteLimit = typeof limit === "number" && Number.isFinite(limit) && limit > 0;
+        const hasFiniteRemaining = typeof remaining === "number" && Number.isFinite(remaining);
+        const usedPct = hasFiniteLimit && hasFiniteRemaining
+            ? Math.max(0, Math.min(100, ((limit - remaining) / limit) * 100))
+            : null;
+        return {
+            providerId: this.providerId,
+            displayName: this.displayName,
+            status: "available",
+            planLabel: null,
+            windows: [
+                {
+                    id: "coding_usage",
+                    label: "Coding usage",
+                    usedPct,
+                    remainingPct: usedPct === null ? null : Math.max(0, 100 - usedPct),
+                    resetsAt: resp.usage?.resetTime ?? null,
+                    tone: "ok",
+                },
+            ],
+            balances: [],
+            details: [],
+            error: null,
+        };
+    }
+    async readKimiToken() {
+        const homeDir = this.homeDir ?? homedir();
+        const paths = [
+            join(process.env["KIMI_CODE_HOME"] || join(homeDir, ".kimi-code"), "credentials", "kimi-code.json"),
+            join(homeDir, ".kimi", "credentials", "kimi-code.json"),
+        ];
+        for (const path of paths) {
+            if (!existsSync(path))
+                continue;
+            try {
+                const credentials = KimiAuthSchema.parse(JSON.parse(await fs.readFile(path, "utf8")));
+                if (credentials.access_token)
+                    return credentials.access_token;
+            }
+            catch {
+                continue;
+            }
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=kimi.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/services/quota-fetcher/providers/minimax.d.ts

@@ -0,0 +1,29 @@
+import type { Logger } from "pino";
+import type { ProviderUsage } from "../../../server/messages.js";
+import type { ProviderApiFetch, ProviderUsageFetcher } from "../provider.js";
+interface MiniMaxQuotaProviderOptions {
+    logger: Logger;
+    fetch?: ProviderApiFetch;
+    configPath?: string;
+    credentialsPath?: string;
+    env?: NodeJS.ProcessEnv;
+    now?: () => number;
+}
+export declare class MiniMaxQuotaProvider implements ProviderUsageFetcher {
+    readonly providerId = "minimax";
+    readonly displayName = "MiniMax";
+    private readonly logger;
+    private readonly fetchApi;
+    private readonly configPath;
+    private readonly credentialsPath;
+    private readonly env;
+    private readonly now;
+    constructor(options: MiniMaxQuotaProviderOptions);
+    fetchUsage(): Promise<ProviderUsage>;
+    private resolveAuth;
+    private isExpired;
+    private readCredentials;
+    private readConfig;
+}
+export {};
+//# sourceMappingURL=minimax.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/services/quota-fetcher/providers/minimax.js

@@ -0,0 +1,227 @@
+import { existsSync, promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { ApiNumberSchema, ApiOptionalStringSchema, fetchProviderApi, unavailableUsage, windowFromUsedPct, } from "../usage.js";
+const MINIMAX_GLOBAL_BASE_URL = "https://api.minimax.io";
+const MINIMAX_CN_BASE_URL = "https://api.minimaxi.com";
+const MINIMAX_CREDENTIALS_PATH = join(homedir(), ".mmx", "credentials.json");
+const MINIMAX_CONFIG_PATH = join(homedir(), ".mmx", "config.json");
+const MiniMaxModelRemainSchema = z.object({
+    model_name: ApiOptionalStringSchema,
+    start_time: ApiNumberSchema.optional(),
+    end_time: ApiNumberSchema.optional(),
+    remains_time: ApiNumberSchema.optional(),
+    current_interval_total_count: ApiNumberSchema.optional(),
+    current_interval_usage_count: ApiNumberSchema.optional(),
+    current_interval_remaining_percent: ApiNumberSchema.optional(),
+    current_weekly_total_count: ApiNumberSchema.optional(),
+    current_weekly_usage_count: ApiNumberSchema.optional(),
+    current_weekly_remaining_percent: ApiNumberSchema.optional(),
+    current_interval_status: ApiNumberSchema.optional(),
+    current_weekly_status: ApiNumberSchema.optional(),
+    weekly_start_time: ApiNumberSchema.optional(),
+    weekly_end_time: ApiNumberSchema.optional(),
+    weekly_remains_time: ApiNumberSchema.optional(),
+    weekly_boost_permille: ApiNumberSchema.optional(),
+});
+const MiniMaxQuotaResponseSchema = z.object({
+    model_remains: z.array(MiniMaxModelRemainSchema).optional(),
+});
+const MiniMaxCredentialsSchema = z.object({
+    access_token: z.string().optional(),
+    refresh_token: z.string().optional(),
+    expires_at: ApiOptionalStringSchema,
+    resource_url: ApiOptionalStringSchema,
+});
+const MiniMaxConfigSchema = z.object({
+    api_key: z.string().optional(),
+    region: z.string().optional(),
+    base_url: ApiOptionalStringSchema,
+    oauth: MiniMaxCredentialsSchema.optional(),
+});
+function resolveBaseUrl(input) {
+    const explicit = input.baseUrl;
+    if (explicit && explicit.startsWith("http"))
+        return explicit;
+    if (input.region === "cn")
+        return MINIMAX_CN_BASE_URL;
+    return MINIMAX_GLOBAL_BASE_URL;
+}
+function computeUsedPct(remaining, total) {
+    if (typeof remaining !== "number" || typeof total !== "number")
+        return null;
+    if (!Number.isFinite(total) || total <= 0)
+        return null;
+    if (!Number.isFinite(remaining))
+        return null;
+    const used = total - remaining;
+    return Math.max(0, Math.min(100, (used / total) * 100));
+}
+function epochMsToIso(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+        return null;
+    return new Date(value).toISOString();
+}
+function toneForStatus(status) {
+    if (status === 2)
+        return "danger";
+    if (status === 3)
+        return "default";
+    return "ok";
+}
+function toIntervalWindow(modelName, model) {
+    const total = model.current_interval_total_count ?? null;
+    const used = model.current_interval_usage_count ?? null;
+    const remainingPercent = model.current_interval_remaining_percent ?? null;
+    const usedPct = typeof remainingPercent === "number" && Number.isFinite(remainingPercent)
+        ? Math.max(0, Math.min(100, 100 - remainingPercent))
+        : computeUsedPct(typeof total === "number" && typeof used === "number" ? total - used : null, total);
+    if (usedPct === null)
+        return null;
+    return windowFromUsedPct({
+        id: `interval_${modelName}`,
+        label: `${modelName} · Interval`,
+        utilizationPct: usedPct,
+        resetsAt: epochMsToIso(model.end_time),
+        tone: toneForStatus(model.current_interval_status),
+    });
+}
+function toWeeklyWindow(modelName, model) {
+    const total = model.current_weekly_total_count ?? null;
+    const used = model.current_weekly_usage_count ?? null;
+    const remainingPercent = model.current_weekly_remaining_percent ?? null;
+    let usedPct = null;
+    if (typeof remainingPercent === "number" && Number.isFinite(remainingPercent)) {
+        usedPct = Math.max(0, Math.min(100, 100 - remainingPercent));
+    }
+    else if (typeof total === "number" && typeof used === "number") {
+        usedPct = computeUsedPct(total - used, total);
+    }
+    if (usedPct === null)
+        return null;
+    return windowFromUsedPct({
+        id: `weekly_${modelName}`,
+        label: `${modelName} · Weekly`,
+        utilizationPct: usedPct,
+        resetsAt: epochMsToIso(model.weekly_end_time),
+        tone: toneForStatus(model.current_weekly_status),
+    });
+}
+export class MiniMaxQuotaProvider {
+    constructor(options) {
+        this.providerId = "minimax";
+        this.displayName = "MiniMax";
+        this.logger = options.logger;
+        this.fetchApi = options.fetch ?? fetch;
+        this.configPath = options.configPath ?? MINIMAX_CONFIG_PATH;
+        this.credentialsPath = options.credentialsPath ?? MINIMAX_CREDENTIALS_PATH;
+        this.env = options.env ?? process.env;
+        this.now = options.now ?? Date.now;
+    }
+    async fetchUsage() {
+        const auth = await this.resolveAuth();
+        if (!auth)
+            return unavailableUsage(this);
+        const res = await fetchProviderApi(this.fetchApi, `${auth.baseUrl}/v1/token_plan/remains`, {
+            headers: {
+                Authorization: `Bearer ${auth.token}`,
+                Accept: "application/json",
+            },
+        });
+        if (!res.ok) {
+            this.logger.debug({ status: res.status }, "MiniMax usage fetch failed");
+            return unavailableUsage(this);
+        }
+        const resp = MiniMaxQuotaResponseSchema.parse(await res.json());
+        const models = resp.model_remains ?? [];
+        const windows = [];
+        for (const model of models) {
+            const name = model.model_name ?? "token-plan";
+            const intervalWindow = toIntervalWindow(name, model);
+            if (intervalWindow)
+                windows.push(intervalWindow);
+            const weeklyWindow = toWeeklyWindow(name, model);
+            if (weeklyWindow)
+                windows.push(weeklyWindow);
+        }
+        return {
+            providerId: this.providerId,
+            displayName: this.displayName,
+            status: windows.length > 0 ? "available" : "unavailable",
+            planLabel: null,
+            windows,
+            balances: [],
+            details: [],
+            error: null,
+        };
+    }
+    async resolveAuth() {
+        const envToken = this.env["MINIMAX_API_KEY"];
+        if (envToken) {
+            const envBase = this.env["MINIMAX_BASE_URL"];
+            return {
+                token: envToken,
+                baseUrl: resolveBaseUrl({ baseUrl: envBase }),
+            };
+        }
+        const credentials = await this.readCredentials();
+        if (credentials?.access_token && !this.isExpired(credentials.expires_at)) {
+            return {
+                token: credentials.access_token,
+                baseUrl: resolveBaseUrl({ baseUrl: credentials.resource_url }),
+            };
+        }
+        const config = await this.readConfig();
+        if (config?.api_key) {
+            return {
+                token: config.api_key,
+                baseUrl: resolveBaseUrl({
+                    baseUrl: config.base_url,
+                    region: config.region,
+                }),
+            };
+        }
+        if (config?.oauth?.access_token && !this.isExpired(config.oauth.expires_at)) {
+            return {
+                token: config.oauth.access_token,
+                baseUrl: resolveBaseUrl({
+                    baseUrl: config.oauth.resource_url ?? config.base_url,
+                    region: config.region,
+                }),
+            };
+        }
+        return null;
+    }
+    isExpired(expiresAt) {
+        if (!expiresAt)
+            return false;
+        const parsed = Date.parse(expiresAt);
+        if (!Number.isFinite(parsed))
+            return false;
+        return parsed <= this.now();
+    }
+    async readCredentials() {
+        if (!existsSync(this.credentialsPath))
+            return null;
+        try {
+            const raw = JSON.parse(await fs.readFile(this.credentialsPath, "utf8"));
+            return MiniMaxCredentialsSchema.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    async readConfig() {
+        if (!existsSync(this.configPath))
+            return null;
+        try {
+            const raw = JSON.parse(await fs.readFile(this.configPath, "utf8"));
+            return MiniMaxConfigSchema.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=minimax.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/services/quota-fetcher/providers/zai.d.ts

@@ -0,0 +1,17 @@
+import type { Logger } from "pino";
+import type { ProviderUsage } from "../../../server/messages.js";
+import type { ProviderApiFetch, ProviderUsageFetcher } from "../provider.js";
+interface ZaiQuotaProviderOptions {
+    logger: Logger;
+    fetch?: ProviderApiFetch;
+}
+export declare class ZaiQuotaProvider implements ProviderUsageFetcher {
+    readonly providerId = "zai";
+    readonly displayName = "Z.ai";
+    private readonly logger;
+    private readonly fetchApi;
+    constructor(options: ZaiQuotaProviderOptions);
+    fetchUsage(): Promise<ProviderUsage>;
+}
+export {};
+//# sourceMappingURL=zai.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/services/quota-fetcher/providers/zai.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { ApiOptionalStringSchema, fetchProviderApi, unavailableUsage } from "../usage.js";
+const ZaiUsageResponseSchema = z.object({
+    data: z
+        .array(z.object({
+        productName: ApiOptionalStringSchema,
+        status: ApiOptionalStringSchema,
+        purchaseTime: ApiOptionalStringSchema,
+        valid: ApiOptionalStringSchema,
+    }))
+        .optional(),
+});
+export class ZaiQuotaProvider {
+    constructor(options) {
+        this.providerId = "zai";
+        this.displayName = "Z.ai";
+        this.logger = options.logger;
+        this.fetchApi = options.fetch ?? fetch;
+    }
+    async fetchUsage() {
+        const token = process.env["ZAI_API_KEY"] || process.env["GLM_API_KEY"];
+        if (!token)
+            return unavailableUsage(this);
+        const res = await fetchProviderApi(this.fetchApi, "https://api.z.ai/api/biz/subscription/list", {
+            headers: {
+                Authorization: `Bearer ${token}`,
+                Accept: "application/json",
+            },
+        });
+        if (!res.ok) {
+            this.logger.debug({ status: res.status }, "Z.ai usage fetch failed");
+            return unavailableUsage(this);
+        }
+        const resp = ZaiUsageResponseSchema.parse(await res.json());
+        const sub = resp.data?.[0];
+        if (!sub)
+            return unavailableUsage(this);
+        const details = [];
+        if (sub.status)
+            details.push({ id: "status", label: "Status", value: sub.status });
+        if (sub.valid)
+            details.push({ id: "valid", label: "Valid", value: sub.valid });
+        if (sub.purchaseTime) {
+            details.push({ id: "purchase_time", label: "Purchased", value: sub.purchaseTime });
+        }
+        return {
+            providerId: this.providerId,
+            displayName: this.displayName,
+            status: "available",
+            planLabel: sub.productName || null,
+            windows: [],
+            balances: [],
+            details,
+            error: null,
+        };
+    }
+}
+//# sourceMappingURL=zai.js.map