dsh-plugin-subscription-usage 0.0.0-stage → 0.1.0

package/lib/client/meter.js

@@ -0,0 +1,196 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { displayPercent, pace } from '../usage/pace.js';
+import { format } from './locales.js';
+/** Translate with placeholders. */
+export function tf(t, key, params) {
+    return format(t(key), params);
+}
+const PATHS = {
+    refresh: _jsxs(_Fragment, { children: [_jsx("path", { d: "M13.5 8a5.5 5.5 0 1 1-1.6-3.9" }), _jsx("path", { d: "M13.5 2.5v3h-3" })] }),
+    alert: _jsxs(_Fragment, { children: [_jsx("path", { d: "M8 1.8 15 14H1z" }), _jsx("path", { d: "M8 6.3v3.4M8 11.8v.01" })] }),
+    check: _jsx("path", { d: "m3.5 8.3 3 3 6-6.6" }),
+    star: _jsx("path", { d: "m8 2 1.8 3.8 4.2.5-3.1 2.9.8 4.1L8 11.3 4.3 13.3l.8-4.1L2 6.3l4.2-.5z", fill: "currentColor" }),
+    bolt: _jsx("path", { d: "M9 1.8 3.5 9H8l-1 5.2L12.5 7H8z", fill: "currentColor", stroke: "none" }),
+    pin: _jsxs(_Fragment, { children: [_jsx("path", { d: "M6 2.5h4l-.6 4 2.1 2.2v1H4.5v-1l2.1-2.2z" }), _jsx("path", { d: "M8 9.7v3.8" })] }),
+    pinFilled: _jsxs(_Fragment, { children: [_jsx("path", { d: "M6 2.5h4l-.6 4 2.1 2.2v1H4.5v-1l2.1-2.2z", fill: "currentColor" }), _jsx("path", { d: "M8 9.7v3.8" })] }),
+    gear: _jsxs(_Fragment, { children: [_jsx("circle", { cx: "8", cy: "8", r: "2.2" }), _jsx("path", { d: "M8 1.8v1.6M8 12.6v1.6M1.8 8h1.6M12.6 8h1.6M3.6 3.6l1.1 1.1M11.3 11.3l1.1 1.1M3.6 12.4l1.1-1.1M11.3 4.7l1.1-1.1" })] }),
+    ext: _jsx("path", { d: "M9 3h4v4M13 3 7.5 8.5M12 9.5V13H3V4h3.5" }),
+    copy: _jsxs(_Fragment, { children: [_jsx("rect", { x: "5", y: "5", width: "8.5", height: "8.5", rx: "1.5" }), _jsx("path", { d: "M11 5V3.5A1.5 1.5 0 0 0 9.5 2h-6A1.5 1.5 0 0 0 2 3.5v6A1.5 1.5 0 0 0 3.5 11H5" })] }),
+    x: _jsx("path", { d: "m4 4 8 8M12 4l-8 8" }),
+    right: _jsx("path", { d: "m6 4 4 4-4 4" }),
+    down: _jsx("path", { d: "m5 6.5 3 3 3-3" }),
+    meter: _jsxs(_Fragment, { children: [_jsx("path", { d: "M2.5 11a5.5 5.5 0 0 1 11 0" }), _jsx("path", { d: "m8 11 2.6-3.2" })] }),
+    sparkle: _jsx("path", { d: "M8 1.5 9.4 6.6 14.5 8 9.4 9.4 8 14.5 6.6 9.4 1.5 8 6.6 6.6z", fill: "currentColor", stroke: "none" }),
+};
+/** One 16-unit stroke icon. */
+export function Icon({ name, size = 14, className }) {
+    return (_jsx("svg", { className: className, width: size, height: size, viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: 1.5, strokeLinecap: "round", strokeLinejoin: "round", "aria-hidden": "true", style: { flex: 'none', display: 'block' }, children: PATHS[name] }));
+}
+const H = 3_600_000;
+const D = 24 * H;
+/** "3h 6m", "2d 12h", "42m". */
+export function shortDuration(ms) {
+    // Round once, then split, so 4h 59.6m reads 5h rather than 4h 60m.
+    const total = Math.max(1, Math.round(ms / 60_000));
+    const days = Math.floor(total / 1440);
+    const hours = Math.floor((total % 1440) / 60);
+    const minutes = total % 60;
+    if (days > 0)
+        return hours > 0 ? `${days}d ${hours}h` : `${days}d`;
+    if (hours > 0)
+        return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
+    return `${Math.max(1, minutes)}m`;
+}
+/**
+ * A short point in time in the browser's locale: "6:04 PM" today, "Wed" within
+ * the week, "12 Nov" beyond. The day alone keeps the time column narrow; the
+ * tooltip carries the exact reset time.
+ */
+export function clockTime(at, now) {
+    const date = new Date(at);
+    if (date.toDateString() === new Date(now).toDateString()) {
+        return date.toLocaleTimeString(undefined, { hour: 'numeric', minute: '2-digit' });
+    }
+    if (Math.abs(at - now) < 6 * D)
+        return date.toLocaleDateString(undefined, { weekday: 'short' });
+    return date.toLocaleDateString(undefined, { day: 'numeric', month: 'short' });
+}
+/** Weekday and time, for tooltips. */
+export function fullTime(at) {
+    return new Date(at).toLocaleString(undefined, { weekday: 'short', hour: 'numeric', minute: '2-digit' });
+}
+/** The window's length as "5h", "7d" or "30d", rounded to a whole unit; undefined when unknown. */
+export function lengthLabel(durationMs) {
+    if (durationMs === undefined || !Number.isFinite(durationMs) || durationMs <= 0)
+        return undefined;
+    const hours = Math.round(durationMs / 3_600_000);
+    if (hours < 1)
+        return `${Math.max(1, Math.round(durationMs / 60_000))}m`;
+    return hours < 48 ? `${hours}h` : `${Math.round(hours / 24)}d`;
+}
+/** "5h", "7d", "30d": the window's own length, else its kind, else "limit". */
+export function kindLabel(t, kind, durationMs) {
+    const length = lengthLabel(durationMs);
+    if (length !== undefined)
+        return length;
+    return kind === 'session' ? t('window5h') : kind === 'weekly' ? t('window7d') : t('windowOther');
+}
+/** The length label, with a model scope when the window has one. A per-model quota is named by its scope alone. */
+export function windowLabel(t, window) {
+    if (window.scope === undefined)
+        return kindLabel(t, window.kind, window.durationMs);
+    return window.kind === 'other' ? window.scope : `${kindLabel(t, window.kind, window.durationMs)} ${window.scope}`;
+}
+const FAMILY_NAMES = { gemini: 'Gemini', claude: 'Claude', gpt: 'GPT' };
+/** "claude-opus-4-6-thinking" becomes "Claude"; "tab_flash_lite" becomes "Tab". */
+function modelFamily(id) {
+    const head = id.split(/[-_]/)[0] ?? id;
+    return FAMILY_NAMES[head.toLowerCase()] ?? head.charAt(0).toUpperCase() + head.slice(1);
+}
+/**
+ * Per-model windows that report the same usage and reset share one quota pool
+ * (Antigravity reports one window per model), so they merge into one row named
+ * by model family. A per-model window at 0% with no reset carries no information
+ * and is hidden. Unscoped windows pass through unchanged.
+ */
+export function shownWindows(windows) {
+    const out = [];
+    const groups = new Map();
+    for (const window of windows ?? []) {
+        if (window.scope === undefined || window.kind !== 'other') {
+            out.push(window);
+            continue;
+        }
+        if (window.resetsAt === undefined && window.usedPercent === 0)
+            continue;
+        const minute = window.resetsAt === undefined ? '' : String(Math.round(window.resetsAt / 60_000));
+        const key = `${Math.round(window.usedPercent)}/${minute}`;
+        const group = groups.get(key);
+        if (group === undefined) {
+            const entry = { window, models: [window.scope] };
+            groups.set(key, entry);
+        }
+        else {
+            group.models.push(window.scope);
+        }
+    }
+    for (const { window, models } of groups.values()) {
+        const families = [...new Set(models.map(modelFamily))];
+        out.push({ ...window, scope: families.join(' · '), models });
+    }
+    return out;
+}
+/**
+ * What compact surfaces show: unscoped windows, session first. A provider that
+ * only reports per-model windows (Antigravity) shows its two most used instead.
+ */
+export function primaryWindows(windows) {
+    const order = { session: 0, weekly: 1, other: 2 };
+    const all = shownWindows(windows);
+    const unscoped = all.filter(w => w.scope === undefined).sort((a, b) => order[a.kind] - order[b.kind]);
+    if (unscoped.length > 0)
+        return unscoped;
+    return [...all].sort((a, b) => b.usedPercent - a.usedPercent).slice(0, 2);
+}
+/** The pace bar: fill is quota, hatch is the forecast, color is the pace state. Drains in `left` mode. */
+export function Bar({ window, p, display, height = 6 }) {
+    const used = p.state === 'unknown' ? 0 : p.usedPercent;
+    const left = display === 'left';
+    const fill = left ? 100 - used : used;
+    let projection = null;
+    if (p.state === 'over' || p.state === 'tight') {
+        const end = Math.min(100, p.projectedPercent);
+        projection = _jsx("span", { className: "dsm-proj", style: left ? { left: `${100 - end}%`, width: `${end - used}%` } : { left: `${used}%`, width: `${end - used}%` } });
+    }
+    return (_jsxs("span", { className: `dsm-bar dsm-${p.state}`, style: { height }, role: "meter", "aria-valuemin": 0, "aria-valuemax": 100, "aria-valuenow": displayPercent(window, display) ?? 0, children: [_jsx("span", { className: "dsm-fill", style: { width: `${fill}%` } }), projection] }));
+}
+function valueText(window, display) {
+    const value = displayPercent(window, display);
+    return value === undefined ? '–' : `${value}%`;
+}
+/** The time column: when this changes next. */
+function timeText(t, window, p, now) {
+    if (p.state === 'out' && window.resetsAt !== undefined)
+        return tf(t, 'backAt', { time: clockTime(window.resetsAt, now) });
+    if (p.state === 'over')
+        return tf(t, 'emptyAt', { time: clockTime(p.emptyAt, now) });
+    return window.resetsAt === undefined ? '' : tf(t, 'resetsIn', { time: shortDuration(Math.max(0, window.resetsAt - now)) });
+}
+function tooltip(t, window, p, now) {
+    if (p.state === 'unknown')
+        return t('notReported');
+    const used = Math.round(p.usedPercent);
+    const lines = [...window.models ?? [], tf(t, 'tipUsedLeft', { used, left: 100 - used })];
+    if (window.used !== undefined && window.limit !== undefined) {
+        lines.push(tf(t, 'tipCount', { used: Math.round(window.used), limit: window.limit }));
+    }
+    if ((p.state === 'calm' || p.state === 'tight' || p.state === 'over') && p.elapsed !== undefined) {
+        lines.push(tf(t, 'tipElapsed', { percent: Math.round(p.elapsed * 100) }));
+    }
+    if (p.state === 'tight')
+        lines.push(tf(t, 'tipPace', { percent: Math.round(p.projectedPercent) }));
+    if (p.state === 'over')
+        lines.push(tf(t, 'emptyAt', { time: fullTime(p.emptyAt) }));
+    if (window.resetsAt !== undefined)
+        lines.push(tf(t, 'tipResets', { time: fullTime(window.resetsAt) }));
+    return lines.join('\n');
+}
+/** One window on the shared grid: label | bar | value | time. */
+export function WindowRow({ t, window, display, now }) {
+    const p = pace(window, now);
+    const tip = tooltip(t, window, p, now);
+    // The row is `display: contents` so its cells sit on the shared grid; each cell carries the tooltip.
+    return (_jsxs("div", { className: `dsm-w dsm-${p.state}`, children: [_jsx("span", { className: "dsm-wl", title: window.scope === undefined ? tip : `${windowLabel(t, window)}\n${tip}`, children: windowLabel(t, window) }), _jsx("span", { title: tip, children: _jsx(Bar, { window: window, p: p, display: display }) }), _jsx("span", { className: "dsm-wv", title: tip, children: valueText(window, display) }), _jsx("span", { className: "dsm-wt", title: tip, children: timeText(t, window, p, now) })] }));
+}
+/** Label, small bar and value, for summary rows and the gauge. */
+export function Mini({ t, window, display, now }) {
+    const p = pace(window, now);
+    return (_jsxs("span", { className: `dsm-mini dsm-${p.state}`, title: window.scope === undefined ? tooltip(t, window, p, now) : `${window.scope}\n${tooltip(t, window, p, now)}`, children: [_jsx("i", { children: window.kind === 'other' && window.scope !== undefined ? window.scope : kindLabel(t, window.kind, window.durationMs) }), _jsx(Bar, { window: window, p: p, display: display, height: 4 }), _jsx("b", { children: valueText(window, display) })] }));
+}
+/** The mini meters of an account's unscoped windows. */
+export function Minis({ t, windows, display, now }) {
+    const shown = primaryWindows(windows);
+    if (shown.length === 0)
+        return null;
+    return _jsx("span", { className: "dsm-minis", children: shown.map((w, i) => _jsx(Mini, { t: t, window: w, display: display, now: now }, i)) });
+}

