open-multi-agent-kit 0.94.0 → 0.95.0

package/dist/core/provider-usage.js

@@ -0,0 +1,780 @@
+import { createHash } from "node:crypto";
+const FIVE_HOUR_SECONDS = 5 * 60 * 60;
+const SEVEN_DAY_SECONDS = 7 * 24 * 60 * 60;
+const WINDOW_TOLERANCE_SECONDS = 120;
+const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+const CLAUDE_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
+const CLAUDE_MESSAGES_URL = "https://api.anthropic.com/v1/messages";
+const KIMI_USAGE_URL = "https://api.kimi.com/coding/v1/usages";
+const OPENAI_AUTH_CLAIM = "https://api.openai.com/auth";
+const MAX_USAGE_RESPONSE_BYTES = 1024 * 1024;
+const MAX_USAGE_LIMITS = 64;
+const MAX_PASSIVE_ACCOUNTS = 64;
+const PASSIVE_USAGE_TTL_MS = 6 * 60 * 60 * 1000;
+const CLAUDE_QUOTA_PROBE_COOLDOWN_MS = 60 * 60 * 1000;
+const CLAUDE_QUOTA_PROBE_TIMEOUT_MS = 10_000;
+const passiveCodexUsage = new Map();
+const passiveClaudeUsage = new Map();
+const claudeQuotaProbeAttempts = new Map();
+const claudeQuotaProbesInFlight = new Map();
+const subscriptionUsageRevisions = new Map();
+const MINUTE_TTL_MS = 60_000;
+const VISIBLE_USAGE_PROVIDERS = [
+    "openai-codex",
+    "anthropic",
+    "kimi-coding",
+    "zai",
+    "modelstudio-maas",
+    "qwen-oauth",
+    "grok-oauth-proxy",
+];
+const SOURCES = {
+    "openai-codex": source("CODEX", "codex", [{ provider: "openai-codex", oauthOnly: true }]),
+    anthropic: source("CLAUDE", "claude", [{ provider: "anthropic", oauthOnly: true }], 5 * MINUTE_TTL_MS),
+    "qwen-oauth": source("QWEN", "unavailable", [{ provider: "qwen-oauth", oauthOnly: true }]),
+    "modelstudio-maas": source("QWEN TOKEN PLAN", "unavailable", [{ provider: "modelstudio-maas", oauthOnly: false }], MINUTE_TTL_MS, "console-only quota"),
+    "kimi-code": source("KIMI", "kimi", [
+        { provider: "kimi-code", oauthOnly: true },
+        { provider: "kimi-coding", oauthOnly: false },
+    ]),
+    "kimi-coding": source("KIMI", "kimi", [
+        { provider: "kimi-code", oauthOnly: true },
+        { provider: "kimi-coding", oauthOnly: false },
+    ]),
+    "zhipu-coding-plan": source("GLM", "zai", [{ provider: "zhipu-coding-plan", oauthOnly: true }]),
+    zai: source("GLM", "zai", [
+        { provider: "zai", oauthOnly: false },
+        { provider: "zai-coding-cn", oauthOnly: false },
+        { provider: "zhipu-coding-plan", oauthOnly: true },
+    ]),
+    "zai-coding-cn": source("GLM", "zai", [
+        { provider: "zai-coding-cn", oauthOnly: false },
+        { provider: "zhipu-coding-plan", oauthOnly: true },
+    ]),
+    "grok-oauth-proxy": source("GROK", "unavailable", [
+        { provider: "grok-oauth-proxy", oauthOnly: true },
+        { provider: "xai", oauthOnly: true },
+    ]),
+    xai: source("GROK", "unavailable", [{ provider: "xai", oauthOnly: true }]),
+};
+function source(label, kind, credentials, ttlMs = MINUTE_TTL_MS, unavailableMessage) {
+    return { label, kind, credentials, ttlMs, unavailableMessage };
+}
+export function getSubscriptionUsageSource(provider) {
+    if (!provider)
+        return undefined;
+    const configured = SOURCES[provider];
+    if (configured)
+        return configured;
+    if (/^openai-codex-\d+$/.test(provider)) {
+        return source("CODEX", "codex", [
+            { provider, oauthOnly: true },
+            { provider: "openai-codex", oauthOnly: true },
+        ]);
+    }
+    return undefined;
+}
+function usageRevisionKey(provider) {
+    const kind = getSubscriptionUsageSource(provider)?.kind;
+    if (kind === "codex")
+        return "codex";
+    if (kind === "claude")
+        return "claude";
+    return provider;
+}
+export function getSubscriptionUsageRevision(provider) {
+    return subscriptionUsageRevisions.get(usageRevisionKey(provider)) ?? 0;
+}
+function bumpSubscriptionUsageRevision(provider) {
+    const key = usageRevisionKey(provider);
+    subscriptionUsageRevisions.set(key, (subscriptionUsageRevisions.get(key) ?? 0) + 1);
+}
+export function supportsSubscriptionUsage(session, provider = session.state.model?.provider) {
+    const usageSource = getSubscriptionUsageSource(provider);
+    return usageSource?.credentials.some((candidate) => credentialConfigured(session, candidate)) ?? false;
+}
+/** Configured quota groups shown in the rail, with the active group first. */
+export function getConfiguredSubscriptionUsageProviders(session) {
+    const activeProvider = session.state.model?.provider;
+    const activeSource = getSubscriptionUsageSource(activeProvider);
+    const providers = VISIBLE_USAGE_PROVIDERS.filter((provider) => supportsSubscriptionUsage(session, provider));
+    if (!activeProvider || !activeSource || !supportsSubscriptionUsage(session, activeProvider))
+        return providers;
+    const activeCanonical = providers.find((provider) => getSubscriptionUsageSource(provider)?.label === activeSource.label);
+    if (!activeCanonical)
+        return [activeProvider, ...providers];
+    return [activeCanonical, ...providers.filter((provider) => provider !== activeCanonical)];
+}
+export async function loadSubscriptionUsage(session, fetchImpl = fetch, provider = session.state.model?.provider) {
+    const model = session.state.model;
+    const usageSource = getSubscriptionUsageSource(provider);
+    if (!model || !usageSource || !supportsSubscriptionUsage(session, provider))
+        return undefined;
+    if (usageSource.kind === "unavailable") {
+        return {
+            label: usageSource.label,
+            windows: [],
+            message: usageSource.unavailableMessage ?? "quota API unavailable",
+        };
+    }
+    if (offline())
+        return { label: usageSource.label, windows: [], message: "offline" };
+    const credential = await resolveCredential(session, usageSource);
+    if (!credential)
+        return { label: usageSource.label, windows: [], message: "usage unavailable" };
+    try {
+        switch (usageSource.kind) {
+            case "codex":
+                return await fetchCodexUsage(usageSource.label, credential.apiKey, fetchImpl);
+            case "claude":
+                return await fetchClaudeUsage(usageSource.label, credential.apiKey, fetchImpl);
+            case "kimi":
+                return await fetchKimiUsage(usageSource.label, credential.apiKey, fetchImpl);
+            case "zai":
+                return await fetchZaiUsage(usageSource.label, provider ?? model.provider, credential, fetchImpl);
+        }
+    }
+    catch {
+        return { label: usageSource.label, windows: [], message: "usage unavailable" };
+    }
+}
+export function parseCodexUsageSnapshot(value, nowSeconds = Date.now() / 1000) {
+    const rateLimit = record(record(value)?.rate_limit);
+    const primary = codexWindow(rateLimit?.primary_window, nowSeconds);
+    const secondary = codexWindow(rateLimit?.secondary_window, nowSeconds);
+    const windows = [primary, secondary].filter((window) => window !== undefined);
+    const fiveHour = windows.find((window) => near(window.windowSeconds, FIVE_HOUR_SECONDS));
+    const sevenDay = windows.find((window) => near(window.windowSeconds, SEVEN_DAY_SECONDS));
+    const fallbackFiveHour = fiveHour ?? (primary?.windowSeconds === undefined ? primary : undefined);
+    const fallbackSevenDay = sevenDay ?? (secondary?.windowSeconds === undefined ? secondary : undefined);
+    if (!fallbackFiveHour && !fallbackSevenDay)
+        return undefined;
+    return {
+        ...(fallbackFiveHour ? { fiveHour: publicCodexWindow(fallbackFiveHour) } : {}),
+        ...(fallbackSevenDay ? { sevenDay: publicCodexWindow(fallbackSevenDay) } : {}),
+    };
+}
+export function parseClaudeUsageSnapshot(value) {
+    const payload = record(value);
+    if (!payload)
+        return undefined;
+    const entries = Array.isArray(payload.limits)
+        ? payload.limits.slice(0, MAX_USAGE_LIMITS).map(record).filter(isDefined)
+        : [];
+    const fiveHour = claudeWindow(payload.five_hour) ?? claudeWindow(entries.find((entry) => entry.kind === "session"));
+    const sevenDay = claudeWindow(payload.seven_day) ?? claudeWindow(entries.find((entry) => entry.kind === "weekly_all"));
+    const windows = [
+        fiveHour ? withLabel("5H", fiveHour) : undefined,
+        sevenDay ? withLabel("7D", sevenDay) : undefined,
+    ].filter(isDefined);
+    return windows.length > 0 ? windows : undefined;
+}
+export function parseKimiUsageSnapshot(value, nowSeconds = Date.now() / 1000) {
+    const payload = record(value);
+    if (!payload)
+        return undefined;
+    const windows = [];
+    const total = usageRatio(record(payload.usage), nowSeconds);
+    if (total)
+        windows.push(withLabel("TOTAL", total));
+    if (Array.isArray(payload.limits)) {
+        for (const rawLimit of payload.limits.slice(0, MAX_USAGE_LIMITS)) {
+            const limit = record(rawLimit);
+            if (!limit)
+                continue;
+            const detail = record(limit.detail) ?? limit;
+            const windowData = record(limit.window);
+            const parsed = usageRatio(detail, nowSeconds);
+            if (!parsed)
+                continue;
+            const resetsAt = parseReset(windowData, nowSeconds) ?? parsed.resetsAt;
+            windows.push({
+                label: durationLabel(windowData) ?? shortLabel(limit.name ?? limit.title ?? limit.scope, windows.length),
+                usedPercent: parsed.usedPercent,
+                ...(resetsAt === undefined ? {} : { resetsAt }),
+            });
+        }
+    }
+    return windows.length > 0 ? windows.slice(0, 4) : undefined;
+}
+export function parseZaiUsageSnapshot(value) {
+    const payload = record(value);
+    const limits = record(payload?.data)?.limits;
+    if (payload?.success !== true || !Array.isArray(limits))
+        return undefined;
+    const parsed = limits.slice(0, MAX_USAGE_LIMITS).map(zaiWindow).filter(isDefined);
+    const requestWindows = parsed.filter((window) => window.type === "TIME_LIMIT" && !window.featureOnly);
+    const selected = requestWindows.length > 0 ? requestWindows : parsed.filter((window) => window.type === "TOKENS_LIMIT");
+    selected.sort((left, right) => left.durationSeconds - right.durationSeconds);
+    const windows = selected
+        .slice(0, 4)
+        .map(({ type: _type, durationSeconds: _duration, featureOnly: _feature, ...window }) => window);
+    return windows.length > 0 ? windows : undefined;
+}
+export function recordCodexPassiveUsage(apiKey, snapshot, nowMs = Date.now()) {
+    const accountId = codexAccountId(apiKey);
+    const limitId = snapshot.limitId?.trim().toLowerCase().replace(/-/g, "_");
+    if (!accountId || !Number.isFinite(nowMs) || nowMs < 0 || (limitId && limitId !== "codex"))
+        return;
+    prunePassiveCodexUsage(nowMs);
+    const cacheKey = passiveCredentialCacheKey(accountId);
+    const primary = normalizePassiveCodexWindow(snapshot.primary, nowMs);
+    const secondary = normalizePassiveCodexWindow(snapshot.secondary, nowMs);
+    if (!primary && !secondary)
+        return;
+    const previous = passiveCodexUsage.get(cacheKey);
+    const next = {
+        primary: primary ? { window: primary, observedAt: nowMs } : freshObservedCodexWindow(previous?.primary, nowMs),
+        secondary: secondary
+            ? { window: secondary, observedAt: nowMs }
+            : freshObservedCodexWindow(previous?.secondary, nowMs),
+    };
+    passiveCodexUsage.delete(cacheKey);
+    passiveCodexUsage.set(cacheKey, next);
+    while (passiveCodexUsage.size > MAX_PASSIVE_ACCOUNTS) {
+        const oldestCacheKey = passiveCodexUsage.keys().next().value;
+        if (oldestCacheKey === undefined)
+            break;
+        passiveCodexUsage.delete(oldestCacheKey);
+    }
+    bumpSubscriptionUsageRevision("openai-codex");
+}
+export function recordClaudePassiveUsage(apiKey, snapshot, nowMs = Date.now()) {
+    const limitId = snapshot.limitId?.trim().toLowerCase().replace(/-/g, "_");
+    if (!apiKey ||
+        apiKey.length > 32_768 ||
+        !Number.isFinite(nowMs) ||
+        nowMs < 0 ||
+        (limitId && limitId !== "anthropic_unified")) {
+        return;
+    }
+    prunePassiveClaudeUsage(nowMs);
+    const cacheKey = passiveCredentialCacheKey(apiKey);
+    const primary = normalizePassiveCodexWindow(snapshot.primary, nowMs);
+    const secondary = normalizePassiveCodexWindow(snapshot.secondary, nowMs);
+    if (!primary && !secondary)
+        return;
+    const previous = passiveClaudeUsage.get(cacheKey);
+    const next = {
+        primary: primary ? { window: primary, observedAt: nowMs } : freshObservedCodexWindow(previous?.primary, nowMs),
+        secondary: secondary
+            ? { window: secondary, observedAt: nowMs }
+            : freshObservedCodexWindow(previous?.secondary, nowMs),
+    };
+    passiveClaudeUsage.delete(cacheKey);
+    passiveClaudeUsage.set(cacheKey, next);
+    while (passiveClaudeUsage.size > MAX_PASSIVE_ACCOUNTS) {
+        const oldestCacheKey = passiveClaudeUsage.keys().next().value;
+        if (oldestCacheKey === undefined)
+            break;
+        passiveClaudeUsage.delete(oldestCacheKey);
+    }
+    bumpSubscriptionUsageRevision("anthropic");
+}
+async function fetchCodexUsage(label, apiKey, fetchImpl) {
+    const accountId = codexAccountId(apiKey);
+    if (!accountId)
+        return { label, windows: [], message: "usage unavailable" };
+    const passive = passiveCodexSnapshot(apiKey);
+    let polled;
+    try {
+        const payload = await fetchJson(fetchImpl, CODEX_USAGE_URL, {
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                Accept: "application/json",
+                "chatgpt-account-id": accountId,
+                "User-Agent": "omk",
+            },
+        });
+        polled = parseCodexUsageSnapshot(payload);
+    }
+    catch (error) {
+        if (!passive)
+            throw error;
+    }
+    const merged = {
+        fiveHour: polled?.fiveHour ?? passive?.fiveHour,
+        sevenDay: polled?.sevenDay ?? passive?.sevenDay,
+    };
+    if (!merged.fiveHour && !merged.sevenDay)
+        return { label, windows: [], message: "usage unavailable" };
+    return {
+        label,
+        windows: [
+            merged.fiveHour ? withLabel("5H", merged.fiveHour) : undefined,
+            merged.sevenDay ? withLabel("7D", merged.sevenDay) : undefined,
+        ].filter(isDefined),
+    };
+}
+async function fetchClaudeUsage(label, apiKey, fetchImpl) {
+    let passive = passiveClaudeSnapshot(apiKey);
+    const response = await fetchJsonResult(fetchImpl, CLAUDE_USAGE_URL, {
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            Accept: "application/json",
+            "anthropic-beta": "claude-code-20250219,oauth-2025-04-20",
+            "User-Agent": "claude-cli/2.1.177 (external, cli)",
+        },
+    });
+    const windows = [...(parseClaudeUsageSnapshot(response.payload) ?? [])];
+    if (response.status === 429 && (!passive?.fiveHour || !passive?.sevenDay)) {
+        await probeClaudeQuota(apiKey, fetchImpl);
+        passive = passiveClaudeSnapshot(apiKey);
+    }
+    for (const passiveWindow of [
+        passive?.fiveHour ? withLabel("5H", passive.fiveHour) : undefined,
+        passive?.sevenDay ? withLabel("7D", passive.sevenDay) : undefined,
+    ].filter(isDefined)) {
+        if (!windows.some((window) => window.label === passiveWindow.label))
+            windows.push(passiveWindow);
+    }
+    return windows.length > 0
+        ? { label, windows }
+        : { label, windows: [], message: response.status === 429 ? "rate limited · retry later" : "usage unavailable" };
+}
+/**
+ * Claude Code 2.1.177 performs the same `quota`/`max_tokens: 1` request during startup.
+ * Keep it account-scoped and hourly so a pinned sidebar cannot turn the fallback into polling.
+ */
+async function probeClaudeQuota(apiKey, fetchImpl, nowMs = Date.now()) {
+    if (!apiKey || apiKey.length > 32_768 || !Number.isFinite(nowMs) || nowMs < 0)
+        return;
+    const cacheKey = passiveCredentialCacheKey(apiKey);
+    const activeProbe = claudeQuotaProbesInFlight.get(cacheKey);
+    if (activeProbe)
+        return activeProbe;
+    const lastAttempt = claudeQuotaProbeAttempts.get(cacheKey);
+    if (lastAttempt !== undefined && nowMs - lastAttempt < CLAUDE_QUOTA_PROBE_COOLDOWN_MS)
+        return;
+    if (claudeQuotaProbesInFlight.size >= MAX_PASSIVE_ACCOUNTS)
+        return;
+    claudeQuotaProbeAttempts.delete(cacheKey);
+    claudeQuotaProbeAttempts.set(cacheKey, nowMs);
+    while (claudeQuotaProbeAttempts.size > MAX_PASSIVE_ACCOUNTS) {
+        const oldestCacheKey = claudeQuotaProbeAttempts.keys().next().value;
+        if (oldestCacheKey === undefined)
+            break;
+        claudeQuotaProbeAttempts.delete(oldestCacheKey);
+    }
+    const probe = (async () => {
+        try {
+            const response = await fetchImpl(CLAUDE_MESSAGES_URL, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    Accept: "application/json",
+                    "Content-Type": "application/json",
+                    "anthropic-version": "2023-06-01",
+                    "anthropic-beta": "claude-code-20250219,oauth-2025-04-20",
+                    "anthropic-dangerous-direct-browser-access": "true",
+                    "User-Agent": "claude-cli/2.1.177 (external, cli)",
+                    "x-app": "cli",
+                },
+                body: JSON.stringify({
+                    model: "claude-haiku-4-5",
+                    max_tokens: 1,
+                    messages: [{ role: "user", content: "quota" }],
+                }),
+                signal: AbortSignal.timeout(CLAUDE_QUOTA_PROBE_TIMEOUT_MS),
+            });
+            const snapshot = parseClaudeQuotaProbeHeaders(response.headers, nowMs);
+            if (snapshot)
+                recordClaudePassiveUsage(apiKey, snapshot, nowMs);
+            try {
+                await response.body?.cancel();
+            }
+            catch {
+                // The quota snapshot lives entirely in response headers.
+            }
+        }
+        catch {
+            // This mirrors Claude Code's best-effort startup quota check.
+        }
+    })().finally(() => {
+        claudeQuotaProbesInFlight.delete(cacheKey);
+    });
+    claudeQuotaProbesInFlight.set(cacheKey, probe);
+    return probe;
+}
+function parseClaudeQuotaProbeHeaders(headers, nowMs) {
+    const parseWindow = (prefix, windowSeconds) => {
+        const rawUtilization = headers.get(`anthropic-ratelimit-unified-${prefix}-utilization`);
+        const rawReset = headers.get(`anthropic-ratelimit-unified-${prefix}-reset`);
+        if (rawUtilization === null || rawReset === null)
+            return undefined;
+        const utilization = Number(rawUtilization);
+        const resetsAt = Number(rawReset);
+        const maxResetAt = nowMs / 1000 + 10 * 365 * 24 * 60 * 60;
+        if (!Number.isFinite(utilization) ||
+            utilization < 0 ||
+            utilization > 1 ||
+            !Number.isSafeInteger(resetsAt) ||
+            resetsAt <= 0 ||
+            resetsAt > maxResetAt) {
+            return undefined;
+        }
+        return { usedPercent: Math.round(utilization * 10_000) / 100, windowSeconds, resetsAt };
+    };
+    const primary = parseWindow("5h", FIVE_HOUR_SECONDS);
+    const secondary = parseWindow("7d", SEVEN_DAY_SECONDS);
+    return primary || secondary ? { limitId: "anthropic-unified", primary, secondary } : undefined;
+}
+async function fetchKimiUsage(label, apiKey, fetchImpl) {
+    const payload = await fetchJson(fetchImpl, KIMI_USAGE_URL, {
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            Accept: "application/json",
+            "User-Agent": "KimiCLI/1.5",
+            "X-Msh-Platform": "kimi_cli",
+            "X-Msh-Version": "1.5",
+        },
+    });
+    const windows = parseKimiUsageSnapshot(payload);
+    return windows ? { label, windows } : { label, windows: [], message: "usage unavailable" };
+}
+async function fetchZaiUsage(label, modelProvider, credential, fetchImpl) {
+    const origin = modelProvider === "zai-coding-cn" ||
+        credential.provider === "zai-coding-cn" ||
+        credential.provider === "zhipu-coding-plan"
+        ? "https://open.bigmodel.cn"
+        : "https://api.z.ai";
+    const payload = await fetchJson(fetchImpl, `${origin}/api/monitor/usage/quota/limit`, {
+        headers: {
+            Authorization: credential.apiKey,
+            Accept: "application/json",
+            "User-Agent": "omk",
+        },
+    });
+    const windows = parseZaiUsageSnapshot(payload);
+    return windows ? { label, windows } : { label, windows: [], message: "usage unavailable" };
+}
+async function fetchJson(fetchImpl, url, init) {
+    return (await fetchJsonResult(fetchImpl, url, init)).payload;
+}
+async function fetchJsonResult(fetchImpl, url, init) {
+    const response = await fetchImpl(url, { ...init, signal: AbortSignal.timeout(10_000) });
+    if (!response.ok)
+        return { status: response.status };
+    const declaredBytes = Number(response.headers?.get("content-length"));
+    if (Number.isFinite(declaredBytes) && declaredBytes > MAX_USAGE_RESPONSE_BYTES) {
+        return { status: response.status };
+    }
+    if (!response.body || typeof response.body.getReader !== "function") {
+        return { status: response.status, payload: await response.json() };
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let totalBytes = 0;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        totalBytes += value.byteLength;
+        if (totalBytes > MAX_USAGE_RESPONSE_BYTES) {
+            await reader.cancel();
+            return { status: response.status };
+        }
+        chunks.push(value);
+    }
+    const body = new Uint8Array(totalBytes);
+    let offset = 0;
+    for (const chunk of chunks) {
+        body.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    try {
+        return { status: response.status, payload: JSON.parse(new TextDecoder().decode(body)) };
+    }
+    catch {
+        return { status: response.status };
+    }
+}
+function credentialConfigured(session, candidate) {
+    if (candidate.oauthOnly)
+        return session.modelRegistry.isUsingOAuthProvider(candidate.provider);
+    const status = session.modelRegistry.getProviderAuthStatus(candidate.provider);
+    return status.configured || status.source !== undefined;
+}
+async function resolveCredential(session, usageSource) {
+    for (const candidate of usageSource.credentials) {
+        if (!credentialConfigured(session, candidate))
+            continue;
+        const apiKey = await session.modelRegistry.getApiKeyForProvider(candidate.provider);
+        if (apiKey)
+            return { provider: candidate.provider, apiKey };
+    }
+    return undefined;
+}
+function codexWindow(value, nowSeconds) {
+    const window = record(value);
+    const usedPercent = finiteNumber(window?.used_percent);
+    if (usedPercent === undefined)
+        return undefined;
+    const windowSeconds = finiteNumber(window?.limit_window_seconds);
+    const resetAt = finiteNumber(window?.reset_at);
+    const resetAfter = finiteNumber(window?.reset_after_seconds);
+    const resetsAt = resetAt ?? (resetAfter === undefined ? undefined : nowSeconds + resetAfter);
+    return {
+        usedPercent: clampPercent(usedPercent),
+        ...(windowSeconds === undefined ? {} : { windowSeconds }),
+        ...(resetsAt === undefined ? {} : { resetsAt }),
+    };
+}
+function claudeWindow(value) {
+    const bucket = record(value);
+    if (!bucket || bucket.is_active === false)
+        return undefined;
+    const usedPercent = finiteNumber(bucket.utilization ?? bucket.percent);
+    if (usedPercent === undefined)
+        return undefined;
+    const resetsAt = epochSeconds(bucket.resets_at);
+    return { usedPercent: clampPercent(usedPercent), ...(resetsAt === undefined ? {} : { resetsAt }) };
+}
+function usageRatio(data, nowSeconds) {
+    if (!data)
+        return undefined;
+    const limit = finiteNumber(data.limit);
+    let used = finiteNumber(data.used);
+    const remaining = finiteNumber(data.remaining);
+    if (used === undefined && limit !== undefined && remaining !== undefined)
+        used = limit - remaining;
+    if (used === undefined || limit === undefined || limit <= 0)
+        return undefined;
+    const resetsAt = parseReset(data, nowSeconds);
+    return {
+        usedPercent: clampPercent((used / limit) * 100),
+        ...(resetsAt === undefined ? {} : { resetsAt }),
+    };
+}
+function zaiWindow(value) {
+    const item = record(value);
+    if (!item || (item.type !== "TIME_LIMIT" && item.type !== "TOKENS_LIMIT"))
+        return undefined;
+    const percentage = finiteNumber(item.percentage);
+    const current = finiteNumber(item.currentValue);
+    const limit = finiteNumber(item.usage);
+    const usedPercent = percentage ?? (current !== undefined && limit !== undefined && limit > 0 ? (current / limit) * 100 : undefined);
+    if (usedPercent === undefined)
+        return undefined;
+    const duration = zaiDuration(finiteNumber(item.unit), finiteNumber(item.number));
+    const resetsAt = epochSeconds(item.nextResetTime);
+    const detailCodes = Array.isArray(item.usageDetails)
+        ? item.usageDetails
+            .map((detail) => record(detail)?.modelCode)
+            .filter((code) => typeof code === "string")
+        : [];
+    return {
+        type: item.type,
+        label: duration.label,
+        durationSeconds: duration.seconds,
+        featureOnly: ["search-prime", "web-reader", "zread"].every((code) => detailCodes.includes(code)),
+        usedPercent: clampPercent(usedPercent),
+        ...(resetsAt === undefined ? {} : { resetsAt }),
+    };
+}
+function zaiDuration(unit, countValue) {
+    const count = countValue && countValue > 0 ? countValue : 1;
+    if (unit === 3)
+        return { label: `${count}H`, seconds: count * 60 * 60 };
+    if (unit === 4)
+        return { label: `${count}D`, seconds: count * 24 * 60 * 60 };
+    if (unit === 5)
+        return { label: count === 1 ? "30D" : `${count}MO`, seconds: count * 30 * 24 * 60 * 60 };
+    if (unit === 6)
+        return { label: "7D", seconds: 7 * 24 * 60 * 60 };
+    return { label: "QUOTA", seconds: Number.POSITIVE_INFINITY };
+}
+function durationLabel(window) {
+    if (!window)
+        return undefined;
+    const duration = finiteNumber(window.duration);
+    const unit = typeof window.timeUnit === "string" ? window.timeUnit.toUpperCase() : "";
+    if (duration === undefined)
+        return undefined;
+    if (unit.includes("MINUTE"))
+        return duration % 60 === 0 ? `${duration / 60}H` : `${duration}M`;
+    if (unit.includes("HOUR"))
+        return `${duration}H`;
+    if (unit.includes("DAY"))
+        return `${duration}D`;
+    if (unit.includes("SECOND"))
+        return `${duration}S`;
+    return undefined;
+}
+function parseReset(data, nowSeconds) {
+    if (!data)
+        return undefined;
+    for (const key of ["reset_at", "resetAt", "reset_time", "resetTime"]) {
+        const parsed = epochSeconds(data[key]);
+        if (parsed !== undefined)
+            return parsed;
+    }
+    for (const key of ["reset_in", "resetIn", "ttl"]) {
+        const seconds = finiteNumber(data[key]);
+        if (seconds !== undefined)
+            return nowSeconds + seconds;
+    }
+    return undefined;
+}
+function epochSeconds(value) {
+    const numeric = finiteNumber(value);
+    if (numeric !== undefined)
+        return numeric > 1_000_000_000_000 ? numeric / 1000 : numeric;
+    if (typeof value !== "string" || !value.trim())
+        return undefined;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed / 1000 : undefined;
+}
+function normalizePassiveCodexWindow(window, nowMs) {
+    if (!window || !Number.isFinite(window.usedPercent))
+        return undefined;
+    const windowSeconds = window.windowSeconds !== undefined &&
+        Number.isFinite(window.windowSeconds) &&
+        window.windowSeconds > 0 &&
+        window.windowSeconds <= Number.MAX_SAFE_INTEGER
+        ? Math.round(window.windowSeconds)
+        : undefined;
+    const maxResetAt = nowMs / 1000 + 10 * 365 * 24 * 60 * 60;
+    const resetsAtValue = window.resetsAt === undefined ? undefined : Math.floor(window.resetsAt);
+    const resetsAt = resetsAtValue !== undefined &&
+        Number.isSafeInteger(resetsAtValue) &&
+        resetsAtValue > 0 &&
+        resetsAtValue <= maxResetAt
+        ? resetsAtValue
+        : undefined;
+    return {
+        usedPercent: clampPercent(window.usedPercent),
+        ...(windowSeconds === undefined ? {} : { windowSeconds }),
+        ...(resetsAt === undefined ? {} : { resetsAt }),
+    };
+}
+function passiveCredentialCacheKey(identifier) {
+    return createHash("sha256").update(identifier).digest("base64url");
+}
+function freshObservedCodexWindow(observed, nowMs) {
+    if (!observed || nowMs - observed.observedAt > PASSIVE_USAGE_TTL_MS)
+        return undefined;
+    if (observed.window.resetsAt !== undefined && observed.window.resetsAt <= nowMs / 1000)
+        return undefined;
+    return observed;
+}
+function prunePassiveCodexUsage(nowMs) {
+    for (const [cacheKey, entry] of passiveCodexUsage) {
+        if (!freshObservedCodexWindow(entry.primary, nowMs) && !freshObservedCodexWindow(entry.secondary, nowMs)) {
+            passiveCodexUsage.delete(cacheKey);
+        }
+    }
+}
+function prunePassiveClaudeUsage(nowMs) {
+    for (const [cacheKey, entry] of passiveClaudeUsage) {
+        if (!freshObservedCodexWindow(entry.primary, nowMs) && !freshObservedCodexWindow(entry.secondary, nowMs)) {
+            passiveClaudeUsage.delete(cacheKey);
+        }
+    }
+}
+function passiveCodexSnapshot(apiKey, nowMs = Date.now()) {
+    const accountId = codexAccountId(apiKey);
+    if (!accountId || !Number.isFinite(nowMs) || nowMs < 0)
+        return undefined;
+    prunePassiveCodexUsage(nowMs);
+    const cacheKey = passiveCredentialCacheKey(accountId);
+    const entry = passiveCodexUsage.get(cacheKey);
+    if (!entry)
+        return undefined;
+    const primary = freshObservedCodexWindow(entry.primary, nowMs);
+    const secondary = freshObservedCodexWindow(entry.secondary, nowMs);
+    if (!primary && !secondary) {
+        passiveCodexUsage.delete(cacheKey);
+        return undefined;
+    }
+    const freshEntry = { primary, secondary };
+    passiveCodexUsage.delete(cacheKey);
+    passiveCodexUsage.set(cacheKey, freshEntry);
+    const windows = [primary?.window, secondary?.window].filter(isDefined);
+    const fiveHour = windows.find((window) => near(window.windowSeconds, FIVE_HOUR_SECONDS));
+    const sevenDay = windows.find((window) => near(window.windowSeconds, SEVEN_DAY_SECONDS));
+    if (!fiveHour && !sevenDay)
+        return undefined;
+    return {
+        ...(fiveHour ? { fiveHour: publicCodexWindow(fiveHour) } : {}),
+        ...(sevenDay ? { sevenDay: publicCodexWindow(sevenDay) } : {}),
+    };
+}
+function passiveClaudeSnapshot(apiKey, nowMs = Date.now()) {
+    if (!apiKey || apiKey.length > 32_768 || !Number.isFinite(nowMs) || nowMs < 0)
+        return undefined;
+    prunePassiveClaudeUsage(nowMs);
+    const cacheKey = passiveCredentialCacheKey(apiKey);
+    const entry = passiveClaudeUsage.get(cacheKey);
+    if (!entry)
+        return undefined;
+    const primary = freshObservedCodexWindow(entry.primary, nowMs);
+    const secondary = freshObservedCodexWindow(entry.secondary, nowMs);
+    if (!primary && !secondary) {
+        passiveClaudeUsage.delete(cacheKey);
+        return undefined;
+    }
+    passiveClaudeUsage.delete(cacheKey);
+    passiveClaudeUsage.set(cacheKey, { primary, secondary });
+    const windows = [primary?.window, secondary?.window].filter(isDefined);
+    const fiveHour = windows.find((window) => near(window.windowSeconds, FIVE_HOUR_SECONDS));
+    const sevenDay = windows.find((window) => near(window.windowSeconds, SEVEN_DAY_SECONDS));
+    if (!fiveHour && !sevenDay)
+        return undefined;
+    return {
+        ...(fiveHour ? { fiveHour: publicCodexWindow(fiveHour) } : {}),
+        ...(sevenDay ? { sevenDay: publicCodexWindow(sevenDay) } : {}),
+    };
+}
+function codexAccountId(token) {
+    try {
+        const payload = token.split(".")[1];
+        if (!payload)
+            return undefined;
+        const claims = record(JSON.parse(Buffer.from(payload, "base64url").toString("utf8")));
+        const auth = record(claims?.[OPENAI_AUTH_CLAIM]);
+        const accountId = typeof auth?.chatgpt_account_id === "string" ? auth.chatgpt_account_id.trim() : "";
+        return accountId && accountId.length <= 256 ? accountId : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function publicCodexWindow(window) {
+    return { usedPercent: window.usedPercent, ...(window.resetsAt === undefined ? {} : { resetsAt: window.resetsAt }) };
+}
+function withLabel(label, window) {
+    return { label, ...window };
+}
+function shortLabel(value, index) {
+    if (typeof value !== "string")
+        return `LIMIT${index + 1}`;
+    const safe = value
+        .replace(/[\u0000-\u001f\u007f-\u009f\u200b-\u200f\u202a-\u202e\u2060-\u206f]/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+    return safe ? safe.toUpperCase().slice(0, 8) : `LIMIT${index + 1}`;
+}
+function finiteNumber(value) {
+    const number = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : Number.NaN;
+    return Number.isFinite(number) ? number : undefined;
+}
+function clampPercent(value) {
+    return Number(Math.max(0, Math.min(100, value)).toFixed(2));
+}
+function near(actual, expected) {
+    return actual !== undefined && Math.abs(actual - expected) <= WINDOW_TOLERANCE_SECONDS;
+}
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function isDefined(value) {
+    return value !== undefined;
+}
+function offline() {
+    const value = process.env.OMK_OFFLINE?.toLowerCase();
+    return value === "1" || value === "true" || value === "yes";
+}
+//# sourceMappingURL=provider-usage.js.map