dsh-subscriptions 0.1.0

package/lib/client/ProviderModelEditor.js

@@ -0,0 +1,107 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { forwardRef, useEffect, useImperativeHandle, useRef, useState } from 'react';
+import { callSubscriptionsAuth } from './subscriptions-rpc.js';
+const border = '1px solid var(--dsw-alias-border-l2, #ddd)';
+const control = {
+    font: 'inherit', color: 'inherit', background: 'transparent', border,
+    borderRadius: 8, padding: '6px 10px', minWidth: 0,
+};
+const actions = { display: 'flex', flexWrap: 'wrap', gap: 8, alignItems: 'center' };
+/**
+ * Embedded section of the account manager dialog. It owns the model draft
+ * (visibility, effort, context, tools) but not its submission: the dialog
+ * collects the draft through the handle and saves it with the account edits
+ * in one go, so there is a single Save/Cancel pair.
+ */
+export const ProviderModelEditor = forwardRef(function ProviderModelEditor({ provider, rpc, t, disabled = false, onDirtyChange }, ref) {
+    const [catalog, setCatalog] = useState();
+    const [draft, setDraft] = useState({});
+    const [contexts, setContexts] = useState({});
+    const [efforts, setEfforts] = useState({});
+    const [query, setQuery] = useState('');
+    const [busy, setBusy] = useState(false);
+    const [dirty, setDirty] = useState(false);
+    const [error, setError] = useState('');
+    const generation = useRef(0);
+    useEffect(() => () => { generation.current++; }, []);
+    useEffect(() => { onDirtyChange?.(dirty); }, [dirty]);
+    function reset(data) {
+        setCatalog(data);
+        setDraft(data.settings);
+        setEfforts(Object.fromEntries(data.models.map(model => [model.id, model.configured ?? ''])));
+        setContexts(Object.fromEntries(Object.entries(data.settings.contextWindows ?? {}).map(([id, value]) => [id, String(value)])));
+        setDirty(false);
+    }
+    async function load(force = false) {
+        const request = ++generation.current;
+        setBusy(true);
+        setError('');
+        try {
+            const data = await callSubscriptionsAuth(rpc, provider === 'cursor-subscription' ? 'cursorSettings' : 'providerSettings', { provider, force });
+            if (generation.current === request)
+                reset(data);
+        }
+        catch (error) {
+            if (generation.current === request)
+                setError(String(error instanceof Error ? error.message : error));
+        }
+        finally {
+            if (generation.current === request)
+                setBusy(false);
+        }
+    }
+    function edit(next) { setDraft(next); setDirty(true); }
+    useEffect(() => { void load(); }, [provider, rpc]);
+    useImperativeHandle(ref, () => ({
+        collect() {
+            if (!catalog || !dirty)
+                return { efforts: [] };
+            const windows = Object.create(null);
+            for (const [model, text] of Object.entries(contexts)) {
+                if (!text.trim())
+                    continue;
+                const value = Number(text);
+                if (!/^\d+$/.test(text.trim()) || !Number.isSafeInteger(value) || value <= 0) {
+                    setError(t('modelsContextInvalid', { model }));
+                    return undefined;
+                }
+                windows[model] = value;
+            }
+            setError('');
+            const { accounts: _accounts, ...settings } = { ...draft, ...(provider === 'codex' ? { contextWindows: windows } : {}) };
+            return {
+                settings,
+                efforts: catalog.models.flatMap(model => {
+                    const effort = efforts[model.id] ?? '';
+                    return effort === (model.configured ?? '') || !model.efforts?.length ? [] : [{ model: model.id, effort }];
+                }),
+            };
+        },
+    }), [catalog, dirty, draft, contexts, efforts, provider]);
+    const allModels = catalog?.models ?? [];
+    const known = new Set(allModels.map(model => model.id));
+    const missing = (draft.visibleModels ?? []).filter(id => !known.has(id)).map(id => ({ id, name: id }));
+    const models = [...allModels, ...missing].filter(model => `${model.name} ${model.id}`.toLowerCase().includes(query.trim().toLowerCase()));
+    const selected = new Set(draft.visibleModels ?? allModels.map(model => model.id));
+    return _jsxs("div", { style: { borderTop: border, marginTop: 12, paddingTop: 12 }, children: [_jsx("h3", { style: { margin: 0, fontSize: 15 }, children: t('modelsEdit') }), _jsxs("div", { style: { display: 'grid', gap: 12, marginTop: 12 }, children: [_jsx("p", { style: { margin: 0 }, children: t(provider === 'cursor-subscription' ? 'cursorManageHint' : 'modelsHint') }), error && _jsx("p", { role: "alert", style: { margin: 0, color: 'var(--dsw-alias-state-error-primary, #b42318)' }, children: error }), _jsxs("div", { style: actions, children: [_jsx("button", { type: "button", style: control, disabled: busy || disabled || dirty, onClick: () => { void load(true); }, children: t('usageRefresh') }), busy && _jsx("span", { role: "status", children: t('modelDefaultsLoading') })] }), catalog && _jsxs("fieldset", { disabled: busy || disabled, style: { border: 0, padding: 0, margin: 0, minWidth: 0, display: 'grid', gap: 12 }, children: [_jsxs("label", { children: [_jsx("input", { type: "checkbox", checked: draft.visibleModels === undefined, onChange: event => {
+                                            const next = { ...draft };
+                                            if (event.target.checked)
+                                                delete next.visibleModels;
+                                            else
+                                                next.visibleModels = allModels.map(model => model.id);
+                                            edit(next);
+                                        } }), " ", t('modelsAutomatic')] }), _jsxs("div", { style: actions, children: [_jsx("input", { style: { ...control, flex: '1 1 180px' }, value: query, onChange: event => setQuery(event.target.value), placeholder: t('modelDefaultsFilterPlaceholder'), "aria-label": t('modelDefaultsFilterPlaceholder') }), _jsx("button", { type: "button", style: control, onClick: () => edit({ ...draft, visibleModels: allModels.map(model => model.id) }), children: t('modelsSelectAll') }), _jsx("button", { type: "button", style: control, onClick: () => edit({ ...draft, visibleModels: [] }), children: t('modelsSelectNone') })] }), _jsxs("div", { style: { maxHeight: 360, overflowY: 'auto', display: 'grid', gap: 8 }, children: [models.map(model => _jsxs("div", { style: { borderBottom: border, padding: '8px 2px', display: 'grid', gap: 8 }, children: [_jsxs("label", { style: { overflowWrap: 'anywhere' }, children: [_jsx("input", { type: "checkbox", checked: selected.has(model.id), onChange: event => {
+                                                            const next = new Set(selected);
+                                                            if (event.target.checked)
+                                                                next.add(model.id);
+                                                            else
+                                                                next.delete(model.id);
+                                                            edit({ ...draft, visibleModels: [...next] });
+                                                        } }), " ", model.name, !known.has(model.id) && ` (${t('modelsUnavailable')})`] }), _jsxs("div", { style: actions, children: [(model.efforts?.length ?? 0) > 0 && _jsxs("label", { style: actions, children: [t('modelDefaultsTitle'), _jsxs("select", { style: control, "aria-label": `${model.name} ${t('modelDefaultsTitle')}`, value: efforts[model.id] ?? '', onChange: event => {
+                                                                    setEfforts({ ...efforts, [model.id]: event.target.value });
+                                                                    setDirty(true);
+                                                                }, children: [_jsx("option", { value: "", children: t('modelDefaultsFollowProvider') }), model.configured && !model.efforts?.some(effort => effort.id === model.configured) &&
+                                                                        _jsxs("option", { value: model.configured, disabled: true, children: [model.configured, " (", t('modelsUnavailable'), ")"] }), model.efforts?.map(effort => _jsx("option", { value: effort.id, children: effort.name }, effort.id))] })] }), provider === 'codex' && model.maxContextWindow !== undefined && _jsxs("div", { style: actions, children: [_jsxs("label", { style: actions, children: [t('modelsContext'), _jsx("input", { style: { ...control, width: 140 }, inputMode: "numeric", value: contexts[model.id] ?? '', "aria-label": `${model.name} ${t('modelsContext')}`, placeholder: String(model.defaultContextWindow), onChange: event => { setContexts({ ...contexts, [model.id]: event.target.value }); setDirty(true); } })] }), _jsx("small", { children: t('modelsContextBounds', { default: model.defaultContextWindow, max: model.maxContextWindow }) })] })] })] }, model.id)), models.length === 0 && _jsx("span", { children: t('modelDefaultsFilterEmpty', { query }) })] }), provider === 'codex' && _jsx("small", { children: t('modelsContextHint') }), catalog.tools.length > 0 && _jsxs("div", { style: { display: 'grid', gap: 8 }, children: [_jsx("strong", { children: t('modelsTools') }), _jsx("small", { children: t('modelsToolsHint') }), catalog.tools.map(tool => _jsxs("label", { children: [_jsx("input", { type: "checkbox", checked: draft.tools?.[tool] !== false, onChange: event => edit({
+                                                    ...draft, tools: { ...draft.tools, [tool]: event.target.checked },
+                                                }) }), " ", t(tool === 'image_generate' ? 'modelsImage' : tool === 'video_generate' ? 'modelsVideo' : tool === 'web_search' ? 'modelsWebSearch' : 'modelsSearch')] }, tool))] })] })] })] });
+});