package/lib/client/prefs.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Usage preferences live in this plugin's volatile `usage` Config field, so
+ * they persist in the profile and reach every tab. The Client reads them
+ * through the settings forms service and validates the section where it
+ * enters.
+ */
+import type { UsageProviderId as ProviderId } from './rpc.js';
+export type { ProviderId };
+export interface UsagePreferencesView {
+    /** Show usage under the composer: the current model's provider plus `pinned`. */
+    composer: boolean;
+    pinned: readonly ProviderId[];
+    display: 'left' | 'used';
+    paceWarnings: boolean;
+    /** Whether writes reach the profile. */
+    writable: boolean;
+}
+export declare const DEFAULT_PREFS: UsagePreferencesView;
+/** The slice of a settings ConfigForm this store uses. */
+export interface ConfigFormLike {
+    getSnapshot(): {
+        status: string;
+        value: unknown;
+        writable: boolean;
+    };
+    subscribe(listener: () => void): () => void;
+    mutate(ops: readonly ({
+        op: 'set';
+        path: string[];
+        value: unknown;
+    } | {
+        op: 'unset';
+        path: string[];
+    })[]): Promise<boolean>;
+}
+/** Narrow the namespace section's `usage` field, falling back field by field. */
+export declare function parsePrefs(section: unknown, writable: boolean): UsagePreferencesView;
+export declare class PrefsStore {
+    private snapshot;
+    private readonly listeners;
+    private unsubscribe;
+    private form;
+    getSnapshot: () => UsagePreferencesView;
+    subscribe: (listener: () => void) => (() => void);
+    /** Bind the form once the settings service is available; returns the unbinder. */
+    bind(form: ConfigFormLike): () => void;
+    /** Change some preferences; the shown value updates at once and settles on the Host's answer. */
+    set(patch: Partial<Omit<UsagePreferencesView, 'writable'>>): Promise<boolean>;
+    togglePinned(provider: ProviderId): Promise<boolean>;
+    private publish;
+}

