feat(shared): add connected-providers-cache for model availability

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-opencode)

Co-authored-by: Sisyphus <[email protected]>

Author: justsisyphus

src/cli/doctor/checks/model-resolution.ts

@@ -199,9 +199,11 @@ function buildDetailsArray(info: ModelResolutionInfo, available: AvailableModels
   details.push("═══ Available Models (from cache) ═══")
   details.push("")
   if (available.cacheExists) {
-    details.push(`  Providers: ${available.providers.length} (${available.providers.slice(0, 8).join(", ")}${available.providers.length > 8 ? "..." : ""})`)
+    details.push(`  Providers in cache: ${available.providers.length}`)
+    details.push(`  Sample: ${available.providers.slice(0, 6).join(", ")}${available.providers.length > 6 ? "..." : ""}`)
     details.push(`  Total models: ${available.modelCount}`)
     details.push(`  Cache: ~/.cache/opencode/models.json`)
+    details.push(`  ℹ Runtime: only connected providers used`)
     details.push(`  Refresh: opencode models --refresh`)
   } else {
     details.push("  ⚠ Cache not found. Run 'opencode' to populate.")

src/hooks/auto-update-checker/index.ts

@@ -6,6 +6,7 @@ import { log } from "../../shared/logger"
 import { getConfigLoadErrors, clearConfigLoadErrors } from "../../shared/config-errors"
 import { runBunInstall } from "../../cli/config-manager"
 import { isModelCacheAvailable } from "../../shared/model-availability"
+import { hasConnectedProvidersCache, updateConnectedProvidersCache } from "../../shared/connected-providers-cache"
 import type { AutoUpdateCheckerOptions } from "./types"
 
 const SISYPHUS_SPINNER = ["·", "•", "●", "○", "◌", "◦", " "]
@@ -77,6 +78,7 @@ export function createAutoUpdateCheckerHook(ctx: PluginInput, options: AutoUpdat
 
         await showConfigErrorsIfAny(ctx)
         await showModelCacheWarningIfNeeded(ctx)
+        await updateAndShowConnectedProvidersCacheStatus(ctx)
 
         if (localDevVersion) {
           if (showStartupToast) {
@@ -186,6 +188,29 @@ async function showModelCacheWarningIfNeeded(ctx: PluginInput): Promise<void> {
   log("[auto-update-checker] Model cache warning shown")
 }
 
+async function updateAndShowConnectedProvidersCacheStatus(ctx: PluginInput): Promise<void> {
+  const hadCache = hasConnectedProvidersCache()
+
+  updateConnectedProvidersCache(ctx.client).catch(() => {})
+
+  if (!hadCache) {
+    await ctx.client.tui
+      .showToast({
+        body: {
+          title: "Connected Providers Cache",
+          message: "Building provider cache for first time. Restart OpenCode for full model filtering.",
+          variant: "info" as const,
+          duration: 8000,
+        },
+      })
+      .catch(() => {})
+
+    log("[auto-update-checker] Connected providers cache toast shown (first run)")
+  } else {
+    log("[auto-update-checker] Connected providers cache exists, updating in background")
+  }
+}
+
 async function showConfigErrorsIfAny(ctx: PluginInput): Promise<void> {
   const errors = getConfigLoadErrors()
   if (errors.length === 0) return

src/shared/connected-providers-cache.ts

@@ -0,0 +1,192 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs"
+import { join } from "path"
+import { log } from "./logger"
+import { getOmoOpenCodeCacheDir } from "./data-path"
+
+const CONNECTED_PROVIDERS_CACHE_FILE = "connected-providers.json"
+const PROVIDER_MODELS_CACHE_FILE = "provider-models.json"
+
+interface ConnectedProvidersCache {
+	connected: string[]
+	updatedAt: string
+}
+
+interface ProviderModelsCache {
+	models: Record<string, string[]>
+	connected: string[]
+	updatedAt: string
+}
+
+function getCacheFilePath(filename: string): string {
+	return join(getOmoOpenCodeCacheDir(), filename)
+}
+
+function ensureCacheDir(): void {
+	const cacheDir = getOmoOpenCodeCacheDir()
+	if (!existsSync(cacheDir)) {
+		mkdirSync(cacheDir, { recursive: true })
+	}
+}
+
+/**
+ * Read the connected providers cache.
+ * Returns the list of connected provider IDs, or null if cache doesn't exist.
+ */
+export function readConnectedProvidersCache(): string[] | null {
+	const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE)
+
+	if (!existsSync(cacheFile)) {
+		log("[connected-providers-cache] Cache file not found", { cacheFile })
+		return null
+	}
+
+	try {
+		const content = readFileSync(cacheFile, "utf-8")
+		const data = JSON.parse(content) as ConnectedProvidersCache
+		log("[connected-providers-cache] Read cache", { count: data.connected.length, updatedAt: data.updatedAt })
+		return data.connected
+	} catch (err) {
+		log("[connected-providers-cache] Error reading cache", { error: String(err) })
+		return null
+	}
+}
+
+/**
+ * Check if connected providers cache exists.
+ */
+export function hasConnectedProvidersCache(): boolean {
+	const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE)
+	return existsSync(cacheFile)
+}
+
+/**
+ * Write the connected providers cache.
+ */
+function writeConnectedProvidersCache(connected: string[]): void {
+	ensureCacheDir()
+	const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE)
+
+	const data: ConnectedProvidersCache = {
+		connected,
+		updatedAt: new Date().toISOString(),
+	}
+
+	try {
+		writeFileSync(cacheFile, JSON.stringify(data, null, 2))
+		log("[connected-providers-cache] Cache written", { count: connected.length })
+	} catch (err) {
+		log("[connected-providers-cache] Error writing cache", { error: String(err) })
+	}
+}
+
+/**
+ * Read the provider-models cache.
+ * Returns the cache data, or null if cache doesn't exist.
+ */
+export function readProviderModelsCache(): ProviderModelsCache | null {
+	const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE)
+
+	if (!existsSync(cacheFile)) {
+		log("[connected-providers-cache] Provider-models cache file not found", { cacheFile })
+		return null
+	}
+
+	try {
+		const content = readFileSync(cacheFile, "utf-8")
+		const data = JSON.parse(content) as ProviderModelsCache
+		log("[connected-providers-cache] Read provider-models cache", { 
+			providerCount: Object.keys(data.models).length, 
+			updatedAt: data.updatedAt 
+		})
+		return data
+	} catch (err) {
+		log("[connected-providers-cache] Error reading provider-models cache", { error: String(err) })
+		return null
+	}
+}
+
+/**
+ * Check if provider-models cache exists.
+ */
+export function hasProviderModelsCache(): boolean {
+	const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE)
+	return existsSync(cacheFile)
+}
+
+/**
+ * Write the provider-models cache.
+ */
+export function writeProviderModelsCache(data: { models: Record<string, string[]>; connected: string[] }): void {
+	ensureCacheDir()
+	const cacheFile = getCacheFilePath(PROVIDER_MODELS_CACHE_FILE)
+
+	const cacheData: ProviderModelsCache = {
+		...data,
+		updatedAt: new Date().toISOString(),
+	}
+
+	try {
+		writeFileSync(cacheFile, JSON.stringify(cacheData, null, 2))
+		log("[connected-providers-cache] Provider-models cache written", { 
+			providerCount: Object.keys(data.models).length 
+		})
+	} catch (err) {
+		log("[connected-providers-cache] Error writing provider-models cache", { error: String(err) })
+	}
+}
+
+/**
+ * Update the connected providers cache by fetching from the client.
+ * Also updates the provider-models cache with model lists per provider.
+ */
+export async function updateConnectedProvidersCache(client: {
+	provider?: {
+		list?: () => Promise<{ data?: { connected?: string[] } }>
+	}
+	model?: {
+		list?: () => Promise<{ data?: Array<{ id: string; provider: string }> }>
+	}
+}): Promise<void> {
+	if (!client?.provider?.list) {
+		log("[connected-providers-cache] client.provider.list not available")
+		return
+	}
+
+	try {
+		const result = await client.provider.list()
+		const connected = result.data?.connected ?? []
+		log("[connected-providers-cache] Fetched connected providers", { count: connected.length, providers: connected })
+
+		writeConnectedProvidersCache(connected)
+
+		// Also update provider-models cache if model.list is available
+		if (client.model?.list) {
+			try {
+				const modelsResult = await client.model.list()
+				const models = modelsResult.data ?? []
+
+				const modelsByProvider: Record<string, string[]> = {}
+				for (const model of models) {
+					if (!modelsByProvider[model.provider]) {
+						modelsByProvider[model.provider] = []
+					}
+					modelsByProvider[model.provider].push(model.id)
+				}
+
+				writeProviderModelsCache({
+					models: modelsByProvider,
+					connected,
+				})
+
+				log("[connected-providers-cache] Provider-models cache updated", {
+					providerCount: Object.keys(modelsByProvider).length,
+					totalModels: models.length,
+				})
+			} catch (modelErr) {
+				log("[connected-providers-cache] Error fetching models", { error: String(modelErr) })
+			}
+		}
+	} catch (err) {
+		log("[connected-providers-cache] Error updating cache", { error: String(err) })
+	}
+}

src/shared/data-path.ts

@@ -20,3 +20,28 @@ export function getDataDir(): string {
 export function getOpenCodeStorageDir(): string {
   return path.join(getDataDir(), "opencode", "storage")
 }
+
+/**
+ * Returns the user-level cache directory.
+ * Matches OpenCode's behavior via xdg-basedir:
+ * - All platforms: XDG_CACHE_HOME or ~/.cache
+ */
+export function getCacheDir(): string {
+  return process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), ".cache")
+}
+
+/**
+ * Returns the oh-my-opencode cache directory.
+ * All platforms: ~/.cache/oh-my-opencode
+ */
+export function getOmoOpenCodeCacheDir(): string {
+  return path.join(getCacheDir(), "oh-my-opencode")
+}
+
+/**
+ * Returns the OpenCode cache directory (for reading OpenCode's cache).
+ * All platforms: ~/.cache/opencode
+ */
+export function getOpenCodeCacheDir(): string {
+  return path.join(getCacheDir(), "opencode")
+}

src/shared/index.ts

@@ -28,6 +28,7 @@ export * from "./agent-tool-restrictions"
 export * from "./model-requirements"
 export * from "./model-resolver"
 export * from "./model-availability"
+export * from "./connected-providers-cache"
 export * from "./case-insensitive"
 export * from "./session-utils"
 export * from "./tmux"