dsh-plugin-subscription-oauth 0.4.0 → 0.6.0

package/lib/auth/ccswitch.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The cc-switch balance query, reimplemented for the plugin's node half.
+ *
+ * cc-switch (github.com/farion1231/cc-switch) reads a DeepSeek-compatible provider's
+ * balance with `GET https://api.deepseek.com/user/balance`, an `Authorization: Bearer
+ * <api key>` header, and a 15 s timeout. This is that request, with the URL hardcoded
+ * exactly as cc-switch does — the provider's own base URL is never substituted in.
+ *
+ * The endpoint answers `{ is_available, balance_infos: [{ currency, total_balance, … }] }`,
+ * where a balance is a number or a numeric string. The module reduces that to the one
+ * figure a status chip needs: the first currency's total. Anything else — a missing key,
+ * a non-2xx answer, malformed JSON — resolves to nothing, so the caller shows no balance
+ * rather than a wrong one.
+ *
+ * @module dsh-plugin-subscription-oauth/auth/ccswitch
+ */
+import type { FetchFn } from '../http.js';
+/** One currency's balance, normalised from the endpoint's answer. */
+export interface CcSwitchBalance {
+    /** The currency the balance is denominated in. */
+    currency: string;
+    /** The remaining balance, as a decimal string. */
+    total: string;
+    /** Whether the account reports itself as usable. */
+    available: boolean;
+}
+/**
+ * Query one provider's balance the way cc-switch does.
+ *
+ * @param input - the provider's API key, and optionally a fetch to substitute in tests.
+ * @returns the balance, or undefined when the provider did not answer with one.
+ */
+export declare function queryCcSwitchBalance(input: {
+    apiKey: string;
+    fetchFn?: FetchFn;
+}): Promise<CcSwitchBalance | undefined>;

package/lib/auth/ccswitch.js

@@ -0,0 +1,75 @@
+/**
+ * The cc-switch balance query, reimplemented for the plugin's node half.
+ *
+ * cc-switch (github.com/farion1231/cc-switch) reads a DeepSeek-compatible provider's
+ * balance with `GET https://api.deepseek.com/user/balance`, an `Authorization: Bearer
+ * <api key>` header, and a 15 s timeout. This is that request, with the URL hardcoded
+ * exactly as cc-switch does — the provider's own base URL is never substituted in.
+ *
+ * The endpoint answers `{ is_available, balance_infos: [{ currency, total_balance, … }] }`,
+ * where a balance is a number or a numeric string. The module reduces that to the one
+ * figure a status chip needs: the first currency's total. Anything else — a missing key,
+ * a non-2xx answer, malformed JSON — resolves to nothing, so the caller shows no balance
+ * rather than a wrong one.
+ *
+ * @module dsh-plugin-subscription-oauth/auth/ccswitch
+ */
+import { proxiedFetch } from '../http.js';
+/** Read a balance field that may be a number or a numeric string. */
+function num(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return String(value);
+    if (typeof value === 'string' && value.trim() !== '' && Number.isFinite(Number(value)))
+        return value.trim();
+    return undefined;
+}
+/**
+ * Query one provider's balance the way cc-switch does.
+ *
+ * @param input - the provider's API key, and optionally a fetch to substitute in tests.
+ * @returns the balance, or undefined when the provider did not answer with one.
+ */
+export async function queryCcSwitchBalance(input) {
+    const fetchFn = input.fetchFn ?? proxiedFetch;
+    let response;
+    try {
+        // cc-switch's exact request shape: hardcoded URL, bearer auth, 15 s timeout.
+        response = await fetchFn('https://api.deepseek.com/user/balance', {
+            headers: { authorization: `Bearer ${input.apiKey}`, accept: 'application/json' },
+            signal: AbortSignal.timeout(15_000),
+        });
+    }
+    catch {
+        return undefined;
+    }
+    if (!response.ok)
+        return undefined;
+    let payload;
+    try {
+        payload = await response.json();
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof payload !== 'object' || payload === null)
+        return undefined;
+    const record = payload;
+    const infos = record.balance_infos;
+    if (!Array.isArray(infos))
+        return undefined;
+    for (const raw of infos) {
+        if (typeof raw !== 'object' || raw === null)
+            continue;
+        const info = raw;
+        const total = num(info.total_balance);
+        if (total === undefined)
+            continue;
+        const currency = typeof info.currency === 'string' && info.currency.trim() !== '' ? info.currency.trim() : 'CNY';
+        return {
+            currency,
+            total,
+            available: record.is_available !== false,
+        };
+    }
+    return undefined;
+}

