@goodandready/dsh-subscriptions 0.4.16 → 0.4.18

package/lib/forecast.js

@@ -0,0 +1,71 @@
+// #84: predictive runway forecast from a sliding window of usage samples.
+// Port of the reference approach (WSL043 quota-forecast): track remaining
+// percent samples per window key, estimate pace with a recency-weighted
+// least-squares slope, convert to a runway estimate.
+
+const HOUR_MS = 60 * 60 * 1000
+const HISTORY_MS = 24 * HOUR_MS
+const MIN_SPAN_MS = 30 * 60 * 1000
+const MIN_CONSUMED = 1
+const MAX_SAMPLES = 192
+
+const finite = (v) => Number.isFinite(Number(v))
+
+export function observeForecast(state, key, remainingPercent, resetsAt, now) {
+  const windows = Object.assign({}, (state && state.windows) || {})
+  const pct = Math.max(0, Math.min(100, Number(remainingPercent)))
+  const reset = finite(resetsAt) ? Number(resetsAt) : null
+  const prev = windows[key]
+  const resetChanged = prev !== undefined && (
+    (prev.resetsAt === null) !== (reset === null) ||
+    (prev.resetsAt !== null && reset !== null && Math.abs(prev.resetsAt - reset) > 300)
+  )
+  const last = prev && prev.samples && prev.samples[prev.samples.length - 1]
+  const increased = last !== undefined && pct > last.pct + 0.5
+  const samples = resetChanged || increased ? [] : ((prev && prev.samples) || []).slice()
+  if (!samples.length || now > samples[samples.length - 1].at && (
+    Math.abs(pct - samples[samples.length - 1].pct) >= 0.1 || now - samples[samples.length - 1].at >= 15 * 60 * 1000
+  )) {
+    samples.push({ at: now, pct })
+  }
+  const kept = samples.filter((s) => s.at >= now - HISTORY_MS).slice(-MAX_SAMPLES)
+  windows[key] = { resetsAt: reset, samples: kept }
+  return { windows }
+}
+
+export function estimateForecast(state, key, remainingPercent, resetsAt, now) {
+  if (!finite(remainingPercent)) return { status: 'idle' }
+  const rec = state && state.windows && state.windows[key]
+  if (!rec) return { status: 'calibrating' }
+  const reset = finite(resetsAt) ? Number(resetsAt) : null
+  if ((rec.resetsAt === null) !== (reset === null) ||
+      (rec.resetsAt !== null && reset !== null && Math.abs(rec.resetsAt - reset) > 300)) return { status: 'calibrating' }
+  const samples = rec.samples.filter((s) => s.at >= now - HISTORY_MS)
+  if (samples.length < 3) return { status: 'calibrating', sampleCount: samples.length }
+  const first = samples[0]
+  const last = samples[samples.length - 1]
+  const spanMs = last.at - first.at
+  const consumed = Math.max(0, first.pct - last.pct)
+  if (spanMs < MIN_SPAN_MS || consumed < MIN_CONSUMED) return { status: 'calibrating', sampleCount: samples.length }
+  const t0 = first.at
+  let sw = 0, sx = 0, sy = 0, sxx = 0, sxy = 0
+  for (const s of samples) {
+    const x = (s.at - t0) / HOUR_MS
+    const y = first.pct - s.pct
+    const w = Math.exp((s.at - last.at) / (6 * HOUR_MS))
+    sw += w; sx += w * x; sy += w * y; sxx += w * x * x; sxy += w * x * y
+  }
+  const den = sw * sxx - sx * sx
+  const pace = den > 0 ? (sw * sxy - sx * sy) / den : 0
+  if (!Number.isFinite(pace) || pace < 0.02) return { status: 'idle', pacePerHour: 0 }
+  const runwayHours = Math.max(0, Math.min(100, Number(remainingPercent))) / pace
+  const resetSec = reset === null ? null : Math.max(0, Math.round((reset - now) / 1000))
+  return {
+    status: 'ready',
+    pacePerHour: pace,
+    runwayHours,
+    runwaySeconds: Math.round(runwayHours * 3600),
+    survivesReset: resetSec !== null && runwayHours * 3600 >= resetSec,
+    sampleCount: samples.length,
+  }
+}

