opencode-models-discovery 0.6.0 → 0.7.0

package/README.md

@@ -2,23 +2,27 @@
 
 [![npm version](https://img.shields.io/npm/v/opencode-models-discovery.svg?color=blue)](https://www.npmjs.com/package/opencode-models-discovery)
 [![npm downloads](https://img.shields.io/npm/dt/opencode-models-discovery.svg)](https://www.npmjs.com/package/opencode-models-discovery)
+[![release](https://github.com/yuhp/opencode-models-discovery/actions/workflows/release.yml/badge.svg)](https://github.com/yuhp/opencode-models-discovery/actions/workflows/release.yml)
+[![license](https://img.shields.io/github/license/yuhp/opencode-models-discovery)](https://github.com/yuhp/opencode-models-discovery/blob/main/LICENSE)
+[![OpenCode](https://img.shields.io/badge/OpenCode-%3E%3D1.4.0-blueviolet)](https://opencode.ai)
 
-> Forked from [opencode-lmstudio](https://github.com/nicktasios/opencode-lmstudio) and expanded to support **any OpenAI-compatible provider**.
+> A universal OpenCode plugin for dynamic model discovery across **any OpenAI-compatible provider**.
 
-OpenCode plugin for auto-discovery of OpenAI-compatible models with dynamic provider configuration.
+Originally inspired by [opencode-lmstudio](https://github.com/nicktasios/opencode-lmstudio), this project has been fully refactored into a general-purpose model discovery plugin with richer configuration controls for providers, models, naming, caching, and discovery behavior.
 
 ## Features
 
-- **Multi-Provider Support**: Works with any OpenAI-compatible provider (LM Studio, Ollama, LocalAI, etc.)
-- **Dynamic Model Discovery**: Queries provider's `/v1/models` endpoint to discover available models
-- **Auto-Injection**: Automatically adds unconfigured models to provider configuration
-- **Smart Model Formatting**: Optional formatting for better readability when explicitly enabled
-- **Organization Owner Extraction**: Extracts and sets `organizationOwner` field from model IDs
-- **Health Check Monitoring**: Verifies providers are accessible before attempting operations
+- **Universal Provider Support**: Works with any OpenAI-compatible provider (LM Studio, Ollama, LocalAI, gateways, and more)
+- **Dynamic Model Discovery**: Queries each provider's `/v1/models` endpoint to discover available models
+- **Auto-Injection**: Automatically adds unconfigured models into OpenCode provider config
+- **Provider Filtering**: Include or exclude specific providers from discovery
+- **Model Filtering**: Use regex rules to precisely control which discovered models are injected
+- **Configurable Discovery**: Control discovery behavior with enable/disable switches and TTL-based caching
+- **Smart Model Formatting**: Optional human-friendly display names for discovered models
+- **Organization Owner Extraction**: Extracts and sets `organizationOwner` from model IDs when available
+- **Health Check Monitoring**: Verifies providers are accessible before attempting discovery
 - **Model Merging**: Intelligently merges discovered models with existing configuration
-- **Comprehensive Caching**: Reduces API calls with intelligent caching system
-- **Error Handling**: Smart error categorization with auto-fix suggestions
-- **Configurable Discovery**: Enable/disable discovery and filter providers
+- **Error Handling**: Smart error categorization with actionable suggestions
 
 ## Installation
 
@@ -74,8 +78,7 @@ The plugin configuration is placed in the `plugin` array using tuple format `["p
         "excludeRegex": []
       },
       "discovery": {
-        "enabled": true,
-        "ttl": 15000
+        "enabled": true
       },
       "smartModelName": false
     }]
@@ -85,6 +88,67 @@ The plugin configuration is placed in the `plugin` array using tuple format `["p
 
 Set `smartModelName` to `true` if you want discovered models to use human-friendly display names instead of the raw `model_id`. (e.g., "Qwen3 30B A3B" instead of "qwen/qwen3-30b-a3b")
 
+#### Provider-Level Discovery Overrides
+
+Each provider can override discovery behavior through `provider.<name>.options.modelsDiscovery`:
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `provider.<name>.options.modelsDiscovery.enabled` | `boolean` | Override global discovery and provider filters for a single provider |
+| `provider.<name>.options.modelsDiscovery.models.includeRegex` | `string[]` | Provider-specific model include filter |
+| `provider.<name>.options.modelsDiscovery.models.excludeRegex` | `string[]` | Provider-specific model exclude filter |
+| `provider.<name>.options.modelsDiscovery.smartModelName` | `boolean` | Override global `smartModelName` for a single provider |
+
+Priority rules:
+
+1. `provider.<name>.options.modelsDiscovery.enabled` overrides global `discovery.enabled` and `providers.include/exclude`
+2. If a provider defines its own `modelsDiscovery.models` filters, those filters replace global `models.includeRegex/excludeRegex` for that provider
+3. If a provider does not define its own model filters, global `models.includeRegex/excludeRegex` are used
+4. `provider.<name>.options.modelsDiscovery.smartModelName` overrides global `smartModelName`
+
+```json
+{
+  "plugin": [
+    ["opencode-models-discovery", {
+      "providers": {
+        "include": ["ollama"]
+      },
+      "models": {
+        "includeRegex": ["^qwen/"]
+      },
+      "discovery": {
+        "enabled": false
+      },
+      "smartModelName": false
+    }]
+  ],
+  "provider": {
+    "lmstudio": {
+      "npm": "@ai-sdk/openai-compatible",
+      "name": "LM Studio",
+      "options": {
+        "baseURL": "http://127.0.0.1:1234/v1",
+        "modelsDiscovery": {
+          "enabled": true,
+          "models": {
+            "includeRegex": ["^gpt-"]
+          },
+          "smartModelName": true
+        }
+      },
+      "models": {}
+    }
+  }
+}
+```
+
+In this example:
+
+1. Global discovery is disabled
+2. `lmstudio` is still discovered because `modelsDiscovery.enabled` is `true`
+3. `lmstudio` uses `^gpt-` instead of the global `^qwen/` filter
+4. `lmstudio` uses smart model names even though the global setting is `false`
+
 #### Provider Filtering
 
 Control which providers are discovered:
@@ -239,7 +303,7 @@ This means providers using `@ai-sdk/anthropic` with OpenAI-compatible backends (
 
 ## Logging
 
-When available, the plugin writes logs through OpenCode's structured server log API via `client.app.log(...)` using the service name `opencode-model-discovery`.
+When available, the plugin writes logs through OpenCode's structured server log API via `client.app.log(...)` using the service name `opencode-models-discovery`.
 
 If structured logging is unavailable in the runtime, the plugin falls back to prefixed `console.*` output. Key log categories are emitted through metadata such as `plugin`, `config`, `discovery`, `event`, and `filtering` to make local debugging easier with `opencode --print-logs`.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "opencode-models-discovery",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "OpenCode plugin for auto-discovery of OpenAI-compatible models with dynamic provider configuration",
   "type": "module",
   "main": "./src/index.ts",

package/src/index.ts

@@ -1 +1 @@
-export { ModelDiscoveryPlugin, LMStudioPlugin } from './plugin'
+export { ModelDiscoveryPlugin } from './plugin'

package/src/monitoring/loading-monitor.ts

@@ -21,7 +21,7 @@ export class ModelLoadingMonitor {
       progress: 0
     })
     
-    console.info(`[opencode-model-discovery] Started monitoring model loading`, { modelId, baseURL })
+    console.info(`[opencode-models-discovery] Started monitoring model loading`, { modelId, baseURL })
     
     // Clear any existing interval
     this.stopMonitoring(modelId)
@@ -68,7 +68,7 @@ export class ModelLoadingMonitor {
         const duration = Date.now() - (state.startTime || Date.now())
         this.updateState(modelId, 'loaded', 100, 0)
         this.stopMonitoring(modelId)
-        console.info(`[opencode-model-discovery] Model loading completed`, {
+        console.info(`[opencode-models-discovery] Model loading completed`, {
           modelId,
           duration: `${duration}ms`,
           totalModels: this.loadingStates.size
@@ -111,11 +111,11 @@ export class ModelLoadingMonitor {
     // Log state changes
     if (currentState.status !== status) {
       if (status === 'loaded') {
-        console.info(`[opencode-model-discovery] Model loading completed`, { modelId })
+        console.info(`[opencode-models-discovery] Model loading completed`, { modelId })
       } else if (status === 'error') {
-        console.warn(`[opencode-model-discovery] Model loading failed`, { modelId, error })
+        console.warn(`[opencode-models-discovery] Model loading failed`, { modelId, error })
       } else if (status === 'loading') {
-        console.info(`[opencode-model-discovery] Model loading started`, { modelId })
+        console.info(`[opencode-models-discovery] Model loading started`, { modelId })
       }
     }
   }
@@ -138,4 +138,4 @@ export class ModelLoadingMonitor {
     }
     this.loadingStates.clear()
   }
-}
+}

package/src/plugin/config-hook.ts

@@ -20,7 +20,7 @@ export function createConfigHook(
     const validation = validateConfig(config)
     if (!validation.isValid) {
       logger.error('Invalid config provided', { errors: validation.errors })
-      toastNotifier.error("Plugin configuration is invalid", "Configuration Error").catch(() => {})
+      toastNotifier.error("Plugin configuration is invalid", "Configuration Error").catch(() => { })
       return
     }
 
@@ -28,10 +28,6 @@ export function createConfigHook(
       logger.warn('Config warnings', { warnings: validation.warnings })
     }
 
-    if (pluginConfig.discovery?.enabled === false) {
-      logger.info('Discovery disabled by configuration')
-      return
-    }
 
     const discoveryPromise = enhanceConfig(
       config,

package/src/plugin/enhance-config.ts

@@ -1,15 +1,12 @@
-import { ModelStatusCache } from '../cache/model-status-cache'
 import { ToastNotifier } from '../ui/toast-notifier'
 import { categorizeModel, formatModelName, extractModelOwner } from '../utils'
 import { normalizeBaseURL, checkProviderHealth, discoverModelsFromProvider, autoDetectOpenAICompatibleProvider, canDiscoverModels } from '../utils/openai-compatible-api'
-import { getProviderFilter, getDiscoveryConfig, getModelRegexFilter, shouldDiscoverModel, shouldDiscoverProvider } from '../types/plugin-config'
+import { getProviderFilter, getDiscoveryConfig, getModelRegexFilter, getProviderModelRegexFilter, shouldDiscoverModel, shouldDiscoverProviderWithOverride } from '../types/plugin-config'
 import type { PluginLogger } from './logger'
 import type { PluginInput } from '@opencode-ai/plugin'
 import type { OpenAIModel } from '../types'
 import type { PluginConfig } from '../types/plugin-config'
 
-const modelStatusCache = new ModelStatusCache()
-
 interface DiscoveredProvider {
   name: string
   baseURL: string
@@ -23,23 +20,24 @@ export async function enhanceConfig(
   pluginConfig: PluginConfig,
   logger: PluginLogger
 ): Promise<void> {
-  modelStatusCache.invalidateAll()
-  
   try {
     const providers = config.provider || {}
     const openAICompatibleProviders: DiscoveredProvider[] = []
     const providerFilter = getProviderFilter(pluginConfig)
     const modelRegexFilter = getModelRegexFilter(pluginConfig, logger.child({ category: 'filtering' }))
     const discoveryConfig = getDiscoveryConfig(pluginConfig)
+    const globalDiscoveryEnabled = discoveryConfig.enabled
 
     for (const [providerName, providerConfig] of Object.entries(providers)) {
       const p = providerConfig as any
-      
+      const providerDiscoveryConfig = p.options?.modelsDiscovery ?? {}
+
       if (!canDiscoverModels(p)) {
         continue
       }
 
-      if (!shouldDiscoverProvider(providerName, providerFilter)) {
+      if (!shouldDiscoverProviderWithOverride(providerName, providerFilter, globalDiscoveryEnabled, providerDiscoveryConfig)) {
+        logger.debug(`Provider ${providerName} model discovery disabled by configuration`)
         continue
       }
 
@@ -81,11 +79,18 @@ export async function enhanceConfig(
       let chatModelsCount = 0
       let embeddingModelsCount = 0
 
+      const hasProviderModelRegexFilter = !!providerDiscoveryConfig.models?.includeRegex?.length || !!providerDiscoveryConfig.models?.excludeRegex?.length
+      const providerModelRegexFilter = getProviderModelRegexFilter(providerDiscoveryConfig, logger.child({ category: 'filtering' }))
+      let smartModelNameEnabled = providerDiscoveryConfig.smartModelName
+      if (smartModelNameEnabled === undefined) {
+        smartModelNameEnabled = pluginConfig.smartModelName
+      }
+
       for (const model of models) {
         const modelKey = model.id
-
         if (!existingModels[modelKey]) {
-          if (!shouldDiscoverModel(model.id, modelRegexFilter)) {
+          const activeModelRegexFilter = hasProviderModelRegexFilter ? providerModelRegexFilter : modelRegexFilter
+          if (!shouldDiscoverModel(model.id, activeModelRegexFilter)) {
             continue
           }
 
@@ -93,7 +98,7 @@ export async function enhanceConfig(
           const owner = extractModelOwner(model.id)
           const modelConfig: any = {
             id: model.id,
-            name: pluginConfig.smartModelName ? formatModelName(model) : model.id,
+            name: smartModelNameEnabled ? formatModelName(model) : model.id,
           }
 
           if (owner) {
@@ -154,33 +159,10 @@ export async function enhanceConfig(
       }
     }
 
-    try {
-      for (const [providerName, providerConfig] of Object.entries(providers)) {
-        const p = providerConfig as any
-        if (!canDiscoverModels(p) || !shouldDiscoverProvider(providerName, providerFilter)) {
-          continue
-        }
-        if (p.options?.baseURL) {
-          const baseURL = normalizeBaseURL(p.options.baseURL)
-          if (discoveryConfig.ttl) {
-            modelStatusCache.setTTL(baseURL, discoveryConfig.ttl)
-          }
-          if (!modelStatusCache.isValid(baseURL)) {
-            await modelStatusCache.getModels(baseURL, async () => {
-              return await discoverModelsFromProvider(baseURL).then(models => models.map(m => m.id))
-            })
-          }
-        }
-      }
-    } catch (error) {
-      logger.warn('Model status cache refresh failed', {
-        error: error instanceof Error ? error.message : String(error),
-      })
-    }
   } catch (error) {
     logger.error('Unexpected error in enhanceConfig', {
       error: error instanceof Error ? error.message : String(error),
     })
-    toastNotifier.warning("Plugin configuration failed", "Configuration Error").catch(() => {})
+    toastNotifier.warning("Plugin configuration failed", "Configuration Error").catch(() => { })
   }
 }

package/src/plugin/index.ts

@@ -13,9 +13,9 @@ export const ModelDiscoveryPlugin: Plugin = async (input: PluginInput, options?:
   if (!client || typeof client !== 'object') {
     logger.error('Invalid client provided to plugin')
     return {
-      config: async () => {},
-      event: async () => {},
-      "chat.params": async () => {}
+      config: async () => { },
+      event: async () => { },
+      "chat.params": async () => { }
     }
   }
 
@@ -36,4 +36,4 @@ export const ModelDiscoveryPlugin: Plugin = async (input: PluginInput, options?:
   }
 }
 
-export const LMStudioPlugin = ModelDiscoveryPlugin
+//export const LMStudioPlugin = ModelDiscoveryPlugin

package/src/types/index.ts

@@ -22,61 +22,5 @@ export interface ModelLoadingState {
   error?: string
 }
 
-export interface ModelValidationError {
-  type: 'offline' | 'not_found' | 'network' | 'permission' | 'timeout' | 'unknown'
-  severity: 'low' | 'medium' | 'high' | 'critical'
-  message: string
-  canRetry: boolean
-  autoFixAvailable: boolean
-}
-
-export interface AutoFixSuggestion {
-  action: string
-  command?: string
-  steps?: string[]
-  automated: boolean
-}
-
-export interface SimilarModel {
-  model: string
-  similarity: number
-  reason: string
-}
-
-export interface CacheStats {
-  size: number
-  entries: Array<{
-    baseURL: string
-    age: number
-    modelCount: number
-    ttl: number
-  }>
-}
-
-export interface ModelValidationResult {
-  status: 'success' | 'error'
-  model: string
-  availableModels: string[]
-  message: string
-  errorCategory?: string
-  severity?: string
-  canRetry?: boolean
-  autoFixAvailable?: boolean
-  autoFixSuggestions?: AutoFixSuggestion[]
-  steps?: string[]
-  similarModels?: Array<{
-    model: string
-    similarity: number
-    reason: string
-  }>
-  cacheInfo?: {
-    age: number
-    valid: boolean
-    totalCacheEntries: number
-  }
-  performanceHint?: string
-}
-
 export type LMStudioModel = OpenAIModel
 export type LMStudioModelsResponse = OpenAIModelsResponse
-export type LMStudioValidationResult = ModelValidationResult

package/src/types/plugin-config.ts

@@ -9,7 +9,15 @@ export interface PluginConfig {
   }
   discovery?: {
     enabled?: boolean
-    ttl?: number
+  }
+  smartModelName?: boolean
+}
+
+export interface ProviderDiscoveryConfig {
+  enabled?: boolean
+  models?: {
+    includeRegex?: string[]
+    excludeRegex?: string[]
   }
   smartModelName?: boolean
 }
@@ -21,7 +29,6 @@ export interface ProviderFilter {
 
 export interface DiscoveryConfig {
   enabled: boolean
-  ttl: number
 }
 
 export interface ModelRegexFilter {
@@ -31,7 +38,6 @@ export interface ModelRegexFilter {
 
 export const DEFAULT_DISCOVERY_CONFIG: DiscoveryConfig = {
   enabled: true,
-  ttl: 15000,
 }
 
 export function shouldDiscoverProvider(
@@ -54,10 +60,30 @@ export function getProviderFilter(config: PluginConfig): ProviderFilter {
 export function getDiscoveryConfig(config: PluginConfig): DiscoveryConfig {
   return {
     enabled: config.discovery?.enabled ?? DEFAULT_DISCOVERY_CONFIG.enabled,
-    ttl: config.discovery?.ttl ?? DEFAULT_DISCOVERY_CONFIG.ttl,
   }
 }
 
+export function shouldDiscoverProviderWithOverride(
+  providerName: string,
+  filter: ProviderFilter,
+  globalEnabled: boolean,
+  providerConfig: ProviderDiscoveryConfig
+): boolean {
+  if (providerConfig.enabled === true) {
+    return true
+  }
+
+  if (providerConfig.enabled === false) {
+    return false
+  }
+
+  if (!globalEnabled) {
+    return false
+  }
+
+  return shouldDiscoverProvider(providerName, filter)
+}
+
 function toRegExp(pattern: string, logger?: PluginLogger): RegExp | null {
   try {
     return new RegExp(pattern)
@@ -65,7 +91,7 @@ function toRegExp(pattern: string, logger?: PluginLogger): RegExp | null {
     if (logger) {
       logger.warn('Ignoring invalid model regex', { category: 'filtering', pattern })
     } else {
-      console.warn(`[opencode-model-discovery] Ignoring invalid model regex: ${pattern}`)
+      console.warn(`[opencode-models-discovery] Ignoring invalid model regex: ${pattern}`)
     }
     return null
   }
@@ -78,6 +104,13 @@ export function getModelRegexFilter(config: PluginConfig, logger?: PluginLogger)
   }
 }
 
+export function getProviderModelRegexFilter(config: ProviderDiscoveryConfig, logger?: PluginLogger): ModelRegexFilter {
+  return {
+    includeRegex: (config.models?.includeRegex || []).map((pattern) => toRegExp(pattern, logger)).filter((pattern): pattern is RegExp => pattern !== null),
+    excludeRegex: (config.models?.excludeRegex || []).map((pattern) => toRegExp(pattern, logger)).filter((pattern): pattern is RegExp => pattern !== null),
+  }
+}
+
 export function shouldDiscoverModel(modelId: string, filter: ModelRegexFilter): boolean {
   if (filter.includeRegex.length > 0) {
     return filter.includeRegex.some((pattern) => pattern.test(modelId))

package/src/ui/toast-notifier.ts

@@ -1,4 +1,4 @@
-// UI notification system for LM Studio plugin
+// UI notification system for the model discovery plugin
 export class ToastNotifier {
   private client: any // OpenCode client
   
@@ -10,7 +10,7 @@ export class ToastNotifier {
   async success(message: string, title?: string, duration?: number): Promise<void> {
     try {
       if (!this.client?.tui?.showToast) {
-        console.warn('[opencode-model-discovery] Toast API not available (client.tui.showToast missing)')
+        console.warn('[opencode-models-discovery] Toast API not available (client.tui.showToast missing)')
         return
       }
       await this.client.tui.showToast({
@@ -22,7 +22,7 @@ export class ToastNotifier {
         }
       })
     } catch (error) {
-      console.error(`[opencode-model-discovery] Failed to show success toast`, error)
+      console.error(`[opencode-models-discovery] Failed to show success toast`, error)
     }
   }
   
@@ -30,7 +30,7 @@ export class ToastNotifier {
   async error(message: string, title?: string, duration?: number): Promise<void> {
     try {
       if (!this.client?.tui?.showToast) {
-        console.warn('[opencode-model-discovery] Toast API not available (client.tui.showToast missing)')
+        console.warn('[opencode-models-discovery] Toast API not available (client.tui.showToast missing)')
         return
       }
       await this.client.tui.showToast({
@@ -42,7 +42,7 @@ export class ToastNotifier {
         }
       })
     } catch (error) {
-      console.error(`[opencode-model-discovery] Failed to show error toast`, error)
+      console.error(`[opencode-models-discovery] Failed to show error toast`, error)
     }
   }
   
@@ -50,7 +50,7 @@ export class ToastNotifier {
   async warning(message: string, title?: string, duration?: number): Promise<void> {
     try {
       if (!this.client?.tui?.showToast) {
-        console.warn('[opencode-model-discovery] Toast API not available (client.tui.showToast missing)')
+        console.warn('[opencode-models-discovery] Toast API not available (client.tui.showToast missing)')
         return
       }
       await this.client.tui.showToast({
@@ -62,7 +62,7 @@ export class ToastNotifier {
         }
       })
     } catch (error) {
-      console.error(`[opencode-model-discovery] Failed to show warning toast`, error)
+      console.error(`[opencode-models-discovery] Failed to show warning toast`, error)
     }
   }
   
@@ -70,7 +70,7 @@ export class ToastNotifier {
   async info(message: string, title?: string, duration?: number): Promise<void> {
     try {
       if (!this.client?.tui?.showToast) {
-        console.warn('[opencode-model-discovery] Toast API not available (client.tui.showToast missing)')
+        console.warn('[opencode-models-discovery] Toast API not available (client.tui.showToast missing)')
         return
       }
       await this.client.tui.showToast({
@@ -82,7 +82,7 @@ export class ToastNotifier {
         }
       })
     } catch (error) {
-      console.error(`[opencode-model-discovery] Failed to show info toast`, error)
+      console.error(`[opencode-models-discovery] Failed to show info toast`, error)
     }
   }
   
@@ -90,7 +90,7 @@ export class ToastNotifier {
   async progress(message: string, title?: string, progress?: number): Promise<void> {
     try {
       if (!this.client?.tui?.showToast) {
-        console.warn('[opencode-model-discovery] Toast API not available (client.tui.showToast missing)')
+        console.warn('[opencode-models-discovery] Toast API not available (client.tui.showToast missing)')
         return
       }
       await this.client.tui.showToast({
@@ -102,7 +102,7 @@ export class ToastNotifier {
         }
       })
     } catch (error) {
-      console.error(`[opencode-model-discovery] Failed to show progress toast`, error)
+      console.error(`[opencode-models-discovery] Failed to show progress toast`, error)
     }
   }
   
@@ -115,7 +115,7 @@ export class ToastNotifier {
   }): Promise<void> {
     try {
       if (!this.client?.tui?.showToast) {
-        console.warn('[opencode-model-discovery] Toast API not available (client.tui.showToast missing)')
+        console.warn('[opencode-models-discovery] Toast API not available (client.tui.showToast missing)')
         return
       }
       await this.client.tui.showToast({
@@ -127,7 +127,7 @@ export class ToastNotifier {
         }
       })
     } catch (error) {
-      console.error(`[opencode-model-discovery] Failed to show detailed toast`, error)
+      console.error(`[opencode-models-discovery] Failed to show detailed toast`, error)
     }
   }
-}
+}

package/src/utils/index.ts

@@ -1,5 +1,3 @@
-import type { ModelValidationError, AutoFixSuggestion, SimilarModel } from '../types'
-
 export { formatModelName, extractModelOwner } from './format-model-name'
 
 // Categorize models by type
@@ -16,201 +14,3 @@ export function categorizeModel(modelId: string): 'chat' | 'embedding' | 'unknow
   }
   return 'unknown'
 }
-
-// Enhanced model similarity matching
-export function findSimilarModels(targetModel: string, availableModels: string[]): SimilarModel[] {
-  const target = targetModel.toLowerCase()
-  const targetTokens = target.split(/[-_\s]/).filter(Boolean)
-  
-  return availableModels
-    .map(model => {
-      const candidate = model.toLowerCase()
-      const candidateTokens = candidate.split(/[-_\s]/).filter(Boolean)
-      
-      let similarity = 0
-      const reasons: string[] = []
-      
-      // Exact match gets highest score
-      if (candidate === target) {
-        similarity = 1.0
-        reasons.push("Exact match")
-      }
-      
-      // Check for common model family prefixes
-      const targetPrefix = targetTokens[0]
-      const candidatePrefix = candidateTokens[0]
-      if (targetPrefix && candidatePrefix && targetPrefix === candidatePrefix) {
-        similarity += 0.5
-        reasons.push(`Same family: ${targetPrefix}`)
-      }
-      
-      // Check for common suffixes (quantization levels, sizes)
-      const commonSuffixes = ['3b', '7b', '13b', '70b', 'q4', 'q8', 'instruct', 'chat', 'base']
-      for (const suffix of commonSuffixes) {
-        if (target.includes(suffix) && candidate.includes(suffix)) {
-          similarity += 0.2
-          reasons.push(`Shared suffix: ${suffix}`)
-        }
-      }
-      
-      // Token overlap score
-      const commonTokens = targetTokens.filter(token => candidateTokens.includes(token))
-      if (commonTokens.length > 0) {
-        similarity += (commonTokens.length / Math.max(targetTokens.length, candidateTokens.length)) * 0.3
-        reasons.push(`Common tokens: ${commonTokens.join(', ')}`)
-      }
-      
-      return {
-        model,
-        similarity: Math.min(similarity, 1.0),
-        reason: reasons.join(", ")
-      }
-    })
-    .filter(item => item.similarity > 0.1) // Only include models with some similarity
-    .sort((a, b) => b.similarity - a.similarity)
-    .slice(0, 5) // Top 5 suggestions
-}
-
-// Retry logic with exponential backoff
-export async function retryWithBackoff<T>(
-  operation: () => Promise<T>, 
-  maxRetries: number = 3,
-  baseDelay: number = 1000
-): Promise<{ success: boolean; result?: T; error?: string }> {
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      const result = await operation()
-      return { success: true, result }
-    } catch (error) {
-      if (attempt === maxRetries) {
-        return { 
-          success: false, 
-          error: error instanceof Error ? error.message : String(error) 
-        }
-      }
-      
-      const delay = baseDelay * Math.pow(2, attempt)
-      console.warn(`[opencode-model-discovery] Retrying operation after ${delay}ms`, { 
-        attempt: attempt + 1, 
-        maxRetries: maxRetries + 1,
-        error: error instanceof Error ? error.message : String(error)
-      })
-      await new Promise(resolve => setTimeout(resolve, delay))
-    }
-  }
-  return { success: false, error: "Max retries exceeded" }
-}
-
-// Smart error categorization
-export function categorizeError(error: any, context: { baseURL: string; modelId: string }): ModelValidationError {
-  const errorStr = String(error).toLowerCase()
-  const { baseURL, modelId } = context
-  
-  // Network/connection issues
-  if (errorStr.includes('econnrefused') || errorStr.includes('fetch failed') || errorStr.includes('network')) {
-    return {
-      type: 'offline',
-      severity: 'critical',
-      message: `Cannot connect to provider at ${baseURL}. Ensure the server is running and accessible.`,
-      canRetry: true,
-      autoFixAvailable: true
-    }
-  }
-
-  // Timeout issues
-  if (errorStr.includes('timeout') || errorStr.includes('aborted')) {
-    return {
-      type: 'timeout',
-      severity: 'medium',
-      message: `Request timed out. This might happen with large models or slow systems.`,
-      canRetry: true,
-      autoFixAvailable: false
-    }
-  }
-
-  // Model not found
-  if (errorStr.includes('404') || errorStr.includes('not found')) {
-    return {
-      type: 'not_found',
-      severity: 'high',
-      message: `Model '${modelId}' not found. Check if model is available in the provider.`,
-      canRetry: false,
-      autoFixAvailable: false
-    }
-  }
-
-  // Permission issues
-  if (errorStr.includes('401') || errorStr.includes('403') || errorStr.includes('unauthorized')) {
-    return {
-      type: 'permission',
-      severity: 'high',
-      message: `Authentication or permission issue. Check your provider configuration.`,
-      canRetry: false,
-      autoFixAvailable: false
-    }
-  }
-  
-  // Unknown errors
-  return {
-    type: 'unknown',
-    severity: 'medium',
-    message: `Unexpected error: ${errorStr}`,
-    canRetry: true,
-    autoFixAvailable: false
-  }
-}
-
-// Generate auto-fix suggestions
-export function generateAutoFixSuggestions(errorCategory: ModelValidationError): AutoFixSuggestion[] {
-  const suggestions: AutoFixSuggestion[] = []
-
-  switch (errorCategory.type) {
-    case 'offline':
-      suggestions.push({
-        action: "Check if provider server is running",
-        steps: [
-          "1. Verify the server application is running",
-          "2. Verify the server is started",
-          "3. Check the server URL and port",
-          "4. Ensure the server is not blocked by firewall"
-        ],
-        automated: false
-      })
-      suggestions.push({
-        action: "Try alternative ports",
-        steps: [
-          "1. Check if provider is running on a different port",
-          "2. Common ports: 1234 (LM Studio), 8080 (LocalAI), 11434 (Ollama)",
-          "3. Update your OpenCode configuration with the correct port"
-        ],
-        automated: false
-      })
-      break
-
-    case 'not_found':
-      suggestions.push({
-        action: "Check model availability",
-        steps: [
-          "1. Verify the model is available in your provider",
-          "2. Download or load the model if needed",
-          "3. Ensure the model is properly installed"
-        ],
-        automated: false
-      })
-      break
-
-    case 'timeout':
-      suggestions.push({
-        action: "Increase timeout or use smaller model",
-        steps: [
-          "1. Try a smaller model version",
-          "2. Increase request timeout in OpenCode settings",
-          "3. Close other applications to free up system resources"
-        ],
-        automated: false
-      })
-      break
-  }
-
-  return suggestions
-}

package/src/cache/model-status-cache.ts

@@ -1,122 +0,0 @@
-import type { CacheStats } from '../types'
-
-// Model Status Cache for reducing API calls
-export class ModelStatusCache {
-  private cache = new Map<string, {
-    models: string[]
-    timestamp: number
-    ttl: number
-  }>()
-  
-  private readonly DEFAULT_TTL = 15000 // 15 seconds (reduced for better freshness)
-  private readonly MAX_CACHE_SIZE = 50 // Prevent memory leaks
-  
-  // Get cached model status or fetch fresh data
-  async getModels(baseURL: string, fetchFn: () => Promise<string[]>): Promise<string[]> {
-    const now = Date.now()
-    const cached = this.cache.get(baseURL)
-    
-    // Return cached data if still valid
-    if (cached && (now - cached.timestamp) < cached.ttl) {
-      return cached.models
-    }
-    
-    // Fetch fresh data
-    try {
-      const models = await fetchFn()
-      
-      // Update cache with new data
-      this.cache.set(baseURL, {
-        models: [...models], // Create copy to prevent mutations
-        timestamp: now,
-        ttl: this.DEFAULT_TTL
-      })
-      
-      // Prevent cache from growing too large
-      if (this.cache.size > this.MAX_CACHE_SIZE) {
-        this.cleanup()
-      }
-      
-      
-      return models
-    } catch (error) {
-      // If we have stale cached data, return it as fallback but mark as potentially invalid
-      if (cached) {
-        console.warn(`[opencode-model-discovery] Using stale cache data due to fetch error`, { 
-          baseURL, 
-          age: now - cached.timestamp,
-          error: error instanceof Error ? error.message : String(error) 
-        })
-        // Invalidate cache if it's very old (> 5x TTL)
-        if (now - cached.timestamp > cached.ttl * 5) {
-          this.invalidate(baseURL)
-        }
-        return cached.models
-      }
-      throw error
-    }
-  }
-  
-  // Invalidate cache for specific URL
-  invalidate(baseURL: string): void {
-    this.cache.delete(baseURL)
-  }
-  
-  // Invalidate entire cache
-  invalidateAll(): void {
-    this.cache.clear()
-  }
-  
-  // Force refresh for specific URL (useful after model changes)
-  async forceRefresh(baseURL: string, fetchFn: () => Promise<string[]>): Promise<string[]> {
-    this.invalidate(baseURL)
-    return this.getModels(baseURL, fetchFn)
-  }
-  
-  // Get cache statistics
-  getStats(): CacheStats {
-    const now = Date.now()
-    return {
-      size: this.cache.size,
-      entries: Array.from(this.cache.entries()).map(([baseURL, data]) => ({
-        baseURL,
-        age: now - data.timestamp,
-        modelCount: data.models.length,
-        ttl: data.ttl
-      }))
-    }
-  }
-  
-  // Cleanup old entries to prevent memory leaks
-  private cleanup(): void {
-    const now = Date.now()
-    const toDelete: string[] = []
-    
-    for (const [baseURL, data] of this.cache.entries()) {
-      // Delete entries older than 5x TTL or if cache is too large
-      if (now - data.timestamp > data.ttl * 5 || this.cache.size > this.MAX_CACHE_SIZE) {
-        toDelete.push(baseURL)
-      }
-    }
-    
-    toDelete.forEach(baseURL => this.cache.delete(baseURL))
-    
-    if (toDelete.length > 0) {
-    }
-  }
-  
-  // Configure TTL for specific use cases
-  setTTL(baseURL: string, ttl: number): void {
-    const cached = this.cache.get(baseURL)
-    if (cached) {
-      cached.ttl = ttl
-    }
-  }
-  
-  // Check if cache entry exists and is valid
-  isValid(baseURL: string): boolean {
-    const cached = this.cache.get(baseURL)
-    const now = Date.now()
-    return cached !== undefined && (now - cached.timestamp) < cached.ttl
-  }
-}

package/src/plugin/get-loaded-models.ts

@@ -1,10 +0,0 @@
-import { ModelStatusCache } from '../cache/model-status-cache'
-import { fetchModelsDirect } from '../utils/openai-compatible-api'
-
-const modelStatusCache = new ModelStatusCache()
-
-export function getLoadedModels(baseURL: string): Promise<string[]> {
-  return modelStatusCache.getModels(baseURL, async () => {
-    return await fetchModelsDirect(baseURL)
-  })
-}