package/lib/client/SpeedSelect.d.ts

@@ -0,0 +1,71 @@
+import type { PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ConnectionHandle } from '@deepseek-ai/dsh-api-remotes/client';
+/** One session's speed choice: standard routing or the fast (priority) tier. */
+export type SpeedTier = 'standard' | 'fast';
+/** `speed` endpoint value, mirrored from the node half. */
+export interface SpeedState {
+    tier: SpeedTier;
+    fastModels: string[];
+}
+/** What {@link SpeedSelect} renders from: visibility plus the current tier. */
+export interface SpeedSelectState {
+    visible: boolean;
+    tier: SpeedTier;
+}
+/**
+ * Minimal structural face of ui-model-selection's `ctx.modelDirectories`
+ * service (the sanctioned cross-plugin channel: cordis services, not value
+ * imports — same mirroring discipline as ToolCallOwnerProps). Both dsh lines
+ * ship it with this shape; it replaces rc.2's `connection.api.sessions.models`
+ * read, which the 0.1.2-alpha removed along with the whole `.api` face.
+ */
+export interface ModelDirectoriesLike {
+    /** Resolve one session's shared model directory (throws for unknown sessions). */
+    directoryFor(sessionId: string): {
+        /** Load the directory; `current` is the session's effective model selection. */
+        load(): Promise<{
+            current: {
+                provider: string;
+                model: string;
+            } | null;
+        }>;
+    };
+}
+/** Injected dependencies of {@link SpeedSelect} (slot `inject`, session-bound). */
+export interface SpeedSelectInjected {
+    /** Load the session's speed state; `visible` false keeps the control hidden. */
+    loadSpeed: () => Promise<SpeedSelectState>;
+    /** Set the session's speed tier; resolves false when the write failed. */
+    setSpeed: (tier: SpeedTier) => Promise<boolean>;
+}
+/**
+ * Props delivered by the slot outlet: the framework session kit and InputZone
+ * owner share (unused — everything arrives session-bound through the inject
+ * face), the injected callbacks, and the locale seat.
+ */
+export type SpeedSelectProps = PropsRuntime<'conversation.input.right'> & Partial<SpeedSelectInjected> & Partial<PropsLocale<'settings.subscriptions'>>;
+/**
+ * The `loadSpeed` half of the inject face: the plugin's own speed state plus
+ * the host's current model selection (the visibility gate). A model-RPC
+ * failure throws rather than answering "hidden" — the caller keeps its last
+ * known state, so a transient failure never locks the toggle away.
+ *
+ * `sessionId` is a plain string: slot and command contexts brand it through
+ * different dsh-session copies, and only the service boundary needs one.
+ *
+ * `models` resolves lazily per call: the ui-model-selection service may
+ * register after this plugin applies, and a shell without it (no model seat
+ * at all) simply keeps the toggle hidden.
+ */
+export declare function createSpeedLoader(connection: ConnectionHandle, models: () => ModelDirectoriesLike | undefined, sessionId: string): SpeedSelectInjected['loadSpeed'];
+/** The `setSpeed` half of the inject face: boolean outcome for the component's busy state. */
+export declare function createSpeedSetter(connection: ConnectionHandle, sessionId: string): SpeedSelectInjected['setSpeed'];
+/**
+ * The composer Speed control: a trigger reading `速度 · 快速`/`速度 · 标准`
+ * that opens a two-row menu (standard/fast with descriptions, check mark on
+ * the current tier). The host pushes nothing on a model switch, so the
+ * control re-reads on a slow poll with a single-flight guard; a failed read
+ * keeps the last known state, so a transient RPC failure can never lock the
+ * toggle away (the earlier mount-only load had no recovery path).
+ */
+export declare function SpeedSelect({ loadSpeed, setSpeed, t }: SpeedSelectProps): import("react").JSX.Element | null;

