Publish v1.1.0 (#48)

github-actions[bot] · Riven-Spell · yuhp · web-flow · commit fdffd8baa644 · 2026-07-20T11:38:24.000+08:00
* Add vllm backend support (#47) * `npm audit fix` * Refactor to use an enum instead for ModelInfoFormat * Add support for vLLM-compatible-backed endpoints to provide model context length * Trim unnecessary tests * Remove input limit * Revert "`npm audit fix`" This reverts commit d5d98a2. * test: align vLLM limit expectation --------- Co-authored-by: yuhp <yu.haip@gmail.com> * docs: document vLLM model info enrichment * chore: bump version to 1.1.0 --------- Co-authored-by: Adele <virepri2k@gmail.com> Co-authored-by: yuhp <yu.haip@gmail.com> Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
diff --git a/docs/configuration.md b/docs/configuration.md
@@ -39,7 +39,7 @@ Each provider can configure discovery behavior through `provider.<name>.options.
 | `provider.<name>.options.modelsDiscovery.enabled` | `boolean` | Force enable or disable discovery for a single provider |
 | `provider.<name>.options.modelsDiscovery.endpoint` | `string` | Provider-specific models endpoint path. Defaults to `/v1/models` |
 | `provider.<name>.options.modelsDiscovery.modelInfoEndpoint` | `string` | Provider-specific model info endpoint path. Metadata enrichment is disabled when omitted |
-| `provider.<name>.options.modelsDiscovery.modelInfoFormat` | `string` | Model info response format. Currently supports `"litellm"` and `"models.dev"` |
+| `provider.<name>.options.modelsDiscovery.modelInfoFormat` | `string` | Model info response format. Currently supports `"litellm"`, `"models.dev"`, and `"vllm"` |
 | `provider.<name>.options.modelsDiscovery.filterNonChat` | `boolean` | When model info is available, skip models whose `model_info.mode` is not `chat`. Defaults to `true` |
 | `provider.<name>.options.modelsDiscovery.models.includeRegex` | `string[]` | Shortcut regex allow-list for discovered model ids only |
 | `provider.<name>.options.modelsDiscovery.models.excludeRegex` | `string[]` | Shortcut regex deny-list for discovered model ids only |
@@ -145,12 +145,13 @@ Community provider examples live in [`docs/config_example/`](config_example/).
 
 The generic OpenAI-compatible `/v1/models` endpoint only guarantees a small model list shape. Extra metadata such as context limits, tool calling, reasoning, image input, or structured output is provider-specific, so metadata enrichment is opt-in.
 
-The plugin currently supports two model info formats:
+The plugin currently supports three model info formats:
 
 | Format | Source | Requires `modelInfoEndpoint` | Notes |
 |--------|--------|------------------------------|-------|
 | `"litellm"` | Provider-specific model info endpoint | Yes | Uses LiteLLM `/v1/model/info` responses |
 | `"models.dev"` | `https://models.dev/models.json` | No | Uses the public models.dev metadata index |
+| `"vllm"` | Fields in the provider's `/v1/models` response | No | Reads vLLM-style `max_model_len` when present |
 
 ### LiteLLM Model Info
 
@@ -187,6 +188,34 @@ When model info is available, the plugin uses LiteLLM `model_info` fields to pop
 - `supports_*_reasoning_effort` and `supported_openai_params` create reasoning `variants`
 - By default, entries whose `model_info.mode` is not `chat` are skipped
 
+### vLLM Model Info
+
+Use `modelInfoFormat: "vllm"` for a vLLM-compatible provider whose `/v1/models` response includes a numeric `max_model_len` field for each model. This does not make another metadata request.
+
+```json
+{
+  "plugin": ["opencode-models-discovery"],
+  "provider": {
+    "local-vllm": {
+      "npm": "@ai-sdk/openai-compatible",
+      "name": "Local vLLM",
+      "options": {
+        "baseURL": "http://127.0.0.1:8000/v1",
+        "modelsDiscovery": {
+          "enabled": true,
+          "modelInfoFormat": "vllm"
+        }
+      },
+      "models": {}
+    }
+  }
+}
+```
+
+For each discovered model with a positive numeric `max_model_len`, the plugin sets `limit.context` and `limit.output` to that value. `max_model_len` represents the total request sequence length shared by prompt and generated tokens; it is not used as an independent input limit.
+
+`max_model_len` is not part of the standard OpenAI-compatible `/v1/models` response. If a vLLM deployment or proxy does not expose it, discovery still succeeds but no limit is added. This format does not infer reasoning, tool-calling, modalities, or other capabilities.
+
 ### models.dev Metadata
 
 Use `modelInfoFormat: "models.dev"` to enrich discovered models from the public [models.dev](https://models.dev) metadata index.
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "opencode-models-discovery",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "OpenCode plugin for auto-discovery of OpenAI-compatible models with dynamic provider configuration",
   "type": "module",
   "main": "./src/index.ts",
diff --git a/src/plugin/commands.ts b/src/plugin/commands.ts
@@ -116,6 +116,7 @@ Supported plugin options under provider.<id>.options.modelsDiscovery:
 - smartModelName: use friendlier display names for discovered models
 - modelInfoFormat="models.dev": enrich from the public models.dev index without modelInfoEndpoint
 - modelInfoEndpoint plus modelInfoFormat="litellm": enrich from a LiteLLM-compatible model info endpoint
+- modelInfoFormat="vllm": for vLLM-compatible providers whose raw /v1/models entries include a positive numeric max_model_len; without another request, sets limit.context and limit.output for matching discovered models
 - filterNonChat: when LiteLLM model info is available, skip non-chat models by default
 
 Recommended defaults:
@@ -135,6 +136,7 @@ Recommended defaults:
 - use smartModelName=true only when the user wants friendlier display names
 - use modelInfoFormat="models.dev" for models.dev metadata enrichment
 - use modelInfoEndpoint and modelInfoFormat="litellm" for LiteLLM-compatible model info endpoints
+- use modelInfoFormat="vllm" only when the provider's /v1/models response exposes max_model_len; it is not a standard OpenAI-compatible field, does not require modelInfoEndpoint, and does not infer other capabilities
 
 Provider compatibility guidance:
 - Discovery works for @ai-sdk/openai-compatible providers by default.
diff --git a/src/plugin/enhance-config.ts b/src/plugin/enhance-config.ts
@@ -5,7 +5,7 @@ import { ToastNotifier } from '../ui/toast-notifier'
 import { categorizeModel, formatModelName, extractModelOwner } from '../utils'
 import { normalizeBaseURL, discoverModelsFromProvider, discoverModelInfoFromProvider, canDiscoverModels } from '../utils/openai-compatible-api'
 import { createModelInfoEnricher, isSupportedModelInfoFormat, type ModelInfoEnricher } from '../utils/model-info'
-import { getDefaultDiscoveryConfigFromEnv, getProviderModelFieldFilters, getProviderModelRegexFilter, shouldDiscoverModel, shouldDiscoverModelByFields, shouldDiscoverProviderWithOverride } from '../types/plugin-config'
+import { getDefaultDiscoveryConfigFromEnv, getProviderModelFieldFilters, getProviderModelRegexFilter, shouldDiscoverModel, shouldDiscoverModelByFields, shouldDiscoverProviderWithOverride, ModelInfoFormat } from '../types/plugin-config'
 import { fetchModelsDevData } from '../utils/models-dev-fetcher'
 import type { PluginLogger } from './logger'
 import type { PluginInput } from '@opencode-ai/plugin'
@@ -231,13 +231,15 @@ export async function enhanceConfig(
           provider: providerName,
           format: modelInfoFormat,
         })
-      } else if (modelInfoFormat === 'models.dev') {
+      } else if (modelInfoFormat === ModelInfoFormat.ModelsDev) {
         const modelsDevCache = await fetchModelsDevData()
         modelInfoEnricher = createModelInfoEnricher(modelInfoFormat, modelsDevCache, { filterNonChat })
         logger.info('Loaded models.dev data', {
           provider: providerName,
           count: modelsDevCache.size,
         })
+      } else if (modelInfoFormat === ModelInfoFormat.VLLM) {
+        modelInfoEnricher = createModelInfoEnricher(modelInfoFormat, null)
       } else if (typeof modelInfoEndpoint === 'string' && modelInfoEndpoint.length > 0 && modelInfoFormat) {
         const modelInfoDiscovery = await discoverModelInfoFromProvider(baseURL, apiKey, modelInfoEndpoint)
         if (modelInfoDiscovery.ok) {
@@ -299,7 +301,7 @@ export async function enhanceConfig(
             }
           }
 
-          modelInfoEnricher?.applyModelInfo(modelConfig, model.id)
+          modelInfoEnricher?.applyModelInfo(modelConfig, model.id, model)
 
           discoveredModels[modelKey] = modelConfig
         }
diff --git a/src/types/plugin-config.ts b/src/types/plugin-config.ts
@@ -29,7 +29,11 @@ export type ModelFieldFilter = ModelFieldEqualsFilter | ModelFieldMatchFilter
 
 export type CompiledModelFieldFilter = ModelFieldEqualsFilter | (Omit<ModelFieldMatchFilter, 'match'> & { match: RegExp })
 
-export type ModelInfoFormat = 'litellm' | 'models.dev' | (string & {})
+export enum ModelInfoFormat {
+  LiteLLM = 'litellm',
+  ModelsDev = 'models.dev',
+  VLLM = 'vllm',
+}
 
 export interface ProviderDiscoveryConfig {
   enabled?: boolean
diff --git a/src/utils/model-info/index.ts b/src/utils/model-info/index.ts
@@ -1,19 +1,21 @@
 import { createLiteLLMModelInfoEnricher } from './litellm'
 import { createModelsDevModelInfoEnricher } from './models-dev'
-import type { ModelInfoFormat } from '../../types/plugin-config'
+import { createVLLMModelInfoEnricher } from './vllm'
+import { ModelInfoFormat } from '../../types/plugin-config'
 import type { ModelInfoEnricher, ModelInfoEnricherOptions } from './types'
 
-type ModelInfoEnricherFactory = (data: unknown, options: ModelInfoEnricherOptions) => ModelInfoEnricher
+type ModelInfoEnricherFactory = (data: unknown, options?: ModelInfoEnricherOptions) => ModelInfoEnricher
 
-const MODEL_INFO_ENRICHERS: Record<string, ModelInfoEnricherFactory> = {
-  litellm: createLiteLLMModelInfoEnricher,
-  'models.dev': createModelsDevModelInfoEnricher,
+const MODEL_INFO_ENRICHERS: Partial<Record<ModelInfoFormat, ModelInfoEnricherFactory>> = {
+  [ModelInfoFormat.LiteLLM]: createLiteLLMModelInfoEnricher,
+  [ModelInfoFormat.ModelsDev]: createModelsDevModelInfoEnricher,
+  [ModelInfoFormat.VLLM]: createVLLMModelInfoEnricher,
 }
 
 export function createModelInfoEnricher(
   format: ModelInfoFormat,
   data: unknown,
-  options: ModelInfoEnricherOptions
+  options?: ModelInfoEnricherOptions
 ): ModelInfoEnricher | undefined {
   return MODEL_INFO_ENRICHERS[format]?.(data, options)
 }
diff --git a/src/utils/model-info/litellm.ts b/src/utils/model-info/litellm.ts
@@ -100,14 +100,14 @@ function getModelInfo(modelInfoById: Map<string, LiteLLMModelInfoEntry>, modelId
 
 export function createLiteLLMModelInfoEnricher(
   data: unknown,
-  options: ModelInfoEnricherOptions
+  options?: ModelInfoEnricherOptions
 ): ModelInfoEnricher {
   const response = data as { data?: LiteLLMModelInfoEntry[] } | undefined
   const modelInfoById = buildModelInfoMap(Array.isArray(response?.data) ? response.data : [])
 
   return {
     shouldSkipModel(modelId: string): boolean {
-      if (!options.filterNonChat) return false
+      if (!options?.filterNonChat) return false
       const mode = getModelInfo(modelInfoById, modelId)?.model_info?.mode
       return typeof mode === 'string' && mode.length > 0 && mode !== 'chat'
     },
diff --git a/src/utils/model-info/types.ts b/src/utils/model-info/types.ts
@@ -1,7 +1,7 @@
 export interface ModelInfoEnricher {
   shouldSkipModel(modelId: string): boolean
   getModelName?(modelId: string): string | undefined
-  applyModelInfo(modelConfig: any, modelId: string): void
+  applyModelInfo(modelConfig: any, modelId: string, rawModel?: Record<string, unknown>): void
 }
 
 export interface ModelInfoEnricherOptions {
diff --git a/src/utils/model-info/vllm.ts b/src/utils/model-info/vllm.ts
@@ -0,0 +1,22 @@
+import type { ModelInfoEnricher, ModelInfoEnricherOptions } from './types'
+
+function hasUsableNumber(value: unknown): value is number {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0
+}
+
+export function createVLLMModelInfoEnricher(_data: unknown, _options?: ModelInfoEnricherOptions): ModelInfoEnricher {
+  return {
+    shouldSkipModel(): boolean {
+      return false
+    },
+    applyModelInfo(modelConfig: any, _modelId: string, rawModel?: Record<string, unknown>): void {
+      const maxModelLen = rawModel?.max_model_len
+      if (hasUsableNumber(maxModelLen)) {
+        modelConfig.limit = {
+          context: maxModelLen,
+          output: maxModelLen,
+        }
+      }
+    },
+  }
+}
diff --git a/test/plugin-config.test.ts b/test/plugin-config.test.ts
@@ -0,0 +1,39 @@
+import { describe, it, expect } from 'vitest'
+import { isSupportedModelInfoFormat } from '../src/utils/model-info'
+
+describe('JSON config struct parsing', () => {
+  function parse(json: string): Record<string, unknown> {
+    return JSON.parse(json)
+  }
+
+  it.each([
+    { json: '{"modelInfoFormat":"litellm"}', expected: true },
+    { json: '{"modelInfoFormat":"models.dev"}', expected: true },
+    { json: '{"modelInfoFormat":"vllm"}', expected: true },
+    { json: '{"modelInfoFormat":"bogus"}', expected: false },
+  ])('handles modelInfoFormat=$json', ({ json, expected }) => {
+    const config = parse(json)
+    expect(isSupportedModelInfoFormat(config.modelInfoFormat)).toBe(expected)
+  })
+
+  it('handles absence of modelInfoFormat', () => {
+    const config = parse('{"enabled":true}')
+    expect(config.modelInfoFormat).toBeUndefined()
+  })
+
+  it('handles a full provider discovery config from JSON', () => {
+    const json = `{
+      "enabled": true,
+      "endpoint": "/v1/models",
+      "modelInfoEndpoint": "/v1/model/info",
+      "modelInfoFormat": "litellm",
+      "filterNonChat": true,
+      "models": {
+        "includeBy": [{ "field": "id", "match": "^chat-" }]
+      }
+    }`
+    const config = parse(json)
+    expect(config.modelInfoFormat).toBe('litellm')
+    expect(isSupportedModelInfoFormat(config.modelInfoFormat)).toBe(true)
+  })
+})
diff --git a/test/plugin.test.ts b/test/plugin.test.ts
@@ -257,6 +257,8 @@ describe('ModelDiscovery Plugin', () => {
         expect(config.command['models-discovery:config'].template).toContain('excludeBy')
         expect(config.command['models-discovery:config'].template).toContain('modelInfoFormat="models.dev"')
         expect(config.command['models-discovery:config'].template).toContain('modelInfoFormat="litellm"')
+        expect(config.command['models-discovery:config'].template).toContain('modelInfoFormat="vllm"')
+        expect(config.command['models-discovery:config'].template).toContain('max_model_len')
         expect(config.command['models-discovery:config'].template).toContain('restart opencode')
 
         expect(mockClient.tui.showToast).not.toHaveBeenCalled()
diff --git a/test/vllm-model-info.test.ts b/test/vllm-model-info.test.ts
@@ -0,0 +1,43 @@
+import { describe, it, expect } from 'vitest'
+import { ModelInfoFormat } from '../src/types/plugin-config'
+import { createModelInfoEnricher } from '../src/utils/model-info'
+
+describe('vLLM model info enricher', () => {
+  it('extracts max_model_len from raw model', () => {
+    const enricher = createModelInfoEnricher(ModelInfoFormat.VLLM, null)
+    expect(enricher).toBeDefined()
+
+    const modelConfig: any = { id: 'test-model' }
+    const rawModel: Record<string, unknown> = {
+      id: 'test-model',
+      object: 'model',
+      created: 1,
+      owned_by: 'vllm',
+      max_model_len: 8192,
+    }
+
+    enricher!.applyModelInfo(modelConfig, 'test-model', rawModel)
+    expect(modelConfig.limit).toEqual({
+      context: 8192,
+      output: 8192,
+    })
+  })
+
+  it('does not set limit when max_model_len is missing', () => {
+    const enricher = createModelInfoEnricher(ModelInfoFormat.VLLM, null)
+    expect(enricher).toBeDefined()
+
+    const modelConfig: any = { id: 'test-model' }
+    enricher!.applyModelInfo(modelConfig, 'test-model', { id: 'test-model', object: 'model', created: 1, owned_by: 'llama.cpp' })
+    expect(modelConfig.limit).toBeUndefined()
+  })
+
+  it('does not set limit for non-positive max_model_len values', () => {
+    const enricher = createModelInfoEnricher(ModelInfoFormat.VLLM, null)
+    expect(enricher).toBeDefined()
+
+    const modelConfig: any = { id: 'test-model' }
+    enricher!.applyModelInfo(modelConfig, 'test-model', { id: 'test-model', object: 'model', created: 1, owned_by: 'vllm', max_model_len: 0 })
+    expect(modelConfig.limit).toBeUndefined()
+  })
+})

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`{`
`2`	`2`	`"$schema": "https://json.schemastore.org/package.json",`
`3`	`3`	`"name": "opencode-models-discovery",`
`4`		`- "version": "1.0.2",`
	`4`	`+ "version": "1.1.0",`
`5`	`5`	`"description": "OpenCode plugin for auto-discovery of OpenAI-compatible models with dynamic provider configuration",`
`6`	`6`	`"type": "module",`
`7`	`7`	`"main": "./src/index.ts",`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`export interface ModelInfoEnricher {`
`2`	`2`	`shouldSkipModel(modelId: string): boolean`
`3`	`3`	`getModelName?(modelId: string): string \| undefined`
`4`		`- applyModelInfo(modelConfig: any, modelId: string): void`
	`4`	`+ applyModelInfo(modelConfig: any, modelId: string, rawModel?: Record<string, unknown>): void`
`5`	`5`	`}`
`6`	`6`
`7`	`7`	`export interface ModelInfoEnricherOptions {`