package/lib/index.js

@@ -15,6 +15,8 @@ import { encryptWithPassphrase, decryptWithPassphrase } from './crypto.js'
 import { quotaSnapshot } from './ratelimit.js'
 import { createAccountStore, normalizeSlots, vendorConfig } from './accounts.js'
 import { startLoopback } from './loopback.js'
+import { OllamaAdapter, ollamaAlive, ollamaModels, ollamaBase } from './ollama.js'
+import { createResetCreditService } from './reset-credits.js'
 import { maskEmail, maskLabel, maskText } from './mask.js'
 import { proxyFetch, pickFetch } from './proxy.js'
 import { HistoryStore } from './history.js'
@@ -71,7 +73,21 @@ export const Config = z.object({
     .description('When on, redirect_uri is this Web UI origin + /dsh-subscriptions/oauth/callback. When off, the vendor CLI registered redirect is used and you paste the redirected URL.'),
   autoLoopback: z.boolean().default(true)
     .description('#89 When on and the vendor redirect_uri is a loopback address (codex :1455, grok :56121), a temporary local server catches the OAuth callback automatically - no paste needed. Paste fallback stays available.'),
+  ollamaBaseUrl: z.string().default('http://127.0.0.1:11434')
+    .description('#91 Local Ollama base URL. Served as the ollama provider in the native model picker when reachable.'),
+  ollamaFallback: z.boolean().default(true)
+    .description('#91 When every account of a provider is exhausted, continue the chat on local Ollama instead of failing.'),
+  ollamaFallbackModel: z.string().default('')
+    .description('#91 Ollama model used for the fallback (for example qwen2.5-coder). Empty = first model from /api/tags.'),
+  hideDeprecatedModels: z.boolean().default(false)
+    .description('#94 Hide test/preview/beta/legacy model ids from the native model picker.'),
   codexClientId: z.string().default(''),
+  codexVerbosity: z.string().default('')
+    .description('#93 Response verbosity for Codex reasoning models: low, medium or high. Empty = protocol default.'),
+  codexFastMode: z.boolean().default(false)
+    .description('#92 Fast Mode for Codex: sends service_tier priority (1.5x speed billing tier) with every request.'),
+  composerQuota: z.string().default('off')
+    .description('#84 Composer quota indicator mode: off, percent, bar or forecast (predictive runway from a sliding window).'),
   codexRedirectUri: z.string().default(''),
   codexBaseUrl: z.string().default(''),
   claudeClientId: z.string().default(''),
@@ -165,6 +181,51 @@ export function apply(ctx, config) {
   const history = new HistoryStore()
   const recordHistory = (entry) => history.add(entry)
 
+  // #85: host-only reset credit service for Codex accounts.
+  const resetCredits = createResetCreditService({ loadBlob: (ref) => store.loadBlob(ref) })
+  function refForSlot(provider, index) {
+    const slot = normalizeSlots(live().slots).find((s) => s.provider === provider && s.index === index)
+    return slot ? slot.ref : null
+  }
+
+  // #91: local Ollama - native provider + seamless fallback when the whole
+  // pool is exhausted and nothing has been streamed yet.
+  const ollamaAdapter = new OllamaAdapter({
+    baseUrl: () => ollamaBase(live()),
+    fallbackModel: () => live().ollamaFallbackModel || '',
+  })
+  let ollamaHandle
+  async function syncOllama() {
+    const cfg = live()
+    const alive = !!cfg.ollamaFallback && await ollamaAlive(ollamaBase(cfg), fetch)
+    if (alive && !ollamaHandle) {
+      try { ollamaHandle = ctx.llm.registerAdapter(['ollama'], ollamaAdapter) } catch { /* already registered elsewhere */ }
+    } else if (!alive && ollamaHandle) {
+      try { ollamaHandle() } catch { /* already gone */ }
+      ollamaHandle = undefined
+    }
+  }
+  async function* ollamaFallbackStream({ options, provider, err }) {
+    const cfg = live()
+    const models = await ollamaModels(ollamaBase(cfg), fetch).catch(() => [])
+    if (!cfg.ollamaFallback || !models.length) throw err
+    const model = cfg.ollamaFallbackModel || models[0].id
+    try { ctx.emit && ctx.emit('subscriptions.ollama-fallback', { provider, model, reason: err && err.code || 'EXHAUSTED' }) } catch {}
+    try { ctx.log && ctx.log.warn && ctx.log.warn(`[dsh-subscriptions] ${provider}: все аккаунты исчерпаны (${err && err.code || 'EXHAUSTED'}), откат на ollama/${model}`) } catch {}
+    try {
+      recordHistory({
+        provider: 'ollama',
+        ref: 'OLLAMA_FALLBACK',
+        model,
+        path: '/v1/chat/completions',
+        method: 'POST',
+        status: 200,
+        kind: 'fallback',
+      })
+    } catch {}
+    yield* ollamaAdapter.stream({ ...options, provider: 'ollama', model })
+  }
+
   const subscriptions = createSubscriptionsService({
     listAccounts: (provider) => store.listAccounts(provider),
     loadBlob: (ref) => store.loadBlob(ref),
@@ -172,7 +233,7 @@ export function apply(ctx, config) {
     vendorConfig: (provider) => vendorConfig(provider, live()),
     cooldownMs: () => live().cooldownMs,
     switchAtRemaining: () => live().switchAtRemaining,
-    rememberCooldown: (ref, until) => store.rememberCooldown(ref, until),
+    rememberCooldown: (ref, until, families) => store.rememberCooldown(ref, until, families),
     recordSuccess: (ref) => store.recordSuccess(ref),
     getHealth: (ref) => store.getHealth(ref),
     recordSwitch: (ref) => store.recordSwitch(ref),
@@ -185,6 +246,8 @@ export function apply(ctx, config) {
     recordHistory,
     fetchImpl: fetch,
     fetchForRef,
+    ollamaFallback: ollamaFallbackStream,
+    hideDeprecatedModels: () => !!live().hideDeprecatedModels,
   })
 
   // Служба генерации картинок на подписке.
@@ -235,7 +298,7 @@ export function apply(ctx, config) {
     vendorConfig: (provider) => vendorConfig(provider, live()),
     cooldownMs: () => live().cooldownMs,
     switchAtRemaining: () => live().switchAtRemaining,
-    rememberCooldown: (ref, until) => store.rememberCooldown(ref, until),
+    rememberCooldown: (ref, until, families) => store.rememberCooldown(ref, until, families),
     rememberQuota: (ref, snap) => store.rememberQuota(ref, snap),
     getQuota: (ref) => store.getQuota(ref),
     refreshUsage: (provider) => store.refreshUsage(provider),
@@ -470,6 +533,7 @@ export function apply(ctx, config) {
 
   ctx.effect(() => {
     syncAdapter().catch(() => { /* first paint */ })
+    syncOllama().catch(() => { /* first paint */ })
     // #75: eager refresh usage на старте, чтобы windows (5h/7d) появились в blob сразу
     // и активная подписка в чипе сразу показывала 5h/7d/..., а не ждала probeInterval.
     const eager = async () => {
@@ -560,7 +624,7 @@ export function apply(ctx, config) {
       await tick()
     }
     wrapped().catch(() => {})
-    const timer = setInterval(() => { wrapped().catch(() => {}) }, 60 * 1000)
+    const timer = setInterval(() => { wrapped().catch(() => {}); syncOllama().catch(() => {}) }, 60 * 1000)
     return () => clearInterval(timer)
   }, 'dsh-subscriptions: probe loop')
 
@@ -676,11 +740,86 @@ export function apply(ctx, config) {
         expiresAt: expires,
         labels,
         expiryNotifyDays: live().expiryNotifyDays,
+        fastMode: !!live().codexFastMode,
+        composerQuota: String(live().composerQuota || 'off'),
         active,
       })
     },
   }), 'dsh-subscriptions: /status')
 
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/reset-credits',
+    handler: async (req, res) => {
+      if (req.method !== 'GET') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } })
+        return
+      }
+      const q = queryOf(req)
+      const ref = refForSlot(String(q.provider || ''), Number(q.index) || 1)
+      if (!ref) { writeJson(res, 404, { ok: false, error: { code: 'slot', message: 'slot not found' } }); return }
+      try {
+        writeJson(res, 200, { ok: true, ...(await resetCredits.inspect(ref)) })
+      } catch (e) {
+        writeJson(res, 200, { ok: false, error: { code: 'reset', message: String(e && e.message || e) } })
+      }
+    },
+  }), 'dsh-subscriptions: /reset-credits')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/reset-credits/prepare',
+    handler: async (req, res) => {
+      if (req.method !== 'POST') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      let payload
+      try { payload = JSON.parse((await readBody(req, 4096)).toString('utf8') || '{}') } catch {
+        writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
+        return
+      }
+      const ref = refForSlot(String(payload.provider || ''), Number(payload.index) || 1)
+      if (!ref) { writeJson(res, 404, { ok: false, error: { code: 'slot', message: 'slot not found' } }); return }
+      try {
+        writeJson(res, 200, { ok: true, ...(await resetCredits.prepare(ref)) })
+      } catch (e) {
+        writeJson(res, 200, { ok: false, error: { code: 'reset', message: String(e && e.message || e) } })
+      }
+    },
+  }), 'dsh-subscriptions: /reset-credits/prepare')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/reset-credits/consume',
+    handler: async (req, res) => {
+      if (req.method !== 'POST') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      let payload
+      try { payload = JSON.parse((await readBody(req, 4096)).toString('utf8') || '{}') } catch {
+        writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
+        return
+      }
+      try {
+        const result = await resetCredits.consume({ challengeId: payload.challengeId, acknowledged: payload.acknowledged })
+        writeJson(res, 200, { ok: true, result })
+        refreshModels().catch(() => {})
+      } catch (e) {
+        writeJson(res, 200, { ok: false, error: { code: 'reset', message: String(e && e.message || e) } })
+      }
+    },
+  }), 'dsh-subscriptions: /reset-credits/consume')
+
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
     path: '/dsh-subscriptions/diagnostics',

