opencode-provider-litellm 0.5.2 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-provider-litellm",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "OpenCode plugin for any LiteLLM proxy — auto-discovers models, auth, and capabilities",
   "type": "module",
   "exports": {

package/src/model-cache.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect, vi, afterEach } from 'vitest'
+import type { OpencodeModelConfig } from './types.js'
+
+const mockReadFileSync = vi.hoisted(() => vi.fn())
+const mockWriteFileSync = vi.hoisted(() => vi.fn())
+
+vi.mock('fs', () => ({
+  existsSync: vi.fn(() => true),
+  readFileSync: mockReadFileSync,
+  writeFileSync: mockWriteFileSync,
+}))
+
+vi.mock('os', () => ({
+  homedir: () => '/home/test',
+}))
+
+const { loadModelCache, saveModelCache } = await import('./model-cache.js')
+
+const sampleModels: Record<string, OpencodeModelConfig> = {
+  'anthropic/claude-sonnet': {
+    name: 'anthropic/claude-sonnet',
+    tool_call: true,
+    reasoning: true,
+    limit: { context: 1_000_000, output: 64_000 },
+    cost: { input: 3, output: 15, cache_read: 0.3, cache_write: 3.75 },
+    modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+  },
+  'qwen/qwen3.6-27b': {
+    name: 'qwen/qwen3.6-27b',
+    tool_call: true,
+    reasoning: false,
+    limit: { context: 262144, output: 32768 },
+    modalities: { input: ['text'], output: ['text'] },
+  },
+}
+
+describe('loadModelCache', () => {
+  afterEach(() => vi.clearAllMocks())
+
+  it('returns null when file does not exist', () => {
+    mockReadFileSync.mockImplementation(() => { throw new Error('ENOENT') })
+    expect(loadModelCache('protector')).toBeNull()
+  })
+
+  it('returns null when file contains invalid JSON', () => {
+    mockReadFileSync.mockReturnValue('not valid json{{{')
+    expect(loadModelCache('protector')).toBeNull()
+  })
+
+  it('returns null when providerId does not match', () => {
+    mockReadFileSync.mockReturnValue(JSON.stringify({
+      savedAt: Date.now(), providerId: 'other', models: sampleModels,
+    }))
+    expect(loadModelCache('protector')).toBeNull()
+  })
+
+  it('returns null when models field is missing', () => {
+    mockReadFileSync.mockReturnValue(JSON.stringify({
+      savedAt: Date.now(), providerId: 'protector', models: null,
+    }))
+    expect(loadModelCache('protector')).toBeNull()
+  })
+
+  it('returns models when cache is valid', () => {
+    mockReadFileSync.mockReturnValue(JSON.stringify({
+      savedAt: Date.now(), providerId: 'protector', models: sampleModels,
+    }))
+    expect(loadModelCache('protector')).toEqual(sampleModels)
+  })
+
+  it('reads from the correct path', () => {
+    mockReadFileSync.mockReturnValue(JSON.stringify({
+      savedAt: Date.now(), providerId: 'protector', models: sampleModels,
+    }))
+    loadModelCache('protector')
+    expect(mockReadFileSync).toHaveBeenCalledWith(
+      expect.stringContaining('opencode-provider-litellm-cache.json'),
+      'utf-8',
+    )
+  })
+})
+
+describe('saveModelCache', () => {
+  afterEach(() => vi.clearAllMocks())
+
+  it('writes a valid cache file', () => {
+    saveModelCache('protector', sampleModels)
+    expect(mockWriteFileSync).toHaveBeenCalledOnce()
+    const [filePath, content] = mockWriteFileSync.mock.calls[0] as [string, string, string]
+    expect(filePath).toContain('opencode-provider-litellm-cache.json')
+    const parsed = JSON.parse(content)
+    expect(parsed.providerId).toBe('protector')
+    expect(parsed.models).toEqual(sampleModels)
+    expect(typeof parsed.savedAt).toBe('number')
+  })
+
+  it('writes to the correct path under ~/.local/share/opencode/', () => {
+    saveModelCache('protector', sampleModels)
+    const [filePath] = mockWriteFileSync.mock.calls[0] as [string, string, string]
+    expect(filePath).toMatch(/\.local[/\\]share[/\\]opencode[/\\]opencode-provider-litellm-cache\.json/)
+  })
+
+  it('does not throw when writeFileSync fails', () => {
+    mockWriteFileSync.mockImplementation(() => { throw new Error('EACCES') })
+    expect(() => saveModelCache('protector', sampleModels)).not.toThrow()
+  })
+
+  it('round-trips correctly with loadModelCache', () => {
+    let written = ''
+    mockWriteFileSync.mockImplementation((_p: string, content: string) => { written = content })
+    mockReadFileSync.mockImplementation(() => written)
+    saveModelCache('protector', sampleModels)
+    expect(loadModelCache('protector')).toEqual(sampleModels)
+  })
+})