package/lib/client/prefs.js

@@ -0,0 +1,71 @@
+import { isUsageProviderId } from './rpc.js';
+export const DEFAULT_PREFS = { composer: true, pinned: [], display: 'left', paceWarnings: true, writable: false };
+/** Narrow the namespace section's `usage` field, falling back field by field. */
+export function parsePrefs(section, writable) {
+    const usage = section !== null && typeof section === 'object' && 'usage' in section ? section.usage : undefined;
+    if (usage === null || typeof usage !== 'object')
+        return { ...DEFAULT_PREFS, writable };
+    const read = (key) => (key in usage ? usage[key] : undefined);
+    const composer = read('composer');
+    // Profiles saved before `composer` existed carry a three-way `gauge` mode.
+    const legacyGauge = read('gauge');
+    const display = read('display');
+    const pinned = read('pinned');
+    const pace = read('paceWarnings');
+    return {
+        composer: typeof composer === 'boolean' ? composer : legacyGauge !== 'off',
+        pinned: Array.isArray(pinned) ? pinned.filter(isUsageProviderId) : [],
+        display: display === 'used' ? 'used' : 'left',
+        paceWarnings: typeof pace === 'boolean' ? pace : true,
+        writable,
+    };
+}
+export class PrefsStore {
+    snapshot = DEFAULT_PREFS;
+    listeners = new Set();
+    unsubscribe;
+    form;
+    getSnapshot = () => this.snapshot;
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => { this.listeners.delete(listener); };
+    };
+    /** Bind the form once the settings service is available; returns the unbinder. */
+    bind(form) {
+        this.form = form;
+        const sync = () => {
+            const view = form.getSnapshot();
+            if (view.status !== 'ready')
+                return;
+            this.publish(parsePrefs(view.value, view.writable));
+        };
+        this.unsubscribe = form.subscribe(sync);
+        sync();
+        return () => {
+            this.unsubscribe?.();
+            this.form = undefined;
+        };
+    }
+    /** Change some preferences; the shown value updates at once and settles on the Host's answer. */
+    async set(patch) {
+        const next = { ...this.snapshot, ...patch };
+        this.publish(next);
+        if (this.form === undefined)
+            return false;
+        const ops = Object.entries(patch).map(([key, value]) => ({ op: 'set', path: ['usage', key], value }));
+        // `composer` replaces the legacy `gauge` mode; drop it on the first write.
+        ops.push({ op: 'unset', path: ['usage', 'gauge'] });
+        return this.form.mutate(ops);
+    }
+    togglePinned(provider) {
+        const pinned = this.snapshot.pinned.includes(provider)
+            ? this.snapshot.pinned.filter(p => p !== provider)
+            : [...this.snapshot.pinned, provider];
+        return this.set({ pinned });
+    }
+    publish(next) {
+        this.snapshot = next;
+        for (const listener of this.listeners)
+            listener();
+    }
+}

