@goodandready/dsh-model-sync 0.3.13 → 0.4.0

package/lib/synchronizer-helpers.js

@@ -0,0 +1,113 @@
+import { statusOfError } from './reliability.js'
+
+export const PIAI_NS = 'llm-pi-ai'
+export const DEFAULT_RELIABILITY = Object.freeze({
+  timeoutMs: 15000,
+  retryAttempts: 3,
+  retryBaseDelayMs: 250,
+  retryMaxDelayMs: 4000,
+  concurrency: 4,
+  circuitBreakerFailures: 3,
+  circuitBreakerCooldownMs: 300000,
+})
+
+export function boundedInteger(value, fallback, minimum, maximum) {
+  const number = Number(value)
+  if (!Number.isFinite(number)) return fallback
+  return Math.min(maximum, Math.max(minimum, Math.floor(number)))
+}
+
+export function reliabilityOptions(config, options) {
+  const source = { ...config, ...options }
+  const baseDelay = boundedInteger(source.retryBaseDelayMs, DEFAULT_RELIABILITY.retryBaseDelayMs, 0, 60000)
+  const cooldownMs = source.circuitBreakerCooldownMs !== undefined
+    ? boundedInteger(source.circuitBreakerCooldownMs, DEFAULT_RELIABILITY.circuitBreakerCooldownMs, 0, 3600000)
+    : boundedInteger(Number(source.circuitBreakerCooldownMinutes) * 60000, DEFAULT_RELIABILITY.circuitBreakerCooldownMs, 0, 3600000)
+  return {
+    timeoutMs: boundedInteger(source.requestTimeoutMs, DEFAULT_RELIABILITY.timeoutMs, 100, 120000),
+    retryAttempts: boundedInteger(source.retryAttempts, DEFAULT_RELIABILITY.retryAttempts, 1, 6),
+    retryBaseDelayMs: baseDelay,
+    retryMaxDelayMs: Math.max(baseDelay, boundedInteger(source.retryMaxDelayMs, DEFAULT_RELIABILITY.retryMaxDelayMs, 0, 120000)),
+    concurrency: boundedInteger(source.concurrency, DEFAULT_RELIABILITY.concurrency, 1, 32),
+    circuitBreakerFailures: boundedInteger(source.circuitBreakerFailures, DEFAULT_RELIABILITY.circuitBreakerFailures, 0, 20),
+    circuitBreakerCooldownMs: cooldownMs,
+  }
+}
+
+export function settingsOf(ctx) {
+  try { return (typeof ctx.get === 'function' ? (ctx.get('settings') ?? ctx.settings) : ctx.settings) } catch { return ctx.settings }
+}
+
+export function llmOf(ctx) {
+  try {
+    const llm = typeof ctx.get === 'function' ? ctx.get('llm') : null
+    return (llm && typeof llm === 'object' && (llm.listConfigurableProviders || llm.listProviders)) ? llm : ctx.llm
+  } catch {
+    return ctx.llm
+  }
+}
+
+export function descriptorOf(settings, ns) {
+  try { return settings?.describe?.({ redactSecrets: true })?.find((row) => row.ns === ns) }
+  catch { return undefined }
+}
+
+export function profileOf(settings, provider) {
+  try { return settings?.get(PIAI_NS)?.providers?.[provider] ?? {} }
+  catch { return {} }
+}
+
+export function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error)
+}
+
+export function diagnosticMessage(error) {
+  return errorMessage(error).replace(/(api[_-]?key|token|secret|authorization|password)\s*[:=]\s*[^\s,;]+/gi, '$1=[redacted]').slice(0, 160)
+}
+
+export function adapterErrorType(error) {
+  if (error?.adapterCode === 'auth') return 'auth'
+  if (error?.adapterCode === 'rate-limit') return 'rate-limit'
+  if (error?.adapterCode === 'schema') return 'schema'
+  if (error?.adapterCode === 'endpoint') return 'endpoint'
+  if (error?.code === 'CREDENTIALS_UNAVAILABLE' || error?.code === 'AUTH') return 'credential'
+  const status = statusOfError(error)
+  if (status === 401 || status === 403) return 'auth'
+  if (status === 429) return 'rate-limit'
+  if (status) return 'http'
+  return 'endpoint'
+}
+
+export async function replaceWithRetry(settings, ns, patchFn, attempts = 3) {
+  let lastError
+  for (let i = 0; i < attempts; i++) {
+    const section = settings?.get?.(ns)
+    const descriptor = descriptorOf(settings, ns)
+    if (!section || !descriptor || typeof settings.replace !== 'function') {
+      throw Object.assign(new Error(`${ns} settings are not writable`), { code: 'SETTINGS_UNAVAILABLE' })
+    }
+    const next = patchFn(structuredClone(section))
+    try {
+      await settings.replace(ns, next, descriptor.revision)
+      return next
+    } catch (err) {
+      lastError = err
+      const isConflict = err?.code === 'SETTINGS_CONFLICT' || err?.status === 409 || /conflict|revision/i.test(err?.message || '')
+      if (isConflict && i < attempts - 1) {
+        continue
+      }
+      throw err
+    }
+  }
+  throw lastError
+}
+
+export function rotationRefs(settings, provider) {
+  try {
+    const rows = settings?.get?.('dsh-key-rotation')?.providers
+    if (!Array.isArray(rows)) return []
+    return rows.filter((row) => row?.provider === provider).flatMap((row) => Array.isArray(row.keys) ? row.keys : [])
+  } catch {
+    return []
+  }
+}

