@goodandready/dsh-subscriptions 0.6.60 → 0.6.62

package/lib/client.js

@@ -122,6 +122,10 @@ window.__ModuleLoader__.load({
     '.dsub-stat-box{padding:10px 12px;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;background:var(--dsw-alias-bg-layer-2);display:flex;flex-direction:column;gap:3px}' +
     '.dsub-stat-val{font-size:16.5px;font-weight:700;color:var(--dsw-alias-label-primary)}' +
     '.dsub-stat-lbl{font-size:11.5px;color:var(--dsw-alias-label-secondary)}' +
+    '.dsub-chart-wrap{display:flex;align-items:flex-end;gap:3px;height:52px;padding:6px 0;margin-top:8px;border-bottom:1px solid var(--dsw-alias-border-l3)}' +
+    '.dsub-chart-bar{flex:1;background:var(--dsw-alias-brand-primary);border-radius:2px 2px 0 0;min-height:3px;transition:height .2s ease;opacity:0.85;cursor:pointer}' +
+    '.dsub-chart-bar:hover{opacity:1;background:var(--dsw-alias-state-success-primary)}' +
+    '.dsub-chart-labels{display:flex;justify-content:space-between;font-size:10px;color:var(--dsw-alias-label-secondary);margin-top:3px}' +
     '.dsub-alert-ok{padding:8px 12px;border-radius:8px;background:color-mix(in srgb,var(--dsw-alias-state-success-primary) 10%,transparent);color:var(--dsw-alias-state-success-primary);font-size:12.5px;border:1px solid color-mix(in srgb,var(--dsw-alias-state-success-primary) 25%,transparent)}' +
     '.dsub-alert-bad{padding:8px 12px;border-radius:8px;background:color-mix(in srgb,var(--dsw-alias-state-error-primary) 10%,transparent);color:var(--dsw-alias-state-error-primary);font-size:12.5px;border:1px solid color-mix(in srgb,var(--dsw-alias-state-error-primary) 25%,transparent)}' +
     '.dsub-btn-primary{background:var(--dsw-alias-label-primary) !important;color:var(--dsw-alias-bg-layer-3) !important;border-color:transparent !important;font-weight:600}' +
@@ -130,6 +134,15 @@ window.__ModuleLoader__.load({
     '.dsub-model-chip{display:inline-flex;align-items:center;gap:6px;padding:3px 8px;border-radius:6px;background:var(--dsw-alias-bg-layer-1);border:1px solid var(--dsw-alias-border-l2);font-size:11.5px;color:var(--dsw-alias-label-primary)}' +
     '.dsub-model-chip code{font-family:ui-monospace,monospace;font-weight:600}' +
     '.dsub-model-tag{font-size:10px;padding:1px 4px;border-radius:3px;background:var(--dsw-alias-bg-layer-2);color:var(--dsw-alias-label-secondary);font-weight:600}' +
+    '.dsub-trace-box{padding:8px 12px;border-radius:8px;background:var(--dsw-alias-bg-layer-2);border:1px solid var(--dsw-alias-border-l2);margin-top:8px;font-size:12px}' +
+    '.dsub-trace-row{display:flex;align-items:center;justify-content:space-between;gap:8px;padding:4px 0;border-bottom:1px solid var(--dsw-alias-border-l3)}' +
+    '.dsub-trace-row:last-child{border-bottom:none}' +
+    '.dsub-model-status-available{color:var(--dsw-alias-state-success-primary);background:color-mix(in srgb,var(--dsw-alias-state-success-primary) 12%,transparent)}' +
+    '.dsub-model-status-degraded{color:var(--dsw-alias-state-warn-primary);background:color-mix(in srgb,var(--dsw-alias-state-warn-primary) 12%,transparent)}' +
+    '.dsub-model-status-quarantined{color:var(--dsw-alias-state-error-primary);background:color-mix(in srgb,var(--dsw-alias-state-error-primary) 12%,transparent)}' +
+    '.dsub-model-status-cooldown{color:var(--dsw-alias-state-business-primary);background:color-mix(in srgb,var(--dsw-alias-state-business-primary) 12%,transparent)}' +
+    '.dsub-model-status-exhausted{color:var(--dsw-alias-state-error-primary);background:color-mix(in srgb,var(--dsw-alias-state-error-primary) 12%,transparent)}' +
+    '.dsub-model-status-unconfigured{color:var(--dsw-alias-label-tertiary);background:var(--dsw-alias-bg-layer-3)}' +
     '.dsub-heroBars{display:flex;flex-direction:column;gap:8px;margin-top:10px}' +
     '.dsub-barLabelRow{display:flex;justify-content:space-between;font-size:11.5px;color:var(--dsw-alias-label-secondary);margin-bottom:3px}' +
     '.dsub-barTrack{height:6px;border-radius:3px;background:var(--dsw-alias-bg-layer-1);overflow:hidden}' +
@@ -408,6 +421,17 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       "smokeFail": "Smoke test failed",
       "modelsCatalogTitle": "Curated Subscription Models",
       "modelsCatalogDesc": "Available model catalog across active subscriptions in DeepSeek Harness.",
+      "rotationDecisionsTitle": "Rotation & Routing Decisions",
+      "rotationDecisionsDesc": "Real-time decision trace explaining account selection, skips, and fallback reasons.",
+      "rotationAttempt": "attempt",
+      "rotationAttempts": "attempts",
+      "rotationCascaded": "Cascaded fallback",
+      "modelPoolAvailable": "Available",
+      "modelPoolDegraded": "Degraded",
+      "modelPoolQuarantined": "Quarantined",
+      "modelPoolCooldown": "Cooldown",
+      "modelPoolExhausted": "Exhausted",
+      "modelPoolUnconfigured": "Unconfigured",
       "resetCredits": "Reset credits",
       "resetCreditsHint": "ChatGPT reset cards: emergency reset for the 5-hour window. Requires a 5s confirmation.",
       "resetCreditsAction": "Reset ChatGPT Limit",
@@ -549,6 +573,27 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       "toastReleased": "Account active and healthy",
       "toastQuotaWarning": "Quota threshold exceeded",
       "enableToasts": "In-app toast alerts",
+      "groupQueue": "Concurrency & Request Queue",
+      "enableQueue": "Enable request queue",
+      "enableQueueHint": "Queue excess requests when account hits concurrency limit instead of failing with 429",
+      "accountMaxConcurrency": "Max concurrent streams per account",
+      "accountMaxConcurrencyHint": "Maximum simultaneous streaming requests allowed per account (default 2)",
+      "maxQueueSize": "Max queue depth",
+      "maxQueueSizeHint": "Maximum queued requests per account before rejecting with overflow (default 20)",
+      "queueTimeoutSec": "Queue wait timeout (seconds)",
+      "queueTimeoutSecHint": "Maximum wait time in queue before timeout rejection (default 30s)",
+      "analyticsTitle": "Subscription & Cache Analytics",
+      "analyticsDesc": "Cache hit rate, token caching efficiency, TTFT latency, generation speed, and 24h activity",
+      "ttftMetric": "TTFT Latency",
+      "speedMetric": "Speed",
+      "queueActive": "Active Streams",
+      "queueWaiting": "Queued",
+      "queueRejected": "Rejected",
+      "activity24h": "24-Hour Activity Distribution",
+      "forecastTitle": "Quota Exhaustion Forecast",
+      "forecastRunway": "Estimated runway",
+      "forecastBurnRate": "Burn rate",
+      "forecastExhaustWarning": "Quota projected to exhaust before reset window",
       "field.enableToasts": "Show popup toast notifications on quarantine or quota events"
 };
 
@@ -619,6 +664,17 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       "smokeFail": "冒烟测试失败",
       "modelsCatalogTitle": "精选订阅模型",
       "modelsCatalogDesc": "当前 DeepSeek Harness 活跃订阅下可用模型一览。",
+      "rotationDecisionsTitle": "轮询调度与路由决策",
+      "rotationDecisionsDesc": "实时决策追踪，透明展示每次请求的账号选择、跳过与回退原因。",
+      "rotationAttempt": "次尝试",
+      "rotationAttempts": "次尝试",
+      "rotationCascaded": "级联回退",
+      "modelPoolAvailable": "就绪可用",
+      "modelPoolDegraded": "降级运行",
+      "modelPoolQuarantined": "已隔离",
+      "modelPoolCooldown": "冷却中",
+      "modelPoolExhausted": "额度耗尽",
+      "modelPoolUnconfigured": "未配置",
       "resetCredits": "重置 ChatGPT 额度",
       "resetCreditsHint": "ChatGPT 重置卡：紧急重置 5 小时额度窗口。扣除前需等待 5 秒倒计时确认。",
       "resetCreditsAction": "重置 ChatGPT 限制",
@@ -760,6 +816,27 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       "toastReleased": "账户已解除隔离恢复使用",
       "toastQuotaWarning": "额度预警",
       "enableToasts": "应用内弹窗提醒",
+      "groupQueue": "并发限制与请求队列",
+      "enableQueue": "启用并发请求排队",
+      "enableQueueHint": "当账户达到并发上限时将多余请求排队等待，避免直接触发 429 报错",
+      "accountMaxConcurrency": "单账户最大并发流数",
+      "accountMaxConcurrencyHint": "每个账户允许同时执行的最大流式请求数（默认 2）",
+      "maxQueueSize": "队列最大等待深度",
+      "maxQueueSizeHint": "每个账户允许排队的最大请求数，超限后拒绝执行（默认 20）",
+      "queueTimeoutSec": "排队超时时间（秒）",
+      "queueTimeoutSecHint": "在队列中等待槽位的最长时间，超时后自动放弃并回退（默认 30 秒）",
+      "analyticsTitle": "订阅与缓存深度分析",
+      "analyticsDesc": "缓存命中率、Token 缓存效率、首字响应延迟 (TTFT)、生成速度及 24 小时负载分布",
+      "ttftMetric": "首字响应延迟 (TTFT)",
+      "speedMetric": "生成速度",
+      "queueActive": "活跃流",
+      "queueWaiting": "排队中",
+      "queueRejected": "已拒绝",
+      "activity24h": "24 小时活动分布",
+      "forecastTitle": "额度消耗预测与预警",
+      "forecastRunway": "预计可用时间",
+      "forecastBurnRate": "消耗速率",
+      "forecastExhaustWarning": "预计在额度重置前耗尽",
       "field.enableToasts": "当账户发生隔离或额度达到警戒线时显示即时弹窗提醒"
 };
     // #51: live countdown to the quota window reset (account.quota.resetAt).
@@ -878,6 +955,7 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       const [draft, setDraft] = React.useState(null)
       const [accounts, setAccounts] = React.useState([])
       const [providers, setProviders] = React.useState([])
+      const [modelsCatalog, setModelsCatalog] = React.useState([])
       const [paste, setPaste] = React.useState({})
       const [device, setDevice] = React.useState({})  // #90 key -> {state,userCode,authUrl,intervalMs,status}
       const [proxyRes, setProxyRes] = React.useState({})  // #88 key -> {ok,latencyMs,error}
@@ -983,6 +1061,8 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       const [checkRes, setCheckRes] = React.useState({})
       const [hostPing, setHostPing] = React.useState({ ok: true, latencyMs: null })
       const [telemetry, setTelemetry] = React.useState(null)
+      const [analytics, setAnalytics] = React.useState(null)
+      const [queueStats, setQueueStats] = React.useState(null)
       const [smoke, setSmoke] = React.useState({ testing: false, result: null })
       const [updater, setUpdater] = React.useState({ checking: false, updating: false, status: null, message: '' })
       const [backupModal, setBackupModal] = React.useState(null)
@@ -1085,6 +1165,14 @@ const cssId = 'dsh-subscriptions/settings.module.css'
           .then((r) => r.json())
           .then((d) => { if (d && d.ok && d.telemetry) setTelemetry(d.telemetry) })
           .catch(() => {})
+        fetch('/dsh-subscriptions/analytics', { cache: 'no-store' })
+          .then((r) => r.json())
+          .then((d) => { if (d && d.ok && d.analytics) setAnalytics(d.analytics) })
+          .catch(() => {})
+        fetch('/dsh-subscriptions/queue', { cache: 'no-store' })
+          .then((r) => r.json())
+          .then((d) => { if (d && d.ok && d.queue) setQueueStats(d.queue) })
+          .catch(() => {})
       }
 
       const runSmokeTest = async (provider, index) => {
@@ -1115,6 +1203,7 @@ const cssId = 'dsh-subscriptions/settings.module.css'
         setDraft(JSON.parse(JSON.stringify((data && data.config) || {})))
         setAccounts((data && data.accounts) || [])
         setProviders((data && data.providers) || [])
+        setModelsCatalog((data && data.modelsCatalog) || [])
       }
 
       const reload = () => {
@@ -1473,6 +1562,88 @@ const cssId = 'dsh-subscriptions/settings.module.css'
             React.createElement('div', { className: 'dsub-stat-lbl' }, t('statsLastActivity')),
           ),
         ) : null,