package/lib/auth/deepseek-balance.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The DeepSeek account's balance, read on the node half.
+ *
+ * The host owns the DeepSeek OAuth grant and its platform endpoint, and exposes a
+ * `deepseekAccount` service with a `getBalance(client)`. The browser cannot call that
+ * service directly — it lives behind the host's Remote controller, not a `/api` fetch
+ * route — so this plugin's node half reads it and serves it over the plugin's own RPC,
+ * the same channel the rest of the chip's data already travels on.
+ *
+ * @module dsh-plugin-subscription-oauth/auth/deepseek-balance
+ */
+import type { FetchFn } from '../http.js';
+/** One currency's wallet, as the platform reports it. */
+export interface DeepSeekWallet {
+    /** ISO currency the balance is denominated in. */
+    currency: 'CNY' | 'USD' | string;
+    /** Remaining balance, as a decimal string. */
+    balance: string;
+}
+/** The DeepSeek account's wallets, normal and bonus. */
+export interface DeepSeekBalance {
+    /** Normal (topped-up) wallets, one per currency. */
+    wallets: readonly DeepSeekWallet[];
+    /** Bonus / promotional wallets, one per currency. */
+    bonusWallets: readonly DeepSeekWallet[];
+}
+/**
+ * The slice of the host's `deepseekAccount` service this module reads.
+ *
+ * Declared locally rather than imported: the host package's published typings differ
+ * across DSH lines, and this plugin only needs this one method.
+ */
+export interface DeepSeekAccountService {
+    getBalance: (client: unknown) => Promise<unknown>;
+}
+/**
+ * Read the DeepSeek account's balance through the host's service.
+ *
+ * @param account - the host's `deepseekAccount` service, when the composition provides
+ * one.
+ * @param client - the client metadata the service expects.
+ * @returns the balance, or undefined when the account is signed out or the read failed.
+ */
+export declare function readDeepSeekBalance(account: DeepSeekAccountService | undefined, client: unknown): Promise<DeepSeekBalance | undefined>;
+/**
+ * Reduce the host service's answer to the wallets the chip shows.
+ *
+ * The service resolves `null` when the account is signed out, `{ status: 'failed' }`
+ * when the read did not complete, and `{ status: 'ready', value: <normal>, bonusWallets }`
+ * on success. Anything else — an unexpected shape from a newer host — is nothing rather
+ * than a wrong figure.
+ *
+ * @param value - the service's raw answer.
+ * @returns the wallets, or undefined when there is nothing usable.
+ */
+export declare function normalizeDeepSeekBalance(value: unknown): DeepSeekBalance | undefined;
+/** A fetch substitute is accepted for symmetry with the other balance readers. */
+export type { FetchFn };

package/lib/auth/deepseek-balance.js

