@neuralnomads/codenomad-dev 0.18.0-dev-20260715-07e8ce68 → 0.18.0-dev-20260716-40cee071

package/dist/usage/providers/google.js

@@ -0,0 +1,171 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { asObject, fetchJson, getAuthEntry, getString, notConfigured, result, toNumber, toTimestamp, toUsageWindow } from "../shared";
+const GOOGLE_ENDPOINTS = [
+    "https://daily-cloudcode-pa.sandbox.googleapis.com",
+    "https://autopush-cloudcode-pa.sandbox.googleapis.com",
+    "https://cloudcode-pa.googleapis.com",
+];
+const DEFAULT_PROJECT_ID = "rising-fact-p41fc";
+function parseRefresh(value) {
+    const raw = getString(value);
+    if (!raw)
+        return {};
+    const [token, projectId, managedProjectId] = raw.split("|");
+    return { token: getString(token) ?? undefined, projectId: getString(projectId) ?? getString(managedProjectId) ?? undefined };
+}
+function readJson(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function googleSources() {
+    const sources = [];
+    const entry = asObject(getAuthEntry(["google", "google.oauth"]));
+    const oauth = asObject(entry?.oauth) ?? entry;
+    if (oauth) {
+        const refresh = parseRefresh(oauth.refresh);
+        const accessToken = getString(oauth.access) ?? getString(oauth.token) ?? undefined;
+        if (accessToken || refresh.token) {
+            sources.push({
+                id: "gemini",
+                accessToken,
+                refreshToken: refresh.token,
+                projectId: refresh.projectId,
+                expires: toTimestamp(oauth.expires),
+            });
+        }
+    }
+    const home = os.homedir();
+    for (const candidate of [
+        path.join(home, ".config", "opencode", "antigravity-accounts.json"),
+        path.join(home, ".local", "share", "opencode", "antigravity-accounts.json"),
+    ]) {
+        const data = readJson(candidate);
+        const accounts = Array.isArray(data?.accounts) ? data.accounts : [];
+        const account = accounts[data?.activeIndex ?? 0] ?? accounts[0];
+        const refresh = parseRefresh(account?.refreshToken);
+        const accessToken = getString(account?.accessToken) ?? getString(account?.access_token) ?? undefined;
+        if (accessToken || refresh.token) {
+            sources.push({
+                id: "antigravity",
+                accessToken,
+                refreshToken: refresh.token,
+                projectId: getString(account?.projectId) ?? refresh.projectId,
+                expires: toTimestamp(account?.expiresAt ?? account?.expires),
+            });
+            break;
+        }
+    }
+    return sources;
+}
+async function refreshAccessToken(source) {
+    if (!source.refreshToken)
+        return null;
+    const prefix = source.id === "gemini" ? "GOOGLE" : "ANTIGRAVITY";
+    const clientId = getString(process.env[`${prefix}_OAUTH_CLIENT_ID`]);
+    const clientSecret = getString(process.env[`${prefix}_OAUTH_CLIENT_SECRET`]);
+    if (!clientId || !clientSecret)
+        return null;
+    const payload = await fetchJson("https://oauth2.googleapis.com/token", {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+            client_id: clientId,
+            client_secret: clientSecret,
+            refresh_token: source.refreshToken,
+            grant_type: "refresh_token",
+        }),
+    });
+    return getString(payload?.access_token);
+}
+function transformModel(sourceId, modelId, data) {
+    const fraction = toNumber(data?.quotaInfo?.remainingFraction ?? data?.remainingFraction);
+    const resetAt = toTimestamp(data?.quotaInfo?.resetTime ?? data?.resetTime);
+    const label = sourceId === "gemini" || (resetAt !== null && resetAt - Date.now() > 10 * 3600 * 1000) ? "daily" : "5h";
+    return {
+        [`${sourceId}/${modelId}`]: {
+            windows: {
+                [label]: toUsageWindow({
+                    usedPercent: fraction === null ? null : 100 - fraction * 100,
+                    windowSeconds: label === "daily" ? 86400 : 5 * 3600,
+                    resetAt,
+                }),
+            },
+        },
+    };
+}
+const google = {
+    id: "google",
+    name: "Google",
+    aliases: ["google", "google.oauth", "gemini", "antigravity"],
+    async fetchQuota() {
+        const sources = googleSources();
+        if (sources.length === 0)
+            return notConfigured(this.id, this.name);
+        const models = {};
+        try {
+            for (const source of sources) {
+                const accessToken = source.accessToken && (!source.expires || source.expires > Date.now())
+                    ? source.accessToken
+                    : await refreshAccessToken(source);
+                if (!accessToken)
+                    continue;
+                const projectId = source.projectId ?? DEFAULT_PROJECT_ID;
+                if (source.id === "gemini") {
+                    try {
+                        const quota = await fetchJson(`${GOOGLE_ENDPOINTS[2]}/v1internal:retrieveUserQuota`, {
+                            method: "POST",
+                            headers: { Authorization: `Bearer ${accessToken}`, "Content-Type": "application/json" },
+                            body: JSON.stringify({ project: projectId }),
+                        });
+                        for (const bucket of Array.isArray(quota?.buckets) ? quota.buckets : []) {
+                            const modelId = getString(bucket?.modelId);
+                            if (modelId)
+                                Object.assign(models, transformModel(source.id, modelId, bucket));
+                        }
+                    }
+                    catch {
+                        // The model endpoint below often remains available when quota buckets are not.
+                    }
+                }
+                for (const endpoint of GOOGLE_ENDPOINTS) {
+                    try {
+                        const payload = await fetchJson(`${endpoint}/v1internal:fetchAvailableModels`, {
+                            method: "POST",
+                            headers: {
+                                Authorization: `Bearer ${accessToken}`,
+                                "Content-Type": "application/json",
+                                "User-Agent": "antigravity/1.11.5 windows/amd64",
+                                "X-Goog-Api-Client": "google-cloud-sdk vscode_cloudshelleditor/0.1",
+                            },
+                            body: JSON.stringify({ project: projectId }),
+                        });
+                        for (const [modelId, data] of Object.entries(payload?.models ?? {})) {
+                            Object.assign(models, transformModel(source.id, modelId, data));
+                        }
+                        break;
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+            }
+            if (Object.keys(models).length === 0)
+                throw new Error("No model quota data available");
+            return result(this.id, this.name, { ok: true, configured: true, usage: { windows: {}, models } });
+        }
+        catch (error) {
+            return result(this.id, this.name, {
+                ok: false,
+                configured: true,
+                error: error instanceof Error ? error.message : "Request failed",
+            });
+        }
+    },
+};
+export const googleProviders = [google];

package/dist/usage/providers/minimax.js

@@ -0,0 +1,109 @@
+import { fetchJson, getCredential, notConfigured, result, toNumber, toTimestamp, toUsageWindow } from "../shared";
+const INACTIVE_WINDOW_STATUS = 3;
+function pickChatModel(models) {
+    return (models.find((model) => /^minimax-m/i.test(String(model?.model_name ?? "")) && (toNumber(model?.current_interval_total_count) ?? 0) > 0) ??
+        models.find((model) => ["general", "chat", "text"].includes(String(model?.model_name ?? "").toLowerCase())) ??
+        models.find((model) => toNumber(model?.current_interval_remaining_percent) !== null) ??
+        models[0] ??
+        null);
+}
+function isUsablePayload(payload) {
+    if (payload?.base_resp && payload.base_resp.status_code !== 0)
+        return false;
+    return Array.isArray(payload?.model_remains) && payload.model_remains.length > 0;
+}
+function usedPercent(model, prefix, tokenPlan) {
+    const remainingPercent = toNumber(model?.[`current_${prefix}_remaining_percent`]);
+    if (remainingPercent !== null)
+        return 100 - remainingPercent;
+    const total = toNumber(model?.[`current_${prefix}_total_count`]);
+    const rawUsage = toNumber(model?.[`current_${prefix}_usage_count`]);
+    if (!total || rawUsage === null)
+        return null;
+    const used = tokenPlan ? total - rawUsage : rawUsage;
+    return (Math.max(0, used) / total) * 100;
+}
+function windowSeconds(model, prefix) {
+    const startAt = toTimestamp(prefix === "interval" ? model?.start_time : model?.weekly_start_time);
+    const resetAt = toTimestamp(prefix === "interval" ? model?.end_time : model?.weekly_end_time);
+    if (startAt !== null && resetAt !== null && resetAt > startAt)
+        return Math.floor((resetAt - startAt) / 1000);
+    const remainsMs = toNumber(prefix === "interval" ? model?.remains_time : model?.weekly_remains_time);
+    return remainsMs && remainsMs > 0 ? Math.floor(remainsMs / 1000) : null;
+}
+function createMiniMaxProvider(input) {
+    return {
+        id: input.id,
+        name: input.name,
+        aliases: input.aliases,
+        async fetchQuota() {
+            const key = getCredential(input.aliases, ["key", "token"]);
+            if (!key)
+                return notConfigured(this.id, this.name);
+            try {
+                let tokenPlan = true;
+                let payload = null;
+                try {
+                    const tokenPayload = await fetchJson(input.tokenPlanUrl, { headers: { Authorization: `Bearer ${key}` } });
+                    if (isUsablePayload(tokenPayload))
+                        payload = tokenPayload;
+                }
+                catch {
+                    // Fall back to the legacy Coding Plan endpoint below.
+                }
+                if (!payload) {
+                    tokenPlan = false;
+                    const codingPayload = await fetchJson(input.codingPlanUrl, { headers: { Authorization: `Bearer ${key}` } });
+                    if (isUsablePayload(codingPayload))
+                        payload = codingPayload;
+                }
+                if (!payload)
+                    throw new Error("Provider returned no usable quota data");
+                const model = pickChatModel(Array.isArray(payload?.model_remains) ? payload.model_remains : []);
+                if (!model)
+                    throw new Error("No model quota data available");
+                const intervalResetAt = toTimestamp(model?.end_time);
+                const windows = {
+                    "5h": toUsageWindow({
+                        usedPercent: usedPercent(model, "interval", tokenPlan),
+                        windowSeconds: windowSeconds(model, "interval"),
+                        resetAt: intervalResetAt,
+                    }),
+                };
+                const weeklyStatus = toNumber(model?.current_weekly_status);
+                const hasWeekly = weeklyStatus !== INACTIVE_WINDOW_STATUS && (toNumber(model?.current_weekly_remaining_percent) !== null || (toNumber(model?.current_weekly_total_count) ?? 0) > 0);
+                if (hasWeekly) {
+                    windows.weekly = toUsageWindow({
+                        usedPercent: usedPercent(model, "weekly", tokenPlan),
+                        windowSeconds: windowSeconds(model, "weekly"),
+                        resetAt: toTimestamp(model?.weekly_end_time),
+                    });
+                }
+                return result(this.id, this.name, { ok: true, configured: true, usage: { windows } });
+            }
+            catch (error) {
+                return result(this.id, this.name, {
+                    ok: false,
+                    configured: true,
+                    error: error instanceof Error ? error.message : "Request failed",
+                });
+            }
+        },
+    };
+}
+export const miniMaxProviders = [
+    createMiniMaxProvider({
+        id: "minimax-coding-plan",
+        name: "MiniMax Coding Plan",
+        aliases: ["minimax-coding-plan", "minimax"],
+        tokenPlanUrl: "https://api.minimax.io/v1/token_plan/remains",
+        codingPlanUrl: "https://api.minimax.io/v1/api/openplatform/coding_plan/remains",
+    }),
+    createMiniMaxProvider({
+        id: "minimax-cn-coding-plan",
+        name: "MiniMax Coding Plan CN",
+        aliases: ["minimax-cn-coding-plan", "minimaxi"],
+        tokenPlanUrl: "https://api.minimaxi.com/v1/token_plan/remains",
+        codingPlanUrl: "https://www.minimaxi.com/v1/api/openplatform/coding_plan/remains",
+    }),
+];

package/dist/usage/providers/oauth.js

@@ -0,0 +1,111 @@
+import { fetchJson, getAuthEntry, getCredential, notConfigured, resolveWindowLabel, safeFetch, toNumber, toTimestamp, toUsageWindow, } from "../shared";
+const claudeAliases = ["anthropic", "claude"];
+const claude = {
+    id: "claude",
+    name: "Claude",
+    aliases: claudeAliases,
+    async fetchQuota() {
+        const token = getCredential(claudeAliases, ["access", "token"]);
+        if (!token)
+            return notConfigured(this.id, this.name);
+        return safeFetch(this.id, this.name, async () => {
+            const payload = await fetchJson("https://api.anthropic.com/api/oauth/usage", {
+                headers: { Authorization: `Bearer ${token}`, "anthropic-beta": "oauth-2025-04-20" },
+            });
+            const windows = {};
+            for (const [key, source] of [
+                ["5h", payload?.five_hour],
+                ["7d", payload?.seven_day],
+                ["7d-sonnet", payload?.seven_day_sonnet],
+                ["7d-opus", payload?.seven_day_opus],
+            ]) {
+                if (!source)
+                    continue;
+                windows[key] = toUsageWindow({ usedPercent: toNumber(source.utilization), resetAt: toTimestamp(source.resets_at) });
+            }
+            return { windows };
+        });
+    },
+};
+const codexAliases = ["openai", "codex", "chatgpt"];
+const codex = {
+    id: "codex",
+    name: "Codex",
+    aliases: codexAliases,
+    async fetchQuota() {
+        const entry = getAuthEntry(codexAliases);
+        const token = entry && (typeof entry.access === "string" ? entry.access : typeof entry.token === "string" ? entry.token : null);
+        if (!token)
+            return notConfigured(this.id, this.name);
+        return safeFetch(this.id, this.name, async () => {
+            const accountId = typeof entry?.accountId === "string" ? entry.accountId : null;
+            const payload = await fetchJson("https://chatgpt.com/backend-api/wham/usage", {
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    "Content-Type": "application/json",
+                    ...(accountId ? { "ChatGPT-Account-Id": accountId } : {}),
+                },
+            });
+            const windows = {};
+            for (const source of [payload?.rate_limit?.primary_window, payload?.rate_limit?.secondary_window]) {
+                if (!source)
+                    continue;
+                const seconds = toNumber(source.limit_window_seconds);
+                windows[resolveWindowLabel(seconds)] = toUsageWindow({
+                    usedPercent: toNumber(source.used_percent),
+                    windowSeconds: seconds,
+                    resetAt: toTimestamp(source.reset_at),
+                });
+            }
+            const balance = toNumber(payload?.credits?.balance);
+            if (payload?.credits?.unlimited || balance !== null) {
+                windows.credits_balance = toUsageWindow({
+                    usedPercent: null,
+                    valueLabel: payload?.credits?.unlimited ? "∞" : `$${balance.toFixed(2)}`,
+                });
+            }
+            return { windows };
+        });
+    },
+};
+const copilotAliases = ["github-copilot", "copilot"];
+const copilot = {
+    id: "github-copilot",
+    name: "GitHub Copilot",
+    aliases: copilotAliases,
+    async fetchQuota() {
+        const token = getCredential(copilotAliases, ["access", "token"]);
+        if (!token)
+            return notConfigured(this.id, this.name);
+        return safeFetch(this.id, this.name, async () => {
+            const payload = await fetchJson("https://api.github.com/copilot_internal/user", {
+                headers: {
+                    Authorization: `token ${token}`,
+                    Accept: "application/json",
+                    "Editor-Version": "vscode/1.96.2",
+                    "X-Github-Api-Version": "2025-04-01",
+                },
+            });
+            const resetAt = toTimestamp(payload?.quota_reset_date);
+            const windows = {};
+            for (const [key, snapshot] of Object.entries({
+                chat: payload?.quota_snapshots?.chat,
+                completions: payload?.quota_snapshots?.completions,
+                premium: payload?.quota_snapshots?.premium_interactions,
+            })) {
+                if (!snapshot)
+                    continue;
+                const source = snapshot;
+                const entitlement = toNumber(source.entitlement);
+                const remaining = toNumber(source.remaining);
+                windows[key] = toUsageWindow({
+                    usedPercent: entitlement && remaining !== null ? 100 - (remaining / entitlement) * 100 : null,
+                    resetAt,
+                    valueLabel: entitlement !== null && remaining !== null ? `${remaining.toFixed(0)} / ${entitlement.toFixed(0)}` : null,
+                });
+            }
+            return { windows };
+        });
+    },
+};
+export const oauthProviders = [claude, codex, copilot];

package/dist/usage/providers/special.js

@@ -0,0 +1,148 @@
+import { fetchJson, getString, notConfigured, safeFetch, toNumber, toTimestamp, toUsageWindow } from "../shared";
+function decodeJwtExpiration(token) {
+    try {
+        const payload = token.split(".")[1];
+        if (!payload)
+            return null;
+        const parsed = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+        return typeof parsed?.exp === "number" ? parsed.exp * 1000 : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveCursorToken() {
+    const accessToken = getString(process.env.CURSOR_ACCESS_TOKEN) ?? getString(process.env.CURSOR_TOKEN);
+    const refreshToken = getString(process.env.CURSOR_REFRESH_TOKEN);
+    const expiresAt = accessToken ? decodeJwtExpiration(accessToken) : null;
+    if (accessToken && (!expiresAt || expiresAt > Date.now() + 5 * 60000))
+        return accessToken;
+    if (!refreshToken)
+        return accessToken;
+    const payload = await fetchJson("https://api2.cursor.sh/oauth/token", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ grant_type: "refresh_token", client_id: "KbZUR41cY7W6zRSdpSUJ7I7mLYBKOCmB", refresh_token: refreshToken }),
+    });
+    return getString(payload?.access_token);
+}
+async function cursorPost(url, token) {
+    return fetchJson(url, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json", "Connect-Protocol-Version": "1" },
+        body: "{}",
+    });
+}
+const cursor = {
+    id: "cursor",
+    name: "Cursor",
+    aliases: ["cursor"],
+    async fetchQuota() {
+        const token = await resolveCursorToken().catch(() => null);
+        if (!token)
+            return notConfigured(this.id, this.name);
+        return safeFetch(this.id, this.name, async () => {
+            const usage = await cursorPost("https://api2.cursor.sh/aiserver.v1.DashboardService/GetCurrentPeriodUsage", token);
+            const plan = await cursorPost("https://api2.cursor.sh/aiserver.v1.DashboardService/GetPlanInfo", token).catch(() => null);
+            const source = usage?.planUsage ?? {};
+            const limit = toNumber(source.limit);
+            const remaining = toNumber(source.remaining);
+            const explicit = toNumber(source.totalPercentUsed);
+            const resetAt = toTimestamp(usage?.billingCycleEnd ?? plan?.planInfo?.billingCycleEnd);
+            return {
+                windows: {
+                    billing_cycle: toUsageWindow({
+                        usedPercent: explicit ?? (limit && remaining !== null ? ((limit - remaining) / limit) * 100 : null),
+                        resetAt,
+                        valueLabel: toNumber(source.totalSpend) !== null ? `$${(toNumber(source.totalSpend) / 100).toFixed(2)}` : null,
+                    }),
+                },
+            };
+        });
+    },
+};
+function parseOllamaUsage(html) {
+    const windows = {};
+    for (const [label, pattern] of [
+        ["session", /Session\s+usage[^0-9]*([0-9.]+)%/i],
+        ["weekly", /Weekly\s+usage[^0-9]*([0-9.]+)%/i],
+    ]) {
+        const match = html.match(pattern);
+        if (match)
+            windows[label] = toUsageWindow({ usedPercent: toNumber(match[1]) });
+    }
+    const premium = html.match(/Premium[^0-9]*([0-9]+)\s*\/\s*([0-9]+)/i);
+    if (premium) {
+        const used = toNumber(premium[1]);
+        const total = toNumber(premium[2]);
+        windows.premium = toUsageWindow({
+            usedPercent: total && used !== null ? (used / total) * 100 : null,
+            valueLabel: used !== null && total !== null ? `${used} / ${total}` : null,
+        });
+    }
+    return windows;
+}
+const ollamaCloud = {
+    id: "ollama-cloud",
+    name: "Ollama Cloud",
+    aliases: ["ollama-cloud", "ollamacloud"],
+    async fetchQuota() {
+        const cookie = getString(process.env.OLLAMA_CLOUD_COOKIE);
+        if (!cookie)
+            return notConfigured(this.id, this.name);
+        return safeFetch(this.id, this.name, async () => {
+            const response = await fetch("https://ollama.com/settings", {
+                headers: { Cookie: cookie, "User-Agent": "CodeNomad usage provider" },
+                redirect: "manual",
+                signal: AbortSignal.timeout(15000),
+            });
+            if (!response.ok)
+                throw new Error(`Provider returned HTTP ${response.status}`);
+            const windows = parseOllamaUsage(await response.text());
+            if (Object.keys(windows).length === 0)
+                throw new Error("No usage data available");
+            return { windows };
+        });
+    },
+};
+function parseOpenCodeGoUsage(html, now = Date.now()) {
+    const normalized = html.replace(/"|"|\\u0022|\\"/g, '"');
+    const windows = {};
+    for (const [label, field] of Object.entries({ "5h": "rollingUsage", weekly: "weeklyUsage", monthly: "monthlyUsage" })) {
+        const match = normalized.match(new RegExp(`["']?${field}["']?\\s*:\\s*(?:\\$R\\[\\d+\\]\\s*=\\s*)?\\{([^{}]*)\\}`, "s"));
+        if (!match)
+            continue;
+        const capture = (name) => toNumber(match[1]?.match(new RegExp(`["']?${name}["']?\\s*:\\s*["']?(-?\\d+(?:\\.\\d+)?)`))?.[1]);
+        const usedPercent = capture("usagePercent");
+        const resetInSec = capture("resetInSec");
+        if (usedPercent !== null && resetInSec !== null) {
+            windows[label] = toUsageWindow({ usedPercent, resetAt: now + Math.max(0, resetInSec) * 1000 });
+        }
+    }
+    return windows;
+}
+const openCodeGo = {
+    id: "opencode-go",
+    name: "OpenCode Go",
+    aliases: ["opencode-go", "opencode"],
+    async fetchQuota() {
+        const workspaceId = getString(process.env.OPENCODE_GO_WORKSPACE_ID);
+        const authCookie = getString(process.env.OPENCODE_GO_AUTH_COOKIE);
+        if (!workspaceId || !authCookie)
+            return notConfigured(this.id, this.name);
+        return safeFetch(this.id, this.name, async () => {
+            const response = await fetch(`https://opencode.ai/workspace/${encodeURIComponent(workspaceId)}/go`, {
+                headers: { Cookie: `auth=${authCookie.replace(/^auth=/, "")}`, "User-Agent": "CodeNomad usage provider" },
+                redirect: "manual",
+                signal: AbortSignal.timeout(15000),
+            });
+            if (!response.ok)
+                throw new Error(`Provider returned HTTP ${response.status}`);
+            const windows = parseOpenCodeGoUsage(await response.text());
+            if (Object.keys(windows).length === 0)
+                throw new Error("No usage data available");
+            return { windows };
+        });
+    },
+};
+export const specialProviders = [cursor, ollamaCloud, openCodeGo];

package/dist/usage/service.js

@@ -0,0 +1,83 @@
+import { apiKeyProviders } from "./providers/api-key";
+import { googleProviders } from "./providers/google";
+import { miniMaxProviders } from "./providers/minimax";
+import { oauthProviders } from "./providers/oauth";
+import { specialProviders } from "./providers/special";
+const CACHE_TTL_MS = 60000;
+const providers = [...oauthProviders, ...apiKeyProviders, ...miniMaxProviders, ...googleProviders, ...specialProviders];
+const registry = new Map();
+for (const provider of providers) {
+    registry.set(provider.id, provider);
+    for (const alias of provider.aliases)
+        registry.set(alias.toLowerCase(), provider);
+}
+const cache = new Map();
+const pending = new Map();
+export function resolveUsageProvider(providerId) {
+    return registry.get(providerId.trim().toLowerCase()) ?? null;
+}
+function normalizeModelId(value) {
+    return value.toLowerCase().replace(/^models\//, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+export function selectModelWindows(result, modelId) {
+    const usage = result.usage;
+    if (!usage)
+        return {};
+    if (!modelId || !usage.models)
+        return usage.windows;
+    const target = normalizeModelId(modelId);
+    const entries = Object.entries(usage.models);
+    const exact = entries.find(([name]) => normalizeModelId(name.split("/").pop() ?? name) === target);
+    if (exact)
+        return exact[1].windows;
+    const partial = entries.find(([name]) => {
+        const candidate = normalizeModelId(name.split("/").pop() ?? name);
+        return candidate.includes(target) || target.includes(candidate);
+    });
+    return partial?.[1].windows ?? usage.windows;
+}
+async function fetchProvider(provider) {
+    const cached = cache.get(provider.id);
+    if (cached && cached.expiresAt > Date.now())
+        return cached.result;
+    const inFlight = pending.get(provider.id);
+    if (inFlight)
+        return inFlight;
+    const request = provider.fetchQuota().then((result) => {
+        cache.set(provider.id, { result, expiresAt: Date.now() + CACHE_TTL_MS });
+        return result;
+    }).finally(() => pending.delete(provider.id));
+    pending.set(provider.id, request);
+    return request;
+}
+export async function getProviderUsage(requestedProviderId, options = {}) {
+    const provider = resolveUsageProvider(requestedProviderId);
+    if (!provider) {
+        return {
+            requestedProviderId,
+            providerId: null,
+            providerName: requestedProviderId,
+            modelId: options.modelId,
+            supported: false,
+            configured: false,
+            ok: false,
+            windows: {},
+            fetchedAt: Date.now(),
+        };
+    }
+    const result = await fetchProvider(provider);
+    return {
+        requestedProviderId,
+        providerId: provider.id,
+        providerName: result.providerName,
+        modelId: options.modelId,
+        supported: true,
+        configured: result.configured,
+        ok: result.ok,
+        windows: selectModelWindows(result, options.modelId),
+        fetchedAt: result.fetchedAt,
+    };
+}
+export function clearProviderUsageCache() {
+    cache.clear();
+}

package/dist/usage/service.test.js

@@ -0,0 +1,59 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { getProviderUsage, resolveUsageProvider, selectModelWindows } from "./service";
+const providerIds = [
+    "claude",
+    "codex",
+    "github-copilot",
+    "google",
+    "kimi-for-coding",
+    "nano-gpt",
+    "openrouter",
+    "zai-coding-plan",
+    "zhipuai-coding-plan",
+    "minimax-coding-plan",
+    "minimax-cn-coding-plan",
+    "ollama-cloud",
+    "wafer",
+    "opencode-go",
+    "cursor",
+];
+test("registers every supported usage provider", () => {
+    for (const providerId of providerIds) {
+        assert.equal(resolveUsageProvider(providerId)?.id, providerId);
+    }
+});
+test("maps OpenCode provider aliases to their usage provider", () => {
+    assert.equal(resolveUsageProvider("anthropic")?.id, "claude");
+    assert.equal(resolveUsageProvider("openai")?.id, "codex");
+    assert.equal(resolveUsageProvider("copilot")?.id, "github-copilot");
+    assert.equal(resolveUsageProvider("gemini")?.id, "google");
+    assert.equal(resolveUsageProvider("opencode")?.id, "opencode-go");
+});
+test("selects model-specific windows by normalized model id", () => {
+    const result = {
+        providerId: "google",
+        providerName: "Google",
+        ok: true,
+        configured: true,
+        fetchedAt: 1,
+        usage: {
+            windows: {},
+            models: {
+                "gemini/gemini-2.5-flash": {
+                    windows: {
+                        daily: { usedPercent: 25, remainingPercent: 75, windowSeconds: 86400, resetAt: null },
+                    },
+                },
+            },
+        },
+    };
+    assert.equal(selectModelWindows(result, "models/gemini-2.5-flash").daily?.usedPercent, 25);
+});
+test("returns a stable unsupported response without making a provider request", async () => {
+    const response = await getProviderUsage("unknown-provider", { modelId: "model" });
+    assert.equal(response.supported, false);
+    assert.equal(response.configured, false);
+    assert.equal(response.providerId, null);
+    assert.deepEqual(response.windows, {});
+});