@open-mercato/search 0.6.6-develop.6296.1.5e8bdfee17 → 0.6.6-develop.6299.1.29224e2d86

package/src/modules/search/lib/provider-probe.ts

@@ -0,0 +1,143 @@
+import type { CacheStrategy } from '@open-mercato/cache'
+import type { AppContainer } from '@open-mercato/shared/lib/di/container'
+import type { EmbeddingProviderId } from '../../../vector'
+import { EMBEDDING_PROVIDERS } from '../../../vector'
+
+const CACHE_VERSION = 'v1'
+const CACHE_TTL_MS = 30_000
+const OLLAMA_PROBE_TIMEOUT_MS = 1500
+
+export type ProviderAvailability = {
+  available: boolean
+  reason?: string
+  models?: number
+}
+
+export type ProviderAvailabilityEntry = ProviderAvailability & {
+  providerId: EmbeddingProviderId
+}
+
+export type EmbeddingProviderProbe = {
+  checkAvailability(providerId: EmbeddingProviderId, options?: { force?: boolean }): Promise<ProviderAvailability>
+}
+
+const ALL_PROVIDERS: EmbeddingProviderId[] = ['openai', 'google', 'mistral', 'cohere', 'bedrock', 'ollama']
+
+export async function checkAllProviders(
+  probe: EmbeddingProviderProbe,
+  options?: { force?: boolean },
+): Promise<ProviderAvailabilityEntry[]> {
+  return Promise.all(
+    ALL_PROVIDERS.map(async (providerId) => ({
+      providerId,
+      ...(await probe.checkAvailability(providerId, options)),
+    })),
+  )
+}
+
+const cacheKey = (providerId: string) => `embedding-provider-probe:${CACHE_VERSION}:${providerId}`
+
+const resolveCache = (container: AppContainer): CacheStrategy | null => {
+  try {
+    return container.resolve('cache') as CacheStrategy
+  } catch {
+    return null
+  }
+}
+
+const ollamaBaseUrl = () => process.env.OLLAMA_BASE_URL ?? 'http://localhost:11434'
+
+const keyPresence = (providerId: EmbeddingProviderId): ProviderAvailability => {
+  const info = EMBEDDING_PROVIDERS[providerId]
+  const envKey = info?.envKeyRequired
+  switch (providerId) {
+    case 'openai':
+      return process.env.OPENAI_API_KEY?.trim()
+        ? { available: true }
+        : { available: false, reason: `Set ${envKey} to enable ${info?.name ?? providerId}` }
+    case 'google':
+      return process.env.GOOGLE_GENERATIVE_AI_API_KEY?.trim()
+        ? { available: true }
+        : { available: false, reason: `Set ${envKey} to enable ${info?.name ?? providerId}` }
+    case 'mistral':
+      return process.env.MISTRAL_API_KEY?.trim()
+        ? { available: true }
+        : { available: false, reason: `Set ${envKey} to enable ${info?.name ?? providerId}` }
+    case 'cohere':
+      return process.env.COHERE_API_KEY?.trim()
+        ? { available: true }
+        : { available: false, reason: `Set ${envKey} to enable ${info?.name ?? providerId}` }
+    case 'bedrock':
+      return process.env.AWS_ACCESS_KEY_ID?.trim() && process.env.AWS_SECRET_ACCESS_KEY?.trim()
+        ? { available: true }
+        : { available: false, reason: 'Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY to enable Bedrock' }
+    default:
+      return { available: false, reason: `Unknown provider: ${providerId}` }
+  }
+}
+
+export async function probeOllama(baseUrl: string): Promise<ProviderAvailability> {
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), OLLAMA_PROBE_TIMEOUT_MS)
+  try {
+    const response = await fetch(`${baseUrl.replace(/\/$/, '')}/api/tags`, {
+      method: 'GET',
+      signal: controller.signal,
+    })
+    if (!response.ok) {
+      return { available: false, reason: `Ollama responded ${response.status} at ${baseUrl}` }
+    }
+    let models: number | undefined
+    try {
+      const payload = (await response.json()) as { models?: unknown[] }
+      if (Array.isArray(payload?.models)) models = payload.models.length
+    } catch {}
+    return { available: true, models }
+  } catch (error) {
+    const aborted = error instanceof Error && error.name === 'AbortError'
+    return {
+      available: false,
+      reason: aborted ? `Ollama not reachable at ${baseUrl} (timed out)` : `Ollama not reachable at ${baseUrl}`,
+    }
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+async function computeAvailability(providerId: EmbeddingProviderId): Promise<ProviderAvailability> {
+  try {
+    if (providerId === 'ollama') {
+      return await probeOllama(ollamaBaseUrl())
+    }
+    return keyPresence(providerId)
+  } catch (error) {
+    // Fail closed: any unexpected error means the provider is treated as unavailable.
+    return { available: false, reason: error instanceof Error ? error.message : 'Availability check failed' }
+  }
+}
+
+export function createEmbeddingProviderProbe(container: AppContainer): EmbeddingProviderProbe {
+  const checkAvailability = async (
+    providerId: EmbeddingProviderId,
+    options?: { force?: boolean },
+  ): Promise<ProviderAvailability> => {
+    const cache = resolveCache(container)
+    const key = cacheKey(providerId)
+    if (!options?.force && cache) {
+      try {
+        const cached = await cache.get(key)
+        if (cached && typeof cached === 'object' && 'available' in cached) {
+          return cached as ProviderAvailability
+        }
+      } catch {}
+    }
+    const result = await computeAvailability(providerId)
+    if (cache) {
+      try {
+        await cache.set(key, result, { ttl: CACHE_TTL_MS })
+      } catch {}
+    }
+    return result
+  }
+  return { checkAvailability }
+}