package/lib/client/rpc.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Browser calls to the Host's `/api/subscriptions-auth.*` routes, and the
+ * shapes those routes return. Only types cross from the Host modules, so the
+ * bundle stays free of Node imports.
+ */
+import type { ConnectionHandle } from '@deepseek-ai/dsh-api-remotes/client';
+import type { AccountStatus, ProviderStatus, ProviderAccountCatalog } from '../auth/rpc.js';
+import type { ProviderId } from '../auth/store.js';
+import type { KeyProviderId, KeyProviderView } from '../usage-providers/index.js';
+import type { ProviderPreferences, SubscriptionTool } from '../provider-settings.js';
+import type { DisplayUsage, UsageReadReason } from '../usage/service.js';
+import type { ProxyConfigView, ProxyInput, ProxyTestResult } from '../http.js';
+export type { KeyProviderId, KeyProviderView, AccountStatus, ProviderStatus, ProviderId, ProviderPreferences, DisplayUsage, UsageReadReason, ProxyConfigView, ProxyTestResult };
+/** Every provider this plugin can route, in Models-page order. Names and metering come from `status`. */
+export declare const PROVIDERS: readonly ProviderId[];
+/** Providers that read usage with a pasted key, in Usage-page order. Mirrors the Host's `KEY_PROVIDER_IDS`. */
+export declare const KEY_PROVIDERS: readonly KeyProviderId[];
+/** Any provider the Usage page and gauge can show. */
+export type UsageProviderId = ProviderId | KeyProviderId;
+export declare const USAGE_PROVIDERS: readonly UsageProviderId[];
+export declare const isUsageProviderId: (value: unknown) => value is UsageProviderId;
+export declare const isProviderId: (value: unknown) => value is ProviderId;
+/** The provider's short name from `status`, else its id. */
+export declare const shortName: (status: StatusValue | undefined, provider: UsageProviderId) => string;
+/** Whether the Host reports usage for this provider. */
+export declare const isMetered: (status: StatusValue | undefined, provider: UsageProviderId) => boolean;
+/** `status` response. */
+export interface StatusValue {
+    usageRevision: number;
+    /** Every key provider with whether a key is stored; configured ones also appear in `providers`. Absent from a Host that predates key providers. */
+    keyProviders?: KeyProviderView[];
+    providers: Partial<Record<UsageProviderId, ProviderStatus>>;
+}
+/** One model row of `providerSettings`. */
+export interface ProviderModelRow {
+    id: string;
+    name: string;
+    contextWindow?: number;
+    efforts: {
+        id: string;
+        name: string;
+    }[];
+    configured?: string;
+}
+/** `providerSettings` response. */
+export interface ProviderSettingsValue {
+    provider: ProviderId;
+    settings: ProviderPreferences;
+    models: ProviderModelRow[];
+    tools: readonly SubscriptionTool[];
+    accounts: ProviderAccountCatalog[];
+}
+/** The Host's business error text. */
+export declare class SubscriptionsAuthError extends Error {
+}
+/** Typed endpoint table: payload in, value out. */
+export interface Endpoints {
+    status: [{
+        sessionId?: string;
+    }, StatusValue];
+    usage: [{
+        provider: UsageProviderId;
+        account: string;
+        reason: UsageReadReason;
+    }, DisplayUsage];
+    keysSet: [{
+        provider: KeyProviderId;
+        key: string;
+    }, {
+        ok: true;
+    }];
+    keysRemove: [{
+        provider: KeyProviderId;
+    }, {
+        ok: true;
+    }];
+    login: [{
+        provider: ProviderId;
+        method?: 'oauth' | 'keychain';
+    }, {
+        authorizeUrl: string;
+        userCode?: string;
+    }];
+    manual: [{
+        provider: ProviderId;
+        input: string;
+    }, {
+        ok: true;
+    }];
+    cancel: [{
+        provider: ProviderId;
+    }, {
+        ok: true;
+    }];
+    logout: [{
+        provider: ProviderId;
+        account: string;
+    }, {
+        ok: true;
+    }];
+    setDefault: [{
+        provider: ProviderId;
+        account: string;
+    }, {
+        ok: true;
+    }];
+    providerSettings: [{
+        provider: ProviderId;
+        force?: boolean;
+    }, ProviderSettingsValue];
+    setProviderSettings: [{
+        provider: ProviderId;
+        settings: ProviderPreferences;
+    }, {
+        ok: true;
+    }];
+    setModelDefault: [{
+        provider: ProviderId;
+        model: string;
+        effort?: string;
+    }, {
+        ok: true;
+    }];
+    proxyGet: [Record<string, never>, ProxyConfigView];
+    proxySet: [ProxyInput, ProxyConfigView];
+    proxyTest: [{
+        url?: string;
+        proxy?: {
+            url: string;
+        };
+    }, ProxyTestResult];
+    image: [Record<string, unknown>, {
+        mediaType: string;
+        dataBase64: string;
+    }];
+    video: [{
+        name: string;
+    }, {
+        mediaType: string;
+        dataBase64: string;
+    }];
+    speed: [{
+        sessionId: string;
+        model?: string;
+    }, {
+        tier: 'standard' | 'fast';
+        fastModels: string[];
+    }];
+    setSpeed: [{
+        sessionId: string;
+        tier: 'standard' | 'fast';
+        model?: string;
+    }, {
+        ok: true;
+    }];
+}
+/**
+ * Call one endpoint and unwrap its business result.
+ * @throws SubscriptionsAuthError with the Host's message on transport or business failure.
+ */
+export declare function call<E extends keyof Endpoints>(rpc: ConnectionHandle['rpc'], endpoint: E, payload: Endpoints[E][0]): Promise<Endpoints[E][1]>;