package/lib/synchronizer-prober.js

@@ -0,0 +1,50 @@
+export function createModelProber({ health }) {
+  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 {
+      provider,
+      model,
+      ok: entry?.status === 'ok',
+      latencyMs: Date.now() - start,
+      status: entry?.status ?? 'unknown',
+      ...(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 }
+    }
+  }
+
+  return {
+    tryModel,
+    batchTryModels,
+  }
+}

package/lib/synchronizer-transfer.js

@@ -0,0 +1,118 @@
+export function createConfigTransfer({ getConfig = () => ({}), saveConfig = async () => {}, listProviders = () => [], validatePolicy } = {}) {
+  function exportConfig() {
+    const config = getConfig() ?? {}
+    const pmap = {}
+    for (const p of listProviders()) {
+      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] = typeof validatePolicy === 'function' ? validatePolicy(pdata.policy) : 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 {
+    exportConfig,
+    importConfig,
+    getAliases,
+    setAlias,
+    deleteAlias,
+  }
+}

package/lib/synchronizer.js

@@ -9,117 +9,23 @@ import { appendHistory, createHistoryEntry, historyEntry, listHistory } from './
 import { lifecycleOptions, lifecycleStatus, selectableModels, updateLifecycle } from './lifecycle.js'
 import { appendNotification, listNotifications, createSyncReport, updateNotification } from './reporting.js'
 
-const PIAI_NS = 'llm-pi-ai'
-const DEFAULT_RELIABILITY = Object.freeze({
-  timeoutMs: 15000,
-  retryAttempts: 3,
-  retryBaseDelayMs: 250,
-  retryMaxDelayMs: 4000,
-  concurrency: 4,
-  circuitBreakerFailures: 3,
-  circuitBreakerCooldownMs: 300000,
-})
-
-function boundedInteger(value, fallback, minimum, maximum) {
-  const number = Number(value)
-  if (!Number.isFinite(number)) return fallback
-  return Math.min(maximum, Math.max(minimum, Math.floor(number)))
-}
-
-function reliabilityOptions(config, options) {
-  const source = { ...config, ...options }
-  const baseDelay = boundedInteger(source.retryBaseDelayMs, DEFAULT_RELIABILITY.retryBaseDelayMs, 0, 60000)
-  const cooldownMs = source.circuitBreakerCooldownMs !== undefined
-    ? boundedInteger(source.circuitBreakerCooldownMs, DEFAULT_RELIABILITY.circuitBreakerCooldownMs, 0, 3600000)
-    : boundedInteger(Number(source.circuitBreakerCooldownMinutes) * 60000, DEFAULT_RELIABILITY.circuitBreakerCooldownMs, 0, 3600000)
-  return {
-    timeoutMs: boundedInteger(source.requestTimeoutMs, DEFAULT_RELIABILITY.timeoutMs, 100, 120000),
-    retryAttempts: boundedInteger(source.retryAttempts, DEFAULT_RELIABILITY.retryAttempts, 1, 6),
-    retryBaseDelayMs: baseDelay,
-    retryMaxDelayMs: Math.max(baseDelay, boundedInteger(source.retryMaxDelayMs, DEFAULT_RELIABILITY.retryMaxDelayMs, 0, 120000)),
-    concurrency: boundedInteger(source.concurrency, DEFAULT_RELIABILITY.concurrency, 1, 32),
-    circuitBreakerFailures: boundedInteger(source.circuitBreakerFailures, DEFAULT_RELIABILITY.circuitBreakerFailures, 0, 20),
-    circuitBreakerCooldownMs: cooldownMs,
-  }
-}
-
-function settingsOf(ctx) {
-  try { return (typeof ctx.get === 'function' ? (ctx.get('settings') ?? ctx.settings) : ctx.settings) } catch { return ctx.settings }
-}
-
-function llmOf(ctx) {
-  try {
-    const llm = typeof ctx.get === 'function' ? ctx.get('llm') : null
-    return (llm && typeof llm === 'object' && (llm.listConfigurableProviders || llm.listProviders)) ? llm : ctx.llm
-  } catch {
-    return ctx.llm
-  }
-}
-
-function descriptorOf(settings, ns) {
-  try { return settings?.describe?.({ redactSecrets: true })?.find((row) => row.ns === ns) }
-  catch { return undefined }
-}
-
-function profileOf(settings, provider) {
-  try { return settings?.get(PIAI_NS)?.providers?.[provider] ?? {} }
-  catch { return {} }
-}
-
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error)
-}
-
-function diagnosticMessage(error) {
-  return errorMessage(error).replace(/(api[_-]?key|token|secret|authorization|password)\s*[:=]\s*[^\s,;]+/gi, '$1=[redacted]').slice(0, 160)
-}
-
-function adapterErrorType(error) {
-  if (error?.adapterCode === 'auth') return 'auth'
-  if (error?.adapterCode === 'rate-limit') return 'rate-limit'
-  if (error?.adapterCode === 'schema') return 'schema'
-  if (error?.adapterCode === 'endpoint') return 'endpoint'
-  if (error?.code === 'CREDENTIALS_UNAVAILABLE' || error?.code === 'AUTH') return 'credential'
-  const status = statusOfError(error)
-  if (status === 401 || status === 403) return 'auth'
-  if (status === 429) return 'rate-limit'
-  if (status) return 'http'
-  return 'endpoint'
-}
-
-async function replaceWithRetry(settings, ns, patchFn, attempts = 3) {
-  let lastError
-  for (let i = 0; i < attempts; i++) {
-    const section = settings?.get?.(ns)
-    const descriptor = descriptorOf(settings, ns)
-    if (!section || !descriptor || typeof settings.replace !== 'function') {
-      throw Object.assign(new Error(`${ns} settings are not writable`), { code: 'SETTINGS_UNAVAILABLE' })
-    }
-    const next = patchFn(structuredClone(section))
-    try {
-      await settings.replace(ns, next, descriptor.revision)
-      return next
-    } catch (err) {
-      lastError = err
-      const isConflict = err?.code === 'SETTINGS_CONFLICT' || err?.status === 409 || /conflict|revision/i.test(err?.message || '')
-      if (isConflict && i < attempts - 1) {
-        continue
-      }
-      throw err
-    }
-  }
-  throw lastError
-}
-
-function rotationRefs(settings, provider) {
-  try {
-    const rows = settings?.get?.('dsh-key-rotation')?.providers
-    if (!Array.isArray(rows)) return []
-    return rows.filter((row) => row?.provider === provider).flatMap((row) => Array.isArray(row.keys) ? row.keys : [])
-  } catch {
-    return []
-  }
-}
+import {
+  PIAI_NS,
+  DEFAULT_RELIABILITY,
+  boundedInteger,
+  reliabilityOptions,
+  settingsOf,
+  llmOf,
+  descriptorOf,
+  profileOf,
+  errorMessage,
+  diagnosticMessage,
+  adapterErrorType,
+  replaceWithRetry,
+  rotationRefs,
+} from './synchronizer-helpers.js'
+import { createConfigTransfer } from './synchronizer-transfer.js'
+import { createModelProber } from './synchronizer-prober.js'
 
 export function createModelSynchronizer(ctx, { getConfig = () => ({}), saveConfig = async () => {}, fetchImpl = fetch, adapterImplementations = {} } = {}) {
   const resolveCredential = createCredentialResolver(ctx)
@@ -531,22 +437,9 @@ export function createModelSynchronizer(ctx, { getConfig = () => ({}), saveConfi
     return transientNotifications.find((row) => row.id === id)
   }
 
-  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()
-    // Use health as lightweight probe; latency is the signal
-    const result = await health({ provider })
-    const entry = result?.results?.find((r) => r.provider === provider)
-    return {
-      provider,
-      model,
-      ok: entry?.status === 'ok',
-      latencyMs: Date.now() - start,
-      status: entry?.status ?? 'unknown',
-      ...(entry?.status !== 'ok' ? { error: entry?.message || entry?.status || 'probe failed' } : {}),
-    }
-  }
+  const prober = createModelProber({ health })
+  const tryModel = prober.tryModel
+  const batchTryModels = prober.batchTryModels
 
   async function rollbackHistory({ historyId, provider } = {}) {
     if (typeof historyId !== 'string' || !historyId) throw Object.assign(new Error('historyId is required'), { code: 'INVALID_HISTORY' })
@@ -632,6 +525,17 @@ export function createModelSynchronizer(ctx, { getConfig = () => ({}), saveConfi
     }
     return { provider, selectedModels, models: nextModels, availableModels: available, selectableModels: safeAvailable, applied: true }
   }
+  const transfer = createConfigTransfer({
+    getConfig,
+    saveConfig,
+    listProviders: providers,
+    validatePolicy,
+  })
+  const exportConfig = transfer.exportConfig
+  const importConfig = transfer.importConfig
+  const getAliases = transfer.getAliases
+  const setAlias = transfer.setAlias
+  const deleteAlias = transfer.deleteAlias
 
   return Object.freeze({
     listProviders: providers,
@@ -645,12 +549,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 ?? {}) }),
   })
 }