package/src/model-cache.ts

@@ -0,0 +1,49 @@
+import { existsSync, readFileSync, writeFileSync } from 'fs'
+import { join } from 'path'
+import { homedir } from 'os'
+import type { OpencodeModelConfig } from './types.js'
+
+const CACHE_FILENAME = 'opencode-provider-litellm-cache.json'
+
+interface ModelCache {
+  savedAt: number
+  providerId: string
+  models: Record<string, OpencodeModelConfig>
+}
+
+function getCachePath(): string {
+  return join(homedir(), '.local', 'share', 'opencode', CACHE_FILENAME)
+}
+
+/**
+ * Loads the model cache from disk. Returns null if the file does not exist,
+ * cannot be parsed, or belongs to a different provider.
+ */
+export function loadModelCache(providerId: string): Record<string, OpencodeModelConfig> | null {
+  try {
+    const raw = readFileSync(getCachePath(), 'utf-8')
+    const cache = JSON.parse(raw) as ModelCache
+    if (cache.providerId !== providerId) return null
+    if (!cache.models || typeof cache.models !== 'object') return null
+    return cache.models
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Saves the discovered models to the cache file on disk. Failures are
+ * non-fatal — discovery already succeeded.
+ */
+export function saveModelCache(providerId: string, models: Record<string, OpencodeModelConfig>): void {
+  try {
+    const cache: ModelCache = {
+      savedAt: Date.now(),
+      providerId,
+      models,
+    }
+    writeFileSync(getCachePath(), JSON.stringify(cache, null, 2), 'utf-8')
+  } catch {
+    // Non-fatal — cache will be written next time
+  }
+}

package/src/plugin.test.ts

@@ -26,6 +26,12 @@ vi.mock('./gcloud-token.js', () => ({
   resetTokenCache: vi.fn(),
 }))
 
+// Mock the model cache module — no cache by default
+vi.mock('./model-cache.js', () => ({
+  loadModelCache: vi.fn().mockReturnValue(null),
+  saveModelCache: vi.fn(),
+}))
+
 import { LiteLLMPlugin } from './plugin.js'
 import { discoverModels, injectModelsIntoConfig } from './discovery.js'
 import { resolvePluginConfig } from './utils.js'

package/src/plugin.ts

@@ -3,6 +3,7 @@ import { resolvePluginConfig, getProviderId } from './utils.js'
 import { discoverModels, injectModelsIntoConfig } from './discovery.js'
 import { createMcpToolDefinitions } from './mcp-tools.js'
 import { getGcloudToken } from './gcloud-token.js'
+import { loadModelCache, saveModelCache } from './model-cache.js'
 
 export const LiteLLMPlugin: Plugin = async (
   input: PluginInput,
@@ -45,11 +46,23 @@ export const LiteLLMPlugin: Plugin = async (
 
   const result: Record<string, unknown> = {
     config: async (config: Record<string, any>) => {
-      try {
-        const models = await discoverModels(
-          pluginConfig,
-          getToken,
+      // Inject cached models immediately so opencode has something to work
+      // with while live discovery runs.
+      const cachedModels = loadModelCache(providerId)
+      if (cachedModels) {
+        const token = await getToken()
+        injectModelsIntoConfig(
+          config as Parameters<typeof injectModelsIntoConfig>[0],
+          providerId,
+          pluginConfig.url,
+          token,
+          cachedModels,
         )
+      }
+
+      // Discover live models, update cache, and re-inject with fresh data.
+      try {
+        const models = await discoverModels(pluginConfig, getToken)
 
         if (Object.keys(models).length === 0) {
           await input.client.app.log({
@@ -60,6 +73,7 @@ export const LiteLLMPlugin: Plugin = async (
             },
           })
         } else {
+          saveModelCache(providerId, models)
           const token = await getToken()
           injectModelsIntoConfig(
             config as Parameters<typeof injectModelsIntoConfig>[0],