@@ -0,0 +1,63 @@
+/**
+ * The DeepSeek account's balance, read on the node half.
+ *
+ * The host owns the DeepSeek OAuth grant and its platform endpoint, and exposes a
+ * `deepseekAccount` service with a `getBalance(client)`. The browser cannot call that
+ * service directly — it lives behind the host's Remote controller, not a `/api` fetch
+ * route — so this plugin's node half reads it and serves it over the plugin's own RPC,
+ * the same channel the rest of the chip's data already travels on.
+ *
+ * @module dsh-plugin-subscription-oauth/auth/deepseek-balance
+ */
+import { proxiedFetch } from '../http.js';
+/**
+ * Read the DeepSeek account's balance through the host's service.
+ *
+ * @param account - the host's `deepseekAccount` service, when the composition provides
+ * one.
+ * @param client - the client metadata the service expects.
+ * @returns the balance, or undefined when the account is signed out or the read failed.
+ */
+export async function readDeepSeekBalance(account, client) {
+    if (account === undefined)
+        return undefined;
+    let result;
+    try {
+        result = await account.getBalance(client);
+    }
+    catch {
+        return undefined;
+    }
+    return normalizeDeepSeekBalance(result);
+}
+/**
+ * Reduce the host service's answer to the wallets the chip shows.
+ *
+ * The service resolves `null` when the account is signed out, `{ status: 'failed' }`
+ * when the read did not complete, and `{ status: 'ready', value: <normal>, bonusWallets }`
+ * on success. Anything else — an unexpected shape from a newer host — is nothing rather
+ * than a wrong figure.
+ *
+ * @param value - the service's raw answer.
+ * @returns the wallets, or undefined when there is nothing usable.
+ */
+export function normalizeDeepSeekBalance(value) {
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const record = value;
+    if (record.status !== 'ready')
+        return undefined;
+    if (!Array.isArray(record.value))
+        return undefined;
+    const wallets = record.value.filter(isWallet);
+    const bonusRaw = record.bonusWallets;
+    const bonusWallets = Array.isArray(bonusRaw) ? bonusRaw.filter(isWallet) : [];
+    return { wallets, bonusWallets };
+}
+/** Narrow one entry to a wallet shape. */
+function isWallet(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const record = value;
+    return typeof record.currency === 'string' && typeof record.balance === 'string';
+}

package/lib/auth/rpc.d.ts

@@ -1,3 +1,32 @@
+/**
+ * How one named credential resolves to a value.
+ *
+ * The host's credential service owns this; the RPC layer only calls it, so the balance
+ * query does not re-derive how a key is stored.
+ */
+export type CredentialResolver = (ref: string) => Promise<string | undefined>;
+/**
+ * The balance a non-subscription provider reports, and how to read it.
+ *
+ * A provider that is not a subscription this plugin serves has no usage windows, so the
+ * chip shows its balance instead. The balance is read by cc-switch's query, which needs
+ * the provider's API key; the provider's profile names that key by reference
+ * (`apiKeyEnv`), and this map is the one place a provider id is tied to that reference.
+ */
+export interface BalanceContext {
+    /** The credential reference each provider id's balance query uses. */
+    readonly credentialRefs: Readonly<Record<string, string>>;
+    /** Resolve one credential reference to its key. */
+    readonly resolveCredential?: CredentialResolver;
+    /**
+     * Resolve the host's DeepSeek account service, read lazily per request.
+     *
+     * The service may register after this plugin applies, so it is resolved when a
+     * balance is actually read, not once at startup. Returns undefined when the
+     * composition has no such service.
+     */
+    readonly resolveDeepSeekAccount?: () => DeepSeekAccountService | undefined;
+}
 /**
  * The host-side transport behind the Settings page.
  *
@@ -10,6 +39,7 @@
  * @module dsh-plugin-subscription-oauth/auth/rpc
  */
 import type { Context } from '@deepseek-ai/cordis';
+import type { DeepSeekAccountService } from './deepseek-balance.js';
 import type { RpcResult } from '../protocol.js';
 import type { SubscriptionRegistry } from './registry.js';
 /**
@@ -21,11 +51,11 @@ import type { SubscriptionRegistry } from './registry.js';
  * @param payload - the request's decoded payload.
  * @returns the envelope result.
  */
-export declare function dispatchRpc(registry: SubscriptionRegistry, endpoint: string, payload: unknown): Promise<RpcResult>;
+export declare function dispatchRpc(registry: SubscriptionRegistry, endpoint: string, payload: unknown, balance?: BalanceContext): Promise<RpcResult>;
 /**
  * Register every endpoint route on the `connection` service, when one exists.
  *
  * @param ctx - the plugin's context.
  * @param registry - the provider routes every route dispatches through.
  */
-export declare function registerSubscriptionRpc(ctx: Context, registry: SubscriptionRegistry): void;
+export declare function registerSubscriptionRpc(ctx: Context, registry: SubscriptionRegistry, balance?: BalanceContext): void;

package/lib/auth/rpc.js

