@goodandready/dsh-subscriptions 0.7.31 → 0.7.33

package/lib/account-reliability.js

@@ -0,0 +1,68 @@
+function text(value) {
+  return value == null ? '' : String(value).trim()
+}
+
+/**
+ * #827: decide whether a stored credential is usable without exposing it.
+ * Empty access/refresh tokens and non-finite expiry are treated as corrupt.
+ */
+export function credentialState(blob) {
+  if (!blob || typeof blob !== 'object') return { usable: false, reason: 'invalid_blob' }
+  const accessToken = text(blob.accessToken)
+  const refreshToken = text(blob.refreshToken)
+  if (!accessToken && !refreshToken && !text(blob.apiKey)) {
+    return { usable: false, reason: 'empty_credentials' }
+  }
+  if (blob.expiresAt != null && blob.expiresAt !== '' && !Number.isFinite(Number(blob.expiresAt))) {
+    return { usable: false, reason: 'invalid_expiry' }
+  }
+  return { usable: true, reason: null }
+}
+
+/**
+ * #831: stable provider identity used for duplicate detection. Unknown
+ * identities return null and must never be merged automatically.
+ */
+export function accountIdentityKey(provider, blob) {
+  if (!blob || typeof blob !== 'object') return null
+  const id = text(blob.email || blob.login || blob.accountId || blob.userId)
+  if (!id) return null
+  return `${text(provider).toLowerCase()}:${id.toLowerCase()}`
+}
+
+/**
+ * #818: aliases are display-only. Resolve either a stable ref or a legacy
+ * label within one provider back to the stable credential ref.
+ */
+export function resolveAccountRef(slots, provider, value) {
+  const wanted = text(value)
+  if (!wanted) return null
+  const list = (Array.isArray(slots) ? slots : []).filter((slot) => slot && slot.provider === provider)
+  const byIndex = Number(wanted)
+  if (Number.isInteger(byIndex) && byIndex > 0) {
+    return list.find((slot) => Number(slot.index) === byIndex)?.ref || null
+  }
+  return list.find((slot) => slot.ref === wanted || text(slot.label) === wanted)?.ref || null
+}
+
+/**
+ * #806: a delayed refresh may only write when its credential lineage is
+ * still current. A newer save/revoke bumps the version.
+ */
+export function refreshIsCurrent(currentVersion, expectedVersion) {
+  return Number(currentVersion) === Number(expectedVersion)
+}
+
+/**
+ * #833: deterministic host-env vs plugin-proxy precedence.
+ * @param {{ hostProxy?: string, pluginProxy?: string, prefer?: 'host' | 'plugin' }} [options]
+ */
+export function proxyPrecedence(options = {}) {
+  const prefer = options.prefer || 'host'
+  const host = text(options.hostProxy)
+  const plugin = text(options.pluginProxy)
+  if (host && plugin && prefer === 'plugin') return { proxy: plugin, source: 'plugin', conflict: true }
+  if (host) return { proxy: host, source: 'host', conflict: Boolean(plugin) }
+  if (plugin) return { proxy: plugin, source: 'plugin', conflict: false }
+  return { proxy: '', source: 'none', conflict: false }
+}

package/lib/accounts-view.js

