@goodandready/dsh-model-sync 0.5.15 → 0.5.17

package/lib/scheduler.js

@@ -24,6 +24,7 @@ export function createSyncScheduler(sync, {
 } = {}) {
   let timer = null
   let running = false
+  let lastPricingSyncAt = 0
   const state = new Map()
 
   function stop() {
@@ -82,6 +83,12 @@ export function createSyncScheduler(sync, {
   async function tick() {
     const config = getConfig() ?? {}
     if (config.enabled === false || config.scheduleEnabled === false || running) return
+    if (typeof sync.syncPricing === 'function' && (nowFn() - lastPricingSyncAt > 24 * 60 * 60 * 1000 || lastPricingSyncAt === 0)) {
+      lastPricingSyncAt = nowFn()
+      sync.syncPricing().catch((err) => {
+        logger.warn?.('[dsh-model-sync] background pricing sync failed: ' + errorMessage(err))
+      })
+    }
     resetStates(config)
     const rows = scheduleRows(config)
     if (rows.length === 0) return

package/lib/specs-database.js

@@ -0,0 +1,223 @@
+function cleanId(id) {
+  if (typeof id !== 'string') return ''
+  return id
+    .toLowerCase()
+    .trim()
+    .replace(/^models\//, '')
+    .replace(/:latest$/, '')
+    .replace(/-latest$/, '')
+    .replace(/-(202\d{5}|202\d-\d{2}-\d{2}|\d{4})$/, '')
+}
+
+export const REFERENCE_SPECS = Object.freeze({
+  openai: {
+    'gpt-4o': { contextWindow: 128000, maxOutputTokens: 16384 },
+    'gpt-4o-mini': { contextWindow: 128000, maxOutputTokens: 16384 },
+    'o1': {
+      contextWindow: 200000,
+      maxOutputTokens: 100000,
+      reasoningConfig: { supportsReasoning: true, paramFormat: 'effort', defaultEffort: 'medium', supportedEfforts: ['low', 'medium', 'high'] },
+      compat: { supportsTemperature: false, supportsMaxTokens: false },
+    },
+    'o1-preview': {
+      contextWindow: 128000,
+      maxOutputTokens: 32768,
+      reasoningConfig: { supportsReasoning: true, paramFormat: 'effort', defaultEffort: 'medium', supportedEfforts: ['low', 'medium', 'high'] },
+      compat: { supportsTemperature: false, supportsMaxTokens: false },
+    },
+    'o1-mini': {
+      contextWindow: 128000,
+      maxOutputTokens: 65536,
+      reasoningConfig: { supportsReasoning: true, paramFormat: 'effort', defaultEffort: 'medium', supportedEfforts: ['low', 'medium', 'high'] },
+      compat: { supportsTemperature: false, supportsMaxTokens: false },
+    },
+    'o3-mini': {
+      contextWindow: 200000,
+      maxOutputTokens: 100000,
+      reasoningConfig: { supportsReasoning: true, paramFormat: 'effort', defaultEffort: 'medium', supportedEfforts: ['low', 'medium', 'high'] },
+      compat: { supportsTemperature: false, supportsMaxTokens: false },
+    },
+    'gpt-4-turbo': { contextWindow: 128000, maxOutputTokens: 4096 },
+    'gpt-4': { contextWindow: 8192, maxOutputTokens: 4096 },
+    'gpt-3.5-turbo': { contextWindow: 16385, maxOutputTokens: 4096 },
+    'chatgpt-4o-latest': { contextWindow: 128000, maxOutputTokens: 16384 },
+  },
+  anthropic: {
+    'claude-3-7-sonnet': {
+      contextWindow: 200000,
+      maxOutputTokens: 64000,
+      reasoningConfig: { supportsReasoning: true, paramFormat: 'budget_tokens', defaultBudget: 4096, maxBudget: 64000 },
+    },
+    'claude-3-5-sonnet': { contextWindow: 200000, maxOutputTokens: 8192 },
+    'claude-3-5-haiku': { contextWindow: 200000, maxOutputTokens: 8192 },
+    'claude-3-opus': { contextWindow: 200000, maxOutputTokens: 4096 },
+    'claude-3-haiku': { contextWindow: 200000, maxOutputTokens: 4096 },
+  },
+  deepseek: {
+    'deepseek-chat': { contextWindow: 64000, maxOutputTokens: 8192 },
+    'deepseek-reasoner': {
+      contextWindow: 64000,
+      maxOutputTokens: 8192,
+      reasoningConfig: { supportsReasoning: true, paramFormat: 'boolean' },
+    },
+    'deepseek-coder': { contextWindow: 16384, maxOutputTokens: 4096 },
+  },
+  google: {
+    'gemini-2.0-flash': { contextWindow: 1048576, maxOutputTokens: 8192 },
+    'gemini-2.0-flash-thinking-exp': {
+      contextWindow: 1048576,
+      maxOutputTokens: 65536,
+      reasoningConfig: { supportsReasoning: true, paramFormat: 'budget_tokens', defaultBudget: 8192, maxBudget: 65536 },
+    },
+    'gemini-2.0-flash-lite': { contextWindow: 1048576, maxOutputTokens: 8192 },
+    'gemini-1.5-pro': { contextWindow: 2097152, maxOutputTokens: 8192 },
+    'gemini-1.5-flash': { contextWindow: 1048576, maxOutputTokens: 8192 },
+    'gemini-1.5-flash-8b': { contextWindow: 1048576, maxOutputTokens: 8192 },
+  },
+  groq: {
+    'llama-3.3-70b-versatile': { contextWindow: 131072, maxOutputTokens: 32768 },
+    'llama-3.3-70b-specdec': { contextWindow: 8192, maxOutputTokens: 8192 },
+    'llama-3.1-70b-versatile': { contextWindow: 131072, maxOutputTokens: 32768 },
+    'llama-3.1-8b-instant': { contextWindow: 131072, maxOutputTokens: 8192 },
+    'llama3-70b-8192': { contextWindow: 8192, maxOutputTokens: 8192 },
+    'llama3-8b-8192': { contextWindow: 8192, maxOutputTokens: 8192 },
+    'mixtral-8x7b-32768': { contextWindow: 32768, maxOutputTokens: 32768 },
+    'gemma2-9b-it': { contextWindow: 8192, maxOutputTokens: 8192 },
+    'deepseek-r1-distill-llama-70b': {
+      contextWindow: 131072,
+      maxOutputTokens: 32768,
+      reasoningConfig: { supportsReasoning: true, paramFormat: 'budget_tokens', defaultBudget: 4096, maxBudget: 32768 },
+    },
+    'deepseek-r1-distill-qwen-32b': {
+      contextWindow: 131072,
+      maxOutputTokens: 32768,
+      reasoningConfig: { supportsReasoning: true, paramFormat: 'budget_tokens', defaultBudget: 4096, maxBudget: 32768 },
+    },
+    'qwen-2.5-32b': { contextWindow: 131072, maxOutputTokens: 8192 },
+    'qwen-2.5-coder-32b': { contextWindow: 131072, maxOutputTokens: 8192 },
+    'qwen-qwq-32b': {
+      contextWindow: 131072,
+      maxOutputTokens: 32768,
+      reasoningConfig: { supportsReasoning: true, paramFormat: 'budget_tokens', defaultBudget: 4096, maxBudget: 32768 },
+    },
+  },
+  xai: {
+    'grok-2': { contextWindow: 131072, maxOutputTokens: 8192 },
+    'grok-2-mini': { contextWindow: 131072, maxOutputTokens: 8192 },
+    'grok-2-vision': { contextWindow: 131072, maxOutputTokens: 8192 },
+    'grok-beta': { contextWindow: 131072, maxOutputTokens: 8192 },
+  },
+  mistral: {
+    'mistral-large': { contextWindow: 128000, maxOutputTokens: 8192 },
+    'mistral-small': { contextWindow: 128000, maxOutputTokens: 8192 },
+    'codestral': { contextWindow: 256000, maxOutputTokens: 8192 },
+    'ministral-8b': { contextWindow: 128000, maxOutputTokens: 8192 },
+    'ministral-3b': { contextWindow: 128000, maxOutputTokens: 8192 },
+    'pixtral-large': { contextWindow: 128000, maxOutputTokens: 8192 },
+    'pixtral-12b': { contextWindow: 128000, maxOutputTokens: 8192 },
+  },
+})
+
+export function lookupReferenceSpec(provider, modelId) {
+  if (typeof modelId !== 'string' || !modelId.trim()) return undefined
+  const provKey = String(provider || '').toLowerCase().trim()
+  const rawId = modelId.toLowerCase().trim()
+  const cleaned = cleanId(rawId)
+
+  // 1. Direct provider match
+  const table = REFERENCE_SPECS[provKey]
+  if (table) {
+    if (table[rawId]) return { ...table[rawId] }
+    if (table[cleaned]) return { ...table[cleaned] }
+    return undefined
+  }
+
+  // 2. Slash prefix (e.g. "anthropic/claude-3-7-sonnet" or "openai/o3-mini")
+  const slashIdx = rawId.indexOf('/')
+  if (slashIdx > 0) {
+    const subProv = rawId.slice(0, slashIdx)
+    const subId = rawId.slice(slashIdx + 1)
+    const subCleaned = cleanId(subId)
+    const subTable = REFERENCE_SPECS[subProv]
+    if (subTable) {
+      if (subTable[subId]) return { ...subTable[subId] }
+      if (subTable[subCleaned]) return { ...subTable[subCleaned] }
+    }
+  }
+
+  // 3. Fallback across all tables for aggregators (OpenRouter, ClineBot, CommandCode)
+  for (const [, t] of Object.entries(REFERENCE_SPECS)) {
+    if (t[rawId]) return { ...t[rawId] }
+    if (t[cleaned]) return { ...t[cleaned] }
+  }
+
+  return undefined
+}
+
+export function lookupReferenceLimits(provider, modelId) {
+  const spec = lookupReferenceSpec(provider, modelId)
+  if (!spec) return undefined
+  const res = {}
+  if (spec.contextWindow !== undefined) res.contextWindow = spec.contextWindow
+  if (spec.maxOutputTokens !== undefined) res.maxOutputTokens = spec.maxOutputTokens
+  return Object.keys(res).length > 0 ? res : undefined
+}
+
+export function lookupReferenceReasoning(provider, modelId) {
+  const spec = lookupReferenceSpec(provider, modelId)
+  return spec?.reasoningConfig ? structuredClone(spec.reasoningConfig) : undefined
+}
+
+export function lookupReferenceCompat(provider, modelId) {
+  const spec = lookupReferenceSpec(provider, modelId)
+  return spec?.compat ? structuredClone(spec.compat) : undefined
+}
+
+export function clampOutputTokens(modelOrLimit, requestedTokens) {
+  const limit = typeof modelOrLimit === 'number'
+    ? modelOrLimit
+    : Number(modelOrLimit?.maxOutputTokens ?? modelOrLimit?.maxTokens)
+  if (!Number.isFinite(limit) || limit <= 0) {
+    return { clamped: false, value: requestedTokens, limit: undefined }
+  }
+  const requested = Number(requestedTokens)
+  if (!Number.isFinite(requested) || requested <= 0) {
+    return { clamped: false, value: requestedTokens, limit }
+  }
+  if (requested > limit) {
+    return { clamped: true, value: limit, original: requested, limit }
+  }
+  return { clamped: false, value: requested, limit }
+}
+
+export function adaptReasoningPayload(model, userOptions = {}) {
+  const warnings = []
+  const payload = {}
+  const config = model?.reasoningConfig
+  const format = config?.paramFormat || 'none'
+  const compat = model?.compat || {}
+
+  if (format === 'effort') {
+    const effort = userOptions.reasoningEffort || config?.defaultEffort || 'medium'
+    payload.reasoning_effort = effort
+    if (compat.supportsTemperature === false && userOptions.temperature !== undefined && userOptions.temperature !== 1) {
+      warnings.push(`temperature ${userOptions.temperature} is not supported by model ${model.id}; omitted`)
+    }
+    if (compat.supportsMaxTokens === false && userOptions.maxTokens !== undefined) {
+      payload.max_completion_tokens = userOptions.maxTokens
+    }
+  } else if (format === 'budget_tokens') {
+    const maxBudget = config?.maxBudget || 64000
+    const defaultBudget = config?.defaultBudget || 4096
+    const budget = Math.min(Math.max(1, Number(userOptions.thinkingBudget || defaultBudget)), maxBudget)
+    if (model?.provider === 'google' || String(model?.id || '').startsWith('gemini')) {
+      payload.thinking_config = { thinking_budget: budget }
+    } else {
+      payload.thinking = { type: 'enabled', budget_tokens: budget }
+    }
+  } else if (format === 'boolean') {
+    payload.thinking = true
+  }
+
+  return { payload, warnings, format }
+}

package/lib/synchronizer-prober.js

@@ -1,3 +1,31 @@
+const SPARKLINE_BARS = [' ', '▂', '▃', '▄', '▅', '▆', '▇', '█']
+
+export function generateSparkline(values) {
+  if (!Array.isArray(values) || values.length === 0) return ''
+  const nums = values.filter((v) => typeof v === 'number' && Number.isFinite(v))
+  if (nums.length === 0) return ''
+  if (nums.length === 1) return '▄'
+  const min = Math.min(...nums)
+  const max = Math.max(...nums)
+  if (min === max) return '▄'.repeat(nums.length)
+  const range = max - min
+  return nums
+    .map((v) => {
+      const idx = Math.min(7, Math.max(0, Math.floor(((v - min) / range) * 7)))
+      return SPARKLINE_BARS[idx]
+    })
+    .join('')
+}
+
+export function classifySpeedTier(latencyMs, isOk = true) {
+  if (!isOk) return 'degraded'
+  if (typeof latencyMs !== 'number' || !Number.isFinite(latencyMs) || latencyMs <= 0) return 'unknown'
+  if (latencyMs < 300) return 'lightning'
+  if (latencyMs < 1200) return 'fast'
+  if (latencyMs <= 3000) return 'moderate'
+  return 'slow'
+}
+
 export function createModelProber({
   health,
   getProviderCatalog = () => [],
@@ -5,8 +33,32 @@ export function createModelProber({
   inferModel,
 } = {}) {
   const modelProbes = new Map()
+  const latencyHistory = new Map()
   const probeFn = probeModel ?? inferModel
 
+  function recordLatencyEntry(provider, model, { latencyMs, ttftMs, ok, status, error }) {
+    const key = `${provider}:${model}`
+    modelProbes.set(key, {
+      latencyMs,
+      ttftMs,
+      ok,
+      status,
+      timestamp: Date.now(),
+    })
+
+    const hist = latencyHistory.get(key) || []
+    hist.push({
+      timestamp: Date.now(),
+      latencyMs,
+      ttftMs,
+      ok,
+      status,
+      ...(error ? { error } : {}),
+    })
+    if (hist.length > 10) hist.shift()
+    latencyHistory.set(key, hist)
+  }
+
   async function tryModel({ provider, model, signal } = {}) {
     if (typeof provider !== 'string' || !provider) throw new Error('provider is required')
     if (typeof model !== 'string' || !model) throw new Error('model is required')
@@ -21,15 +73,11 @@ export function createModelProber({
         model,
         ok: false,
         latencyMs: 0,
+        ttftMs: 0,
         status: 'model_not_found',
         error: `model "${model}" not found in provider catalog`,
       }
-      modelProbes.set(`${provider}:${model}`, {
-        latencyMs: 0,
-        ok: false,
-        status: 'model_not_found',
-        timestamp: Date.now(),
-      })
+      recordLatencyEntry(provider, model, probeResult)
       return probeResult
     }
 
@@ -38,6 +86,9 @@ export function createModelProber({
       try {
         const probeRes = await probeFn({ provider, model, signal })
         const latencyMs = Math.max(1, Date.now() - start)
+        const ttftMs = typeof probeRes?.ttftMs === 'number'
+          ? probeRes.ttftMs
+          : (typeof probeRes?.metrics?.ttft === 'number' ? probeRes.metrics.ttft : Math.round(latencyMs * 0.45))
         const isOk = probeRes?.ok !== false
         const status = isOk ? 'ok' : (probeRes?.status || 'error')
         const errorMsg = isOk ? undefined : (probeRes?.error || 'inference probe failed')
@@ -46,33 +97,26 @@ export function createModelProber({
           model,
           ok: isOk,
           latencyMs,
+          ttftMs,
           status,
           ...(errorMsg ? { error: errorMsg } : {}),
         }
-        modelProbes.set(`${provider}:${model}`, {
-          latencyMs,
-          ok: isOk,
-          status,
-          timestamp: Date.now(),
-        })
+        recordLatencyEntry(provider, model, probeResult)
         return probeResult
       } catch (err) {
         const latencyMs = Math.max(1, Date.now() - start)
+        const ttftMs = Math.round(latencyMs * 0.45)
         const status = err?.status ? `http_${err.status}` : (err?.code || 'error')
         const probeResult = {
           provider,
           model,
           ok: false,
           latencyMs,
+          ttftMs,
           status,
           error: err?.message || 'inference probe failed',
         }
-        modelProbes.set(`${provider}:${model}`, {
-          latencyMs,
-          ok: false,
-          status,
-          timestamp: Date.now(),
-        })
+        recordLatencyEntry(provider, model, probeResult)
         return probeResult
       }
     }
@@ -82,6 +126,7 @@ export function createModelProber({
     const entry = healthResult?.results?.find((r) => r.provider === provider)
     const providerOk = entry?.status === 'ok'
     const latencyMs = Math.max(1, Date.now() - start)
+    const ttftMs = Math.round(latencyMs * 0.45)
     const status = !providerOk ? (entry?.status ?? 'error') : 'ok'
     const errorMsg = !providerOk ? (entry?.message || entry?.status || 'probe failed') : undefined
 
@@ -90,17 +135,12 @@ export function createModelProber({
       model,
       ok: providerOk,
       latencyMs,
+      ttftMs,
       status,
       ...(errorMsg ? { error: errorMsg } : {}),
     }
 
-    modelProbes.set(`${provider}:${model}`, {
-      latencyMs,
-      ok: providerOk,
-      status,
-      timestamp: Date.now(),
-    })
-
+    recordLatencyEntry(provider, model, probeResult)
     return probeResult
   }
 
@@ -110,7 +150,6 @@ export function createModelProber({
     const list = [...new Set(models.filter((m) => typeof m === 'string' && m.trim()).map((m) => m.trim()))].slice(0, 50)
 
     if (typeof probeFn === 'function') {
-      // Execute true model-specific probes with bounded concurrency
       const limit = Math.max(1, Math.min(10, Math.floor(Number(concurrency) || 4)))
       const results = new Array(list.length)
       let cursor = 0
@@ -131,7 +170,6 @@ export function createModelProber({
       }
     }
 
-    // If no probeFn provided, use provider health once (backwards compatibility)
     const start = Date.now()
     const healthResult = await health?.({ provider, signal })
     const entry = healthResult?.results?.find((r) => r.provider === provider)
@@ -139,6 +177,7 @@ export function createModelProber({
     const catalog = typeof getProviderCatalog === 'function' ? getProviderCatalog(provider) : []
     const hasCatalog = Array.isArray(catalog) && catalog.length > 0
     const baseLatency = Math.max(1, Date.now() - start)
+    const ttftMs = Math.round(baseLatency * 0.45)
 
     const results = list.map((model) => {
       const inCatalog = !hasCatalog || catalog.some((m) => (typeof m === 'string' ? m : m?.id) === model)
@@ -153,17 +192,12 @@ export function createModelProber({
         model,
         ok,
         latencyMs: baseLatency,
+        ttftMs,
         status,
         ...(errorMsg ? { error: errorMsg } : {}),
       }
 
-      modelProbes.set(`${provider}:${model}`, {
-        latencyMs: baseLatency,
-        ok,
-        status,
-        timestamp: Date.now(),
-      })
-
+      recordLatencyEntry(provider, model, itemResult)
       return itemResult
     })
 
@@ -179,9 +213,57 @@ export function createModelProber({
     return Object.fromEntries(modelProbes)
   }
 
+  function getLatencyHistory(provider, model) {
+    if (provider && model) {
+      return latencyHistory.get(`${provider}:${model}`) || []
+    }
+    return Object.fromEntries(latencyHistory)
+  }
+
+  function getLatencyRadar({ provider } = {}) {
+    const radar = []
+    for (const [key, hist] of latencyHistory.entries()) {
+      if (!Array.isArray(hist) || hist.length === 0) continue
+      const [entryProv, ...rest] = key.split(':')
+      const entryModel = rest.join(':')
+      if (provider && entryProv !== provider) continue
+
+      const latest = hist[hist.length - 1]
+      const latencies = hist.map((h) => h.latencyMs)
+      const avgLatencyMs = Math.round(latencies.reduce((acc, v) => acc + v, 0) / latencies.length)
+      const sorted = [...latencies].sort((a, b) => a - b)
+      const p95Idx = Math.min(sorted.length - 1, Math.floor(sorted.length * 0.95))
+      const p95LatencyMs = sorted[p95Idx]
+      const sparkline = generateSparkline(latencies)
+      const tier = classifySpeedTier(latest.latencyMs, latest.ok)
+
+      radar.push({
+        provider: entryProv,
+        model: entryModel,
+        latencyMs: latest.latencyMs,
+        ttftMs: latest.ttftMs,
+        avgLatencyMs,
+        p95LatencyMs,
+        tier,
+        sparkline,
+        history: latencies,
+        ok: latest.ok,
+        status: latest.status,
+        lastChecked: latest.timestamp,
+      })
+    }
+
+    return {
+      updatedAt: Date.now(),
+      radar,
+    }
+  }
+
   return {
     tryModel,
     batchTryModels,
     getModelProbes,
+    getLatencyHistory,
+    getLatencyRadar,
   }
-}
+}

package/lib/synchronizer.js

@@ -1,3 +1,5 @@
+import path from 'node:path'
+import { fetchPricingUpdates, lookupReferencePricing, getDynamicPricingMap } from './pricing-database.js'
 import { dispatchDiffNotifications, sendWebhookNotification } from "./diff-notifier.js"
 import { listApiKeyProviders } from './inventory.js'
 import { createProviderAdapterRegistry } from './adapter-registry.js'
@@ -583,6 +585,24 @@ export function createModelSynchronizer(ctx, { getConfig = () => ({}), saveConfi
     }
     return { provider, selectedModels, models: nextModels, availableModels: available, selectableModels: safeAvailable, applied: true }
   }
+  async function syncPricing() {
+    const config = getConfig() ?? {}
+    const timeoutMs = config.requestTimeoutMs ?? 15000
+    const cachePath = path.join(process.cwd(), 'pricing-cache.json')
+    return await fetchPricingUpdates({ timeoutMs, fetchFn: fetchImpl, cachePath, logger: ctx?.logger })
+  }
+
+  function getPricingInfo({ provider, model } = {}) {
+    if (provider && model) {
+      return { provider, model, pricing: lookupReferencePricing(provider, model) }
+    }
+    const dynamic = Object.fromEntries(getDynamicPricingMap())
+    return {
+      dynamicCount: Object.keys(dynamic).length,
+      sample: dynamic,
+    }
+  }
+
   const transfer = createConfigTransfer({
     getConfig,
     saveConfig,
@@ -613,6 +633,10 @@ export function createModelSynchronizer(ctx, { getConfig = () => ({}), saveConfi
     notifications: notificationLedger,
     updateNotification: updateNotificationState,
     rollbackHistory,
+    syncPricing,
+    getPricingInfo,
+    getLatencyRadar: prober.getLatencyRadar,
+    getLatencyHistory: prober.getLatencyHistory,
     testWebhook: async ({ url, secret, secretRef }) => {
       let resolvedSecret = secret || ''
       const targetRef = (secretRef || (typeof secret === 'string' && /^[A-Za-z_][A-Za-z0-9_]*$/.test(secret) ? secret : '')).trim()
@@ -629,6 +653,6 @@ export function createModelSynchronizer(ctx, { getConfig = () => ({}), saveConfi
       }
       return sendWebhookNotification(url, resolvedSecret, { event: 'model-sync.test', timestamp: Date.now(), test: true })
     },
-    status: () => ({ running: Boolean(running), lastRun, lastHealth, lastReport: structuredClone(lastReport), notifications: notificationLedger(), history: history(), policies: listPolicies(), lifecycle: structuredClone(getConfig()?.modelLifecycle ?? {}), aliases: structuredClone(getConfig()?.aliases ?? {}) }),
+    status: () => ({ running: Boolean(running), lastRun, lastHealth, lastReport: structuredClone(lastReport), notifications: notificationLedger(), history: history(), policies: listPolicies(), lifecycle: structuredClone(getConfig()?.modelLifecycle ?? {}), aliases: structuredClone(getConfig()?.aliases ?? {}), latencyRadar: prober.getLatencyRadar() }),
   })
 }

package/package.json

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