@goodandready/dsh-subscriptions 0.7.38 → 0.7.40

package/lib/adapter-manager.js

@@ -55,6 +55,7 @@ export function createAdapterManager({
     drainSafetyPercent: () => live().drainSafetyPercent,
     switchAtRemaining: () => live().switchAtRemaining,
     rotationStrategy: () => live().rotationStrategy,
+    modelAccountRules: () => live().modelAccountRules || [],
     rateLimitWait: () => live().rateLimitWait,
     rateLimitMaxWaitMs: () => live().rateLimitMaxWaitMs,
     enableSoftFailureSentinel: () => live().enableSoftFailureSentinel,

package/lib/adapter.js

@@ -221,6 +221,8 @@ export class SubscriptionAdapter extends LlmAdapter {
         drainBeforeReset: effectiveDrainBeforeReset,
         drainSafetyPercent: effectiveDrainSafetyPercent,
         rotationStrategy: effectiveRotationStrategy,
+        modelAccountRules: typeof deps.modelAccountRules === 'function' ? deps.modelAccountRules() : [],
+        provider,
         enableSoftFailureSentinel: effectiveSoftFailureSentinel,
         rateLimitWait: typeof deps.rateLimitWait === 'function' ? deps.rateLimitWait() : deps.rateLimitWait,
         rateLimitMaxWaitMs: typeof deps.rateLimitMaxWaitMs === 'function' ? deps.rateLimitMaxWaitMs() : deps.rateLimitMaxWaitMs,

package/lib/client-version.js

@@ -0,0 +1,35 @@
+/** #798: choose a client version with deterministic source precedence. */
+export function resolveClientVersion({ configValue, npmVersion, localVersion, fallback } = {}) {
+  const values = [
+    ['config', configValue],
+    ['npm', npmVersion],
+    ['local', localVersion],
+    ['fallback', fallback],
+  ]
+  for (const [source, value] of values) {
+    const text = String(value || '').trim()
+    if (text) return { version: text, source }
+  }
+  return { version: '', source: 'none' }
+}
+
+export function parseNpmVersion(json) {
+  if (!json || typeof json !== 'object') return ''
+  return String(json.version || '').trim()
+}
+
+export function createVersionCache(ttlMs = 6 * 60 * 60 * 1000) {
+  const cache = new Map()
+  return {
+    get(key, now = Date.now()) {
+      const hit = cache.get(key)
+      if (!hit) return null
+      if (Number(now) - hit.at >= ttlMs) return null
+      return hit.value
+    },
+    set(key, value, now = Date.now()) {
+      cache.set(key, { at: Number(now), value })
+    },
+    clear() { cache.clear() },
+  }
+}

package/lib/compat.js

@@ -0,0 +1,20 @@
+/** #816: normalize host API shape differences in one place. */
+export function toolCallId(value) {
+  if (!value || typeof value !== 'object') return ''
+  return String(value.toolCallId || value.tool_call_id || value.callId || value.call_id || value.id || '')
+}
+
+export function normalizeRpcResult(value) {
+  if (value == null) return { ok: false, value: null }
+  if (typeof value === 'object' && Object.prototype.hasOwnProperty.call(value, 'ok')) {
+    return { ok: Boolean(value.ok), value: value.value ?? value.result ?? null }
+  }
+  return { ok: true, value }
+}
+
+export function hostCompatibilityError(detail) {
+  const suffix = detail ? `: ${String(detail)}` : ''
+  const err = new Error(`unsupported DSH host API${suffix}`)
+  err.code = 'DSH_HOST_INCOMPATIBLE'
+  return err
+}

package/lib/config-schema.js

@@ -20,6 +20,8 @@ export const Slot = z.object({
     .description('#67 Optional subscription expiry timestamp (ms). When set and within expiryNotifyDays, the header chip shows the account and expiry date.'),
   proxyUrl: z.string().default('')
     .description('#88 Per-account proxy URL (http://, https://, socks5://). All requests for this account route through it. Empty = direct connection.'),
+  proxyBypass: z.array(z.string()).default([])
+    .description('#803 Hosts/domains that bypass the per-account proxy.'),
   maxConcurrency: z.number().default(1)
     .description('#555 Per-slot max concurrent requests before queuing. Defaults to 1 for subscription safety.'),
   monthlyCost: z.number().default(20)
@@ -155,6 +157,10 @@ export const Config = z.object({
     .description('#349 Opt-in cross-vendor fallback when all accounts of a provider are exhausted or rate limited.'),
   cascadingFallbackOrder: z.array(z.string()).volatile().default(PROVIDERS)
     .description('Configurable global priority sequence for cross-vendor fallback.'),
+  modelAccountRules: z.array(z.object({ provider: z.string(), pattern: z.string(), account: z.string() })).volatile().default([])
+    .description('#788 Per-provider model glob rules. First match wins; account may be a ref, label or index.'),
+  tiers: z.array(z.any()).volatile().default([])
+    .description('#817 Named picker tiers: { id, name, members: [accountRef] }. No cross-tier fallback.'),
   rotationStrategy: z.string().volatile().default('round-robin')
     .description('Load balancing strategy among available accounts: round-robin (balanced), least-loaded (fair-share quota), quota-aware (urgent quota first), or priority (sequential).'),
   poolEnabled: z.boolean().volatile().default(true)

package/lib/feature-helpers.js

@@ -0,0 +1,107 @@
+function hostOf(value) {
+  try { return new URL(String(value)).hostname.toLowerCase() } catch { return '' }
+}
+
+/** #803: bypass plugin proxy for listed hosts/domains. */
+export function shouldBypassProxy(bypassList, targetUrl) {
+  const host = hostOf(targetUrl)
+  if (!host) return false
+  for (const raw of Array.isArray(bypassList) ? bypassList : []) {
+    const entry = String(raw || '').trim().toLowerCase().replace(/^\*\./, '').replace(/^\./, '')
+    if (!entry) continue
+    if (host === entry || host.endsWith('.' + entry)) return true
+  }
+  return false
+}
+
+/** #803: distinguish proxy transport failure from provider failure. */
+export function classifyConnectivityProbe({ proxyError, providerStatus, latencyMs } = {}) {
+  if (proxyError) return { ok: false, kind: 'proxy', error: String(proxyError), latencyMs: null }
+  const status = Number(providerStatus) || 0
+  return {
+    ok: status >= 200 && status < 500,
+    kind: status >= 400 ? 'provider' : 'ok',
+    status,
+    latencyMs: Number.isFinite(Number(latencyMs)) ? Number(latencyMs) : null,
+  }
+}
+
+/** #817: tiers are independent named pools; no cross-tier fallback. */
+export function validateTiers(tiers) {
+  const list = Array.isArray(tiers) ? tiers : []
+  const ids = new Set()
+  const out = []
+  for (const tier of list) {
+    if (!tier || typeof tier !== 'object') continue
+    const id = String(tier.id || '').trim()
+    if (!id || ids.has(id)) continue
+    ids.add(id)
+    out.push({
+      id,
+      name: String(tier.name || id),
+      members: (Array.isArray(tier.members) ? tier.members : [])
+        .map((member) => String(member || '').trim())
+        .filter(Boolean),
+    })
+  }
+  return out
+}
+
+export function selectTierAccount(tier, accounts, nowMs = Date.now()) {
+  const members = new Set((tier && tier.members) || [])
+  if (!members.size) return null
+  return (Array.isArray(accounts) ? accounts : []).find((account) => account
+    && members.has(account.ref)
+    && account.hasToken
+    && (!account.cooldownUntil || Number(account.cooldownUntil) <= nowMs)
+    && (!account.quarantineUntil || Number(account.quarantineUntil) <= nowMs)
+    && !(account.usagePercent != null && Number(account.usagePercent) >= 100)) || null
+}
+
+/** #832: session policy snapshots are frozen at session creation. */
+export function snapshotToolPolicy(policy, sessionId, at = Date.now()) {
+  return { sessionId: String(sessionId || ''), at: Number(at), policy: JSON.parse(JSON.stringify(policy || {})) }
+}
+
+export function toolPolicyForSession(snapshots, sessionId) {
+  const found = (Array.isArray(snapshots) ? snapshots : []).find((row) => row && row.sessionId === String(sessionId || ''))
+  return found ? found.policy : null
+}
+
+/** #834: Claude CLI-synced accounts must not fight standalone OAuth over Keychain. */
+export function claudeAccountMode(slot = {}) {
+  const raw = String(slot.accountMode || slot.mode || '').toLowerCase()
+  if (raw === 'cli-synced' || raw === 'cli') return 'cli-synced'
+  return 'standalone'
+}
+
+export function canWriteClaudeKeychain(slot, blob, expectedAccountId) {
+  if (claudeAccountMode(slot) !== 'cli-synced') return false
+  if (!blob) return false
+  const owner = String(blob.accountId || blob.email || '').trim()
+  const expected = String(expectedAccountId || slot.accountId || slot.email || '').trim()
+  return Boolean(owner && expected && owner === expected)
+}
+
+/** #815: normalize Codex web-search results and bound retry behavior. */
+export function normalizeWebSearchResult(payload, maxBytes = 64 * 1024) {
+  const body = payload && typeof payload === 'object' ? payload : {}
+  const text = String(body.output_text || body.answer || body.text || '').slice(0, maxBytes)
+  const citations = (Array.isArray(body.citations) ? body.citations : [])
+    .map((citation) => {
+      if (!citation) return null
+      if (typeof citation === 'string') return { url: citation }
+      return { url: String(citation.url || citation.link || ''), title: citation.title ? String(citation.title) : undefined }
+    })
+    .filter((citation) => citation && citation.url)
+    .slice(0, 50)
+  return { text, citations }
+}
+
+export function webSearchRetryDelay(attempt, status) {
+  const n = Number(attempt) || 0
+  const code = Number(status) || 0
+  if (code === 429) return null
+  if (code >= 500 && n < 2) return Math.min(2000, 250 * 2 ** n)
+  return null
+}

package/lib/rotate.js

@@ -2,6 +2,13 @@ import { computePacingRisk, calculateBurnRatePerHour, calculateBurnUrgency } fro
 import { isQuarantined } from './quarantine.js'
 import { getPinnedAccountRef, pinSession, touchSessionPin, unpinSession, isCacheAwareProvider } from './session-pin.js'
 import { accountCatalogHasModel, proactiveQuotaDecision, promptCacheAffinity } from './routing-reliability.js'
+import { matchModelAccountRule } from './routing-rules.js'
+
+const roundRobinCursor = new Map()
+
+export function resetRoundRobinState() {
+  roundRobinCursor.clear()
+}
 
 const SWITCH_CODES = new Set([
   'RATE_LIMIT',
@@ -128,6 +135,7 @@ export function pickAccountWithTrace(accounts, nowMs, opts) {
   const isVipRequest = Boolean(opts && opts.vip)
   const targetTag = opts && opts.tag
   const targetSession = opts && opts.sessionId
+  const ruleRef = matchModelAccountRule(opts && opts.modelAccountRules, opts && opts.provider, opts && opts.model, list)
 
   const evaluations = []
 
@@ -156,7 +164,7 @@ export function pickAccountWithTrace(accounts, nowMs, opts) {
   }
 
   // Sticky & Cache-Aware Session Pinning (#170, #517, #520)
-  if (targetSession) {
+  if (targetSession && !ruleRef) {
     const pinnedRef = getPinnedAccountRef(targetSession, now)
     if (pinnedRef) {
       const pinned = list.find((a) => (a.ref || a.id) === pinnedRef)
@@ -388,6 +396,11 @@ export function pickAccountWithTrace(accounts, nowMs, opts) {
           const aUrgency = calculateBurnUrgency(getAccountRemainingPercent(a), a.quota && a.quota.resetAt, now, floor)
           const bUrgency = calculateBurnUrgency(getAccountRemainingPercent(b), b.quota && b.quota.resetAt, now, floor)
           if (Math.abs(aUrgency - bUrgency) > 0.01) return bUrgency - aUrgency
+        } else if (strategy === 'lowest-latency') {
+          const aLatency = Number(a.lastPingMs ?? a.latencyMs ?? Infinity)
+          const bLatency = Number(b.lastPingMs ?? b.latencyMs ?? Infinity)
+          if (Number.isFinite(aLatency) && Number.isFinite(bLatency) && Math.abs(aLatency - bLatency) > 1) return aLatency - bLatency
+          if (Number.isFinite(aLatency) !== Number.isFinite(bLatency)) return Number.isFinite(aLatency) ? -1 : 1
         }
 
         // #810: keep session traffic on a warm prompt-cache account.
@@ -421,8 +434,23 @@ export function pickAccountWithTrace(accounts, nowMs, opts) {
       })
 
       let chosen = tier[0]
+      let decisionReason = tierIdx === 0 ? 'healthy_tier0' : tierIdx === 1 ? 'healthy_tier1' : 'tier2_fallback'
       const strategy = (opts && opts.rotationStrategy) || 'round-robin'
-      if (strategy === 'quota-aware' && opts && opts.defaultRef) {
+      if (ruleRef) {
+        const ruled = tier.find((account) => (account.ref || account.id) === ruleRef)
+        if (ruled) {
+          chosen = ruled
+          decisionReason = 'model_rule'
+        }
+      } else if (strategy === 'round-robin' && tier.length > 1) {
+        const key = tier.map((account) => account.ref || account.id).join('|')
+        const last = roundRobinCursor.get(key)
+        const index = last ? tier.findIndex((account) => (account.ref || account.id) === last) : -1
+        chosen = tier[(index + 1) % tier.length]
+        roundRobinCursor.set(key, chosen.ref || chosen.id)
+        if (index >= 0) decisionReason = 'round_robin'
+      }
+      if (!ruleRef && strategy === 'quota-aware' && opts && opts.defaultRef) {
         const byDefault = tier.find((account) => (account.ref || account.id) === opts.defaultRef)
         if (byDefault && byDefault !== chosen) {
           const floor = opts.drainSafetyPercent != null ? Number(opts.drainSafetyPercent) : 5
@@ -443,7 +471,7 @@ export function pickAccountWithTrace(accounts, nowMs, opts) {
         account: chosen,
         trace: {
           chosenRef,
-          decisionReason: tierIdx === 0 ? 'healthy_tier0' : tierIdx === 1 ? 'healthy_tier1' : 'tier2_fallback',
+          decisionReason,
           tier: tierIdx,
           evaluations,
           selectionMetrics: {

package/lib/routing-rules.js

@@ -0,0 +1,34 @@
+function escapeRegExp(value) {
+  return String(value).replace(/[.+^${}()|[\]\\]/g, '\\$&')
+}
+
+export function globToRegExp(pattern) {
+  const source = String(pattern || '').trim()
+  if (!source) return null
+  let out = '^'
+  for (const char of source) {
+    if (char === '*') out += '.*'
+    else if (char === '?') out += '.'
+    else out += escapeRegExp(char)
+  }
+  out += '$'
+  try { return new RegExp(out, 'i') } catch { return null }
+}
+
+/** #788: first matching provider/model glob rule wins. */
+export function matchModelAccountRule(rules, provider, model, slots) {
+  const list = Array.isArray(rules) ? rules : []
+  const accounts = Array.isArray(slots) ? slots : []
+  for (const rule of list) {
+    if (!rule || rule.provider !== provider) continue
+    const pattern = globToRegExp(rule.pattern)
+    if (!pattern || !pattern.test(String(model || ''))) continue
+    const wanted = String(rule.account || '').trim()
+    if (!wanted) continue
+    const slot = accounts.find((item) => item && item.provider === provider && (
+      item.ref === wanted || String(item.label || '') === wanted || String(item.index) === wanted
+    ))
+    if (slot) return slot.ref
+  }
+  return null
+}

package/lib/stream-rotate.js

@@ -54,6 +54,8 @@ export async function* streamWithRotation({
       model: options && options.model,
       onlyRef: options && options.onlyRef,
       defaultRef: options && options.defaultRef,
+      provider: options && options.provider,
+      modelAccountRules: options && options.modelAccountRules,
       promptCacheTtlMs: options && options.promptCacheTtlMs,
       proactiveGuard: options && options.proactiveGuard,
       proactiveMinRemaining: options && options.proactiveMinRemaining,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-subscriptions",
-  "version": "0.7.38",
+  "version": "0.7.40",
   "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",
@@ -39,7 +39,7 @@
     "url": "https://github.com/GooDAnDReaDY/dsh-subscriptions/issues"
   },
   "scripts": {
-    "test": "eslint lib/ test/ && npm run typecheck && node --import ./test/_setup.mjs --test test/*.test.mjs && node scripts/check-pack-size.mjs",
+    "test": "eslint lib/ test/ && npm run typecheck && node --import ./test/_setup.mjs --test --experimental-test-coverage --test-coverage-lines=85 --test-coverage-branches=70 --test-coverage-functions=75 --test-coverage-include='lib/**/*.js' --test-coverage-exclude='lib/client.js' test/*.test.mjs && node scripts/check-pack-size.mjs",
     "typecheck": "tsc -p tsconfig.checkjs.json"
   },
   "dsh": {