@@ -169,6 +169,8 @@ export async function createAccountsView({ live, store, fetch, pmL, pmE, concurr
       poolEnabled: slot.poolEnabled !== false,
       isDefault: !!slot.isDefault,
       ...(Array.isArray(slot.poolModels) ? { poolModels: slot.poolModels } : {}),
+      credentialError: info.credentialError || null,
+      duplicateOf: info.duplicateOf || null,
       capabilities,
       billing,
       renewsAt: billing.renewsAt,

package/lib/accounts.js

@@ -46,6 +46,7 @@ import { credentialRef } from '@deepseek-ai/dsh-credentials'
 import { oauthRef, isProvider } from './refs.js'
 import { parseBlob, serializeBlob } from './blob.js'
 import { encryptWithPassphrase, decryptWithPassphrase } from './crypto.js'
+import { accountIdentityKey, credentialState } from './account-reliability.js'
 import { recordSwitch, recordExhaust, recordBroken, computeHealthScore, healthBadge } from './health.js'
 import { executeWithRetry } from './backoff.js'
 import { getVendor } from './vendors/index.js'
@@ -308,6 +309,26 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
     if (base.configured) {
       try {
         const blob = parseBlob(await resolveRaw(ref))
+        const state = credentialState(blob)
+        if (!state.usable) {
+          base.configured = false
+          base.credentialError = state.reason
+          base.label = blob.label || blob.email || ''
+          return {
+            ...base,
+            cooldownUntil: 0,
+            quarantineUntil: 0,
+            cooldownFamilies: null,
+            cooldownModels: null,
+            quota: null,
+            isRevoked: false,
+            authWarning: '',
+            validationUrl: '',
+            validationMessage: '',
+            accountNotice: '',
+            paidTierName: '',
+          }
+        }
         base.label = blob.label || blob.email || ''
         base.email = blob.email || ''
         base.plan = blob.plan || blob.paidTierName || ''
@@ -367,6 +388,7 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
       latencyGrade: pings.get(ref)?.latencyGrade ?? null,
       lastDoctorVerdict: doctorVerdicts.get(ref) || null,
       availableModels: dynamicModels.get(ref)?.models || null,
+      credentialError: base.credentialError || null,
     }
   }
 
@@ -374,8 +396,12 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
     const curConfig = getConfig()
     const slots = normalizeSlots(curConfig.slots).filter((s) => s.provider === provider)
     const out = []
+    const identities = new Map()
     for (const slot of slots) {
       const info = await describeRef(slot.ref, curConfig)
+      const identity = accountIdentityKey(provider, { email: info.email, accountId: info.accountId })
+      const duplicateOf = identity ? (identities.get(identity) || null) : null
+      if (identity && !duplicateOf) identities.set(identity, slot.ref)
       const q = quarantines.get(slot.ref)
       out.push({
         ref: slot.ref,
@@ -400,6 +426,8 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
         poolEnabled: slot.poolEnabled !== false,
         isDefault: !!slot.isDefault,
         ...(Array.isArray(slot.poolModels) ? { poolModels: slot.poolModels } : {}),
+        credentialError: info.credentialError || null,
+        duplicateOf,
       })
     }
     return out

package/lib/index.js

@@ -18,6 +18,7 @@ import { createSubscriptionsService } from './subscriptions.js'
 import { registerSubscriptionTools } from './native-tools.js'
 import { detectConflicts, readProfilePluginNames, setActiveConflicts } from './coexistence.js'
 import { createAccountStore, defaultAccountRef, normalizeSlots, vendorConfig } from './accounts.js'
+import { resolveAccountRef } from './account-reliability.js'
 import { OllamaAdapter, ollamaAlive, ollamaModels, ollamaBase } from './ollama.js'
 import { createResetCreditService } from './reset-credits.js'
 import { maskEmail, maskLabel } from './mask.js'
@@ -276,9 +277,8 @@ export function apply(ctx, rawConfig) {
 
   // #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
+  function refForSlot(provider, indexOrAlias) {
+    return resolveAccountRef(normalizeSlots(live().slots), provider, indexOrAlias)
   }
 
   function stripLegacySlots(slots) {

package/lib/rotate.js

@@ -1,6 +1,7 @@
 import { computePacingRisk, calculateBurnRatePerHour, calculateBurnUrgency } from "./forecast.js"
 import { isQuarantined } from './quarantine.js'
 import { getPinnedAccountRef, pinSession, touchSessionPin, unpinSession, isCacheAwareProvider } from './session-pin.js'
+import { accountCatalogHasModel, proactiveQuotaDecision } from './routing-reliability.js'
 
 const SWITCH_CODES = new Set([
   'RATE_LIMIT',
@@ -159,7 +160,9 @@ export function pickAccountWithTrace(accounts, nowMs, opts) {
     const pinnedRef = getPinnedAccountRef(targetSession, now)
     if (pinnedRef) {
       const pinned = list.find((a) => (a.ref || a.id) === pinnedRef)
-      const pinnedBlock = pinned ? poolBlockReason(pinned, opts) : null
+      const pinnedBlock = pinned
+        ? (poolBlockReason(pinned, opts) || (!accountCatalogHasModel(pinned, opts && opts.model) ? 'model_not_in_account_catalog' : null))
+        : null
       if (pinned && pinnedBlock) {
         unpinSession(targetSession, pinnedBlock)
         evaluations.push({
@@ -248,6 +251,17 @@ export function pickAccountWithTrace(accounts, nowMs, opts) {
       evaluations.push({ ref, eligible: false, tier: null, reason: blockedByPool })
       continue
     }
+    if (!accountCatalogHasModel(acc, opts && opts.model)) {
+      evaluations.push({ ref, eligible: false, tier: null, reason: 'model_not_in_account_catalog', model: opts && opts.model })
+      continue
+    }
+    if (opts && opts.proactiveGuard === true) {
+      const proactive = proactiveQuotaDecision(acc.quota, now, opts.proactiveMinRemaining)
+      if (proactive.block) {
+        evaluations.push({ ref, eligible: false, tier: null, reason: proactive.reason, until: proactive.until })
+        continue
+      }
+    }
 
     if (!opts || opts.autoPacing !== false) {
       if (acc.pacingRisk === undefined) {

package/lib/routing-reliability.js

@@ -0,0 +1,71 @@
+import { createHash } from 'node:crypto'
+
+export const DEFAULT_PROMPT_CACHE_TTL_MS = 5 * 60 * 1000
+export const MIN_CONNECT_ATTEMPT_TIMEOUT_MS = 1500
+
+function text(value) {
+  return value == null ? '' : String(value).trim()
+}
+
+/** #810: cache usefulness score for an account (higher = warmer cache). */
+export function promptCacheAffinity(account, nowMs = Date.now(), ttlMs = DEFAULT_PROMPT_CACHE_TTL_MS) {
+  if (!account) return { score: 0, state: 'cache_expired' }
+  const at = Number(account.lastUsedAt || account.cacheAt || 0)
+  if (!at) return { score: 0, state: 'cache_expired' }
+  const ttl = Number(ttlMs) > 0 ? Number(ttlMs) : 0
+  if (!ttl) return { score: 0, state: 'cache_off' }
+  const age = Math.max(0, Number(nowMs) - at)
+  if (age >= ttl) return { score: 0, state: 'cache_expired', ageMs: age }
+  return { score: 1 - age / ttl, state: 'cache_affinity', ageMs: age }
+}
+
+/** #813: a model may only route to accounts whose catalog contains it. */
+export function accountCatalogHasModel(account, model) {
+  if (!Array.isArray(account?.availableModels) || !account.availableModels.length) return true
+  const wanted = text(model).toLowerCase()
+  if (!wanted) return true
+  return account.availableModels.some((entry) => {
+    const id = typeof entry === 'string' ? entry : (entry && (entry.id || entry.slug || entry.name))
+    return text(id).toLowerCase() === wanted
+  })
+}
+
+/** #820: never lower a larger host value; raise tiny per-address attempts. */
+export function effectiveConnectAttemptTimeout(hostValue, minimum = MIN_CONNECT_ATTEMPT_TIMEOUT_MS) {
+  const host = Number(hostValue)
+  const min = Number(minimum) > 0 ? Number(minimum) : MIN_CONNECT_ATTEMPT_TIMEOUT_MS
+  if (!Number.isFinite(host) || host <= 0) return min
+  return Math.max(host, min)
+}
+
+/** #824: bind opaque provider replay state to provider/account/model. */
+export function replayStateKey(provider, accountRef, model) {
+  return createHash('sha256')
+    .update(`${text(provider).toLowerCase()}|${text(accountRef)}|${text(model)}`)
+    .digest('hex')
+    .slice(0, 24)
+}
+
+export function wrapReplayState(state, key, version = 1) {
+  if (state == null || !key) return state
+  return { kind: 'dsh-subscriptions.replay', version, key, state }
+}
+
+export function unwrapReplayState(envelope, key) {
+  if (!envelope || typeof envelope !== 'object' || envelope.kind !== 'dsh-subscriptions.replay') {
+    return { state: envelope, legacy: true, matched: true }
+  }
+  return { state: envelope.key === key ? envelope.state : undefined, legacy: false, matched: envelope.key === key }
+}
+
+/** #792: proactive guard for near-zero remaining quota. */
+export function proactiveQuotaDecision(quota, nowMs = Date.now(), minRemaining = 1) {
+  if (!quota) return { block: false, reason: null }
+  const resetAt = Number(quota.resetAt || 0)
+  if (resetAt && resetAt <= nowMs) return { block: false, reason: null }
+  const remaining = quota.remaining != null ? Number(quota.remaining) : null
+  const remainingPercent = quota.remainingPercent != null ? Number(quota.remainingPercent) : null
+  if (remaining != null && remaining <= Number(minRemaining)) return { block: true, reason: 'remaining_low', until: resetAt || null }
+  if (remainingPercent != null && remainingPercent <= 0) return { block: true, reason: 'remaining_zero', until: resetAt || null }
+  return { block: false, reason: null }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-subscriptions",
-  "version": "0.7.31",
+  "version": "0.7.33",
   "description": "Use ChatGPT Codex, Claude, Grok, Antigravity, Kimi, GLM, Cursor, Kiro, Copilot, Qwen, ERNIE, Spark, JetBrains, Perplexity, Replit, and Cody subscriptions as DeepSeek Harness LLM providers via OAuth.",
   "license": "MIT",
   "type": "module",