@goodandready/dsh-subscriptions 0.6.39 → 0.6.41

package/lib/accounts.js

@@ -260,59 +260,84 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
     return promise
   }
 
+  const providerUsageLocks = new Map()
+  const slotUsageLocks = new Map()
+
   async function refreshUsage(provider) {
-    const curConfig = getConfig()
-    const cfg = vendorConfig(provider, curConfig)
-    const vendor = getVendor(provider)
-    const slots = normalizeSlots(curConfig.slots).filter((s) => s.provider === provider)
-    for (const slot of slots) {
-      const last = usageFetched.get(slot.ref) || 0
-      if (Date.now() - last < USAGE_TTL_MS) continue
-      let raw = ''
-      try { raw = await resolveRaw(slot.ref) } catch { continue }
-      if (!raw) continue
-      try {
-        const blob = await ensureFresh(provider, parseBlob(raw), slot.ref)
-        const snap = await vendor.usage(blob, cfg, fetchFor(slot.ref))
-        usageFetched.set(slot.ref, Date.now())
-        if (!snap) continue
-        if (Number.isFinite(Number(snap.usedPercent))) {
-          usage.set(slot.ref, Number(snap.usedPercent))
+    if (providerUsageLocks.has(provider)) {
+      return providerUsageLocks.get(provider)
+    }
+    const flight = (async () => {
+      const curConfig = getConfig()
+      const cfg = vendorConfig(provider, curConfig)
+      const vendor = getVendor(provider)
+      const slots = normalizeSlots(curConfig.slots).filter((s) => s.provider === provider)
+      for (const slot of slots) {
+        if (slotUsageLocks.has(slot.ref)) {
+          await slotUsageLocks.get(slot.ref).catch(() => {})
+          continue
         }
-        // Notification thresholds: 70/90/100% — fire once per window until reset.
-        if (Array.isArray(snap.windows)) {
-          for (const win of snap.windows) {
-            if (!win || !Number.isFinite(Number(win.usedPercent))) continue
-            const pct = Number(win.usedPercent)
-            const key = slot.ref + ':' + win.id
-            const prev = notifyThresholds.get(key) || 0
-            const THRESHOLDS = [70, 90, 100]
-            for (const th of THRESHOLDS) {
-              if (pct >= th && prev < th) {
-                notifyThresholds.set(key, th)
-                try { onLimitNotice && onLimitNotice(slot.provider, slot.ref, win, th) } catch { /* ignore notification failure */ }
-                break
+        const last = usageFetched.get(slot.ref) || 0
+        if (Date.now() - last < USAGE_TTL_MS) continue
+        let raw = ''
+        try { raw = await resolveRaw(slot.ref) } catch { continue }
+        if (!raw) continue
+
+        const slotFlight = (async () => {
+          try {
+            usageFetched.set(slot.ref, Date.now())
+            const blob = await ensureFresh(provider, parseBlob(raw), slot.ref)
+            const snap = await vendor.usage(blob, cfg, fetchFor(slot.ref))
+            if (!snap) return
+            if (Number.isFinite(Number(snap.usedPercent))) {
+              usage.set(slot.ref, Number(snap.usedPercent))
+            }
+            // Notification thresholds: 70/90/100% — fire once per window until reset.
+            if (Array.isArray(snap.windows)) {
+              for (const win of snap.windows) {
+                if (!win || !Number.isFinite(Number(win.usedPercent))) continue
+                const pct = Number(win.usedPercent)
+                const key = slot.ref + ':' + win.id
+                const prev = notifyThresholds.get(key) || 0
+                const THRESHOLDS = [70, 90, 100]
+                for (const th of THRESHOLDS) {
+                  if (pct >= th && prev < th) {
+                    notifyThresholds.set(key, th)
+                    try { onLimitNotice && onLimitNotice(slot.provider, slot.ref, win, th) } catch { /* ignore notification failure */ }
+                    break
+                  }
+                }
               }
             }
-          }
-        }
-        const list = Array.isArray(snap.windows) ? snap.windows : null
-        if (list) {
-          windows.set(slot.ref, list)
-          // persist last known windows so the card survives restarts
-          try {
-            const prev = Array.isArray(blob.usage) ? JSON.stringify(blob.usage) : ''
-            if (prev !== JSON.stringify(list)) {
-              await saveBlob(slot.ref, { ...blob, usage: list, usageAt: Date.now() })
-            } else if (!blob.usageAt) {
-              await saveBlob(slot.ref, { ...blob, usageAt: Date.now() })
+            const list = Array.isArray(snap.windows) ? snap.windows : null
+            if (list) {
+              windows.set(slot.ref, list)
+              // persist last known windows so the card survives restarts
+              try {
+                const prev = Array.isArray(blob.usage) ? JSON.stringify(blob.usage) : ''
+                if (prev !== JSON.stringify(list)) {
+                  await saveBlob(slot.ref, { ...blob, usage: list, usageAt: Date.now() })
+                } else if (!blob.usageAt) {
+                  await saveBlob(slot.ref, { ...blob, usageAt: Date.now() })
+                }
+              } catch { /* persistence best-effort */ }
             }
-          } catch { /* persistence best-effort */ }
-        }
-      } catch {
-        usageFetched.set(slot.ref, Date.now())
+          } catch {
+            usageFetched.set(slot.ref, Date.now())
+          } finally {
+            slotUsageLocks.delete(slot.ref)
+          }
+        })()
+
+        slotUsageLocks.set(slot.ref, slotFlight)
+        await slotFlight.catch(() => {})
       }
-    }
+    })().finally(() => {
+      providerUsageLocks.delete(provider)
+    })
+
+    providerUsageLocks.set(provider, flight)
+    return flight
   }
 
   return {

package/lib/adapter-manager.js

@@ -63,7 +63,8 @@ export function createAdapterManager({
     const cfg = live()
     if (!cfg.cascadingFallback) throw err
     const logged = await store.loggedInProviders()
-    const available = Object.keys(logged || {}).filter((p) => logged[p] && p !== provider)
+    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)
     if (!nextVendor) throw err
@@ -280,8 +281,9 @@ export function createAdapterManager({
       // #75: eager usage refresh at startup so the windows (5h/7d) land in the blob immediately
       const eager = async () => {
         try {
-          for (const slot of normalizeSlots(live().slots)) {
-            store.refreshUsage(slot.provider).catch((err) => {
+          const uniqueProviders = new Set(normalizeSlots(live().slots).map((s) => s.provider).filter(Boolean))
+          for (const provider of uniqueProviders) {
+            store.refreshUsage(provider).catch((err) => {
               if (logger && logger.debug) logger.debug('[dsh-subscriptions] eager usage error: ' + (err && err.message || err))
             })
           }

package/lib/adapter.js

@@ -73,7 +73,7 @@ export class SubscriptionAdapter extends LlmAdapter {
       models = models.filter((m) => !isDeprecatedId(String((m && m.id) || '')))
     }
     // Defensive: ensure every model has the provider field set
-    models = models.map((m) => (m && !m.provider ? { ...m, provider } : m))
+    models = models.map((m) => (m ? { ...m, provider: (!m.provider || m.provider === "custom") ? provider : m.provider } : m))
     return models
   }
 
@@ -132,8 +132,70 @@ export class SubscriptionAdapter extends LlmAdapter {
           const t0 = Date.now()
           let firstChunkTime = null
           let outputTokens = 0
+          let inputTokens = 0
+          let cacheReadTokens = 0
+          let cacheWriteTokens = 0
           let approxChars = 0
-          const blob = await deps.ensureFresh(provider, await deps.loadBlob(account.ref), account.ref)
+          let completed = false
+          let sawFinish = false
+          let finishReason = null
+          let errorCaught = null
+          let finalized = false
+          let blob = null
+
+          const finalizeOnce = (outcome, extraStatus) => {
+            if (finalized) return
+            finalized = true
+
+            if (!outputTokens && approxChars > 0) {
+              outputTokens = Math.max(1, Math.round(approxChars / 4))
+            }
+
+            const totalMs = Date.now() - t0
+            const ttftMs = firstChunkTime !== null ? Math.max(0, firstChunkTime - t0) : null
+            const genMs = (firstChunkTime !== null && totalMs > ttftMs) ? (totalMs - ttftMs) : 0
+            const tps = (outputTokens > 0 && genMs > 0)
+              ? Math.round((outputTokens / (genMs / 1000)) * 10) / 10
+              : null
+
+            let status = 200
+            if (outcome === 'error') {
+              status = extraStatus || (errorCaught && (errorCaught.status || errorCaught.statusCode)) || (errorCaught && errorCaught.code === 'QUOTA' ? 429 : 500)
+            } else if (outcome === 'cancel') {
+              status = 499
+            } else if (outcome === 'runaway') {
+              status = 200
+            }
+
+            if (outcome === 'success') {
+              if (typeof deps.recordSuccess === 'function') deps.recordSuccess(account.ref)
+            }
+
+            if (typeof deps.recordHistory === 'function') {
+              try {
+                deps.recordHistory({
+                  provider,
+                  ref: account.ref,
+                  model: (opts && opts.model) || null,
+                  path: '/responses',
+                  method: 'POST',
+                  status,
+                  outcome,
+                  ms: totalMs,
+                  ttftMs,
+                  tps,
+                  inputTokens: inputTokens || undefined,
+                  outputTokens: outputTokens || undefined,
+                  cacheReadTokens: cacheReadTokens || undefined,
+                  cacheWriteTokens: cacheWriteTokens || undefined,
+                  kind: 'stream',
+                  ...(outcome === 'error' && errorCaught ? { error: errorCaught.message || String(errorCaught) } : {}),
+                  ...(outcome === 'runaway' ? { reason: finishReason || (opts && opts._runawayState && opts._runawayState.reason) || 'runaway_loop_detected' } : {}),
+                })
+              } catch { /* ignore quota capture failure */ }
+            }
+          }
+
           const vendor = getVendor(provider)
           // ponytail: capture x-ratelimit headers without touching vendors
           const baseFetch = pickFetch(deps, account.ref)
@@ -186,7 +248,9 @@ export class SubscriptionAdapter extends LlmAdapter {
             }
             return res
           }
+
           try {
+            blob = await deps.ensureFresh(provider, await deps.loadBlob(account.ref), account.ref)
             if (typeof deps.rememberRequest === 'function') deps.rememberRequest(account.ref)
             for await (const chunk of vendor.streamOnce({
               blob,
@@ -201,54 +265,38 @@ export class SubscriptionAdapter extends LlmAdapter {
                 firstChunkTime = Date.now()
               }
               if (chunk && typeof chunk === 'object') {
-                if (chunk.type === 'usage' && chunk.usage) {
+                if (chunk.type === 'finish') {
+                  sawFinish = true
+                  finishReason = chunk.reason
+                } else if (chunk.type === 'usage' && chunk.usage) {
                   const u = toTokenUsage(chunk.usage)
                   if (u && typeof u.outputTokens === 'number' && u.outputTokens > 0) {
                     outputTokens = u.outputTokens
                   }
+                  if (u && typeof u.inputTokens === 'number') {
+                    inputTokens = u.inputTokens
+                  }
+                  if (u && typeof u.cacheReadTokens === 'number') {
+                    cacheReadTokens = u.cacheReadTokens
+                  }
+                  if (u && typeof u.cacheWriteTokens === 'number') {
+                    cacheWriteTokens = u.cacheWriteTokens
+                  }
                 } else if (chunk.type === 'text-delta' && typeof chunk.text === 'string') {
                   approxChars += chunk.text.length
                 }
               }
               yield chunk
             }
-            if (!outputTokens && approxChars > 0) {
-              outputTokens = Math.max(1, Math.round(approxChars / 4))
-            }
-            // stream completed successfully: clear cooldown and health penalties
-            if (typeof deps.recordSuccess === 'function') deps.recordSuccess(account.ref)
-            // #65: record in the request and cost history.
-            if (typeof deps.recordHistory === 'function') {
-              try {
-                const totalMs = Date.now() - t0
-                const ttftMs = firstChunkTime !== null ? Math.max(0, firstChunkTime - t0) : null
-                const genMs = (firstChunkTime !== null && totalMs > ttftMs) ? (totalMs - ttftMs) : 0
-                const tps = (outputTokens > 0 && genMs > 0)
-                  ? Math.round((outputTokens / (genMs / 1000)) * 10) / 10
-                  : null
-
-                deps.recordHistory({
-                  provider,
-                  ref: account.ref,
-                  model: (opts && opts.model) || null,
-                  path: '/responses',
-                  method: 'POST',
-                  status: 200,
-                  ms: totalMs,
-                  ttftMs,
-                  tps,
-                  outputTokens: outputTokens || undefined,
-                  kind: 'stream',
-                })
-              } catch { /* ignore quota capture failure */ }
-            }
+            completed = true
           } catch (err) {
+            errorCaught = err
             if (err && (err.code === 'QUOTA' || err.code === 'QUOTA_EXCEEDED' || err.status === 429)) {
               if (typeof deps.recordExhaust === 'function') deps.recordExhaust(account.ref)
             } else if (err && (err.status === 401 || err.status === 403 || err.code === 'TOKEN_REVOKED' || err.code === 'BROKEN')) {
               if (typeof deps.recordBroken === 'function') deps.recordBroken(account.ref)
             }
-            if (err && err.code === 'VALIDATION_REQUIRED' && err.validationUrl) {
+            if (err && err.code === 'VALIDATION_REQUIRED' && err.validationUrl && blob) {
               await deps.saveBlob(account.ref, {
                 ...blob,
                 validationUrl: err.validationUrl,
@@ -256,6 +304,18 @@ export class SubscriptionAdapter extends LlmAdapter {
               })
             }
             throw err
+          } finally {
+            if (errorCaught) {
+              finalizeOnce('error')
+            } else if (opts && opts._runawayState && opts._runawayState.tripped) {
+              finalizeOnce('runaway')
+            } else if (completed || sawFinish) {
+              finalizeOnce('success')
+            } else if (opts && opts.signal && opts.signal.aborted) {
+              finalizeOnce('cancel', 499)
+            } else {
+              finalizeOnce('cancel', 499)
+            }
           }
         },
       })) {

package/lib/client.js

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

package/lib/history.js

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

package/lib/images.js

@@ -205,25 +205,48 @@ export function toOpenAiImage(norm) {
 }
 
 export function toAnthropicImage(norm) {
-  if (!norm.base64) return null
-  return {
-    type: 'image',
-    source: {
-      type: 'base64',
-      media_type: norm.mimeType || 'image/jpeg',
-      data: norm.base64,
-    },
+  if (!norm) return null
+  if (norm.base64) {
+    return {
+      type: 'image',
+      source: {
+        type: 'base64',
+        media_type: norm.mimeType || 'image/jpeg',
+        data: norm.base64,
+      },
+    }
   }
+  if (norm.url) {
+    return {
+      type: 'image',
+      source: {
+        type: 'url',
+        url: norm.url,
+      },
+    }
+  }
+  return null
 }
 
 export function toGeminiImage(norm) {
-  if (!norm.base64) return null
-  return {
-    inlineData: {
-      mimeType: norm.mimeType || 'image/jpeg',
-      data: norm.base64,
-    },
+  if (!norm) return null
+  if (norm.base64) {
+    return {
+      inlineData: {
+        mimeType: norm.mimeType || 'image/jpeg',
+        data: norm.base64,
+      },
+    }
   }
+  if (norm.url) {
+    return {
+      fileData: {
+        mimeType: norm.mimeType || 'image/jpeg',
+        fileUri: norm.url,
+      },
+    }
+  }
+  return null
 }
 
 export function toCodexImage(norm) {

package/lib/index.js

@@ -22,6 +22,7 @@ import { HistoryStore, resolveHistoryDir } from './history.js'
 import { createDiagnosticsReport } from './diagnostics.js'
 import { createAccountsView } from './accounts-view.js'
 import { createAdapterManager } from './adapter-manager.js'
+import { pickAccount } from './rotate.js'
 
 export { observeForecast, estimateForecast } from './forecast.js'
 export { formatRelativeReset } from './relative-time.js'
@@ -328,7 +329,8 @@ export function apply(ctx, rawConfig) {
   ctx.effect(() => ctx.provide('subscriptionImages', {
     async available() {
       const logged = await store.loggedInProviders()
-      return ['codex', 'grok'].filter((name) => logged && logged[name])
+      const loggedList = Array.isArray(logged) ? logged : Object.keys(logged || {}).filter((name) => logged[name])
+      return ['codex', 'grok'].filter((name) => loggedList.includes(name))
     },
     sizes: IMAGE_SIZES,
     async generate(request) {
@@ -337,18 +339,20 @@ export function apply(ctx, rawConfig) {
         throw new Error(`unknown subscription provider: ${provider}`)
       }
       const accounts = await store.listAccounts(provider)
-      const slot = (accounts || []).find((row) => row && row.ref)
+      const eligible = pickAccount(accounts || [], Date.now(), { family: provider === 'codex' ? 'gpt' : 'grok' })
+      const slot = eligible || (accounts || []).find((row) => row && row.ref && row.hasToken)
       if (!slot) throw new Error(`not logged in to ${provider}: sign in in the Subscriptions section`)
       const raw = await store.resolveRaw(slot.ref)
       if (!raw) throw new Error(`not logged in to ${provider}: sign in in the Subscriptions section`)
       const session = await store.ensureFresh(provider, parseBlob(raw), slot.ref)
+      const fetchFn = (typeof fetchForRef === 'function' && fetchForRef(slot.ref)) || fetch
       return generateOnce({
         provider,
         prompt: request.prompt,
         size: request.size,
         quality: request.quality,
         session,
-        fetchImpl: fetch,
+        fetchImpl: fetchFn,
         signal: request.signal,
       })
     },

package/lib/responses-stream.js

@@ -170,6 +170,6 @@ export async function* streamResponses(body) {
     if (translator.terminated) return
   }
   if (!translator.terminated) {
-    yield { type: 'finish', reason: { kind: 'stop' } }
+    yield { type: 'finish', reason: { kind: 'error', failure: { code: 'INCOMPLETE', message: 'stream terminated before response.completed' } } }
   }
 }

package/lib/rotate.js

@@ -44,7 +44,7 @@ export function cooldownBlocks(acc, family) {
 export function pickAccount(accounts, nowMs, opts) {
   const list = Array.isArray(accounts) ? accounts : []
   const now = Number(nowMs) || 0
-  const thrRaw = opts && opts.switchAtRemaining != null ? Number(opts.switchAtRemaining) : 0.01
+  const thrRaw = opts && opts.switchAtRemaining != null ? Number(opts.switchAtRemaining) : 0
   const thr = Number.isFinite(thrRaw) ? thrRaw : 0
   const isVipRequest = Boolean(opts && opts.vip)
   const targetTag = opts && opts.tag
@@ -115,8 +115,7 @@ export function pickAccount(accounts, nowMs, opts) {
 
     const isCooldown = acc.cooldownUntil && Number(acc.cooldownUntil) > now && cooldownBlocks(acc, opts && opts.family)
     const inQuarantine = isQuarantined(acc, now)
-    const isHardExhausted = (acc.quota && acc.quota.remaining != null && Number(acc.quota.remaining) <= 0 && acc.quota.resetAt && Number(acc.quota.resetAt) > now) ||
-                            (acc.usagePercent != null && Number(acc.usagePercent) >= 100 && (!acc.quota || !acc.quota.resetAt || Number(acc.quota.resetAt) > now))
+    const isHardExhausted = (acc.usagePercent != null && Number(acc.usagePercent) >= 100 && (!acc.quota || !acc.quota.resetAt || Number(acc.quota.resetAt) > now))
 
     if (isCooldown || inQuarantine || isHardExhausted) {
       continue

package/lib/routes/proxy.js

@@ -53,7 +53,7 @@ export function registerProxyRoutes(ctx, state) {
       const url = new URL(req.url || '/', 'http://localhost')
       const parts = url.pathname.replace(/^\/dsh-subscriptions\/proxy\//, '').split('/').filter(Boolean)
       const provider = parts[0]
-      const restPath = '/' + parts.slice(1).join('/')
+      const restPath = '/' + parts.slice(1).join('/') + (url.search || '')
       if (!isProvider(provider)) {
         writeJson(res, 404, { ok: false, error: { code: 'provider', message: 'unknown provider' } })
         return