@goodandready/dsh-model-sync 0.3.12 → 0.3.14

package/lib/policy.js

@@ -1,4 +1,4 @@
-const CAPABILITY_KEYS = new Set(['vision', 'tools', 'reasoning', 'embeddings'])
+const CAPABILITY_KEYS = new Set(['vision', 'tools', 'reasoning', 'embeddings', 'code'])
 const MAX_PATTERNS = 100
 const MAX_PATTERN_LENGTH = 256
 
@@ -16,12 +16,21 @@ function capabilities(value) {
 
 export function normalizePolicy(policy) {
   const value = policy && typeof policy === 'object' && !Array.isArray(policy) ? policy : {}
-  return {
+  const res = {
     include: list(value.include),
     exclude: list(value.exclude),
     requireCapabilities: capabilities(value.requireCapabilities),
     denyCapabilities: capabilities(value.denyCapabilities),
   }
+  if (value.enableCostFilter) res.enableCostFilter = true
+  if (typeof value.maxPricePerMillion === 'number' && Number.isFinite(value.maxPricePerMillion) && value.maxPricePerMillion >= 0) {
+    res.maxPricePerMillion = value.maxPricePerMillion
+  }
+  if (value.enableContextFilter) res.enableContextFilter = true
+  if (typeof value.minContextTokens === 'number' && Number.isFinite(value.minContextTokens) && value.minContextTokens >= 0) {
+    res.minContextTokens = Math.floor(value.minContextTokens)
+  }
+  return res
 }
 
 function compilePatterns(patterns, field) {
@@ -48,6 +57,8 @@ export function hasPolicy(policy) {
     || normalized.exclude.length > 0
     || Object.keys(normalized.requireCapabilities).length > 0
     || Object.keys(normalized.denyCapabilities).length > 0
+    || (normalized.enableCostFilter && normalized.maxPricePerMillion !== undefined)
+    || (normalized.enableContextFilter && normalized.minContextTokens !== undefined)
 }
 
 export function filterModels(models, policy) {
@@ -66,6 +77,18 @@ export function filterModels(models, policy) {
     for (const [key, denied] of Object.entries(normalized.denyCapabilities)) {
       if (modelCapabilities[key] === denied) return false
     }
+    if (normalized.enableCostFilter && normalized.maxPricePerMillion !== undefined) {
+      const inputPrice = model?.pricing?.inputPerToken
+      if (typeof inputPrice === 'number' && Number.isFinite(inputPrice)) {
+        if (inputPrice * 1000000 > normalized.maxPricePerMillion) return false
+      }
+    }
+    if (normalized.enableContextFilter && normalized.minContextTokens !== undefined) {
+      const context = model?.contextWindow
+      if (typeof context === 'number' && Number.isFinite(context)) {
+        if (context < normalized.minContextTokens) return false
+      }
+    }
     return true
   })
 }

package/lib/reliability.js

@@ -105,6 +105,7 @@ export async function retryWithBackoff(operation, {
   attempts = 3,
   baseDelayMs = 250,
   maxDelayMs = 4000,
+  jitter = true,
   signal,
   onRetry,
 } = {}) {
@@ -117,11 +118,14 @@ export async function retryWithBackoff(operation, {
     } catch (error) {
       lastError = error
       if (attempt >= total || !isRetryableError(error)) throw error
-      const defaultDelayMs = Math.min(Math.max(0, Number(maxDelayMs) || 0), Math.max(0, Number(baseDelayMs) || 0) * (2 ** (attempt - 1)))
+      const exponential = Math.max(0, Number(baseDelayMs) || 0) * (2 ** (attempt - 1))
+      // Full jitter: randomized between [0.5, 1.0] of calculated exponential backoff
+      const jitterFactor = jitter ? (0.5 + Math.random() * 0.5) : 1
+      const calculatedDelayMs = Math.min(Math.max(0, Number(maxDelayMs) || 0), Math.round(exponential * jitterFactor))
       const retryAfterMs = Number(error?.retryAfterMs)
       const delayMs = (Number.isFinite(retryAfterMs) && retryAfterMs > 0)
         ? Math.min(Math.max(0, Number(maxDelayMs) || 0), retryAfterMs)
-        : defaultDelayMs
+        : calculatedDelayMs
       onRetry?.({ attempt, nextAttempt: attempt + 1, delayMs, error })
       await delay(delayMs, signal)
     }

package/lib/synchronizer.js

@@ -132,6 +132,7 @@ export function createModelSynchronizer(ctx, { getConfig = () => ({}), saveConfi
   const credentialOutcomes = new Map()
   let lastReport = null
   let transientNotifications = []
+  const providerHttpMeta = new Map()
 
   function recordCredentialOutcome(provider, outcome) {
     credentialOutcomes.set(provider, { ...outcome, at: Date.now() })
@@ -240,11 +241,12 @@ export function createModelSynchronizer(ctx, { getConfig = () => ({}), saveConfi
       }
     }
     let retries = 0
+    const existingMeta = providerHttpMeta.get(row.provider)
     try {
-      const models = await retryWithBackoff(async () => {
+      const result = await retryWithBackoff(async () => {
         const timed = createTimeoutSignal(signal, reliability.timeoutMs)
         try {
-          return await adapter.discover(profile, { signal: timed.signal })
+          return await adapter.discover(profile, { signal: timed.signal, etag: existingMeta?.etag, lastModified: existingMeta?.lastModified })
         } finally {
           timed.cleanup()
         }
@@ -257,6 +259,15 @@ export function createModelSynchronizer(ctx, { getConfig = () => ({}), saveConfi
       })
       circuits.delete(row.provider)
       recordCredentialOutcome(row.provider, { status: 'ok', retries })
+      if (result && result.notModified) {
+        const config = getConfig() ?? {}
+        const cached = normalizeModels(row.provider, config.modelCatalogs?.[row.provider] ?? row.models ?? [])
+        return { provider: row.provider, status: 'ok', models: cached, retries, notModified: true }
+      }
+      const models = Array.isArray(result) ? result : []
+      if (result?.__httpMeta) {
+        providerHttpMeta.set(row.provider, result.__httpMeta)
+      }
       return { provider: row.provider, status: 'ok', models, retries }
     } catch (error) {
       if (!signal?.aborted) recordFailure(row.provider, reliability, error)
@@ -536,6 +547,34 @@ export function createModelSynchronizer(ctx, { getConfig = () => ({}), saveConfi
       ...(entry?.status !== 'ok' ? { error: entry?.message || entry?.status || 'probe failed' } : {}),
     }
   }
+  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)
+    const results = []
+    const concurrency = 3
+    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) => ({
+          provider,
+          model,
+          ok: false,
+          latencyMs: 0,
+          status: 'error',
+          error: err instanceof Error ? err.message : String(err)
+        })))
+      )
+      results.push(...chunkResults)
+    }
+    const reachable = results.filter((r) => r.ok).length
+    return {
+      provider,
+      results,
+      summary: { total: results.length, reachable, unreachable: results.length - reachable }
+    }
+  }
+
 
   async function rollbackHistory({ historyId, provider } = {}) {
     if (typeof historyId !== 'string' || !historyId) throw Object.assign(new Error('historyId is required'), { code: 'INVALID_HISTORY' })
@@ -621,6 +660,115 @@ export function createModelSynchronizer(ctx, { getConfig = () => ({}), saveConfi
     }
     return { provider, selectedModels, models: nextModels, availableModels: available, selectableModels: safeAvailable, applied: true }
   }
+  function exportConfig() {
+    const config = getConfig() ?? {}
+    const pmap = {}
+    for (const p of providers()) {
+      if (p.configured) {
+        pmap[p.provider] = {
+          policy: config.modelPolicies?.[p.provider] ?? {},
+          selectedModels: config.modelSelections?.[p.provider] ?? []
+        }
+      }
+    }
+    return {
+      version: '1.0',
+      exportedAt: new Date().toISOString(),
+      plugin: '@goodandready/dsh-model-sync',
+      providers: pmap,
+      aliases: config.aliases ?? {},
+      scheduler: {
+        scheduleEnabled: config.scheduleEnabled ?? false,
+        intervalMinutes: config.intervalMinutes ?? 60,
+        autoApply: config.autoApply ?? false
+      }
+    }
+  }
+
+  async function importConfig(data) {
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+      throw Object.assign(new Error('invalid config payload'), { code: 'INVALID_CONFIG' })
+    }
+    if (typeof saveConfig !== 'function') throw Object.assign(new Error('dsh-model-sync settings are not writable'), { code: 'CONFIG_UNAVAILABLE' })
+    const config = getConfig() ?? {}
+    const importedProviders = []
+    const importedAliases = []
+    const patch = {}
+
+    if (data.providers && typeof data.providers === 'object') {
+      const currentPolicies = structuredClone(config.modelPolicies ?? {})
+      const currentSelections = structuredClone(config.modelSelections ?? {})
+      for (const [pname, pdata] of Object.entries(data.providers)) {
+        if (pdata && typeof pdata === 'object') {
+          if (pdata.policy) {
+            currentPolicies[pname] = validatePolicy(pdata.policy)
+            importedProviders.push(pname)
+          }
+          if (Array.isArray(pdata.selectedModels)) {
+            currentSelections[pname] = pdata.selectedModels.filter((m) => typeof m === 'string')
+            importedProviders.push(pname)
+          }
+        }
+      }
+      patch.modelPolicies = currentPolicies
+      patch.modelSelections = currentSelections
+    }
+
+    if (data.aliases && typeof data.aliases === 'object') {
+      const currentAliases = structuredClone(config.aliases ?? {})
+      for (const [k, v] of Object.entries(data.aliases)) {
+        if (typeof k === 'string' && /^[a-zA-Z0-9_\-.]{1,64}$/.test(k.trim()) && v && typeof v === 'object' && typeof v.provider === 'string' && typeof v.model === 'string') {
+          currentAliases[k.trim()] = { provider: v.provider, model: v.model, updatedAt: Date.now() }
+          importedAliases.push(k.trim())
+        }
+      }
+      patch.aliases = currentAliases
+    }
+
+    if (data.scheduler && typeof data.scheduler === 'object') {
+      if (typeof data.scheduler.scheduleEnabled === 'boolean') patch.scheduleEnabled = data.scheduler.scheduleEnabled
+      if (typeof data.scheduler.intervalMinutes === 'number') patch.intervalMinutes = data.scheduler.intervalMinutes
+      if (typeof data.scheduler.autoApply === 'boolean') patch.autoApply = data.scheduler.autoApply
+    }
+
+    await saveConfig(patch)
+    return {
+      success: true,
+      importedProviders: [...new Set(importedProviders)],
+      importedAliases: [...new Set(importedAliases)]
+    }
+  }
+
+  function getAliases() {
+    const config = getConfig() ?? {}
+    return config.aliases ?? {}
+  }
+
+  async function setAlias({ alias, provider, model } = {}) {
+    if (typeof alias !== 'string' || !/^[a-zA-Z0-9_\-.]{1,64}$/.test(alias.trim())) {
+      throw Object.assign(new Error('alias must be 1-64 alphanumeric characters or _-.'), { code: 'INVALID_ALIAS' })
+    }
+    const trimmedAlias = alias.trim()
+    if (typeof provider !== 'string' || !provider) throw new Error('provider is required')
+    if (typeof model !== 'string' || !model) throw new Error('model is required')
+    if (typeof saveConfig !== 'function') throw Object.assign(new Error('dsh-model-sync settings are not writable'), { code: 'CONFIG_UNAVAILABLE' })
+    const config = getConfig() ?? {}
+    const currentAliases = structuredClone(config.aliases ?? {})
+    currentAliases[trimmedAlias] = { provider, model, updatedAt: Date.now() }
+    await saveConfig({ aliases: currentAliases })
+    return { alias: trimmedAlias, provider, model, aliases: currentAliases }
+  }
+
+  async function deleteAlias({ alias } = {}) {
+    if (typeof alias !== 'string' || !alias) throw new Error('alias is required')
+    if (typeof saveConfig !== 'function') throw Object.assign(new Error('dsh-model-sync settings are not writable'), { code: 'CONFIG_UNAVAILABLE' })
+    const config = getConfig() ?? {}
+    const currentAliases = structuredClone(config.aliases ?? {})
+    delete currentAliases[alias.trim()]
+    await saveConfig({ aliases: currentAliases })
+    return { alias: alias.trim(), deleted: true, aliases: currentAliases }
+  }
+
 
   return Object.freeze({
     listProviders: providers,
@@ -634,12 +782,18 @@ export function createModelSynchronizer(ctx, { getConfig = () => ({}), saveConfi
     listPolicies,
     health,
     tryModel,
+    batchTryModels,
+    exportConfig,
+    importConfig,
+    getAliases,
+    setAlias,
+    deleteAlias,
     credentialDiagnostics,
     history,
     report: () => structuredClone(lastReport),
     notifications: notificationLedger,
     updateNotification: updateNotificationState,
     rollbackHistory,
-    status: () => ({ running: Boolean(running), lastRun, lastHealth, lastReport: structuredClone(lastReport), notifications: notificationLedger(), history: history(), policies: listPolicies(), lifecycle: structuredClone(getConfig()?.modelLifecycle ?? {}) }),
+    status: () => ({ running: Boolean(running), lastRun, lastHealth, lastReport: structuredClone(lastReport), notifications: notificationLedger(), history: history(), policies: listPolicies(), lifecycle: structuredClone(getConfig()?.modelLifecycle ?? {}), aliases: structuredClone(getConfig()?.aliases ?? {}) }),
   })
 }

package/package.json

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