package/lib/client/rpc.js

@@ -0,0 +1,31 @@
+/** Every provider this plugin can route, in Models-page order. Names and metering come from `status`. */
+export const PROVIDERS = ['codex', 'claude', 'grok', 'copilot', 'antigravity'];
+/** Providers that read usage with a pasted key, in Usage-page order. Mirrors the Host's `KEY_PROVIDER_IDS`. */
+export const KEY_PROVIDERS = ['zai', 'ollama-cloud', 'kimi'];
+export const USAGE_PROVIDERS = [...PROVIDERS, ...KEY_PROVIDERS];
+export const isUsageProviderId = (value) => typeof value === 'string' && USAGE_PROVIDERS.includes(value);
+export const isProviderId = (value) => typeof value === 'string' && PROVIDERS.includes(value);
+/** The provider's short name from `status`, else its id. */
+export const shortName = (status, provider) => status?.providers[provider]?.shortName ?? provider;
+/** Whether the Host reports usage for this provider. */
+export const isMetered = (status, provider) => status?.providers[provider]?.metered === true;
+/** The Host's business error text. */
+export class SubscriptionsAuthError extends Error {
+}
+/**
+ * Call one endpoint and unwrap its business result.
+ * @throws SubscriptionsAuthError with the Host's message on transport or business failure.
+ */
+export async function call(rpc, endpoint, payload) {
+    let result;
+    try {
+        result = await rpc.call('/api', `subscriptions-auth.${endpoint}`, payload);
+    }
+    catch (error) {
+        throw new SubscriptionsAuthError(error instanceof Error ? error.message : String(error));
+    }
+    if (!result.ok)
+        throw new SubscriptionsAuthError(result.error.message);
+    // The Host route owns this shape; the endpoint table mirrors it.
+    return result.value;
+}