package/lib/client/SpeedSelect.js

@@ -0,0 +1,177 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Codex Speed toggle: one small control in the composer's right tool row
+ * (`conversation.input.right`), switching the session between standard routing
+ * and the fast (priority) service tier — the Codex desktop app's Speed menu.
+ * The choice is per session and lives in the node half (in-memory); this
+ * component holds only viewing state. The control renders nothing until the
+ * first load proves the session's current model is a codex model whose catalog
+ * advertises the fast tier.
+ *
+ * Every color resolves through a `--dsw-alias-*` design token and every
+ * user-visible string goes through the locale `t` of the
+ * 'settings.subscriptions' namespace, same as the settings section.
+ */
+import { useEffect, useRef, useState } from 'react';
+import { callSubscriptionsAuth } from './SubscriptionsSection.js';
+import { en } from './locales.js';
+/**
+ * The `loadSpeed` half of the inject face: the plugin's own speed state plus
+ * the host's current model selection (the visibility gate). A model-RPC
+ * failure throws rather than answering "hidden" — the caller keeps its last
+ * known state, so a transient failure never locks the toggle away.
+ *
+ * `sessionId` is a plain string: slot and command contexts brand it through
+ * different dsh-session copies, and only the service boundary needs one.
+ *
+ * `models` resolves lazily per call: the ui-model-selection service may
+ * register after this plugin applies, and a shell without it (no model seat
+ * at all) simply keeps the toggle hidden.
+ */
+export function createSpeedLoader(connection, models, sessionId) {
+    return async () => {
+        const state = await callSubscriptionsAuth(connection.rpc, 'speed', { sessionId });
+        const directories = models();
+        if (directories === undefined)
+            return { visible: false, tier: state.tier };
+        const { current } = await directories.directoryFor(sessionId).load();
+        const visible = current !== null && current.provider === 'codex'
+            && state.fastModels.includes(current.model);
+        return { visible, tier: state.tier };
+    };
+}
+/** The `setSpeed` half of the inject face: boolean outcome for the component's busy state. */
+export function createSpeedSetter(connection, sessionId) {
+    return tier => callSubscriptionsAuth(connection.rpc, 'setSpeed', { sessionId, tier })
+        .then(() => true, () => false);
+}
+/** English-dictionary fallback for a missing inject `t` (standalone renders). */
+function fallbackTranslate(key) {
+    return en[key];
+}
+const TIERS = ['standard', 'fast'];
+/**
+ * The composer Speed control: a trigger reading `速度 · 快速`/`速度 · 标准`
+ * that opens a two-row menu (standard/fast with descriptions, check mark on
+ * the current tier). Mount and every open reload the host state so a model
+ * switch made since the last open self-corrects.
+ */
+/** How often the control re-reads the host state (model switches arrive only by asking). */
+const POLL_INTERVAL_MS = 3000;
+/**
+ * The composer Speed control: a trigger reading `速度 · 快速`/`速度 · 标准`
+ * that opens a two-row menu (standard/fast with descriptions, check mark on
+ * the current tier). The host pushes nothing on a model switch, so the
+ * control re-reads on a slow poll with a single-flight guard; a failed read
+ * keeps the last known state, so a transient RPC failure can never lock the
+ * toggle away (the earlier mount-only load had no recovery path).
+ */
+export function SpeedSelect({ loadSpeed, setSpeed, t }) {
+    const translate = t ?? fallbackTranslate;
+    const [state, setState] = useState(null);
+    const [open, setOpen] = useState(false);
+    const [busy, setBusy] = useState(false);
+    const rootRef = useRef(null);
+    // The inject face may be re-evaluated (new callback identities) on re-render;
+    // the poll effect mounts once and reads through this ref, so identity churn
+    // neither resets the interval nor multiplies in-flight loads.
+    const loadRef = useRef(loadSpeed);
+    loadRef.current = loadSpeed;
+    useEffect(() => {
+        if (loadRef.current === undefined)
+            return;
+        let cancelled = false;
+        let inflight = false;
+        const reload = () => {
+            const load = loadRef.current;
+            if (load === undefined || inflight)
+                return;
+            inflight = true;
+            void load().then((loaded) => { if (!cancelled)
+                setState(loaded); }, () => { }).finally(() => { inflight = false; });
+        };
+        reload();
+        const timer = setInterval(reload, POLL_INTERVAL_MS);
+        return () => {
+            cancelled = true;
+            clearInterval(timer);
+        };
+    }, []);
+    useEffect(() => {
+        if (!open)
+            return;
+        const closeOutside = (event) => {
+            if (!rootRef.current?.contains(event.target))
+                setOpen(false);
+        };
+        document.addEventListener('mousedown', closeOutside);
+        return () => { document.removeEventListener('mousedown', closeOutside); };
+    }, [open]);
+    if (loadSpeed === undefined || setSpeed === undefined || state === null || !state.visible) {
+        return null;
+    }
+    const choose = (tier) => {
+        if (busy)
+            return;
+        if (tier === state.tier) {
+            setOpen(false);
+            return;
+        }
+        setBusy(true);
+        void setSpeed(tier).then((ok) => {
+            setBusy(false);
+            if (ok) {
+                setState({ visible: true, tier });
+                setOpen(false);
+            }
+        });
+    };
+    const show = () => {
+        setOpen(true);
+        const load = loadRef.current;
+        if (load === undefined)
+            return;
+        void load().then(setState, () => { });
+    };
+    const tierName = (tier) => translate(tier === 'fast' ? 'speedFast' : 'speedStandard');
+    const tierDescription = (tier) => translate(tier === 'fast' ? 'speedFastDescription' : 'speedStandardDescription');
+    const triggerLabel = `${translate('speed')} · ${tierName(state.tier)}`;
+    return (_jsxs("div", { ref: rootRef, style: styles.root, onKeyDown: (event) => {
+            if (event.key === 'Escape' && open) {
+                event.preventDefault();
+                setOpen(false);
+            }
+        }, children: [open && (_jsx("div", { style: styles.menu, role: "menu", "aria-label": translate('speed'), children: TIERS.map(tier => (_jsxs("button", { type: "button", role: "menuitemradio", "aria-checked": tier === state.tier, style: styles.item, disabled: busy, onClick: () => { choose(tier); }, children: [_jsx("span", { style: styles.itemCheck, children: tier === state.tier ? '✓' : '' }), _jsxs("span", { style: styles.itemText, children: [_jsx("span", { style: styles.itemName, children: tierName(tier) }), _jsx("span", { style: styles.itemDescription, children: tierDescription(tier) })] })] }, tier))) })), _jsx("button", { type: "button", style: styles.trigger, "aria-haspopup": "menu", "aria-expanded": open, title: triggerLabel, disabled: busy, onClick: () => {
+                    if (open)
+                        setOpen(false);
+                    else
+                        show();
+                }, children: triggerLabel })] }));
+}
+const styles = {
+    root: { position: 'relative', display: 'inline-flex' },
+    trigger: {
+        border: '1px solid var(--dsw-alias-border-l2)', borderRadius: 8,
+        background: 'transparent', color: 'var(--dsw-alias-label-secondary)',
+        font: 'inherit', fontSize: 12, lineHeight: '18px',
+        padding: '2px 8px', cursor: 'pointer', whiteSpace: 'nowrap',
+    },
+    menu: {
+        position: 'absolute', bottom: '100%', right: 0, marginBottom: 4,
+        minWidth: 180, padding: 4, zIndex: 20,
+        background: 'var(--dsw-alias-bg-layer-1)', border: '1px solid var(--dsw-alias-border-l2)',
+        borderRadius: 8, display: 'flex', flexDirection: 'column', gap: 2,
+    },
+    item: {
+        display: 'flex', alignItems: 'flex-start', gap: 6, width: '100%',
+        border: 'none', borderRadius: 6, background: 'transparent',
+        padding: '6px 8px', cursor: 'pointer', font: 'inherit', textAlign: 'left',
+    },
+    itemCheck: {
+        width: 14, flexShrink: 0, fontSize: 12, lineHeight: '18px',
+        color: 'var(--dsw-alias-label-primary)',
+    },
+    itemText: { display: 'flex', flexDirection: 'column' },
+    itemName: { fontSize: 12, lineHeight: '18px', color: 'var(--dsw-alias-label-primary)' },
+    itemDescription: { fontSize: 11, lineHeight: '16px', color: 'var(--dsw-alias-label-tertiary)' },
+};

