sidekick-shared 0.27.6 → 0.28.0

package/dist/esm/zaiQuota.js

@@ -0,0 +1,323 @@
+// ── Tier budgets ──
+/**
+ * Published z.ai coding-plan prompt budgets.
+ *
+ * Source: https://docs.z.ai/devpack/overview & /devpack/faq.
+ * "One prompt ≈ one query; each prompt is estimated to invoke the model
+ * 15–20 times." We use the midpoint (17.5) when converting observed
+ * assistant turns into prompt equivalents.
+ *
+ * @deprecated Use `resolveZaiQuota()` from `zaiQuotaApi`, which reads z.ai's
+ * authoritative quota endpoint. This observed-traffic estimator is retained
+ * for backward compatibility only and drifts from actual billing.
+ */
+export const ZAI_TIER_BUDGETS = {
+    lite: { fiveHour: 80, weekly: 400 },
+    pro: { fiveHour: 400, weekly: 2000 },
+    max: { fiveHour: 1600, weekly: 8000 },
+};
+/**
+ * Midpoint of z.ai's documented "15–20 model invocations per prompt" range.
+ * Used to convert accumulated assistant turns into prompt equivalents.
+ * Calibration note: this constant may need per-tier adjustment after
+ * real-world validation against the z.ai web UI.
+ *
+ * @deprecated Use `resolveZaiQuota()` from `zaiQuotaApi`, which reads z.ai's
+ * authoritative quota endpoint. This observed-traffic estimator is retained
+ * for backward compatibility only and drifts from actual billing.
+ */
+export const ZAI_PROMPT_INVOCATIONS = 17.5;
+const FIVE_HOUR_MS = 5 * 3_600_000;
+const SEVEN_DAY_MS = 7 * 86_400_000;
+/**
+ * Provider IDs that OpenCode tags on z.ai-routed messages.
+ * `zai-coding-plan` is the Coding Plan key; `zai` is the bare API key.
+ *
+ * @deprecated Use `resolveZaiQuota()` from `zaiQuotaApi`, which reads z.ai's
+ * authoritative quota endpoint. This observed-traffic estimator is retained
+ * for backward compatibility only and drifts from actual billing.
+ */
+export const ZAI_PROVIDER_IDS = ['zai', 'zai-coding-plan'];
+/**
+ * @deprecated Use `resolveZaiQuota()` from `zaiQuotaApi`, which reads z.ai's
+ * authoritative quota endpoint. This observed-traffic estimator is retained
+ * for backward compatibility only and drifts from actual billing.
+ */
+export function isZaiProviderId(value) {
+    return value === 'zai' || value === 'zai-coding-plan';
+}
+/**
+ * Sums the token fields of a single turn into a scalar.
+ * Cache reads are weighted at 0.1× (Anthropic convention) to avoid
+ * over-counting repeated context. Output and reasoning tokens are weighted 1×.
+ *
+ * @deprecated Use `resolveZaiQuota()` from `zaiQuotaApi`, which reads z.ai's
+ * authoritative quota endpoint. This observed-traffic estimator is retained
+ * for backward compatibility only and drifts from actual billing.
+ */
+export function turnTokenWeight(turn) {
+    return (turn.inputTokens +
+        turn.outputTokens +
+        Math.round(turn.cacheReadTokens * 0.1) +
+        turn.cacheWriteTokens +
+        (turn.reasoningTokens || 0));
+}
+/**
+ * Reduces a stream of z.ai-routed assistant turns into rolling-window usage.
+ *
+ * Pure & stateless: the caller is responsible for passing the relevant turns.
+ * Turns outside the 7-day window are ignored; turns inside the 7-day window
+ * but outside the 5-hour window still count toward weekly usage.
+ *
+ * @deprecated Use `resolveZaiQuota()` from `zaiQuotaApi`, which reads z.ai's
+ * authoritative quota endpoint. This observed-traffic estimator is retained
+ * for backward compatibility only and drifts from actual billing.
+ */
+export function accumulateZaiUsage(turns, nowMs = Date.now()) {
+    const fiveHourCutoff = nowMs - FIVE_HOUR_MS;
+    const weeklyCutoff = nowMs - SEVEN_DAY_MS;
+    let fiveHourTurns = 0;
+    let weeklyTurns = 0;
+    let fiveHourTokens = 0;
+    let weeklyTokens = 0;
+    let fiveHourStartedAtMs = null;
+    let weeklyStartedAtMs = null;
+    for (const turn of turns) {
+        if (turn.timestampMs < weeklyCutoff)
+            continue;
+        weeklyTurns += 1;
+        weeklyTokens += turnTokenWeight(turn);
+        if (weeklyStartedAtMs === null || turn.timestampMs < weeklyStartedAtMs) {
+            weeklyStartedAtMs = turn.timestampMs;
+        }
+        if (turn.timestampMs >= fiveHourCutoff) {
+            fiveHourTurns += 1;
+            fiveHourTokens += turnTokenWeight(turn);
+            if (fiveHourStartedAtMs === null || turn.timestampMs < fiveHourStartedAtMs) {
+                fiveHourStartedAtMs = turn.timestampMs;
+            }
+        }
+    }
+    return {
+        fiveHourTurns,
+        weeklyTurns,
+        fiveHourTokens,
+        weeklyTokens,
+        fiveHourPrompts: fiveHourTurns / ZAI_PROMPT_INVOCATIONS,
+        weeklyPrompts: weeklyTurns / ZAI_PROMPT_INVOCATIONS,
+        fiveHourStartedAtMs,
+        weeklyStartedAtMs,
+    };
+}
+// ── Tier resolution ──
+/**
+ * Resolves the effective z.ai tier when the user has selected `'auto'`.
+ *
+ * Heuristic: if accumulated weekly prompts already exceed a tier's budget,
+ * the user must be on a higher tier. This under-detects at the start of a
+ * weekly cycle (a Max user looks identical to a Lite user until they cross
+ * 400 prompts/week), so callers should still expose an explicit override.
+ *
+ * @deprecated Use `resolveZaiQuota()` from `zaiQuotaApi`, which reads z.ai's
+ * authoritative quota endpoint. This observed-traffic estimator is retained
+ * for backward compatibility only and drifts from actual billing.
+ */
+export function resolveZaiTier(configured, accumulated) {
+    if (configured !== 'auto')
+        return configured;
+    if (accumulated.weeklyPrompts > ZAI_TIER_BUDGETS.pro.weekly)
+        return 'max';
+    if (accumulated.weeklyPrompts > ZAI_TIER_BUDGETS.lite.weekly)
+        return 'pro';
+    return 'lite';
+}
+/**
+ * Converts accumulated usage into a shared `QuotaState`.
+ *
+ * The two windows reuse the `fiveHour` / `sevenDay` field names for cross-
+ * provider compatibility, but are labeled "5-Hour" and "Weekly" via
+ * `fiveHourLabel` / `sevenDayLabel` — mirroring how Codex relabels its
+ * generic primary/secondary windows.
+ *
+ * Reset timestamps are best-effort because z.ai does not expose them:
+ *   - `fiveHour.resetsAt` ← first turn in window + 5h, unless an error
+ *     event supplied an authoritative reset.
+ *   - `sevenDay.resetsAt` ← first turn in window + 7d (documented as
+ *     "7 days from order time" — order time is unknown, so this is a
+ *     lower bound at best).
+ *
+ * @deprecated Use `resolveZaiQuota()` from `zaiQuotaApi`, which reads z.ai's
+ * authoritative quota endpoint. This observed-traffic estimator is retained
+ * for backward compatibility only and drifts from actual billing.
+ */
+export function inferZaiQuotaState(accumulated, tier, options = {}) {
+    const budget = ZAI_TIER_BUDGETS[tier];
+    const capturedAt = options.capturedAt ?? new Date().toISOString();
+    const fiveHourUtil = budget.fiveHour > 0 ? Math.min((accumulated.fiveHourPrompts / budget.fiveHour) * 100, 200) : 0;
+    const weeklyUtil = budget.weekly > 0 ? Math.min((accumulated.weeklyPrompts / budget.weekly) * 100, 200) : 0;
+    const fiveHourResetsAt = options.authoritativeFiveHourResetAt ??
+        (accumulated.fiveHourStartedAtMs !== null
+            ? new Date(accumulated.fiveHourStartedAtMs + FIVE_HOUR_MS).toISOString()
+            : '');
+    const sevenDayResetsAt = options.authoritativeWeeklyResetAt ??
+        (accumulated.weeklyStartedAtMs !== null
+            ? new Date(accumulated.weeklyStartedAtMs + SEVEN_DAY_MS).toISOString()
+            : '');
+    const fiveHour = {
+        utilization: Math.round(fiveHourUtil * 10) / 10,
+        resetsAt: fiveHourResetsAt,
+    };
+    const sevenDay = {
+        utilization: Math.round(weeklyUtil * 10) / 10,
+        resetsAt: sevenDayResetsAt,
+    };
+    const hasAnyData = accumulated.fiveHourTurns > 0 || accumulated.weeklyTurns > 0;
+    return {
+        fiveHour,
+        sevenDay,
+        available: hasAnyData,
+        providerId: 'zai',
+        source: 'session',
+        capturedAt,
+        stale: options.stale ?? !hasAnyData,
+        fiveHourLabel: '5-Hour',
+        sevenDayLabel: 'Weekly',
+        planType: tier,
+        limitId: `zai-${tier}`,
+        limitName: `z.ai ${tier.charAt(0).toUpperCase() + tier.slice(1)}`,
+    };
+}
+/**
+ * z.ai business error codes that signal quota/plan state.
+ * Source: https://docs.z.ai/api-reference/api-code
+ */
+const ZAI_ERROR_CODES = {
+    '1308': 'exhausted', // Usage limit reached for `{number} {unit}` (includes next_flush_time)
+    '1310': 'exhausted', // Weekly/Monthly limit exhausted (resets at next_flush_time)
+    '1313': 'fup', // Fair-Use-Policy violation — request rate restricted
+    '1309': 'expired', // GLM Coding Plan package has expired
+};
+/**
+ * Extracts a z.ai quota error from a message-error payload, if present.
+ *
+ * The reset timestamp is embedded inside the human-readable `message` text
+ * as `${next_flush_time}`. z.ai's docs interpolate the value into the
+ * message string; we parse ISO datetimes, epoch seconds, and the literal
+ * `YYYY-MM-DD HH:mm:ss` form defensively.
+ *
+ * Returns `null` when the code is not a quota-related business error.
+ *
+ * @deprecated Use `resolveZaiQuota()` from `zaiQuotaApi`, which reads z.ai's
+ * authoritative quota endpoint. This observed-traffic estimator is retained
+ * for backward compatibility only and drifts from actual billing.
+ */
+export function parseZaiQuotaError(error) {
+    if (!error)
+        return null;
+    const code = String(error.code ?? '');
+    const kind = ZAI_ERROR_CODES[code];
+    if (!kind)
+        return null;
+    const message = error.message ?? '';
+    const resetsAt = extractNextFlushTime(message);
+    return { kind, resetsAt, code, message };
+}
+/**
+ * Parses `${next_flush_time}` out of a z.ai error message.
+ *
+ * Handles ISO 8601 (`2025-01-31T14:00:00Z`), space-separated
+ * (`2025-01-31 14:00:00`), and epoch-seconds (1234567890) forms.
+ * Returns undefined when no parseable timestamp is found.
+ *
+ * @deprecated Use `resolveZaiQuota()` from `zaiQuotaApi`, which reads z.ai's
+ * authoritative quota endpoint. This observed-traffic estimator is retained
+ * for backward compatibility only and drifts from actual billing.
+ */
+export function extractNextFlushTime(message) {
+    if (!message)
+        return undefined;
+    // ISO 8601 with optional timezone.
+    const isoMatch = message.match(/(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)/);
+    if (isoMatch) {
+        const ms = Date.parse(isoMatch[1]);
+        if (Number.isFinite(ms))
+            return new Date(ms).toISOString();
+    }
+    // `YYYY-MM-DD HH:mm:ss` (no T separator) — z.ai's likely interpolated form.
+    const spaceMatch = message.match(/(\d{4}-\d{2}-\d{2}[ ]\d{2}:\d{2}:\d{2})/);
+    if (spaceMatch) {
+        const normalised = spaceMatch[1].replace(' ', 'T');
+        const ms = Date.parse(`${normalised}Z`);
+        if (Number.isFinite(ms))
+            return new Date(ms).toISOString();
+    }
+    // Epoch seconds — 10-digit integer in a plausible range.
+    const epochMatch = message.match(/(?<!\d)(\d{10})(?!\d)/);
+    if (epochMatch) {
+        const seconds = Number(epochMatch[1]);
+        if (seconds > 1_700_000_000 && seconds < 2_000_000_000) {
+            return new Date(seconds * 1000).toISOString();
+        }
+    }
+    return undefined;
+}
+// ── Unavailable state helper ──
+/**
+ * Builds an unavailable z.ai `QuotaState` for the cold-start case where
+ * no z.ai traffic has been observed yet.
+ *
+ * @deprecated Use `resolveZaiQuota()` from `zaiQuotaApi`, which reads z.ai's
+ * authoritative quota endpoint. This observed-traffic estimator is retained
+ * for backward compatibility only and drifts from actual billing.
+ */
+export function makeUnavailableZaiQuotaState(error = 'No z.ai usage observed yet', tier = 'lite', capturedAt = new Date().toISOString()) {
+    return {
+        fiveHour: { utilization: 0, resetsAt: '' },
+        sevenDay: { utilization: 0, resetsAt: '' },
+        available: false,
+        error,
+        providerId: 'zai',
+        source: 'session',
+        capturedAt,
+        stale: true,
+        fiveHourLabel: '5-Hour',
+        sevenDayLabel: 'Weekly',
+        planType: tier,
+    };
+}
+/**
+ * Converts raw OpenCode DB rows (filtered to z.ai providerIDs by the caller)
+ * into the watcher's `ZaiAssistantTurn` shape, and surfaces any trapped
+ * business errors.
+ *
+ * Returns `{ turns, errors }` so callers can replay them through
+ * `ZaiQuotaWatcher.ingestAssistantTurns` and `ingestError`.
+ *
+ * @deprecated Use `resolveZaiQuota()` from `zaiQuotaApi`, which reads z.ai's
+ * authoritative quota endpoint. This observed-traffic estimator is retained
+ * for backward compatibility only and drifts from actual billing.
+ */
+export function rowsToZaiTurnsAndErrors(rows) {
+    const turns = [];
+    const errors = [];
+    for (const row of rows) {
+        turns.push({
+            timestampMs: row.timeCreated,
+            model: row.modelId,
+            inputTokens: row.inputTokens || 0,
+            outputTokens: row.outputTokens || 0,
+            cacheReadTokens: row.cacheReadTokens || 0,
+            cacheWriteTokens: row.cacheWriteTokens || 0,
+            reasoningTokens: row.reasoningTokens || 0,
+        });
+        if (row.errorCode != null || row.errorMessage) {
+            const parsed = parseZaiQuotaError({
+                code: row.errorCode ?? undefined,
+                message: row.errorMessage ?? undefined,
+            });
+            if (parsed)
+                errors.push(parsed);
+        }
+    }
+    return { turns, errors };
+}