package/lib/client/store.d.ts

@@ -0,0 +1,67 @@
+/**
+ * One shared store per page for login status and usage, read by the Models
+ * cards, the composer gauge, and its popover. It never fetches on its own
+ * beyond the policy below; the Host decides whether a read reaches a provider.
+ *
+ * - `status` is read on start, every 5 minutes while the page is visible, after
+ *   a sign-in or account change, and after each turn the gauge observes.
+ * - `usage` is re-read when `status.usageRevision` moves (a reply carried new
+ *   headers, or another surface fetched), when the popover opens (`open`), on
+ *   the Refresh button (`manual`), and every 5 minutes while visible (`poll`).
+ */
+import type { ConnectionHandle } from '@deepseek-ai/dsh-api-remotes/client';
+import type { AccountStatus, DisplayUsage, UsageProviderId as ProviderId, ProviderStatus, StatusValue, UsageReadReason } from './rpc.js';
+export declare const POLL_MS: number;
+/** Usage of one account, or the failure that left it empty. */
+export type UsageEntry = {
+    kind: 'loading';
+} | {
+    kind: 'ready';
+    usage: DisplayUsage;
+    receivedAt: number;
+} | {
+    kind: 'error';
+    message: string;
+};
+export interface StoreSnapshot {
+    status: StatusValue | undefined;
+    statusError: string | undefined;
+    /** Keyed `${provider}/${account}`. */
+    usage: ReadonlyMap<string, UsageEntry>;
+    /** Accounts with a read in flight, keyed like `usage`. */
+    refreshing: ReadonlySet<string>;
+}
+export declare const usageKey: (provider: ProviderId, account: string) => string;
+export declare class SubscriptionsStore {
+    private readonly rpc;
+    private snapshot;
+    private readonly listeners;
+    private lastRevision;
+    private statusInFlight;
+    private timer;
+    /** The session the gauge is showing, so `status` reports its serving account. */
+    private sessionId;
+    constructor(rpc: ConnectionHandle['rpc']);
+    getSnapshot: () => StoreSnapshot;
+    subscribe: (listener: () => void) => (() => void);
+    /** Report the session whose serving account the `status` read should name. */
+    focusSession(sessionId: string | undefined): void;
+    /** Re-read login status; usage follows when the Host's revision moved. */
+    refreshStatus(): Promise<void>;
+    /** Read every signed-in account's usage under one reason. */
+    refreshUsage(reason: UsageReadReason, only?: ProviderId): Promise<void>;
+    private readStatus;
+    private readUsage;
+    private setUsage;
+    private publish;
+    private readonly onVisibility;
+    private start;
+    private stop;
+}
+/** The account a provider is using now: the one that served last, else the default, else the first. */
+export declare function activeAccountKey(status: ProviderStatus | undefined): string | undefined;
+/** The active account shown in full, and the others that fold behind one row. */
+export declare function splitAccounts(status: ProviderStatus): {
+    active: AccountStatus;
+    rest: AccountStatus[];
+} | undefined;