@goodandready/dsh-subscriptions 0.6.68 → 0.6.70

package/README.md

@@ -207,6 +207,18 @@ const res = await ctx.subscriptions.request('codex', '/backend-api/codex/images/
 * **In-App Toast Alerts (`enableToasts`)**: Lightweight floating toast alerts in the DSH chat interface notifying you when accounts enter quarantine, recover from cooldowns, or exceed quota safety thresholds.
 * **Automated Webhook Integration**: Instant event notifications dispatched via `notifyQuarantineEntered` and `notifyQuarantineReleased`.
 
+### 24. 🛡️ Resilience, Diagnostics & Fallback Enhancements (v0.6.70)
+* **Cross-Vendor Cascading Fallback & Provider Priority Ordering (#536)**: Configure fallback ordering across subscription providers with interactive reordering in WebUI.
+* **1-Click Connection Smoke Test & Latency Ping (#536)**: Test individual account connections on the spot with real-time latency badges.
+* **Live Cooldown Countdown & Availability Toasts (#536)**: Exact countdown timer for cooled-down accounts and automated toast alerts upon recovery.
+* **Proactive OAuth Token Heartbeat (#536)**: Pre-emptive background token refresh before expiry to prevent first-query latency spikes.
+* **Recent Errors Ring Buffer Inspector (#536)**: In-memory sanitized log of the last 20 runtime failures in WebUI Diagnostics.
+
+### 23. 🧠 Antigravity Tiered Models, Tool Sentinel & Stream Resilience (v0.6.69)
+* **Gemini 3 Tool Replay Sentinel (#534)**: Injects `thoughtSignature: 'skip_thought_signature_validator'` on reconstructed tool calls, enabling reliable multi-turn tool calling without Gemini 3 validation failures.
+* **Tiered Flash Models & Thinking Levels (#534)**: Exposes Gemini 3.8 and 3.7 Flash High, Medium, and Low thinking levels with upstream `*-flash-tiered` mapping.
+* **Stream Resilience & Empty Stream Retry (#534)**: Idle SSE timeout (30s), empty response detection, and transient stream retry with automatic account rotation.
+
 ### 22. ⚡ xAI Grok RFC 8628 Device Authorization Flow (v0.6.68)
 * **RFC 8628 Device Code Authorization (GH #17, #532)**: Native device authorization grant support for xAI Grok. Solves the issue where xAI presents a Grok Build user-code verification page for CLI client IDs without redirecting back to loopback callbacks. Provides direct user code display and automatic token polling.
 

package/README.ru.md

@@ -183,6 +183,18 @@ const res = await ctx.subscriptions.request('codex', '/backend-api/codex/images/
 * **Всплывающие уведомления (Toast Alerts)**: Легковесные всплывающие тосты в веб-интерфейсе DSH при событиях карантина (с отображением причины), восстановлении доступа и критическом расходе квоты. Включение управляется параметром `enableToasts` (по умолчанию `true`).
 * **Интеграция с вебхуками**: Автоматическая отправка уведомлений через `notifyQuarantineEntered` и `notifyQuarantineReleased`.
 
+### 20. 🛡️ Отказоустойчивость, диагностика и порядок фолбэка (v0.6.70)
+* **Межвендорный каскадный фолбэк с настройкой очередности (#536)**: Настройка порядка переключения провайдеров при исчерпании квот с интерактивным изменением приоритета (▲/▼) в WebUI.
+* **1-Click проверка подключения и пинг задержки (#536)**: Проверка конкретного аккаунта в один клик с отображением задержки (`✓ 240ms`).
+* **Живой таймер кулдауна и уведомления о восстановлении (#536)**: Точный обратный отсчет кулдауна и всплывающие in-app тосты при возвращении аккаунта в строй.
+* **Превентивный OAuth Heartbeat (#536)**: Упреждающее фоновое обновление токенов до истечения срока действия.
+* **Журнал последних ошибок (Ring Buffer) (#536)**: Встроенный инспектор последних 20 ошибок в WebUI Diagnostics с кнопкой очистки.
+
+### 19. 🧠 Antigravity Tiered-модели, сентинел тулов и устойчивость стримов (v0.6.69)
+* **Сентинел реплея тулов Gemini 3 (#534)**: Автоматическая вставка `thoughtSignature: 'skip_thought_signature_validator'` для реплея истории вызовов тулов без сбоев валидации Google API.
+* **Tiered-модели и уровни мышления (#534)**: Выбор уровней High/Medium/Low для Gemini 3.8 и 3.7 Flash с маппингом в upstream `*-flash-tiered` и `thinkingLevel`.
+* **Устойчивость стримов и авто-ретрай (#534)**: Защита от зависания SSE (таймаут 30с), детекция пустых ответов и авто-ротация аккаунтов по `EMPTY_RESPONSE`/`TIMEOUT`.
+
 ### 18. ⚡ RFC 8628 Device Code авторизация для xAI Grok (v0.6.68)
 * **Авторизация по коду устройства (GH #17, #532)**: Нативная поддержка RFC 8628 device code flow для xAI Grok. Устраняет проблему, когда xAI для CLI client ID открывает страницу ввода кода для Grok Build без обратного редиректа на loopback-порт. Отображает одноразовый код на карточке и автоматически поллит токены в фоне.
 

package/README.zh.md

@@ -132,6 +132,18 @@ graph LR
   queueTimeoutMs: 30000     # v0.6.62: 队列最大等待超时时间（毫秒）
 * **自动化 Webhook 告警集成**：通过 `notifyQuarantineEntered` 与 `notifyQuarantineReleased` 自动向外部通知系统派发隔离生命周期事件。
 
+### 🛡️ 弹性容灾、故障诊断与跨服务商回退 (v0.6.70)
+* **跨服务商级联故障转移与优先级排序 (#536)**: 支持自定义跨服务商回退顺序，可在 WebUI 中通过 ▲/▼ 交互调整优先级。
+* **一键链路测试与延迟检测 (#536)**: 在账户列表或状态弹窗中一键发起探活并显示往返延迟。
+* **冷却倒计时与就绪通知 (#536)**: 实时展示受限账户恢复倒计时，解除冷却时自动弹出就绪通知。
+* **主动 OAuth 令牌心跳 (#536)**: 提前预刷即将过期的访问令牌，避免用户请求时产生额外等待。
+* **最近错误环形日志审查 (#536)**: 内存保存最近 20 条已脱敏的运行错误，支持在 Diagnostics 中查看与清空。
+
+### Antigravity 分档思考模型、工具回放哨兵与流式自愈 (v0.6.69)
+* **Gemini 3 工具回放哨兵 (#534)**：在重建的工具调用中注入 `thoughtSignature: 'skip_thought_signature_validator'`，彻底解决多轮工具调用历史重放时 Gemini 3 的校验失败问题。
+* **分档 Flash 模型与思考档位 (#534)**：将 `gemini-3.8-flash-tiered` 与 `3.7` 自动解析展开为 High/Medium/Low 档位选择，并在调用时自动组装 `thinkingConfig.thinkingLevel`。
+* **流式空响应自愈与账号轮换 (#534)**：引入 30 秒 SSE 空闲超时保护与空响应检测，在未输出前自动重试一次，失败时通过 `EMPTY_RESPONSE` / `TIMEOUT` 自动轮换至下一个可用账号。
+
 ### xAI Grok RFC 8628 设备码授权流支持 (v0.6.68)
 * **RFC 8628 设备码授权流 (GH #17, #532)**：为 xAI Grok 新增原生设备码登录授权支持。彻底解决 xAI 针对 CLI 客户端标识返回 Grok Build 验证码页面且不触发回环重定向回调导致的死锁问题。直接在槽位卡片展示用户授权码，并自动在后台轮询兑换会话令牌。
 

package/lib/adapter-manager.js

@@ -75,7 +75,7 @@ export function createAdapterManager({
     const loggedList = Array.isArray(logged) ? logged : Object.keys(logged || {}).filter((p) => logged[p])
     const available = loggedList.filter((p) => p !== provider)
     visited.add(provider)
-    const nextVendor = resolveFallbackVendor(provider, available, cfg.cascadingChain, visited)
+    const nextVendor = resolveFallbackVendor(provider, available, cfg.cascadingChain, visited, cfg.cascadingFallbackOrder)
     if (!nextVendor) throw err
     visited.add(nextVendor)
     const targetModel = mapFallbackModel(provider, options && options.model, nextVendor)

package/lib/cascade.js

@@ -29,10 +29,35 @@ export const DEFAULT_CASCADE_CHAINS = {
  * @param {Set<string>} [visited] - set of already attempted providers in this request cascade
  * @returns {string|null} - the next candidate provider or null if none available
  */
-export function resolveFallbackVendor(currentProvider, availableProviders, customChains = {}, visited = new Set()) {
+/**
+ * Resolves the next candidate fallback provider from the cascade chain.
+ * @param {string} currentProvider - currently failing provider
+ * @param {Set<string>|Array<string>} availableProviders - providers that currently have logged-in accounts
+ * @param {Record<string, string[]>} [customChains] - user-configured custom chains
+ * @param {Set<string>} [visited] - set of already attempted providers in this request cascade
+ * @param {string[]} [globalOrder] - configured global fallback priority sequence
+ * @returns {string|null} - the next candidate provider or null if none available
+ */
+export function resolveFallbackVendor(currentProvider, availableProviders, customChains = {}, visited = new Set(), globalOrder = []) {
   const availSet = new Set(availableProviders || [])
-  const chain = (customChains && customChains[currentProvider]) || DEFAULT_CASCADE_CHAINS[currentProvider] || []
+  const custom = customChains && customChains[currentProvider]
+  if (Array.isArray(custom) && custom.length > 0) {
+    for (const candidate of custom) {
+      if (candidate !== currentProvider && !visited.has(candidate) && availSet.has(candidate)) {
+        return candidate
+      }
+    }
+  }
+
+  if (Array.isArray(globalOrder) && globalOrder.length > 0) {
+    for (const candidate of globalOrder) {
+      if (candidate !== currentProvider && !visited.has(candidate) && availSet.has(candidate)) {
+        return candidate
+      }
+    }
+  }
 
+  const chain = DEFAULT_CASCADE_CHAINS[currentProvider] || []
   for (const candidate of chain) {
     if (candidate !== currentProvider && !visited.has(candidate) && availSet.has(candidate)) {
       return candidate

package/lib/client.js

@@ -430,6 +430,17 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       "smokeTesting": "Pinging…",
       "smokeOk": "Smoke test passed",
       "smokeFail": "Smoke test failed",
+      "testConnection": "Test",
+      "testConnectionSuccess": "Connection verified",
+      "cascadingFallback": "Cross-vendor fallback",
+      "cascadingFallbackHint": "Automatically route queries to alternative providers when all accounts of a primary provider are exhausted.",
+      "cascadingFallbackOrder": "Fallback Provider Order",
+      "cascadingFallbackOrderHint": "Sequence of alternative providers to try when primary accounts are exhausted.",
+      "recentErrors": "Recent Runtime Errors",
+      "recentErrorsDesc": "Last 20 runtime failures across model streams and providers (sanitized).",
+      "recentErrorsClear": "Clear Log",
+      "recentErrorsEmpty": "No recent errors recorded",
+      "toastCooldownRecovered": "is now available (cooldown expired)",
       "modelsCatalogTitle": "Curated Subscription Models",
       "modelsCatalogDesc": "Available model catalog across active subscriptions in DeepSeek Harness.",
       "rotationDecisionsTitle": "Rotation & Routing Decisions",
@@ -702,6 +713,17 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       "smokeTesting": "正在探活…",
       "smokeOk": "冒烟测试成功",
       "smokeFail": "冒烟测试失败",
+      "testConnection": "测试",
+      "testConnectionSuccess": "连接已验证",
+      "cascadingFallback": "跨服务商自动故障转移",
+      "cascadingFallbackHint": "当首选服务商所有账户配额耗尽或限流时，自动无缝转接至备选服务商。",
+      "cascadingFallbackOrder": "故障转移供应商顺序",
+      "cascadingFallbackOrderHint": "首选服务商耗尽时按此顺序依次尝试备选服务商。",
+      "recentErrors": "最近运行错误记录",
+      "recentErrorsDesc": "最近 20 条流式传输与 API 调用失败记录（已脱敏）。",
+      "recentErrorsClear": "清空记录",
+      "recentErrorsEmpty": "暂无错误记录",
+      "toastCooldownRecovered": "已解除冷却恢复可用",
       "modelsCatalogTitle": "精选订阅模型",
       "modelsCatalogDesc": "当前 DeepSeek Harness 活跃订阅下可用模型一览。",
       "rotationDecisionsTitle": "轮询调度与路由决策",
@@ -987,7 +1009,13 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       if (account.quarantineReason && account.quarantineUntil && account.quarantineUntil > Date.now()) {
         return account.quarantineReason === 'VERIFY' ? t('verifyAccount') : String(account.quarantineReason)
       }
-      if (account.cooldownUntil && account.cooldownUntil > Date.now()) return t('coolingDown')
+      if (account.cooldownUntil && account.cooldownUntil > Date.now()) {
+        const leftSec = Math.max(0, Math.ceil((account.cooldownUntil - Date.now()) / 1000))
+        const m = Math.floor(leftSec / 60)
+        const s = leftSec % 60
+        const pad = (n) => String(n).padStart(2, "0")
+        return t("coolingDown") + " (" + pad(m) + ":" + pad(s) + ")"
+      }
       if (account.usagePercent != null && account.usagePercent >= 100) return t('usageFull')
       return t('connected')
     }
@@ -1114,12 +1142,14 @@ const cssId = 'dsh-subscriptions/settings.module.css'
         fetch('/dsh-subscriptions/diagnostics', { cache: 'no-store' })
           .then((r) => r.json())
           .then((d) => {
+            if (d && d.ok && d.report) setDiagReport(d.report)
             const txt = d && d.ok ? JSON.stringify(d.report, null, 2) : ('error: ' + ((d && d.error && d.error.message) || 'unknown'))
             setDiag(txt)
             try { navigator.clipboard.writeText(txt) } catch { /* clipboard write disallowed */ }
           })
           .catch((e) => setDiag('error: ' + String(e && e.message || e)))
       }
+      const [diagReport, setDiagReport] = React.useState(null)
       const [checkRes, setCheckRes] = React.useState({})
       const [hostPing, setHostPing] = React.useState({ ok: true, latencyMs: null })
       const [telemetry, setTelemetry] = React.useState(null)
@@ -1259,6 +1289,10 @@ const cssId = 'dsh-subscriptions/settings.module.css'
           .then((r) => r.json())
           .then((d) => { if (d && d.ok && d.queue) setQueueStats(d.queue) })
           .catch(() => {})
+        fetch('/dsh-subscriptions/diagnostics', { cache: 'no-store' })
+          .then((r) => r.json())
+          .then((d) => { if (d && d.ok && d.report) setDiagReport(d.report) })
+          .catch(() => {})
       }
 
       const runSmokeTest = async (provider, index) => {
@@ -2081,6 +2115,48 @@ const cssId = 'dsh-subscriptions/settings.module.css'
                 React.createElement('span', null, t('notifyLimits')),
               ),
               React.createElement('div', { className: 'dsub-sub' }, t('notifyLimitsHint')),
+              React.createElement('label', { className: 'dsub-row', style: { marginTop: 10 } },
+                React.createElement('input', {
+                  type: 'checkbox',
+                  checked: Boolean(draft.cascadingFallback),
+                  onChange: (e) => setDraft((d) => Object.assign({}, d, { cascadingFallback: e.target.checked })),
+                }),
+                React.createElement('span', null, t('cascadingFallback')),
+              ),
+              React.createElement('div', { className: 'dsub-sub' }, t('cascadingFallbackHint')),
+              Boolean(draft.cascadingFallback) ? React.createElement('div', { style: { marginTop: 8, padding: '8px 12px', background: 'var(--dsw-alias-bg-layer-2)', borderRadius: 8 } },
+                React.createElement('div', { style: { fontSize: 12, fontWeight: 600, marginBottom: 4 } }, t('cascadingFallbackOrder')),
+                React.createElement('div', { className: 'dsub-sub', style: { marginBottom: 8 } }, t('cascadingFallbackOrderHint')),
+                React.createElement('div', { style: { display: 'flex', flexDirection: 'column', gap: 4 } },
+                  (Array.isArray(draft.cascadingFallbackOrder) && draft.cascadingFallbackOrder.length ? draft.cascadingFallbackOrder : (providers.length ? providers : ['antigravity', 'claude', 'codex', 'grok', 'copilot', 'cursor'])).map((p, idx, arr) => {
+                    return React.createElement('div', { key: p, style: { display: 'flex', alignItems: 'center', justifyContent: 'space-between', padding: '4px 8px', background: 'var(--dsw-alias-bg-layer-1)', borderRadius: 6, fontSize: 12 } },
+                      React.createElement('span', null, (idx + 1) + '. ' + p.toUpperCase()),
+                      React.createElement('div', { style: { display: 'flex', gap: 4 } },
+                        idx > 0 ? React.createElement('button', {
+                          type: 'button', className: 'dsub-mini', style: { padding: '1px 6px', fontSize: 10 },
+                          onClick: () => {
+                            const next = arr.slice()
+                            const tmp = next[idx - 1]
+                            next[idx - 1] = next[idx]
+                            next[idx] = tmp
+                            setDraft((d) => Object.assign({}, d, { cascadingFallbackOrder: next }))
+                          }
+                        }, '▲') : null,
+                        idx < arr.length - 1 ? React.createElement('button', {
+                          type: 'button', className: 'dsub-mini', style: { padding: '1px 6px', fontSize: 10 },
+                          onClick: () => {
+                            const next = arr.slice()
+                            const tmp = next[idx + 1]
+                            next[idx + 1] = next[idx]
+                            next[idx] = tmp
+                            setDraft((d) => Object.assign({}, d, { cascadingFallbackOrder: next }))
+                          }
+                        }, '▼') : null,
+                      )
+                    )
+                  })
+                )
+              ) : null,
             ),
           ),
         ),
@@ -2105,6 +2181,39 @@ const cssId = 'dsh-subscriptions/settings.module.css'
             }, t('diagCopy')),
             React.createElement('pre', { className: 'dsub-diag' }, diag),
           ) : null,
+          React.createElement('details', { className: 'dsub-details', style: { marginTop: 12 } },
+            React.createElement('summary', { className: 'dsub-summary' }, '⚠️ ' + t('recentErrors')),
+            React.createElement('div', { className: 'dsub-block' },
+              React.createElement('div', { style: { display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 8 } },
+                React.createElement('span', { className: 'dsub-sub' }, t('recentErrorsDesc')),
+                React.createElement('button', {
+                  type: 'button', className: 'dsub-mini',
+                  onClick: async () => {
+                    await fetch('/dsh-subscriptions/diagnostics/errors/clear', { method: 'POST' }).catch(() => {})
+                    genDiag()
+                  }
+                }, t('recentErrorsClear'))
+              ),
+              (diagReport && Array.isArray(diagReport.recentErrors) && diagReport.recentErrors.length ? diagReport.recentErrors : []).length === 0
+                ? React.createElement('div', { className: 'dsub-dim', style: { padding: 8 } }, t('recentErrorsEmpty'))
+                : React.createElement('div', { style: { display: 'flex', flexDirection: 'column', gap: 6 } },
+                    (diagReport.recentErrors || []).map((err, i) => React.createElement('div', {
+                      key: i,
+                      style: { padding: '6px 10px', background: 'var(--dsw-alias-bg-layer-2)', borderRadius: 6, fontSize: 11.5, borderLeft: '3px solid var(--dsw-alias-state-error-primary)' }
+                    },
+                      React.createElement('div', { style: { display: 'flex', justifyContent: 'space-between', marginBottom: 2 } },
+                        React.createElement('span', { style: { fontWeight: 600 } }, (err.provider || 'unknown').toUpperCase() + (err.model ? ' · ' + err.model : '')),
+                        React.createElement('span', { className: 'dsub-dim' }, (err.ts || '').slice(11, 19))
+                      ),
+                      React.createElement('div', { style: { display: 'flex', gap: 6, alignItems: 'center' } },
+                        err.code ? React.createElement('span', { className: 'dsub-pillTag', style: { background: 'color-mix(in srgb,var(--dsw-alias-state-error-primary) 15%,transparent)', color: 'var(--dsw-alias-state-error-primary)' } }, err.code) : null,
+                        err.status ? React.createElement('span', { className: 'dsub-dim' }, 'HTTP ' + err.status) : null,
+                        React.createElement('span', { style: { opacity: 0.9, wordBreak: 'break-word' } }, err.message)
+                      )
+                    ))
+                  )
+            )
+          ),
           wizardModal ? React.createElement('div', { className: 'dsub-modalWrap', onClick: (e) => { if (e.target === e.currentTarget) setWizardModal(null) } },
             React.createElement('div', { className: 'dsub-modal' },
               React.createElement('div', { className: 'dsub-modalHead' },
@@ -2269,8 +2378,16 @@ const cssId = 'dsh-subscriptions/settings.module.css'
                   React.createElement('button', {
                     type: 'button', className: 'dsub-mini',
                     disabled: checking[key],
+                    title: t('smokeDesc'),
                     onClick: () => doCheck(row.slot.provider, row.slot.index).catch((e) => setErr(cleanErrorMessage(e.message || e))),
-                  }, checking[key] ? t('checking') : t('check')),
+                  }, checking[key] ? t('checking') : ('⚡ ' + t('testConnection'))),
+                  (function(){
+                    var r = checkRes[key];
+                    if (!r) return null;
+                    var cls = r.ok ? 'dsub-badge-ok' : 'dsub-badge-bad';
+                    var txt = r.ok ? ('✓ ' + (r.latencyMs != null ? r.latencyMs + 'ms' : 'OK')) : ('✗ ' + ((r.error && (r.error.code || r.error.message)) || 'FAIL'));
+                    return React.createElement('span', { className: 'dsub-badge ' + cls, style: { marginLeft: 4 }, title: r.ok ? t('testConnectionSuccess') : ((r.error && r.error.message) || 'fail') }, txt);
+                  })(),
                   React.createElement('button', {
                     type: 'button', className: 'dsub-mini',
                     title: t('wizardTitle'),
@@ -3141,6 +3258,24 @@ const cssId = 'dsh-subscriptions/settings.module.css'
         )
       }
 
+      const prevCooldownsRef = React.useRef(new Map())
+      React.useEffect(() => {
+        for (const a of (state.accounts || [])) {
+          const isCooled = Boolean(a.cooldownUntil && a.cooldownUntil > now)
+          const wasCooled = prevCooldownsRef.current.get(a.ref)
+          if (wasCooled && !isCooled) {
+            const toastId = 't_cool_' + a.ref + '_' + Date.now()
+            setToasts((prev) => [{
+              id: toastId,
+              message: (a.label || a.ref) + ' ' + t('toastCooldownRecovered'),
+              cls: 'dsub-toast-ok',
+            }, ...prev].slice(0, 3))
+            setTimeout(() => dismissToast(toastId), 5000)
+          }
+          prevCooldownsRef.current.set(a.ref, isCooled)
+        }
+      }, [state.accounts, now])
+
       // Accounts list
       const rows = state.accounts.map((a, i) => {
         const isLogged = state.logged.includes(a.provider)
@@ -3157,8 +3292,12 @@ const cssId = 'dsh-subscriptions/settings.module.css'
           statusText = a.quarantineReason === 'VERIFY' ? t('verifyAccount') : String(a.quarantineReason)
         } else if (cooled) {
           statusClass = 'dsub-statusWarn'
-          // Only some model families may be cooled down - say which ones.
-          statusText = t('subsCooldown') + (Array.isArray(a.cooldownFamilies) && a.cooldownFamilies.length ? ' · ' + a.cooldownFamilies.join('/') : '')
+          const leftSec = Math.max(0, Math.ceil((a.cooldownUntil - now) / 1000))
+          const m = Math.floor(leftSec / 60)
+          const s = leftSec % 60
+          const pad = (n) => String(n).padStart(2, '0')
+          const fams = Array.isArray(a.cooldownFamilies) && a.cooldownFamilies.length ? ' · ' + a.cooldownFamilies.join('/') : ''
+          statusText = t('subsCooldown') + ' (' + pad(m) + ':' + pad(s) + ')' + fams
         } else if (isLogged) {
           if (pct >= 90) { statusClass = 'dsub-statusBad'; statusText = '90%+ ' + t('subsUsed') }
           else if (pct >= 50) { statusClass = 'dsub-statusWarn'; statusText = pct + '% ' + t('subsUsed') }

package/lib/code-assist.js

@@ -156,21 +156,28 @@ function catalogRows(json) {
   return []
 }
 
+export function antigravityTieredAlias(model) {
+  const match = /^gemini-(3\.[78])-flash-(low|medium|high)$/.exec(model || '')
+  return match ? { model: `gemini-${match[1]}-flash-tiered`, thinkingLevel: match[2] } : null
+}
+
 export async function fetchAvailableModels(fetchImpl, token, extraHeaders, fallbackIds, provider) {
   try {
     const json = await postAssist(fetchImpl, 'fetchAvailableModels', token, {}, extraHeaders)
     const out = []
-    for (const row of catalogRows(json)) {
+    const catalog = catalogRows(json)
+    const publishedIds = new Set(catalog.map((row) => String(row?.id || '').replace(/^models\//, '')))
+    for (const row of catalog) {
       if (!row) continue
       if (typeof row === 'string') {
-        if (row && !row.startsWith('chat_')) out.push({ provider, id: row, name: row })
+        if (row && !row.startsWith('chat_') && !row.startsWith('tab_')) out.push({ provider, id: row, name: row })
         continue
       }
       if (row.isInternal) continue
       const raw = String(row.id || row.name || row.model || '').replace(/^models\//, '')
-      if (!raw || raw.startsWith('chat_')) continue
+      if (!raw || raw.startsWith('chat_') || raw.startsWith('tab_')) continue
       const display = row.displayName ?? row.display_name
-      if (display === '') continue
+      if (display === '' && !raw.endsWith('-tiered')) continue
       out.push({
         provider,
         id: raw,
@@ -178,6 +185,19 @@ export async function fetchAvailableModels(fetchImpl, token, extraHeaders, fallb
         ...(row.recommended ? { description: 'Recommended' } : {}),
         ...(row.maxTokens ? { contextWindow: row.maxTokens } : {}),
       })
+      const tiered = /^gemini-(3\.[78])-flash-tiered$/.exec(raw)
+      if (tiered) {
+        for (const level of ['high', 'medium', 'low']) {
+          const id = `gemini-${tiered[1]}-flash-${level}`
+          if (publishedIds.has(id)) continue
+          out.push({
+            provider,
+            id,
+            name: `Gemini ${tiered[1]} Flash (${level[0].toUpperCase()}${level.slice(1)})`,
+            ...(row.maxTokens ? { contextWindow: row.maxTokens } : {}),
+          })
+        }
+      }
     }
     if (out.length) {
       out.sort((a, b) => Number(Boolean(b.description)) - Number(Boolean(a.description)) || a.name.localeCompare(b.name))

package/lib/config-schema.js

@@ -108,6 +108,8 @@ export const Config = z.object({
     .description('Custom model catalog for Grok.'),
   cascadingFallback: z.boolean().volatile().default(false)
     .description('#349 Opt-in cross-vendor fallback when all accounts of a provider are exhausted or rate limited.'),
+  cascadingFallbackOrder: z.array(z.string()).volatile().default(PROVIDERS)
+    .description('Configurable global priority sequence for cross-vendor fallback.'),
   cascadingChain: z.any().volatile().default({})
     .description('#349 Custom cross-vendor fallback chains (e.g. { claude: ["copilot", "cursor"] }).'),
   webhookUrl: z.string().volatile().default('')

package/lib/diagnostics.js

@@ -6,6 +6,7 @@ import { getSessionPinStats } from './session-pin.js'
 import { maskText } from './mask.js'
 import { normalizeSlots } from './accounts.js'
 import { PROVIDERS } from './refs.js'
+import { defaultErrorBuffer } from './error-buffer.js'
 
 function scrubReport(v) {
   if (typeof v === 'string') return maskText(v)
@@ -18,7 +19,7 @@ function scrubReport(v) {
   return v
 }
 
-export async function createDiagnosticsReport({ live, store, history, NS, pkgVersion }) {
+export async function createDiagnosticsReport({ live, store, history, NS, pkgVersion, heartbeatStats }) {
   const cfg = live()
   const slots = normalizeSlots(cfg.slots)
   const mk = () => ({ loggedIn: false, slots: 0, configured: 0, cooldown: 0, proxy: 0, maxUsagePercent: null })
@@ -51,6 +52,8 @@ 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 },
+    recentErrors: defaultErrorBuffer.getEntries(),
+    heartbeat: heartbeatStats || { lastRunAt: null, proactiveRefreshCount: 0 },
     cache: calculateCacheMetrics(rows),
     queue: defaultConcurrencyQueue.stats(),
     pins: getSessionPinStats(),
@@ -78,6 +81,8 @@ export async function createDiagnosticsReport({ live, store, history, NS, pkgVer
       privacyMask: !!cfg.privacyMask,
       customVendors: Array.isArray(cfg.customVendors) ? cfg.customVendors.length : 0,
       proxySlots: slots.filter((s) => s.proxyUrl).length,
+      cascadingFallback: !!cfg.cascadingFallback,
+      cascadingFallbackOrder: cfg.cascadingFallbackOrder || PROVIDERS,
     },
   })
 }

package/lib/error-buffer.js

@@ -0,0 +1,49 @@
+import { cleanErrorMessage, maskText } from './mask.js'
+
+/**
+ * Ring buffer holding the most recent runtime errors across vendors and streams.
+ * Sanitizes all text to prevent credential or PII leaks in diagnostics.
+ */
+export class ErrorRingBuffer {
+  /**
+   * @param {number} [limit=20]
+   */
+  constructor(limit = 20) {
+    this.limit = limit
+    /** @type {Array<{ id: string, ts: string, provider: string, ref: string, model: string, status: number|null, code: string, message: string }>} */
+    this.entries = []
+    this._nextId = 1
+  }
+
+  /**
+   * @param {{ provider?: string, ref?: string, model?: string, status?: number|null, code?: string, message?: string }} [param0]
+   */
+  record({ provider = 'unknown', ref = '', model = '', status = null, code = '', message = '' } = {}) {
+    const rawMsg = cleanErrorMessage(maskText(String(message || '')))
+    const entry = {
+      id: String(this._nextId++),
+      ts: new Date().toISOString(),
+      provider: String(provider || ''),
+      ref: String(ref || ''),
+      model: String(model || ''),
+      status: typeof status === 'number' ? status : null,
+      code: String(code || ''),
+      message: rawMsg.slice(0, 250),
+    }
+    this.entries.unshift(entry)
+    if (this.entries.length > this.limit) {
+      this.entries.length = this.limit
+    }
+    return entry
+  }
+
+  getEntries() {
+    return this.entries.slice()
+  }
+
+  clear() {
+    this.entries = []
+  }
+}
+
+export const defaultErrorBuffer = new ErrorRingBuffer(20)

package/lib/index.js

@@ -416,37 +416,45 @@ export function apply(ctx, rawConfig) {
   const pmE = (s) => privacyOn() ? maskEmail(s) : String(s || '')
   const pmL = (s) => privacyOn() ? maskLabel(s) : String(s || '')
 
-  const diagnosticsReport = () => createDiagnosticsReport({ live, store, history, NS, pkgVersion })
+  const heartbeatStats = { lastRunAt: 0, proactiveRefreshCount: 0 }
+  const runProactiveHeartbeat = async () => {
+    heartbeatStats.lastRunAt = Date.now()
+    const cfg = live()
+    const ahead = Number(cfg.refreshAheadMs) || 5 * 60 * 1000
+    const retryMs = Number(cfg.refreshRetryMs) || 10 * 60 * 1000
+    const now = Date.now()
+    let refreshed = 0
+    for (const slot of normalizeSlots(cfg.slots)) {
+      const ref = slot.ref
+      try {
+        const info = await store.describeRef(ref)
+        if (!info.configured) continue
+        if (info.cooldownUntil && info.cooldownUntil > now) continue
+        const raw = await store.resolveRaw(ref)
+        if (!raw) continue
+        const blob = await store.loadBlob(ref).catch(() => null)
+        if (!blob || !blob.refreshToken) continue
+        if (!blob.expiresAt) continue
+        if (blob.expiresAt - now > ahead) continue
+        if (typeof store.shouldSkipRefresh === "function" && store.shouldSkipRefresh(ref, now, retryMs)) continue
+        await store.ensureFresh(slot.provider, blob, ref).then(() => {
+          refreshed++
+          heartbeatStats.proactiveRefreshCount++
+        }).catch((e) => {
+          if (logger && logger.warn) logger.warn("[dsh-subscriptions] background refresh failed for " + ref + ": " + String(e && e.message || e))
+        })
+      } catch { /* best-effort */ }
+    }
+    return refreshed
+  }
+
+  const diagnosticsReport = () => createDiagnosticsReport({ live, store, history, NS, pkgVersion, heartbeatStats })
   const accountsView = () => createAccountsView({ live, store, fetch, pmL })
 
   // Ponytail: background refresh ahead of expiry, single timer
   ctx.effect(() => {
-    const tick = async () => {
-      const cfg = live()
-      const ahead = Number(cfg.refreshAheadMs) || 5 * 60 * 1000
-      const retryMs = Number(cfg.refreshRetryMs) || 10 * 60 * 1000
-      const now = Date.now()
-      for (const slot of normalizeSlots(cfg.slots)) {
-        const ref = slot.ref
-        try {
-          const info = await store.describeRef(ref)
-          if (!info.configured) continue
-          if (info.cooldownUntil && info.cooldownUntil > now) continue
-          const raw = await store.resolveRaw(ref)
-          if (!raw) continue
-          const blob = await store.loadBlob(ref).catch(() => null)
-          if (!blob || !blob.refreshToken) continue
-          if (!blob.expiresAt) continue
-          if (blob.expiresAt - now > ahead) continue
-          if (typeof store.shouldSkipRefresh === 'function' && store.shouldSkipRefresh(ref, now, retryMs)) continue
-          await store.ensureFresh(slot.provider, blob, ref).catch((e) => {
-            if (logger && logger.warn) logger.warn('[dsh-subscriptions] background refresh failed for ' + ref + ': ' + String(e && e.message || e))
-          })
-        } catch { /* best-effort */ }
-      }
-    }
-    tick().catch(() => {})
-    const id = setInterval(() => { tick().catch(() => {}) }, 60 * 1000)
+    runProactiveHeartbeat().catch(() => {})
+    const id = setInterval(() => { runProactiveHeartbeat().catch(() => {}) }, 60 * 1000)
     return () => clearInterval(id)
   }, 'dsh-subscriptions: refresh ahead')
 
@@ -509,6 +517,7 @@ export function apply(ctx, rawConfig) {
     refForSlot,
     resetCredits,
     diagnosticsReport,
+    triggerHeartbeat: runProactiveHeartbeat,
     pending,
     completeOAuth,
     fetchForRef,

package/lib/messages.js

@@ -478,7 +478,13 @@ export function googleContents(options) {
       }))),
     ]
     for (const call of calls) {
-      parts.push({ functionCall: { name: call.name, args: safeJson(call.arguments) } })
+      // DSH provider-neutral tool history cannot retain Gemini's opaque thoughtSignature.
+      // Gemini 3 requires one on replay after a tool result; Google's documented sentinel
+      // permits reconstructed/foreign history.
+      parts.push({
+        functionCall: { name: call.name, args: safeJson(call.arguments) },
+        thoughtSignature: 'skip_thought_signature_validator',
+      })
     }
     for (const result of toolResults(message.content)) {
       const name = result.toolName || result.name || 'tool'

package/lib/rotate.js

@@ -18,6 +18,7 @@ export function isRegionError(err) {
 
 export function isSwitchableError(err) {
   if (!err || typeof err !== 'object') return false
+  if (err.name === 'TimeoutError' || err.code === 'TIMEOUT' || err.code === 'EMPTY_RESPONSE') return true
   if (err.name === 'AbortError' || err.code === 'ABORT_ERR' || err.code === 'ERR_ABORTED' || (err.message && /aborted/i.test(err.message))) return false
   const code = err.code || (err.failure && err.failure.code)
   if (SWITCH_CODES.has(code)) return true

package/lib/routes/status.js

@@ -19,6 +19,7 @@ import { isTrustedSettingsRequest, queryOf, readBody, safeJsonHandler, writeJson
 import { quotaSnapshot } from '../ratelimit.js'
 import { PROVIDERS, displayName, droppedCredentialRefs, isProvider, oauthRef } from '../refs.js'
 import { getVendor } from '../vendors/index.js'
+import { defaultErrorBuffer } from '../error-buffer.js'
 
 export function registerStatusRoutes(ctx, state) {
   const {
@@ -298,6 +299,40 @@ export function registerStatusRoutes(ctx, state) {
     }),
   }), 'dsh-subscriptions: /diagnostics')
 
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/diagnostics/errors/clear',
+    handler: safeJsonHandler(async (req, res) => {
+      if (req.method !== 'POST') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req, ctx)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      defaultErrorBuffer.clear()
+      writeJson(res, 200, { ok: true, cleared: true })
+    }),
+  }), 'dsh-subscriptions: /diagnostics/errors/clear')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/heartbeat/run',
+    handler: safeJsonHandler(async (req, res) => {
+      if (req.method !== 'POST') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req, ctx)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      const refreshedCount = typeof state.triggerHeartbeat === 'function' ? await state.triggerHeartbeat() : 0
+      writeJson(res, 200, { ok: true, refreshed: refreshedCount })
+    }),
+  }), 'dsh-subscriptions: /heartbeat/run')
+
 
   // ponytail: cheap per-vendor probe; never sets cooldown, never returns tokens
   ctx.effect(() => ctx.webServer.register({
@@ -345,10 +380,6 @@ export function registerStatusRoutes(ctx, state) {
         return
       }
       const vendor = getVendor(provider)
-      if (typeof vendor.check !== 'function') {
-        writeJson(res, 200, { ok: true, provider, index: index, ref, email: pmE(blob.email), label: pmL(blob.label), expiresAt: blob.expiresAt || null, quota: info.quota || null })
-        return
-      }
       let capturedQuota = null
       const probeFetch = async (url, init = {}) => {
         const doFetch = (typeof fetchForRef === "function" && fetchForRef(ref)) || fetch
@@ -360,8 +391,14 @@ export function registerStatusRoutes(ctx, state) {
         return res2
       }
       try {
-        await vendor.check(blob, vendorConfig(provider, live()), probeFetch)
-        const latencyMs = Date.now() - t0;
+        if (typeof vendor.check === 'function') {
+          await vendor.check(blob, vendorConfig(provider, live()), probeFetch)
+        } else if (typeof vendor.listModels === 'function') {
+          await vendor.listModels(blob, vendorConfig(provider, live()), probeFetch)
+        } else if (typeof vendor.usage === 'function') {
+          await vendor.usage(blob, vendorConfig(provider, live()), probeFetch)
+        }
+        const latencyMs = Date.now() - t0
         writeJson(res, 200, { ok: true, provider, index: index, ref, latencyMs, email: pmE(blob.email), label: pmL(blob.label), expiresAt: blob.expiresAt || null, quota: capturedQuota || info.quota || null, usagePercent: info.usagePercent ?? null })
       } catch (e) {
         const isTimeout = isTimeoutError(e)

package/lib/stream-rotate.js

@@ -4,6 +4,7 @@ import { pickAccountWithTrace, markCooldown, isSwitchableError, isRegionError, m
 import { putInQuarantine, REASON_RATE_LIMIT, REASON_HARD_LIMIT, REASON_REVOKED } from './quarantine.js'
 import { notifySessionExpired, notifyQuarantineEntered } from './alerts.js'
 import { withRunawayGuard } from './runaway-guard.js'
+import { defaultErrorBuffer } from './error-buffer.js'
 
 export async function* streamWithRotation({
   accounts,
@@ -163,6 +164,14 @@ export async function* streamWithRotation({
         return
       } catch (err) {
         lastError = err
+        defaultErrorBuffer.record({
+          provider: options && options.provider,
+          ref: account.ref || account.id,
+          model: options && options.model,
+          status: err && (err.status || err.statusCode),
+          code: err && (err.code || err.name),
+          message: err && (err.message || String(err)),
+        })
         // If chunks were already yielded to the caller, never rotate mid-stream
         // as that would repeat or scramble generated tokens.
         if (firstChunkDelivered) throw err

package/lib/vendors/antigravity.js

@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto'
 import { buildAuthorizeUrl } from '../oauth.js'
 import { googleContents } from '../messages.js'
 import { formTokenRequest, googleStream, throwHttpError, tokenBlobFromOAuth } from '../wire.js'
+import { fetchWithTimeout } from '../http.js'
 import { emailFromToken } from '../jwt.js'
 import {
   CODE_ASSIST_STREAM,
@@ -9,6 +10,7 @@ import {
   antigravityIdentityHeaders,
   discoverProject,
   fetchAvailableModels,
+  antigravityTieredAlias,
   retrieveQuotaPercent,
   streamEnvelope,
   assistHeaders,
@@ -38,14 +40,22 @@ export function defaults() {
     clientSecret: '',
     redirectUri: 'http://localhost:8085/oauth/callback',
     models: [
+      'gemini-3.8-flash-high',
       'gemini-3.8-flash-medium',
+      'gemini-3.8-flash-low',
+      'gemini-3.8-flash-tiered',
+      'gemini-3.7-flash-high',
       'gemini-3.7-flash-medium',
+      'gemini-3.7-flash-low',
+      'gemini-3.7-flash-tiered',
+      'gemini-3.6-flash-high',
       'gemini-3.6-flash-medium',
+      'gemini-3.6-flash-low',
       'gemini-3.1-pro-low',
-      'claude-sonnet-4.6-thinking',
-      'claude-opus-4.6-thinking',
+      'gemini-3.1-pro-high',
+      'claude-sonnet-4-6',
+      'claude-opus-4-6-thinking',
       'gpt-oss-120b-medium',
-      'gemini-3.1-pro-high-vertex',
       'gemini-3-flash',
       'gemini-2.5-pro',
       'gemini-2.5-flash',
@@ -183,30 +193,72 @@ export async function usage(blob, _cfg, fetchImpl) {
   return retrieveQuotaPercent(fetchImpl || fetch, blob.accessToken, headersFor(blob.projectId || ''))
 }
 
+const RESPONSE_TIMEOUT_MS = 30000
+
+function isTransientFailure(err) {
+  return err?.name === 'TimeoutError' || err?.code === 'TIMEOUT' || err?.code === 'EMPTY_RESPONSE' || err instanceof TypeError
+}
+
 export async function* streamOnce({ blob, options, fetchImpl, headers, signal, saveBlob }) {
+  const impl = fetchImpl || fetch
   // Abort must cover the project pre-flight as well as the stream.
-  const preflight = (u, i) => fetchImpl(u, { ...(i || {}), signal })
-  const ready = await withProject(blob, preflight, saveBlob)
-  const { envelope, sessionId } = streamEnvelope({
-    projectId: ready.projectId,
-    model: options.model,
-    request: googleContents(options),
-    userAgent: 'antigravity',
-    sessionId: ready.sessionId,
-    paidTierId: ready.paidTierId,
-  })
-  const res = await fetchImpl(`${CODE_ASSIST_STREAM}:streamGenerateContent?alt=sse`, {
-    method: 'POST',
-    headers: {
-      ...headers,
-      ...assistHeaders(ready.accessToken, { ...headersFor(ready.projectId || ''), Accept: 'text/event-stream' }),
-    },
-    body: JSON.stringify(envelope),
-    signal,
-  })
-  if (!res.ok) throwHttpError(res.status, await res.text())
-  if (saveBlob && sessionId && sessionId !== ready.sessionId) {
-    await saveBlob({ ...ready, sessionId })
+  const preflight = (u, i) => fetchWithTimeout(impl, u, { ...(i || {}), signal }, { timeoutMs: RESPONSE_TIMEOUT_MS })
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    let emitted = false
+    try {
+      const ready = await withProject(blob, preflight, saveBlob)
+      const tiered = antigravityTieredAlias(options.model)
+      const request = googleContents(options)
+      if (tiered) {
+        if (!request.generationConfig) request.generationConfig = {}
+        request.generationConfig.thinkingConfig = /** @type {any} */ ({ thinkingLevel: tiered.thinkingLevel })
+      }
+      const { envelope, sessionId } = streamEnvelope({
+        projectId: ready.projectId,
+        model: tiered ? tiered.model : options.model,
+        request,
+        userAgent: 'antigravity',
+        sessionId: ready.sessionId,
+        paidTierId: ready.paidTierId,
+      })
+      const res = await fetchWithTimeout(impl, `${CODE_ASSIST_STREAM}:streamGenerateContent?alt=sse`, {
+        method: 'POST',
+        headers: {
+          ...headers,
+          ...assistHeaders(ready.accessToken, { ...headersFor(ready.projectId || ''), Accept: 'text/event-stream' }),
+        },
+        body: JSON.stringify(envelope),
+        signal,
+      }, { timeoutMs: RESPONSE_TIMEOUT_MS })
+      if (!res.ok) throwHttpError(res.status, await res.text())
+      if (saveBlob && sessionId && sessionId !== ready.sessionId) {
+        await saveBlob({ ...ready, sessionId })
+      }
+      const pending = []
+      let hasContent = false
+      for await (const event of googleStream(res.body, { signal, idleTimeoutMs: RESPONSE_TIMEOUT_MS })) {
+        if (!hasContent) {
+          if (event.type === 'text-delta' || event.type === 'tool-call-delta' || event.type === 'reasoning-delta') {
+            hasContent = true
+            for (const item of pending) { emitted = true; yield item }
+          } else if (event.type !== 'finish') {
+            pending.push(event)
+            continue
+          } else {
+            continue
+          }
+        }
+        emitted = true
+        yield event
+      }
+      if (!hasContent) {
+        const err = /** @type {any} */ (new Error('Antigravity returned no content'))
+        err.code = 'EMPTY_RESPONSE'
+        throw err
+      }
+      return
+    } catch (err) {
+      if (emitted || signal?.aborted || attempt === 1 || !isTransientFailure(err)) throw err
+    }
   }
-  yield* googleStream(res.body)
 }

package/lib/wire.js

@@ -328,14 +328,18 @@ export async function* anthropicStream(body) {
   yield { type: 'finish', reason: finish }
 }
 
-export async function* googleStream(body) {
+/**
+ * @param {any} body
+ * @param {{ signal?: AbortSignal, idleTimeoutMs?: number }} [options]
+ */
+export async function* googleStream(body, { signal, idleTimeoutMs } = {}) {
   let index = 0
   let started = false
   let callCount = 0
   const functionCallIndexes = new Map()
   let finish = { kind: 'stop' }
   let sawTerminal = false
-  for await (const data of iterateSse(body)) {
+  for await (const data of iterateSse(body, { signal, idleTimeoutMs })) {
     if (data === '[DONE]') {
       sawTerminal = true
       break

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-subscriptions",
-  "version": "0.6.68",
+  "version": "0.6.70",
   "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",