package/dist/esm/zaiQuotaApi.js

@@ -0,0 +1,271 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { readQuotaSnapshot, writeQuotaSnapshot } from './quotaSnapshots';
+import { FIVE_HOUR_WINDOW_MS, SEVEN_DAY_WINDOW_MS, withQuotaProjections } from './quota';
+const DEFAULT_ZAI_BASE_URL = 'https://api.z.ai/api/anthropic';
+const QUOTA_PATH = '/api/monitor/usage/quota/limit';
+const DEFAULT_ACCOUNT_ID = 'default';
+const DEFAULT_TIMEOUT_MS = 10_000;
+function unavailableZaiQuotaState(error, meta = {}, capturedAt = new Date().toISOString()) {
+    return {
+        fiveHour: { utilization: 0, resetsAt: '' },
+        sevenDay: { utilization: 0, resetsAt: '' },
+        available: false,
+        error,
+        providerId: 'zai',
+        source: 'api',
+        capturedAt,
+        fiveHourLabel: '5-Hour',
+        sevenDayLabel: 'Weekly',
+        ...meta,
+    };
+}
+function openCodeDataDirCandidates() {
+    const candidates = [];
+    const xdg = process.env.XDG_DATA_HOME;
+    if (xdg)
+        candidates.push(path.join(xdg, 'opencode'));
+    candidates.push(path.join(os.homedir(), '.local', 'share', 'opencode'));
+    if (process.platform === 'darwin') {
+        candidates.push(path.join(os.homedir(), 'Library', 'Application Support', 'opencode'));
+    }
+    else if (process.platform === 'win32') {
+        candidates.push(path.join(process.env.LOCALAPPDATA ||
+            process.env.APPDATA ||
+            path.join(os.homedir(), 'AppData', 'Local'), 'opencode'));
+    }
+    return Array.from(new Set(candidates));
+}
+function readOpenCodeAuthToken(openCodeDataDir) {
+    const candidates = openCodeDataDir ? [openCodeDataDir] : openCodeDataDirCandidates();
+    for (const dataDir of candidates) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(path.join(dataDir, 'auth.json'), 'utf8'));
+            const codingPlan = parsed['zai-coding-plan'];
+            const zai = parsed.zai;
+            if (typeof codingPlan?.key === 'string' && codingPlan.key.trim())
+                return codingPlan.key.trim();
+            if (typeof zai?.key === 'string' && zai.key.trim())
+                return zai.key.trim();
+        }
+        catch {
+            // Try the next candidate.
+        }
+    }
+    return null;
+}
+function platformFromBaseUrl(baseUrl) {
+    if (baseUrl.includes('api.z.ai'))
+        return 'ZAI';
+    if (baseUrl.includes('open.bigmodel.cn') || baseUrl.includes('dev.bigmodel.cn'))
+        return 'ZHIPU';
+    return null;
+}
+export function readZaiCredentials(options = {}) {
+    const openCodeToken = readOpenCodeAuthToken(options.openCodeDataDir);
+    if (openCodeToken) {
+        return {
+            authToken: openCodeToken,
+            baseUrl: DEFAULT_ZAI_BASE_URL,
+            platform: 'ZAI',
+            source: 'opencode',
+        };
+    }
+    const env = options.env ?? process.env;
+    const authToken = env.ANTHROPIC_AUTH_TOKEN?.trim();
+    const baseUrl = env.ANTHROPIC_BASE_URL?.trim();
+    if (!authToken || !baseUrl)
+        return null;
+    const platform = platformFromBaseUrl(baseUrl);
+    if (!platform)
+        return null;
+    return {
+        authToken,
+        baseUrl,
+        platform,
+        source: 'env',
+    };
+}
+function quotaLimitUrl(baseUrl) {
+    try {
+        const parsed = new URL(baseUrl);
+        return `${parsed.protocol}//${parsed.host}${QUOTA_PATH}`;
+    }
+    catch {
+        return null;
+    }
+}
+function tokenLimitEntries(payload) {
+    const limits = payload.data?.limits ?? payload.limits ?? [];
+    return limits.filter((item) => item?.type === 'TOKENS_LIMIT' && typeof item.percentage === 'number');
+}
+function isFiveHourLimit(item) {
+    return item.type === 'TOKENS_LIMIT' && item.unit === 3 && item.number === 5;
+}
+function isWeeklyLimit(item) {
+    return item.type === 'TOKENS_LIMIT' && item.unit === 6 && item.number === 1;
+}
+function isoFromEpochMs(value) {
+    if (value == null)
+        return '';
+    const ms = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(ms) || ms <= 0)
+        return '';
+    return new Date(ms).toISOString();
+}
+function displayPlanName(level) {
+    if (!level)
+        return 'z.ai Coding Plan';
+    return `z.ai ${level.charAt(0).toUpperCase()}${level.slice(1)}`;
+}
+export function quotaStateFromZaiQuotaLimitPayload(payload, capturedAt = new Date().toISOString()) {
+    const data = payload;
+    const tokenLimits = tokenLimitEntries(data);
+    const fiveHourLimit = tokenLimits.find(isFiveHourLimit) ?? tokenLimits[0];
+    const weeklyLimit = tokenLimits.find(isWeeklyLimit) ?? tokenLimits.find((item) => item !== fiveHourLimit);
+    const level = data.data?.level;
+    if (!fiveHourLimit || !weeklyLimit) {
+        return unavailableZaiQuotaState('z.ai quota API returned no token quota windows.', {
+            failureKind: 'unknown',
+        }, capturedAt);
+    }
+    return withQuotaProjections({
+        fiveHour: {
+            utilization: fiveHourLimit.percentage ?? 0,
+            resetsAt: isoFromEpochMs(fiveHourLimit.nextResetTime),
+        },
+        sevenDay: {
+            utilization: weeklyLimit.percentage ?? 0,
+            resetsAt: isoFromEpochMs(weeklyLimit.nextResetTime),
+        },
+        available: true,
+        providerId: 'zai',
+        source: 'api',
+        capturedAt,
+        fiveHourLabel: '5-Hour',
+        sevenDayLabel: 'Weekly',
+        planType: level,
+        limitId: level ? `zai-${level}` : 'zai-coding-plan',
+        limitName: displayPlanName(level),
+    }, {
+        fiveHourWindowMs: FIVE_HOUR_WINDOW_MS,
+        sevenDayWindowMs: SEVEN_DAY_WINDOW_MS,
+        capturedAt,
+    });
+}
+function parseRetryAfterMs(retryAfter) {
+    if (!retryAfter)
+        return undefined;
+    const seconds = Number(retryAfter);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return seconds * 1000;
+    const dateMs = Date.parse(retryAfter);
+    if (Number.isFinite(dateMs))
+        return Math.max(0, dateMs - Date.now());
+    return undefined;
+}
+function failureKindForStatus(status) {
+    if (status === 401 || status === 403)
+        return 'auth';
+    if (status === 429)
+        return 'rate_limit';
+    if (status >= 500)
+        return 'server';
+    return 'unknown';
+}
+function sanitizeErrorMessage(message, authToken) {
+    let result = message;
+    if (authToken) {
+        result = result.split(authToken).join('<redacted>');
+    }
+    return result.replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/g, 'Bearer <redacted>');
+}
+export async function fetchZaiQuotaFromApi(options = {}) {
+    const capturedAt = options.capturedAt ?? new Date().toISOString();
+    const credentials = options.credentials ?? readZaiCredentials(options);
+    if (!credentials) {
+        return unavailableZaiQuotaState('No z.ai credentials found. Sign in to OpenCode with z.ai or set ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN.', { failureKind: 'auth' }, capturedAt);
+    }
+    const url = quotaLimitUrl(credentials.baseUrl);
+    if (!url) {
+        return unavailableZaiQuotaState('Invalid z.ai base URL.', { failureKind: 'unknown' }, capturedAt);
+    }
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    timeout.unref?.();
+    try {
+        const response = await fetchImpl(url, {
+            method: 'GET',
+            headers: {
+                Authorization: credentials.authToken,
+                'Accept-Language': 'en-US,en',
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+            signal: controller.signal,
+        });
+        const body = await response.text();
+        let parsed;
+        try {
+            parsed = JSON.parse(body);
+        }
+        catch {
+            parsed = null;
+        }
+        if (!response.ok) {
+            const failureKind = failureKindForStatus(response.status);
+            const retryAfterMs = parseRetryAfterMs(response.headers.get('retry-after'));
+            const detail = parsed && typeof parsed === 'object' && 'msg' in parsed
+                ? String(parsed.msg ?? '')
+                : '';
+            const baseMessage = failureKind === 'auth'
+                ? `z.ai quota API rejected credentials (HTTP ${response.status}).`
+                : `z.ai quota API error (HTTP ${response.status}).`;
+            return unavailableZaiQuotaState(sanitizeErrorMessage([baseMessage, detail].filter(Boolean).join(' '), credentials.authToken), { failureKind, httpStatus: response.status, retryAfterMs }, capturedAt);
+        }
+        return quotaStateFromZaiQuotaLimitPayload(parsed, capturedAt);
+    }
+    catch (error) {
+        const isAbort = error instanceof Error && error.name === 'AbortError';
+        return unavailableZaiQuotaState(isAbort ? 'z.ai quota API timed out.' : 'z.ai quota API network error.', { failureKind: 'network' }, capturedAt);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/** Stamp a z.ai quota sample with its runtime provider, projections, and window labels. */
+export function enrichZaiQuota(state) {
+    const withProjections = withQuotaProjections(state);
+    return {
+        ...withProjections,
+        runtimeProvider: 'zai',
+        providerId: 'zai',
+        fiveHourLabel: state.fiveHourLabel ?? '5-Hour',
+        sevenDayLabel: state.sevenDayLabel ?? 'Weekly',
+    };
+}
+export async function resolveZaiQuota(options = {}) {
+    const accountId = options.accountId ?? DEFAULT_ACCOUNT_ID;
+    const readSnapshot = options.readSnapshot ?? readQuotaSnapshot;
+    const writeSnapshot = options.writeSnapshot ?? writeQuotaSnapshot;
+    const apiQuota = await fetchZaiQuotaFromApi(options);
+    if (apiQuota.available) {
+        writeSnapshot('zai', accountId, apiQuota);
+        return enrichZaiQuota(apiQuota);
+    }
+    const cached = readSnapshot('zai', accountId);
+    if (cached) {
+        return enrichZaiQuota({
+            ...cached,
+            providerId: 'zai',
+            source: 'cache',
+            stale: true,
+            fiveHourLabel: cached.fiveHourLabel ?? '5-Hour',
+            sevenDayLabel: cached.sevenDayLabel ?? 'Weekly',
+        });
+    }
+    return enrichZaiQuota(apiQuota);
+}