@goodandready/dsh-subscriptions 0.2.1 → 0.2.3

package/lib/accounts.js

@@ -50,6 +50,9 @@ export function vendorConfig(provider, cfg) {
 
 export function createAccountStore({ credentials, getConfig, fetchImpl }) {
   const cooldowns = new Map()
+  const quotas = new Map()
+  const refreshLocks = new Map()
+  const refreshFailures = new Map()
   const usage = new Map()
   const usageFetched = new Map()
   const doFetch = fetchImpl || fetch
@@ -80,6 +83,8 @@ export function createAccountStore({ credentials, getConfig, fetchImpl }) {
   async function clearRef(ref) {
     await credentials.unset(credentialRef(ref))
     cooldowns.delete(ref)
+    quotas.delete(ref)
+    refreshFailures.delete(ref)
     usage.delete(ref)
     usageFetched.delete(ref)
   }
@@ -111,7 +116,9 @@ export function createAccountStore({ credentials, getConfig, fetchImpl }) {
     return {
       ...base,
       cooldownUntil: cooldowns.get(ref) || 0,
+      quota: quotas.get(ref) || null,
       usagePercent: usage.has(ref) ? usage.get(ref) : null,
+      refreshError: refreshFailures.get(ref)?.error || '',
       validationUrl: base.validationUrl || '',
       validationMessage: base.validationMessage || '',
       accountNotice: base.accountNotice || '',
@@ -129,6 +136,7 @@ export function createAccountStore({ credentials, getConfig, fetchImpl }) {
         hasToken: !!info.configured,
         usagePercent: info.usagePercent,
         cooldownUntil: info.cooldownUntil,
+        quota: info.quota || null,
         label: slot.label || info.label,
       })
     }
@@ -147,17 +155,30 @@ export function createAccountStore({ credentials, getConfig, fetchImpl }) {
   async function ensureFresh(provider, blob, ref) {
     if (!blob.refreshToken) return blob
     if (blob.expiresAt && blob.expiresAt - SKEW_MS > Date.now()) return blob
-    const cfg = vendorConfig(provider, getConfig())
-    const next = await getVendor(provider).refresh(cfg, blob, doFetch)
-    const merged = {
-      ...blob,
-      ...next,
-      refreshToken: next.refreshToken || blob.refreshToken,
-      projectId: next.projectId || blob.projectId,
-      accountId: next.accountId || blob.accountId,
-    }
-    if (ref) await saveBlob(ref, merged)
-    return merged
+    if (ref && refreshLocks.has(ref)) return refreshLocks.get(ref)
+    const promise = (async () => {
+      try {
+        const cfg = vendorConfig(provider, getConfig())
+        const next = await getVendor(provider).refresh(cfg, blob, doFetch)
+        const merged = {
+          ...blob,
+          ...next,
+          refreshToken: next.refreshToken || blob.refreshToken,
+          projectId: next.projectId || blob.projectId,
+          accountId: next.accountId || blob.accountId,
+        }
+        if (ref) await saveBlob(ref, merged)
+        if (ref) refreshFailures.delete(ref)
+        return merged
+      } catch (e) {
+        if (ref) refreshFailures.set(ref, { at: Date.now(), error: String(e && e.message || e) })
+        throw e
+      } finally {
+        if (ref) refreshLocks.delete(ref)
+      }
+    })()
+    if (ref) refreshLocks.set(ref, promise)
+    return promise
   }
 
   async function refreshUsage(provider) {
@@ -193,6 +214,9 @@ export function createAccountStore({ credentials, getConfig, fetchImpl }) {
     ensureFresh,
     refreshUsage,
     rememberCooldown(ref, until) { cooldowns.set(ref, until) },
+    rememberQuota(ref, snap) { if (snap) quotas.set(ref, snap); else quotas.delete(ref) },
+    shouldSkipRefresh(ref, now, retryMs) { const f = refreshFailures.get(ref); if (!f) return false; return (Number(f.at) + Number(retryMs)) > Number(now) },
+    getQuota(ref) { return quotas.get(ref) || null },
     rememberUsage(ref, percent) { usage.set(ref, percent) },
   }
 }

package/lib/adapter.js

@@ -76,16 +76,40 @@ export class SubscriptionAdapter extends LlmAdapter {
         accounts: await deps.listAccounts(provider),
         nowMs: () => Date.now(),
         cooldownMs: deps.cooldownMs(),
+        switchAtRemaining: typeof deps.switchAtRemaining === 'function' ? deps.switchAtRemaining() : (deps.switchAtRemaining ?? 0),
         options,
         onCooldown: (account) => deps.rememberCooldown(account.ref, account.cooldownUntil),
         streamOnce: async function* (account, opts) {
           const blob = await deps.ensureFresh(provider, await deps.loadBlob(account.ref), account.ref)
           const vendor = getVendor(provider)
+          // ponytail: capture x-ratelimit headers without touching vendors
+          const baseFetch = deps.fetchImpl || fetch
+          const quotaFetch = async (url, init) => {
+            const res = await baseFetch(url, init)
+            try {
+              const snap = quotaSnapshot(provider, res.headers, null, Date.now())
+              if (snap && typeof deps.rememberQuota === "function") deps.rememberQuota(account.ref, snap)
+            } catch {}
+            if (!res.ok && res.clone) {
+              try {
+                const txt = await res.clone().text()
+                let j=null; try{ j=JSON.parse(txt)}catch{}
+                if (j) {
+                  const b = parseBody(provider, j, Date.now())
+                  if (b) {
+                    const snap2 = quotaSnapshot(provider, res.headers, j, Date.now())
+                    if (snap2) deps.rememberQuota(account.ref, snap2)
+                  }
+                }
+              } catch {}
+            }
+            return res
+          }
           try {
             yield* vendor.streamOnce({
               blob,
               options: opts,
-              fetchImpl: deps.fetchImpl || fetch,
+              fetchImpl: quotaFetch,
               headers: attributionHeaders(),
               config: deps.vendorConfig(provider),
               signal: opts.signal,

package/lib/client.js

@@ -109,6 +109,8 @@ window.__ModuleLoader__.load({
       const [accounts, setAccounts] = React.useState([])
       const [providers, setProviders] = React.useState([])
       const [paste, setPaste] = React.useState({})
+      const [checkRes, setCheckRes] = React.useState({})
+      const [checking, setChecking] = React.useState({})
       const [saved, setSaved] = React.useState(false)
       const [err, setErr] = React.useState('')
 
@@ -170,6 +172,25 @@ window.__ModuleLoader__.load({
         setPaste((p) => Object.assign({}, p, { [key]: '' }))
       }
 
+      const doCheck = async (provider, index) => {
+        const key = provider + ':' + index
+        setChecking((c) => Object.assign({}, c, { [key]: true }))
+        setErr('')
+        try {
+          const res = await fetch('/dsh-subscriptions/check', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ provider, index }),
+          })
+          const data = await res.json().catch(() => ({}))
+          setCheckRes((m) => Object.assign({}, m, { [key]: data }))
+          if (data && data.quota) {
+            setAccounts((prev) => prev.map((a) => a.provider===provider && a.index===index ? Object.assign({}, a, { quota: data.quota }) : a))
+          }
+        } catch (e) { setErr(String(e.message || e)) }
+        setChecking((c) => Object.assign({}, c, { [key]: false }))
+      }
+
       const logout = async (provider, index) => {
         setErr('')
         const res = await fetch('/dsh-subscriptions/logout', {
@@ -244,6 +265,11 @@ window.__ModuleLoader__.load({
                     disabled: !on,
                     onClick: () => logout(row.slot.provider, row.slot.index).catch((e) => setErr(String(e.message || e))),
                   }, t('disconnect')),
+                  React.createElement('button', {
+                    type: 'button', className: 'dsub-mini',
+                    disabled: checking[key],
+                    onClick: () => doCheck(row.slot.provider, row.slot.index).catch((e) => setErr(String(e.message || e))),
+                  }, checking[key] ? '...' : 'Check'),
                   React.createElement('button', {
                     type: 'button', className: 'dsub-mini', title: t('removeSlot'),
                     onClick: () => {
@@ -267,12 +293,16 @@ window.__ModuleLoader__.load({
                   }, t('submitCode')),
                 ),
                 account.accountNotice ? React.createElement('div', { className: 'dsub-verify' }, account.accountNotice) : null,
+                account.refreshError ? React.createElement('div', { className: 'dsub-bad' }, 'reconnect required: ' + account.refreshError) : null,
+                (function(){ var r=checkRes[key]; if(!r) return null; var txt=r.ok ? ('ok ' + (r.email||'')) : ('fail ' + (r.error && r.error.message || '')); var cls=r.ok ? 'dsub-ok' : 'dsub-bad'; var q=r.quota; if(q && q.remaining!=null) txt += ' quota:'+q.remaining+(q.limit!=null?'/'+q.limit:''); return React.createElement('div', {className: cls}, txt) })(),
                 account.validationUrl ? React.createElement('div', { className: 'dsub-verify' },
                   t('verifyPrefix'),
                   React.createElement('a', { href: account.validationUrl, target: '_blank', rel: 'noopener noreferrer' }, t('verifyLink')),
                   t('verifySuffix'),
                 ) : null,
-                account.paidTierName ? React.createElement('span', { className: 'dsub-sub' }, t('plan') + ': ' + account.paidTierName) : null,
+(function(){var q=account.quota;if(!q)return null;var a=[];if(q.remaining!=null&&q.limit!=null)a.push(q.remaining+"/"+q.limit);else if(q.remaining!=null)a.push(String(q.remaining));if(q.resetAt){var d=new Date(q.resetAt);a.push(d.toLocaleTimeString())}if(q.measuredAt){var m=Math.round((Date.now()-q.measuredAt)/60000);a.push(m<1?"<1m":m+"m ago")}if(!a.length)return null;return React.createElement("span",{className:"dsub-sub"},"Quota "+a.join(" \u00b7 "))})(),
+
+                                account.paidTierName ? React.createElement('span', { className: 'dsub-sub' }, t('plan') + ': ' + account.paidTierName) : null,
                 account.ref ? React.createElement('span', { className: 'dsub-sub' }, t('storedAs') + ' ' + account.ref) : null,
               )
             }),

package/lib/index.js

@@ -7,6 +7,8 @@ import { getVendor } from './vendors/index.js'
 import { SubscriptionAdapter } from './adapter.js'
 import { generateOnce, SIZES as IMAGE_SIZES } from './images.js'
 import { parseBlob } from './blob.js'
+import { createSubscriptionsService } from './subscriptions.js'
+import { quotaSnapshot } from './ratelimit.js'
 import { createAccountStore, normalizeSlots, vendorConfig } from './accounts.js'
 import {
   inspectGoogleAccount,
@@ -34,6 +36,12 @@ const defaultSlots = PROVIDERS.map((provider) => ({ provider, index: 1, label: '
 export const Config = z.object({
   cooldownMs: z.number().default(30 * 60 * 1000)
     .description('After RATE_LIMIT/QUOTA/429, skip that account for this many milliseconds.'),
+  switchAtRemaining: z.number().default(0)
+    .description('If remaining <= this (absolute or <1 fraction), treat as exhausted before request. 0 disables.'),
+  refreshAheadMs: z.number().default(5 * 60 * 1000)
+    .description('Background refresh when expiry within this many ms.'),
+  refreshRetryMs: z.number().default(10 * 60 * 1000)
+    .description('Do not retry background refresh more often than this after failure.'),
   slots: z.array(Slot).default(defaultSlots)
     .description('Account slots. Secrets are not stored here; only the credential ref names.'),
   useWebCallback: z.boolean().default(false)
@@ -79,6 +87,17 @@ export function apply(ctx, config) {
 
   const live = () => Config(structuredClone(getConfig() ?? {})) ?? config
   const store = createAccountStore({ credentials: ctx.credentials, getConfig: live, fetchImpl: fetch })
+  const subscriptions = createSubscriptionsService({
+    listAccounts: (provider) => store.listAccounts(provider),
+    loadBlob: (ref) => store.loadBlob(ref),
+    ensureFresh: (provider, blob, ref) => store.ensureFresh(provider, blob, ref),
+    vendorConfig: (provider) => vendorConfig(provider, live()),
+    cooldownMs: () => live().cooldownMs,
+    switchAtRemaining: () => live().switchAtRemaining,
+    rememberCooldown: (ref, until) => store.rememberCooldown(ref, until),
+    rememberQuota: (ref, snap) => store.rememberQuota(ref, snap),
+    fetchImpl: fetch,
+  })
 
   // Служба генерации картинок на подписке.
   //
@@ -86,6 +105,7 @@ export function apply(ctx, config) {
   // ключ доступа каждому, кто дотянется до харнесса, а служба живёт внутри
   // процесса и видна только другим плагинам. Обновлением токена по-прежнему
   // занимается один хозяин — этот плагин.
+  ctx.effect(() => ctx.provide('subscriptions', subscriptions), 'dsh-subscriptions: subscriptions service')
   ctx.effect(() => ctx.provide('subscriptionImages', {
     /** Провайдеры, у которых есть вход прямо сейчас. */
     async available() {
@@ -126,7 +146,10 @@ export function apply(ctx, config) {
     ensureFresh: (provider, blob, ref) => store.ensureFresh(provider, blob, ref),
     vendorConfig: (provider) => vendorConfig(provider, live()),
     cooldownMs: () => live().cooldownMs,
+    switchAtRemaining: () => live().switchAtRemaining,
     rememberCooldown: (ref, until) => store.rememberCooldown(ref, until),
+    rememberQuota: (ref, snap) => store.rememberQuota(ref, snap),
+    getQuota: (ref) => store.getQuota(ref),
     refreshUsage: (provider) => store.refreshUsage(provider),
     saveBlob: (ref, blob) => store.saveBlob(ref, blob),
     fetchImpl: fetch,
@@ -187,7 +210,6 @@ export function apply(ctx, config) {
     return { ref, label: blob.label || blob.email || displayName(provider) }
   }
 
-
   async function enrichAntigravityAccount(slot, info) {
     if (!info.configured || slot.provider !== 'antigravity') return info
     let blob
@@ -250,6 +272,8 @@ export function apply(ctx, config) {
         writable: info.writable,
         cooldownUntil: info.cooldownUntil,
         usagePercent: info.usagePercent,
+        quota: info.quota || null,
+        refreshError: info.refreshError || '',
         validationUrl: info.validationUrl || '',
         validationMessage: info.validationMessage || '',
         accountNotice: info.accountNotice || '',
@@ -277,6 +301,39 @@ export function apply(ctx, config) {
       }
     }
   }, 'dsh-subscriptions: llm adapter')
+  // ponytail: background refresh ahead of expiry, single timer, per-account lock + retry backoff
+  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) => {
+            try { ctx.log && ctx.log.warn && ctx.log.warn("[dsh-subscriptions] background refresh failed for " + ref + ": " + String(e && e.message || e)) } catch {}
+          })
+        } catch {}
+      }
+    }
+    tick().catch(() => {})
+    const timer = setInterval
+    const clear = clearInterval
+    const id = timer(() => { tick().catch(() => {}) }, 60 * 1000)
+    return () => clear(id)
+  }, 'dsh-subscriptions: refresh ahead')
+
 
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
@@ -316,6 +373,9 @@ export function apply(ctx, config) {
         writeJson(res, 400, { ok: false, error: { code: 'save', message: String(e && e.message || e) } })
       }
     },
+
+  
+
   }), 'dsh-subscriptions: /config')
 
   ctx.effect(() => ctx.webServer.register({

package/lib/ratelimit.js

@@ -0,0 +1,218 @@
+// ponytail: per-provider header/body maps, add keys when new vendor differs
+export function numberOrNull(v) {
+  if (v == null || String(v).trim() === "") return null
+  const n = Number(v)
+  return Number.isFinite(n) ? n : null
+}
+
+function resetAtFromValue(raw, now) {
+  if (raw == null) return null
+  const s = String(raw).trim()
+  if (!s) return null
+  // ISO date?
+  if (/^\d{4}-\d{2}-\d{2}/.test(s)) {
+    const t = Date.parse(s)
+    return Number.isFinite(t) ? t : null
+  }
+  const n = Number(s)
+  if (!Number.isFinite(n)) return null
+  // if looks like epoch seconds (>1e9) -> ms
+  if (n > 1e9) {
+    // epoch seconds or ms? if >1e12 already ms
+    return n > 1e12 ? n : n * 1000
+  }
+  // otherwise seconds-from-now (Retry-After)
+  if (n >= 0 && n < 7 * 24 * 3600) return now + n * 1000
+  return null
+}
+
+function getHeader(headers, name) {
+  if (!headers) return null
+  const want = name.toLowerCase()
+  // Headers instance
+  if (typeof headers.get === "function") {
+    // try direct, then lowercase
+    let v = headers.get(name)
+    if (v != null) return v
+    // Headers are case-insensitive, but some impls need lower
+    v = headers.get(want)
+    if (v != null) return v
+    // iterate
+    if (typeof headers.forEach === "function") {
+      let found = null
+      headers.forEach((val, key) => {
+        if (String(key).toLowerCase() === want) found = val
+      })
+      return found
+    }
+    return null
+  }
+  // plain object
+  if (typeof headers === "object") {
+    for (const [k, v] of Object.entries(headers)) {
+      if (String(k).toLowerCase() === want) return v
+    }
+    // also handle array of pairs
+    if (Array.isArray(headers)) {
+      for (const [k,v] of headers) if (String(k).toLowerCase()===want) return v
+    }
+  }
+  return null
+}
+
+const HEADER_REMAINING = [
+  "x-ratelimit-remaining",
+  "x-ratelimit-remaining-requests",
+  "x-ratelimit-remaining-tokens",
+  "ratelimit-remaining",
+  "x-ratelimit-remaining-minute",
+]
+const HEADER_LIMIT = [
+  "x-ratelimit-limit",
+  "x-ratelimit-limit-requests",
+  "x-ratelimit-limit-tokens",
+  "ratelimit-limit",
+]
+const HEADER_RESET = [
+  "x-ratelimit-reset",
+  "x-ratelimit-reset-requests",
+  "x-ratelimit-reset-tokens",
+  "ratelimit-reset",
+  "retry-after",
+  "x-retry-after",
+  "x-ratelimit-reset-minute",
+]
+
+// per-provider body field tables — add provider key to extend without touching parser
+export const PROVIDER_BODY_FIELDS = {
+  codex: {
+    remaining: ["remaining", "remaining_requests", "rate_limit_remaining", "quota_remaining", "requests_remaining"],
+    limit: ["limit", "limit_requests", "quota_limit", "rate_limit", "max_requests"],
+    reset: ["reset", "reset_at", "resetAt", "reset_time", "retry_after", "reset_after"],
+  },
+  claude: {
+    remaining: ["remaining", "remaining_requests", "rate_limit_remaining"],
+    limit: ["limit", "quota", "rate_limit"],
+    reset: ["reset", "reset_at", "retry_after"],
+  },
+  grok: {
+    remaining: ["remaining", "creditRemaining", "remainingCredits"],
+    limit: ["limit", "monthlyLimit", "creditLimit"],
+    reset: ["reset", "resetAt", "retry_after"],
+  },
+  antigravity: {
+    remaining: ["remaining", "quotaRemaining"],
+    limit: ["limit", "quotaLimit"],
+    reset: ["reset", "resetAt", "retry_after"],
+  },
+  _common: {
+    remaining: ["remaining", "remaining_requests", "requests_remaining", "quota_remaining", "rate_limit_remaining", "rateLimitRemaining", "creditRemaining"],
+    limit: ["limit", "limit_requests", "quota_limit", "rate_limit", "rateLimit", "creditLimit", "monthlyLimit"],
+    reset: ["reset", "reset_at", "resetAt", "reset_time", "retry_after", "retryAfter", "reset_after", "rateLimitReset"],
+  },
+}
+
+function pickBodyField(obj, keys) {
+  if (!obj || typeof obj !== "object") return null
+  for (const k of keys) {
+    if (k in obj) {
+      const v = obj[k]
+      if (v != null && String(v) !== "") return v
+    }
+    // case-insensitive fallback
+    const low = k.toLowerCase()
+    for (const [ok, ov] of Object.entries(obj)) {
+      if (String(ok).toLowerCase() === low && ov != null && String(ov) !== "") return ov
+    }
+  }
+  return null
+}
+
+function deepest(obj, keys, depth=0) {
+  if (!obj || typeof obj !== "object" || depth>4) return null
+  const direct = pickBodyField(obj, keys)
+  if (direct != null) return direct
+  for (const v of Object.values(obj)) {
+    if (v && typeof v === "object") {
+      const found = deepest(v, keys, depth+1)
+      if (found != null) return found
+    }
+  }
+  return null
+}
+
+export function parseHeaders(headers, nowMs = Date.now()) {
+  let remaining = null, limit = null, resetAt = null
+  for (const h of HEADER_REMAINING) {
+    const v = getHeader(headers, h)
+    const n = numberOrNull(v)
+    if (n != null) { remaining = n; break }
+  }
+  for (const h of HEADER_LIMIT) {
+    const v = getHeader(headers, h)
+    const n = numberOrNull(v)
+    if (n != null) { limit = n; break }
+  }
+  for (const h of HEADER_RESET) {
+    const v = getHeader(headers, h)
+    if (v != null && String(v) !== "") {
+      const t = resetAtFromValue(v, nowMs)
+      if (t != null) { resetAt = t; break }
+      const n = numberOrNull(v)
+      if (n != null) { resetAt = n > 1e9 ? (n>1e12?n:n*1000) : nowMs + n*1000; break }
+    }
+  }
+  if (remaining==null && limit==null && resetAt==null) return null
+  return { remaining, limit, resetAt }
+}
+
+export function parseBody(provider, json, nowMs = Date.now()) {
+  if (!json || typeof json !== "object") return null
+  const table = PROVIDER_BODY_FIELDS[provider] || PROVIDER_BODY_FIELDS._common
+  const common = PROVIDER_BODY_FIELDS._common
+  const rk = [...(table.remaining||[]), ...common.remaining]
+  const lk = [...(table.limit||[]), ...common.limit]
+  const sk = [...(table.reset||[]), ...common.reset]
+  const rawRem = deepest(json, [...new Set(rk)])
+  const rawLim = deepest(json, [...new Set(lk)])
+  const rawReset = deepest(json, [...new Set(sk)])
+  const remaining = numberOrNull(rawRem)
+  const limit = numberOrNull(rawLim)
+  let resetAt = null
+  if (rawReset != null) resetAt = resetAtFromValue(rawReset, nowMs)
+  if (remaining==null && limit==null && resetAt==null) return null
+  return { remaining, limit, resetAt }
+}
+
+export function mergeQuota(headerPart, bodyPart) {
+  if (!headerPart && !bodyPart) return null
+  const remaining = headerPart?.remaining ?? bodyPart?.remaining ?? null
+  const limit = headerPart?.limit ?? bodyPart?.limit ?? null
+  const resetAt = headerPart?.resetAt ?? bodyPart?.resetAt ?? null
+  if (remaining==null && limit==null && resetAt==null) return null
+  return { remaining, limit, resetAt }
+}
+
+export function quotaSnapshot(provider, headers, bodyJson, nowMs = Date.now()) {
+  const h = parseHeaders(headers, nowMs)
+  const b = bodyJson ? parseBody(provider, bodyJson, nowMs) : null
+  const merged = mergeQuota(h, b)
+  if (!merged) return null
+  const { remaining, limit, resetAt } = merged
+  let usedPercent = null
+  if (remaining!=null && limit!=null && limit>0) {
+    usedPercent = ((limit - remaining) / limit) * 100
+    if (usedPercent < 0) usedPercent = 0
+    if (usedPercent > 100) usedPercent = 100
+  }
+  return { remaining, limit, resetAt: resetAt ?? null, usedPercent, measuredAt: nowMs }
+}
+
+export function formatQuota(q) {
+  if (!q) return ""
+  const parts = []
+  if (q.remaining!=null && q.limit!=null) parts.push(q.remaining+"/"+q.limit)
+  else if (q.remaining!=null) parts.push("осталось "+q.remaining)
+  if (q.resetAt) parts.push("сброс "+new Date(q.resetAt).toLocaleString())
+  return parts.join(" · ")
+}

package/lib/rotate.js

@@ -1,26 +1,56 @@
 const SWITCH_CODES = new Set([
-  'RATE_LIMIT',
-  'QUOTA',
-  'QUOTA_EXCEEDED',
+  "RATE_LIMIT",
+  "QUOTA",
+  "QUOTA_EXCEEDED",
 ])
 
 export function isSwitchableError(err) {
-  if (!err || typeof err !== 'object') return false
+  if (!err || typeof err !== "object") return false
   const code = err.code || (err.failure && err.failure.code)
   if (SWITCH_CODES.has(code)) return true
   const status = err.status || err.statusCode
   return status === 429
 }
 
-export function pickAccount(accounts, nowMs) {
+export function pickAccount(accounts, nowMs, opts) {
   const list = Array.isArray(accounts) ? accounts : []
   const now = Number(nowMs) || 0
-  for (const account of list) {
-    if (!account || !account.hasToken) continue
-    if (account.usagePercent != null && Number(account.usagePercent) >= 100) continue
-    if (account.cooldownUntil && Number(account.cooldownUntil) > now) continue
-    return account
+  const thrRaw = opts && opts.switchAtRemaining != null ? Number(opts.switchAtRemaining) : 0
+  const thr = Number.isFinite(thrRaw) ? thrRaw : 0
+  function isQuotaExhausted(acc) {
+    if (!thr || thr <= 0) return false
+    const q = acc.quota
+    if (!q) return false
+    if (q.resetAt && Number(q.resetAt) <= now) return false
+    if (q.remaining == null) return false
+    if (q.limit != null && q.limit > 0 && thr > 0 && thr < 1) {
+      const frac = q.remaining / q.limit
+      return frac <= thr
+    }
+    return q.remaining <= thr
   }
+  function isUsageExhausted(acc) {
+    if (acc.usagePercent == null || Number(acc.usagePercent) < 100) return false
+    const q = acc.quota
+    if (q && q.resetAt && Number(q.resetAt) <= now) return false
+    return true
+  }
+  const tiers = [[], [], []]
+  const fallback = []
+  for (const acc of list) {
+    if (!acc || !acc.hasToken) continue
+    const isCooldown = acc.cooldownUntil && Number(acc.cooldownUntil) > now
+    const exhausted = isQuotaExhausted(acc) || isUsageExhausted(acc)
+    if (isCooldown || exhausted) {
+      tiers[2].push(acc)
+      fallback.push(acc)
+      continue
+    }
+    if (!acc.quota) tiers[1].push(acc)
+    else tiers[0].push(acc)
+  }
+  for (const tier of tiers) if (tier.length) return tier[0]
+  if (fallback.length) return fallback[0]
   return null
 }
 

package/lib/stream-rotate.js

@@ -4,6 +4,7 @@ export async function* streamWithRotation({
   accounts,
   nowMs,
   cooldownMs,
+  switchAtRemaining,
   streamOnce,
   options,
   onCooldown,
@@ -12,7 +13,7 @@ export async function* streamWithRotation({
   let lastError = null
   const tried = new Set()
   while (true) {
-    const account = pickAccount(pool, nowMs())
+    const account = pickAccount(pool, nowMs(), { switchAtRemaining })
     if (!account) {
       if (lastError) throw lastError
       const err = new Error('no usable subscription account for this provider')

package/lib/subscriptions.js

@@ -0,0 +1,174 @@
+import { isProvider } from "./refs.js"
+import { pickAccount, markCooldown, isSwitchableError } from "./rotate.js"
+import { quotaSnapshot } from "./ratelimit.js"
+import { getVendor } from "./vendors/index.js"
+
+// ponytail: allowlist per provider — add path to extend without touching request logic
+export const ALLOWLIST = {
+  codex: ["/responses", "/models", "/images/generations", "/backend-api/codex/responses", "/backend-api/codex/models", "/backend-api/codex/images/generations"],
+  claude: ["/v1/messages", "/api/oauth/profile", "/api/oauth/usage", "/v1/models"],
+  grok: ["/v1/models", "/responses", "/v1/responses", "/v1/billing", "/v1/chat/completions", "/images/generations", "/v1/images/generations"],
+  antigravity: ["/v1/models", "/v1/generateContent", "/v1/streamGenerateContent", "/v1/loadCodeAssist", "/v1/fetchAvailableModels", "/v1/countTokens", "/v1/internal:loadCodeAssist"],
+}
+
+export function isAllowed(provider, path) {
+  if (!isProvider(provider)) return false
+  const list = ALLOWLIST[provider] || []
+  let p = String(path || "")
+  // strip query and hash
+  p = p.split("?")[0].split("#")[0]
+  try {
+    if (p.startsWith("http://") || p.startsWith("https://")) p = new URL(p).pathname
+  } catch {}
+  if (!p.startsWith("/")) p = "/" + p
+  for (const allowed of list) {
+    const a = allowed.split("?")[0]
+    if (p === a) return true
+    if (p.startsWith(a + "/")) return true
+    if (p.startsWith(a + "?")) return true
+  }
+  return false
+}
+
+function baseFor(provider, cfg) {
+  if (provider === "codex") return (cfg.baseUrl || "https://chatgpt.com/backend-api/codex").replace(/\/$/, "")
+  if (provider === "grok") return (cfg.baseUrl || "https://api.x.ai/v1").replace(/\/$/, "")
+  if (provider === "claude") return "https://api.anthropic.com"
+  if (provider === "antigravity") return "https://cloudcode-pa.googleapis.com"
+  return (cfg.baseUrl || "").replace(/\/$/, "")
+}
+
+function headersFor(provider, blob, cfg) {
+  const h = {}
+  if (provider === "codex" && blob.accountId) {
+    h["chatgpt-account-id"] = blob.accountId
+    h["ChatGPT-Account-ID"] = blob.accountId
+    h["originator"] = cfg.originator || "codex_cli_rs"
+  }
+  if (provider === "grok" && String(cfg.baseUrl || "").includes("grok.com")) {
+    h["X-XAI-Token-Auth"] = "xai-grok-cli"
+    h["x-grok-client-identifier"] = "grok-shell"
+    h["x-grok-client-version"] = cfg.clientVersion || "0.2.103"
+  }
+  if (provider === "antigravity" && blob.projectId) {
+    h["x-goog-user-project"] = blob.projectId
+  }
+  return h
+}
+
+export function createSubscriptionsService(deps) {
+  return {
+    async available(provider) {
+      if (provider) {
+        if (!isProvider(provider)) return false
+        const accs = await deps.listAccounts(provider)
+        return accs.some((a) => a.hasToken)
+      }
+      const providers = ["codex", "claude", "grok", "antigravity"]
+      const out = []
+      for (const p of providers) {
+        const accs = await deps.listAccounts(p)
+        if (accs.some((a) => a.hasToken)) out.push(p)
+      }
+      return out
+    },
+    async request({ provider, path, method = "GET", headers = {}, body, signal }) {
+      if (!isProvider(provider)) {
+        const err = new Error("unknown provider: " + provider)
+        err.code = "PROVIDER"
+        throw err
+      }
+      if (!isAllowed(provider, path)) {
+        const err = new Error("path not allowed for " + provider + ": " + path)
+        err.code = "FORBIDDEN"
+        throw err
+      }
+      const list = await deps.listAccounts(provider)
+      const thr = typeof deps.switchAtRemaining === "function" ? deps.switchAtRemaining() : (deps.switchAtRemaining ?? 0)
+      const cooldownMs = typeof deps.cooldownMs === "function" ? deps.cooldownMs() : (deps.cooldownMs ?? 30 * 60 * 1000)
+      // copy pool for rotation
+      const pool = list.map((a) => ({ ...a }))
+      const tried = new Set()
+      let lastError = null
+      while (true) {
+        const account = pickAccount(pool, Date.now(), { switchAtRemaining: thr })
+        if (!account) {
+          if (lastError) throw lastError
+          const err = new Error("no usable subscription account for this provider")
+          err.code = "AUTH"
+          throw err
+        }
+        if (tried.has(account.ref)) {
+          if (lastError) throw lastError
+          const err = new Error("all subscription accounts failed")
+          err.code = "RATE_LIMIT"
+          throw err
+        }
+        tried.add(account.ref)
+        try {
+          const blob = await deps.ensureFresh(provider, await deps.loadBlob(account.ref), account.ref)
+          const cfg = deps.vendorConfig(provider)
+          const base = baseFor(provider, cfg)
+          // normalize path
+          let p = String(path)
+          if (p.startsWith("http://") || p.startsWith("https://")) {
+            // full URL, use as is
+          } else {
+            if (!p.startsWith("/")) p = "/" + p
+            // for codex, path /responses should become base + /responses
+            // for claude, path /v1/messages with base https://api.anthropic.com => https://api.anthropic.com/v1/messages
+            p = base + p
+          }
+          const url = p
+          const extraHeaders = headersFor(provider, blob, cfg)
+          const fetchImpl = deps.fetchImpl || fetch
+          const res = await fetchImpl(url, {
+            method,
+            headers: {
+              Authorization: "Bearer " + blob.accessToken,
+              Accept: "application/json",
+              ...extraHeaders,
+              ...headers,
+              ...(body && typeof body === "object" && !(body instanceof Uint8Array) && !(typeof body === "string") ? { "Content-Type": "application/json" } : {}),
+            },
+            body: body && typeof body === "object" && !(body instanceof Uint8Array) && typeof body !== "string" ? JSON.stringify(body) : body,
+            signal,
+          })
+          // capture quota
+          try {
+            const snap = quotaSnapshot(provider, res.headers, null, Date.now())
+            if (snap && typeof deps.rememberQuota === "function") deps.rememberQuota(account.ref, snap)
+          } catch {}
+          if (!res.ok && res.clone) {
+            try {
+              const txt = await res.clone().text()
+              let j = null
+              try { j = JSON.parse(txt) } catch {}
+              if (j) {
+                const snap2 = quotaSnapshot(provider, res.headers, j, Date.now())
+                if (snap2 && typeof deps.rememberQuota === "function") deps.rememberQuota(account.ref, snap2)
+              }
+            } catch {}
+          }
+          if (!res.ok) {
+            const txt = await res.text().catch(() => "")
+            const err = new Error("vendor http " + res.status + (txt ? ": " + txt.slice(0, 200) : ""))
+            err.status = res.status
+            if (res.status === 429) err.code = "RATE_LIMIT"
+            else if (res.status === 402) err.code = "QUOTA"
+            else err.code = "VENDOR"
+            throw err
+          }
+          return res
+        } catch (err) {
+          lastError = err
+          if (!isSwitchableError(err)) throw err
+          const cooled = markCooldown(account, Date.now(), cooldownMs)
+          account.cooldownUntil = cooled.cooldownUntil
+          if (typeof deps.rememberCooldown === "function") deps.rememberCooldown(account.ref, account.cooldownUntil)
+          // try next account
+        }
+      }
+    },
+  }
+}

package/lib/vendors/antigravity.js

@@ -114,6 +114,18 @@ export async function refresh(cfg, blob, fetchImpl) {
   })
 }
 
+
+export async function check(blob, cfg, fetchImpl) {
+  const impl = fetchImpl || fetch
+  try {
+    const models = await fetchAvailableModels(impl, blob.accessToken, headersFor(blob.projectId || ""), cfg.models || defaults().models, id)
+    return { ok: true, raw: { models } }
+  } catch (e) {
+    // fallback to quota check
+    throw e
+  }
+}
+
 export async function listModels(blob, cfg, fetchImpl) {
   const fallback = cfg.models || defaults().models
   return fetchAvailableModels(fetchImpl || fetch, blob.accessToken, headersFor(blob.projectId || ''), fallback, id)

package/lib/vendors/claude.js

@@ -91,6 +91,15 @@ export async function listModels(blob, cfg) {
   return modelCatalog(id, cfg.models || defaults().models)
 }
 
+
+export async function check(blob, _cfg, fetchImpl) {
+  const impl = fetchImpl || fetch
+  const res = await impl(PROFILE, { headers: oauthHeaders(blob.accessToken) })
+  if (!res.ok) throw httpError(res.status, await res.text())
+  const json = await readJson(res)
+  return { ok: true, raw: json }
+}
+
 export async function usage(blob, _cfg, fetchImpl) {
   try {
     const res = await (fetchImpl || fetch)(USAGE, { headers: oauthHeaders(blob.accessToken) })

package/lib/vendors/codex.js

@@ -130,6 +130,20 @@ export async function listModels(blob, cfg, fetchImpl) {
   return catalog
 }
 
+
+export async function check(blob, cfg, fetchImpl) {
+  const base = (cfg.baseUrl || defaults().baseUrl).replace(/\/$/, "")
+  const version = cfg.clientVersion || defaults().clientVersion
+  const impl = fetchImpl || fetch
+  const res = await impl(base + "/models?client_version=" + encodeURIComponent(version), {
+    headers: identityHeaders(blob, cfg, { Accept: "application/json" }),
+  })
+  if (!res.ok) throw httpError(res.status, await res.text())
+  const json = await readJson(res)
+  // quota headers may contain limits
+  return { ok: true, raw: json }
+}
+
 export async function usage(blob, cfg, fetchImpl) {
   try {
     const res = await (fetchImpl || fetch)(USAGE, {

package/lib/vendors/grok.js

@@ -186,6 +186,15 @@ export async function listModels(blob, cfg, fetchImpl) {
   }
 }
 
+
+export async function check(blob, cfg, fetchImpl) {
+  const impl = fetchImpl || fetch
+  const res = await impl(MODELS, { headers: { Authorization: "Bearer " + blob.accessToken, Accept: "application/json" } })
+  if (!res.ok) throw httpError(res.status, await res.text())
+  const json = await readJson(res)
+  return { ok: true, raw: json }
+}
+
 export async function usage(blob, cfg, fetchImpl) {
   try {
     const res = await (fetchImpl || fetch)(BILLING, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-subscriptions",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Use ChatGPT Codex, Claude, Grok, and Antigravity subscriptions as DeepSeek Harness LLM providers via OAuth.",
   "license": "MIT",
   "type": "module",