package/lib/messages.js

@@ -65,7 +65,7 @@ export function openaiTools(options) {
   }))
 }
 
-export function codexResponsesBody(options, fallbackInstructions) {
+export function codexResponsesBody(options, fallbackInstructions, vendorCfg) {
   const systemParts = []
   if (options.system) systemParts.push(options.system)
   const input = []
@@ -134,6 +134,13 @@ export function codexResponsesBody(options, fallbackInstructions) {
     instructions,
     input,
     ...(responsesTools && responsesTools.length ? { tools: responsesTools } : {}),
+    // #93: reasoning effort chosen in the native picker flows to the protocol.
+    ...(options.reasoningEffort ? { reasoning: { effort: String(options.reasoningEffort) } } : {}),
+    // #93: verbosity comes from the codexVerbosity setting (low/medium/high).
+    ...(vendorCfg && /^(low|medium|high)$/.test(String(vendorCfg.verbosity || ''))
+      ? { text: { verbosity: String(vendorCfg.verbosity) } } : {}),
+    // #92: Fast Mode = 1.5x speed billing tier on the Codex backend.
+    ...(vendorCfg && vendorCfg.fastMode ? { service_tier: 'priority' } : {}),
     ...(options.maxTokens != null ? { max_output_tokens: options.maxTokens } : {}),
     ...(options.temperature != null ? { temperature: options.temperature } : {}),
   }

package/lib/ollama.js

@@ -0,0 +1,70 @@
+import { LlmAdapter, LlmError, attributionHeaders } from '@deepseek-ai/dsh-llm'
+import { openaiMessages, openaiTools } from './messages.js'
+import { openaiChatStream } from './wire.js'
+
+// #91: local Ollama gateway - a $0 emergency provider and seamless quota
+// fallback. Speaks the OpenAI-compatible subset Ollama serves at /v1.
+
+export function ollamaBase(cfg) {
+  return String(cfg.ollamaBaseUrl || 'http://127.0.0.1:11434').replace(/\/$/, '')
+}
+
+export async function ollamaAlive(baseUrl, fetchImpl, timeoutMs = 2000) {
+  try {
+    const res = await fetchImpl(baseUrl + '/api/tags', { signal: AbortSignal.timeout(timeoutMs) })
+    return !!res && res.ok
+  } catch { return false }
+}
+
+export async function ollamaModels(baseUrl, fetchImpl) {
+  const res = await fetchImpl(baseUrl + '/api/tags', { signal: AbortSignal.timeout(3000) })
+  if (!res || !res.ok) throw new LlmError('ollama /api/tags http ' + (res && res.status), 'VENDOR', { status: res && res.status })
+  const j = await res.json()
+  return (Array.isArray(j.models) ? j.models : []).map((m) => ({
+    id: m.name,
+    name: m.name,
+    ...(m.details && m.details.parameter_size ? { description: m.details.parameter_size } : {}),
+  }))
+}
+
+export class OllamaAdapter extends LlmAdapter {
+  constructor(deps) {
+    super()
+    this.deps = deps
+  }
+
+  providerInfo(provider) {
+    return { id: provider, name: 'Ollama (local)' }
+  }
+
+  providerRetryPolicy(_provider) {
+    return undefined
+  }
+
+  async listModels(provider) {
+    return ollamaModels(this.deps.baseUrl(), this.deps.fetchImpl || fetch)
+  }
+
+  async resolveModel(provider, model, _signal) {
+    return { provider, id: model, name: model }
+  }
+
+  async *stream(options) {
+    const base = this.deps.baseUrl()
+    const model = options.model || this.deps.fallbackModel() || ''
+    const body = { model, messages: openaiMessages(options), stream: true }
+    const tools = openaiTools(options)
+    if (tools) body.tools = tools
+    const res = await (this.deps.fetchImpl || fetch)(base + '/v1/chat/completions', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...attributionHeaders() },
+      body: JSON.stringify(body),
+      signal: options.signal,
+    })
+    if (!res || !res.ok) {
+      const txt = res && res.text ? await res.text().catch(() => '') : ''
+      throw new LlmError('ollama http ' + (res && res.status) + (txt ? ': ' + txt.slice(0, 200) : ''), 'VENDOR', { status: res && res.status })
+    }
+    yield* openaiChatStream(res.body)
+  }
+}