+        (analytics && (analytics.totalRequests > 0 || (analytics.hourly && analytics.hourly.some(function(b) { return b.requests > 0 })))) || (queueStats && (queueStats.totalActive > 0 || queueStats.totalQueued > 0)) ? React.createElement('details', { className: 'dsub-group', open: true, style: { marginBottom: '14px' } },
+          React.createElement('summary', { className: 'dsub-groupHead' }, '📊 ' + t('analyticsTitle')),
+          React.createElement('div', { className: 'dsub-sub', style: { marginTop: '4px' } }, t('analyticsDesc')),
+          React.createElement('div', { className: 'dsub-grid-2', style: { marginTop: '10px' } },
+            React.createElement('div', { className: 'dsub-stat-box' },
+              React.createElement('div', { className: 'dsub-stat-val' }, ((analytics && analytics.cache && analytics.cache.cacheHitRate) || 0) + '%'),
+              React.createElement('div', { className: 'dsub-stat-lbl' }, t('cacheHitRate') + (analytics && analytics.cache ? ' (' + (analytics.cache.cacheReadTokens || 0).toLocaleString() + ' tok)' : '')),
+            ),
+            React.createElement('div', { className: 'dsub-stat-box' },
+              React.createElement('div', { className: 'dsub-stat-val' }, (analytics && analytics.performance && analytics.performance.ttft && analytics.performance.ttft.avgMs != null ? analytics.performance.ttft.avgMs + ' ms' : '—')),
+              React.createElement('div', { className: 'dsub-stat-lbl' }, t('ttftMetric') + (analytics && analytics.performance && analytics.performance.ttft && analytics.performance.ttft.p95Ms != null ? ' · p95 ' + analytics.performance.ttft.p95Ms + ' ms' : '')),
+            ),
+            React.createElement('div', { className: 'dsub-stat-box' },
+              React.createElement('div', { className: 'dsub-stat-val' }, (analytics && analytics.performance && analytics.performance.tps && analytics.performance.tps.avg != null ? analytics.performance.tps.avg + ' tok/s' : '—')),
+              React.createElement('div', { className: 'dsub-stat-lbl' }, t('speedMetric') + (analytics && analytics.performance && analytics.performance.tps && analytics.performance.tps.p95 != null ? ' · p95 ' + analytics.performance.tps.p95 : '')),
+            ),
+            React.createElement('div', { className: 'dsub-stat-box' },
+              React.createElement('div', { className: 'dsub-stat-val' }, (queueStats ? queueStats.totalActive : 0) + ' / ' + (queueStats ? queueStats.totalQueued : 0)),
+              React.createElement('div', { className: 'dsub-stat-lbl' }, t('queueActive') + ' / ' + t('queueWaiting') + (queueStats && queueStats.metrics && queueStats.metrics.totalOverflowed ? ' · ' + queueStats.metrics.totalOverflowed + ' ' + t('queueRejected') : '')),
+            ),
+          ),
+          analytics && Array.isArray(analytics.hourly) && analytics.hourly.length ? (function() {
+            var maxReq = Math.max.apply(Math, [1].concat(analytics.hourly.map(function(b) { return b.requests || 0 })))
+            return React.createElement('div', { style: { marginTop: '12px' } },
+              React.createElement('div', { style: { fontSize: '11.5px', fontWeight: 600, color: 'var(--dsw-alias-label-secondary)' } }, t('activity24h')),
+              React.createElement('div', { className: 'dsub-chart-wrap' },
+                analytics.hourly.map(function(b, idx) {
+                  var pct = Math.max(4, Math.round(((b.requests || 0) / maxReq) * 100))
+                  var title = b.label + ': ' + b.requests + ' req (' + b.cacheReadTokens + ' cached tok, ' + b.errorCount + ' err)'
+                  return React.createElement('div', {
+                    key: idx,
+                    className: 'dsub-chart-bar',
+                    style: {
+                      height: pct + '%',
+                      backgroundColor: b.errorCount > 0 && b.requests === b.errorCount
+                        ? 'var(--dsw-alias-state-error-primary)'
+                        : (b.cacheReadTokens > 0 ? 'var(--dsw-alias-brand-primary)' : 'var(--dsw-alias-state-success-primary)'),
+                    },
+                    title: title,
+                  })
+                })
+              ),
+              React.createElement('div', { className: 'dsub-chart-labels' },
+                React.createElement('span', null, '-24h'),
+                React.createElement('span', null, '-18h'),
+                React.createElement('span', null, '-12h'),
+                React.createElement('span', null, '-6h'),
+                React.createElement('span', null, 'Now'),
+              ),
+            )
+          })() : null,
+          analytics && Array.isArray(analytics.forecast) && analytics.forecast.some(function(f) { return f.willExhaustBeforeReset || (f.burnRateTokensPerHour > 0 && f.hoursToExhaustion != null && f.hoursToExhaustion < 72) }) ? React.createElement('div', { style: { marginTop: '12px' } },
+            React.createElement('div', { style: { fontSize: '11.5px', fontWeight: 600, color: 'var(--dsw-alias-state-warn-primary)', marginBottom: '6px' } }, '⚠️ ' + t('forecastTitle')),
+            analytics.forecast.filter(function(f) { return f.willExhaustBeforeReset || (f.burnRateTokensPerHour > 0 && f.hoursToExhaustion != null && f.hoursToExhaustion < 72) }).map(function(f, idx) {
+              return React.createElement('div', { key: idx, className: 'dsub-alert-bad', style: { marginBottom: '6px' } },
+                (f.provider ? f.provider.toUpperCase() : 'LLM') + ' (' + (f.label || f.ref) + '): ' +
+                (f.willExhaustBeforeReset ? t('forecastExhaustWarning') : (t('forecastRunway') + ': ~' + f.hoursToExhaustion + 'h')) +
+                ' · ' + t('forecastBurnRate') + ': ' + f.burnRateTokensPerHour.toLocaleString() + ' tok/h'
+              )
+            })
+          ) : null,
+        ) : null,
+        telemetry && Array.isArray(telemetry.recentDecisions) && telemetry.recentDecisions.length ? React.createElement('details', { className: 'dsub-group', style: { marginBottom: '14px' } },
+          React.createElement('summary', { className: 'dsub-groupHead' }, '🧭 ' + t('rotationDecisionsTitle')),
+          React.createElement('div', { className: 'dsub-sub', style: { marginTop: '4px' } }, t('rotationDecisionsDesc')),
+          React.createElement('div', { className: 'dsub-trace-box' },
+            telemetry.recentDecisions.map((dec, idx) => {
+              const reasonBadge = dec.cascaded ? ('🔀 ' + t('rotationCascaded')) : (dec.decisionReason === 'session_pinned' ? '📌 Pinned' : ('⚡ ' + dec.decisionReason))
+              return React.createElement('div', { key: idx, className: 'dsub-trace-row' },
+                React.createElement('div', { style: { display: 'flex', alignItems: 'center', gap: '6px' } },
+                  dec.provider ? React.createElement('span', { className: 'dsub-brand dsub-brand-' + dec.provider, style: { fontSize: '9px', padding: '1px 4px' } }, dec.provider.toUpperCase()) : null,
+                  React.createElement('span', { style: { fontWeight: 600 } }, dec.ref || '—'),
+                  dec.model ? React.createElement('code', { style: { fontSize: '11px', opacity: 0.8 } }, dec.model) : null,
+                ),
+                React.createElement('div', { style: { display: 'flex', alignItems: 'center', gap: '8px' } },
+                  React.createElement('span', { className: 'dsub-model-tag' }, reasonBadge),
+                  React.createElement('span', { style: { fontSize: '10.5px', opacity: 0.6 } }, dec.attemptsCount > 1 ? (dec.attemptsCount + ' ' + t('rotationAttempts')) : ('1 ' + t('rotationAttempt'))),
+                ),
+              )
+            })
+          ),
+        ) : null,
         accounts && accounts.length ? React.createElement('details', { className: 'dsub-group', open: true, style: { marginBottom: '14px' } },
           React.createElement('summary', { className: 'dsub-groupHead' }, '📊 ' + (t('healthMatrix') || 'Health Matrix & Quota Runway')),
           React.createElement('div', { style: { padding: '8px 0', overflowX: 'auto' } },
@@ -1587,6 +1758,57 @@ const cssId = 'dsh-subscriptions/settings.module.css'
           React.createElement('div', { className: 'dsub-sub' },
             t('expiryNotifyDaysHint')),
           ),
+          React.createElement('details', { className: 'dsub-group', open: true },
+            React.createElement('summary', { className: 'dsub-groupHead' }, '🚦 ' + t('groupQueue')),
+            React.createElement('label', { className: 'dsub-row' },
+              React.createElement('input', {
+                type: 'checkbox',
+                checked: draft.enableQueue !== false,
+                onChange: function(e) { setDraft(function(d) { return Object.assign({}, d, { enableQueue: e.target.checked }) }) },
+              }),
+              React.createElement('span', null, t('enableQueue')),
+            ),
+            React.createElement('div', { className: 'dsub-sub' }, t('enableQueueHint')),
+            React.createElement('div', { className: 'dsub-row' },
+              React.createElement('span', { className: 'dsub-h' }, t('accountMaxConcurrency')),
+              React.createElement('input', {
+                type: 'number',
+                className: 'dsub-inp',
+                style: { width: '80px', minWidth: '80px' },
+                min: 1,
+                max: 20,
+                value: draft.accountMaxConcurrency != null ? draft.accountMaxConcurrency : 2,
+                onChange: function(e) { setDraft(function(d) { return Object.assign({}, d, { accountMaxConcurrency: Math.max(1, Number(e.target.value) || 2) }) }) },
+              }),
+            ),
+            React.createElement('div', { className: 'dsub-sub' }, t('accountMaxConcurrencyHint')),
+            React.createElement('div', { className: 'dsub-row' },
+              React.createElement('span', { className: 'dsub-h' }, t('maxQueueSize')),
+              React.createElement('input', {
+                type: 'number',
+                className: 'dsub-inp',
+                style: { width: '80px', minWidth: '80px' },
+                min: 1,
+                max: 100,
+                value: draft.maxQueueSize != null ? draft.maxQueueSize : 20,
+                onChange: function(e) { setDraft(function(d) { return Object.assign({}, d, { maxQueueSize: Math.max(1, Number(e.target.value) || 20) }) }) },
+              }),
+            ),
+            React.createElement('div', { className: 'dsub-sub' }, t('maxQueueSizeHint')),
+            React.createElement('div', { className: 'dsub-row' },
+              React.createElement('span', { className: 'dsub-h' }, t('queueTimeoutSec')),
+              React.createElement('input', {
+                type: 'number',
+                className: 'dsub-inp',
+                style: { width: '80px', minWidth: '80px' },
+                min: 1,
+                max: 120,
+                value: Math.round((draft.queueTimeoutMs != null ? draft.queueTimeoutMs : 30000) / 1000),
+                onChange: function(e) { setDraft(function(d) { return Object.assign({}, d, { queueTimeoutMs: Math.max(1, Number(e.target.value) || 30) * 1000 }) }) },
+              }),
+            ),
+            React.createElement('div', { className: 'dsub-sub' }, t('queueTimeoutSecHint')),
+          ),
           React.createElement('details', { className: 'dsub-group', open: true },
             React.createElement('summary', { className: 'dsub-groupHead' }, t('groupProvider')),
           React.createElement('label', { className: 'dsub-row' },
@@ -1648,14 +1870,51 @@ const cssId = 'dsh-subscriptions/settings.module.css'
             React.createElement('summary', { className: 'dsub-groupHead' }, '🎯 ' + t('modelsCatalogTitle')),
             React.createElement('div', { className: 'dsub-sub', style: { marginTop: '4px' } }, t('modelsCatalogDesc')),
             React.createElement('div', { className: 'dsub-model-grid' },
-              React.createElement('div', { className: 'dsub-model-chip' }, React.createElement('code', null, 'gpt-4o'), React.createElement('span', { className: 'dsub-model-tag' }, '128k · Vision')),
-              React.createElement('div', { className: 'dsub-model-chip' }, React.createElement('code', null, 'o1 / o3-mini'), React.createElement('span', { className: 'dsub-model-tag' }, '200k · Reasoning')),
-              React.createElement('div', { className: 'dsub-model-chip' }, React.createElement('code', null, 'claude-3-7-sonnet'), React.createElement('span', { className: 'dsub-model-tag' }, '200k · Hybrid')),
-              React.createElement('div', { className: 'dsub-model-chip' }, React.createElement('code', null, 'claude-3-5-sonnet'), React.createElement('span', { className: 'dsub-model-tag' }, '200k · Coding')),
-              React.createElement('div', { className: 'dsub-model-chip' }, React.createElement('code', null, 'grok-beta'), React.createElement('span', { className: 'dsub-model-tag' }, '128k · Speed')),
-              React.createElement('div', { className: 'dsub-model-chip' }, React.createElement('code', null, 'gemini-2.5-pro'), React.createElement('span', { className: 'dsub-model-tag' }, '1M · Context')),
-              React.createElement('div', { className: 'dsub-model-chip' }, React.createElement('code', null, 'kimi-k1.5'), React.createElement('span', { className: 'dsub-model-tag' }, '128k · Math')),
-              React.createElement('div', { className: 'dsub-model-chip' }, React.createElement('code', null, 'glm-4-plus'), React.createElement('span', { className: 'dsub-model-tag' }, '128k · Chinese')),
+              (Array.isArray(modelsCatalog) && modelsCatalog.length ? modelsCatalog : [
+                { id: 'gpt-4o', contextLabel: '128k', capabilities: ['vision'], pool: { status: 'available' } },
+                { id: 'o1 / o3-mini', contextLabel: '200k', capabilities: ['reasoning'], pool: { status: 'available' } },
+                { id: 'claude-3-7-sonnet', contextLabel: '200k', capabilities: ['reasoning'], pool: { status: 'available' } },
+                { id: 'claude-3-5-sonnet', contextLabel: '200k', capabilities: ['coding'], pool: { status: 'available' } },
+                { id: 'grok-beta', contextLabel: '128k', capabilities: ['fast'], pool: { status: 'available' } },
+                { id: 'gemini-2.5-pro', contextLabel: '1M', capabilities: ['vision'], pool: { status: 'available' } },
+                { id: 'kimi-k1.5', contextLabel: '128k', capabilities: ['math'], pool: { status: 'available' } },
+                { id: 'glm-4-plus', contextLabel: '128k', capabilities: ['chinese'], pool: { status: 'available' } },
+              ]).map((m, idx) => {
+                const poolStatus = m.pool ? m.pool.status : 'unconfigured'
+                const statusClass = 'dsub-model-status-' + poolStatus
+                let poolLabel = ''
+                if (poolStatus === 'available') {
+                  poolLabel = '🟢 ' + (m.pool && m.pool.remainingPercent != null ? (m.pool.remainingPercent + '%') : t('modelPoolAvailable'))
+                } else if (poolStatus === 'degraded') {
+                  poolLabel = '🟡 ' + t('modelPoolDegraded') + (m.pool ? ' (' + m.pool.healthyAccounts + '/' + m.pool.totalAccounts + ')' : '')
+                } else if (poolStatus === 'quarantined') {
+                  poolLabel = '⛔ ' + t('modelPoolQuarantined')
+                } else if (poolStatus === 'cooldown') {
+                  poolLabel = '❄️ ' + t('modelPoolCooldown')
+                } else if (poolStatus === 'exhausted') {
+                  poolLabel = '⚠️ ' + t('modelPoolExhausted')
+                } else {
+                  poolLabel = '⚪ ' + t('modelPoolUnconfigured')
+                }
+
+                const tags = []
+                if (m.contextLabel) tags.push(m.contextLabel)
+                if (Array.isArray(m.capabilities)) {
+                  for (const c of m.capabilities) {
+                    if (c === 'vision') tags.push('Vision')
+                    else if (c === 'reasoning') tags.push('Reasoning')
+                    else if (c === 'coding') tags.push('Coding')
+                    else if (c === 'fast') tags.push('Fast')
+                  }
+                }
+
+                return React.createElement('div', { key: (m.id || idx) + '_' + idx, className: 'dsub-model-chip' },
+                  m.provider ? React.createElement('span', { className: 'dsub-brand dsub-brand-' + m.provider, style: { fontSize: '9px', padding: '1px 4px' } }, m.provider.toUpperCase()) : null,
+                  React.createElement('code', null, m.name || m.id),
+                  tags.length ? React.createElement('span', { className: 'dsub-model-tag' }, tags.join(' · ')) : null,
+                  React.createElement('span', { className: 'dsub-model-tag ' + statusClass }, poolLabel),
+                )
+              })
             ),
           ),
           React.createElement('details', { className: 'dsub-details' },

package/lib/concurrency-queue.js

@@ -0,0 +1,222 @@
+// Concurrency limiting, bounded queue, and cooperative cancellation per account/provider.
+// Standardized error codes: QUEUE_OVERFLOW, QUEUE_TIMEOUT, ABORT_ERR, QUEUE_DISPOSED.
+
+/**
+ * @param {string} message
+ * @param {string} code
+ * @param {number} [status]
+ * @returns {Error & { code: string, status?: number }}
+ */
+function createQueueError(message, code, status) {
+  const err = /** @type {Error & { code: string, status?: number }} */ (new Error(message))
+  err.code = code
+  if (status !== undefined) err.status = status
+  return err
+}
+
+export class ConcurrencyQueue {
+  constructor(options = {}) {
+    this.maxConcurrency = options.maxConcurrency !== undefined ? Number(options.maxConcurrency) : 2
+    this.maxQueueSize = options.maxQueueSize !== undefined ? Number(options.maxQueueSize) : 20
+    this.timeoutMs = options.timeoutMs !== undefined ? Number(options.timeoutMs) : 30000
+    this.enabled = options.enabled !== undefined ? Boolean(options.enabled) : true
+
+    /** @type {Map<string, number>} */
+    this._active = new Map()
+    /** @type {Map<string, Array<{ id: string, resolve: Function, reject: Function, timer: any, signal: any, abortHandler: Function | null, enqueuedAt: number }>>} */
+    this._waiting = new Map()
+
+    this._stats = {
+      totalAcquired: 0,
+      totalReleased: 0,
+      totalQueued: 0,
+      totalTimedOut: 0,
+      totalOverflowed: 0,
+      totalAborted: 0,
+    }
+  }
+
+  configure(options = {}) {
+    if (options.maxConcurrency !== undefined) this.maxConcurrency = Number(options.maxConcurrency)
+    if (options.maxQueueSize !== undefined) this.maxQueueSize = Number(options.maxQueueSize)
+    if (options.timeoutMs !== undefined) this.timeoutMs = Number(options.timeoutMs)
+    if (options.enabled !== undefined) this.enabled = Boolean(options.enabled)
+  }
+
+  async acquire(key = 'default', options = {}) {
+    if (!this.enabled) {
+      return () => {}
+    }
+
+    const signal = options.signal
+    if (signal && signal.aborted) {
+      const err = createQueueError('Request aborted before acquiring queue slot', 'ABORT_ERR')
+      err.name = 'AbortError'
+      this._stats.totalAborted++
+      throw err
+    }
+
+    const k = String(key || 'default')
+    const active = this._active.get(k) || 0
+    const limit = options.maxConcurrency !== undefined ? Number(options.maxConcurrency) : this.maxConcurrency
+
+    if (active < limit) {
+      this._active.set(k, active + 1)
+      this._stats.totalAcquired++
+      return this._createRelease(k)
+    }
+
+    // Queue is required
+    const queueList = this._waiting.get(k) || []
+    const maxQ = options.maxQueueSize !== undefined ? Number(options.maxQueueSize) : this.maxQueueSize
+
+    if (queueList.length >= maxQ) {
+      this._stats.totalOverflowed++
+      const err = createQueueError(`Concurrency queue overflow for ${k} (max queue size: ${maxQ})`, 'QUEUE_OVERFLOW', 429)
+      throw err
+    }
+
+    const timeoutDuration = options.timeoutMs !== undefined ? Number(options.timeoutMs) : this.timeoutMs
+    this._stats.totalQueued++
+
+    return new Promise((resolve, reject) => {
+      let timer = null
+      let abortHandler = null
+      const id = Math.random().toString(36).slice(2)
+
+      const cleanup = () => {
+        if (timer) clearTimeout(timer)
+        if (signal && abortHandler && typeof signal.removeEventListener === 'function') {
+          signal.removeEventListener('abort', abortHandler)
+        }
+      }
+
+      if (timeoutDuration > 0) {
+        timer = setTimeout(() => {
+          cleanup()
+          this._removeFromWaiting(k, id)
+          this._stats.totalTimedOut++
+          const err = createQueueError(`Concurrency queue wait timeout for ${k} after ${timeoutDuration}ms`, 'QUEUE_TIMEOUT', 504)
+          reject(err)
+        }, timeoutDuration)
+      }
+
+      if (signal) {
+        abortHandler = () => {
+          cleanup()
+          this._removeFromWaiting(k, id)
+          this._stats.totalAborted++
+          const err = createQueueError('Request aborted while waiting in concurrency queue', 'ABORT_ERR')
+          err.name = 'AbortError'
+          reject(err)
+        }
+        signal.addEventListener('abort', abortHandler, { once: true })
+      }
+
+      const item = {
+        id,
+        resolve: () => {
+          cleanup()
+          this._stats.totalAcquired++
+          resolve(this._createRelease(k))
+        },
+        reject: (err) => {
+          cleanup()
+          reject(err)
+        },
+        timer,
+        signal,
+        abortHandler,
+        enqueuedAt: Date.now(),
+      }
+
+      if (!this._waiting.has(k)) {
+        this._waiting.set(k, [])
+      }
+      this._waiting.get(k).push(item)
+    })
+  }
+
+  _createRelease(k) {
+    let released = false
+    return () => {
+      if (released) return
+      released = true
+      this._release(k)
+    }
+  }
+
+  _release(k) {
+    this._stats.totalReleased++
+    const waiting = this._waiting.get(k)
+    if (waiting && waiting.length > 0) {
+      const next = waiting.shift()
+      if (waiting.length === 0) this._waiting.delete(k)
+      // Hand over slot directly to next queued consumer
+      next.resolve()
+    } else {
+      const active = this._active.get(k) || 0
+      if (active <= 1) {
+        this._active.delete(k)
+      } else {
+        this._active.set(k, active - 1)
+      }
+    }
+  }
+
+  _removeFromWaiting(k, id) {
+    const list = this._waiting.get(k)
+    if (!list) return
+    const idx = list.findIndex((item) => item.id === id)
+    if (idx !== -1) {
+      list.splice(idx, 1)
+      if (list.length === 0) this._waiting.delete(k)
+    }
+  }
+
+  stats() {
+    let totalActive = 0
+    let totalQueued = 0
+    const byKey = {}
+
+    for (const [k, count] of this._active) {
+      totalActive += count
+      if (!byKey[k]) byKey[k] = { active: 0, queued: 0 }
+      byKey[k].active = count
+    }
+
+    for (const [k, list] of this._waiting) {
+      totalQueued += list.length
+      if (!byKey[k]) byKey[k] = { active: 0, queued: 0 }
+      byKey[k].queued = list.length
+    }
+
+    return {
+      enabled: this.enabled,
+      maxConcurrency: this.maxConcurrency,
+      maxQueueSize: this.maxQueueSize,
+      timeoutMs: this.timeoutMs,
+      totalActive,
+      totalQueued,
+      byKey,
+      metrics: { ...this._stats },
+    }
+  }
+
+  dispose() {
+    for (const [, list] of this._waiting) {
+      for (const item of list) {
+        if (item.timer) clearTimeout(item.timer)
+        if (item.signal && item.abortHandler && typeof item.signal.removeEventListener === 'function') {
+          item.signal.removeEventListener('abort', item.abortHandler)
+        }
+        const err = createQueueError('Concurrency queue was disposed', 'QUEUE_DISPOSED')
+        item.reject(err)
+      }
+    }
+    this._waiting.clear()
+    this._active.clear()
+  }
+}
+
+export const defaultConcurrencyQueue = new ConcurrencyQueue()

package/lib/config-schema.js

@@ -118,6 +118,14 @@ export const Config = z.object({
     .description('#485 Prioritize accounts with closest reset window to burn expiring quota first.'),
   drainSafetyPercent: z.number().volatile().default(5)
     .description('#485 Safety margin percent: avoid draining accounts below this threshold when alternatives exist.'),
+  enableQueue: z.boolean().volatile().default(true)
+    .description('#518 Bounded concurrency queue to prevent bursts of 429 errors.'),
+  accountMaxConcurrency: z.number().volatile().default(2)
+    .description('#518 Max concurrent requests per account before queuing.'),
+  maxQueueSize: z.number().volatile().default(20)
+    .description('#518 Max requests waiting in queue before reject.'),
+  queueTimeoutMs: z.number().volatile().default(30000)
+    .description('#518 Max queue wait time in ms before timeout.'),
   customVendors: z.array(z.any()).volatile().default([])
     .description('Declarative OpenAI-Responses-compatible providers. See README.'),
 })

package/lib/diagnostics.js

@@ -1,3 +1,5 @@
+import { defaultConcurrencyQueue } from './concurrency-queue.js'
+import { calculateCacheMetrics } from './analytics.js'
 import { maskText } from './mask.js'
 import { normalizeSlots } from './accounts.js'
 import { PROVIDERS } from './refs.js'
@@ -46,6 +48,21 @@ export async function createDiagnosticsReport({ live, store, history, NS, pkgVer
     runtime: { node: process.version, platform: process.platform, arch: process.arch, uptimeSec: Math.round(process.uptime()) },
     providers,
     requests: { total: rows.length, byStatus, lastErrors },
+    cache: calculateCacheMetrics(rows),
+    queue: defaultConcurrencyQueue.stats(),
+    decisions: {
+      recent: rows.filter((r) => r && r.decisionTrace).slice(0, 10).map((r) => ({
+        ts: r.ts,
+        provider: r.provider,
+        ref: r.ref,
+        outcome: r.decisionTrace.finalOutcome || 'success',
+        attempts: (r.decisionTrace.attempts || []).map((a) => ({
+          ref: a.ref,
+          status: a.status,
+          decision: a.decisionReason || a.kind,
+        })),
+      })),
+    },
     settings: {
       cooldownMs: cfg.cooldownMs,
       switchAtRemaining: cfg.switchAtRemaining,