@goodandready/dsh-model-sync 0.5.16 → 0.5.18

package/lib/http.js

@@ -357,6 +357,199 @@ export function registerHttpApi(ctx, synchronizer, { getSchedulerStatus = () =>
       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')
+        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)
+      } 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) } })
+        }
+      }
+      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) } })
+        }
+      }
+      return json(res, 405, { error: { code: 'method', message: 'GET or 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 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) {
+        return json(res, 500, { error: { code: 'probe-failed', message: error instanceof Error ? error.message : String(error) } })
+      }
+    }
+    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 === 'probe-status') {
+      if (req.method !== 'GET') return json(res, 405, { error: { code: 'method', message: 'GET only' } })
+      const result = typeof synchronizer.getCapabilityStatus === 'function'
+        ? synchronizer.getCapabilityStatus()
+        : { isProbing: false }
+      return json(res, 200, result)
+    }
+    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 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) } })
+      }
+    }
+
+    // --- 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 (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) } })
+      }
+    }
     if (req.method !== 'POST') return json(res, 405, { error: { code: 'method', message: 'POST only' } })
     let options
     try {
@@ -423,5 +616,18 @@ export function registerHttpApi(ctx, synchronizer, { getSchedulerStatus = () =>
     ctx.webServer.register({ kind: 'exact', path: BASE + '/notifications/read', handler: makeHandler('notification-read') }),
     ctx.webServer.register({ kind: 'exact', path: BASE + '/notifications/acknowledge', handler: makeHandler('notification-acknowledge') }),
     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/models.js

@@ -365,6 +365,120 @@ function normalizeReasoningConfig(provider, row, id, capabilities) {
   return source
 }
 
+export function deriveModelTags(model) {
+  if (!model || typeof model !== "object") return []
+  const tags = new Set(Array.isArray(model.tags) ? model.tags.filter((t) => typeof t === "string" && t.trim()).map((t) => t.trim().toLowerCase()) : [])
+  const idLower = String(model.id || "").toLowerCase()
+  const nameLower = String(model.name || "").toLowerCase()
+  const provLower = String(model.provider || "").toLowerCase()
+  const capabilities = model.capabilities || {}
+
+  // 1. coding
+  if (
+    capabilities.code === true ||
+    idLower.includes("coder") ||
+    idLower.includes("codestral") ||
+    idLower.includes("starcoder") ||
+    idLower.includes("deepseek-coder") ||
+    idLower.includes("claude-3-7-sonnet") ||
+    idLower.includes("claude-3-5-sonnet") ||
+    idLower.includes("kimi-k2.7-code") ||
+    idLower.includes("qwen-2.5-coder") ||
+    idLower.includes("qwen2.5-coder") ||
+    (/(^|[_-])(code|dev|prog)($|[_-])/i.test(idLower)) ||
+    (/(^|[_-])(code|coder)($|[_-])/i.test(nameLower))
+  ) {
+    tags.add("coding")
+  }
+
+  // 2. reasoning
+  if (
+    model.reasoningConfig?.supportsReasoning === true ||
+    capabilities.reasoning === true ||
+    /(^|[_-])(o1|o3|r1|qwq)($|[_-])/i.test(idLower) ||
+    idLower.includes("reasoner") ||
+    idLower.includes("deepseek-r1") ||
+    idLower.includes("thinking") ||
+    idLower.includes("-r1")
+  ) {
+    tags.add("reasoning")
+  }
+
+  // 3. fast
+  if (
+    provLower === "groq" ||
+    provLower === "cerebras" ||
+    idLower.includes("flash") ||
+    idLower.includes("mini") ||
+    idLower.includes("instant") ||
+    idLower.includes("haiku") ||
+    idLower.includes("small") ||
+    idLower.includes("8b") ||
+    idLower.includes("3b") ||
+    idLower.includes("1b") ||
+    idLower.includes("turbo") ||
+    idLower.includes("lite") ||
+    idLower.includes("nano")
+  ) {
+    tags.add("fast")
+  }
+
+  // 4. vision
+  if (
+    capabilities.vision === true ||
+    (Array.isArray(model.input) && model.input.includes("image")) ||
+    idLower.includes("vision") ||
+    idLower.includes("vl") ||
+    idLower.includes("pixtral") ||
+    idLower.includes("gemini") ||
+    idLower.includes("claude-3") ||
+    idLower.includes("4o")
+  ) {
+    tags.add("vision")
+  }
+
+  // 5. long-context (>= 128k tokens)
+  if (typeof model.contextWindow === "number" && model.contextWindow >= 128000) {
+    tags.add("long-context")
+  }
+
+  return [...tags].sort()
+}
+
+export function isCuratedModel(model) {
+  if (!model || typeof model !== "object") return false
+  if (model.lifecycle?.deprecated) return false
+  const id = String(model.id || "").toLowerCase()
+  if (/-(202\d{5}|202\d-\d{2}-\d{2}|\d{4})$/.test(id) && !id.includes("claude-3-7") && !id.includes("claude-3-5")) {
+    return false
+  }
+  if (id.includes("-0314") || id.includes("-0613") || id.includes("-1106") || id.includes("-0125")) {
+    return false
+  }
+
+  const curatedIds = [
+    "claude-3-7-sonnet", "claude-3-5-sonnet", "claude-3-5-haiku",
+    "gpt-4o", "gpt-4o-mini", "o1", "o3-mini",
+    "deepseek-chat", "deepseek-reasoner", "deepseek-v3", "deepseek-r1",
+    "gemini-2.0-flash", "gemini-1.5-pro", "gemini-1.5-flash",
+    "llama-3.3-70b-versatile", "llama-3.1-8b-instant", "llama-3.1-70b-versatile",
+    "qwen-2.5-coder-32b", "qwen-2.5-72b", "qwq-32b",
+    "mistral-large", "codestral", "pixtral-large",
+    "kimi-k2.7-code"
+  ]
+
+  for (const c of curatedIds) {
+    if (id === c || id.endsWith("/" + c) || id.includes(c)) return true
+  }
+
+  const tags = model.tags || deriveModelTags(model)
+  if (tags.includes("coding") && tags.includes("reasoning") && tags.includes("long-context")) {
+    return true
+  }
+
+  return false
+}
+
 export function normalizeModel(provider, row) {
   if (typeof row === 'string') {
     row = { id: row }

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