@goodandready/dsh-model-sync 0.5.10 → 0.5.11

package/lib/adapter-registry.js

@@ -219,6 +219,9 @@ async function requestSpecific(profile, descriptor, { resolveCredential, fetchIm
   }
   if (response.status === 304) return response
   if (!response.ok) {
+    if (typeof response.body?.cancel === "function") {
+      try { await response.body.cancel() } catch (_err) { /* best-effort cancel */ }
+    }
     const error = catalogRequestError(response.status, response)
     error.adapterCode = [401, 403].includes(response.status) ? 'auth' : response.status === 429 ? 'rate-limit' : 'http'
     throw error
@@ -231,6 +234,9 @@ async function fetchSpecific(profile, descriptor, options) {
   try {
     const response = await requestSpecific(profile, descriptor, options)
     if (response.status === 304) {
+      if (typeof response.body?.cancel === "function") {
+        try { await response.body.cancel() } catch (_err) { /* best-effort cancel */ }
+      }
       return { notModified: true, etag: response.headers?.get?.('etag') || options.etag, lastModified: response.headers?.get?.('last-modified') || options.lastModified }
     }
     const respEtag = response.headers?.get?.('etag') || undefined

package/lib/alias-resolver.js

@@ -53,6 +53,16 @@ function estimateLatency(provider, model, probes = {}) {
   return Math.round(base)
 }
 
+function isProviderEligible(provider, { healthResults = [], isCircuitOpen = () => false } = {}) {
+  if (isCircuitOpen(provider)) return false
+  const health = healthResults.find((h) => h.provider === provider)
+  if (health) {
+    if (health.ok === false) return false
+    if (health.status && health.status !== "ok") return false
+  }
+  return true
+}
+
 export function resolveAlias(aliasName, {
   aliases = {},
   modelCatalogs = {},
@@ -72,7 +82,8 @@ export function resolveAlias(aliasName, {
     for (let i = 0; i < custom.targets.length; i++) {
       const target = custom.targets[i]
       const circuitBlocked = isCircuitOpen(target.provider)
-      const healthFail = healthResults.find((h) => h.provider === target.provider && h.status === 'error')
+      const healthEntry = healthResults.find((h) => h.provider === target.provider)
+      const healthFail = Boolean(healthEntry && (healthEntry.status === "error" || healthEntry.status === "circuit-open" || healthEntry.ok === false || (healthEntry.status && healthEntry.status !== "ok")))
       if (circuitBlocked || healthFail) {
         skipped.push({ ...target, reason: circuitBlocked ? 'circuit_open' : 'health_failed' })
         continue
@@ -101,12 +112,15 @@ export function resolveAlias(aliasName, {
   // 2. Static explicit alias
   if (custom?.provider && custom?.model && !custom.strategy) {
     const circuitBlocked = isCircuitOpen(custom.provider)
+    const healthEntry = healthResults.find((h) => h.provider === custom.provider)
+    const healthFailed = Boolean(healthEntry && (healthEntry.status === "error" || healthEntry.status === "circuit-open" || healthEntry.ok === false || (healthEntry.status && healthEntry.status !== "ok")))
     return {
       alias: clean,
       provider: custom.provider,
       model: custom.model,
       fallbackUsed: false,
       ...(circuitBlocked ? { warning: 'circuit_open', circuitOpen: true } : {}),
+      ...(healthFailed ? { warning: 'health_failed', healthFailed: true } : {}),
     }
   }
 
@@ -125,7 +139,7 @@ export function resolveAlias(aliasName, {
     }
     const available = []
     for (const [provider, models] of Object.entries(modelCatalogs)) {
-      if (isCircuitOpen(provider)) continue
+      if (!isProviderEligible(provider, { healthResults, isCircuitOpen })) continue
       if (!Array.isArray(models)) continue
       for (const m of models) {
         if (!m?.id) continue

package/lib/diff-notifier.js

@@ -177,18 +177,29 @@ export async function sendWebhookNotification(url, secret, payload, { fetchImpl
   const controller = typeof AbortController !== "undefined" ? new AbortController() : null
   const timer = controller ? setTimeout(() => controller.abort(new Error("Webhook request timed out")), timeoutMs) : null
 
+  let res = null
   try {
-    const res = await fetchImpl(parsedUrl.toString(), {
+    res = await fetchImpl(parsedUrl.toString(), {
       method: "POST",
       headers,
       body,
       ...(controller ? { signal: controller.signal } : {}),
     })
+    if (typeof res?.body?.cancel === "function") {
+      try { await res.body.cancel() } catch (_err) { /* best-effort cancel */ }
+    } else if (typeof res?.arrayBuffer === "function") {
+      try { await res.arrayBuffer() } catch (_err) { /* best-effort cancel */ }
+    }
     if (timer) clearTimeout(timer)
     return { ok: res.ok, status: res.status }
   } catch (err) {
+    if (res && typeof res.body?.cancel === "function") {
+      try { await res.body.cancel() } catch (_err) { /* best-effort cancel */ }
+    }
     if (timer) clearTimeout(timer)
     return { ok: false, error: err?.message || String(err) }
+  } finally {
+    if (timer) clearTimeout(timer)
   }
 }
 

package/lib/generic-adapter.js

@@ -109,7 +109,12 @@ async function resolveGenericRequest(profile, { resolveCredential, fetchImpl, si
   const apiKey = keyRef ? await resolveCredential(keyRef) : ''
   const response = await fetchImpl(endpointFor(profile.baseURL), { headers: requestHeaders(apiKey, etag, lastModified), signal })
   if (response.status === 304) return response
-  if (!response.ok) throw catalogRequestError(response.status, response)
+  if (!response.ok) {
+    if (typeof response.body?.cancel === "function") {
+      try { await response.body.cancel() } catch (_err) { /* best-effort cancel */ } 
+    }
+    throw catalogRequestError(response.status, response)
+  }
   return response
 }
 
@@ -125,6 +130,9 @@ export async function discoverOpenAIModels(profile, {
   }
   const response = await resolveGenericRequest(profile, { resolveCredential, fetchImpl, signal, etag, lastModified })
   if (response.status === 304) {
+    if (typeof response.body?.cancel === "function") {
+      try { await response.body.cancel() } catch (_err) { /* best-effort cancel */ }
+    }
     return { notModified: true, etag: response.headers?.get?.('etag') || etag, lastModified: response.headers?.get?.('last-modified') || lastModified }
   }
   const respEtag = response.headers?.get?.('etag') || undefined

package/lib/inventory.js

@@ -66,17 +66,25 @@ export function listApiKeyProviders(llm, settings) {
   const seen = new Set()
   for (const entry of directory) {
     let profile = profiles[entry.provider]
+    let configured = Object.prototype.hasOwnProperty.call(profiles, entry.provider)
     if (!profile && (entry.provider === 'commandcode' || entry.settingsNs === 'llm-commandcode')) {
       const cc = sectionOf(settings, 'llm-commandcode')
-      profile = {
-        apiKeyEnv: cc?.apiKeyEnv ?? 'COMMANDCODE_API_KEY',
-        credentialRef: cc?.apiKeyEnv ?? 'COMMANDCODE_API_KEY',
-        baseURL: cc?.apiBase ?? 'https://api.commandcode.ai',
-        models: cc?.visibleModels ?? [],
+      if (cc && typeof cc === 'object' && Object.keys(cc).length > 0) {
+        const hasCredentials = Boolean(cc.apiKey || cc.apiKeyEnv || cc.credentialRef || cc.apiKeyRef)
+        const hasModels = Array.isArray(cc.visibleModels) && cc.visibleModels.length > 0
+        const hasBase = Boolean(cc.apiBase)
+        if (hasCredentials || hasModels || hasBase) {
+          configured = true
+          profile = {
+            apiKeyEnv: cc.apiKeyEnv ?? (hasCredentials ? 'COMMANDCODE_API_KEY' : ''),
+            credentialRef: cc.apiKeyEnv ?? cc.credentialRef ?? '',
+            baseURL: cc.apiBase ?? 'https://api.commandcode.ai',
+            models: cc.visibleModels ?? [],
+          }
+        }
       }
-    } else {
-      profile = profile ?? {}
     }
+    profile = profile ?? {}
     if (!isApiKeyProvider(entry, profile) || seen.has(entry.provider)) continue
     seen.add(entry.provider)
     out.push({
@@ -85,7 +93,7 @@ export function listApiKeyProviders(llm, settings) {
       settingsNs: entry.settingsNs,
       settingsPath: [...(entry.settingsPath ?? [])],
       declared: entry.declared === true,
-      configured: Object.prototype.hasOwnProperty.call(profiles, entry.provider),
+      configured,
       live: live.has(entry.provider),
       apiKeyEnv: profile.apiKeyEnv ?? profile.credentialRef ?? profile.apiKeyRef ?? '',
       credentialRef: profile.credentialRef ?? profile.apiKeyRef ?? profile.apiKeyEnv ?? '',

package/lib/models.js

@@ -140,13 +140,13 @@ function normalizeCapabilities(row) {
 
   // Model ID & name heuristic markers for modern models
   const idStr = String(row?.id ?? row?.slug ?? row?.model ?? '').toLowerCase()
-  if (!result.reasoning && (/(^|[_-])(o1|o3|r1|qwq|deepseek-r1|thinking)($|[_-])/i.test(idStr) || idStr.includes('-r1') || idStr.includes('reasoning') || idStr.includes('thinking'))) {
+  if (result.reasoning === undefined && (/(^|[_-])(o1|o3|r1|qwq|deepseek-r1|thinking)($|[_-])/i.test(idStr) || idStr.includes('-r1') || idStr.includes('reasoning') || idStr.includes('thinking'))) {
     result.reasoning = true
   }
-  if (!result.code && (/(^|[_-])(coder|code|starcoder|codellama)($|[_-])/i.test(idStr) || idStr.includes('coder') || idStr.includes('code-'))) {
+  if (result.code === undefined && (/(^|[_-])(coder|code|starcoder|codellama)($|[_-])/i.test(idStr) || idStr.includes('coder') || idStr.includes('code-'))) {
     result.code = true
   }
-  if (!result.vision && (/(^|[_-])(vision|vl)($|[_-])/i.test(idStr) || idStr.includes('-vl') || idStr.includes('-vision'))) {
+  if (result.vision === undefined && (/(^|[_-])(vision|vl)($|[_-])/i.test(idStr) || idStr.includes('-vl') || idStr.includes('-vision'))) {
     result.vision = true
   }
 

package/lib/reliability.js

@@ -1,5 +1,39 @@
 const RETRYABLE_STATUSES = new Set([408, 425, 429, 500, 502, 503, 504, 522, 524])
-const RETRYABLE_CODES = new Set(['ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT', 'EAI_AGAIN', 'UND_ERR_CONNECT_TIMEOUT'])
+const RETRYABLE_CODES = new Set([
+  'ECONNRESET',
+  'ECONNREFUSED',
+  'ETIMEDOUT',
+  'EAI_AGAIN',
+  'UND_ERR_CONNECT_TIMEOUT',
+  'UND_ERR_HEADERS_TIMEOUT',
+  'UND_ERR_BODY_TIMEOUT',
+  'UND_ERR_SOCKET',
+  'UND_ERR_DESTROYED',
+  'UND_ERR_CLOSED',
+  'EHOSTUNREACH',
+  'ENETUNREACH',
+  'EPIPE',
+])
+
+function isTimeout(err) {
+  if (!err) return false
+  if (err.name === 'TimeoutError') return true
+  if (
+    err.code === 'ETIMEDOUT' ||
+    err.code === 'UND_ERR_CONNECT_TIMEOUT' ||
+    err.code === 'UND_ERR_HEADERS_TIMEOUT' ||
+    err.code === 'UND_ERR_BODY_TIMEOUT'
+  ) return true
+  const msg = String(err.message || '').toLowerCase()
+  return msg.includes('timed out') || msg.includes('timeout')
+}
+
+function isAbort(err) {
+  if (!err) return false
+  if (err.name === 'AbortError') return true
+  const msg = String(err.message || '').toLowerCase()
+  return msg.includes('aborted') || msg.includes('the operation was aborted')
+}
 
 export function statusOfError(error) {
   const direct = Number(error?.status ?? error?.statusCode)
@@ -10,10 +44,36 @@ export function statusOfError(error) {
 
 export function isRetryableError(error) {
   if (!error) return false
-  if (error.name === 'AbortError' || error.name === 'TimeoutError') return true
-  if (RETRYABLE_CODES.has(error.code)) return true
-  const status = statusOfError(error)
-  return status !== undefined && RETRYABLE_STATUSES.has(status)
+
+  let curr = error
+  let depth = 0
+  let hasTimeout = false
+  let hasAbort = false
+
+  while (curr && depth < 6) {
+    if (isTimeout(curr)) {
+      hasTimeout = true
+      break
+    }
+    if (isAbort(curr)) {
+      hasAbort = true
+    }
+    if (curr.code && RETRYABLE_CODES.has(curr.code)) {
+      return true
+    }
+    const status = statusOfError(curr)
+    if (status !== undefined) {
+      if (RETRYABLE_STATUSES.has(status)) return true
+      if (status >= 400 && status < 500) return false
+    }
+    curr = curr.cause
+    depth++
+  }
+
+  if (hasTimeout) return true
+  if (hasAbort) return false
+
+  return false
 }
 
 export function parseRetryAfter(response) {
@@ -46,7 +106,10 @@ export function catalogRequestError(status, response) {
   const error = new Error(`model catalog request failed with HTTP ${status}`)
   error.status = Number(status)
   const retryAfterMs = parseRetryAfter(response)
-  if (retryAfterMs !== undefined) error.retryAfterMs = retryAfterMs
+  if (retryAfterMs !== undefined) {
+    error.retryAfterMs = retryAfterMs
+    error.retryAt = new Date(Date.now() + retryAfterMs).toISOString()
+  }
   return error
 }
 
@@ -105,6 +168,7 @@ export async function retryWithBackoff(operation, {
   attempts = 3,
   baseDelayMs = 250,
   maxDelayMs = 4000,
+  maxRetryAfterMs = 300000,
   jitter = true,
   signal,
   onRetry,
@@ -116,14 +180,22 @@ export async function retryWithBackoff(operation, {
       return await operation({ attempt })
     } catch (error) {
       if (attempt >= total || !isRetryableError(error)) throw error
-      const exponential = Math.max(0, Number(baseDelayMs) || 0) * (2 ** (attempt - 1))
-      // Full jitter: randomized between [0.5, 1.0] of calculated exponential backoff
-      const jitterFactor = jitter ? (0.5 + Math.random() * 0.5) : 1
-      const calculatedDelayMs = Math.min(Math.max(0, Number(maxDelayMs) || 0), Math.round(exponential * jitterFactor))
       const retryAfterMs = Number(error?.retryAfterMs)
-      const delayMs = (Number.isFinite(retryAfterMs) && retryAfterMs > 0)
-        ? Math.min(Math.max(0, Number(maxDelayMs) || 0), retryAfterMs)
-        : calculatedDelayMs
+      let delayMs
+      if (Number.isFinite(retryAfterMs) && retryAfterMs > 0) {
+        if (retryAfterMs > maxRetryAfterMs) {
+          if (!error.retryAt) {
+            error.retryAt = new Date(Date.now() + retryAfterMs).toISOString()
+          }
+          throw error
+        }
+        delayMs = retryAfterMs
+      } else {
+        const exponential = Math.max(0, Number(baseDelayMs) || 0) * (2 ** (attempt - 1))
+        // Full jitter: randomized between [0.5, 1.0] of calculated exponential backoff
+        const jitterFactor = jitter ? (0.5 + Math.random() * 0.5) : 1
+        delayMs = Math.min(Math.max(0, Number(maxDelayMs) || 0), Math.round(exponential * jitterFactor))
+      }
       onRetry?.({ attempt, nextAttempt: attempt + 1, delayMs, error })
       await delay(delayMs, signal)
     }
@@ -142,4 +214,4 @@ export async function mapWithConcurrency(items, worker, concurrency = 4) {
     }
   }))
   return values
-}
+}

package/lib/synchronizer-prober.js

@@ -1,30 +1,94 @@
-export function createModelProber({ health, getProviderCatalog = () => [] } = {}) {
+export function createModelProber({
+  health,
+  getProviderCatalog = () => [],
+  probeModel,
+  inferModel,
+} = {}) {
   const modelProbes = new Map()
+  const probeFn = probeModel ?? inferModel
 
-  async function tryModel({ provider, model } = {}) {
+  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')
-    const start = Date.now()
-    const result = await health({ provider })
-    const entry = result?.results?.find((r) => r.provider === provider)
-    const providerOk = entry?.status === 'ok'
 
     // Verify model in provider catalog if catalog is available
     const catalog = typeof getProviderCatalog === 'function' ? getProviderCatalog(provider) : []
     const hasCatalog = Array.isArray(catalog) && catalog.length > 0
     const inCatalog = !hasCatalog || catalog.some((m) => (typeof m === 'string' ? m : m?.id) === model)
+    if (hasCatalog && !inCatalog) {
+      const probeResult = {
+        provider,
+        model,
+        ok: false,
+        latencyMs: 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(),
+      })
+      return probeResult
+    }
+
+    const start = Date.now()
+    if (typeof probeFn === 'function') {
+      try {
+        const probeRes = await probeFn({ provider, model, signal })
+        const latencyMs = Math.max(1, Date.now() - start)
+        const isOk = probeRes?.ok !== false
+        const status = isOk ? 'ok' : (probeRes?.status || 'error')
+        const errorMsg = isOk ? undefined : (probeRes?.error || 'inference probe failed')
+        const probeResult = {
+          provider,
+          model,
+          ok: isOk,
+          latencyMs,
+          status,
+          ...(errorMsg ? { error: errorMsg } : {}),
+        }
+        modelProbes.set(`${provider}:${model}`, {
+          latencyMs,
+          ok: isOk,
+          status,
+          timestamp: Date.now(),
+        })
+        return probeResult
+      } catch (err) {
+        const latencyMs = Math.max(1, Date.now() - start)
+        const status = err?.status ? `http_${err.status}` : (err?.code || 'error')
+        const probeResult = {
+          provider,
+          model,
+          ok: false,
+          latencyMs,
+          status,
+          error: err?.message || 'inference probe failed',
+        }
+        modelProbes.set(`${provider}:${model}`, {
+          latencyMs,
+          ok: false,
+          status,
+          timestamp: Date.now(),
+        })
+        return probeResult
+      }
+    }
 
-    const ok = Boolean(providerOk && inCatalog)
-    const latencyMs = Date.now() - start
-    const status = !providerOk ? (entry?.status ?? 'error') : (!inCatalog ? 'model_not_found' : 'ok')
-    const errorMsg = !providerOk
-      ? (entry?.message || entry?.status || 'probe failed')
-      : (!inCatalog ? `model "${model}" not found in provider catalog` : undefined)
+    // Fallback if no probeFn provided: check provider health
+    const healthResult = await health?.({ provider, model, signal })
+    const entry = healthResult?.results?.find((r) => r.provider === provider)
+    const providerOk = entry?.status === 'ok'
+    const latencyMs = Math.max(1, Date.now() - start)
+    const status = !providerOk ? (entry?.status ?? 'error') : 'ok'
+    const errorMsg = !providerOk ? (entry?.message || entry?.status || 'probe failed') : undefined
 
     const probeResult = {
       provider,
       model,
-      ok,
+      ok: providerOk,
       latencyMs,
       status,
       ...(errorMsg ? { error: errorMsg } : {}),
@@ -32,7 +96,7 @@ export function createModelProber({ health, getProviderCatalog = () => [] } = {}
 
     modelProbes.set(`${provider}:${model}`, {
       latencyMs,
-      ok,
+      ok: providerOk,
       status,
       timestamp: Date.now(),
     })
@@ -40,58 +104,74 @@ export function createModelProber({ health, getProviderCatalog = () => [] } = {}
     return probeResult
   }
 
-  async function batchTryModels({ provider, models } = {}) {
+  async function batchTryModels({ provider, models, signal, concurrency = 4 } = {}) {
     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)
 
-    // Probe provider health ONCE for the entire batch rather than per-model
+    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
+
+      await Promise.all(Array.from({ length: Math.min(limit, list.length || 1) }, async () => {
+        while (cursor < list.length) {
+          if (signal?.aborted) break
+          const index = cursor++
+          results[index] = await tryModel({ provider, model: list[index], signal })
+        }
+      }))
+
+      const reachable = results.filter((r) => r?.ok).length
+      return {
+        provider,
+        results,
+        summary: { total: results.length, reachable, unreachable: results.length - reachable },
+      }
+    }
+
+    // If no probeFn provided, use provider health once (backwards compatibility)
     const start = Date.now()
-    const healthResult = await health({ provider })
+    const healthResult = await health?.({ provider, signal })
     const entry = healthResult?.results?.find((r) => r.provider === provider)
     const providerOk = entry?.status === 'ok'
     const catalog = typeof getProviderCatalog === 'function' ? getProviderCatalog(provider) : []
     const hasCatalog = Array.isArray(catalog) && catalog.length > 0
-    const baseLatency = Date.now() - start
-
-    const results = []
-    const concurrency = 5
-    for (let i = 0; i < list.length; i += concurrency) {
-      const chunk = list.slice(i, i + concurrency)
-      const chunkResults = chunk.map((model) => {
-        const inCatalog = !hasCatalog || catalog.some((m) => (typeof m === 'string' ? m : m?.id) === model)
-        const ok = Boolean(providerOk && inCatalog)
-        const status = !providerOk ? (entry?.status ?? 'error') : (!inCatalog ? 'model_not_found' : 'ok')
-        const errorMsg = !providerOk
-          ? (entry?.message || entry?.status || 'probe failed')
-          : (!inCatalog ? `model "${model}" not found in provider catalog` : undefined)
-
-        const itemResult = {
-          provider,
-          model,
-          ok,
-          latencyMs: baseLatency,
-          status,
-          ...(errorMsg ? { error: errorMsg } : {}),
-        }
+    const baseLatency = Math.max(1, Date.now() - start)
 
-        modelProbes.set(`${provider}:${model}`, {
-          latencyMs: baseLatency,
-          ok,
-          status,
-          timestamp: Date.now(),
-        })
+    const results = list.map((model) => {
+      const inCatalog = !hasCatalog || catalog.some((m) => (typeof m === 'string' ? m : m?.id) === model)
+      const ok = Boolean(providerOk && inCatalog)
+      const status = !providerOk ? (entry?.status ?? 'error') : (!inCatalog ? 'model_not_found' : 'ok')
+      const errorMsg = !providerOk
+        ? (entry?.message || entry?.status || 'probe failed')
+        : (!inCatalog ? `model "${model}" not found in provider catalog` : undefined)
+
+      const itemResult = {
+        provider,
+        model,
+        ok,
+        latencyMs: baseLatency,
+        status,
+        ...(errorMsg ? { error: errorMsg } : {}),
+      }
 
-        return itemResult
+      modelProbes.set(`${provider}:${model}`, {
+        latencyMs: baseLatency,
+        ok,
+        status,
+        timestamp: Date.now(),
       })
-      results.push(...chunkResults)
-    }
+
+      return itemResult
+    })
 
     const reachable = results.filter((r) => r.ok).length
     return {
       provider,
       results,
-      summary: { total: results.length, reachable, unreachable: results.length - reachable }
+      summary: { total: results.length, reachable, unreachable: results.length - reachable },
     }
   }
 
@@ -104,4 +184,4 @@ export function createModelProber({ health, getProviderCatalog = () => [] } = {}
     batchTryModels,
     getModelProbes,
   }
-}
+}

package/lib/synchronizer.js

@@ -31,7 +31,7 @@ import {
 import { createConfigTransfer } from './synchronizer-transfer.js'
 import { createModelProber } from './synchronizer-prober.js'
 
-export function createModelSynchronizer(ctx, { getConfig = () => ({}), saveConfig = async () => {}, fetchImpl = fetch, adapterImplementations = {} } = {}) {
+export function createModelSynchronizer(ctx, { getConfig = () => ({}), saveConfig = async () => {}, fetchImpl = fetch, adapterImplementations = {}, probeModel } = {}) {
   const resolveCredential = createCredentialResolver(ctx)
   const registry = createProviderAdapterRegistry({ resolveCredential, fetchImpl, adapters: adapterImplementations })
   let running = null
@@ -467,6 +467,35 @@ export function createModelSynchronizer(ctx, { getConfig = () => ({}), saveConfi
       const row = providers().find((item) => item.provider === p)
       return row?.availableModels || row?.models || []
     },
+    probeModel: probeModel ?? (async ({ provider, model, signal }) => {
+      const llm = llmOf(ctx)
+      if (typeof llm?.stream === "function") {
+        const stream = await llm.stream({
+          provider,
+          model,
+          messages: [{ role: "user", content: [{ type: "text", text: "ping" }] }],
+        }, { signal })
+        if (stream && typeof stream[Symbol.asyncIterator] === "function") {
+          for await (const _chunk of stream) {
+            break
+          }
+        }
+        return { ok: true }
+      }
+      const profile = profileOf(settingsOf(ctx), provider)
+      const adapter = selectAdapter(profile)
+      if (typeof adapter?.probeModel === "function") {
+        return adapter.probeModel(profile, model, { signal, fetchImpl })
+      }
+      const h = await health({ provider, model, signal })
+      const entry = h?.results?.find((r) => r.provider === provider)
+      if (entry?.status !== "ok") {
+        const err = new Error(entry?.message || "provider health failed: " + entry?.status)
+        if (entry?.status === "circuit-open") err.status = 503
+        throw err
+      }
+      return { ok: true }
+    }),
   })
 
   const rollbackHistory = (opts) => performHistoryRollback({ ctx, config: getConfig() ?? {}, providers: providers(), ...opts })

package/lib/updater.js

@@ -200,7 +200,12 @@ export async function latestVersion(packageName, registry = 'https://registry.np
     const response = await fetch(`${registry.replace(/\/$/, '')}/${encodeURIComponent(packageName)}/latest`, {
       signal: typeof AbortSignal !== 'undefined' && AbortSignal.timeout ? AbortSignal.timeout(8000) : undefined,
     })
-    if (!response.ok) return undefined
+    if (!response.ok) {
+      if (typeof response.body?.cancel === "function") {
+        try { await response.body.cancel() } catch (_err) { /* best-effort cancel */ }
+      }
+      return undefined
+    }
     const value = await response.json()
     if (typeof value?.version !== 'string' || value.version === '') return undefined
     latestCache = { packageName, registry, version: value.version, expiresAt: Date.now() + VERSION_CACHE_MS }

package/package.json

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