package/lib/reset-credits.js

@@ -0,0 +1,193 @@
+import { randomUUID } from 'node:crypto'
+
+// #85: safe Codex quota reset credits. Host-only: the browser never sees
+// account ids, bearer tokens, credit ids or idempotency keys. A single-flight
+// challenge carries a 5s cooldown plus an explicit acknowledgement, so a
+// double click or concurrent call can never consume two credits.
+
+const RESET_URL = 'https://chatgpt.com/backend-api/wham/rate-limit-reset-credits'
+const CONSUME_URL = RESET_URL + '/consume'
+const CONFIRM_DELAY_MS = 5000
+const CHALLENGE_TTL_MS = 60000
+const TIMEOUT_MS = 15000
+const UNCERTAIN = 'reset result is uncertain; re-run the confirmation to check the same request'
+
+function record(v) {
+  return v !== null && typeof v === 'object' && !Array.isArray(v)
+}
+
+function expirationOf(v) {
+  if (v == null) return undefined
+  if (Number.isSafeInteger(v) && v > 0) return v * 1000
+  if (typeof v === 'string' && v.length > 0 && v.length <= 64) {
+    const p = Date.parse(v)
+    if (Number.isFinite(p) && p > 0) return p
+  }
+  throw new Error('malformed reset expiry')
+}
+
+export function parseDetails(raw, now) {
+  if (!record(raw) || !Number.isSafeInteger(raw.available_count) || raw.available_count < 0 || !Array.isArray(raw.credits)) {
+    throw new Error('malformed reset details')
+  }
+  if (raw.available_count === 0) throw new Error('no reset available')
+  const nowMs = Number(now) || 0
+  const available = raw.credits
+    .filter((c) => record(c) && typeof c.id === 'string' && c.id.length > 0 && c.id.length <= 256 && String(c.status || '').toLowerCase() === 'available')
+    .map((c) => ({ c, expiresAt: expirationOf(c.expires_at) }))
+    .filter((row) => row.expiresAt === undefined || row.expiresAt > nowMs)
+    .sort((a, b) => (a.expiresAt === undefined ? Number.MAX_SAFE_INTEGER : a.expiresAt) - (b.expiresAt === undefined ? Number.MAX_SAFE_INTEGER : b.expiresAt))
+  if (!available.length) throw new Error('no usable reset credit')
+  const first = available[0]
+  return {
+    availableCount: raw.available_count,
+    creditId: first.c.id,
+    title: typeof first.c.title === 'string' ? first.c.title.slice(0, 240) : undefined,
+    description: typeof first.c.description === 'string' ? first.c.description.slice(0, 240) : undefined,
+    creditExpiresAt: first.expiresAt,
+  }
+}
+
+export function parseConsumeResult(raw) {
+  if (!record(raw) || !['reset', 'nothing_to_reset', 'no_credit', 'already_redeemed'].includes(raw.code)) {
+    throw new Error('unreadable reset response')
+  }
+  const windowsReset = Array.isArray(raw.windows_reset)
+    ? raw.windows_reset.filter((x) => typeof x === 'string').slice(0, 16)
+    : []
+  const count = Number.isSafeInteger(raw.windows_reset) && raw.windows_reset >= 0 && raw.windows_reset <= 16
+    ? raw.windows_reset
+    : undefined
+  return { code: raw.code, windowsReset, ...(count === undefined ? {} : { windowsResetCount: count }) }
+}
+
+export function createResetCreditService({ loadBlob, fetchImpl, now = Date.now, randomId = randomUUID }) {
+  const challenges = new Map()
+
+  async function readDetails(ref) {
+    const blob = await loadBlob(ref)
+    const access = blob && blob.accessToken
+    const accountId = blob && blob.accountId
+    if (!access || !accountId) throw new Error('codex account is not signed in')
+    const res = await (fetchImpl || fetch)(RESET_URL, {
+      method: 'GET',
+      headers: {
+        Authorization: 'Bearer ' + access,
+        'chatgpt-account-id': accountId,
+        Accept: 'application/json',
+        'cache-control': 'no-store',
+      },
+      signal: AbortSignal.timeout(TIMEOUT_MS),
+    })
+    if (!res.ok) {
+      throw new Error(res.status === 401 || res.status === 403
+        ? 'codex sign-in needs renewal'
+        : 'reset request failed (HTTP ' + res.status + ')')
+    }
+    let raw
+    try { raw = await res.json() } catch { throw new Error('unreadable reset details') }
+    return { accountId, details: parseDetails(raw, now()) }
+  }
+
+  return {
+    async inspect(ref) {
+      const { details } = await readDetails(ref)
+      return {
+        availableCount: details.availableCount,
+        ...(details.creditExpiresAt === undefined ? {} : { nextExpiresAt: details.creditExpiresAt }),
+      }
+    },
+
+    async prepare(ref) {
+      const { accountId, details } = await readDetails(ref)
+      const preparedAt = now()
+      const readyAt = preparedAt + CONFIRM_DELAY_MS
+      const expiresAt = Math.min(preparedAt + CHALLENGE_TTL_MS, details.creditExpiresAt === undefined ? Number.MAX_SAFE_INTEGER : details.creditExpiresAt)
+      if (expiresAt <= readyAt) throw new Error('the available reset expires too soon')
+      const challengeId = randomId()
+      challenges.set(challengeId, {
+        state: 'prepared',
+        ref,
+        accountId,
+        creditId: details.creditId,
+        redeemRequestId: randomId(),
+        readyAt,
+        expiresAt,
+        availableCount: details.availableCount,
+        creditExpiresAt: details.creditExpiresAt,
+        title: details.title,
+        description: details.description,
+        uncertain: false,
+      })
+      return {
+        challengeId,
+        availableCount: details.availableCount,
+        readyAt,
+        expiresAt,
+        ...(details.creditExpiresAt === undefined ? {} : { creditExpiresAt: details.creditExpiresAt }),
+        ...(details.title ? { title: details.title } : {}),
+        ...(details.description ? { description: details.description } : {}),
+      }
+    },
+
+    async consume({ challengeId, acknowledged } = {}) {
+      const challenge = typeof challengeId === 'string' ? challenges.get(challengeId) : undefined
+      if (!challenge) throw new Error('this reset confirmation is no longer valid')
+      if (challenge.state === 'pending') throw new Error('this reset is already in progress')
+      if (now() < challenge.readyAt) throw new Error('wait before confirming this reset')
+      if (now() > challenge.expiresAt) {
+        challenges.delete(challengeId)
+        throw new Error('this reset confirmation is no longer valid')
+      }
+      if (acknowledged !== true) throw new Error('acknowledge that one reset attempt will be consumed')
+      // Synchronous gate before the first await: rapid clicks and concurrent
+      // calls can never create more than one provider POST.
+      challenge.state = 'pending'
+      let retryable = challenge.uncertain === true
+      try {
+        const blob = await loadBlob(challenge.ref)
+        const access = blob && blob.accessToken
+        const accountId = blob && blob.accountId
+        if (!access || !accountId) { retryable = false; throw new Error('codex account is not signed in') }
+        if (accountId !== challenge.accountId) { retryable = false; throw new Error('the signed-in account changed') }
+        let res
+        try {
+          res = await (fetchImpl || fetch)(CONSUME_URL, {
+            method: 'POST',
+            headers: {
+              Authorization: 'Bearer ' + access,
+              'chatgpt-account-id': accountId,
+              Accept: 'application/json',
+              'content-type': 'application/json',
+              'cache-control': 'no-store',
+            },
+            body: JSON.stringify({
+              redeem_request_id: challenge.redeemRequestId,
+              credit_id: challenge.creditId,
+            }),
+            signal: AbortSignal.timeout(TIMEOUT_MS),
+          })
+        } catch { retryable = true; throw new Error(UNCERTAIN) }
+        if (!res.ok) {
+          if (res.status >= 500) { retryable = true; throw new Error(UNCERTAIN) }
+          throw new Error(res.status === 401 || res.status === 403
+            ? 'codex sign-in needs renewal'
+            : 'reset request failed (HTTP ' + res.status + ')')
+        }
+        let raw
+        try { raw = await res.json() } catch { retryable = true; throw new Error(UNCERTAIN) }
+        let result
+        try { result = parseConsumeResult(raw) } catch { retryable = true; throw new Error(UNCERTAIN) }
+        retryable = false
+        return result
+      } finally {
+        if (retryable && now() <= challenge.expiresAt) {
+          challenge.state = 'prepared'
+          challenge.uncertain = true
+        } else {
+          challenges.delete(challengeId)
+        }
+      }
+    },
+  }
+}

