@goodandready/dsh-subscriptions 0.6.40 → 0.6.43

package/lib/accounts.js

@@ -1,5 +1,5 @@
 import { needsWarmupProbe, enterProbing, resolveWarmupSuccess, resolveWarmupFailure, STATUS_QUARANTINE, STATUS_PROBING } from "./quarantine.js"
-import { fetchWithTimeout } from "./http.js"
+import { fetchWithTimeout, isTimeoutError } from "./http.js"
 import { credentialRef } from '@deepseek-ai/dsh-credentials'
 import { oauthRef, isProvider } from './refs.js'
 import { parseBlob, serializeBlob } from './blob.js'
@@ -75,7 +75,7 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
   const doFetch = fetchImpl || fetch
   // #88: per-account proxy fetch for token refresh / usage (falls back to doFetch).
   const rawFetchFor = (ref) => (typeof fetchForRef === 'function' && fetchForRef(ref)) || doFetch
-  const fetchFor = (ref) => (url, init, opts) => fetchWithTimeout(rawFetchFor(ref), url, init, { timeoutMs: 25000, ...(opts || {}) })
+  const fetchFor = (ref, defaultTimeoutMs = 25000) => (url, init, opts) => fetchWithTimeout(rawFetchFor(ref), url, init, { timeoutMs: defaultTimeoutMs, ...(opts || {}) })
 
   async function resolveRaw(ref) {
     try {
@@ -89,7 +89,7 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
   async function loadBlob(ref) {
     const raw = await resolveRaw(ref)
     if (!raw) {
-      const err = new Error(`no token for ${ref}`)
+      const err = /** @type {Error & { code?: string }} */ (new Error(`no token for ${ref}`))
       err.code = 'AUTH'
       throw err
     }
@@ -103,7 +103,7 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
       try {
         await credentials.set(credentialRef(ref), serializeBlob(blob))
       } catch (err) {
-        const wrapErr = new Error(`failed to persist credentials for ${ref}: ${err && err.message || err}`)
+        const wrapErr = /** @type {Error & { code?: string, cause?: any }} */ (new Error(`failed to persist credentials for ${ref}: ${err && err.message || err}`))
         wrapErr.code = "CREDENTIAL_SAVE_FAILED"
         wrapErr.cause = err
         throw wrapErr
@@ -171,6 +171,7 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
       healthBadge: healthBadge(computeHealthScore(health.get(ref) || null)),
       usagePercent: usage.has(ref) ? usage.get(ref) : null,
       refreshError: refreshFailures.get(ref)?.error || '',
+      isTimeout: !!refreshFailures.get(ref)?.isTimeout,
       validationUrl: base.validationUrl || '',
       validationMessage: base.validationMessage || '',
       accountNotice: base.accountNotice || '',
@@ -227,7 +228,7 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
         const curConfig = getConfig()
         const cfg = vendorConfig(provider, curConfig)
         const next = await executeWithRetry(
-          () => getVendor(provider).refresh(cfg, blob, fetchFor(ref)),
+          () => getVendor(provider).refresh(cfg, blob, fetchFor(ref, 30000)),
           {
             maxRetries: 2,
             initialDelayMs: 300,
@@ -250,7 +251,11 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
         if (ref) refreshFailures.delete(ref)
         return merged
       } catch (e) {
-        if (ref) refreshFailures.set(ref, { at: Date.now(), error: String(e && e.message || e) })
+        const isTimeout = isTimeoutError(e)
+        const errMsg = isTimeout
+          ? `Network timeout refreshing token: ${e.message || 'timed out'}`
+          : String(e && e.message || e)
+        if (ref) refreshFailures.set(ref, { at: Date.now(), error: errMsg, isTimeout })
         throw e
       } finally {
         refreshLocks.delete(lockKey)
@@ -260,59 +265,89 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
     return promise
   }
 
+  const providerUsageLocks = new Map()
+  const slotUsageLocks = new Map()
+
   async function refreshUsage(provider) {
-    const curConfig = getConfig()
-    const cfg = vendorConfig(provider, curConfig)
-    const vendor = getVendor(provider)
-    const slots = normalizeSlots(curConfig.slots).filter((s) => s.provider === provider)
-    for (const slot of slots) {
-      const last = usageFetched.get(slot.ref) || 0
-      if (Date.now() - last < USAGE_TTL_MS) continue
-      let raw = ''
-      try { raw = await resolveRaw(slot.ref) } catch { continue }
-      if (!raw) continue
-      try {
-        const blob = await ensureFresh(provider, parseBlob(raw), slot.ref)
-        const snap = await vendor.usage(blob, cfg, fetchFor(slot.ref))
-        usageFetched.set(slot.ref, Date.now())
-        if (!snap) continue
-        if (Number.isFinite(Number(snap.usedPercent))) {
-          usage.set(slot.ref, Number(snap.usedPercent))
+    if (providerUsageLocks.has(provider)) {
+      return providerUsageLocks.get(provider)
+    }
+    const flight = (async () => {
+      const curConfig = getConfig()
+      const cfg = vendorConfig(provider, curConfig)
+      const vendor = getVendor(provider)
+      const slots = normalizeSlots(curConfig.slots).filter((s) => s.provider === provider)
+      for (const slot of slots) {
+        if (slotUsageLocks.has(slot.ref)) {
+          await slotUsageLocks.get(slot.ref).catch(() => {})
+          continue
         }
-        // Notification thresholds: 70/90/100% — fire once per window until reset.
-        if (Array.isArray(snap.windows)) {
-          for (const win of snap.windows) {
-            if (!win || !Number.isFinite(Number(win.usedPercent))) continue
-            const pct = Number(win.usedPercent)
-            const key = slot.ref + ':' + win.id
-            const prev = notifyThresholds.get(key) || 0
-            const THRESHOLDS = [70, 90, 100]
-            for (const th of THRESHOLDS) {
-              if (pct >= th && prev < th) {
-                notifyThresholds.set(key, th)
-                try { onLimitNotice && onLimitNotice(slot.provider, slot.ref, win, th) } catch { /* ignore notification failure */ }
-                break
+        const last = usageFetched.get(slot.ref) || 0
+        if (Date.now() - last < USAGE_TTL_MS) continue
+        let raw = ''
+        try { raw = await resolveRaw(slot.ref) } catch { continue }
+        if (!raw) continue
+
+        const slotFlight = (async () => {
+          try {
+            usageFetched.set(slot.ref, Date.now())
+            const blob = await ensureFresh(provider, parseBlob(raw), slot.ref)
+            const usageTimeout = Number(curConfig?.usageTimeoutMs) || 15000
+            const snap = await vendor.usage(blob, cfg, fetchFor(slot.ref, usageTimeout))
+            if (!snap) return
+            if (Number.isFinite(Number(snap.usedPercent))) {
+              usage.set(slot.ref, Number(snap.usedPercent))
+            }
+            // Notification thresholds: 70/90/100% — fire once per window until reset.
+            if (Array.isArray(snap.windows)) {
+              for (const win of snap.windows) {
+                if (!win || !Number.isFinite(Number(win.usedPercent))) continue
+                const pct = Number(win.usedPercent)
+                const key = slot.ref + ':' + win.id
+                const prev = notifyThresholds.get(key) || 0
+                const THRESHOLDS = [70, 90, 100]
+                for (const th of THRESHOLDS) {
+                  if (pct >= th && prev < th) {
+                    notifyThresholds.set(key, th)
+                    try { onLimitNotice && onLimitNotice(slot.provider, slot.ref, win, th) } catch { /* ignore notification failure */ }
+                    break
+                  }
+                }
               }
             }
-          }
-        }
-        const list = Array.isArray(snap.windows) ? snap.windows : null
-        if (list) {
-          windows.set(slot.ref, list)
-          // persist last known windows so the card survives restarts
-          try {
-            const prev = Array.isArray(blob.usage) ? JSON.stringify(blob.usage) : ''
-            if (prev !== JSON.stringify(list)) {
-              await saveBlob(slot.ref, { ...blob, usage: list, usageAt: Date.now() })
-            } else if (!blob.usageAt) {
-              await saveBlob(slot.ref, { ...blob, usageAt: Date.now() })
+            const list = Array.isArray(snap.windows) ? snap.windows : null
+            if (list) {
+              windows.set(slot.ref, list)
+              // persist last known windows so the card survives restarts
+              try {
+                const prev = Array.isArray(blob.usage) ? JSON.stringify(blob.usage) : ''
+                if (prev !== JSON.stringify(list)) {
+                  await saveBlob(slot.ref, { ...blob, usage: list, usageAt: Date.now() })
+                } else if (!blob.usageAt) {
+                  await saveBlob(slot.ref, { ...blob, usageAt: Date.now() })
+                }
+              } catch { /* persistence best-effort */ }
             }
-          } catch { /* persistence best-effort */ }
-        }
-      } catch {
-        usageFetched.set(slot.ref, Date.now())
+          } catch (err) {
+            usageFetched.set(slot.ref, Date.now())
+            const isTimeout = isTimeoutError(err)
+            if (isTimeout && !refreshFailures.has(slot.ref)) {
+              refreshFailures.set(slot.ref, { at: Date.now(), error: `Network timeout fetching usage: ${err.message || 'timed out'}`, isTimeout: true })
+            }
+          } finally {
+            slotUsageLocks.delete(slot.ref)
+          }
+        })()
+
+        slotUsageLocks.set(slot.ref, slotFlight)
+        await slotFlight.catch(() => {})
       }
-    }
+    })().finally(() => {
+      providerUsageLocks.delete(provider)
+    })
+
+    providerUsageLocks.set(provider, flight)
+    return flight
   }
 
   return {

package/lib/adapter-manager.js

@@ -281,8 +281,9 @@ export function createAdapterManager({
       // #75: eager usage refresh at startup so the windows (5h/7d) land in the blob immediately
       const eager = async () => {
         try {
-          for (const slot of normalizeSlots(live().slots)) {
-            store.refreshUsage(slot.provider).catch((err) => {
+          const uniqueProviders = new Set(normalizeSlots(live().slots).map((s) => s.provider).filter(Boolean))
+          for (const provider of uniqueProviders) {
+            store.refreshUsage(provider).catch((err) => {
               if (logger && logger.debug) logger.debug('[dsh-subscriptions] eager usage error: ' + (err && err.message || err))
             })
           }

package/lib/adapter.js

@@ -53,14 +53,16 @@ export class SubscriptionAdapter extends LlmAdapter {
     let models = null
     if (targetAccount) {
       const cfg = this.deps.vendorConfig(provider)
-      const fetchImpl = pickFetch(this.deps, targetAccount.ref)
+      const baseFetch = pickFetch(this.deps, targetAccount.ref)
+      const listModelsFetch = (url, init, opts) =>
+        fetchWithTimeout(baseFetch, url, init, { timeoutMs: 15000, ...(opts || {}) })
       try {
         const blob = await this.deps.ensureFresh(
           provider,
           await this.deps.loadBlob(targetAccount.ref),
           targetAccount.ref,
         )
-        const live = await getVendor(provider).listModels(blob, cfg, fetchImpl)
+        const live = await getVendor(provider).listModels(blob, cfg, listModelsFetch)
         if (Array.isArray(live) && live.length) models = live
       } catch { /* use built-in catalog */ }
     }
@@ -73,7 +75,7 @@ export class SubscriptionAdapter extends LlmAdapter {
       models = models.filter((m) => !isDeprecatedId(String((m && m.id) || '')))
     }
     // Defensive: ensure every model has the provider field set
-    models = models.map((m) => (m && !m.provider ? { ...m, provider } : m))
+    models = models.map((m) => (m ? { ...m, provider: (!m.provider || m.provider === "custom") ? provider : m.provider } : m))
     return models
   }
 
@@ -136,12 +138,71 @@ export class SubscriptionAdapter extends LlmAdapter {
           let cacheReadTokens = 0
           let cacheWriteTokens = 0
           let approxChars = 0
-          const blob = await deps.ensureFresh(provider, await deps.loadBlob(account.ref), account.ref)
+          let completed = false
+          let sawFinish = false
+          let finishReason = null
+          let errorCaught = null
+          let finalized = false
+          let blob = null
+
+          const finalizeOnce = (outcome, extraStatus) => {
+            if (finalized) return
+            finalized = true
+
+            if (!outputTokens && approxChars > 0) {
+              outputTokens = Math.max(1, Math.round(approxChars / 4))
+            }
+
+            const totalMs = Date.now() - t0
+            const ttftMs = firstChunkTime !== null ? Math.max(0, firstChunkTime - t0) : null
+            const genMs = (firstChunkTime !== null && totalMs > ttftMs) ? (totalMs - ttftMs) : 0
+            const tps = (outputTokens > 0 && genMs > 0)
+              ? Math.round((outputTokens / (genMs / 1000)) * 10) / 10
+              : null
+
+            let status = 200
+            if (outcome === 'error') {
+              status = extraStatus || (errorCaught && (errorCaught.status || errorCaught.statusCode)) || (errorCaught && errorCaught.code === 'QUOTA' ? 429 : 500)
+            } else if (outcome === 'cancel') {
+              status = 499
+            } else if (outcome === 'runaway') {
+              status = 200
+            }
+
+            if (outcome === 'success') {
+              if (typeof deps.recordSuccess === 'function') deps.recordSuccess(account.ref)
+            }
+
+            if (typeof deps.recordHistory === 'function') {
+              try {
+                deps.recordHistory({
+                  provider,
+                  ref: account.ref,
+                  model: (opts && opts.model) || null,
+                  path: '/responses',
+                  method: 'POST',
+                  status,
+                  outcome,
+                  ms: totalMs,
+                  ttftMs,
+                  tps,
+                  inputTokens: inputTokens || undefined,
+                  outputTokens: outputTokens || undefined,
+                  cacheReadTokens: cacheReadTokens || undefined,
+                  cacheWriteTokens: cacheWriteTokens || undefined,
+                  kind: 'stream',
+                  ...(outcome === 'error' && errorCaught ? { error: errorCaught.message || String(errorCaught) } : {}),
+                  ...(outcome === 'runaway' ? { reason: finishReason || (opts && opts._runawayState && opts._runawayState.reason) || 'runaway_loop_detected' } : {}),
+                })
+              } catch { /* ignore quota capture failure */ }
+            }
+          }
+
           const vendor = getVendor(provider)
           // ponytail: capture x-ratelimit headers without touching vendors
           const baseFetch = pickFetch(deps, account.ref)
           const quotaFetch = async (url, init) => {
-            const res = await fetchWithTimeout(baseFetch, url, init, { timeoutMs: 120000 })
+            const res = await fetchWithTimeout(baseFetch, url, init, { timeoutMs: 60000, stream: true })
             try {
               const snap = quotaSnapshot(provider, res.headers, null, Date.now())
               if (snap && typeof deps.rememberQuota === "function") {
@@ -162,7 +223,9 @@ export class SubscriptionAdapter extends LlmAdapter {
             } catch { /* ignore quota capture failure */ }
             if (!res.ok && res.clone) {
               try {
-                const txt = await res.clone().text()
+                const textPromise = res.clone().text()
+                const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), 5000))
+                const txt = await Promise.race([textPromise, timeoutPromise])
                 let j=null; try { j = JSON.parse(txt) } catch { j = null }
                 if (j) {
                   const b = parseBody(provider, j, Date.now())
@@ -189,7 +252,9 @@ export class SubscriptionAdapter extends LlmAdapter {
             }
             return res
           }
+
           try {
+            blob = await deps.ensureFresh(provider, await deps.loadBlob(account.ref), account.ref)
             if (typeof deps.rememberRequest === 'function') deps.rememberRequest(account.ref)
             for await (const chunk of vendor.streamOnce({
               blob,
@@ -204,7 +269,10 @@ export class SubscriptionAdapter extends LlmAdapter {
                 firstChunkTime = Date.now()
               }
               if (chunk && typeof chunk === 'object') {
-                if (chunk.type === 'usage' && chunk.usage) {
+                if (chunk.type === 'finish') {
+                  sawFinish = true
+                  finishReason = chunk.reason
+                } else if (chunk.type === 'usage' && chunk.usage) {
                   const u = toTokenUsage(chunk.usage)
                   if (u && typeof u.outputTokens === 'number' && u.outputTokens > 0) {
                     outputTokens = u.outputTokens
@@ -224,46 +292,15 @@ export class SubscriptionAdapter extends LlmAdapter {
               }
               yield chunk
             }
-            if (!outputTokens && approxChars > 0) {
-              outputTokens = Math.max(1, Math.round(approxChars / 4))
-            }
-            // stream completed successfully: clear cooldown and health penalties
-            if (typeof deps.recordSuccess === 'function') deps.recordSuccess(account.ref)
-            // #65: record in the request and cost history.
-            if (typeof deps.recordHistory === 'function') {
-              try {
-                const totalMs = Date.now() - t0
-                const ttftMs = firstChunkTime !== null ? Math.max(0, firstChunkTime - t0) : null
-                const genMs = (firstChunkTime !== null && totalMs > ttftMs) ? (totalMs - ttftMs) : 0
-                const tps = (outputTokens > 0 && genMs > 0)
-                  ? Math.round((outputTokens / (genMs / 1000)) * 10) / 10
-                  : null
-
-                deps.recordHistory({
-                  provider,
-                  ref: account.ref,
-                  model: (opts && opts.model) || null,
-                  path: '/responses',
-                  method: 'POST',
-                  status: 200,
-                  ms: totalMs,
-                  ttftMs,
-                  tps,
-                  inputTokens: inputTokens || undefined,
-                  outputTokens: outputTokens || undefined,
-                  cacheReadTokens: cacheReadTokens || undefined,
-                  cacheWriteTokens: cacheWriteTokens || undefined,
-                  kind: 'stream',
-                })
-              } catch { /* ignore quota capture failure */ }
-            }
+            completed = true
           } catch (err) {
+            errorCaught = err
             if (err && (err.code === 'QUOTA' || err.code === 'QUOTA_EXCEEDED' || err.status === 429)) {
               if (typeof deps.recordExhaust === 'function') deps.recordExhaust(account.ref)
             } else if (err && (err.status === 401 || err.status === 403 || err.code === 'TOKEN_REVOKED' || err.code === 'BROKEN')) {
               if (typeof deps.recordBroken === 'function') deps.recordBroken(account.ref)
             }
-            if (err && err.code === 'VALIDATION_REQUIRED' && err.validationUrl) {
+            if (err && err.code === 'VALIDATION_REQUIRED' && err.validationUrl && blob) {
               await deps.saveBlob(account.ref, {
                 ...blob,
                 validationUrl: err.validationUrl,
@@ -271,6 +308,18 @@ export class SubscriptionAdapter extends LlmAdapter {
               })
             }
             throw err
+          } finally {
+            if (errorCaught) {
+              finalizeOnce('error')
+            } else if (opts && opts._runawayState && opts._runawayState.tripped) {
+              finalizeOnce('runaway')
+            } else if (completed || sawFinish) {
+              finalizeOnce('success')
+            } else if (opts && opts.signal && opts.signal.aborted) {
+              finalizeOnce('cancel', 499)
+            } else {
+              finalizeOnce('cancel', 499)
+            }
           }
         },
       })) {

package/lib/backoff.js

@@ -1,9 +1,21 @@
+/**
+ * @template T
+ * @param {() => Promise<T>} fn
+ * @param {{
+ *   maxRetries?: number,
+ *   initialDelayMs?: number,
+ *   maxDelayMs?: number,
+ *   factor?: number,
+ *   isRetryable?: (err: any) => boolean,
+ * }} [options]
+ * @returns {Promise<T>}
+ */
 export async function executeWithRetry(fn, {
   maxRetries = 3,
   initialDelayMs = 200,
   maxDelayMs = 3000,
   factor = 2,
-  isRetryable = () => true
+  isRetryable = (_err) => true
 } = {}) {
   let attempt = 0
   let delay = initialDelayMs

package/lib/client.js

@@ -919,9 +919,12 @@ const cssId = 'dsh-subscriptions/settings.module.css'
             const items = (h && h.items) || []
             const events = items.map((it) => ({
               usage: {
-                promptTokens: it.promptTokens || (it.tokens && it.tokens.prompt) || 0,
-                cachedTokens: it.cachedTokens || (it.tokens && it.tokens.cached) || 0,
-                completionTokens: it.completionTokens || (it.tokens && it.tokens.completion) || 0,
+                inputTokens: it.inputTokens ?? it.promptTokens ?? (it.tokens && it.tokens.prompt) ?? 0,
+                cacheReadTokens: it.cacheReadTokens ?? it.cachedTokens ?? (it.tokens && it.tokens.cached) ?? 0,
+                outputTokens: it.outputTokens ?? it.completionTokens ?? (it.tokens && it.tokens.completion) ?? 0,
+                promptTokens: it.inputTokens ?? it.promptTokens ?? (it.tokens && it.tokens.prompt) ?? 0,
+                cachedTokens: it.cacheReadTokens ?? it.cachedTokens ?? (it.tokens && it.tokens.cached) ?? 0,
+                completionTokens: it.outputTokens ?? it.completionTokens ?? (it.tokens && it.tokens.completion) ?? 0,
               },
             }))
             return fetch('/dsh-subscriptions/analyze-session', {
@@ -1396,6 +1399,10 @@ const cssId = 'dsh-subscriptions/settings.module.css'
             React.createElement('div', { className: 'dsub-stat-val' }, (telemetry.successRate || 100) + '%'),
             React.createElement('div', { className: 'dsub-stat-lbl' }, t('statsSuccessRate')),
           ),
+          React.createElement('div', { className: 'dsub-stat-box' },
+            React.createElement('div', { className: 'dsub-stat-val' }, (telemetry.cacheHitPercent || 0) + '%'),
+            React.createElement('div', { className: 'dsub-stat-lbl' }, t('cacheHitRate')),
+          ),
           React.createElement('div', { className: 'dsub-stat-box' },
             React.createElement('div', { className: 'dsub-stat-val' }, telemetry.lastRequestAt ? Math.round((Date.now() - telemetry.lastRequestAt) / 60000) + 'm ago' : '—'),
             React.createElement('div', { className: 'dsub-stat-lbl' }, t('statsLastActivity')),
@@ -2169,17 +2176,31 @@ const cssId = 'dsh-subscriptions/settings.module.css'
             ))
             if (typeof un1 === 'function') cleanups.push(un1)
 
-            const un2 = ctx.slots.inject('plugins.row.config', () => ctx.slots.register(
+            // DSH 0.2 bundle config seat: rendered in PackageDetail when viewing package
+            const unBundle = ctx.slots.inject('plugins.bundle.config', () => ctx.slots.register(
               {
-                name: 'plugins.row.config',
-                key: ROW_CONFIG_KEY,
+                name: 'plugins.bundle.config',
+                key: PKG,
                 locale: NS,
                 inject: () => ({ ctx: ctx }),
               },
               PluginCard,
             ))
-            if (typeof un2 === 'function') cleanups.push(un2)
-
+            if (typeof unBundle === 'function') cleanups.push(unBundle)
+
+            // DSH 0.1/0.2 row config seats
+            for (const key of [ROW_CONFIG_KEY, ROW_ID + '#' + ROW_ID, ROW_ID]) {
+              const unRow = ctx.slots.inject('plugins.row.config', () => ctx.slots.register(
+                {
+                  name: 'plugins.row.config',
+                  key,
+                  locale: NS,
+                  inject: () => ({ ctx: ctx }),
+                },
+                PluginCard,
+              ))
+              if (typeof unRow === 'function') cleanups.push(unRow)
+            }
           }
         } catch {
           // Slot system not available — expected on headless / non-web profiles.
@@ -2536,8 +2557,35 @@ const cssId = 'dsh-subscriptions/settings.module.css'
                   e.preventDefault()
                   setState((s) => Object.assign({}, s, { open: false }))
                   try {
-                    const btn = Array.from(document.querySelectorAll('button')).find((b) => (b.textContent || '').includes(t('title')))
-                    if (btn) btn.click()
+                    const nav = (props.ctx && props.ctx.pluginNavigation) || (window.__dshCtx && window.__dshCtx.pluginNavigation)
+                    if (nav && typeof nav.openBundle === 'function') {
+                      nav.openBundle(PKG)
+                      return
+                    }
+                  } catch { /* best-effort */ }
+
+                  try {
+                    if (props.ctx && props.ctx.layout && typeof props.ctx.layout.selectPanel === 'function') {
+                      props.ctx.layout.selectPanel('plugins')
+                    }
+                  } catch { /* best-effort */ }
+
+                  try {
+                    const panelBtn = document.querySelector('[data-panel-id="plugins"]') ||
+                      document.querySelector('button[aria-label*="Plugin" i]') ||
+                      document.querySelector('button[title*="Plugin" i]')
+                    if (panelBtn) panelBtn.click()
+
+                    setTimeout(() => {
+                      try {
+                        const item = document.querySelector(`[data-plugin-name="${PKG}"]`) ||
+                          document.querySelector(`[data-plugin-item="${ROW_ID}"]`) ||
+                          Array.from(document.querySelectorAll('button, a, div')).find((el) =>
+                            el.textContent && (el.textContent.includes('dsh-subscriptions') || el.textContent.includes(t('title')))
+                          )
+                        if (item) item.click()
+                      } catch { /* best-effort */ }
+                    }, 150)
                   } catch { /* best-effort */ }
                 },
               }, t('subsOpenSettings')),
@@ -2557,7 +2605,7 @@ const cssId = 'dsh-subscriptions/settings.module.css'
               order: 15,
               locale: NS,
             },
-            () => React.createElement(ErrorBoundary, null, React.createElement(SubsPill, { t })),
+            () => React.createElement(ErrorBoundary, null, React.createElement(SubsPill, { t, ctx })),
           ),
         )
       }, 'dsh-subscriptions: subs pill')
@@ -2643,6 +2691,11 @@ const cssId = 'dsh-subscriptions/settings.module.css'
     exports.inject = ['slots', 'locale', 'sessions']
     exports.apply = function apply(ctx) {
       setT(ctx.locale.bind(NS))
+      try {
+        ctx.inject(['pluginNavigation'], (navCtx) => {
+          ctx.pluginNavigation = navCtx.pluginNavigation
+        })
+      } catch { /* optional */ }
       registerSettings(ctx)
       registerSubsPill(ctx)
       registerComposerQuota(ctx)

package/lib/code-assist.js

@@ -204,6 +204,7 @@ export function streamEnvelope({ projectId, model, request, userAgent, sessionId
   const session = sessionId || randomUUID()
   const body = { ...(request || {}) }
   if (!body.session_id) body.session_id = session
+  /** @type {Record<string, any>} */
   const envelope = {
     ...(projectId ? { project: projectId } : {}),
     model,

package/lib/google-validation.js

@@ -98,7 +98,7 @@ export function validationFromHttpError(status, bodyText) {
 }
 
 export function validationRequiredError(details) {
-  const err = new Error(`${details.message} Verify at ${details.validationUrl}`)
+  const err = /** @type {Error & { code?: string, validationUrl?: string, learnMoreUrl?: string }} */ (new Error(`${details.message} Verify at ${details.validationUrl}`))
   err.code = 'VALIDATION_REQUIRED'
   err.validationUrl = details.validationUrl
   if (details.learnMoreUrl) err.learnMoreUrl = details.learnMoreUrl

package/lib/history.js

@@ -242,6 +242,9 @@ export class HistoryStore {
     const now = Date.now()
     const last24h = now - 24 * 60 * 60 * 1000
     let count24h = 0
+    let totalPromptTokens = 0
+    let totalCompletionTokens = 0
+    let totalCacheReadTokens = 0
 
     for (const r of this.rows) {
       if (r.ts >= last24h) count24h++
@@ -252,6 +255,9 @@ export class HistoryStore {
         totalMs += r.ms
         latencyCount++
       }
+      if (typeof r.inputTokens === 'number') totalPromptTokens += r.inputTokens
+      if (typeof r.outputTokens === 'number') totalCompletionTokens += r.outputTokens
+      if (typeof r.cacheReadTokens === 'number') totalCacheReadTokens += r.cacheReadTokens
     }
 
     const first = this.rows[0] // newest first
@@ -266,6 +272,12 @@ export class HistoryStore {
       lastRequestAt: (first && first.ts) || null,
       lastProvider: (first && first.provider) || null,
       lastModel: (first && first.model) || null,
+      totalPromptTokens,
+      totalCompletionTokens,
+      totalCacheReadTokens,
+      cacheHitPercent: totalPromptTokens > 0
+        ? Math.round((totalCacheReadTokens / totalPromptTokens) * 1000) / 10
+        : 0,
       accounts: this.accountsTelemetry(),
     }
   }