@goodandready/dsh-model-sync 0.5.6 → 0.5.7

package/lib/alias-resolver.js

@@ -1,9 +1,12 @@
 export const VIRTUAL_STRATEGIES = Object.freeze(['fastest', 'cheapest', 'best-code'])
 
-export function isVirtualAlias(name) {
+export const VIRTUAL_ALIASES = Object.freeze(new Set(['@fast', '@cheap', '@best-code']))
+
+export function isVirtualAlias(name, strategy) {
+  if (strategy && VIRTUAL_STRATEGIES.includes(typeof strategy === 'string' ? strategy.trim() : '')) return true
   if (typeof name !== 'string') return false
   const clean = name.trim().toLowerCase()
-  return clean === '@fast' || clean === '@cheap' || clean === '@best-code' || clean.startsWith('@')
+  return VIRTUAL_ALIASES.has(clean)
 }
 
 export function validateAliasName(name) {
@@ -135,11 +138,22 @@ export function resolveAlias(aliasName, {
     }
 
     if (strategy === 'fastest') {
-      const scored = available.map((item) => ({
-        ...item,
-        latencyMs: estimateLatency(item.provider, item.model, modelProbes),
-      }))
-      scored.sort((a, b) => a.latencyMs - b.latencyMs)
+      const scored = available.map((item) => {
+        const probeKey = `${item.provider}:${item.model.id}`
+        const probe = modelProbes[probeKey]
+        const measured = probe?.latencyMs && Number.isFinite(probe.latencyMs) && probe.ok !== false
+        const latencyMs = measured ? Math.round(probe.latencyMs) : estimateLatency(item.provider, item.model, modelProbes)
+        return {
+          ...item,
+          latencyMs,
+          measured: Boolean(measured),
+        }
+      })
+      scored.sort((a, b) => {
+        if (a.measured && !b.measured) return -1
+        if (!a.measured && b.measured) return 1
+        return a.latencyMs - b.latencyMs
+      })
       const best = scored[0]
       return {
         alias: clean,
@@ -149,7 +163,7 @@ export function resolveAlias(aliasName, {
         name: best.model.name || best.model.id,
         latencyMs: best.latencyMs,
         fallbackUsed: false,
-        reason: 'lowest_latency',
+        reason: best.measured ? 'lowest_latency' : 'estimated_lowest_latency',
       }
     }
 

package/lib/diff-notifier.js

@@ -74,7 +74,7 @@ export function extractDiffEvents(results, options = {}) {
         const bp = pair?.before?.pricing
         const ap = pair?.after?.pricing
         if (bp || ap) {
-          const inputDiff = bp?.inputPerToken !== ap?.outputPerToken && bp?.inputPerToken !== ap?.inputPerToken
+          const inputDiff = bp?.inputPerToken !== ap?.inputPerToken
           const outputDiff = bp?.outputPerToken !== ap?.outputPerToken
           if (inputDiff || outputDiff) {
             priceChanged.push({

package/lib/policy.js

@@ -33,9 +33,21 @@ export function normalizePolicy(policy) {
   return res
 }
 
+function isDangerousPattern(pattern) {
+  if (typeof pattern !== 'string') return false
+  // Check for nested quantifiers like (a+)+, (a*)*, (a+)*, (a{1,2})+
+  if (/(\([^)]*[+*]\)[+*?{])|(\([^)]*\{[0-9]+,[0-9]*\}\)[+*?{])/.test(pattern)) return true
+  // Check for quantified groups containing quantified inner constructs
+  if (/\([^\)]*([+*]|\{[0-9]+,[0-9]*\})[^\)]*\)([+*]|\{[0-9]+,[0-9]*\})/.test(pattern)) return true
+  // Check for multiple consecutive open-ended wildcards (e.g. .*.*)
+  if (/(\.\*|\.\+){2,}/.test(pattern)) return true
+  return false
+}
+
 function compilePatterns(patterns, field) {
   return patterns.map((pattern) => {
     if (pattern.length > MAX_PATTERN_LENGTH) throw Object.assign(new Error(`${field} pattern is too long`), { code: 'INVALID_POLICY' })
+    if (isDangerousPattern(pattern)) throw Object.assign(new Error(`${field} pattern has catastrophic backtracking risk: ${pattern}`), { code: 'INVALID_POLICY' })
     try {
       return new RegExp(pattern, 'i')
     } catch {
@@ -53,10 +65,12 @@ export function validatePolicy(policy) {
 
 export function hasPolicy(policy) {
   const normalized = normalizePolicy(policy)
+  const hasRequire = Object.values(normalized.requireCapabilities).some((v) => v === true)
+  const hasDeny = Object.values(normalized.denyCapabilities).some((v) => v === true)
   return normalized.include.length > 0
     || normalized.exclude.length > 0
-    || Object.keys(normalized.requireCapabilities).length > 0
-    || Object.keys(normalized.denyCapabilities).length > 0
+    || hasRequire
+    || hasDeny
     || (normalized.enableCostFilter && normalized.maxPricePerMillion !== undefined)
     || (normalized.enableContextFilter && normalized.minContextTokens !== undefined)
 }
@@ -74,10 +88,10 @@ export function filterModels(models, policy) {
     if (exclude.some((pattern) => pattern.test(haystack))) return false
     const modelCapabilities = model?.capabilities ?? {}
     for (const [key, expected] of Object.entries(normalized.requireCapabilities)) {
-      if (modelCapabilities[key] !== expected) return false
+      if (expected === true && modelCapabilities[key] !== true) return false
     }
     for (const [key, denied] of Object.entries(normalized.denyCapabilities)) {
-      if (modelCapabilities[key] === denied) return false
+      if (denied === true && modelCapabilities[key] === true) return false
     }
     if (normalized.enableCostFilter && normalized.maxPricePerMillion !== undefined) {
       const inputPrice = model?.pricing?.inputPerToken

package/lib/pricing-database.js

@@ -100,14 +100,13 @@ export function lookupReferencePricing(provider, modelId) {
   const rawId = modelId.toLowerCase().trim()
   const cleaned = cleanId(rawId)
 
-  // 1. Direct check in provider table
+  // 1. Direct check in provider table (exact match or date-cleaned match)
   const table = REFERENCE_PRICING[provKey]
   if (table) {
     if (table[rawId]) return { ...table[rawId] }
     if (table[cleaned]) return { ...table[cleaned] }
-    for (const [key, val] of Object.entries(table)) {
-      if (rawId.startsWith(key) || cleaned.startsWith(key)) return { ...val }
-    }
+    // If the provider has a dedicated pricing table, do not search other providers' tables
+    return undefined
   }
 
   // 2. Vendor prefix check (e.g. "openai/gpt-4o" or "anthropic/claude-3-5-sonnet")
@@ -120,18 +119,12 @@ export function lookupReferencePricing(provider, modelId) {
     if (subTable) {
       if (subTable[subId]) return { ...subTable[subId] }
       if (subTable[subCleaned]) return { ...subTable[subCleaned] }
-      for (const [key, val] of Object.entries(subTable)) {
-        if (subId.startsWith(key) || subCleaned.startsWith(key)) return { ...val }
-      }
     }
   }
 
-  // 3. Fallback search across all tables if cleaned matches well-known key
+  // 3. Fallback search across tables ONLY for unknown/aggregator providers without a dedicated table
   for (const [p, t] of Object.entries(REFERENCE_PRICING)) {
     if (t[cleaned]) return { ...t[cleaned] }
-    for (const [key, val] of Object.entries(t)) {
-      if (cleaned.startsWith(key)) return { ...val }
-    }
   }
 
   return undefined

package/lib/reporting.js

@@ -127,7 +127,7 @@ export function appendNotification(existing, report, { limit = DEFAULT_NOTIFICAT
     rows.push({
       ...current,
       updatedAt: now,
-      occurrences: boundedInteger(current.occurrences, 1, 1, 1000000) + 1,
+      occurrences: boundedInteger(Number(current.occurrences || 0) + 1, 1, 1, 1000000),
     })
   } else {
     rows.push(notification)

package/lib/scheduler.js

@@ -82,6 +82,7 @@ export function createSyncScheduler(sync, {
   async function tick() {
     const config = getConfig() ?? {}
     if (config.enabled === false || config.scheduleEnabled === false || running) return
+    resetStates(config)
     const rows = scheduleRows(config)
     if (rows.length === 0) return
     const now = nowFn()
@@ -131,8 +132,6 @@ export function createSyncScheduler(sync, {
   }
 
   function status() {
-    const config = getConfig() ?? {}
-    resetStates(config)
     const values = [...state.values()]
     const nextAt = (timer !== null && values.length > 0) ? Math.min(...values.map((row) => row.nextAt)) : null
     const lastRunAt = values.filter((row) => row.lastRunAt).reduce((max, row) => Math.max(max, row.lastRunAt), 0) || null

package/lib/synchronizer-prober.js

@@ -1,40 +1,92 @@
-export function createModelProber({ health }) {
+export function createModelProber({ health, getProviderCatalog = () => [] } = {}) {
+  const modelProbes = new Map()
+
   async function tryModel({ provider, model } = {}) {
     if (typeof provider !== 'string' || !provider) throw new Error('provider is required')
     if (typeof model !== 'string' || !model) throw new Error('model is required')
     const start = Date.now()
     const result = await health({ provider })
     const entry = result?.results?.find((r) => r.provider === provider)
-    return {
+    const providerOk = entry?.status === 'ok'
+
+    // Verify model in provider catalog if catalog is available
+    const catalog = typeof getProviderCatalog === 'function' ? getProviderCatalog(provider) : []
+    const hasCatalog = Array.isArray(catalog) && catalog.length > 0
+    const inCatalog = !hasCatalog || catalog.some((m) => (typeof m === 'string' ? m : m?.id) === model)
+
+    const ok = Boolean(providerOk && inCatalog)
+    const latencyMs = Date.now() - start
+    const status = !providerOk ? (entry?.status ?? 'error') : (!inCatalog ? 'model_not_found' : 'ok')
+    const errorMsg = !providerOk
+      ? (entry?.message || entry?.status || 'probe failed')
+      : (!inCatalog ? `model "${model}" not found in provider catalog` : undefined)
+
+    const probeResult = {
       provider,
       model,
-      ok: entry?.status === 'ok',
-      latencyMs: Date.now() - start,
-      status: entry?.status ?? 'unknown',
-      ...(entry?.status !== 'ok' ? { error: entry?.message || entry?.status || 'probe failed' } : {}),
+      ok,
+      latencyMs,
+      status,
+      ...(errorMsg ? { error: errorMsg } : {}),
     }
+
+    modelProbes.set(`${provider}:${model}`, {
+      latencyMs,
+      ok,
+      status,
+      timestamp: Date.now(),
+    })
+
+    return probeResult
   }
 
   async function batchTryModels({ provider, models } = {}) {
     if (typeof provider !== 'string' || !provider) throw new Error('provider is required')
     if (!Array.isArray(models)) throw new Error('models must be an array')
     const list = [...new Set(models.filter((m) => typeof m === 'string' && m.trim()).map((m) => m.trim()))].slice(0, 50)
+
+    // Probe provider health ONCE for the entire batch rather than per-model
+    const start = Date.now()
+    const healthResult = await health({ provider })
+    const entry = healthResult?.results?.find((r) => r.provider === provider)
+    const providerOk = entry?.status === 'ok'
+    const catalog = typeof getProviderCatalog === 'function' ? getProviderCatalog(provider) : []
+    const hasCatalog = Array.isArray(catalog) && catalog.length > 0
+    const baseLatency = Date.now() - start
+
     const results = []
-    const concurrency = 3
+    const concurrency = 5
     for (let i = 0; i < list.length; i += concurrency) {
       const chunk = list.slice(i, i + concurrency)
-      const chunkResults = await Promise.all(
-        chunk.map((model) => tryModel({ provider, model }).catch((err) => ({
+      const chunkResults = chunk.map((model) => {
+        const inCatalog = !hasCatalog || catalog.some((m) => (typeof m === 'string' ? m : m?.id) === model)
+        const ok = Boolean(providerOk && inCatalog)
+        const status = !providerOk ? (entry?.status ?? 'error') : (!inCatalog ? 'model_not_found' : 'ok')
+        const errorMsg = !providerOk
+          ? (entry?.message || entry?.status || 'probe failed')
+          : (!inCatalog ? `model "${model}" not found in provider catalog` : undefined)
+
+        const itemResult = {
           provider,
           model,
-          ok: false,
-          latencyMs: 0,
-          status: 'error',
-          error: err instanceof Error ? err.message : String(err)
-        })))
-      )
+          ok,
+          latencyMs: baseLatency,
+          status,
+          ...(errorMsg ? { error: errorMsg } : {}),
+        }
+
+        modelProbes.set(`${provider}:${model}`, {
+          latencyMs: baseLatency,
+          ok,
+          status,
+          timestamp: Date.now(),
+        })
+
+        return itemResult
+      })
       results.push(...chunkResults)
     }
+
     const reachable = results.filter((r) => r.ok).length
     return {
       provider,
@@ -43,8 +95,13 @@ export function createModelProber({ health }) {
     }
   }
 
+  function getModelProbes() {
+    return Object.fromEntries(modelProbes)
+  }
+
   return {
     tryModel,
     batchTryModels,
+    getModelProbes,
   }
 }

package/lib/synchronizer-transfer.js

@@ -74,7 +74,7 @@ export function createConfigTransfer({
             const strat = v.strategy.trim()
             if (VIRTUAL_STRATEGIES.includes(strat)) {
               entry.strategy = strat
-              entry.isVirtual = isVirtualAlias(k)
+              entry.isVirtual = isVirtualAlias(k, strat)
             } else {
               continue
             }
@@ -125,7 +125,7 @@ export function createConfigTransfer({
       }
       currentAliases[trimmedAlias] = {
         strategy: cleanStrategy,
-        isVirtual: isVirtualAlias(trimmedAlias),
+        isVirtual: isVirtualAlias(trimmedAlias, cleanStrategy),
         updatedAt: Date.now(),
       }
     } else {

package/lib/synchronizer.js

@@ -452,7 +452,13 @@ export function createModelSynchronizer(ctx, { getConfig = () => ({}), saveConfi
     return transientNotifications.find((row) => row.id === id)
   }
 
-  const prober = createModelProber({ health })
+  const prober = createModelProber({
+    health,
+    getProviderCatalog: (p) => {
+      const row = providers().find((item) => item.provider === p)
+      return row?.availableModels || row?.models || []
+    },
+  })
 
   const rollbackHistory = (opts) => performHistoryRollback({ ctx, config: getConfig() ?? {}, providers: providers(), ...opts })
 
@@ -533,6 +539,7 @@ export function createModelSynchronizer(ctx, { getConfig = () => ({}), saveConfi
     validatePolicy,
     isCircuitOpen: (p) => Boolean(circuits.get(p)?.blockedUntil > Date.now()),
     getHealthResults: () => lastHealth?.results ?? [],
+    getModelProbes: () => prober.getModelProbes(),
   })
 
   return Object.freeze({
@@ -547,6 +554,7 @@ export function createModelSynchronizer(ctx, { getConfig = () => ({}), saveConfi
     listPolicies,
     health,
     ...prober,
+    getModelProbes: prober.getModelProbes,
     ...transfer,
     credentialDiagnostics,
     history,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-model-sync",
-  "version": "0.5.6",
+  "version": "0.5.7",
   "description": "Automatic model catalog synchronization for API-key DeepSeek Harness providers.",
   "keywords": [
     "deepseek-harness",