dsh-cline-pass 0.2.0 → 0.2.1

package/README.en.md

@@ -68,7 +68,7 @@ To override defaults, add a `cline-pass` section to your profile's `$DSH_HOME/pr
         apiKeyEnv: CLINE_PASS_BACKUP_KEY
 ```
 
-Common settings include `baseURL`, `knownModels`, `models`, `perModel`, `exposeCatalog`, and `historyLimit`. The default gateway is `https://api.cline.bot/api/v1`.
+Common settings include `baseURL`, `knownModels`, `models`, `perModel`, `exposeCatalog`, and `historyLimit`. The default gateway is `https://api.cline.bot/api/v1`. `maxConcurrentRequests` caps how many streams each account keeps open to the gateway at once (default 16); further requests wait for a free slot, and `0` lifts the cap.
 
 ## Upstream channels
 

package/README.md

@@ -68,7 +68,7 @@ cline_pass_accounts action=mode mode=roundrobin
         apiKeyEnv: CLINE_PASS_BACKUP_KEY
 ```
 
-常用设置包括 `baseURL`、`knownModels`、`models`、`perModel`、`exposeCatalog` 和 `historyLimit`。默认网关地址为 `https://api.cline.bot/api/v1`。
+常用设置包括 `baseURL`、`knownModels`、`models`、`perModel`、`exposeCatalog` 和 `historyLimit`。默认网关地址为 `https://api.cline.bot/api/v1`。`maxConcurrentRequests` 限制每个账号同时发往网关的流数，默认 16，超出的请求排队等待空位，设为 `0` 表示不限。
 
 ## 上游渠道
 

package/lib/adapter.js

@@ -38,6 +38,15 @@ import { parseServerSentEvents } from './engine.js'
 
 /** Default maximum idle interval while a stream read is outstanding. */
 export const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 300000