package/lib/rotate.js

@@ -12,6 +12,25 @@ export function isSwitchableError(err) {
   return status === 429
 }
 
+// #87: family classification. Cooldowns are scoped to the model family that
+// hit the limit, so a reasoning 429 does not block standard models.
+export function modelFamily(provider, model) {
+  const id = String(model || '')
+  if (provider === 'claude') return /thinking/i.test(id) ? 'reasoning' : 'standard'
+  if (provider === 'grok') return /reasoning/i.test(id) ? 'reasoning' : 'standard'
+  if (provider === 'codex') return 'reasoning'
+  return 'standard'
+}
+
+// Legacy cooldowns (no family list) block everything; scoped ones block only
+// their own family. An unknown family never blocks a differently-scoped cooldown.
+export function cooldownBlocks(acc, family) {
+  const fams = acc && acc.cooldownFamilies
+  if (!Array.isArray(fams) || !fams.length) return true
+  if (!family) return true
+  return fams.includes(family)
+}
+
 export function pickAccount(accounts, nowMs, opts) {
   const list = Array.isArray(accounts) ? accounts : []
   const now = Number(nowMs) || 0
@@ -47,7 +66,7 @@ export function pickAccount(accounts, nowMs, opts) {
   const fallback = []
   for (const acc of list) {
     if (!acc || !acc.hasToken) continue
-    const isCooldown = acc.cooldownUntil && Number(acc.cooldownUntil) > now
+    const isCooldown = acc.cooldownUntil && Number(acc.cooldownUntil) > now && cooldownBlocks(acc, opts && opts.family)
     const exhausted = isQuotaExhausted(acc) || isUsageExhausted(acc)
     if (isCooldown || exhausted) {
       tiers[2].push(acc)
@@ -68,8 +87,14 @@ export function pickAccount(accounts, nowMs, opts) {
   return null
 }
 
-export function markCooldown(account, nowMs, cooldownMs) {
+export function markCooldown(account, nowMs, cooldownMs, family) {
   const wait = Number(cooldownMs)
   const ms = Number.isFinite(wait) && wait > 0 ? wait : 30 * 60 * 1000
-  return { ...account, cooldownUntil: (Number(nowMs) || 0) + ms }
+  const prev = Array.isArray(account.cooldownFamilies) ? account.cooldownFamilies.slice() : []
+  const fams = family ? (prev.includes(family) ? prev : prev.concat(family)) : prev
+  return {
+    ...account,
+    cooldownUntil: (Number(nowMs) || 0) + ms,
+    ...(fams.length ? { cooldownFamilies: fams } : {}),
+  }
 }

package/lib/stream-rotate.js

@@ -1,4 +1,4 @@
-import { pickAccount, markCooldown, isSwitchableError } from './rotate.js'
+import { pickAccount, markCooldown, isSwitchableError, modelFamily } from './rotate.js'
 
 export async function* streamWithRotation({
   accounts,
@@ -13,7 +13,7 @@ export async function* streamWithRotation({
   let lastError = null
   const tried = new Set()
   while (true) {
-    const account = pickAccount(pool, nowMs(), { switchAtRemaining })
+    const account = pickAccount(pool, nowMs(), { switchAtRemaining, family: modelFamily(options && options.provider, options && options.model) })
     if (!account) {
       if (lastError) throw lastError
       const err = new Error('no usable subscription account for this provider')
@@ -33,8 +33,9 @@ export async function* streamWithRotation({
     } catch (err) {
       lastError = err
       if (!isSwitchableError(err)) throw err
-      const cooled = markCooldown(account, nowMs(), cooldownMs)
+      const cooled = markCooldown(account, nowMs(), cooldownMs, modelFamily(options && options.provider, options && options.model))
       account.cooldownUntil = cooled.cooldownUntil
+      if (cooled.cooldownFamilies) account.cooldownFamilies = cooled.cooldownFamilies
       if (onCooldown) onCooldown(account)
     }
   }