@goodandready/dsh-subscriptions 0.7.38 → 0.7.39

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

@@ -155,6 +155,8 @@ 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.'),
   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/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.39",
   "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": {