@leo000001/opencode-quota-sidebar 2.0.14 → 2.0.19

package/dist/cost.d.ts

@@ -1,6 +1,8 @@
 import type { AssistantMessage } from '@opencode-ai/sdk';
 import type { CacheCoverageMode } from './types.js';
 export declare const API_COST_ENABLED_PROVIDERS: Set<string>;
+export type CanonicalPriceSource = 'official-doc' | 'runtime';
+export declare function canonicalPricingProviderID(providerID: string): string;
 export declare function canonicalApiCostProviderID(providerID: string): string;
 export type ModelCostRates = {
     input: number;
@@ -14,8 +16,38 @@ export type ModelCostRates = {
         cacheWrite: number;
     };
 };
+export type CanonicalPriceEntry = {
+    provider: string;
+    model: string;
+    rates: ModelCostRates;
+    source: CanonicalPriceSource;
+    sourceURL?: string;
+    updatedAt?: string;
+};
 export declare function modelCostKey(providerID: string, modelID: string): string;
 export declare function modelCostLookupKeys(providerID: string, modelID: string): string[];
+export declare function getBundledModelCostMap(): {
+    [x: string]: ModelCostRates;
+};
+export declare function getBundledCanonicalPriceEntries(): {
+    rates: {
+        contextOver200k: {
+            input: number;
+            output: number;
+            cacheRead: number;
+            cacheWrite: number;
+        } | undefined;
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+    };
+    provider: string;
+    model: string;
+    source: CanonicalPriceSource;
+    sourceURL?: string;
+    updatedAt?: string;
+}[];
 export declare function parseModelCostRates(value: unknown): ModelCostRates | undefined;
 export declare function guessModelCostDivisor(rates: ModelCostRates): 1 | 1000000;
 export declare function cacheCoverageModeFromRates(rates: ModelCostRates | undefined): CacheCoverageMode;

package/dist/cost.js

@@ -3,11 +3,73 @@ export const API_COST_ENABLED_PROVIDERS = new Set([
     'openai',
     'anthropic',
     'kimi-for-coding',
+    'zhipu',
 ]);
 const MODEL_COST_RATE_ALIASES = {
-    'kimi-for-coding:k2p5': ['moonshotai-cn:kimi-k2.5'],
-    'kimi-for-coding:kimi-k2-thinking': ['moonshotai-cn:kimi-k2-thinking'],
+    'zhipuai-coding-plan:glm-5.1': ['zhipu:glm-5'],
+    'zhipuai-coding-plan:glm-5.1-thinking': ['zhipu:glm-5'],
+    'zhipu:glm-5.1': ['zhipu:glm-5'],
+    'zhipu:glm-5.1-thinking': ['zhipu:glm-5'],
 };
