@goodandready/dsh-model-sync 0.5.17 → 0.5.18

package/lib/http.js

@@ -339,7 +339,25 @@ export function registerHttpApi(ctx, synchronizer, { getSchedulerStatus = () =>
       }
     }
     if (route === 'import') {
-      if (route === 'health-latency') {
+      if (req.method !== 'POST') return json(res, 405, { error: { code: 'method', message: 'POST only' } })
+      try {
+        const body = await readJson(req)
+        const result = await synchronizer.importConfig(body)
+        return json(res, 200, result)
+      } catch (error) {
+        const code = error?.code === 'INVALID_CONFIG' || error?.code === 'INVALID_POLICY' ? 400 : 500
+        return json(res, code, { error: { code: error?.code ?? 'import-failed', message: error instanceof Error ? error.message : String(error) } })
+      }
+    }
+    if (route === 'report') {
+      if (req.method !== 'GET') return json(res, 405, { error: { code: 'method', message: 'GET only' } })
+      return json(res, 200, { report: synchronizer.report() })
+    }
+    if (route === 'notifications') {
+      if (req.method !== 'GET') return json(res, 405, { error: { code: 'method', message: 'GET only' } })
+      return json(res, 200, { notifications: synchronizer.notifications(normalizeNotificationRequest(req.url)) })
+    }
+    if (route === 'health-latency') {
       if (req.method !== 'GET') return json(res, 405, { error: { code: 'method', message: 'GET only' } })
       try {
         const urlObj = new URL(req.url, 'http://127.0.0.1')
@@ -378,62 +396,159 @@ export function registerHttpApi(ctx, synchronizer, { getSchedulerStatus = () =>
       }
       return json(res, 405, { error: { code: 'method', message: 'GET or POST only' } })
     }
-    if (req.method !== 'POST') return json(res, 405, { error: { code: 'method', message: 'POST only' } })
+
+    // --- Capability Probing Routes ---
+    if (route === 'probe-provider') {
+      if (req.method !== 'POST') return json(res, 405, { error: { code: 'method', message: 'POST only' } })
       try {
         const body = await readJson(req)
-        const result = await synchronizer.importConfig(body)
+        const provider = body?.provider
+        const onlyNew = Boolean(body?.onlyNew)
+        const concurrency = Number(body?.concurrency) || 2
+        if (!provider) return json(res, 400, { error: { code: 'bad-request', message: 'provider is required' } })
+        const result = typeof synchronizer.probeProviderCapabilities === 'function'
+          ? await synchronizer.probeProviderCapabilities({ provider, onlyNew, concurrency })
+          : { provider, results: [] }
         return json(res, 200, result)
       } catch (error) {
-        const code = error?.code === 'INVALID_CONFIG' || error?.code === 'INVALID_POLICY' ? 400 : 500
-        return json(res, code, { error: { code: error?.code ?? 'import-failed', message: error instanceof Error ? error.message : String(error) } })
+        return json(res, 500, { error: { code: 'probe-failed', message: error instanceof Error ? error.message : String(error) } })
       }
     }
-    if (route === 'report') {
-      if (req.method !== 'GET') return json(res, 405, { error: { code: 'method', message: 'GET only' } })
-      return json(res, 200, { report: synchronizer.report() })
+    if (route === 'probe-all') {
+      if (req.method !== 'POST') return json(res, 405, { error: { code: 'method', message: 'POST only' } })
+      try {
+        const body = await readJson(req).catch(() => ({}))
+        const onlyNew = Boolean(body?.onlyNew)
+        const concurrency = Number(body?.concurrency) || 2
+        const result = typeof synchronizer.probeAllCapabilities === 'function'
+          ? await synchronizer.probeAllCapabilities({ onlyNew, concurrency })
+          : { results: [] }
+        return json(res, 200, result)
+      } catch (error) {
+        return json(res, 500, { error: { code: 'probe-failed', message: error instanceof Error ? error.message : String(error) } })
+      }
     }
-    if (route === 'notifications') {
+    if (route === 'probe-status') {
       if (req.method !== 'GET') return json(res, 405, { error: { code: 'method', message: 'GET only' } })
-      return json(res, 200, { notifications: synchronizer.notifications(normalizeNotificationRequest(req.url)) })
+      const result = typeof synchronizer.getCapabilityStatus === 'function'
+        ? synchronizer.getCapabilityStatus()
+        : { isProbing: false }
+      return json(res, 200, result)
     }
-    if (route === 'health-latency') {
+    if (route === 'probe-verified') {
       if (req.method !== 'GET') return json(res, 405, { error: { code: 'method', message: 'GET only' } })
       try {
         const urlObj = new URL(req.url, 'http://127.0.0.1')
         const provider = urlObj.searchParams.get('provider') || undefined
-        const report = typeof synchronizer.getLatencyRadar === 'function'
-          ? synchronizer.getLatencyRadar({ provider })
-          : { updatedAt: Date.now(), radar: [] }
-        return json(res, 200, report)
+        const model = urlObj.searchParams.get('model') || undefined
+        const result = typeof synchronizer.getVerifiedCapabilities === 'function'
+          ? synchronizer.getVerifiedCapabilities({ provider, model })
+          : {}
+        return json(res, 200, { verified: result })
       } catch (error) {
         return json(res, 400, { error: { code: 'bad-request', message: error instanceof Error ? error.message : String(error) } })
       }
     }
-    if (route === 'pricing') {
-      if (req.method === 'GET') {
-        try {
-          const urlObj = new URL(req.url, 'http://127.0.0.1')
-          const provider = urlObj.searchParams.get('provider') || undefined
-          const model = urlObj.searchParams.get('model') || undefined
-          const report = typeof synchronizer.getPricingInfo === 'function'
-            ? synchronizer.getPricingInfo({ provider, model })
-            : { pricing: {} }
-          return json(res, 200, report)
-        } catch (error) {
-          return json(res, 400, { error: { code: 'bad-request', message: error instanceof Error ? error.message : String(error) } })
-        }
+
+    // --- Ollama Management Hub Routes ---
+    if (route === 'ollama-ps') {
+      if (req.method !== 'GET') return json(res, 405, { error: { code: 'method', message: 'GET only' } })
+      try {
+        const urlObj = new URL(req.url, 'http://127.0.0.1')
+        const baseURL = urlObj.searchParams.get('baseURL') || undefined
+        const result = typeof synchronizer.fetchOllamaPs === 'function'
+          ? await synchronizer.fetchOllamaPs({ baseURL })
+          : { ok: false, running: [] }
+        return json(res, 200, result)
+      } catch (error) {
+        return json(res, 500, { error: { code: 'ollama-failed', message: error instanceof Error ? error.message : String(error) } })
       }
-      if (req.method === 'POST') {
-        try {
-          const result = typeof synchronizer.syncPricing === 'function'
-            ? await synchronizer.syncPricing()
-            : { updated: 0, source: 'reference' }
-          return json(res, 200, result)
-        } catch (error) {
-          return json(res, 500, { error: { code: 'sync-failed', message: error instanceof Error ? error.message : String(error) } })
-        }
+    }
+    if (route === 'ollama-tags') {
+      if (req.method !== 'GET') return json(res, 405, { error: { code: 'method', message: 'GET only' } })
+      try {
+        const urlObj = new URL(req.url, 'http://127.0.0.1')
+        const baseURL = urlObj.searchParams.get('baseURL') || undefined
+        const result = typeof synchronizer.fetchOllamaTags === 'function'
+          ? await synchronizer.fetchOllamaTags({ baseURL })
+          : { ok: false, models: [] }
+        return json(res, 200, result)
+      } catch (error) {
+        return json(res, 500, { error: { code: 'ollama-failed', message: error instanceof Error ? error.message : String(error) } })
+      }
+    }
+    if (route === 'ollama-info') {
+      if (req.method !== 'GET') return json(res, 405, { error: { code: 'method', message: 'GET only' } })
+      try {
+        const urlObj = new URL(req.url, 'http://127.0.0.1')
+        const model = urlObj.searchParams.get('model')
+        const baseURL = urlObj.searchParams.get('baseURL') || undefined
+        if (!model) return json(res, 400, { error: { code: 'bad-request', message: 'model is required' } })
+        const result = typeof synchronizer.fetchOllamaModelInfo === 'function'
+          ? await synchronizer.fetchOllamaModelInfo({ model, baseURL })
+          : { ok: false }
+        return json(res, 200, result)
+      } catch (error) {
+        return json(res, 500, { error: { code: 'ollama-failed', message: error instanceof Error ? error.message : String(error) } })
+      }
+    }
+    if (route === 'ollama-pull') {
+      if (req.method !== 'POST') return json(res, 405, { error: { code: 'method', message: 'POST only' } })
+      try {
+        const body = await readJson(req)
+        const model = body?.model
+        const baseURL = body?.baseURL
+        if (!model) return json(res, 400, { error: { code: 'bad-request', message: 'model is required' } })
+        const result = typeof synchronizer.startOllamaPull === 'function'
+          ? synchronizer.startOllamaPull({ model, baseURL })
+          : { started: false }
+        return json(res, 200, result)
+      } catch (error) {
+        return json(res, 500, { error: { code: 'ollama-failed', message: error instanceof Error ? error.message : String(error) } })
+      }
+    }
+    if (route === 'ollama-pull-status') {
+      if (req.method !== 'GET') return json(res, 405, { error: { code: 'method', message: 'GET only' } })
+      try {
+        const urlObj = new URL(req.url, 'http://127.0.0.1')
+        const model = urlObj.searchParams.get('model') || undefined
+        const result = typeof synchronizer.getOllamaPullStatus === 'function'
+          ? synchronizer.getOllamaPullStatus(model)
+          : null
+        return json(res, 200, { status: result })
+      } catch (error) {
+        return json(res, 400, { error: { code: 'bad-request', message: error instanceof Error ? error.message : String(error) } })
+      }
+    }
+    if (route === 'ollama-unload') {
+      if (req.method !== 'POST') return json(res, 405, { error: { code: 'method', message: 'POST only' } })
+      try {
+        const body = await readJson(req)
+        const model = body?.model
+        const baseURL = body?.baseURL
+        if (!model) return json(res, 400, { error: { code: 'bad-request', message: 'model is required' } })
+        const result = typeof synchronizer.unloadOllamaModel === 'function'
+          ? await synchronizer.unloadOllamaModel({ model, baseURL })
+          : { ok: false }
+        return json(res, 200, result)
+      } catch (error) {
+        return json(res, 500, { error: { code: 'ollama-failed', message: error instanceof Error ? error.message : String(error) } })
+      }
+    }
+    if (route === 'ollama-delete') {
+      if (req.method !== 'POST' && req.method !== 'DELETE') return json(res, 405, { error: { code: 'method', message: 'POST or DELETE only' } })
+      try {
+        const body = await readJson(req)
+        const model = body?.model
+        const baseURL = body?.baseURL
+        if (!model) return json(res, 400, { error: { code: 'bad-request', message: 'model is required' } })
+        const result = typeof synchronizer.deleteOllamaModel === 'function'
+          ? await synchronizer.deleteOllamaModel({ model, baseURL })
+          : { ok: false }
+        return json(res, 200, result)
+      } catch (error) {
+        return json(res, 500, { error: { code: 'ollama-failed', message: error instanceof Error ? error.message : String(error) } })
       }
-      return json(res, 405, { error: { code: 'method', message: 'GET or POST only' } })
     }
     if (req.method !== 'POST') return json(res, 405, { error: { code: 'method', message: 'POST only' } })
     let options
@@ -503,5 +618,16 @@ export function registerHttpApi(ctx, synchronizer, { getSchedulerStatus = () =>
     ctx.webServer.register({ kind: 'exact', path: BASE + '/webhook/test', handler: makeHandler('webhook-test') }),
     ctx.webServer.register({ kind: 'exact', path: BASE + '/health/latency', handler: makeHandler('health-latency') }),
     ctx.webServer.register({ kind: 'exact', path: BASE + '/pricing', handler: makeHandler('pricing') }),
+    ctx.webServer.register({ kind: 'exact', path: BASE + '/probe/provider', handler: makeHandler('probe-provider') }),
+    ctx.webServer.register({ kind: 'exact', path: BASE + '/probe/all', handler: makeHandler('probe-all') }),
+    ctx.webServer.register({ kind: 'exact', path: BASE + '/probe/status', handler: makeHandler('probe-status') }),
+    ctx.webServer.register({ kind: 'exact', path: BASE + '/probe/verified', handler: makeHandler('probe-verified') }),
+    ctx.webServer.register({ kind: 'exact', path: BASE + '/ollama/ps', handler: makeHandler('ollama-ps') }),
+    ctx.webServer.register({ kind: 'exact', path: BASE + '/ollama/tags', handler: makeHandler('ollama-tags') }),
+    ctx.webServer.register({ kind: 'exact', path: BASE + '/ollama/info', handler: makeHandler('ollama-info') }),
+    ctx.webServer.register({ kind: 'exact', path: BASE + '/ollama/pull', handler: makeHandler('ollama-pull') }),
+    ctx.webServer.register({ kind: 'exact', path: BASE + '/ollama/pull/status', handler: makeHandler('ollama-pull-status') }),
+    ctx.webServer.register({ kind: 'exact', path: BASE + '/ollama/unload', handler: makeHandler('ollama-unload') }),
+    ctx.webServer.register({ kind: 'exact', path: BASE + '/ollama/delete', handler: makeHandler('ollama-delete') }),
   ]
 }

package/lib/inventory.js

@@ -21,6 +21,7 @@ export const API_KEY_PROVIDER_IDS = Object.freeze([
   'moonshotai',
   'moonshotai-cn',
   'nvidia',
+  'ollama',
   'openai',
   'opencode',
   'opencode-go',

package/lib/ollama-manager.js

@@ -0,0 +1,330 @@
+export function normalizeOllamaURL(url) {
+  let base = typeof url === 'string' && url.trim() ? url.trim() : 'http://127.0.0.1:11434'
+  base = base.replace(/\/+$/, '')
+  if (base.endsWith('/v1')) base = base.slice(0, -3)
+  return base
+}
+
+export function formatBytes(bytes) {
+  if (typeof bytes !== 'number' || !Number.isFinite(bytes) || bytes <= 0) return '0 B'
+  const units = ['B', 'KB', 'MB', 'GB', 'TB']
+  const i = Math.min(units.length - 1, Math.floor(Math.log(bytes) / Math.log(1024)))
+  const val = (bytes / Math.pow(1024, i)).toFixed(i === 0 ? 0 : 1)
+  return `${val} ${units[i]}`
+}
+
+export function createOllamaManager({ fetchImpl = globalThis.fetch } = {}) {
+  const activePulls = new Map()
+  const pullControllers = new Map()
+
+  async function fetchOllamaPs({ baseURL, signal, timeoutMs = 5000 } = {}) {
+    const base = normalizeOllamaURL(baseURL)
+    const url = `${base}/api/ps`
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), timeoutMs)
+    if (signal) signal.addEventListener('abort', () => controller.abort())
+
+    try {
+      const res = await fetchImpl(url, {
+        method: 'GET',
+        headers: { Accept: 'application/json' },
+        signal: controller.signal,
+      })
+      clearTimeout(timer)
+      if (!res.ok) {
+        return { ok: false, running: [], status: res.status, error: `HTTP ${res.status}` }
+      }
+      const data = await res.json()
+      const models = Array.isArray(data?.models) ? data.models : []
+      const running = models.map((m) => {
+        const sizeVram = m.size_vram || 0
+        const sizeTotal = m.size || 0
+        return {
+          name: m.name || m.model || '',
+          model: m.model || m.name || '',
+          size: sizeTotal,
+          sizeFormatted: formatBytes(sizeTotal),
+          sizeVram,
+          sizeVramFormatted: formatBytes(sizeVram),
+          expiresAt: m.expires_at || null,
+          details: {
+            format: m.details?.format || 'gguf',
+            family: m.details?.family || '',
+            families: m.details?.families || [],
+            parameterSize: m.details?.parameter_size || '',
+            quantizationLevel: m.details?.quantization_level || '',
+          },
+        }
+      })
+      return { ok: true, running }
+    } catch (err) {
+      clearTimeout(timer)
+      return { ok: false, running: [], error: err?.message || String(err) }
+    }
+  }
+
+  async function fetchOllamaTags({ baseURL, signal, timeoutMs = 5000 } = {}) {
+    const base = normalizeOllamaURL(baseURL)
+    const url = `${base}/api/tags`
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), timeoutMs)
+    if (signal) signal.addEventListener('abort', () => controller.abort())
+
+    try {
+      const res = await fetchImpl(url, {
+        method: 'GET',
+        headers: { Accept: 'application/json' },
+        signal: controller.signal,
+      })
+      clearTimeout(timer)
+      if (!res.ok) {
+        return { ok: false, models: [], status: res.status, error: `HTTP ${res.status}` }
+      }
+      const data = await res.json()
+      const models = (Array.isArray(data?.models) ? data.models : []).map((m) => ({
+        name: m.name || m.model || '',
+        model: m.model || m.name || '',
+        modifiedAt: m.modified_at || '',
+        size: m.size || 0,
+        sizeFormatted: formatBytes(m.size || 0),
+        digest: m.digest || '',
+        details: {
+          format: m.details?.format || 'gguf',
+          family: m.details?.family || '',
+          families: m.details?.families || [],
+          parameterSize: m.details?.parameter_size || '',
+          quantizationLevel: m.details?.quantization_level || '',
+        },
+      }))
+      return { ok: true, models }
+    } catch (err) {
+      clearTimeout(timer)
+      return { ok: false, models: [], error: err?.message || String(err) }
+    }
+  }
+
+  async function fetchOllamaModelInfo({ model, baseURL, signal, timeoutMs = 5000 } = {}) {
+    if (!model || typeof model !== 'string') throw new Error('model is required')
+    const base = normalizeOllamaURL(baseURL)
+    const url = `${base}/api/show`
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), timeoutMs)
+    if (signal) signal.addEventListener('abort', () => controller.abort())
+
+    try {
+      const res = await fetchImpl(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+        body: JSON.stringify({ name: model }),
+        signal: controller.signal,
+      })
+      clearTimeout(timer)
+      if (!res.ok) {
+        return { ok: false, error: `HTTP ${res.status}` }
+      }
+      const data = await res.json()
+      const modelInfo = data?.model_info || {}
+      let contextWindow = 4096
+      for (const [k, v] of Object.entries(modelInfo)) {
+        if (k.endsWith('.context_length') && typeof v === 'number') {
+          contextWindow = v
+          break
+        }
+      }
+      return {
+        ok: true,
+        model,
+        details: data?.details || {},
+        parameters: data?.parameters || '',
+        template: data?.template || '',
+        modelfile: data?.modelfile || '',
+        contextWindow,
+      }
+    } catch (err) {
+      clearTimeout(timer)
+      return { ok: false, model, error: err?.message || String(err) }
+    }
+  }
+
+  async function unloadOllamaModel({ model, baseURL, signal, timeoutMs = 5000 } = {}) {
+    if (!model || typeof model !== 'string') throw new Error('model is required')
+    const base = normalizeOllamaURL(baseURL)
+    const url = `${base}/api/generate`
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), timeoutMs)
+    if (signal) signal.addEventListener('abort', () => controller.abort())
+
+    try {
+      const res = await fetchImpl(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+        body: JSON.stringify({ model, keep_alive: 0 }),
+        signal: controller.signal,
+      })
+      clearTimeout(timer)
+      if (!res.ok) {
+        return { ok: false, error: `HTTP ${res.status}` }
+      }
+      return { ok: true, unloaded: model, message: `Model "${model}" unloaded from VRAM` }
+    } catch (err) {
+      clearTimeout(timer)
+      return { ok: false, model, error: err?.message || String(err) }
+    }
+  }
+
+  async function deleteOllamaModel({ model, baseURL, signal, timeoutMs = 5000 } = {}) {
+    if (!model || typeof model !== 'string') throw new Error('model is required')
+    const base = normalizeOllamaURL(baseURL)
+    const url = `${base}/api/delete`
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), timeoutMs)
+    if (signal) signal.addEventListener('abort', () => controller.abort())
+
+    try {
+      const res = await fetchImpl(url, {
+        method: 'DELETE',
+        headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+        body: JSON.stringify({ name: model }),
+        signal: controller.signal,
+      })
+      clearTimeout(timer)
+      if (!res.ok) {
+        return { ok: false, error: `HTTP ${res.status}` }
+      }
+      return { ok: true, deleted: model, message: `Model "${model}" deleted` }
+    } catch (err) {
+      clearTimeout(timer)
+      return { ok: false, model, error: err?.message || String(err) }
+    }
+  }
+
+  function startOllamaPull({ model, baseURL } = {}) {
+    if (!model || typeof model !== 'string') throw new Error('model is required')
+    const cleanModel = model.trim()
+    const base = normalizeOllamaURL(baseURL)
+
+    const existing = activePulls.get(cleanModel)
+    if (existing && !existing.done) {
+      return { started: false, alreadyRunning: true, status: existing }
+    }
+
+    const state = {
+      model: cleanModel,
+      baseURL: base,
+      status: 'starting',
+      completed: 0,
+      total: 0,
+      percent: 0,
+      completedFormatted: '0 B',
+      totalFormatted: '0 B',
+      done: false,
+      error: null,
+      startedAt: Date.now(),
+      updatedAt: Date.now(),
+    }
+
+    activePulls.set(cleanModel, state)
+    const controller = new AbortController()
+    pullControllers.set(cleanModel, controller)
+
+    // Execute streaming pull in background
+    ;(async () => {
+      try {
+        const res = await fetchImpl(`${base}/api/pull`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ name: cleanModel, stream: true }),
+          signal: controller.signal,
+        })
+
+        if (!res.ok) {
+          state.done = true
+          state.error = `HTTP ${res.status}`
+          state.status = 'error'
+          state.updatedAt = Date.now()
+          return
+        }
+
+        if (res.body && typeof res.body.getReader === 'function') {
+          const reader = res.body.getReader()
+          const decoder = new TextDecoder()
+          let buffer = ''
+
+          while (true) {
+            const { done, value } = await reader.read()
+            if (done) break
+            buffer += decoder.decode(value, { stream: true })
+            const lines = buffer.split('\n')
+            buffer = lines.pop() || ''
+
+            for (const line of lines) {
+              const trimmed = line.trim()
+              if (!trimmed) continue
+              try {
+                const chunk = JSON.parse(trimmed)
+                if (chunk.status) state.status = chunk.status
+                if (typeof chunk.completed === 'number') state.completed = chunk.completed
+                if (typeof chunk.total === 'number') state.total = chunk.total
+                if (state.total > 0) {
+                  state.percent = Math.min(100, Math.round((state.completed / state.total) * 100))
+                }
+                state.completedFormatted = formatBytes(state.completed)
+                state.totalFormatted = formatBytes(state.total)
+                state.updatedAt = Date.now()
+              } catch {
+                // Ignore parse errors on partial stream lines
+              }
+            }
+          }
+        }
+
+        state.done = true
+        state.status = 'success'
+        state.percent = 100
+        state.updatedAt = Date.now()
+      } catch (err) {
+        state.done = true
+        state.status = 'error'
+        state.error = err?.message || String(err)
+        state.updatedAt = Date.now()
+      } finally {
+        pullControllers.delete(cleanModel)
+      }
+    })()
+
+    return { started: true, status: state }
+  }
+
+  function getOllamaPullStatus(model) {
+    if (model) return activePulls.get(model) || null
+    return Object.fromEntries(activePulls.entries())
+  }
+
+  function cancelOllamaPull(model) {
+    if (!model) return false
+    const ctrl = pullControllers.get(model)
+    if (ctrl) {
+      ctrl.abort()
+      pullControllers.delete(model)
+      const st = activePulls.get(model)
+      if (st) {
+        st.done = true
+        st.status = 'cancelled'
+        st.updatedAt = Date.now()
+      }
+      return true
+    }
+    return false
+  }
+
+  return {
+    fetchOllamaPs,
+    fetchOllamaTags,
+    fetchOllamaModelInfo,
+    unloadOllamaModel,
+    deleteOllamaModel,
+    startOllamaPull,
+    getOllamaPullStatus,
+    cancelOllamaPull,
+  }
+}

package/lib/provider-service.js

@@ -88,6 +88,19 @@ export function createProviderService(ctx) {
     return isCuratedModel(found || { provider, id: modelId })
   }
 
+
+  const getVerifiedCapabilities = (provider, modelId) => {
+    try {
+      const runner = ctx?.reflect?.get?.('modelSyncRunner') ?? (typeof ctx?.get === 'function' ? ctx.get('modelSyncRunner') : undefined)
+      if (runner && typeof runner.getVerifiedCapabilities === 'function') {
+        return runner.getVerifiedCapabilities({ provider, model: modelId })
+      }
+    } catch {
+      // ignore
+    }
+    return null
+  }
+
   return Object.freeze({
     listProviders,
     getProvider,
@@ -98,5 +111,6 @@ export function createProviderService(ctx) {
     getPricing,
     getTags,
     isCurated,
+    getVerifiedCapabilities,
   })
 }