@goodandready/dsh-model-sync 0.3.14 → 0.4.1

package/lib/index.js

@@ -3,6 +3,7 @@ import { createProviderService } from './provider-service.js'
 import { createModelSynchronizer } from './synchronizer.js'
 import { createSyncScheduler } from './scheduler.js'
 import { registerHttpApi } from './http.js'
+import { registerPluginUpdater } from './updater.js'
 
 export const name = '@goodandready/dsh-model-sync'
 export const inject = ['llm', 'settings', 'webServer', 'credentials']
@@ -143,7 +144,9 @@ export function apply(ctx, config) {
   }
 
   let settings
-  try { settings = ctx.get('settings') } catch {}
+  try { settings = ctx.get('settings') } catch (e) {
+    if (typeof ctx.logger?.debug === 'function') ctx.logger.debug('[dsh-model-sync] settings service not immediately available:', e)
+  }
   if (!bindSettings(settings, ctx)) {
     ctx.inject(['settings'], (sctx) => {
       bindSettings((typeof sctx.get === 'function' ? sctx.get('settings') : null) ?? sctx.settings, sctx)
@@ -163,6 +166,11 @@ export function apply(ctx, config) {
       for (const dispose of registrations) if (typeof dispose === 'function') dispose()
     }
   }, 'dsh-model-sync: http api')
+  ctx.effect(() => registerPluginUpdater(ctx, {
+    packageName: name,
+    endpoint: '/api/dsh-model-sync/update',
+    manifestUrl: new URL('../package.json', import.meta.url),
+  }), 'dsh-model-sync: plugin updater')
   ctx.effect(() => {
     if (!liveConfig.enabled) return () => {}
     ctx.provide('modelSync', service)

package/lib/models.js

@@ -92,7 +92,14 @@ function normalizeCapabilities(row) {
     }
   }
 
-  const sources = [row?.capabilities, row?.supportedCapabilities, row?.supported_capabilities]
+  const sources = [
+    row?.capabilities,
+    row?.supportedCapabilities,
+    row?.supported_capabilities,
+    row?.supportedFeatures,
+    row?.supported_features,
+    row?.features,
+  ]
   for (const source of sources) {
     if (Array.isArray(source)) {
       for (const token of source) {
@@ -148,6 +155,74 @@ function normalizeCapabilities(row) {
   return Object.keys(result).length > 0 ? result : undefined
 }
 
+
+function isGroqMinijinjaModel(id) {
+  if (typeof id !== 'string') return false
+  const lower = id.toLowerCase().replace(/^groq\//, '')
+  return (
+    lower.startsWith('qwen') ||
+    lower.startsWith('meta-llama') ||
+    lower.startsWith('llama') ||
+    lower.startsWith('mistral') ||
+    lower.startsWith('mixtral') ||
+    lower.startsWith('gemma') ||
+    lower.startsWith('deepseek')
+  )
+}
+
+function normalizeCompat(provider, row, id) {
+  const source = row?.compat && typeof row.compat === 'object' ? { ...row.compat } : {}
+  const isGroq = provider === 'groq'
+  const isDeepSeek = provider === 'deepseek'
+
+  let defaultSupportsDeveloperRole
+  if (isGroq && id && isGroqMinijinjaModel(id)) {
+    defaultSupportsDeveloperRole = false
+  } else if (isDeepSeek) {
+    defaultSupportsDeveloperRole = false
+  }
+
+  if (source.supportsDeveloperRole === undefined && defaultSupportsDeveloperRole !== undefined) {
+    source.supportsDeveloperRole = defaultSupportsDeveloperRole
+  }
+
+  return Object.keys(source).length > 0 ? source : undefined
+}
+
+function normalizeInput(row) {
+  const modalitySources = [row?.inputModalities, row?.input_modalities, row?.modalities]
+  for (const source of modalitySources) {
+    if (Array.isArray(source) && source.length > 0) {
+      const set = new Set()
+      for (const item of source) {
+        if (typeof item !== 'string') continue
+        const val = item.trim().toLowerCase()
+        if (val === 'image' || val === 'vision') set.add('image')
+        else if (val === 'text') set.add('text')
+        else if (val) set.add(val)
+      }
+      const order = ['text', 'image']
+      const result = []
+      for (const k of order) {
+        if (set.has(k)) {
+          result.push(k)
+          set.delete(k)
+        }
+      }
+      for (const k of set) {
+        result.push(k)
+      }
+      if (result.length > 0) return result
+    }
+  }
+
+  if (Array.isArray(row?.input)) {
+    return row.input.map((item) => (typeof item === 'string' ? item.trim() : item)).filter(Boolean)
+  }
+
+  return undefined
+}
+
 function normalizeTags(row) {
   const source = row?.tags ?? row?.labels
   if (!Array.isArray(source)) return undefined
@@ -208,6 +283,9 @@ export function normalizeModel(provider, row) {
     row = { id: row }
   }
   if (!row || typeof row !== 'object') return null
+  const effectiveProvider = (typeof provider === 'string' && provider.trim())
+    ? provider.trim()
+    : (typeof row.provider === 'string' ? row.provider.trim() : '')
   const id = String(row.id ?? row.slug ?? row.model ?? '').trim()
   if (!id) return null
   const name = String(row.name ?? row.displayName ?? row.display_name ?? id).trim() || id
@@ -218,13 +296,17 @@ export function normalizeModel(provider, row) {
   const tags = normalizeTags(row)
   const aliases = normalizeAliases(row, id)
   const lifecycle = normalizeLifecycle(row)
+  const input = normalizeInput(row)
+  const compat = normalizeCompat(effectiveProvider, row, id)
   return {
-    provider,
+    provider: effectiveProvider || provider,
     id,
     name,
     ...(contextWindow === undefined ? {} : { contextWindow }),
     ...(maxTokens === undefined ? {} : { maxTokens }),
     ...(row.description ? { description: String(row.description) } : {}),
+    ...(input === undefined ? {} : { input }),
+    ...(compat === undefined ? {} : { compat }),
     ...(capabilities === undefined ? {} : { capabilities }),
     ...(pricing === undefined ? {} : { pricing }),
     ...(tags === undefined ? {} : { tags }),

package/lib/reconcile.js

@@ -18,8 +18,20 @@ export function reconcileModels(provider, current, discovered, {
   const stale = []
   for (const row of before) {
     const fresh = advertisedById.get(row.id)
-    if (fresh) next.push(fresh)
-    else if (renamedBefore.has(row.id)) {
+    if (fresh) {
+      const merged = {
+        ...row,
+        ...fresh,
+        ...(row.capabilities || fresh.capabilities ? {
+          capabilities: { ...(fresh.capabilities ?? {}), ...(row.capabilities ?? {}) },
+        } : {}),
+        ...(row.compat || fresh.compat ? {
+          compat: { ...(fresh.compat ?? {}), ...(row.compat ?? {}) },
+        } : {}),
+        ...(fresh.input?.length ? { input: fresh.input } : row.input ? { input: row.input } : {}),
+      }
+      next.push(merged)
+    } else if (renamedBefore.has(row.id)) {
       // An explicit provider alias is safe evidence that the old id was renamed.
     } else {
       stale.push(row)

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,
+  }
+}