+/**
+ * Default number of streams one account keeps open to the gateway at once.
+ *
+ * Twice dsh 0.1.7's default `maxActiveSubagents` (8): a main agent with a full
+ * set of subagents, plus a title or compaction call, never queues, while a
+ * runaway fan-out still cannot open an unbounded number of upstream streams
+ * (CWE-770). `0` lifts the cap.
+ */
+export const DEFAULT_MAX_CONCURRENT_REQUESTS = 16
 /**
  * Conservative context capacity for a model the catalog does not describe.
  * Shipped models carry their published window, so this only bounds the
@@ -558,6 +567,81 @@ async function* tapRouting(payloads, observed) {
   }
 }
 
+//#region upstream concurrency
+
+/**
+ * Per-account slots for streams open to the gateway.
+ *
+ * A slot is held for a whole attempt — from before `fetch` until the response
+ * body is closed — because the stream, not the wait for headers, is what keeps
+ * a socket and the account's concurrency busy. Accounts are counted apart, so a
+ * stalled account cannot hold up requests routed to a healthy one; absorbing
+ * exactly that is what the pool is for.
+ *
+ * Waiters are served first in, first out, and a freed slot is handed to the
+ * next waiter and counted in the same step, so a request arriving in between
+ * cannot take it as well. A waiter whose signal aborts leaves the queue at
+ * once; a held slot is also freed when its signal aborts, so a consumer that
+ * stops reading without closing the stream does not keep it.
+ *
+ * @returns `{ acquire(key, limit, signal) }`, resolving to a release function
+ *   that is safe to call more than once. A `limit` below 1 means no limit.
+ */
+export function createUpstreamSlots() {
+  const pools = new Map()
+  const admit = (pool) => {
+    while (pool.waiting.length > 0 && pool.active < pool.limit) {
+      pool.active += 1
+      pool.waiting.shift()()
+    }
+  }
+  const hold = (pool, signal) => {
+    let held = true
+    const release = () => {
+      if (!held) return
+      held = false
+      signal?.removeEventListener('abort', release)
+      pool.active -= 1
+      admit(pool)
+    }
+    signal?.addEventListener('abort', release, { once: true })
+    return release
+  }
+  return {
+    async acquire(key, limit, signal) {
+      signal?.throwIfAborted()
+      let pool = pools.get(key)
+      if (pool === undefined) {
+        pool = { active: 0, limit: Infinity, waiting: [] }
+        pools.set(key, pool)
+      }
+      // Read on every call, so a changed setting reaches the next request; a
+      // raised limit admits the queue before this caller joins it.
+      pool.limit = Number.isFinite(limit) && limit >= 1 ? Math.floor(limit) : Infinity
+      admit(pool)
+      if (pool.waiting.length === 0 && pool.active < pool.limit) {
+        pool.active += 1
+        return hold(pool, signal)
+      }
+      return await new Promise((resolve, reject) => {
+        const grant = () => {
+          signal?.removeEventListener('abort', abandon)
+          resolve(hold(pool, signal))
+        }
+        const abandon = () => {
+          const at = pool.waiting.indexOf(grant)
+          if (at !== -1) pool.waiting.splice(at, 1)
+          reject(signal.reason)
+        }
+        pool.waiting.push(grant)
+        signal?.addEventListener('abort', abandon, { once: true })
+      })
+    },
+  }
+}
+
+//#endregion
+
 /**
  * The Cline Pass adapter. One instance serves the plugin's provider route(s);
  * the harness model id IS the gateway's wire model id.
@@ -566,6 +650,7 @@ export class ClinePassAdapter extends LlmAdapter {
   constructor(config) {
     super()
     this.config = config
+    this.upstreamSlots = createUpstreamSlots()
   }
 
   providerInfo(provider) {
@@ -668,9 +753,18 @@ export class ClinePassAdapter extends LlmAdapter {
       const account = await this.config.resolveAccount({ exclude: [...refused] })
       if (account === undefined) break
       const body = injectPrefs(buildRequestBody(options, connection, images), meta, attempt)
-      const attemptStarted = Date.now()
       const consumer = new AbortController()
       const upstream = options.signal === undefined ? consumer.signal : AbortSignal.any([options.signal, consumer.signal])
+      // The account's slot is taken before the attempt's clock starts: the wait
+      // is local, and counting it would teach the channel a latency it never had.
+      let release
+      try {
+        release = await this.upstreamSlots.acquire(account.name, connection.maxConcurrentRequests ?? DEFAULT_MAX_CONCURRENT_REQUESTS, upstream)
+      } catch (error) {
+        if (options.signal?.aborted) throw new LlmError('Cline Pass request aborted by caller', 'ABORTED', { cause: error })
+        throw error
+      }
+      const attemptStarted = Date.now()
       const watchdog = idleWatchdog(upstream, connection.streamIdleTimeoutMs, STREAM_IDLE_TIMEOUT_CODE)
       try {
         let response
@@ -847,6 +941,9 @@ export class ClinePassAdapter extends LlmAdapter {
         if (attempt.upstream !== null && adherence === 'adopted') this.config.learnUpstream(options.model, attempt.upstream, 'ok', '', Date.now() - attemptStarted)
         return
       } finally {
+        // Held until the attempt ends, response body included, so the slot
+        // bounds open streams rather than requests waiting for headers.
+        release()
         watchdog[Symbol.dispose]()
       }
     }

package/lib/client.js

@@ -119,16 +119,43 @@ window.__ModuleLoader__.load({
       // track is resolved from that row's own content, so a row whose upstream
       // is a long pill and a row whose upstream is "(auto)" end up with
       // different column widths — and nothing lines up with the header.
-      '.cp-history-table{width:100%;border-collapse:collapse;table-layout:fixed}',
+      //
+      // `table-layout:auto`, i.e. the browser's own algorithm, and no `min-width`:
+      // the table always fits its container, so the log never needs sideways
+      // scrolling, and the sizing decision is left to the engine that knows each
+      // cell's real content width.
+      //
+      // That decision matters because the content genuinely does not fit. Measured
+      // at this card's real width (about 490px of table inside the settings card,
+      // which caps at 760px): the columns need roughly 85 + 208 + 234 + 111 =
+      // 638px, so something has to give. Under `table-layout:fixed` plus shares,
+      // what gave was the right-hand figures — they were ellipsised to "13…" and
+      // "4…", losing the number the reader came for. Left to itself the engine
+      // gives way on the token column instead, which simply wraps to a second
+      // line: the figures stay whole and nothing is lost.
+      '.cp-history-table{width:100%;border-collapse:collapse;table-layout:auto}',
       // Header and data share one alignment: a table whose labels sit left of
       // their values is the thing this panel keeps getting asked to fix.
       '.cp-history-table th{position:sticky;top:0;z-index:1;background:var(--dsw-alias-bg-layer-1);text-align:center;font-weight:400;font-size:11px;color:var(--dsw-alias-label-tertiary);padding:2px 0 6px;border-bottom:0.5px solid var(--dsw-alias-border-l3)}',
       '.cp-history-table td{padding:6px 0;border-bottom:0.5px solid var(--dsw-alias-border-l2);font-size:12px;vertical-align:middle;text-align:center;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}',
       '.cp-history-table tbody tr:hover td{background:var(--dsw-alias-bg-layer-2)}',
-      '.cp-history-col-dot{width:18px}',
-      '.cp-history-col-when{width:62px}',
-      '.cp-history-col-tokens{width:120px}',
-      '.cp-history-col-load{width:108px}',
+      // Only two columns are pinned, and each to its measured need:
+      //   点 16px    — the status dot
+      //   时间 82px  — a clock, or a dated stamp like "09-24 04:48" (needs 85px,
+      //                but the engine measures a little differently than the
+      //                intrinsic probe; 82px is where the stamp stops clipping)
+      // TOKEN and 延迟 are left to the engine. 延迟 holds single-line figures, so
+      // it always gets what it needs — which is the point: previously the model
+      // column took every spare pixel while the figures on the right were clipped,
+      // and that is the "left too loose, right too tight" shape being fixed.
+      '.cp-history-col-dot{width:16px}',
+      '.cp-history-col-when{width:82px}',
+      // The columns used to sit flush against one another at `padding:0`, which is
+      // what made the right-hand figures read as cramped. A little padding on each
+      // side of the three content columns separates label from neighbour.
+      '.cp-history-table th:nth-child(2),.cp-history-table td:nth-child(2){padding-left:10px;padding-right:10px}',
+      '.cp-history-table th:nth-child(4),.cp-history-table td:nth-child(4){padding-left:10px;padding-right:10px}',
+      '.cp-history-table th:nth-child(5),.cp-history-table td:nth-child(5){padding-left:10px;padding-right:10px}',
       '.cp-history-when{color:var(--dsw-alias-label-tertiary);font-variant-numeric:tabular-nums}',
       '.cp-history-model-cell{min-width:0}',
       // The flex stack lives INSIDE the cell, never on the `<td>` itself: a td
@@ -142,7 +169,20 @@ window.__ModuleLoader__.load({
       '.cp-history-table td.cp-history-tokens{color:var(--dsw-alias-label-secondary);font-size:11.5px;font-variant-numeric:tabular-nums;white-space:normal;overflow:visible;text-overflow:clip;line-height:1.5}',
       // Three stacked figures read like a request log: label left, value right.
       '.cp-history-table td.cp-history-load{font-variant-numeric:tabular-nums;white-space:normal;overflow:visible;text-overflow:clip}',
-      '.cp-history-load-row{display:flex;justify-content:space-between;gap:6px;font-size:11.5px;line-height:1.5}',
+      // `space-between` is what keeps the three figures right-aligned with each
+      // other across rows, but it also turns every spare pixel of the column into
+      // a gap between label and value. Capping the row and centring it makes that
+      // surplus invisible instead, so the column can be given generous width at a
+      // wide panel without the figures drifting apart.
+      '.cp-history-load-row{display:flex;justify-content:space-between;gap:5px;max-width:112px;margin:0 auto;font-size:11.5px;line-height:1.5}',
+      // With the table no longer allowed to scroll sideways, a narrow pane can
+      // leave this column short of its need. The label must not wrap then — a
+      // taller cell would change the row height — so the label stays whole and
+      // the figure is the part that gives way, ellipsised with its exact value
+      // still available in the row tooltip.
+      '.cp-history-load-row>span{white-space:nowrap}',
+      '.cp-history-load-row>span:first-child{flex:none}',
+      '.cp-history-load-row>span:last-child{min-width:0;overflow:hidden;text-overflow:ellipsis;text-align:right}',
       '.cp-history-meta{display:flex;align-items:center;justify-content:center;gap:6px;min-width:0;overflow:hidden}',
       // A failure gets its own row under the entry rather than widening it: the
       // gateway's messages are long enough to wreck a one-line layout.
@@ -173,8 +213,15 @@ window.__ModuleLoader__.load({
       '.cp-fold:hover .cp-chevron{color:var(--dsw-alias-label-primary)}',
       '.cp-set-body{border-top:0.5px solid var(--dsw-alias-border-l2);margin:0 16px;padding:12px 0 8px}',
       '.cp-usage-groups{display:flex;flex-direction:column;gap:12px}',
-      '.cp-usage-group+.cp-usage-group{border-top:0.5px solid var(--dsw-alias-border-l2);padding-top:10px}',
-      '.cp-usage-account{font-size:12px;font-weight:600;color:var(--dsw-alias-label-secondary);margin-bottom:6px}',
+      // A pool shows one account at a time: the arrows are the only way to reach
+      // the others, so they sit on the same row as the name they act on.
+      '.cp-usage-pager{display:flex;align-items:center;gap:8px}',
+      '.cp-usage-nav{box-sizing:border-box;width:24px;height:24px;flex:none;padding:0;border:0.5px solid var(--dsw-alias-border-l2);border-radius:6px;background:var(--dsw-alias-bg-layer-2);color:var(--dsw-alias-label-primary);font-size:14px;line-height:1;cursor:pointer;display:inline-flex;align-items:center;justify-content:center}',
+      '.cp-usage-nav:hover{border-color:var(--dsw-alias-brand-primary)}',
+      '.cp-usage-name{display:flex;align-items:center;gap:8px;min-width:0}',
+      '.cp-usage-acct{font-size:13px;font-weight:600;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}',
+      '.cp-usage-active{border:0.5px solid var(--dsw-alias-brand-primary);border-radius:999px;padding:1px 7px;font-size:11px;font-weight:600;flex:none}',
+      '.cp-usage-pos{font-size:12px;font-variant-numeric:tabular-nums;color:var(--dsw-alias-label-tertiary)}',
       '.cp-usage{display:grid;grid-template-columns:repeat(auto-fit,minmax(170px,1fr));gap:10px}',
       '.cp-usage-item{border:0.5px solid var(--dsw-alias-border-l2);border-radius:8px;padding:10px 12px;display:flex;flex-direction:column;gap:8px}',
       '.cp-usage-head{display:flex;align-items:baseline;justify-content:space-between;gap:8px}',
@@ -262,6 +309,9 @@ window.__ModuleLoader__.load({
       usageUnavailable: '暂时读不到官方额度。',
       usageEmpty: '官方未返回额度窗口。',
       usageAccount: '账号 {name}',
+      usagePrev: '上一个账号',
+      usageNext: '下一个账号',
+      usagePosition: '第 {i} / {n} 个',
       historyWhen: '时间',
       historyModel: '模型',
       historyUpstream: '上游',
@@ -341,6 +391,9 @@ window.__ModuleLoader__.load({
       usageUnavailable: 'The official quota is unavailable right now.',
       usageEmpty: 'The gateway reported no quota windows.',
       usageAccount: 'account {name}',
+      usagePrev: 'Previous account',
+      usageNext: 'Next account',
+      usagePosition: '{i} of {n}',
       historyWhen: 'Time',
       historyModel: 'Model',
       historyUpstream: 'Upstream',
@@ -1443,10 +1496,17 @@ window.__ModuleLoader__.load({
      * One reading per window: the official percentage, plus when it resets.
      */
     function UsageCard(props) {
-      const { t, usage, disabled, actions, unavailable } = props
+      const { t, usage, disabled, actions, unavailable, activeAccount, accountMode } = props
       const fetched = Number(usage?.fetchedAt ?? 0) > 0
       const accounts = usage?.accounts ?? []
-      const anyWindow = accounts.some((entry) => (entry.limits ?? []).length > 0)
+      // A pool is shown one account at a time. Stacking every account turned the
+      // card into a wall of bars and pushed the one reading a user came for below
+      // the fold, so the arrows — not a scroll — are what moves between accounts.
+      const [picked, setPicked] = React.useState(0)
+      // The selection is an index, so a shorter list — an account removed, or its
+      // key deleted — can leave it past the end. Clamp instead of rendering nothing.
+      const index = accounts.length === 0 ? 0 : Math.min(Math.max(picked, 0), accounts.length - 1)
+      const step = (delta) => setPicked((accounts.length + index + delta) % accounts.length)
       const windowRow = (type, key, limit) => {
         const percent = Math.max(0, Math.min(100, Number(limit.percentUsed ?? 0)))
         const left = countdown(t, limit.resetsAt)
@@ -1464,8 +1524,14 @@ window.__ModuleLoader__.load({
           left === '' ? null : h('div', { key: 'note', className: 'cp-usage-note' }, fill(t('usageResetsIn'), { t: left })),
         ])
       }
-      /** One account's block: its name when there is more than one, then its windows. */
-      const accountGroup = (account) => {
+      /**
+       * One account's block: a name row that doubles as the account switcher,
+       * then its windows.
+       *
+       * The arrows only exist in a pool. With a single account there is nowhere
+       * to go, so they would be two controls that cannot do anything.
+       */
+      const accountGroup = (account, at) => {
         const limits = account.limits ?? []
         const known = new Map(limits.map((limit) => [String(limit.type), limit]))
         const windows = [
@@ -1479,15 +1545,41 @@ window.__ModuleLoader__.load({
           : windows.length === 0
             ? h('div', { key: 'none', className: 'cp-muted' }, t('usageEmpty'))
             : h('div', { key: 'bars', className: 'cp-usage' }, windows.map(([type, key, limit]) => windowRow(type, key, limit)))
-        return h('div', { key: account.account, className: 'cp-usage-group' }, [
-          accounts.length > 1 ? h('div', { key: 'name', className: 'cp-usage-account' }, account.account) : null,
-          inner,
-        ])
+        const pooled = accounts.length > 1
+        const label = account.displayName || account.account
+        // Only a single-account pool has a "current" account: in round-robin every
+        // request rotates, so a badge here would name a fact that keeps changing.
+        const isActive = accountMode !== 'roundrobin' && activeAccount !== '' && account.account === activeAccount
+        const head = pooled
+          ? h('div', { key: 'name', className: 'cp-usage-pager' }, [
+            // Switching accounts re-reads nothing: the whole pool was read in one
+            // request, so paging is local and stays available while the panel is
+            // busy or the settings service is read-only.
+            h('button', {
+              key: 'prev', type: 'button', className: 'cp-usage-nav',
+              title: t('usagePrev'), 'aria-label': t('usagePrev'),
+              onClick: () => step(-1),
+            }, '‹'),
+            h('div', { key: 'who', className: 'cp-usage-name' }, [
+              h('span', { key: 'n', className: 'cp-usage-acct', title: label }, label),
+              isActive ? h('span', { key: 'a', className: 'cp-usage-active' }, t('accountsActive')) : null,
+              h('span', { key: 'p', className: 'cp-usage-pos' }, fill(t('usagePosition'), { i: at + 1, n: accounts.length })),
+            ]),
+            h('button', {
+              key: 'next', type: 'button', className: 'cp-usage-nav',
+              title: t('usageNext'), 'aria-label': t('usageNext'),
+              onClick: () => step(1),
+            }, '›'),
+          ])
+          : null
+        return h('div', { key: String(account.account), className: 'cp-usage-group' }, [head, inner])
       }
       let body
       if (!fetched) body = h('div', { key: 'wait', className: 'cp-muted' }, unavailable === true ? t('usageUnavailable') : t('usageLoading'))
       else if (accounts.length === 0) body = h('div', { key: 'none', className: 'cp-muted' }, t('usageEmpty'))
-      else body = h('div', { key: 'groups', className: 'cp-usage-groups' }, accounts.map(accountGroup))
+      // `index` is the account on screen; its own key remounts the block so the
+      // windows never animate between two accounts' readings.
+      else body = h('div', { key: 'groups', className: 'cp-usage-groups' }, accountGroup(accounts[index], index))
       const title = accounts.length > 1
         ? `${t('usageTitle')} · ${fill(t('accountsCount'), { n: accounts.length })}`
         : `${t('usageTitle')}${accounts[0] ? ` · ${fill(t('usageAccount'), { name: accounts[0].account })}` : ''}`
@@ -1607,6 +1699,13 @@ window.__ModuleLoader__.load({
           key: 'usage',
           t,
           usage: data.usage,
+          // Which account the pool would use, resolved the same way the accounts
+          // card resolves it: an empty `activeAccount` means "first enabled", not
+          // "none", so the badge has to name that account rather than nobody.
+          activeAccount: data.activeAccount !== ''
+            ? data.activeAccount
+            : (data.accounts.find((account) => account.enabled)?.key ?? ''),
+          accountMode: data.accountMode,
           unavailable: readFailed,
           disabled,
           actions,

package/lib/index.js

@@ -22,6 +22,7 @@ import { launchEnvironmentOf } from '@deepseek-ai/dsh-launch-environment'
 import {
   ClinePassAdapter,
   DEFAULT_CONTEXT_WINDOW,
+  DEFAULT_MAX_CONCURRENT_REQUESTS,
   DEFAULT_MAX_TOKENS,
   DEFAULT_REQUEST_IMAGE_POLICY,
   DEFAULT_STREAM_IDLE_TIMEOUT_MS,
@@ -34,7 +35,7 @@ import { BUILD_TAG } from './protocol.js'
 import { createStore } from './store.js'
 import { registerTools } from './tools.js'
 
-export { ClinePassAdapter, DEFAULT_CONTEXT_WINDOW, DEFAULT_MAX_TOKENS, DEFAULT_REQUEST_IMAGE_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS }
+export { ClinePassAdapter, DEFAULT_CONTEXT_WINDOW, DEFAULT_MAX_CONCURRENT_REQUESTS, DEFAULT_MAX_TOKENS, DEFAULT_REQUEST_IMAGE_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS }
 export { collectImageRefs, prepareRequestImages, projectImageDimensions, requestImageTarget } from './adapter.js'
 export { MODEL_CATALOG, REASONING_EFFORTS } from './catalog.js'
 export { createEngine } from './engine.js'
@@ -136,6 +137,13 @@ export const Config = z.object({
   defaultContextWindow: z.number().default(DEFAULT_CONTEXT_WINDOW),
   defaultMaxTokens: z.number().default(DEFAULT_MAX_TOKENS),
   streamIdleTimeoutMs: z.number().default(DEFAULT_STREAM_IDLE_TIMEOUT_MS),
+  /**
+   * Streams one account may keep open to the gateway at once.
+   *
+   * A request past the cap waits for a slot (and can still be cancelled while it
+   * waits) instead of opening another stream. `0` lifts the cap.
+   */
+  maxConcurrentRequests: z.number().default(DEFAULT_MAX_CONCURRENT_REQUESTS),
   exposeCatalog: z.boolean().default(false),
   historyLimit: z.number().default(100),
   /**
@@ -303,6 +311,8 @@ export function apply(ctx, config) {
       const key = await resolveKey(profile.apiKeyEnv).catch(() => undefined)
       return {
         name,
+        // The name a person recognizes, for the panel's account switcher.
+        displayName: profile.displayName,
         key: key ?? '',
         keyConfigured: key !== undefined,
         baseURL: profile.baseURL || cfg.baseURL,
@@ -342,6 +352,7 @@ export function apply(ctx, config) {
       maxTokens: cfg.defaultMaxTokens,
       reasoningModels: cfg.reasoningModels,
       streamIdleTimeoutMs: cfg.streamIdleTimeoutMs,
+      maxConcurrentRequests: cfg.maxConcurrentRequests,
     }
   }
 

package/lib/panel.js

@@ -155,12 +155,18 @@ export function createPanel({ control, engine, store }) {
     const accounts = await control.usageAccounts()
     if (accounts.length === 0) throw new Error('every configured Cline Pass account is disabled; enable one first')
     const readings = await Promise.all(accounts.map(async (account) => {
-      if (account.keyConfigured !== true) return { account: account.name, ok: false, limits: [], error: `no API key stored for ${account.name}` }
+      // The reading is keyed by the configuration name, but the panel's switcher
+      // shows the name the accounts card shows, so both travel together.
+      const label = {
+        account: account.name,
+        displayName: String(account.displayName ?? '') || String(account.name),
+      }
+      if (account.keyConfigured !== true) return { ...label, ok: false, limits: [], error: `no API key stored for ${account.name}` }
       const result = await fetchUsageLimits({
         baseURL: account.baseURL || String(config.baseURL ?? ''),
         apiKey: account.key,
       })
-      return { account: account.name, ...result }
+      return { ...label, ...result }
     }))
     const reading = store.setUsage({ accounts: readings })
     return { ...(await state()), usage: reading }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-cline-pass",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Self-contained Cline Pass provider for dsh: register Cline Pass subscription models on the harness LLM seam, enumerate and validate the upstream channels behind each model, pin or exclude them with failover, and drive an account pool. No proxy process and no external cline-pass-switcher install required.",
   "type": "module",
   "main": "lib/index.js",