@goodandready/dsh-subscriptions 0.6.91 → 0.7.2

package/lib/adapter-manager.js

@@ -36,6 +36,7 @@ export function createAdapterManager({
   }
 
   const adapter = new SubscriptionAdapter({
+    live: () => live(),
     listAccounts: (provider) => store.listAccounts(provider),
     loadBlob: (ref) => store.loadBlob(ref),
     ensureFresh: (provider, blob, ref) => store.ensureFresh(provider, blob, ref),
@@ -46,6 +47,8 @@ export function createAdapterManager({
     drainSafetyPercent: () => live().drainSafetyPercent,
     switchAtRemaining: () => live().switchAtRemaining,
     rotationStrategy: () => live().rotationStrategy,
+    rateLimitWait: () => live().rateLimitWait,
+    rateLimitMaxWaitMs: () => live().rateLimitMaxWaitMs,
     enableSoftFailureSentinel: () => live().enableSoftFailureSentinel,
     rememberCooldown: (ref, until, families) => store.rememberCooldown(ref, until, families),
     rememberQuarantine: (ref, reason, until, attempts) => store.rememberQuarantine(ref, reason, until, attempts),

package/lib/adapter.js

@@ -3,6 +3,8 @@ import { inferModelCapabilities, isDeprecatedId } from './models-catalog.js'
 import { fetchWithTimeout } from "./http.js"
 import { LlmAdapter, LlmError, attributionHeaders } from '@deepseek-ai/dsh-llm'
 import { displayName } from './refs.js'
+import { applyModelSettings, bestAccountPlan } from './model-settings.js'
+import { getSpeedMode } from './speed-mode.js'
 import { getVendor } from './vendors/index.js'
 import { modelCatalog } from './messages.js'
 import { streamWithRotation } from './stream-rotate.js'
@@ -21,6 +23,9 @@ function asLlmError(err) {
   try {
     const out = new LlmError(message, code)
     if (err && err.validationUrl) out.validationUrl = err.validationUrl
+    if (err && err.retryAfterMs != null) out.retryAfterMs = err.retryAfterMs
+    if (err && err.resetAt != null) out.resetAt = err.resetAt
+    if (err && err.retryAfter != null) out.retryAfter = err.retryAfter
     return out
   } catch {
     return err
@@ -86,7 +91,7 @@ export class SubscriptionAdapter extends LlmAdapter {
         capabilities: Array.isArray(m.capabilities) && m.capabilities.length ? m.capabilities : caps.capabilities,
       }
     })
-    return models
+    return applyModelSettings(provider, models, this.deps.live ? this.deps.live() : {}, bestAccountPlan(accounts))
   }
 
   imageRequestPricing() {
@@ -112,7 +117,7 @@ export class SubscriptionAdapter extends LlmAdapter {
         ...(reasoningMeta ? { reasoning: reasoningMeta } : {}),
       }
     }
-    return { provider, id: model, name: model, ...(reasoningMeta ? { reasoning: reasoningMeta } : {}) }
+    return { provider, id: model, name: (found && found.name) || model, ...(reasoningMeta ? { reasoning: reasoningMeta } : {}), ...(found && found.contextWindow ? { context: { contextWindow: found.contextWindow } } : {}) }
   }
 
   async prepareCall(provider, model, signal) {
@@ -153,6 +158,7 @@ export class SubscriptionAdapter extends LlmAdapter {
       const decisionTrace = {}
       const streamOptions = {
         ...options,
+        ...(provider === 'codex' && getSpeedMode(sessionId) === 'fast' ? { service_tier: 'priority' } : {}),
         ...(effectiveReasoning.effort ? { reasoningEffort: effectiveReasoning.effort } : {}),
         ...(effectiveReasoning.budgetTokens ? { thinkingBudget: effectiveReasoning.budgetTokens } : {}),
         _decisionTrace: decisionTrace,
@@ -161,6 +167,8 @@ export class SubscriptionAdapter extends LlmAdapter {
         drainSafetyPercent: effectiveDrainSafetyPercent,
         rotationStrategy: effectiveRotationStrategy,
         enableSoftFailureSentinel: effectiveSoftFailureSentinel,
+        rateLimitWait: typeof deps.rateLimitWait === 'function' ? deps.rateLimitWait() : deps.rateLimitWait,
+        rateLimitMaxWaitMs: typeof deps.rateLimitMaxWaitMs === 'function' ? deps.rateLimitMaxWaitMs() : deps.rateLimitMaxWaitMs,
       }
       for await (const event of streamWithRotation({
         accounts: await deps.listAccounts(provider),

package/lib/client.js

@@ -106,6 +106,10 @@ window.__ModuleLoader__.load({
       "hideDeprecated": "Hide deprecated models",
       "hideDeprecatedHint": "Hide older or superseded model variants from model dropdowns.",
       "composerQuota": "Composer quota indicator",
+      "composerQuotaDisplay": "Status-bar quota scope",
+      "composerQuotaDisplayHint": "Show quota for the provider of the current model, or hide the status-bar pill.",
+      "composerQuotaDisplayCurrent": "Current model",
+      "composerQuotaDisplayHidden": "Hidden",
       "composerQuotaHint": "Display subscription usage indicator directly in the composer toolbar.",
       "composerQuotaOff": "Disabled",
       "composerQuotaPercent": "Percentage",
@@ -255,11 +259,23 @@ window.__ModuleLoader__.load({
       "verifyLink": "Open verification link",
       "verifySuffix": " then reconnect.",
       "addAccount": "+ Add account",
+      "slotAdvanced": "Advanced slot settings",
+      "providerGallery": "Add provider",
+      "providerGalleryHint": "Unconnected providers are hidden from the main list to keep the page focused.",
+      "vipOnly": "VIP only",
+      "vipOnlyHint": "Reserve this account for VIP-tagged requests.",
+      "isPro": "Pro",
+      "isProHint": "Treat this account as Pro for weighted priority.",
+      "tags": "Tags",
+      "tagsPlaceholder": "team, prod",
+      "weight": "Weight",
+      "maxQueueSizeSlot": "Queue",
       "save": "Save",
       "saved": "Saved",
       "accountLabel": "Account",
       "plan": "Plan",
       "storedAs": "Stored as",
+      "slashFast": "Toggle Codex Speed (fast/standard)",
       "slashLogin": "Login to a subscription provider",
       "slashLogout": "Log out a subscription provider",
       "forecast": "≈",
@@ -404,6 +420,10 @@ window.__ModuleLoader__.load({
       "hideDeprecated": "隐藏已废弃的旧模型",
       "hideDeprecatedHint": "在模型下拉列表中隐藏早期或已被替代的旧版模型。",
       "composerQuota": "输入框额度指示器",
+      "composerQuotaDisplay": "状态栏额度范围",
+      "composerQuotaDisplayHint": "显示当前模型所属服务商的额度，或隐藏状态栏指示器。",
+      "composerQuotaDisplayCurrent": "当前模型",
+      "composerQuotaDisplayHidden": "隐藏",
       "composerQuotaHint": "在聊天输入框工具栏直接显示当前订阅额度指示器。",
       "composerQuotaOff": "已禁用",
       "composerQuotaPercent": "百分比显示",
@@ -553,11 +573,23 @@ window.__ModuleLoader__.load({
       "verifyLink": "打开验证链接",
       "verifySuffix": "，完成后点击重新连接。",
       "addAccount": "+ 添加账户",
+      "slotAdvanced": "账户高级设置",
+      "providerGallery": "添加服务商",
+      "providerGalleryHint": "未连接的服务商默认隐藏在列表中，保持页面聚焦。",
+      "vipOnly": "仅 VIP",
+      "vipOnlyHint": "将此账户保留给 VIP 请求。",
+      "isPro": "Pro",
+      "isProHint": "按 Pro 账户参与加权优先级。",
+      "tags": "标签",
+      "tagsPlaceholder": "team, prod",
+      "weight": "权重",
+      "maxQueueSizeSlot": "队列",
       "save": "保存",
       "saved": "已保存",
       "accountLabel": "账户",
       "plan": "套餐方案",
       "storedAs": "存储标识",
+      "slashFast": "切换 Codex 加速模式（快速/标准）",
       "slashLogin": "登录订阅服务商",
       "slashLogout": "登出订阅服务商",
       "forecast": "≈",
@@ -1785,6 +1817,18 @@ window.__ModuleLoader__.load({
           ),
           h('details', { className: 'dsub-group', open: true },
             h('summary', { className: 'dsub-groupHead' }, t('groupRotation')),
+          h('div', { className: 'dsub-row' },
+            h('span', { className: 'dsub-h' }, t('composerQuotaDisplay')),
+            h('select', {
+              className: 'dsub-select',
+              value: draft.composerQuotaDisplay || 'current',
+              onChange: (e) => setDraft((d) => Object.assign({}, d, { composerQuotaDisplay: e.target.value })),
+            },
+              h('option', { value: 'current' }, t('composerQuotaDisplayCurrent')),
+              h('option', { value: 'hidden' }, t('composerQuotaDisplayHidden')),
+            ),
+          ),
+          h('div', { className: 'dsub-sub' }, t('composerQuotaDisplayHint')),
           h('div', { className: 'dsub-row' },
             h('span', { className: 'dsub-h' }, t('composerQuota')),
             h('select', {
@@ -2347,7 +2391,17 @@ window.__ModuleLoader__.load({
             )
           ) : null,
         ),
-        names.map((prov) => {
+        (function(){
+          const configuredSlot = (slot) => {
+            const account = accountOf(slot.provider, slot.index)
+            return !!((account && (account.configured || account.hasToken))
+              || slot.label || slot.proxyUrl || slot.expiresAt
+              || (Array.isArray(slot.tags) && slot.tags.length) || slot.vipOnly || slot.isPro || slot.weight)
+          }
+          const visibleNames = names.filter((prov) => slots.some((slot) => slot.provider === prov.id && configuredSlot(slot)))
+          const hiddenNames = names.filter((prov) => visibleNames.indexOf(prov) < 0)
+          return h(React.Fragment, null,
+            visibleNames.map((prov) => {
           const rows = slots
             .map((slot, i) => ({ slot: slot, i: i }))
             .filter((row) => row.slot.provider === prov.id)
@@ -2637,6 +2691,59 @@ window.__ModuleLoader__.load({
                       },
                     })
                   ),
+                  h('details', { className: 'dsub-details' },
+                    h('summary', { className: 'dsub-summary' }, t('slotAdvanced')),
+                    h('div', { className: 'dsub-row' },
+                      h('label', { className: 'dsub-ref-tag', title: t('vipOnlyHint') },
+                        h('input', {
+                          type: 'checkbox',
+                          checked: !!row.slot.vipOnly,
+                          onChange: (e) => updateSlot(row.slot.provider, row.slot.index, { vipOnly: e.target.checked }),
+                        }),
+                        ' ' + t('vipOnly')
+                      ),
+                      h('label', { className: 'dsub-ref-tag', title: t('isProHint') },
+                        h('input', {
+                          type: 'checkbox',
+                          checked: !!row.slot.isPro,
+                          onChange: (e) => updateSlot(row.slot.provider, row.slot.index, { isPro: e.target.checked }),
+                        }),
+                        ' ' + t('isPro')
+                      ),
+                    ),
+                    h('div', { className: 'dsub-row' },
+                      h('span', { className: 'dsub-ref-tag' }, t('tags')),
+                      h('input', {
+                        className: 'dsub-inp',
+                        style: { width: '160px', minWidth: '160px' },
+                        value: (Array.isArray(row.slot.tags) ? row.slot.tags : []).join(','),
+                        placeholder: t('tagsPlaceholder'),
+                        onChange: (e) => updateSlot(row.slot.provider, row.slot.index, {
+                          tags: e.target.value.split(',').map((value) => value.trim()).filter(Boolean),
+                        }),
+                      }),
+                      h('span', { className: 'dsub-ref-tag' }, t('weight')),
+                      h('input', {
+                        type: 'number', min: 0, max: 100,
+                        style: { width: '52px', padding: '1px 4px', fontSize: '11px', textAlign: 'center' },
+                        value: row.slot.weight !== undefined ? row.slot.weight : 0,
+                        onChange: (e) => {
+                          const value = parseInt(e.target.value, 10)
+                          updateSlot(row.slot.provider, row.slot.index, { weight: isNaN(value) ? 0 : Math.max(0, value) })
+                        },
+                      }),
+                      h('span', { className: 'dsub-ref-tag' }, t('maxQueueSizeSlot')),
+                      h('input', {
+                        type: 'number', min: 0, max: 1000,
+                        style: { width: '58px', padding: '1px 4px', fontSize: '11px', textAlign: 'center' },
+                        value: row.slot.maxQueueSize !== undefined ? row.slot.maxQueueSize : 0,
+                        onChange: (e) => {
+                          const value = parseInt(e.target.value, 10)
+                          updateSlot(row.slot.provider, row.slot.index, { maxQueueSize: isNaN(value) ? 0 : Math.max(0, value) })
+                        },
+                      }),
+                    ),
+                  ),
                 ),
                 (function(){
                   var r = proxyRes[key]
@@ -2917,6 +3024,20 @@ window.__ModuleLoader__.load({
             }, t('addAccount')),
           )
         }),
+            hiddenNames.length ? h('details', { className: 'dsub-group', open: visibleNames.length === 0 },
+              h('summary', { className: 'dsub-groupHead' }, '➕ ' + t('providerGallery')),
+              h('div', { className: 'dsub-sub' }, t('providerGalleryHint')),
+              h('div', { className: 'dsub-model-grid' },
+                hiddenNames.map((prov) => h('button', {
+                  key: prov.id,
+                  type: 'button',
+                  className: 'dsub-mini',
+                  onClick: () => addSlot(prov.id),
+                }, prov.name))
+              )
+            ) : null
+          )
+        })(),
         h('div', { className: 'dsub-foot' },
           h('button', {
             type: 'button', className: 'dsub-save',
@@ -3103,10 +3224,28 @@ window.__ModuleLoader__.load({
           labels: (data && data.labels) || {},
           expiryNotifyDays: (data && data.expiryNotifyDays) || 7,
           composerQuota: (data && data.composerQuota) || 'off',
+          composerQuotaDisplay: (data && data.composerQuotaDisplay) || 'current',
           active: (data && data.active) || null,
           error: null,
         }
-      } catch { return { logged: [], usage: 0, expiresAt: {}, labels: {}, expiryNotifyDays: 7, fastMode: false, composerQuota: 'off', active: null, error: 'status unavailable' } }
+      } catch { return { logged: [], usage: 0, expiresAt: {}, labels: {}, expiryNotifyDays: 7, fastMode: false, composerQuota: 'off', composerQuotaDisplay: 'current', active: null, error: 'status unavailable' } }
+    }
+
+    function currentModelProvider(props) {
+      let session = null
+      try {
+        const ctx = typeof window !== 'undefined' ? window.__dshCtx : null
+        session = (props && (props.session || props.conversation))
+          || (ctx && ctx.sessions && (ctx.sessions.current || ctx.sessions.active
+            || (typeof ctx.sessions.getCurrent === 'function' && ctx.sessions.getCurrent())))
+          || null
+      } catch { /* sessions service is optional */ }
+      const model = session && (session.model || session.modelId
+        || (session.header && session.header.model) || (session.state && session.state.model))
+      if (!model) return null
+      if (typeof model === 'object') return model.provider || null
+      const text = String(model)
+      return text.includes('/') ? text.split('/')[0] : null
     }
 
     function ComposerQuota(props) {
@@ -3120,11 +3259,22 @@ window.__ModuleLoader__.load({
             fetch('/dsh-subscriptions/analytics', { cache: 'no-store' })
               .then((res) => res.json())
               .catch(() => ({})),
-          ]).then(([r, analyticsPayload]) => {
+          ]).then(async ([r, analyticsPayload]) => {
             if (!alive) return
             const mode = r.composerQuota || 'off'
-            const a = r.active
-            if (mode !== 'off' && a && a.provider && a.provider !== 'ollama' && a.usagePercent != null) {
+            const current = currentModelProvider(props)
+            let a = r.active
+            if (current && (!a || a.provider !== current)) {
+              const cfg = await fetch('/dsh-subscriptions/config', { cache: 'no-store' })
+                .then((res) => res.json())
+                .catch(() => null)
+              const rows = (cfg && cfg.accounts) || []
+              a = rows.find((row) => row && row.provider === current && row.usagePercent != null)
+                || rows.find((row) => row && row.provider === current)
+                || null
+            }
+            const hidden = r.composerQuotaDisplay === 'hidden'
+            if (mode !== 'off' && !hidden && a && a.provider && a.provider !== 'ollama' && a.usagePercent != null) {
               const remaining = Math.max(0, 100 - a.usagePercent)
               const forecast = (analyticsPayload && analyticsPayload.analytics && analyticsPayload.analytics.forecast) || []
               const row = forecast.find((f) => f.provider === a.provider && (!f.ref || !a.ref || f.ref === a.ref))
@@ -3134,9 +3284,9 @@ window.__ModuleLoader__.load({
                   ? { status: 'idle' }
                   : { status: 'forecast', runwaySeconds: Math.max(0, Number(row.hoursToExhaustion) * 3600) }
               }
-              setState({ mode, active: a, remaining, est })
+              setState({ mode, active: a, remaining, est, hidden })
             } else {
-              setState({ mode, active: a, remaining: null, est: null })
+              setState({ mode, active: a, remaining: null, est: null, hidden })
             }
           }).catch(() => {})
         }
@@ -3144,7 +3294,7 @@ window.__ModuleLoader__.load({
         const id = setInterval(pull, 60 * 1000)
         return () => { alive = false; clearInterval(id) }
       }, [])
-      if (state.mode === 'off' || !state.active || state.remaining == null) return null
+      if (state.mode === 'off' || state.hidden || !state.active || state.remaining == null) return null
       const cls = state.remaining <= 10 ? ' dsub-cqBarFull' : (state.remaining <= 30 ? ' dsub-cqBarWarn' : '')
       var value = null
       if (state.mode === 'percent') {
@@ -3555,6 +3705,7 @@ window.__ModuleLoader__.load({
         const line = (line) => line.trim()
         const sources = [
           { name: 'login', description: t('slashLogin') },
+          { name: 'fast', description: t('slashFast') },
           { name: 'logout', description: t('slashLogout') },
         ]
         const disposers = sources.map((src) =>
@@ -3579,6 +3730,17 @@ window.__ModuleLoader__.load({
                 return refreshLoggedIn().then((logged) =>
                   ({ text: 'Connected: ' + (logged.length ? logged.join(', ') : 'none') }))
               }
+              if (src.name === 'fast') {
+                const mode = /\bstandard\b|\boff\b/.test(t2) ? 'standard' : 'fast'
+                const sid = (_session && (_session.id || _session.sessionId || (_session.header && _session.header.id))) || 'default'
+                return fetch('/dsh-subscriptions/speed', {
+                  method: 'POST',
+                  headers: { 'Content-Type': 'application/json' },
+                  body: JSON.stringify({ sessionId: sid, mode }),
+                }).then((r) => r.json()).then((d) => ({
+                  text: (d && d.mode === 'fast' ? 'Codex Speed: fast' : 'Codex Speed: standard'),
+                })).catch((e) => ({ text: 'Codex Speed: ' + String(e && e.message || e) }))
+              }
               run(src.name, t2)
               return Promise.resolve('handled')
             },

package/lib/coexistence.js

@@ -0,0 +1,45 @@
+import { readFileSync } from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+
+export const CONFLICTING_PLUGINS = Object.freeze([
+  'dsh-plugin-subscriptions',
+  'dsh-super-subscriptions',
+  'dsh-agy-link',
+  'dsh-codex-connect',
+  'dsh-key-rotation',
+  '@goodandready/dsh-key-rotation',
+])
+
+let activeConflicts = []
+
+export function detectConflicts({ dependencies = [], loaded = [] } = {}) {
+  const names = new Set([...(dependencies || []), ...(loaded || [])].filter(Boolean).map(String))
+  return CONFLICTING_PLUGINS.filter((name) => names.has(name))
+}
+
+export function setActiveConflicts(conflicts) {
+  activeConflicts = Array.isArray(conflicts) ? conflicts.slice() : []
+}
+
+export function getActiveConflicts() {
+  return activeConflicts.slice()
+}
+
+export function readProfilePluginNames(profileDir = process.env.DSH_PROFILE_DIR) {
+  const candidates = []
+  if (profileDir) candidates.push(profileDir)
+  try { candidates.push(process.cwd()) } catch { /* ignore cwd errors */ }
+  const home = process.env.DSH_HOME || path.join(os.homedir(), '.dsh')
+  const profile = process.env.DSH_PROFILE
+  if (profile) candidates.push(path.join(home, 'profiles', profile))
+  for (const dir of candidates) {
+    try {
+      const pkg = JSON.parse(readFileSync(path.join(dir, 'package.json'), 'utf8'))
+      const deps = Object.keys(pkg.dependencies || {})
+      const bundles = (pkg.dsh && pkg.dsh.profile && pkg.dsh.profile.bundles) || []
+      return [...deps, ...bundles].filter(Boolean)
+    } catch { /* try next candidate */ }
+  }
+  return []
+}

package/lib/config-schema.js

@@ -78,6 +78,16 @@ export const Config = z.object({
     .description('#91 Ollama model used for the fallback (for example qwen2.5-coder). Empty = first model from /api/tags.'),
   hideDeprecatedModels: z.boolean().volatile().default(false)
     .description('#94 Hide test/preview/beta/legacy model ids from the native model picker.'),
+  modelDisplayNames: z.array(z.object({ provider: z.string(), id: z.string(), name: z.string() })).volatile().default([])
+    .description('#681 Per-model display names shown in the native model picker.'),
+  hiddenModels: z.array(z.object({ provider: z.string(), id: z.string() })).volatile().default([])
+    .description('#681 Per-model visibility switches for the native model picker.'),
+  modelContextWindows: z.array(z.object({ provider: z.string(), id: z.string(), contextWindow: z.number() })).volatile().default([])
+    .description('#681 Per-model context-window override.'),
+  modelReasoningDefaults: z.array(z.object({ provider: z.string(), id: z.string(), effort: z.string() })).volatile().default([])
+    .description('#681 Per-model default reasoning effort.'),
+  modelPlans: z.array(z.object({ provider: z.string(), id: z.string(), minPlan: z.string(), plan: z.string() })).volatile().default([])
+    .description('#690 Minimum subscription plan per model, shown in the picker metadata.'),
   codexClientId: z.string().volatile().default(''),
   codexVerbosity: z.string().volatile().default('')
     .description('#93 Response verbosity for Codex reasoning models: low, medium or high. Empty = protocol default.'),
@@ -85,6 +95,12 @@ export const Config = z.object({
     .description('#92 Fast Mode for Codex: sends service_tier priority (1.5x speed billing tier) with every request.'),
   composerQuota: z.string().volatile().default('off')
     .description('#84 Composer quota indicator mode: off, percent, bar or forecast (predictive runway from a sliding window).'),
+  composerQuotaDisplay: z.string().volatile().default('current')
+    .description('#682 Status-bar quota scope: current (model provider) or hidden.'),
+  rateLimitWait: z.boolean().volatile().default(true)
+    .description('#684 Report the disclosed reset to dsh-llm-retry instead of parking the account on a guess.'),
+  rateLimitMaxWaitMs: z.number().volatile().default(21600000)
+    .description('#684 Maximum reset wait reported to dsh-llm-retry (default 6h).'),
   codexRedirectUri: z.string().volatile().default(''),
   codexBaseUrl: z.string().volatile().default(''),
   codexClientVersion: z.string().volatile().default('')

package/lib/index.js

@@ -14,6 +14,8 @@ import { parseBlob } from './blob.js'
 import { createVendorFromProfile, validateProfiles } from './vendor-factory.js'
 import { registerCustomProviderIds, registerDisplayName } from './refs.js'
 import { createSubscriptionsService } from './subscriptions.js'
+import { registerSubscriptionTools } from './native-tools.js'
+import { detectConflicts, readProfilePluginNames, setActiveConflicts } from './coexistence.js'
 import { createAccountStore, normalizeSlots, vendorConfig } from './accounts.js'
 import { OllamaAdapter, ollamaAlive, ollamaModels, ollamaBase } from './ollama.js'
 import { createResetCreditService } from './reset-credits.js'
@@ -39,7 +41,7 @@ export { pushToWebdav, pullFromWebdav, pushToGist, pullFromGist, buildS3SigV4Hea
 import { syncVaultPush, syncVaultPull, getVaultSyncStatus } from './vault-sync.js'
 
 export const name = '@goodandready/dsh-subscriptions'
-export const inject = ['llm', 'credentials', 'webServer', 'settings']
+export const inject = ['llm', 'credentials', 'webServer', 'settings', 'tools']
 
 const NS = 'dsh-subscriptions'
 
@@ -75,6 +77,11 @@ const OK_HTML = `<!doctype html>
 
 export function apply(ctx, rawConfig) {
   const logger = typeof ctx.logger === 'function' ? ctx.logger('subscriptions') : (ctx.logger || undefined)
+  const conflicts = detectConflicts({ dependencies: readProfilePluginNames() })
+  setActiveConflicts(conflicts)
+  if (conflicts.length && logger && logger.warn) {
+    logger.warn('[dsh-subscriptions] conflicting subscription plugins detected: ' + conflicts.join(', ') + '; keep one provider owner')
+  }
 
   // rawConfig still holds Volatile boxes, so unwrap before validating.
   const resolveEntry = () => {
@@ -377,6 +384,10 @@ export function apply(ctx, rawConfig) {
       })
     },
   }), 'dsh-subscriptions: image generation service')
+  ctx.effect(() => registerSubscriptionTools(ctx, {
+    subscriptions,
+    images: () => ctx.subscriptionImages,
+  }), 'dsh-subscriptions: native tools')
 
   const pending = new Map()
 

package/lib/messages.js

@@ -301,7 +301,7 @@ export function codexResponsesBody(options, fallbackInstructions, vendorCfg) {
     ...(vendorCfg && /^(low|medium|high)$/.test(String(vendorCfg.verbosity || ''))
       ? { text: { verbosity: String(vendorCfg.verbosity) } } : {}),
     // #92: Fast Mode = 1.5x speed billing tier on the Codex backend.
-    ...(vendorCfg && vendorCfg.fastMode ? { service_tier: 'priority' } : {}),
+    ...((vendorCfg && vendorCfg.fastMode) || options.service_tier === 'priority' ? { service_tier: 'priority' } : {}),
     ...(options.maxTokens != null ? { max_output_tokens: options.maxTokens } : {}),
     ...(options.temperature != null ? { temperature: options.temperature } : {}),
   }

package/lib/model-settings.js

@@ -0,0 +1,49 @@
+function rowsFor(rows, provider) {
+  return (Array.isArray(rows) ? rows : []).filter((row) => row && row.provider === provider)
+}
+
+const PLAN_RANK = { free: 0, plus: 1, pro: 2, max: 3, team: 3, enterprise: 4 }
+
+export function planRank(name) {
+  return PLAN_RANK[String(name || '').toLowerCase()] ?? 0
+}
+
+export function bestAccountPlan(accounts) {
+  let best = null
+  for (const account of accounts || []) {
+    const plan = account && (account.plan || account.paidTierName)
+    if (!plan) continue
+    if (!best || planRank(plan) > planRank(best)) best = String(plan)
+  }
+  return best
+}
+
+export function applyModelSettings(provider, models, cfg = {}, accountPlan = null) {
+  const list = Array.isArray(models) ? models : []
+  const hidden = new Set(rowsFor(cfg.hiddenModels, provider).map((row) => String(row.id)))
+  const plans = new Map(rowsFor(cfg.modelPlans, provider).map((row) => [String(row.id), String(row.minPlan || '')]))
+  const accountRank = accountPlan ? planRank(accountPlan) : null
+  const names = new Map(rowsFor(cfg.modelDisplayNames, provider).map((row) => [String(row.id), String(row.name)]))
+  const contexts = new Map(rowsFor(cfg.modelContextWindows, provider).map((row) => [String(row.id), Number(row.contextWindow)]))
+  const efforts = new Map(rowsFor(cfg.modelReasoningDefaults, provider).map((row) => [String(row.id), String(row.effort).toLowerCase()]))
+  return list
+    .filter((model) => {
+      if (!model || hidden.has(String(model.id))) return false
+      const minPlan = plans.get(String(model.id))
+      if (minPlan && accountRank != null && planRank(minPlan) > accountRank) return false
+      return true
+    })
+    .map((model) => {
+      const id = String(model.id)
+      const minPlan = plans.get(id)
+      const contextWindow = contexts.get(id)
+      const effort = efforts.get(id)
+      return {
+        ...model,
+        name: names.get(id) || model.name || model.id,
+        ...(Number.isFinite(contextWindow) && contextWindow > 0 ? { contextWindow } : {}),
+        ...(effort ? { reasoning: { ...(model.reasoning || {}), defaultEffort: effort } } : {}),
+        ...(minPlan ? { plan: minPlan, minPlan } : {}),
+      }
+    })
+}

package/lib/native-tools.js

@@ -0,0 +1,220 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+
+const TOOL_OUTPUT = {
+  schema: {
+    type: 'object',
+    additionalProperties: true,
+    properties: { text: { type: 'string' } },
+    required: ['text'],
+  },
+  render(_args, value) {
+    return [{ type: 'text', text: String((value && value.text) || '') }]
+  },
+}
+
+function textResult(text) {
+  return { text: String(text) }
+}
+
+export function extractResponseText(payload) {
+  const body = payload && typeof payload === 'object' ? payload : {}
+  if (typeof body.output_text === 'string' && body.output_text) return body.output_text
+  if (typeof body.answer === 'string' && body.answer) return body.answer
+  if (Array.isArray(body.output)) {
+    const parts = []
+    for (const item of body.output) {
+      for (const content of (item && item.content) || []) {
+        if (content && typeof content.text === 'string') parts.push(content.text)
+      }
+    }
+    if (parts.length) return parts.join('\n')
+  }
+  if (Array.isArray(body.choices)) {
+    return body.choices.map((choice) => choice && choice.message && choice.message.content)
+      .filter((value) => typeof value === 'string').join('\n')
+  }
+  return JSON.stringify(body).slice(0, 4000)
+}
+
+function outputDir(exec) {
+  const cwd = (exec && exec.agent && exec.agent.session && exec.agent.session.header
+    && exec.agent.session.header.cwd) || process.cwd()
+  return path.join(cwd, 'generated', 'subscriptions')
+}
+
+async function saveImages(images, exec) {
+  const dir = outputDir(exec)
+  await mkdir(dir, { recursive: true })
+  const out = []
+  for (let i = 0; i < images.length; i += 1) {
+    const image = images[i]
+    if (!image || typeof image.b64_json !== 'string') continue
+    const file = path.join(dir, `image-${Date.now()}-${i}.png`)
+    await writeFile(file, Buffer.from(image.b64_json, 'base64'))
+    out.push(file)
+  }
+  return out
+}
+
+export function registerSubscriptionTools(ctx, deps) {
+  const tools = ctx && ctx.tools
+  if (!tools || typeof tools.register !== 'function') return () => {}
+  const disposers = []
+  const register = (definition) => {
+    try {
+      const off = tools.register(definition)
+      if (typeof off === 'function') disposers.push(off)
+    } catch (err) {
+      // Another plugin may already own this tool name (for example x_search
+      // from a Grok search plugin or image_generate from an image plugin).
+      // Keep our remaining tools registered instead of failing the whole plugin.
+      if (!/already registered/i.test(String(err && err.message || err))) throw err
+    }
+  }
+
+  register({
+    name: 'image_generate',
+    description: 'Generate an image with the active ChatGPT/Codex or Grok subscription. Returns saved file paths.',
+    output: TOOL_OUTPUT,
+    parameters: {
+      type: 'object',
+      properties: {
+        prompt: { type: 'string', description: 'Image prompt' },
+        provider: { type: 'string', enum: ['gpt', 'codex', 'grok'], description: 'Preferred provider' },
+        size: { type: 'string', description: 'Image size, e.g. 1024x1024' },
+        quality: { type: 'string', description: 'low, medium or high' },
+      },
+      required: ['prompt'],
+    },
+    async execute(args, exec) {
+      const images = deps.images && deps.images()
+      if (!images || typeof images.generate !== 'function') throw new Error('subscription image service is unavailable')
+      const preferred = String((args && args.provider) || 'gpt').toLowerCase()
+      const order = preferred === 'grok' ? ['grok', 'codex'] : ['codex', 'grok']
+      let lastError = null
+      for (const provider of order) {
+        try {
+          const rows = await images.generate({
+            provider,
+            prompt: args && args.prompt,
+            size: args && args.size,
+            quality: args && args.quality,
+            signal: exec && exec.signal,
+          })
+          const files = await saveImages(rows, exec)
+          if (!files.length) throw new Error('image response contained no images')
+          return textResult(files.map((file) => `Generated image: ${file}`).join('\n'))
+        } catch (err) {
+          lastError = err
+        }
+      }
+      throw lastError || new Error('no subscription image provider is available')
+    },
+  })
+
+  register({
+    name: 'x_search',
+    description: 'Search X posts through the active Grok subscription and return an answer with citations.',
+    output: TOOL_OUTPUT,
+    parameters: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Search query' },
+        model: { type: 'string', description: 'Optional Grok model id' },
+      },
+      required: ['query'],
+    },
+    async execute(args, exec) {
+      const res = await deps.subscriptions.request({
+        provider: 'grok',
+        path: '/v1/responses',
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+        body: {
+          model: (args && args.model) || 'grok-4.6',
+          input: args && args.query,
+          tools: [{ type: 'x_search' }],
+          stream: false,
+        },
+        signal: exec && exec.signal,
+      })
+      const data = await res.json().catch(() => ({}))
+      if (!res.ok) throw new Error(`x_search HTTP ${res.status}: ${extractResponseText(data)}`)
+      return textResult(extractResponseText(data))
+    },
+  })
+
+  register({
+    name: 'web_search',
+    description: 'Search the web through the active ChatGPT/Codex subscription and return an answer with citations.',
+    output: TOOL_OUTPUT,
+    parameters: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Search query' },
+        model: { type: 'string', description: 'Optional Codex model id' },
+      },
+      required: ['query'],
+    },
+    async execute(args, exec) {
+      const res = await deps.subscriptions.request({
+        provider: 'codex',
+        path: '/responses',
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+        body: {
+          model: (args && args.model) || 'gpt-5.6',
+          input: args && args.query,
+          tools: [{ type: 'web_search_preview' }],
+          stream: false,
+        },
+        signal: exec && exec.signal,
+      })
+      const data = await res.json().catch(() => ({}))
+      if (!res.ok) throw new Error(`web_search HTTP ${res.status}: ${extractResponseText(data)}`)
+      return textResult(extractResponseText(data))
+    },
+  })
+
+  register({
+    name: 'video_generate',
+    description: 'Submit a short video generation request through the active Grok subscription.',
+    output: TOOL_OUTPUT,
+    parameters: {
+      type: 'object',
+      properties: {
+        prompt: { type: 'string', description: 'Video prompt' },
+        duration: { type: 'number', description: 'Duration in seconds (1-15)' },
+        aspect_ratio: { type: 'string', description: 'e.g. 16:9, 1:1, 9:16' },
+        image_url: { type: 'string', description: 'Optional source image URL' },
+      },
+      required: ['prompt'],
+    },
+    async execute(args, exec) {
+      const res = await deps.subscriptions.request({
+        provider: 'grok',
+        path: '/v1/videos',
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+        body: {
+          model: 'grok-imagine-video-1.5',
+          prompt: args && args.prompt,
+          duration: args && args.duration,
+          aspect_ratio: args && args.aspect_ratio,
+          image_url: args && args.image_url,
+        },
+        signal: exec && exec.signal,
+      })
+      const data = await res.json().catch(() => ({}))
+      if (!res.ok) throw new Error(`video_generate HTTP ${res.status}: ${extractResponseText(data)}`)
+      return textResult(`Video request submitted: ${JSON.stringify(data).slice(0, 1000)}`)
+    },
+  })
+
+  return () => {
+    for (const off of disposers) {
+      try { off() } catch { /* best-effort cleanup */ }
+    }
+  }
+}

package/lib/reset-clock.js

@@ -80,15 +80,25 @@ export function resolveAccurateReset(err, account, provider, nowMs = Date.now(),
     return targetReset + (Number(safetyBufferMs) || 0)
   }
 
-  const p = String(provider || (account && account.provider) || '').toLowerCase()
-  const windowDefault = VENDOR_WINDOW_MS[p]
-  if (windowDefault && err && (err.status === 429 || err.code === 'RATE_LIMIT' || err.code === 'QUOTA')) {
-    return now + windowDefault + (Number(safetyBufferMs) || 0)
-  }
-
+  // #684: a 429 without a disclosed reset is a local backoff, not a whole
+  // vendor window. Parking on a guessed 2-24h window burns a healthy account.
   return null
 }
 
+export function nextCooldownMs(accounts, now = Date.now()) {
+  const current = Number(now) || Date.now()
+  let next = null
+  for (const account of accounts || []) {
+    if (!account) continue
+    const candidates = [account.cooldownUntil, account.quarantineUntil, account.quota && account.quota.resetAt]
+    for (const value of candidates) {
+      const ts = Number(value)
+      if (Number.isFinite(ts) && ts > current) next = next === null ? ts : Math.min(next, ts)
+    }
+  }
+  return next === null ? null : next - current
+}
+
 export function formatRollingCountdown(resetAt, lang = 'en', now = Date.now()) {
   const ts = Number(resetAt)
   if (!Number.isFinite(ts) || ts <= 0) return ''

package/lib/route-report.js

@@ -0,0 +1,28 @@
+export function buildRouteReport(last, accounts, now = Date.now()) {
+  if (!last || !last.provider) return null
+  const current = Number(now) || Date.now()
+  const account = (Array.isArray(accounts) ? accounts : []).find((row) => row && row.ref === last.ref)
+  const source = (account && account.quota && account.quota.source) || account && account.quotaSource || 'unknown'
+  return {
+    at: last.at || last.timestamp || null,
+    route: {
+      provider: last.provider,
+      model: last.model || null,
+      path: last.path || null,
+      account: last.ref || null,
+    },
+    billing: {
+      provider: last.billingProvider || last.provider,
+      route: last.billingRoute || last.path || null,
+    },
+    quota: {
+      usedPercent: account && account.usagePercent != null ? account.usagePercent : null,
+      source,
+      ageMs: account && account.usageAt ? Math.max(0, current - Number(account.usageAt)) : null,
+      resetAt: (account && account.quota && account.quota.resetAt) || null,
+      confidence: source === 'unknown' ? 'unknown' : 'measured',
+    },
+    healthScore: account && account.healthScore != null ? account.healthScore : null,
+    stale: Boolean(account && account.usageAt && current - Number(account.usageAt) > 5 * 60 * 1000),
+  }
+}

package/lib/routes/status.js

@@ -10,6 +10,10 @@ import {
 } from '../reasoning-effort.js'
 import { defaultConcurrencyQueue } from '../concurrency-queue.js'
 import { calculateAnalytics } from '../analytics.js'
+import { setSpeedMode, getSpeedMode, clearSpeedMode } from '../speed-mode.js'
+import { getActiveConflicts } from '../coexistence.js'
+import { buildUsageRows, buildCallRows, toCsv } from '../usage-export.js'
+import { buildRouteReport } from '../route-report.js'
 import { runDiagnosticWizard } from '../diagnostic-wizard.js'
 import { buildEnrichedCatalog } from '../models-catalog.js'
 // #374: Sensitive GET routes protected by same-origin check
@@ -254,7 +258,7 @@ export function registerStatusRoutes(ctx, state) {
         labels,
         expiryNotifyDays: live().expiryNotifyDays,
         fastMode: !!live().codexFastMode,
-        composerQuota: String(live().composerQuota || 'off'),
+        composerQuota: String(live().composerQuota || 'off'),        composerQuotaDisplay: String(live().composerQuotaDisplay || 'current'),
         active,
       })
     }),
@@ -297,7 +301,14 @@ export function registerStatusRoutes(ctx, state) {
         writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
         return
       }
-      writeJson(res, 200, { ok: true, report: await diagnosticsReport() })
+      const accounts = await accountsView()
+      const last = history.recent(1)[0]
+      writeJson(res, 200, {
+        ok: true,
+        report: await diagnosticsReport(),
+        conflicts: getActiveConflicts(),
+        route: buildRouteReport(last, accounts),
+      })
     }),
   }), 'dsh-subscriptions: /diagnostics')
 
@@ -436,6 +447,45 @@ export function registerStatusRoutes(ctx, state) {
     }),
   }), 'dsh-subscriptions: /history')
 
+  // #687: quota snapshot and per-call ledger export for DSH quota plugins.
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/usage',
+    handler: safeJsonHandler(async (req, res) => {
+      if (req.method !== 'GET') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req, ctx)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      const q = queryOf(req)
+      const type = q.get('type') === 'calls' ? 'calls' : 'accounts'
+      const format = String(q.get('format') || 'json').toLowerCase()
+      const now = Date.now()
+      const accounts = await accountsView()
+      const calls = history.recent(500)
+      const rows = type === 'calls' ? buildCallRows(calls) : buildUsageRows(accounts, now)
+      if (format === 'csv') {
+        res.writeHead(200, {
+          'Content-Type': 'text/csv; charset=utf-8',
+          'Content-Disposition': 'attachment; filename="dsh-subscriptions-' + type + '.csv"',
+          'Cache-Control': 'no-store',
+        })
+        res.end(toCsv(rows))
+        return
+      }
+      writeJson(res, 200, {
+        ok: true,
+        generatedAt: now,
+        type,
+        rows,
+        summary: { accounts: Array.isArray(accounts) ? accounts.length : 0, calls: Array.isArray(calls) ? calls.length : 0 },
+      })
+    }),
+  }), 'dsh-subscriptions: /usage')
+
   // Telemetry summary route for UI stat cards (requests, latency, success rate)
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
@@ -716,6 +766,41 @@ export function registerStatusRoutes(ctx, state) {
     }),
   }), 'dsh-subscriptions: /queue')
 
+  // #681: per-session Codex Speed/Fast toggle.
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/speed',
+    handler: safeJsonHandler(async (req, res) => {
+      if (!isTrustedSettingsRequest(req, ctx)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      if (req.method === 'GET') {
+        const sid = queryOf(req).get('sessionId') || 'default'
+        writeJson(res, 200, { ok: true, sessionId: sid, mode: getSpeedMode(sid) || 'standard' })
+        return
+      }
+      if (req.method !== 'POST') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET or POST only' } })
+        return
+      }
+      let body = {}
+      try { body = JSON.parse((await readBody(req, 16 * 1024)).toString('utf8') || '{}') } catch {
+        writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
+        return
+      }
+      const sid = String(body.sessionId || 'default').slice(0, 200)
+      const mode = String(body.mode || '').toLowerCase()
+      if (mode !== 'fast' && mode !== 'standard' && mode !== 'off') {
+        writeJson(res, 400, { ok: false, error: { code: 'mode', message: 'mode must be fast or standard' } })
+        return
+      }
+      if (mode === 'fast') setSpeedMode(sid, 'fast')
+      else clearSpeedMode(sid)
+      writeJson(res, 200, { ok: true, sessionId: sid, mode: mode === 'fast' ? 'fast' : 'standard' })
+    }),
+  }), 'dsh-subscriptions: /speed')
+
   // #519: Interactive Diagnostic Wizard for accounts and connectivity
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',

package/lib/speed-mode.js

@@ -0,0 +1,17 @@
+const modes = new Map()
+
+export function setSpeedMode(sessionId, mode) {
+  const id = String(sessionId || '').trim()
+  if (!id) return
+  const value = String(mode || '').toLowerCase()
+  if (value === 'fast') modes.set(id, 'fast')
+  else modes.delete(id)
+}
+
+export function getSpeedMode(sessionId) {
+  return modes.get(String(sessionId || '').trim()) || null
+}
+
+export function clearSpeedMode(sessionId) {
+  modes.delete(String(sessionId || '').trim())
+}

package/lib/stream-rotate.js

@@ -7,7 +7,7 @@ import { notifySessionExpired, notifyQuarantineEntered } from './alerts.js'
 import { withRunawayGuard } from './runaway-guard.js'
 import { defaultErrorBuffer } from './error-buffer.js'
 import { withSoftFailureSentinel } from './sentinel.js'
-import { resolveAccurateReset } from './reset-clock.js'
+import { resolveAccurateReset, nextCooldownMs } from './reset-clock.js'
 
 export async function* streamWithRotation({
   accounts,
@@ -88,7 +88,15 @@ export async function* streamWithRotation({
         return
       }
       syncTrace('exhausted')
-      if (lastError) throw lastError
+      if (lastError) {
+        const wait = nextCooldownMs(pool, nowMs())
+        if (wait != null && options && options.rateLimitWait !== false) {
+          const maxWait = Number(options.rateLimitMaxWaitMs) || 6 * 3600 * 1000
+          lastError.retryAfterMs = Math.min(wait, maxWait)
+          lastError.resetAt = nowMs() + lastError.retryAfterMs
+        }
+        throw lastError
+      }
       const err = /** @type {Error & { code?: string }} */ (new Error('no usable subscription account for this provider'))
       err.code = 'RATE_LIMIT'
       throw err

package/lib/subscriptions.js

@@ -20,7 +20,7 @@ const OPENAI_COMPAT = [
 export const ALLOWLIST = {
   codex: ["/responses", "/models", "/images/generations", "/backend-api/codex/responses", "/backend-api/codex/models", "/backend-api/codex/images/generations"],
   claude: ["/v1/messages", "/api/oauth/profile", "/api/oauth/usage", "/v1/models"],
-  grok: ["/v1/models", "/responses", "/v1/responses", "/v1/billing", "/v1/chat/completions", "/images/generations", "/v1/images/generations"],
+  grok: ["/v1/models", "/responses", "/v1/responses", "/v1/billing", "/v1/chat/completions", "/images/generations", "/v1/images/generations", "/v1/videos"],
   antigravity: ["/v1/models", "/v1/generateContent", "/v1/streamGenerateContent", "/v1/loadCodeAssist", "/v1/fetchAvailableModels", "/v1/countTokens", "/v1/internal:loadCodeAssist"],
   kimi: OPENAI_COMPAT,
   glm: [...OPENAI_COMPAT, "/api/paas/v4/chat/completions", "/api/paas/v4/models"],

package/lib/usage-export.js

@@ -0,0 +1,52 @@
+function csvCell(value) {
+  const text = value == null ? '' : String(value)
+  return /[",\n\r]/.test(text) ? '"' + text.replace(/"/g, '""') + '"' : text
+}
+
+export function toCsv(rows) {
+  const list = Array.isArray(rows) ? rows : []
+  if (!list.length) return ''
+  const headers = Object.keys(list[0])
+  const lines = [headers.map(csvCell).join(',')]
+  for (const row of list) lines.push(headers.map((key) => csvCell(row[key])).join(','))
+  return lines.join('\n') + '\n'
+}
+
+export function buildUsageRows(accounts, now = Date.now()) {
+  const current = Number(now) || Date.now()
+  return (Array.isArray(accounts) ? accounts : []).map((account) => ({
+    ref: account.ref || '',
+    provider: account.provider || '',
+    index: account.index ?? '',
+    label: account.label || '',
+    plan: account.plan || account.paidTierName || '',
+    configured: Boolean(account.hasToken || account.configured),
+    usagePercent: account.usagePercent ?? '',
+    remainingPercent: account.usagePercent != null ? Math.max(0, 100 - Number(account.usagePercent)) : '',
+    quotaSource: (account.quota && account.quota.source) || 'unknown',
+    usageAgeMs: account.usageAt ? Math.max(0, current - Number(account.usageAt)) : '',
+    resetAt: (account.quota && account.quota.resetAt) || '',
+    cooldownUntil: account.cooldownUntil || '',
+    quarantineUntil: account.quarantineUntil || '',
+    quarantineReason: account.quarantineReason || '',
+    healthScore: account.healthScore ?? '',
+    monthlyCost: account.monthlyCost ?? '',
+  }))
+}
+
+export function buildCallRows(calls) {
+  return (Array.isArray(calls) ? calls : []).map((call) => ({
+    at: call.at || call.timestamp || '',
+    provider: call.provider || '',
+    ref: call.ref || '',
+    model: call.model || '',
+    path: call.path || '',
+    ok: call.ok !== false,
+    status: call.status ?? '',
+    inputTokens: call.inputTokens ?? '',
+    outputTokens: call.outputTokens ?? '',
+    cacheReadTokens: call.cacheReadTokens ?? '',
+    durationMs: call.durationMs ?? '',
+    error: call.error || '',
+  }))
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-subscriptions",
-  "version": "0.6.91",
+  "version": "0.7.2",
   "description": "Use ChatGPT Codex, Claude, Grok, Antigravity, Kimi, GLM, Cursor, Kiro, Copilot, Qwen, ERNIE, Spark, JetBrains, Perplexity, Replit, and Cody subscriptions as DeepSeek Harness LLM providers via OAuth.",
   "license": "MIT",
   "type": "module",