@goodandready/dsh-subscriptions 0.7.37 → 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

@@ -59,8 +59,15 @@ export class SubscriptionAdapter extends LlmAdapter {
     const builtin = modelCatalog(provider, cfg ? cfg.models : undefined)
     const targetAccount = accounts.find((a) => a.hasToken)
     let targetLive = null
+    const targetCached = targetAccount && typeof this.deps.getDynamicModels === 'function'
+      ? this.deps.getDynamicModels(targetAccount.ref)
+      : null
 
-    if (targetAccount) {
+    // #27: resolution runs on every request. Do not hit live metadata when a
+    // last-known-good per-account snapshot already exists; background refresh
+    // updates it without turning a temporary metadata outage into a capability
+    // verdict.
+    if (targetAccount && !(Array.isArray(targetCached) && targetCached.length)) {
       const baseFetch = pickFetch(this.deps, targetAccount.ref)
       const listModelsFetch = (url, init, opts) =>
         fetchWithTimeout(baseFetch, url, init, { timeoutMs: 15000, ...(opts || {}) })
@@ -214,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/reasoning-effort.js

@@ -97,6 +97,11 @@ export function getModelReasoningCapabilities(provider, modelId, catalog = []) {
     if (id.includes('reasoning') || id === 'grok-3-mini') {
       return { supported: true, levels: ['low', 'medium', 'high'], defaultEffort: 'medium' }
     }
+    // #27: grok-4.x supports reasoning effort even when the best-effort CLI
+    // metadata endpoint is temporarily unreachable.
+    if (/^grok-4(?:[.-]|$)/i.test(id)) {
+      return { supported: true, levels: ['low', 'medium', 'high'], defaultEffort: 'high' }
+    }
     return { supported: false, levels: [] }
   }
 

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/lib/vendors/grok.js

@@ -43,18 +43,37 @@ async function cliCatalogCached(blob, cfg, fetchImpl) {
   const now = Date.now()
   const hit = catalogCache.get(key)
   if (hit && now - hit.at < CATALOG_TTL_MS) return hit.map
-  if (hit) catalogCache.delete(key)
-  const map = await cliCatalog(blob, cfg, fetchImpl)
-  if (map.size > 0) {
-    catalogCache.set(key, { at: now, map })
-    pruneCatalogCache(now)
+  try {
+    const map = await cliCatalog(blob, cfg, fetchImpl)
+    if (map.size > 0) {
+      catalogCache.set(key, { at: now, map })
+      pruneCatalogCache(now)
+      return map
+    }
+    // An empty response must not erase the last-known-good metadata.
+    if (hit) return hit.map
+    return map
+  } catch (err) {
+    if (hit) return hit.map
+    throw err
+  }
+}
+
+function grokFallbackReasoning(modelId) {
+  if (!/^grok-4(?:[.-]|$)/i.test(String(modelId || ''))) return undefined
+  return {
+    efforts: [
+      { id: 'high', name: 'High' },
+      { id: 'medium', name: 'Medium' },
+      { id: 'low', name: 'Low' },
+    ],
+    defaultEffort: 'high',
   }
-  return map
 }
 
 function grokReasoningBody(modelId, effort, catalogMap) {
   const entry = catalogMap && catalogMap.get(modelId)
-  const reasoning = entry && entry.reasoning
+  const reasoning = (entry && entry.reasoning) || grokFallbackReasoning(modelId)
   if (!reasoning || !reasoning.efforts || !reasoning.efforts.length) return undefined
   const allowed = new Set(reasoning.efforts.map((row) => row.id))
   const pick = effort != null && effort !== '' ? String(effort) : ''
@@ -221,7 +240,7 @@ export async function listModels(blob, cfg, fetchImpl) {
   try {
     const [res, extra] = await Promise.all([
       impl(MODELS, { headers: { Authorization: `Bearer ${blob.accessToken}`, Accept: 'application/json' } }),
-      cliCatalog(blob, cfg, impl).catch(() => new Map()),
+      cliCatalogCached(blob, cfg, impl).catch(() => new Map()),
     ])
     const json = await readJson(res)
     const rows = []
@@ -229,6 +248,7 @@ export async function listModels(blob, cfg, fetchImpl) {
       const modelId = entry && entry.id
       if (!modelId || !isChatModel(modelId)) continue
       const enrich = extra.get(modelId) || {}
+      const reasoning = enrich.reasoning || grokFallbackReasoning(modelId)
       const note = /multi-agent/i.test(modelId)
         ? 'Chat only in Harness until xAI grants multi-agent tool beta.'
         : ''
@@ -237,6 +257,7 @@ export async function listModels(blob, cfg, fetchImpl) {
         name: enrich.name || modelId,
         inputModalities: grokModalities(modelId),
         ...enrich,
+        ...(reasoning ? { reasoning } : {}),
         ...(note ? { description: enrich.description ? `${enrich.description} ${note}` : note } : {}),
       })
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-subscriptions",
-  "version": "0.7.37",
+  "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": {