package/lib/client/SubscriptionUsageBadge.d.ts

@@ -0,0 +1,116 @@
+import type { ComponentType } from 'react';
+import type { PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ConnectionHandle } from '@deepseek-ai/dsh-api-remotes/client';
+import type { AccountStatus, ProviderUsage, SubscriptionProvider, UsageWindow } from './SubscriptionsSection.js';
+import type { ModelDirectoriesLike } from './SpeedSelect.js';
+import type { SubscriptionsKey } from './locales.js';
+/** DSH renamed the data icon in 0.1.7; retain older supported hosts too. */
+export declare function usageBadgeIcon(icons: {
+    IconDataOutlineRegular?: ComponentType;
+    IconDataOutline16?: ComponentType;
+}): ComponentType;
+/** Injected dependencies (slot `inject`, session-bound). */
+export interface SubscriptionUsageBadgeInjected {
+    /** Connection RPC caller to reach the `subscriptions-auth` endpoints. */
+    rpc: ConnectionHandle['rpc'];
+    /** Resolve the session's effective provider and model together. */
+    currentModel: () => Promise<{
+        provider: string;
+        model: string;
+    } | undefined>;
+}
+/** Props delivered by the slot outlet + inject + the locale seat. */
+export type SubscriptionUsageBadgeProps = PropsRuntime<'conversation.composer.dock'> & Partial<SubscriptionUsageBadgeInjected> & Partial<PropsLocale<'settings.subscriptions'>>;
+/** One logged-in account's usage windows, as listed in the expanded dialog. */
+export interface AccountUsageDisplay {
+    /** Account key (the `usage` endpoint's `account` argument). */
+    key: string;
+    /** Display handle (email / login), when the provider reports one. */
+    account?: string;
+    plan?: string;
+    /** The account direct routes serve; the collapsed pill reads this one. */
+    isDefault: boolean;
+    windows: UsageWindow[];
+}
+/** One provider's usage snapshot: every logged-in account that reports windows. */
+export interface ProviderUsageDisplay {
+    provider: BadgeProvider;
+    name: string;
+    /** Default account first, then the rest in the `status` endpoint's order. */
+    accounts: AccountUsageDisplay[];
+}
+/** The account the collapsed pill reads: the default one, else the first listed. */
+export declare function pillAccountOf(d: ProviderUsageDisplay): AccountUsageDisplay;
+/** Brand display names (short form for the compact badge). */
+export type BadgeProvider = SubscriptionProvider | 'cursor-subscription' | 'opencode-go' | 'kimi-coding';
+export interface UsageRosterEntry {
+    provider: BadgeProvider;
+    account: AccountStatus;
+}
+/**
+ * Group per-account usage into the badge's provider rows, in roster order
+ * (the `status` provider order, default account first) so rows don't jump
+ * around as polls settle at different times. An account without windows is
+ * left out, and so is a provider whose accounts all lack windows.
+ * @param roster - accounts from {@link loadBadgeRoster}.
+ * @param windowsOf - each account's windows, keyed `provider:accountKey`.
+ * @param plans - the plan each usage call reported, same keys; the roster's plan is the fallback.
+ * @returns one display per provider with at least one account that has windows.
+ */
+export declare function groupUsageDisplays(roster: readonly UsageRosterEntry[], windowsOf: ReadonlyMap<string, UsageWindow[]>, plans: ReadonlyMap<string, string>): ProviderUsageDisplay[];
+/** Read each account source independently so a failing endpoint cannot hide the others. */
+export declare function loadBadgeRoster(rpc: ConnectionHandle['rpc']): Promise<{
+    roster: UsageRosterEntry[];
+    refreshed: Set<BadgeProvider>;
+}>;
+export declare function usageOf(rpc: ConnectionHandle['rpc'], { provider, account }: UsageRosterEntry): Promise<ProviderUsage>;
+/**
+ * The `currentModel` half of the inject face: the session's effective
+ * model selection through ui-model-selection's `modelDirectories` service,
+ * resolved lazily per call (the service may register after this plugin, and
+ * a shell without it reports "unknown"; the badge keeps the most recent
+ * subscription selected in this view, or stays hidden).
+ */
+export declare function createCurrentModelReader(models: () => ModelDirectoriesLike | undefined, sessionId: string): SubscriptionUsageBadgeInjected['currentModel'];
+/**
+ * Compact time-remaining label derived from the window's `resetsAt` timestamp:
+ * "6d18h" (days+hours), "1h58m" (hours+minutes), or "42m" (minutes only).
+ * Falls back to the scope/kind abbreviation when no reset time is known.
+ */
+export declare function windowLabel(w: UsageWindow): string;
+/** Keep model quotas separate: matching percentages do not imply a shared pool. */
+export declare function prioritizeWindows(windows: readonly UsageWindow[], model?: string): UsageWindow[];
+/** Small previews keep a live model catalog from taking over the dialog. */
+export declare const WINDOW_PREVIEW_LIMIT = 4;
+export declare function previewWindows(windows: readonly UsageWindow[], model?: string, provider?: BadgeProvider): {
+    shown: UsageWindow[];
+    hidden: UsageWindow[];
+};
+/** Bounded readout; Antigravity quotas belong to individual models, not the account. */
+export declare function compactSegment(d: ProviderUsageDisplay, model?: string, t?: Translate): string;
+type ModelSelection = {
+    provider: string;
+    model: string;
+};
+/** Remember only the most recent subscription in this view, including its model scope. */
+export declare function retainSubscriptionSelection(previous: ModelSelection | undefined, current: ModelSelection | undefined): ModelSelection | undefined;
+/** At most one provider; no known selection or no usage means no badge. */
+export declare function collapsedDisplays(displays: readonly ProviderUsageDisplay[], current: string | undefined): readonly ProviderUsageDisplay[];
+/** Order for the expanded dialog: the current provider first, the rest in poll order. */
+export declare function expandedDisplays(displays: readonly ProviderUsageDisplay[], current: string | undefined): readonly ProviderUsageDisplay[];
+type Translate = (key: SubscriptionsKey, params?: Record<string, unknown>) => string;
+/**
+ * The composer subscription-usage badge: a pill reading e.g.
+ * `Codex 6d1h 25%` for the current model's provider, opening a dialog with
+ * every provider's accounts and their windows. Returns null when no data is
+ * available.
+ */
+export declare function SubscriptionUsageBadge({ rpc, currentModel, t }: SubscriptionUsageBadgeProps): import("react").JSX.Element;
+/** Preview each account independently; all remaining quotas stay accessible. */
+export declare function AccountWindows({ windows, model, provider, translate }: {
+    windows: readonly UsageWindow[];
+    model: string | undefined;
+    provider?: BadgeProvider;
+    translate: Translate;
+}): import("react").JSX.Element;
+export {};