+function moonshotCanonicalModelID(modelID) {
+    const stripped = modelID.replace(/^moonshotai[/:]/i, '');
+    switch (stripped) {
+        case 'k2p5':
+        case 'kimi-k2-5':
+            return 'kimi-k2.5';
+        default:
+            return stripped;
+    }
+}
+function moonshotModelAliases(modelID, options) {
+    const aliases = [];
+    const push = (value) => {
+        if (!value)
+            return;
+        if (!aliases.includes(value))
+            aliases.push(value);
+    };
+    const stripped = modelID.replace(/^moonshotai[/:]/i, '');
+    const canonical = moonshotCanonicalModelID(modelID);
+    if (!options?.canonicalProviderKeys)
+        push(modelID);
+    if (stripped !== modelID)
+        push(stripped);
+    push(canonical);
+    return aliases;
+}
+function zhipuModelAliases(modelID) {
+    const aliases = [];
+    const queue = [];
+    const push = (value) => {
+        if (!value)
+            return;
+        if (!aliases.includes(value)) {
+            aliases.push(value);
+            queue.push(value);
+        }
+    };
+    push(modelID);
+    for (let index = 0; index < queue.length; index++) {
+        const stem = queue[index];
+        const withoutProviderPrefix = stem.replace(/^(?:zhipu|z-ai|bigmodel|zhipuai-coding-plan)[/:]/, '');
+        push(withoutProviderPrefix);
+        push(`zhipu/${withoutProviderPrefix}`);
+        const withoutBillingSuffix = withoutProviderPrefix.replace(/-billing$/, '');
+        push(withoutBillingSuffix);
+        push(`zhipu/${withoutBillingSuffix}`);
+        const withoutThinkingSuffix = withoutBillingSuffix.replace(/-thinking$/, '');
+        push(withoutThinkingSuffix);
+        push(`zhipu/${withoutThinkingSuffix}`);
+        const dotted = withoutThinkingSuffix.replace(/(\d)-(\d)(?=-|$)/g, '$1.$2');
+        push(dotted);
+        push(`zhipu/${dotted}`);
+        const hyphenated = withoutThinkingSuffix.replace(/(\d)\.(\d)(?=-|$)/g, '$1-$2');
+        push(hyphenated);
+        push(`zhipu/${hyphenated}`);
+    }
+    return aliases;
+}
 function anthropicModelAliases(modelID) {
     const aliases = [];
     const queue = [];
@@ -61,6 +123,29 @@ function normalizeKnownProviderID(providerID) {
         return 'github-copilot';
     return providerID;
 }
+function isCanonicalZhipuProviderID(providerID) {
+    return (providerID === 'zhipu' ||
+        providerID === 'bigmodel' ||
+        providerID === 'z-ai' ||
+        providerID === 'zhipuai-coding-plan');
+}
+export function canonicalPricingProviderID(providerID) {
+    const normalized = normalizeKnownProviderID(providerID);
+    const lowered = normalized.toLowerCase();
+    if (isCanonicalZhipuProviderID(lowered)) {
+        return 'zhipu';
+    }
+    if (lowered === 'kimi-for-coding')
+        return 'moonshotai';
+    if (lowered.includes('anthropic') || lowered.includes('claude')) {
+        return 'anthropic';
+    }
+    if (lowered.includes('openai') || lowered.endsWith('-oai'))
+        return 'openai';
+    if (lowered.includes('copilot'))
+        return 'github-copilot';
+    return normalized;
+}
 export function canonicalApiCostProviderID(providerID) {
     const normalized = normalizeKnownProviderID(providerID);
     if (API_COST_ENABLED_PROVIDERS.has(normalized))
@@ -73,24 +158,262 @@ export function canonicalApiCostProviderID(providerID) {
     if (lowered.includes('anthropic') || lowered.includes('claude')) {
         return 'anthropic';
     }
+    if (isCanonicalZhipuProviderID(lowered)) {
+        return 'zhipu';
+    }
     return normalized;
 }
+function anthropicPricing(input, output, options) {
+    // OpenCode currently reports zero Anthropic model prices in runtime metadata,
+    // so keep a bundled fallback sourced from Anthropic's pricing docs.
+    return {
+        input,
+        output,
+        cacheRead: input * 0.1,
+        // OpenCode only exposes aggregate cache.write tokens, so use Anthropic's
+        // default 5-minute prompt-caching write rate.
+        cacheWrite: input * 1.25,
+        contextOver200k: options?.longContextInput !== undefined &&
+            options?.longContextOutput !== undefined
+            ? {
+                input: options.longContextInput,
+                output: options.longContextOutput,
+                cacheRead: options.longContextInput * 0.1,
+                cacheWrite: options.longContextInput * 1.25,
+            }
+            : undefined,
+    };
+}
+function zhipuPricing(input, output, cacheRead) {
+    return {
+        input,
+        output,
+        cacheRead,
+        cacheWrite: 0,
+    };
+}
+function moonshotPricing(input, output, cacheRead) {
+    return {
+        input,
+        output,
+        cacheRead,
+        cacheWrite: 0,
+    };
+}
+const BUNDLED_CANONICAL_PRICE_ENTRIES = [
+    {
+        provider: 'anthropic',
+        model: 'claude-opus-4-6',
+        rates: anthropicPricing(5, 25),
+        source: 'official-doc',
+        sourceURL: 'https://docs.anthropic.com/en/docs/about-claude/pricing',
+    },
+    {
+        provider: 'anthropic',
+        model: 'claude-opus-4-5',
+        rates: anthropicPricing(5, 25),
+        source: 'official-doc',
+        sourceURL: 'https://docs.anthropic.com/en/docs/about-claude/pricing',
+    },
+    {
+        provider: 'anthropic',
+        model: 'claude-opus-4-1',
+        rates: anthropicPricing(15, 75),
+        source: 'official-doc',
+        sourceURL: 'https://docs.anthropic.com/en/docs/about-claude/pricing',
+    },
+    {
+        provider: 'anthropic',
+        model: 'claude-opus-4',
+        rates: anthropicPricing(15, 75),
+        source: 'official-doc',
+        sourceURL: 'https://docs.anthropic.com/en/docs/about-claude/pricing',
+    },
+    {
+        provider: 'anthropic',
+        model: 'claude-sonnet-4-6',
+        rates: anthropicPricing(3, 15),
+        source: 'official-doc',
+        sourceURL: 'https://docs.anthropic.com/en/docs/about-claude/pricing',
+    },
+    {
+        provider: 'anthropic',
+        model: 'claude-sonnet-4-5',
+        rates: anthropicPricing(3, 15, {
+            longContextInput: 6,
+            longContextOutput: 22.5,
+        }),
+        source: 'official-doc',
+        sourceURL: 'https://docs.anthropic.com/en/docs/about-claude/pricing',
+    },
+    {
+        provider: 'anthropic',
+        model: 'claude-sonnet-4',
+        rates: anthropicPricing(3, 15, {
+            longContextInput: 6,
+            longContextOutput: 22.5,
+        }),
+        source: 'official-doc',
+        sourceURL: 'https://docs.anthropic.com/en/docs/about-claude/pricing',
+    },
+    {
+        provider: 'anthropic',
+        model: 'claude-3-7-sonnet',
+        rates: anthropicPricing(3, 15),
+        source: 'official-doc',
+        sourceURL: 'https://docs.anthropic.com/en/docs/about-claude/pricing',
+    },
+    {
+        provider: 'anthropic',
+        model: 'claude-3-5-sonnet',
+        rates: anthropicPricing(3, 15),
+        source: 'official-doc',
+        sourceURL: 'https://docs.anthropic.com/en/docs/about-claude/pricing',
+    },
+    {
+        provider: 'anthropic',
+        model: 'claude-haiku-4-5',
+        rates: anthropicPricing(1, 5),
+        source: 'official-doc',
+        sourceURL: 'https://docs.anthropic.com/en/docs/about-claude/pricing',
+    },
+    {
+        provider: 'anthropic',
+        model: 'claude-3-5-haiku',
+        rates: anthropicPricing(0.8, 4),
+        source: 'official-doc',
+        sourceURL: 'https://docs.anthropic.com/en/docs/about-claude/pricing',
+    },
+    {
+        provider: 'anthropic',
+        model: 'claude-3-opus',
+        rates: anthropicPricing(15, 75),
+        source: 'official-doc',
+        sourceURL: 'https://docs.anthropic.com/en/docs/about-claude/pricing',
+    },
+    {
+        provider: 'anthropic',
+        model: 'claude-3-haiku',
+        rates: anthropicPricing(0.25, 1.25),
+        source: 'official-doc',
+        sourceURL: 'https://docs.anthropic.com/en/docs/about-claude/pricing',
+    },
+    {
+        provider: 'zhipu',
+        model: 'glm-5',
+        rates: zhipuPricing(1, 3.2, 0.2),
+        source: 'official-doc',
+        sourceURL: 'https://docs.z.ai/guides/overview/pricing',
+    },
+    {
+        provider: 'zhipu',
+        model: 'glm-4.7',
+        rates: zhipuPricing(0.6, 2.2, 0.11),
+        source: 'official-doc',
+        sourceURL: 'https://docs.z.ai/guides/overview/pricing',
+    },
+    {
+        provider: 'zhipu',
+        model: 'glm-4.6',
+        rates: zhipuPricing(0.6, 2.2, 0.11),
+        source: 'official-doc',
+        sourceURL: 'https://docs.z.ai/guides/overview/pricing',
+    },
+    {
+        provider: 'zhipu',
+        model: 'glm-4.6v',
+        rates: zhipuPricing(0.3, 0.9, 0.05),
+        source: 'official-doc',
+        sourceURL: 'https://docs.z.ai/guides/overview/pricing',
+    },
+    {
+        provider: 'zhipu',
+        model: 'glm-4.5',
+        rates: zhipuPricing(0.6, 2.2, 0.11),
+        source: 'official-doc',
+        sourceURL: 'https://docs.z.ai/guides/overview/pricing',
+    },
+    {
+        provider: 'zhipu',
+        model: 'glm-4.5-air',
+        rates: zhipuPricing(0.2, 1.1, 0.03),
+        source: 'official-doc',
+        sourceURL: 'https://docs.z.ai/guides/overview/pricing',
+    },
+    {
+        provider: 'zhipu',
+        model: 'glm-4.5v',
+        rates: zhipuPricing(0.6, 1.8, 0.11),
+        source: 'official-doc',
+        sourceURL: 'https://docs.z.ai/guides/overview/pricing',
+    },
+    {
+        provider: 'moonshotai',
+        model: 'kimi-k2.5',
+        rates: moonshotPricing(0.6, 3, 0.1),
+        source: 'official-doc',
+        sourceURL: 'https://platform.moonshot.ai/docs/pricing/chat',
+    },
+    {
+        provider: 'moonshotai',
+        model: 'kimi-k2-thinking',
+        rates: moonshotPricing(0.6, 2.5, 0.15),
+        source: 'official-doc',
+        sourceURL: 'https://platform.moonshot.ai/docs/pricing/chat',
+    },
+    {
+        provider: 'moonshotai',
+        model: 'kimi-k2-0711-preview',
+        rates: moonshotPricing(0.6, 2.5, 0.15),
+        source: 'official-doc',
+        sourceURL: 'https://platform.moonshot.ai/docs/pricing/chat',
+    },
+    {
+        provider: 'moonshotai',
+        model: 'kimi-k2-0905-preview',
+        rates: moonshotPricing(0.6, 2.5, 0.15),
+        source: 'official-doc',
+        sourceURL: 'https://platform.moonshot.ai/docs/pricing/chat',
+    },
+    {
+        provider: 'moonshotai',
+        model: 'kimi-k2-turbo-preview',
+        rates: moonshotPricing(2.4, 10, 0.6),
+        source: 'official-doc',
+        sourceURL: 'https://platform.moonshot.ai/docs/pricing/chat',
+    },
+    {
+        provider: 'moonshotai',
+        model: 'kimi-k2-thinking-turbo',
+        rates: moonshotPricing(1.15, 8, 0.15),
+        source: 'official-doc',
+        sourceURL: 'https://platform.moonshot.ai/docs/pricing/chat',
+    },
+];
 export function modelCostKey(providerID, modelID) {
     return `${providerID}:${modelID}`;
 }
 export function modelCostLookupKeys(providerID, modelID) {
     const keys = [];
-    const canonicalProviderID = canonicalApiCostProviderID(providerID);
+    const canonicalProviderID = canonicalPricingProviderID(providerID);
     const push = (key) => {
         if (!keys.includes(key))
             keys.push(key);
     };
-    const modelIDs = canonicalProviderID === 'anthropic'
+    const modelIDsFor = (options) => canonicalProviderID === 'anthropic'
         ? anthropicModelAliases(modelID)
-        : [modelID];
-    for (const candidateModelID of modelIDs) {
+        : canonicalProviderID === 'zhipu'
+            ? zhipuModelAliases(modelID)
+            : canonicalProviderID === 'moonshotai'
+                ? moonshotModelAliases(modelID, options)
+                : [modelID];
+    for (const candidateModelID of modelIDsFor()) {
         push(modelCostKey(providerID, candidateModelID));
-        if (canonicalProviderID !== providerID) {
+    }
+    if (canonicalProviderID !== providerID) {
+        for (const candidateModelID of modelIDsFor({
+            canonicalProviderKeys: true,
+        })) {
             push(modelCostKey(canonicalProviderID, candidateModelID));
         }
     }
@@ -101,6 +424,30 @@ export function modelCostLookupKeys(providerID, modelID) {
     }
     return keys;
 }
+function createBundledModelCostMap() {
+    const map = {};
+    for (const entry of BUNDLED_CANONICAL_PRICE_ENTRIES) {
+        for (const key of modelCostLookupKeys(entry.provider, entry.model)) {
+            map[key] = entry.rates;
+        }
+    }
+    return map;
+}
+const BUNDLED_MODEL_COST_MAP = createBundledModelCostMap();
+export function getBundledModelCostMap() {
+    return { ...BUNDLED_MODEL_COST_MAP };
+}
+export function getBundledCanonicalPriceEntries() {
+    return BUNDLED_CANONICAL_PRICE_ENTRIES.map((entry) => ({
+        ...entry,
+        rates: {
+            ...entry.rates,
+            contextOver200k: entry.rates.contextOver200k
+                ? { ...entry.rates.contextOver200k }
+                : undefined,
+        },
+    }));
+}
 export function parseModelCostRates(value) {
     if (!isRecord(value))
         return undefined;

package/dist/format.js

@@ -204,6 +204,8 @@ function compactProviderLabel(quota) {
         return 'Ant';
     if (canonical === 'kimi-for-coding')
         return 'Kimi';
+    if (canonical === 'zhipuai-coding-plan')
+        return 'Zhipu';
     if (canonical === 'rightcode')
         return 'RC';
     if (canonical === 'xyai-vibe')
@@ -257,26 +259,28 @@ function compactQuotaWindowText(win) {
     const resetToken = reset
         ? `${compactQuotaResetToken(win.resetLabel)}${reset}`
         : undefined;
+    const note = sanitizeLine(win.note || '');
     if (win.showPercent === false) {
         const safe = sanitizeLine(win.label || '');
         const daily = safe ? safe.replace(/^Daily\s+/i, 'D') : '';
-        return [daily, resetToken].filter(Boolean).join(' ');
+        return [daily, resetToken, note].filter(Boolean).join(' ');
     }
     const percentToken = compactQuotaPercentToken(win.label, win.remainingPercent);
-    return [percentToken, resetToken].filter(Boolean).join(' ');
+    return [percentToken, resetToken, note].filter(Boolean).join(' ');
 }
 function compactQuotaWindowTokens(win) {
     const reset = compactReset(win.resetAt, win.resetLabel, win.label);
     const resetToken = reset
         ? `${compactQuotaResetToken(win.resetLabel)}${reset}`
         : undefined;
+    const note = sanitizeLine(win.note || '');
     if (win.showPercent === false) {
         const safe = sanitizeLine(win.label || '');
         const daily = safe ? safe.replace(/^Daily\s+/i, 'D') : '';
-        return [daily, resetToken].filter((value) => Boolean(value));
+        return [daily, resetToken, note].filter((value) => Boolean(value));
     }
     const percentToken = compactQuotaPercentToken(win.label, win.remainingPercent);
-    return [percentToken, resetToken].filter((value) => Boolean(value));
+    return [percentToken, resetToken, note].filter((value) => Boolean(value));
 }
 function compactQuotaBalanceText(balance) {
     return `B${compactDesktopCurrencyValue(balance.amount, balance.currency)}`;
@@ -611,6 +615,8 @@ function compactQuotaWide(quota, labelWidth = 0, options) {
         if (reset) {
             parts.push(`${sanitizeLine(win.resetLabel || 'Rst')} ${reset}`);
         }
+        if (win.note)
+            parts.push(sanitizeLine(win.note));
         return parts.join(' ');
     };
     // Multi-window rendering
@@ -849,7 +855,9 @@ export function renderMarkdownReport(period, usage, quotas, options) {
         // Multi-window detail
         if (quota.windows && quota.windows.length > 0 && quota.status === 'ok') {
             const windowLines = quota.windows.map((win) => {
-                const extraNote = win === quota.windows?.[0] && quota.note ? ` | ${quota.note}` : '';
+                const extraNote = win.note || (win === quota.windows?.[0] && quota.note)
+                    ? ` | ${win.note || quota.note}`
+                    : '';
                 if (win.showPercent === false) {
                     const winLabel = win.label ? ` (${win.label})` : '';
                     return mdCell(`- ${displayLabel}${winLabel}: ${quota.status} | reset ${reportResetLine(win.resetAt, win.resetLabel, win.label)}${extraNote}`);
@@ -964,7 +972,13 @@ export function renderToastMessage(period, usage, quotas, options) {
         }
         else {
             const hasAnyUsage = Object.keys(usage.providers).length > 0;
-            lines.push(fitLine(hasAnyUsage ? '  N/A (Copilot)' : '  -', width));
+            const hasOnlyCopilotUsage = hasAnyUsage &&
+                Object.values(usage.providers).every((provider) => canonicalProviderID(provider.providerID) === 'github-copilot');
+            lines.push(fitLine(hasOnlyCopilotUsage
+                ? '  N/A (Copilot)'
+                : hasAnyUsage
+                    ? '  N/A'
+                    : '  -', width));
         }
     }
     const providerCachePairs = Object.values(usage.providers)
@@ -995,6 +1009,8 @@ export function renderToastMessage(period, usage, quotas, options) {
                         parts.push(pct);
                     if (reset)
                         parts.push(`${win.resetLabel || 'Rst'} ${reset}`);
+                    if (win.note)
+                        parts.push(win.note);
                     return {
                         label: idx === 0 ? quotaDisplayLabel(item) : '',
                         value: parts.filter(Boolean).join(' '),

package/dist/providers/core/zhipu_coding_plan.d.ts

@@ -0,0 +1,2 @@
+import type { QuotaProviderAdapter } from '../types.js';
+export declare const zhipuCodingPlanAdapter: QuotaProviderAdapter;

package/dist/providers/core/zhipu_coding_plan.js

@@ -0,0 +1,217 @@
+import { isRecord, swallow } from '../../helpers.js';
+import { asNumber, configuredProviderEnabled, fetchWithTimeout, sanitizeBaseURL, toIso, } from '../common.js';
+const ZHIPU_QUOTA_URL = 'https://bigmodel.cn/api/monitor/usage/quota/limit';
+const ZHIPU_INTL_QUOTA_URL = 'https://api.z.ai/api/monitor/usage/quota/limit';
+function resolveApiKey(auth, providerOptions) {
+    const optionKey = providerOptions?.apiKey;
+    if (typeof optionKey === 'string' && optionKey)
+        return optionKey;
+    if (!auth)
+        return undefined;
+    if (auth.type === 'api' && typeof auth.key === 'string' && auth.key) {
+        return auth.key;
+    }
+    if (auth.type === 'wellknown') {
+        if (typeof auth.key === 'string' && auth.key)
+            return auth.key;
+        if (typeof auth.token === 'string' && auth.token)
+            return auth.token;
+    }
+    if (auth.type === 'oauth' && typeof auth.access === 'string' && auth.access) {
+        return auth.access;
+    }
+    return undefined;
+}
+function parseBaseURL(value) {
+    const normalized = sanitizeBaseURL(value);
+    if (!normalized)
+        return undefined;
+    try {
+        return new URL(normalized);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isZhipuCodingBaseURL(value) {
+    const parsed = parseBaseURL(value);
+    if (!parsed || parsed.protocol !== 'https:')
+        return false;
+    const pathname = parsed.pathname.replace(/\/+$/, '');
+    const isKnownHost = parsed.host === 'open.bigmodel.cn' || parsed.host === 'api.z.ai';
+    if (!isKnownHost)
+        return false;
+    return pathname === '/api/anthropic' || pathname === '/api/coding/paas/v4';
+}
+function quotaUrl(baseURL) {
+    const parsed = parseBaseURL(baseURL);
+    if (parsed?.host === 'api.z.ai')
+        return ZHIPU_INTL_QUOTA_URL;
+    return ZHIPU_QUOTA_URL;
+}
+function normalizeUsedPercent(value) {
+    const numeric = asNumber(value);
+    if (numeric === undefined || !Number.isFinite(numeric))
+        return undefined;
+    if (numeric < 0)
+        return 0;
+    if (numeric > 100)
+        return 100;
+    return numeric;
+}
+function tokenWindowLabel(unit, count) {
+    const unitValue = asNumber(unit);
+    const countValue = asNumber(count);
+    if (unitValue === 3 && countValue && countValue > 0) {
+        return `${Math.round(countValue)}h`;
+    }
+    if (unitValue === 1 && countValue === 7)
+        return 'Weekly';
+    if (unitValue === 1 && countValue && countValue > 0) {
+        return `${Math.round(countValue)}d`;
+    }
+    if (unitValue === 5 && countValue && countValue > 0) {
+        return `${Math.round(countValue)}m`;
+    }
+    return 'Tokens';
+}
+function formatCountValue(value) {
+    if (!Number.isFinite(value))
+        return '0';
+    return Number.isInteger(value) ? String(value) : value.toFixed(1);
+}
+function parseTokenWindow(value) {
+    if (value.type !== 'TOKENS_LIMIT')
+        return undefined;
+    const usedPercent = normalizeUsedPercent(value.percentage);
+    if (usedPercent === undefined)
+        return undefined;
+    return {
+        label: tokenWindowLabel(value.unit, value.number),
+        remainingPercent: 100 - usedPercent,
+        usedPercent,
+        resetAt: toIso(value.nextResetTime),
+    };
+}
+function parseMcpWindow(value) {
+    if (value.type !== 'TIME_LIMIT')
+        return undefined;
+    const total = asNumber(value.usage);
+    const remaining = asNumber(value.remaining);
+    if (total === undefined ||
+        remaining === undefined ||
+        !Number.isFinite(total) ||
+        !Number.isFinite(remaining) ||
+        total <= 0) {
+        return undefined;
+    }
+    return {
+        label: `MCP ${formatCountValue(remaining)}/${formatCountValue(total)}`,
+        showPercent: false,
+        remainingPercent: Math.max(0, Math.min(100, (remaining / total) * 100)),
+        resetAt: toIso(value.nextResetTime),
+    };
+}
+async function fetchZhipuCodingPlanQuota({ providerID, providerOptions, auth, config, }) {
+    const checkedAt = Date.now();
+    const base = {
+        providerID,
+        adapterID: 'zhipuai-coding-plan',
+        label: 'Zhipu Coding Plan',
+        shortLabel: 'Zhipu',
+        sortOrder: 16,
+    };
+    const apiKey = resolveApiKey(auth, providerOptions);
+    if (!apiKey) {
+        return {
+            ...base,
+            status: 'unavailable',
+            checkedAt,
+            note: 'missing api key',
+        };
+    }
+    const response = await fetchWithTimeout(quotaUrl(providerOptions?.baseURL), {
+        method: 'GET',
+        headers: {
+            Accept: 'application/json',
+            Authorization: apiKey,
+            'Content-Type': 'application/json',
+            'User-Agent': 'opencode-quota-sidebar',
+        },
+    }, config.quota.requestTimeoutMs).catch(swallow('fetchZhipuCodingPlanQuota:usage'));
+    if (!response) {
+        return {
+            ...base,
+            status: 'error',
+            checkedAt,
+            note: 'network request failed',
+        };
+    }
+    if (!response.ok) {
+        return {
+            ...base,
+            status: 'error',
+            checkedAt,
+            note: `http ${response.status}`,
+        };
+    }
+    const payload = await response
+        .json()
+        .catch(swallow('fetchZhipuCodingPlanQuota:json'));
+    if (!isRecord(payload)) {
+        return {
+            ...base,
+            status: 'error',
+            checkedAt,
+            note: 'invalid response',
+        };
+    }
+    if (payload.success !== true || asNumber(payload.code) !== 200) {
+        return {
+            ...base,
+            status: 'error',
+            checkedAt,
+            note: typeof payload.msg === 'string' && payload.msg
+                ? payload.msg
+                : 'quota request failed',
+        };
+    }
+    const data = isRecord(payload.data) ? payload.data : undefined;
+    const level = typeof data?.level === 'string' && data.level
+        ? `${data.level.toUpperCase()} plan`
+        : undefined;
+    const limits = Array.isArray(data?.limits)
+        ? data.limits.filter((item) => isRecord(item))
+        : [];
+    const token = limits
+        .map((item) => parseTokenWindow(item))
+        .find((value) => Boolean(value));
+    const mcp = limits
+        .map((item) => parseMcpWindow(item))
+        .find((value) => Boolean(value));
+    const windows = [token, mcp].filter((value) => Boolean(value));
+    const primary = token || windows[0];
+    return {
+        ...base,
+        status: primary ? 'ok' : 'error',
+        checkedAt,
+        remainingPercent: primary?.remainingPercent,
+        resetAt: primary?.resetAt,
+        note: primary ? level : 'missing quota fields',
+        windows: windows.length > 0 ? windows : undefined,
+    };
+}
+export const zhipuCodingPlanAdapter = {
+    id: 'zhipuai-coding-plan',
+    label: 'Zhipu Coding Plan',
+    shortLabel: 'Zhipu',
+    sortOrder: 16,
+    normalizeID: (providerID) => providerID === 'zhipuai-coding-plan' ? 'zhipuai-coding-plan' : undefined,
+    matchScore: ({ providerID, providerOptions }) => {
+        if (providerID === 'zhipuai-coding-plan')
+            return 100;
+        return isZhipuCodingBaseURL(providerOptions?.baseURL) ? 95 : 0;
+    },
+    isEnabled: (config) => configuredProviderEnabled(config.quota, 'zhipuai-coding-plan', true),
+    fetch: fetchZhipuCodingPlanQuota,
+};

package/dist/providers/index.d.ts

@@ -3,9 +3,10 @@ import { buzzAdapter } from './third_party/buzz.js';
 import { copilotAdapter } from './core/copilot.js';
 import { kimiForCodingAdapter } from './core/kimi_for_coding.js';
 import { openaiAdapter } from './core/openai.js';
+import { zhipuCodingPlanAdapter } from './core/zhipu_coding_plan.js';
 import { QuotaProviderRegistry } from './registry.js';
 import { rightCodeAdapter } from './third_party/rightcode.js';
 import { xyaiVibeAdapter } from './third_party/xyai_vibe.js';
 export declare function createDefaultProviderRegistry(): QuotaProviderRegistry;
-export { anthropicAdapter, buzzAdapter, copilotAdapter, kimiForCodingAdapter, openaiAdapter, rightCodeAdapter, xyaiVibeAdapter, QuotaProviderRegistry, };
+export { anthropicAdapter, buzzAdapter, copilotAdapter, kimiForCodingAdapter, openaiAdapter, rightCodeAdapter, xyaiVibeAdapter, zhipuCodingPlanAdapter, QuotaProviderRegistry, };
 export type { AuthUpdate, AuthValue, ProviderResolveContext, QuotaFetchContext, QuotaProviderAdapter, RefreshedOAuthAuth, } from './types.js';

package/dist/providers/index.js

@@ -3,6 +3,7 @@ import { buzzAdapter } from './third_party/buzz.js';
 import { copilotAdapter } from './core/copilot.js';
 import { kimiForCodingAdapter } from './core/kimi_for_coding.js';
 import { openaiAdapter } from './core/openai.js';
+import { zhipuCodingPlanAdapter } from './core/zhipu_coding_plan.js';
 import { QuotaProviderRegistry } from './registry.js';
 import { rightCodeAdapter } from './third_party/rightcode.js';
 import { xyaiVibeAdapter } from './third_party/xyai_vibe.js';
@@ -12,9 +13,10 @@ export function createDefaultProviderRegistry() {
     registry.register(buzzAdapter);
     registry.register(xyaiVibeAdapter);
     registry.register(kimiForCodingAdapter);
+    registry.register(zhipuCodingPlanAdapter);
     registry.register(openaiAdapter);
     registry.register(copilotAdapter);
     registry.register(anthropicAdapter);
     return registry;
 }
-export { anthropicAdapter, buzzAdapter, copilotAdapter, kimiForCodingAdapter, openaiAdapter, rightCodeAdapter, xyaiVibeAdapter, QuotaProviderRegistry, };
+export { anthropicAdapter, buzzAdapter, copilotAdapter, kimiForCodingAdapter, openaiAdapter, rightCodeAdapter, xyaiVibeAdapter, zhipuCodingPlanAdapter, QuotaProviderRegistry, };

package/dist/quota.js

@@ -33,7 +33,13 @@ export function quotaSort(left, right) {
 }
 export function listDefaultQuotaProviderIDs() {
     // Keep default report behavior stable for built-in subscription providers.
-    return ['openai', 'kimi-for-coding', 'github-copilot', 'anthropic'];
+    return [
+        'openai',
+        'kimi-for-coding',
+        'zhipuai-coding-plan',
+        'github-copilot',
+        'anthropic',
+    ];
 }
 export function createQuotaRuntime() {
     const providerRegistry = createDefaultProviderRegistry();

package/dist/quota_render.js

@@ -1,6 +1,7 @@
 const PROVIDER_SHORT_LABELS = {
     openai: 'OpenAI',
     'kimi-for-coding': 'Kimi',
+    'zhipuai-coding-plan': 'Zhipu',
     'github-copilot': 'Copilot',
     anthropic: 'Anthropic',
     rightcode: 'RC',
@@ -8,6 +9,8 @@ const PROVIDER_SHORT_LABELS = {
 export function canonicalProviderID(providerID) {
     if (providerID.startsWith('github-copilot'))
         return 'github-copilot';
+    if (providerID === 'zhipuai-coding-plan')
+        return 'zhipuai-coding-plan';
     return providerID;
 }
 export function displayShortLabel(providerID) {

package/dist/storage_parse.js

@@ -177,6 +177,7 @@ export function parseQuotaCache(value) {
                 resetLabel: typeof window.resetLabel === 'string'
                     ? window.resetLabel
                     : undefined,
+                note: typeof window.note === 'string' ? window.note : undefined,
                 remainingPercent: typeof window.remainingPercent === 'number'
                     ? window.remainingPercent
                     : undefined,

package/dist/types.d.ts

@@ -5,6 +5,8 @@ export type QuotaWindow = {
     showPercent?: boolean;
     /** Prefix for reset/expiry time text in sidebar (default: Rst). */
     resetLabel?: string;
+    /** Optional detail note rendered inline for the first window in reports. */
+    note?: string;
     remainingPercent?: number;
     usedPercent?: number;
     resetAt?: string;

package/dist/usage.d.ts

@@ -6,7 +6,7 @@ import type { CacheCoverageMetrics, CacheCoverageMode, CacheUsageBuckets, Cached
  * fields).  This is distinct from the plugin *state* version managed by the
  * persistence layer; billing version only governs usage-cache staleness.
  */
-export declare const USAGE_BILLING_CACHE_VERSION = 7;
+export declare const USAGE_BILLING_CACHE_VERSION = 9;
 export type ProviderUsage = {
     providerID: string;
     input: number;

package/dist/usage.js

@@ -4,7 +4,7 @@
  * fields).  This is distinct from the plugin *state* version managed by the
  * persistence layer; billing version only governs usage-cache staleness.
  */
-export const USAGE_BILLING_CACHE_VERSION = 7;
+export const USAGE_BILLING_CACHE_VERSION = 9;
 const MAX_RECENT_PROVIDER_EVENTS = 100;
 function emptyCacheUsageBucket() {
     return {

package/dist/usage_service.js

@@ -1,5 +1,5 @@
 import { TtlValueCache } from './cache.js';
-import { API_COST_ENABLED_PROVIDERS, cacheCoverageModeFromRates, calcEquivalentApiCostForMessage, canonicalApiCostProviderID, modelCostLookupKeys, modelCostKey, parseModelCostRates, } from './cost.js';
+import { API_COST_ENABLED_PROVIDERS, cacheCoverageModeFromRates, calcEquivalentApiCostForMessage, canonicalApiCostProviderID, canonicalPricingProviderID, getBundledModelCostMap, modelCostLookupKeys, modelCostKey, parseModelCostRates, } from './cost.js';
 import { deleteSessionFromDayChunk, dateKeyFromTimestamp, scanAllSessions, updateSessionsInDayChunks, } from './storage.js';
 import { periodStart } from './period.js';
 import { debug, debugError, isRecord, mapConcurrent, swallow, } from './helpers.js';
@@ -36,9 +36,10 @@ export function createUsageService(deps) {
         const cached = modelCostCache.get();
         if (cached)
             return cached;
+        const fallbackMap = getBundledModelCostMap();
         const providerClient = deps.client;
         if (!providerClient.provider?.list) {
-            return modelCostCache.set({}, 30_000);
+            return modelCostCache.set(fallbackMap, 30_000);
         }
         const response = await providerClient.provider
             .list({
@@ -59,7 +60,7 @@ export function createUsageService(deps) {
             const rawProviderID = typeof provider.id === 'string' ? provider.id : undefined;
             if (!rawProviderID)
                 return acc;
-            const canonicalProviderID = canonicalApiCostProviderID(rawProviderID);
+            const canonicalProviderID = canonicalPricingProviderID(rawProviderID);
             const models = provider.models;
             if (!isRecord(models))
                 return acc;
@@ -83,7 +84,7 @@ export function createUsageService(deps) {
                 }
             }
             return acc;
-        }, {});
+        }, fallbackMap);
         return modelCostCache.set(map, Math.max(30_000, deps.config.quota.refreshMs));
     };
     const calcEquivalentApiCost = (message, modelCostMap) => {
@@ -312,6 +313,42 @@ export function createUsageService(deps) {
             return false;
         return cached.billingVersion === USAGE_BILLING_CACHE_VERSION;
     };
+    const hasAnySubscriptionProvider = (cached) => {
+        const providerIDs = Object.keys(cached.providers);
+        if (providerIDs.length === 0)
+            return true;
+        return providerIDs.some((providerID) => {
+            const canonical = canonicalApiCostProviderID(providerID);
+            return API_COST_ENABLED_PROVIDERS.has(canonical);
+        });
+    };
+    const shouldRecomputeUsageCache = (cached, hasPricing, hasResolvableApiCostMessage) => {
+        if (!isUsageBillingCurrent(cached))
+            return true;
+        if (!hasPricing)
+            return false;
+        if (!hasResolvableApiCostMessage)
+            return false;
+        if (cached.assistantMessages <= 0)
+            return false;
+        if (cached.apiCost > 0)
+            return false;
+        if (cached.total <= 0)
+            return false;
+        if (!hasAnySubscriptionProvider(cached))
+            return false;
+        return true;
+    };
+    const hasResolvableApiCostMessages = (entries, modelCostMap) => {
+        return entries.some(({ info }) => {
+            if (info.role !== 'assistant')
+                return false;
+            const providerID = canonicalApiCostProviderID(info.providerID);
+            if (!API_COST_ENABLED_PROVIDERS.has(providerID))
+                return false;
+            return modelCostLookupKeys(info.providerID, info.modelID).some((key) => Boolean(modelCostMap[key]));
+        });
+    };
     const summarizeSessionUsage = async (sessionID, generationAtStart, options) => {
         const load = await loadSessionEntries(sessionID);
         const entries = load.status === 'ok' ? load.entries : undefined;
@@ -333,14 +370,23 @@ export function createUsageService(deps) {
             return { usage: empty, persist: false };
         }
         const modelCostMap = await getModelCostMap();
+        const hasPricing = Object.keys(modelCostMap).length > 0;
+        const hasResolvablePricing = hasResolvableApiCostMessages(entries, modelCostMap);
         const staleBillingCache = Boolean(sessionState?.usage) &&
             !isUsageBillingCurrent(sessionState?.usage);
-        const forceRescan = forceRescanSessions.has(sessionID) || staleBillingCache;
+        const pricingRefreshCache = sessionState?.usage &&
+            shouldRecomputeUsageCache(sessionState.usage, hasPricing, hasResolvablePricing);
+        const forceRescan = forceRescanSessions.has(sessionID) ||
+            staleBillingCache ||
+            Boolean(pricingRefreshCache);
         if (forceRescan)
             forceRescanSessions.delete(sessionID);
         if (staleBillingCache) {
             debug(`usage cache billing refresh for session ${sessionID}`);
         }
+        if (pricingRefreshCache && !staleBillingCache) {
+            debug(`usage cache pricing refresh for session ${sessionID}`);
+        }
         const { usage, cursor } = summarizeMessagesIncremental(entries, sessionState?.usage, sessionState?.cursor, forceRescan, {
             calcApiCost: (message) => calcEquivalentApiCost(message, modelCostMap),
             classifyCacheMode: (message) => classifyCacheMode(message, modelCostMap),
@@ -449,32 +495,6 @@ export function createUsageService(deps) {
         const usage = emptyUsageSummary();
         const modelCostMap = await getModelCostMap();
         const hasPricing = Object.keys(modelCostMap).length > 0;
-        const hasAnySubscriptionProvider = (cached) => {
-            const providerIDs = Object.keys(cached.providers);
-            // Back-compat: older cached chunks may have empty providers.
-            // In that case, allow recompute so we can persist apiCost.
-            if (providerIDs.length === 0)
-                return true;
-            return providerIDs.some((providerID) => {
-                const canonical = canonicalApiCostProviderID(providerID);
-                return API_COST_ENABLED_PROVIDERS.has(canonical);
-            });
-        };
-        const shouldRecomputeUsageCache = (cached) => {
-            if (!isUsageBillingCurrent(cached))
-                return true;
-            if (!hasPricing)
-                return false;
-            if (cached.assistantMessages <= 0)
-                return false;
-            if (cached.apiCost > 0)
-                return false;
-            if (cached.total <= 0)
-                return false;
-            if (!hasAnySubscriptionProvider(cached))
-                return false;
-            return true;
-        };
         if (sessions.length > 0) {
             const fetched = await mapConcurrent(sessions, RANGE_USAGE_CONCURRENCY, async (session) => {
                 const load = await loadSessionEntries(session.sessionID);
@@ -499,7 +519,7 @@ export function createUsageService(deps) {
                     classifyCacheMode: (message) => classifyCacheMode(message, modelCostMap),
                 });
                 const shouldPersistFullUsage = !session.state.usage ||
-                    shouldRecomputeUsageCache(session.state.usage);
+                    shouldRecomputeUsageCache(session.state.usage, hasPricing, hasResolvableApiCostMessages(entries, modelCostMap));
                 if (!shouldPersistFullUsage) {
                     return {
                         sessionID: session.sessionID,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leo000001/opencode-quota-sidebar",
-  "version": "2.0.14",
+  "version": "2.0.19",
   "description": "OpenCode plugin that shows quota and token usage in session titles",
   "type": "module",
   "main": "dist/index.js",