opencode-models-discovery 0.4.9 → 0.5.3

package/README.md

@@ -1,5 +1,8 @@
 # opencode-models-discovery
 
+[![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)
+
 > Forked from [opencode-lmstudio](https://github.com/nicktasios/opencode-lmstudio) and expanded to support **any OpenAI-compatible provider**.
 
 OpenCode plugin for auto-discovery of OpenAI-compatible models with dynamic provider configuration.
@@ -66,6 +69,10 @@ The plugin configuration is placed in the `plugin` array using tuple format `["p
         "include": [],
         "exclude": []
       },
+      "models": {
+        "includeRegex": [],
+        "excludeRegex": []
+      },
       "discovery": {
         "enabled": true,
         "ttl": 15000
@@ -97,6 +104,30 @@ Control which providers are discovered:
 }
 ```
 
+#### Model Filtering
+
+Control which discovered models are auto-injected with regular expressions:
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `models.includeRegex` | `string[]` | If non-empty, only discovered model IDs matching at least one regex will be added |
+| `models.excludeRegex` | `string[]` | Discovered model IDs matching any regex will be skipped (only used when `includeRegex` is empty) |
+
+Regex filtering only applies to auto-discovered models. Models already explicitly configured by the user are preserved.
+
+```json
+{
+  "plugin": [
+    ["opencode-models-discovery", {
+      "models": {
+        "includeRegex": ["^qwen/", "gpt-4"],
+        "excludeRegex": ["embedding", "test"]
+      }
+    }]
+  ]
+}
+```
+
 ### How It Works
 
 1. On OpenCode startup, the plugin's `config` hook is called
@@ -119,7 +150,7 @@ The plugin supports any OpenAI-compatible provider. Here are the most common one
 | **Text Generation WebUI** | 5000 | OpenAI-compatible extension | `@ai-sdk/openai-compatible` |
 | **FastChat (Vicuna)** | 8001 | Multi-model serving | `@ai-sdk/openai-compatible` |
 | **vLLM** | 8000 | High-performance inference | `@ai-sdk/openai-compatible` |
-| **Anysphere (Cursor)** |  | IDE with AI completion | `@ai-sdk/anthropic` (with `/v1` backend) |
+| **CLIProxyAPI** | 8317 | A LLM proxy server  | `@ai-sdk/anthropic` (with `/v1` backend) & `@ai-sdk/openai-compatible` |
 
 #### Anthropic API with Custom Backend
 
@@ -203,10 +234,16 @@ This means providers using `@ai-sdk/anthropic` with OpenAI-compatible backends (
 - At least one OpenAI-compatible provider running locally or remotely
 - Provider server API accessible (e.g., `http://127.0.0.1:11434/v1`)
 
+## 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`.
+
+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`.
+
 ## License
 
 MIT
 
 ## Contributing
 
-Contributions are welcome! Please feel free to submit a Pull Request.
+Contributions are welcome! Please feel free to submit a Pull Request.

package/package.json

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

package/src/plugin/config-hook.ts

@@ -1,38 +1,45 @@
 import { ToastNotifier } from '../ui/toast-notifier'
 import { validateConfig } from '../utils/validation'
 import { enhanceConfig } from './enhance-config'
+import type { PluginLogger } from './logger'
 import type { PluginInput } from '@opencode-ai/plugin'
 import type { PluginConfig } from '../types/plugin-config'
 
 export function createConfigHook(
   client: PluginInput['client'],
   toastNotifier: ToastNotifier,
-  pluginConfig: PluginConfig
+  pluginConfig: PluginConfig,
+  logger: PluginLogger
 ) {
   return async (config: any) => {
     if (config && (Object.isFrozen?.(config) || Object.isSealed?.(config))) {
-      console.warn("[opencode-model-discovery] Config object is frozen/sealed - cannot modify directly")
+      logger.warn('Config object is frozen or sealed; cannot modify directly')
       return
     }
 
     const validation = validateConfig(config)
     if (!validation.isValid) {
-      console.error("[opencode-model-discovery] Invalid config provided:", validation.errors)
+      logger.error('Invalid config provided', { errors: validation.errors })
       toastNotifier.error("Plugin configuration is invalid", "Configuration Error").catch(() => {})
       return
     }
 
     if (validation.warnings.length > 0) {
-      console.warn("[opencode-model-discovery] Config warnings:", validation.warnings)
+      logger.warn('Config warnings', { warnings: validation.warnings })
     }
 
     if (pluginConfig.discovery?.enabled === false) {
-      console.log("[opencode-model-discovery] Discovery disabled by configuration")
+      logger.info('Discovery disabled by configuration')
       return
     }
 
-    const startTime = Date.now()
-    const discoveryPromise = enhanceConfig(config, client, toastNotifier, pluginConfig)
+    const discoveryPromise = enhanceConfig(
+      config,
+      client,
+      toastNotifier,
+      pluginConfig,
+      logger.child({ category: 'discovery' })
+    )
     const timeoutMs = 5000
 
     try {
@@ -43,7 +50,9 @@ export function createConfigHook(
         })
       ])
     } catch (error) {
-      console.error("[opencode-model-discovery] Config enhancement failed:", error)
+      logger.error('Config enhancement failed', {
+        error: error instanceof Error ? error.message : String(error),
+      })
     }
   }
-}
+}

package/src/plugin/enhance-config.ts

@@ -2,7 +2,8 @@ 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, shouldDiscoverProvider } from '../types/plugin-config'
+import { getProviderFilter, getDiscoveryConfig, getModelRegexFilter, shouldDiscoverModel, shouldDiscoverProvider } 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'
@@ -19,7 +20,8 @@ export async function enhanceConfig(
   config: any,
   client: PluginInput['client'],
   toastNotifier: ToastNotifier,
-  pluginConfig: PluginConfig
+  pluginConfig: PluginConfig,
+  logger: PluginLogger
 ): Promise<void> {
   modelStatusCache.invalidateAll()
   
@@ -27,6 +29,7 @@ export async function enhanceConfig(
     const providers = config.provider || {}
     const openAICompatibleProviders: DiscoveredProvider[] = []
     const providerFilter = getProviderFilter(pluginConfig)
+    const modelRegexFilter = getModelRegexFilter(pluginConfig, logger.child({ category: 'filtering' }))
     const discoveryConfig = getDiscoveryConfig(pluginConfig)
 
     for (const [providerName, providerConfig] of Object.entries(providers)) {
@@ -61,6 +64,11 @@ export async function enhanceConfig(
       try {
         models = await discoverModelsFromProvider(baseURL, apiKey)
       } catch (error) {
+        logger.warn('Provider model discovery failed', {
+          provider: providerName,
+          baseURL,
+          error: error instanceof Error ? error.message : String(error),
+        })
         continue
       }
 
@@ -77,6 +85,10 @@ export async function enhanceConfig(
         const modelKey = model.id
 
         if (!existingModels[modelKey]) {
+          if (!shouldDiscoverModel(model.id, modelRegexFilter)) {
+            continue
+          }
+
           const modelType = categorizeModel(model.id)
           const owner = extractModelOwner(model.id)
           const modelConfig: any = {
@@ -126,13 +138,19 @@ export async function enhanceConfig(
 
     if (openAICompatibleProviders.length > 0) {
       const totalModels = openAICompatibleProviders.reduce((sum, p) => sum + Object.keys(p.models).length, 0)
-      // Discovery complete - models are now available
+      logger.info('Provider model discovery completed', {
+        providerCount: openAICompatibleProviders.length,
+        modelCount: totalModels,
+      })
     }
 
     if (Object.keys(providers).length === 0) {
       const detected = await autoDetectOpenAICompatibleProvider()
       if (detected) {
-        // Auto-detection found a provider, but no config exists
+        logger.info('Detected OpenAI-compatible provider but found no configured providers', {
+          provider: detected.name,
+          baseURL: detected.baseURL,
+        })
       }
     }
 
@@ -155,9 +173,14 @@ export async function enhanceConfig(
         }
       }
     } catch (error) {
+      logger.warn('Model status cache refresh failed', {
+        error: error instanceof Error ? error.message : String(error),
+      })
     }
   } catch (error) {
-    console.error("[opencode-model-discovery] Unexpected error in enhanceConfig:", error)
+    logger.error('Unexpected error in enhanceConfig', {
+      error: error instanceof Error ? error.message : String(error),
+    })
     toastNotifier.warning("Plugin configuration failed", "Configuration Error").catch(() => {})
   }
-}
+}

package/src/plugin/event-hook.ts

@@ -1,18 +1,16 @@
 import { validateHookInput } from '../utils/validation'
+import type { PluginLogger } from './logger'
 
-export function createEventHook() {
+export function createEventHook(logger: PluginLogger) {
   return async ({ event }: { event: any }) => {
-    // Validate event input
     const validation = validateHookInput('event', { event })
     if (!validation.isValid) {
-      console.error("[opencode-model-discovery] Invalid event input:", validation.errors)
+      logger.error('Invalid event input', { errors: validation.errors })
       return
     }
     
-    // Monitor for session events to provide LM Studio status
     if (event.type === "session.created" || event.type === "session.updated") {
-      // Could add health check monitoring here in the future
+      // Reserved for future session-aware discovery diagnostics.
     }
   }
 }
-

package/src/plugin/index.ts

@@ -3,15 +3,15 @@ import { ToastNotifier } from '../ui/toast-notifier'
 import { createConfigHook } from './config-hook'
 import { createEventHook } from './event-hook'
 import { createChatParamsHook } from './chat-params-hook'
+import { createPluginLogger } from './logger'
 import { parsePluginConfig, type PluginConfig } from '../types/plugin-config'
 
 export const ModelDiscoveryPlugin: Plugin = async (input: PluginInput, options?: PluginOptions) => {
-  console.log("[opencode-model-discovery] Model discovery plugin initialized")
-
   const { client } = input
+  const logger = createPluginLogger(client, { category: 'plugin' })
 
   if (!client || typeof client !== 'object') {
-    console.error("[opencode-model-discovery] Invalid client provided to plugin")
+    logger.error('Invalid client provided to plugin')
     return {
       config: async () => {},
       event: async () => {},
@@ -19,19 +19,21 @@ export const ModelDiscoveryPlugin: Plugin = async (input: PluginInput, options?:
     }
   }
 
+  logger.info('Model discovery plugin initialized')
+
   const pluginConfig: PluginConfig = parsePluginConfig(options || {})
 
   if (pluginConfig.discovery?.enabled === false) {
-    console.log("[opencode-model-discovery] Discovery disabled by configuration")
+    logger.info('Discovery disabled by configuration', { category: 'config' })
   }
 
   const toastNotifier = new ToastNotifier(client)
 
   return {
-    config: createConfigHook(client, toastNotifier, pluginConfig),
-    event: createEventHook(),
+    config: createConfigHook(client, toastNotifier, pluginConfig, logger.child({ category: 'config' })),
+    event: createEventHook(logger.child({ category: 'event' })),
     "chat.params": createChatParamsHook(toastNotifier, pluginConfig),
   }
 }
 
-export const LMStudioPlugin = ModelDiscoveryPlugin
+export const LMStudioPlugin = ModelDiscoveryPlugin

package/src/plugin/logger.ts

@@ -0,0 +1,98 @@
+import type { PluginInput } from '@opencode-ai/plugin'
+
+const SERVICE_NAME = 'opencode-models-discovery'
+
+type LogLevel = 'debug' | 'info' | 'warn' | 'error'
+
+type LogExtra = Record<string, unknown>
+
+type PluginClient = PluginInput['client'] | null | undefined
+
+export interface PluginLogger {
+  debug(message: string, extra?: LogExtra): void
+  info(message: string, extra?: LogExtra): void
+  warn(message: string, extra?: LogExtra): void
+  error(message: string, extra?: LogExtra): void
+  child(extra: LogExtra): PluginLogger
+}
+
+function getConsoleMethod(level: LogLevel): typeof console.log {
+  if (level === 'error') {
+    return console.error
+  }
+
+  if (level === 'warn') {
+    return console.warn
+  }
+
+  if (level === 'debug') {
+    return console.debug
+  }
+
+  return console.info
+}
+
+function mergeExtra(baseExtra: LogExtra, extra?: LogExtra): LogExtra | undefined {
+  const merged = {
+    ...baseExtra,
+    ...extra,
+  }
+
+  return Object.keys(merged).length > 0 ? merged : undefined
+}
+
+function fallbackToConsole(level: LogLevel, message: string, extra?: LogExtra) {
+  const log = getConsoleMethod(level)
+  const prefix = `[${SERVICE_NAME}] ${message}`
+
+  if (extra && Object.keys(extra).length > 0) {
+    log(prefix, extra)
+    return
+  }
+
+  log(prefix)
+}
+
+export function createPluginLogger(client?: PluginClient, baseExtra: LogExtra = {}): PluginLogger {
+  const log = (level: LogLevel, message: string, extra?: LogExtra) => {
+    const mergedExtra = mergeExtra(baseExtra, extra)
+
+    try {
+      if (client?.app?.log) {
+        void client.app.log({
+          body: {
+            service: SERVICE_NAME,
+            level,
+            message,
+            extra: mergedExtra,
+          },
+        }).catch(() => {
+          fallbackToConsole(level, message, mergedExtra)
+        })
+        return
+      }
+    } catch {
+      // Fall back to console logging when structured logging is unavailable.
+    }
+
+    fallbackToConsole(level, message, mergedExtra)
+  }
+
+  return {
+    debug(message, extra) {
+      log('debug', message, extra)
+    },
+    info(message, extra) {
+      log('info', message, extra)
+    },
+    warn(message, extra) {
+      log('warn', message, extra)
+    },
+    error(message, extra) {
+      log('error', message, extra)
+    },
+    child(extra) {
+      return createPluginLogger(client, mergeExtra(baseExtra, extra) || {})
+    },
+  }
+}

package/src/types/plugin-config.ts

@@ -3,6 +3,10 @@ export interface PluginConfig {
     include?: string[]
     exclude?: string[]
   }
+  models?: {
+    includeRegex?: string[]
+    excludeRegex?: string[]
+  }
   discovery?: {
     enabled?: boolean
     ttl?: number
@@ -19,6 +23,11 @@ export interface DiscoveryConfig {
   ttl: number
 }
 
+export interface ModelRegexFilter {
+  includeRegex: RegExp[]
+  excludeRegex: RegExp[]
+}
+
 export const DEFAULT_DISCOVERY_CONFIG: DiscoveryConfig = {
   enabled: true,
   ttl: 15000,
@@ -48,6 +57,38 @@ export function getDiscoveryConfig(config: PluginConfig): DiscoveryConfig {
   }
 }
 
+function toRegExp(pattern: string, logger?: PluginLogger): RegExp | null {
+  try {
+    return new RegExp(pattern)
+  } catch {
+    if (logger) {
+      logger.warn('Ignoring invalid model regex', { category: 'filtering', pattern })
+    } else {
+      console.warn(`[opencode-model-discovery] Ignoring invalid model regex: ${pattern}`)
+    }
+    return null
+  }
+}
+
+export function getModelRegexFilter(config: PluginConfig, 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))
+  }
+
+  if (filter.excludeRegex.length > 0) {
+    return !filter.excludeRegex.some((pattern) => pattern.test(modelId))
+  }
+
+  return true
+}
+
 export function parsePluginConfig(rawConfig: any): PluginConfig {
   if (!rawConfig) {
     return {}
@@ -68,4 +109,5 @@ export function parsePluginConfig(rawConfig: any): PluginConfig {
   }
 
   return {}
-}
+}
+import type { PluginLogger } from '../plugin/logger'