opencode-provider-litellm 0.3.1 → 0.5.0

package/src/plugin.test.ts

@@ -1,4 +1,4 @@
-import { vi, describe, it, expect, beforeEach } from 'vitest'
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest'
 import type { PluginInput } from '@opencode-ai/plugin'
 import type { OpencodeModelConfig } from './types.js'
 
@@ -20,17 +20,16 @@ vi.mock('./mcp-tools.js', () => ({
   createMcpToolDefinitions: vi.fn(),
 }))
 
-// Mock the Skills module
-vi.mock('./skills.js', () => ({
-  createSkillToolDefinitions: vi.fn(),
-  createSkillsInjector: vi.fn(),
+// Mock the gcloud token module
+vi.mock('./gcloud-token.js', () => ({
+  getGcloudToken: vi.fn(),
+  resetTokenCache: vi.fn(),
 }))
 
 import { LiteLLMPlugin } from './plugin.js'
 import { discoverModels, injectModelsIntoConfig } from './discovery.js'
 import { resolvePluginConfig } from './utils.js'
 import { createMcpToolDefinitions } from './mcp-tools.js'
-import { createSkillToolDefinitions, createSkillsInjector } from './skills.js'
 
 function createMockInput(): PluginInput {
   const logFn = vi.fn().mockResolvedValue(true)
@@ -79,14 +78,10 @@ describe('LiteLLMPlugin', () => {
     vi.mocked(createMcpToolDefinitions).mockResolvedValue({
       mcp_test_server_test_tool: 'mock-mcp-tool',
     })
-    // Default Skills mock: returns two tools
-    vi.mocked(createSkillToolDefinitions).mockReturnValue({
-      skill_list: 'mock-skill-list',
-      skill_create: 'mock-skill-create',
-      skill_delete: 'mock-skill-delete',
-    })
-    // Default Skills injector mock
-    vi.mocked(createSkillsInjector).mockReturnValue(vi.fn())
+  })
+
+  afterEach(() => {
+    delete process.env.LITELLM_GCLOUD_TOKEN_AUTH
   })
 
   it('throws on missing config', async () => {
@@ -99,6 +94,28 @@ describe('LiteLLMPlugin', () => {
     )
   })
 
+  it('throws gcloud-specific error when LITELLM_GCLOUD_TOKEN_AUTH is set but config is missing', async () => {
+    vi.mocked(resolvePluginConfig).mockReturnValue(null)
+    process.env.LITELLM_GCLOUD_TOKEN_AUTH = '1'
+
+    await expect(
+      LiteLLMPlugin(mockInput, {})
+    ).rejects.toThrow(
+      'LITELLM_KEY is optional when LITELLM_GCLOUD_TOKEN_AUTH=1',
+    )
+  })
+
+  it('throws generic error when LITELLM_GCLOUD_TOKEN_AUTH is not set and config is missing', async () => {
+    vi.mocked(resolvePluginConfig).mockReturnValue(null)
+    delete process.env.LITELLM_GCLOUD_TOKEN_AUTH
+
+    await expect(
+      LiteLLMPlugin(mockInput, {})
+    ).rejects.toThrow(
+      "Plugin config error: set 'url' and 'apiKey'",
+    )
+  })
+
   it('config hook calls discoverModels and injects models into config', async () => {
     const hooks = await LiteLLMPlugin(mockInput, {
       url: 'https://litellm.example.com',
@@ -212,9 +229,6 @@ describe('LiteLLMPlugin', () => {
 
     expect(hooks.tool).toBeDefined()
     expect(hooks.tool).toHaveProperty('mcp_test_server_test_tool')
-    expect(hooks.tool).toHaveProperty('skill_list')
-    expect(hooks.tool).toHaveProperty('skill_create')
-    expect(hooks.tool).toHaveProperty('skill_delete')
   })
 
   it('tool hook passes correct config and apiKey to createMcpToolDefinitions', async () => {
@@ -229,41 +243,7 @@ describe('LiteLLMPlugin', () => {
     )
   })
 
-  it('tool hook passes correct config and apiKey to createSkillToolDefinitions', async () => {
-    await LiteLLMPlugin(mockInput, {
-      url: 'https://litellm.example.com',
-      apiKey: 'test-api-key',
-    })
-
-    expect(createSkillToolDefinitions).toHaveBeenCalledWith(
-      { url: 'https://litellm.example.com', apiKey: 'test-api-key' },
-      'test-api-key',
-    )
-  })
-
-  it('chat.message hook is defined', async () => {
-    const hooks = await LiteLLMPlugin(mockInput, {
-      url: 'https://litellm.example.com',
-      apiKey: 'test-api-key',
-    })
-
-    expect(hooks['chat.message']).toBeDefined()
-    expect(typeof hooks['chat.message']).toBe('function')
-  })
-
-  it('chat.message hook is created with correct config and apiKey', async () => {
-    await LiteLLMPlugin(mockInput, {
-      url: 'https://litellm.example.com',
-      apiKey: 'test-api-key',
-    })
-
-    expect(createSkillsInjector).toHaveBeenCalledWith(
-      { url: 'https://litellm.example.com', apiKey: 'test-api-key' },
-      'test-api-key',
-    )
-  })
-
-  it('MCP discovery failure does not break the plugin — Skills tools still present', async () => {
+  it('MCP discovery failure does not break the plugin', async () => {
     const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
     vi.mocked(createMcpToolDefinitions).mockRejectedValue(new Error('MCP server unavailable'))
 
@@ -278,10 +258,6 @@ describe('LiteLLMPlugin', () => {
 
     // Skills tools should still be present
     expect(hooks.tool).toBeDefined()
-    expect(hooks.tool).toHaveProperty('skill_list')
-    expect(hooks.tool).toHaveProperty('skill_create')
-    expect(hooks.tool).toHaveProperty('skill_delete')
-
     // MCP tools should not be present (empty object merged)
     expect(hooks.tool).not.toHaveProperty('mcp_test_server_test_tool')
 
@@ -300,10 +276,6 @@ describe('LiteLLMPlugin', () => {
     const hooks = await LiteLLMPlugin(mockInput, undefined)
 
     expect(hooks.tool).toBeDefined()
-    expect(hooks.tool).toHaveProperty('skill_list')
-    expect(hooks['chat.message']).toBeDefined()
-    expect(typeof hooks['chat.message']).toBe('function')
-
     expect(createMcpToolDefinitions).toHaveBeenCalledWith(
       { url: 'https://env.litellm.example.com', apiKey: 'env-api-key' },
       'env-api-key',
@@ -312,4 +284,35 @@ describe('LiteLLMPlugin', () => {
     delete process.env.LITELLM_URL
     delete process.env.LITELLM_KEY
   })
+
+  it('registers chat.headers hook when LITELLM_GCLOUD_TOKEN_AUTH is set', async () => {
+    process.env.LITELLM_GCLOUD_TOKEN_AUTH = '1'
+
+    const { getGcloudToken } = await import('./gcloud-token.js')
+    vi.mocked(getGcloudToken).mockResolvedValue('mock-gcloud-token')
+
+    const hooks = await LiteLLMPlugin(mockInput, {
+      url: 'https://litellm.example.com',
+      apiKey: 'test-api-key',
+    })
+
+    expect(hooks['chat.headers']).toBeDefined()
+    expect(typeof hooks['chat.headers']).toBe('function')
+
+    // Verify the hook injects the token
+    const output = { headers: {} as Record<string, string> }
+    await (hooks['chat.headers'] as Function)({}, output)
+    expect(output.headers['Authorization']).toBe('Bearer mock-gcloud-token')
+  })
+
+  it('does not register chat.headers hook when LITELLM_GCLOUD_TOKEN_AUTH is unset', async () => {
+    delete process.env.LITELLM_GCLOUD_TOKEN_AUTH
+
+    const hooks = await LiteLLMPlugin(mockInput, {
+      url: 'https://litellm.example.com',
+      apiKey: 'test-api-key',
+    })
+
+    expect(hooks['chat.headers']).toBeUndefined()
+  })
 })

package/src/plugin.ts

@@ -2,32 +2,28 @@ import type { Plugin, PluginInput, PluginOptions } from '@opencode-ai/plugin'
 import { resolvePluginConfig, getProviderId } from './utils.js'
 import { discoverModels, injectModelsIntoConfig } from './discovery.js'
 import { createMcpToolDefinitions } from './mcp-tools.js'
-import { createSkillToolDefinitions, createSkillsInjector } from './skills.js'
+import { getGcloudToken } from './gcloud-token.js'
 
-/**
- * Main plugin entry point for the LiteLLM provider.
- *
- * Wires together config (model discovery), auth (/connect API key flow),
- * and chat.headers (per-request Bearer token injection).
- *
- * Auth: LITELLM_URL / LITELLM_KEY env vars take precedence,
- * with fallback to values in opencode.json plugin options.
- */
 export const LiteLLMPlugin: Plugin = async (
   input: PluginInput,
   options?: PluginOptions,
 ) => {
   const pluginConfig = resolvePluginConfig(options)
   if (pluginConfig === null) {
+    const isGcloudAuth = process.env.LITELLM_GCLOUD_TOKEN_AUTH &&
+      process.env.LITELLM_GCLOUD_TOKEN_AUTH !== '' &&
+      process.env.LITELLM_GCLOUD_TOKEN_AUTH !== '0'
+
     throw new Error(
-      "Plugin config error: set 'url' and 'apiKey' in plugin options, " +
-      "or set LITELLM_URL and LITELLM_KEY environment variables.",
+      isGcloudAuth
+        ? "Plugin config error: set LITELLM_URL (LITELLM_KEY is optional when LITELLM_GCLOUD_TOKEN_AUTH=1)."
+        : "Plugin config error: set 'url' and 'apiKey' in plugin options, " +
+          "or set LITELLM_URL and LITELLM_KEY environment variables.",
     )
   }
 
   const providerId = getProviderId()
 
-  // Discover MCP tools with graceful error handling
   let mcpTools: Record<string, any> = {}
   try {
     mcpTools = await createMcpToolDefinitions(pluginConfig, pluginConfig.apiKey)
@@ -35,12 +31,8 @@ export const LiteLLMPlugin: Plugin = async (
     console.warn(`[opencode-provider-litellm] MCP tool discovery failed: ${e}`)
   }
 
-  return {
-    /**
-     * Config hook — discovers models from the LiteLLM proxy and injects
-     * them into the OpenCode config under the provider.
-     */
-    config: async (config) => {
+  const result: Record<string, unknown> = {
+    config: async (config: Record<string, any>) => {
       try {
         const models = await discoverModels(
           pluginConfig,
@@ -55,23 +47,22 @@ export const LiteLLMPlugin: Plugin = async (
               message: 'No models discovered',
             },
           })
-          return
+        } else {
+          injectModelsIntoConfig(
+            config as Parameters<typeof injectModelsIntoConfig>[0],
+            providerId,
+            pluginConfig.url,
+            pluginConfig.apiKey,
+            models,
+          )
+          await input.client.app.log({
+            body: {
+              service: providerId,
+              level: 'info',
+              message: `Discovered ${Object.keys(models).length} models`,
+            },
+          })
         }
-
-        injectModelsIntoConfig(
-          config as Parameters<typeof injectModelsIntoConfig>[0],
-          providerId,
-          pluginConfig.url,
-          pluginConfig.apiKey,
-          models,
-        )
-        await input.client.app.log({
-          body: {
-            service: providerId,
-            level: 'info',
-            message: `Discovered ${Object.keys(models).length} models`,
-          },
-        })
       } catch (error) {
         await input.client.app.log({
           body: {
@@ -83,10 +74,6 @@ export const LiteLLMPlugin: Plugin = async (
       }
     },
 
-    /**
-     * Auth hook — lets the user paste an API key via the /connect flow.
-     * The key is stored in OpenCode's auth store and used as the Bearer token.
-     */
     auth: {
       provider: providerId,
       methods: [
@@ -101,28 +88,32 @@ export const LiteLLMPlugin: Plugin = async (
               placeholder: 'sk-...',
             },
           ],
-          async authorize(inputs) {
-            if (!inputs?.apiKey || inputs.apiKey.length === 0) {
+          async authorize(inputs: Record<string, unknown> | undefined) {
+            const apiKey = inputs?.apiKey
+            if (!apiKey || typeof apiKey !== 'string' || apiKey.length === 0) {
               return { type: 'failed' as const }
             }
-            return { type: 'success' as const, key: inputs.apiKey }
+            return { type: 'success' as const, key: apiKey }
           },
         },
       ],
     },
 
-    /**
-     * Tool hook — merges dynamically-discovered MCP tools with static
-     * Skills CRUD tools.
-     */
     tool: {
       ...mcpTools,
-      ...createSkillToolDefinitions(pluginConfig, pluginConfig.apiKey),
     },
+  }
 
-    /**
-     * Chat message hook — injects active Skills as context into chat messages.
-     */
-    "chat.message": createSkillsInjector(pluginConfig, pluginConfig.apiKey),
+  if (process.env.LITELLM_GCLOUD_TOKEN_AUTH &&
+      process.env.LITELLM_GCLOUD_TOKEN_AUTH !== '' &&
+      process.env.LITELLM_GCLOUD_TOKEN_AUTH !== '0') {
+    result['chat.headers'] = async (_input: Record<string, unknown>, output: { headers: Record<string, string> }) => {
+      const token = await getGcloudToken()
+      if (token) {
+        output.headers['Authorization'] = `Bearer ${token}`
+      }
+    }
   }
+
+  return result
 }

package/src/types.ts

@@ -15,29 +15,6 @@ export interface McpTool {
   input_schema: Record<string, unknown>
 }
 
-export interface SkillSource {
-  source: string
-  url: string
-  path?: string
-}
-
-export interface Skill {
-  id: string
-  name: string
-  version: string
-  description: string | null
-  source: SkillSource
-  author: string | null
-  homepage: string | null
-  keywords: string | null
-  category: string | null
-  domain: string | null
-  namespace: string | null
-  enabled: boolean
-  created_at: string
-  updated_at: string
-}
-
 export interface OpencodeModelConfig {
   name: string
   tool_call?: boolean

package/src/utils.test.ts

@@ -137,4 +137,55 @@ describe('resolvePluginConfig', () => {
       expect(resolvePluginConfig({})).toBeNull()
     })
   })
+
+  describe('gcloud token auth', () => {
+    beforeEach(() => {
+      delete process.env.LITELLM_GCLOUD_TOKEN_AUTH
+    })
+
+    it('allows missing LITELLM_KEY when LITELLM_GCLOUD_TOKEN_AUTH is set', () => {
+      process.env.LITELLM_URL = 'https://gcloud.example.com'
+      process.env.LITELLM_GCLOUD_TOKEN_AUTH = '1'
+      delete process.env.LITELLM_KEY
+
+      const config = resolvePluginConfig({})
+      expect(config).toEqual({ url: 'https://gcloud.example.com', apiKey: '' })
+    })
+
+    it('does not allow missing key when gcloud auth is disabled', () => {
+      process.env.LITELLM_URL = 'https://gcloud.example.com'
+      delete process.env.LITELLM_KEY
+      delete process.env.LITELLM_GCLOUD_TOKEN_AUTH
+
+      const config = resolvePluginConfig({})
+      expect(config).toBeNull()
+    })
+
+    it('does not allow missing key when gcloud auth is set to 0', () => {
+      process.env.LITELLM_URL = 'https://gcloud.example.com'
+      process.env.LITELLM_GCLOUD_TOKEN_AUTH = '0'
+      delete process.env.LITELLM_KEY
+
+      const config = resolvePluginConfig({})
+      expect(config).toBeNull()
+    })
+
+    it('does not allow missing key when gcloud auth is empty string', () => {
+      process.env.LITELLM_URL = 'https://gcloud.example.com'
+      process.env.LITELLM_GCLOUD_TOKEN_AUTH = ''
+      delete process.env.LITELLM_KEY
+
+      const config = resolvePluginConfig({})
+      expect(config).toBeNull()
+    })
+
+    it('prefers full env vars over gcloud fallback', () => {
+      process.env.LITELLM_URL = 'https://gcloud.example.com'
+      process.env.LITELLM_KEY = 'normal-key'
+      process.env.LITELLM_GCLOUD_TOKEN_AUTH = '1'
+
+      const config = resolvePluginConfig({})
+      expect(config).toEqual({ url: 'https://gcloud.example.com', apiKey: 'normal-key' })
+    })
+  })
 })

package/src/utils.ts

@@ -34,14 +34,23 @@ export function mapLiteLLMModel(model: LiteLLMModel): OpencodeModelConfig {
 export function resolvePluginConfig(rawConfig: unknown): PluginConfig | null {
   const envUrl = typeof process !== 'undefined' ? process.env.LITELLM_URL : undefined
   const envKey = typeof process !== 'undefined' ? process.env.LITELLM_KEY : undefined
+  const envGcloudAuth = typeof process !== 'undefined'
+    ? process.env.LITELLM_GCLOUD_TOKEN_AUTH
+    : undefined
 
   const hasEnvVars = envUrl !== undefined && envUrl.length > 0 &&
-                     envKey !== undefined && envKey.length > 0
+                      envKey !== undefined && envKey.length > 0
 
   if (hasEnvVars) {
     return { url: envUrl, apiKey: envKey }
   }
 
+  // Allow missing LITELLM_KEY when gcloud token auth is enabled
+  if (envUrl !== undefined && envUrl.length > 0 &&
+      envGcloudAuth !== undefined && envGcloudAuth !== '' && envGcloudAuth !== '0') {
+    return { url: envUrl, apiKey: envKey || '' }
+  }
+
   // Fall back to config options from opencode.json
   if (rawConfig && typeof rawConfig === 'object' && !Array.isArray(rawConfig)) {
     const obj = rawConfig as Record<string, unknown>