@@ -1,15 +1,6 @@
-/**
- * The host-side transport behind the Settings page.
- *
- * Each endpoint is served as its own `POST /api/subscription-oauth.<endpoint>`
- * Fetch route on the `connection` service. `connection` is deliberately not in
- * the plugin's `inject` list: a headless composition has no connection service,
- * and the provider routes must still work there. Nothing else is registered
- * when it is absent, so the browser half simply finds no routes.
- *
- * @module dsh-plugin-subscription-oauth/auth/rpc
- */
 import { BAD_REQUEST, ProviderError } from '../errors.js';
+import { queryCcSwitchBalance } from './ccswitch.js';
+import { readDeepSeekBalance } from './deepseek-balance.js';
 import { RPC_ENDPOINTS, RPC_PREFIX } from '../protocol.js';
 /** Wrap a value as a successful envelope result. */
 function success(value) {
@@ -42,6 +33,25 @@ function stringField(payload, field) {
     const trimmed = value.trim();
     return trimmed.length === 0 ? undefined : trimmed;
 }
+/**
+ * Read the client metadata a balance endpoint forwards to the host service.
+ *
+ * The host's account service expects a version / locale / timezone object; a missing or
+ * partial one is tolerated by building a default rather than failing the read.
+ *
+ * @param payload - the request payload.
+ * @returns the client metadata object.
+ */
+function payloadClient(payload) {
+    const record = typeof payload === 'object' && payload !== null ? payload : {};
+    return {
+        version: typeof record.version === 'string' ? record.version : '1',
+        locale: typeof record.locale === 'string' ? record.locale : 'en-US',
+        timezoneOffsetSeconds: typeof record.timezoneOffsetSeconds === 'number'
+            ? record.timezoneOffsetSeconds
+            : 0,
+    };
+}
 /** Read a boolean field from a payload, defaulting to false when absent. */
 function booleanField(payload, field) {
     if (typeof payload !== 'object' || payload === null)
@@ -85,9 +95,9 @@ function requiredProvider(payload, endpoint) {
  * @param payload - the request's decoded payload.
  * @returns the envelope result.
  */
-export async function dispatchRpc(registry, endpoint, payload) {
+export async function dispatchRpc(registry, endpoint, payload, balance) {
     try {
-        return success(await runEndpoint(registry, endpoint, payload));
+        return success(await runEndpoint(registry, endpoint, payload, balance));
     }
     catch (error) {
         return failure(error);
@@ -97,7 +107,7 @@ export async function dispatchRpc(registry, endpoint, payload) {
  * The endpoint table.
  * @throws {ProviderError} for a request the registry refuses.
  */
-async function runEndpoint(registry, endpoint, payload) {
+async function runEndpoint(registry, endpoint, payload, balance) {
     switch (endpoint) {
         case 'status':
             return registry.status();
@@ -145,6 +155,30 @@ async function runEndpoint(registry, endpoint, payload) {
         }
         case 'usage':
             return registry.usage(requiredProvider(payload, endpoint), booleanField(payload, 'force'));
+        case 'deepseek-balance': {
+            // The DeepSeek account's balance, read on the node half through the host's own
+            // account service. The browser cannot call that service directly (it sits behind
+            // the host's Remote controller, not a /api fetch route), so the node half reads it
+            // and serves it here, on the same channel as the rest of the chip's data. The
+            // service is resolved lazily, per request, because it may register after apply.
+            const client = payloadClient(payload);
+            return await readDeepSeekBalance(balance?.resolveDeepSeekAccount?.(), client);
+        }
+        case 'ccswitch-balance': {
+            // A non-subscription provider's balance, by cc-switch's query. The caller names
+            // the provider; the configured map turns that into the credential reference the
+            // provider's profile uses, and the host's credential service resolves it. No
+            // entry, no key, or a key the provider does not answer for means no balance —
+            // never a fabricated zero.
+            const provider = requiredProvider(payload, endpoint);
+            const credentialRef = balance?.credentialRefs[provider];
+            if (credentialRef === undefined || balance?.resolveCredential === undefined)
+                return undefined;
+            const apiKey = await balance.resolveCredential(credentialRef);
+            if (apiKey === undefined)
+                return undefined;
+            return await queryCcSwitchBalance({ apiKey });
+        }
         case 'reload':
             return registry.reload();
         default:
@@ -152,7 +186,7 @@ async function runEndpoint(registry, endpoint, payload) {
     }
 }
 /** Build the Fetch route for one endpoint. */
-function rpcRoute(endpoint, registry) {
+function rpcRoute(endpoint, registry, balance) {
     const method = `${RPC_PREFIX}${endpoint}`;
     return {
         path: `/api/${method}`,
@@ -176,7 +210,7 @@ function rpcRoute(endpoint, registry) {
             if (envelopeRequest.type !== 'client-request' || envelopeRequest.method !== method) {
                 return rejection(rpcId, 'gateway/bad-request', `${method} received an envelope for another method`, 400);
             }
-            return envelope(rpcId, await dispatchRpc(registry, endpoint, envelopeRequest.payload));
+            return envelope(rpcId, await dispatchRpc(registry, endpoint, envelopeRequest.payload, balance));
         },
     };
 }
@@ -186,7 +220,7 @@ function rpcRoute(endpoint, registry) {
  * @param ctx - the plugin's context.
  * @param registry - the provider routes every route dispatches through.
  */
-export function registerSubscriptionRpc(ctx, registry) {
+export function registerSubscriptionRpc(ctx, registry, balance) {
     ctx.inject(['connection'], (connectionCtx) => {
         const connection = connectionCtx.get('connection');
         if (connection === undefined)
@@ -194,7 +228,7 @@ export function registerSubscriptionRpc(ctx, registry) {
         const register = (route) => connection.fetch.register(route);
         for (const endpoint of RPC_ENDPOINTS) {
             const method = `${RPC_PREFIX}${endpoint}`;
-            connectionCtx.effect(() => register(rpcRoute(endpoint, registry)), `dsh-plugin-subscription-oauth: /api/${method} route`);
+            connectionCtx.effect(() => register(rpcRoute(endpoint, registry, balance)), `dsh-plugin-subscription-oauth: /api/${method} route`);
         }
     });
 }

package/lib/client/UsageChip.d.ts

@@ -17,7 +17,7 @@
  */
 import type { ReactNode } from 'react';
 import type { SessionStandardProps } from '@deepseek-ai/dsh-client-ui-slots';
-import type { SubscriptionsCall } from './subscriptions-rpc.js';
+import type { SubscriptionsCall, AccountBalanceCall, CcSwitchBalanceCall } from './subscriptions-rpc.js';
 import type { ProviderUsage, UsageWindow } from '../protocol.js';
 /** Injected props the chip is registered with. */
 export interface UsageChipInjected {
@@ -27,6 +27,24 @@ export interface UsageChipInjected {
     t: (key: 'usageChipTitle' | 'usageChipFull', values?: Record<string, string | number>) => string;
     /** Whether the provider is one this plugin serves. */
     isOwnProvider: (provider: string) => boolean;
+    /**
+     * The DeepSeek account's balance, when the session uses it.
+     *
+     * The host owns that account's grant and the platform endpoint, so the chip asks the
+     * host rather than re-deriving either. It resolves to `undefined` when the account is
+     * signed out or the read fails, in which case the chip stays silent.
+     */
+    accountBalance: AccountBalanceCall;
+    /**
+     * A non-subscription provider's balance, by cc-switch's query.
+     *
+     * A provider that is not a subscription this plugin serves has no usage windows to
+     * meter, so the chip shows its balance instead. The caller names the provider; the
+     * server maps it to the credential reference the provider's profile names (`apiKeyEnv`),
+     * resolves that to the API key, and asks cc-switch's balance endpoint. It resolves to
+     * `undefined` when the provider has no balance source or did not answer.
+     */
+    ccSwitchBalance: CcSwitchBalanceCall;
 }
 /** One model choice, as the host records it. */
 export interface ModelSelection {
@@ -65,6 +83,46 @@ export interface ChipReading {
     /** Plan name, when the provider stated one. */
     plan?: string;
 }
+/** One currency's balance, as the host's account controller reports it. */
+export interface ChipBalance {
+    /** The wallet's currency. */
+    currency: string;
+    /** Remaining balance, as a decimal string. */
+    balance: string;
+    /** Whether this is a bonus / promotional wallet rather than topped-up credit. */
+    bonus: boolean;
+}
+/**
+ * Reduce the node half's balance payload to the wallets the chip shows.
+ *
+ * Bonus wallets are shown after the topped-up ones, so a reader sees their own credit
+ * first and any promotional credit as a secondary figure. A bonus wallet that holds
+ * nothing is dropped rather than shown as `+¥0`: the platform reports one for every
+ * currency whether or not there is a bonus, and an empty one is noise, not information.
+ *
+ * @param value - the node half's balance, or undefined when there is none.
+ * @returns the wallets, topped-up first then bonus, or undefined when nothing is usable.
+ */
+export declare function balanceOf(value: {
+    wallets?: readonly {
+        currency: string;
+        balance: string;
+    }[];
+    bonusWallets?: readonly {
+        currency: string;
+        balance: string;
+    }[];
+} | null | undefined): readonly ChipBalance[] | undefined;
+/**
+ * Format one wallet for the chip's compact line.
+ *
+ * A balance is money, not a percentage, so it renders as `¥6.89` rather than a meter;
+ * the currency prefix keeps two currencies from being mistaken for one sum.
+ *
+ * @param wallet - the wallet to show.
+ * @returns the short form, e.g. `¥6.89` or `+¥2` for a bonus wallet.
+ */
+export declare function formatBalance(wallet: ChipBalance): string;
 /**
  * The short form of a route's name.
  *
@@ -117,4 +175,4 @@ export declare function formatReset(at: number | undefined, now: number): string
  * @param props - injected RPC caller, copy, and the session's provider reader.
  * @returns the chip, or null when there is nothing true to say.
  */
-export declare function UsageChip({ call, t, isOwnProvider, useProjection }: UsageChipInjected & SessionStandardProps): ReactNode;
+export declare function UsageChip({ call, t, isOwnProvider, accountBalance, ccSwitchBalance, useProjection }: UsageChipInjected & SessionStandardProps): ReactNode;

package/lib/client/UsageChip.js

@@ -55,6 +55,44 @@ const SHORT_WINDOWS = {
 export function providerOf(projection) {
     return (projection?.next ?? projection?.lastUsed)?.provider;
 }
+/**
+ * Reduce the node half's balance payload to the wallets the chip shows.
+ *
+ * Bonus wallets are shown after the topped-up ones, so a reader sees their own credit
+ * first and any promotional credit as a secondary figure. A bonus wallet that holds
+ * nothing is dropped rather than shown as `+¥0`: the platform reports one for every
+ * currency whether or not there is a bonus, and an empty one is noise, not information.
+ *
+ * @param value - the node half's balance, or undefined when there is none.
+ * @returns the wallets, topped-up first then bonus, or undefined when nothing is usable.
+ */
+export function balanceOf(value) {
+    if (value === null || value === undefined)
+        return undefined;
+    const wallets = [
+        ...(value.wallets ?? []).map((wallet) => ({ currency: wallet.currency, balance: wallet.balance, bonus: false })),
+        // Only a bonus wallet that actually holds something is worth a line.
+        ...(value.bonusWallets ?? [])
+            .filter((wallet) => Number.parseFloat(wallet.balance) > 0)
+            .map((wallet) => ({ currency: wallet.currency, balance: wallet.balance, bonus: true })),
+    ];
+    return wallets.length === 0 ? undefined : wallets;
+}
+/**
+ * Format one wallet for the chip's compact line.
+ *
+ * A balance is money, not a percentage, so it renders as `¥6.89` rather than a meter;
+ * the currency prefix keeps two currencies from being mistaken for one sum.
+ *
+ * @param wallet - the wallet to show.
+ * @returns the short form, e.g. `¥6.89` or `+¥2` for a bonus wallet.
+ */
+export function formatBalance(wallet) {
+    const amount = Number.parseFloat(wallet.balance);
+    const trimmed = Number.isFinite(amount) ? String(Math.round(amount * 100) / 100) : wallet.balance;
+    const symbol = wallet.currency === 'CNY' ? '¥' : wallet.currency === 'USD' ? '$' : `${wallet.currency} `;
+    return `${wallet.bonus ? '+' : ''}${symbol}${trimmed}`;
+}
 /**
  * The short form of a route's name.
  *
@@ -157,8 +195,10 @@ export function formatReset(at, now) {
  * @param props - injected RPC caller, copy, and the session's provider reader.
  * @returns the chip, or null when there is nothing true to say.
  */
-export function UsageChip({ call, t, isOwnProvider, useProjection }) {
+export function UsageChip({ call, t, isOwnProvider, accountBalance, ccSwitchBalance, useProjection }) {
     const [reading, setReading] = useState(undefined);
+    const [balance, setBalance] = useState(undefined);
+    const [ccBalance, setCcBalance] = useState(undefined);
     const [now, setNow] = useState(() => Date.now());
     const [open, setOpen] = useState(false);
     // The last route that answered, so a switch to a foreign provider leaves the last own
@@ -167,6 +207,35 @@ export function UsageChip({ call, t, isOwnProvider, useProjection }) {
     // A projection read, so the chip follows the picker: changing the model re-renders it
     // with the new provider instead of waiting for the next unrelated render.
     const selected = useProjection('modelSelection', (value) => providerOf(value));
+    // A non-subscription provider has no usage windows to meter, so the chip shows its
+    // balance instead, read by cc-switch's query. The host's account (deepseek-account)
+    // has its own balance source and takes that over cc-switch; a subscription this plugin
+    // serves keeps its usage meter.
+    const isDeepSeek = selected === 'deepseek-account';
+    const isBalanceProvider = selected !== undefined && !isOwnProvider(selected) && !isDeepSeek;
+    // Read a non-subscription provider's balance while it is in force, on the same cadence
+    // as the other reads. It resolves to undefined when the provider has no balance source
+    // or did not answer, which leaves the chip silent.
+    useEffect(() => {
+        if (!isBalanceProvider || selected === undefined) {
+            setCcBalance(undefined);
+            return;
+        }
+        let live = true;
+        const target = selected;
+        const refresh = () => {
+            void ccSwitchBalance(target)
+                .then((value) => { if (live)
+                setCcBalance(value === undefined ? undefined : { currency: value.currency, total: value.total }); })
+                .catch(() => { });
+        };
+        refresh();
+        const timer = setInterval(refresh, REFRESH_INTERVAL_MS);
+        return () => {
+            live = false;
+            clearInterval(timer);
+        };
+    }, [isBalanceProvider, selected, ccSwitchBalance]);
     const load = useCallback(async (target) => {
         try {
             const result = await call('usage', { provider: target });
@@ -179,6 +248,28 @@ export function UsageChip({ call, t, isOwnProvider, useProjection }) {
             return undefined;
         }
     }, [call]);
+    // Read the DeepSeek account's balance while that provider is in force, on the same
+    // cadence as a usage read. It resolves to undefined when the account is signed out or
+    // the read fails, which leaves the chip silent.
+    useEffect(() => {
+        if (!isDeepSeek) {
+            setBalance(undefined);
+            return;
+        }
+        let live = true;
+        const refresh = () => {
+            void accountBalance()
+                .then((value) => { if (live)
+                setBalance(balanceOf(value)); })
+                .catch(() => { });
+        };
+        refresh();
+        const timer = setInterval(refresh, REFRESH_INTERVAL_MS);
+        return () => {
+            live = false;
+            clearInterval(timer);
+        };
+    }, [isDeepSeek, accountBalance]);
     useEffect(() => {
         const target = selected !== undefined && isOwnProvider(selected)
             ? selected
@@ -213,6 +304,29 @@ export function UsageChip({ call, t, isOwnProvider, useProjection }) {
         document.addEventListener('click', close);
         return () => { document.removeEventListener('click', close); };
     }, [open]);
+    // A non-subscription provider reads as money, through cc-switch's query. It shows the
+    // one currency's total the provider answered with, nothing when there is no usable
+    // balance.
+    if (isBalanceProvider) {
+        if (ccBalance === undefined)
+            return null;
+        const short = shortLabel(selected ?? '', selected ?? '');
+        return (_jsxs("span", { className: "dsh-subscription-usage-chip", children: [_jsx("style", { children: usageChipCss }), _jsxs("button", { type: "button", className: "dsh-subscription-usage-chip-trigger", "aria-expanded": open, title: t('usageChipTitle', { provider: selected ?? '' }), onClick: (event) => {
+                        event.stopPropagation();
+                        setOpen((was) => !was);
+                    }, children: [_jsx("span", { className: "dsh-subscription-usage-chip-label", children: short }), _jsx("span", { className: "dsh-subscription-usage-chip-cell", children: _jsx("span", { className: "dsh-subscription-usage-chip-value", children: `${ccBalance.currency === 'CNY' ? '¥' : ccBalance.currency === 'USD' ? '$' : `${ccBalance.currency} `}${ccBalance.total}` }) })] }), open && (_jsxs("span", { className: "dsh-subscription-usage-chip-panel", role: "status", children: [_jsx("span", { className: "dsh-subscription-usage-chip-full", children: t('usageChipFull', { provider: selected ?? '' }) }), _jsx("span", { className: "dsh-subscription-usage-chip-meter", children: _jsxs("span", { className: "dsh-subscription-usage-chip-meterHead", children: [_jsx("span", { children: ccBalance.currency }), _jsx("span", { className: "dsh-subscription-usage-chip-detail", children: ccBalance.total })] }) })] }))] }));
+    }
+    // The DeepSeek account reads as money, not as a percentage, so it takes its own line:
+    // the route abbreviated, then each wallet. An unknown selection leaves the chip silent.
+    if (isDeepSeek) {
+        if (balance === undefined)
+            return null;
+        const short = shortLabel('deepseek-account', 'DeepSeek Account');
+        return (_jsxs("span", { className: "dsh-subscription-usage-chip", children: [_jsx("style", { children: usageChipCss }), _jsxs("button", { type: "button", className: "dsh-subscription-usage-chip-trigger", "aria-expanded": open, title: t('usageChipTitle', { provider: 'DeepSeek Account' }), onClick: (event) => {
+                        event.stopPropagation();
+                        setOpen((was) => !was);
+                    }, children: [_jsx("span", { className: "dsh-subscription-usage-chip-label", children: short }), balance.map((wallet) => (_jsx("span", { className: "dsh-subscription-usage-chip-cell", children: _jsx("span", { className: "dsh-subscription-usage-chip-value", children: formatBalance(wallet) }) }, `${wallet.currency}${wallet.bonus ? ':bonus' : ''}`)))] }), open && (_jsxs("span", { className: "dsh-subscription-usage-chip-panel", role: "status", children: [_jsx("span", { className: "dsh-subscription-usage-chip-full", children: t('usageChipFull', { provider: 'DeepSeek Account' }) }), balance.map((wallet) => (_jsx("span", { className: "dsh-subscription-usage-chip-meter", children: _jsxs("span", { className: "dsh-subscription-usage-chip-meterHead", children: [_jsx("span", { children: `${wallet.bonus ? 'Bonus · ' : ''}${wallet.currency}` }), _jsx("span", { className: "dsh-subscription-usage-chip-detail", children: formatBalance(wallet) })] }) }, `${wallet.currency}${wallet.bonus ? ':bonus' : ''}`)))] }))] }));
+    }
     if (reading === undefined)
         return null;
     const percent = reading.window.usedPercent;

package/lib/client/index.d.ts

@@ -14,7 +14,7 @@ export type { SubscriptionsSectionInjected, SubscriptionsSectionProps } from './
 export type { UsageChipInjected } from './UsageChip.js';
 export type { SubscriptionsKey } from './locales.js';
 export { createSubscriptionsCall, SubscriptionsRpcError } from './subscriptions-rpc.js';
-export type { SubscriptionsCall } from './subscriptions-rpc.js';
+export type { SubscriptionsCall, AccountBalanceCall } from './subscriptions-rpc.js';
 declare module '@deepseek-ai/dsh-client-ui-slots' {
     interface LocaleNamespaceMap {
         /** The Subscriptions settings page copy. */