opencode-provider-litellm 0.3.0 → 0.4.0

package/README.md

@@ -1,6 +1,6 @@
 # opencode-provider-litellm
 
-OpenCode plugin that auto-discovers models from any [LiteLLM](https://github.com/BerriAI/litellm) proxy — complete with costs, context limits, capabilities, and auth. Zero config, zero hand-maintained model lists.
+OpenCode plugin for any [LiteLLM](https://github.com/BerriAI/litellm) proxy — auto-discovers models, MCP tools, and auth. Zero config, zero hand-maintained model lists.
 
 ## Quick start
 
@@ -15,7 +15,7 @@ opencode plugin opencode-provider-litellm
 # 3. Restart OpenCode
 ```
 
-All models from your LiteLLM proxy appear in OpenCode's model picker automatically.
+All models and MCP tools from your LiteLLM proxy appear in OpenCode automatically.
 
 ## Configuration
 
@@ -56,21 +56,44 @@ You can also authenticate interactively via the OpenCode TUI:
 
 The key is stored in OpenCode's auth store.
 
+## Features
+
+### Model discovery
+
+Queries LiteLLM on startup and injects all models with rich metadata into OpenCode:
+
+- `/health` — model list with internal UUIDs
+- `/model/info?litellm_model_id={uuid}` — costs, context limits, vision, tool calling, reasoning, etc.
+
+Custom `model_info` updates via `/model/update` are respected — no hardcoded fallbacks.
+
+### MCP tools
+
+Discovers tools registered on LiteLLM's MCP servers at startup and exposes them as native OpenCode tools. Each tool keeps its original description and parameter schema.
+
+### Skills
+
+Skills registered in LiteLLM's [Skills Gateway](https://docs.litellm.ai/docs/skills_gateway) are made available to OpenCode via the [proxy-sidecar](../llm-server/proxy-sidecar/), which serves skills in OpenCode's native format. Add the sidecar URL to your config:
+
+```jsonc
+{
+  "skills": {
+    "urls": ["https://your-litellm-proxy.example.com/opencode/skills"]
+  }
+}
+```
+
+Skills appear in OpenCode's `/skills` menu and are loaded natively by the agent.
+
 ## How it works
 
-The plugin uses two OpenCode hooks:
+The plugin uses three OpenCode hooks:
 
 | Hook | Purpose |
 |------|---------|
-| `config` | Queries `/health` + `/model/info` on startup, discovers models with rich metadata (costs, limits, capabilities), and injects them into OpenCode |
+| `config` | Discovers models from LiteLLM and injects them into OpenCode |
 | `auth` | Provides a `/connect` entry point for pasting an API key |
-
-Model metadata is fetched from LiteLLM's admin API:
-
-- `/health` — model list with internal UUIDs
-- `/model/info?litellm_model_id={uuid}` — rich metadata per model (costs, context limits, vision, tool calling, reasoning, etc.)
-
-Custom model_info updates via `/model/update` are respected — no hardcoded fallbacks.
+| `tool` | Exposes discovered MCP tools as native OpenCode tools |
 
 ## Troubleshooting
 
@@ -79,6 +102,7 @@ Custom model_info updates via `/model/update` are respected — no hardcoded fal
 | "Plugin config error" | Set `LITELLM_URL` and `LITELLM_KEY`, or add `url`/`apiKey` to plugin options |
 | "Access denied" (403) | Verify the API key has access to the LiteLLM proxy |
 | "No models discovered" | Check that the proxy is reachable and the `/health` endpoint responds |
+| Skills not showing | Verify the proxy-sidecar is running and the skills URL is in `opencode.json` |
 
 ## Development
 

package/package.json

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

package/src/plugin.test.ts

@@ -20,17 +20,10 @@ vi.mock('./mcp-tools.js', () => ({
   createMcpToolDefinitions: vi.fn(),
 }))
 
-// Mock the Skills module
-vi.mock('./skills.js', () => ({
-  createSkillToolDefinitions: vi.fn(),
-  createSkillsInjector: 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 +72,6 @@ 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())
   })
 
   it('throws on missing config', async () => {
@@ -212,9 +197,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 +211,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 +226,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 +244,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',

package/src/plugin.ts

@@ -2,17 +2,7 @@ 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'
 
-/**
- * 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,
@@ -27,7 +17,6 @@ export const LiteLLMPlugin: Plugin = async (
 
   const providerId = getProviderId()
 
-  // Discover MCP tools with graceful error handling
   let mcpTools: Record<string, any> = {}
   try {
     mcpTools = await createMcpToolDefinitions(pluginConfig, pluginConfig.apiKey)
@@ -36,11 +25,7 @@ export const LiteLLMPlugin: Plugin = async (
   }
 
   return {
-    /**
-     * Config hook — discovers models from the LiteLLM proxy and injects
-     * them into the OpenCode config under the provider.
-     */
-    config: async (config) => {
+    config: async (config: Record<string, any>) => {
       try {
         const models = await discoverModels(
           pluginConfig,
@@ -55,23 +40,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 +67,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: [
@@ -111,18 +91,8 @@ export const LiteLLMPlugin: Plugin = async (
       ],
     },
 
-    /**
-     * 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),
   }
 }

package/src/types.ts

@@ -15,14 +15,6 @@ export interface McpTool {
   input_schema: Record<string, unknown>
 }
 
-export interface Skill {
-  id: string
-  name: string
-  description: string
-  enabled?: boolean
-  [key: string]: unknown
-}
-
 export interface OpencodeModelConfig {
   name: string
   tool_call?: boolean

package/src/skills.test.ts

@@ -1,449 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { tool } from '@opencode-ai/plugin'
-import type { PluginConfig, Skill } from './types.js'
-import {
-  listSkills,
-  createSkill,
-  deleteSkill,
-  createSkillToolDefinitions,
-  createSkillsInjector,
-  resetSkillsCache,
-} from './skills.js'
-
-describe('listSkills', () => {
-  const config: PluginConfig = {
-    url: 'https://litellm.example.com',
-    apiKey: 'test-api-key',
-  }
-  const token = 'test-token'
-
-  beforeEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  it('returns skills from mock response', async () => {
-    const mockSkills: Skill[] = [
-      { id: 'skill-1', name: 'code-review', description: 'Reviews code for best practices', enabled: true },
-      { id: 'skill-2', name: 'security-scan', description: 'Scans for security issues', enabled: true },
-    ]
-
-    const mockFetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      json: async () => mockSkills,
-    })
-    vi.stubGlobal('fetch', mockFetch)
-
-    const result = await listSkills(config, token)
-
-    expect(result).toEqual(mockSkills)
-    expect(mockFetch).toHaveBeenCalledWith(
-      'https://litellm.example.com/v1/skills',
-      expect.objectContaining({
-        method: 'GET',
-        headers: expect.objectContaining({
-          Authorization: 'Bearer test-token',
-        }),
-        signal: expect.any(AbortSignal),
-      }),
-    )
-  })
-
-  it('returns [] on error', async () => {
-    const mockFetch = vi.fn().mockRejectedValue(new Error('network error'))
-    vi.stubGlobal('fetch', mockFetch)
-
-    const result = await listSkills(config, token)
-    expect(result).toEqual([])
-  })
-
-  it('returns [] on non-ok response', async () => {
-    const mockFetch = vi.fn().mockResolvedValue({
-      ok: false,
-      status: 500,
-    })
-    vi.stubGlobal('fetch', mockFetch)
-
-    const result = await listSkills(config, token)
-    expect(result).toEqual([])
-  })
-
-  it('respects timeout (AbortError after 10s)', async () => {
-    vi.useFakeTimers()
-
-    const mockFetch = vi.fn().mockImplementation((_url: string, init: RequestInit) => {
-      return new Promise<Response>((_resolve, reject) => {
-        const signal = init?.signal
-        if (signal) {
-          signal.addEventListener('abort', () => {
-            reject(new DOMException('The operation was aborted.', 'AbortError'))
-          })
-        }
-      })
-    })
-    vi.stubGlobal('fetch', mockFetch)
-
-    const promise = listSkills(config, token)
-
-    await vi.advanceTimersByTimeAsync(10001)
-
-    const result = await promise
-
-    vi.useRealTimers()
-
-    expect(result).toEqual([])
-  })
-})
-
-describe('createSkill', () => {
-  const config: PluginConfig = {
-    url: 'https://litellm.example.com',
-    apiKey: 'test-api-key',
-  }
-  const token = 'test-token'
-
-  beforeEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  it('returns success message', async () => {
-    const mockFetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      json: async () => ({ id: 'skill-new-1', name: 'my-skill' }),
-    })
-    vi.stubGlobal('fetch', mockFetch)
-
-    const result = await createSkill(config, token, 'my-skill', 'A test skill')
-
-    expect(result).toBe('Skill "my-skill" created (id: skill-new-1)')
-    expect(mockFetch).toHaveBeenCalledWith(
-      'https://litellm.example.com/v1/skills',
-      expect.objectContaining({
-        method: 'POST',
-        headers: expect.objectContaining({
-          Authorization: 'Bearer test-token',
-          'Content-Type': 'application/json',
-        }),
-        body: JSON.stringify({ name: 'my-skill', description: 'A test skill', input_schema: undefined, code: undefined }),
-        signal: expect.any(AbortSignal),
-      }),
-    )
-  })
-
-  it('returns error string on failure', async () => {
-    const mockFetch = vi.fn().mockRejectedValue(new Error('connection refused'))
-    vi.stubGlobal('fetch', mockFetch)
-
-    const result = await createSkill(config, token, 'my-skill', 'A test skill')
-
-    expect(result).toBe('Error creating skill: connection refused')
-  })
-
-  it('returns error string on non-ok response', async () => {
-    const mockFetch = vi.fn().mockResolvedValue({
-      ok: false,
-      status: 400,
-    })
-    vi.stubGlobal('fetch', mockFetch)
-
-    const result = await createSkill(config, token, 'my-skill', 'A test skill')
-
-    expect(result).toContain('Error creating skill')
-  })
-
-  it('includes input_schema and code when provided', async () => {
-    const mockFetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      json: async () => ({ id: 'skill-3', name: 'complex-skill' }),
-    })
-    vi.stubGlobal('fetch', mockFetch)
-
-    await createSkill(
-      config,
-      token,
-      'complex-skill',
-      'A complex skill',
-      { type: 'object', properties: { value: { type: 'string' } } },
-      'print("hello")',
-    )
-
-    expect(mockFetch).toHaveBeenCalledWith(
-      'https://litellm.example.com/v1/skills',
-      expect.objectContaining({
-        body: JSON.stringify({
-          name: 'complex-skill',
-          description: 'A complex skill',
-          input_schema: { type: 'object', properties: { value: { type: 'string' } } },
-          code: 'print("hello")',
-        }),
-      }),
-    )
-  })
-})
-
-describe('deleteSkill', () => {
-  const config: PluginConfig = {
-    url: 'https://litellm.example.com',
-    apiKey: 'test-api-key',
-  }
-  const token = 'test-token'
-
-  beforeEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  it('returns success message', async () => {
-    const mockFetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-    })
-    vi.stubGlobal('fetch', mockFetch)
-
-    const result = await deleteSkill(config, token, 'skill-1')
-
-    expect(result).toBe('Skill "skill-1" deleted')
-    expect(mockFetch).toHaveBeenCalledWith(
-      'https://litellm.example.com/v1/skills/skill-1',
-      expect.objectContaining({
-        method: 'DELETE',
-        headers: expect.objectContaining({
-          Authorization: 'Bearer test-token',
-        }),
-        signal: expect.any(AbortSignal),
-      }),
-    )
-  })
-
-  it('returns error string on failure', async () => {
-    const mockFetch = vi.fn().mockRejectedValue(new Error('connection refused'))
-    vi.stubGlobal('fetch', mockFetch)
-
-    const result = await deleteSkill(config, token, 'skill-1')
-
-    expect(result).toBe('Error deleting skill: connection refused')
-  })
-
-  it('returns error string on non-ok response', async () => {
-    const mockFetch = vi.fn().mockResolvedValue({
-      ok: false,
-      status: 404,
-    })
-    vi.stubGlobal('fetch', mockFetch)
-
-    const result = await deleteSkill(config, token, 'skill-1')
-
-    expect(result).toContain('Error deleting skill')
-  })
-})
-
-describe('createSkillToolDefinitions', () => {
-  const config: PluginConfig = {
-    url: 'https://litellm.example.com',
-    apiKey: 'test-api-key',
-  }
-  const token = 'test-token'
-
-  beforeEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  it('returns 3 tools with correct names', () => {
-    const result = createSkillToolDefinitions(config, token)
-
-    expect(Object.keys(result)).toHaveLength(3)
-    expect(result).toHaveProperty('skill_list')
-    expect(result).toHaveProperty('skill_create')
-    expect(result).toHaveProperty('skill_delete')
-  })
-
-  it('skill_list has correct description', () => {
-    const result = createSkillToolDefinitions(config, token)
-
-    expect(result.skill_list.description).toBe('List all skills registered on the LiteLLM proxy')
-  })
-
-  it('skill_create has correct description', () => {
-    const result = createSkillToolDefinitions(config, token)
-
-    expect(result.skill_create.description).toBe('Create a new skill on the LiteLLM proxy')
-  })
-
-  it('skill_delete has correct description', () => {
-    const result = createSkillToolDefinitions(config, token)
-
-    expect(result.skill_delete.description).toBe('Delete a skill from the LiteLLM proxy')
-  })
-
-  it('skill_list execute returns formatted markdown table', async () => {
-    const mockFetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      json: async () => [
-        { id: 'skill-1', name: 'code-review', description: 'Reviews code', enabled: true },
-        { id: 'skill-2', name: 'security-scan', description: 'Scans security', enabled: false },
-      ],
-    })
-    vi.stubGlobal('fetch', mockFetch)
-
-    const result = createSkillToolDefinitions(config, token)
-
-    const output = await result.skill_list.execute({}, {} as any)
-
-    expect(output).toContain('code-review')
-    expect(output).toContain('security-scan')
-    expect(output).toContain('Reviews code')
-    expect(output).toContain('Scans security')
-  })
-
-  it('skill_create execute calls createSkill', async () => {
-    const mockFetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      json: async () => ({ id: 'skill-new', name: 'new-skill' }),
-    })
-    vi.stubGlobal('fetch', mockFetch)
-
-    const result = createSkillToolDefinitions(config, token)
-
-    const output = await result.skill_create.execute(
-      { name: 'new-skill', description: 'A new skill' },
-      {} as any,
-    )
-
-    expect(output).toBe('Skill "new-skill" created (id: skill-new)')
-  })
-
-  it('skill_delete execute calls deleteSkill', async () => {
-    const mockFetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-    })
-    vi.stubGlobal('fetch', mockFetch)
-
-    const result = createSkillToolDefinitions(config, token)
-
-    const output = await result.skill_delete.execute(
-      { skill_id: 'skill-to-delete' },
-      {} as any,
-    )
-
-    expect(output).toBe('Skill "skill-to-delete" deleted')
-  })
-})
-
-describe('createSkillsInjector', () => {
-  const config: PluginConfig = {
-    url: 'https://litellm.example.com',
-    apiKey: 'test-api-key',
-  }
-  const token = 'test-token'
-
-  beforeEach(() => {
-    vi.restoreAllMocks()
-    resetSkillsCache()
-  })
-
-  it('injects skills as text parts', async () => {
-    const mockFetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      json: async () => [
-        { id: 'skill-1', name: 'code-review', description: 'Reviews code', enabled: true },
-        { id: 'skill-2', name: 'security-scan', description: 'Scans security' },
-      ],
-    })
-    vi.stubGlobal('fetch', mockFetch)
-
-    const injector = createSkillsInjector(config, token)
-
-    const input = { sessionID: 'main-session' }
-    const output: { message: any; parts: Array<{ type: string; text: string }> } = { message: { content: 'Hello' }, parts: [] }
-
-    await injector(input, output)
-
-    expect(output.parts).toHaveLength(1)
-    expect(output.parts[0].type).toBe('text')
-    expect(output.parts[0].text).toContain('<skill name="code-review">Reviews code</skill>')
-    expect(output.parts[0].text).toContain('<skill name="security-scan">Scans security</skill>')
-  })
-
-  it('skips ALL sub-agent sessions (returns when input.agent is truthy)', async () => {
-    const mockFetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      json: async () => [
-        { id: 'skill-1', name: 'code-review', description: 'Reviews code', enabled: true },
-      ],
-    })
-    vi.stubGlobal('fetch', mockFetch)
-
-    const injector = createSkillsInjector(config, token)
-
-    const input = { sessionID: 'main-session', agent: 'sub-agent-1' }
-    const output = { message: { content: 'Hello' }, parts: [] }
-
-    await injector(input, output)
-
-    // Should not have injected anything — sub-agent sessions are skipped
-    expect(output.parts).toEqual([])
-    // Should not have called fetch since it returns early
-    expect(mockFetch).not.toHaveBeenCalled()
-  })
-
-  it('skips when no enabled skills', async () => {
-    const mockFetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      json: async () => [
-        { id: 'skill-1', name: 'disabled-skill', description: 'Disabled', enabled: false },
-      ],
-    })
-    vi.stubGlobal('fetch', mockFetch)
-
-    const injector = createSkillsInjector(config, token)
-
-    const input = { sessionID: 'main-session' }
-    const output = { message: { content: 'Hello' }, parts: [] }
-
-    await injector(input, output)
-
-    expect(output.parts).toEqual([])
-  })
-
-  it('cache TTL works (second call within TTL uses cache)', async () => {
-    const mockFetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      json: async () => [
-        { id: 'skill-1', name: 'cached-skill', description: 'Cached', enabled: true },
-      ],
-    })
-    vi.stubGlobal('fetch', mockFetch)
-
-    const injector = createSkillsInjector(config, token)
-
-    // First call — should fetch
-    await injector({ sessionID: 'session-1' }, { message: {}, parts: [] })
-    expect(mockFetch).toHaveBeenCalledTimes(1)
-
-    // Second call — should use cache (fetch not called again)
-    await injector({ sessionID: 'session-2' }, { message: {}, parts: [] })
-    expect(mockFetch).toHaveBeenCalledTimes(1)
-  })
-
-  it('silently skips on fetch failure', async () => {
-    const mockFetch = vi.fn().mockRejectedValue(new Error('network error'))
-    vi.stubGlobal('fetch', mockFetch)
-
-    const injector = createSkillsInjector(config, token)
-
-    const input = { sessionID: 'main-session' }
-    const output = { message: { content: 'Hello' }, parts: [] }
-
-    // Should not throw
-    await expect(injector(input, output)).resolves.toBeUndefined()
-    expect(output.parts).toEqual([])
-  })
-})

package/src/skills.ts

@@ -1,240 +0,0 @@
-import { tool } from '@opencode-ai/plugin'
-import type { PluginConfig, Skill } from './types.js'
-
-interface CacheEntry<T> {
-  data: T
-  timestamp: number
-}
-
-let skillsCache: CacheEntry<Skill[]> | null = null
-const CACHE_TTL_MS = 60_000
-
-/** Reset the skills cache. Used for testing. */
-export function resetSkillsCache(): void {
-  skillsCache = null
-}
-
-/**
- * Fetches all skills from the LiteLLM proxy.
- * Returns an empty array on any error (network, 4xx, 5xx, parse failure).
- * Uses a 10s timeout via AbortController.
- */
-export async function listSkills(
-  config: PluginConfig,
-  token: string,
-): Promise<Skill[]> {
-  const controller = new AbortController()
-  const timeoutId = setTimeout(() => controller.abort(), 10_000)
-
-  try {
-    const response = await fetch(`${config.url}/v1/skills`, {
-      method: 'GET',
-      headers: {
-        Authorization: `Bearer ${token}`,
-      },
-      signal: controller.signal,
-    })
-
-    if (!response.ok) {
-      return []
-    }
-
-    const body = await response.json()
-
-    if (!Array.isArray(body)) {
-      return []
-    }
-
-    return body as Skill[]
-  } catch {
-    return []
-  } finally {
-    clearTimeout(timeoutId)
-  }
-}
-
-/**
- * Creates a new skill on the LiteLLM proxy.
- * Returns a success message string on success, error string on failure.
- * Uses a 10s timeout via AbortController.
- */
-export async function createSkill(
-  config: PluginConfig,
-  token: string,
-  name: string,
-  description: string,
-  inputSchema?: Record<string, unknown>,
-  code?: string,
-): Promise<string> {
-  const controller = new AbortController()
-  const timeoutId = setTimeout(() => controller.abort(), 10_000)
-
-  try {
-    const response = await fetch(`${config.url}/v1/skills`, {
-      method: 'POST',
-      headers: {
-        Authorization: `Bearer ${token}`,
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({
-        name,
-        description,
-        input_schema: inputSchema,
-        code,
-      }),
-      signal: controller.signal,
-    })
-
-    if (!response.ok) {
-      return `Error creating skill: HTTP ${response.status}`
-    }
-
-    const body = await response.json()
-    const id = body.id ?? 'unknown'
-    return `Skill "${name}" created (id: ${id})`
-  } catch (error: unknown) {
-    const message = error instanceof Error ? error.message : String(error)
-    return `Error creating skill: ${message}`
-  } finally {
-    clearTimeout(timeoutId)
-  }
-}
-
-/**
- * Deletes a skill from the LiteLLM proxy.
- * Returns a success message string on success, error string on failure.
- * Uses a 10s timeout via AbortController.
- */
-export async function deleteSkill(
-  config: PluginConfig,
-  token: string,
-  skillId: string,
-): Promise<string> {
-  const controller = new AbortController()
-  const timeoutId = setTimeout(() => controller.abort(), 10_000)
-
-  try {
-    const response = await fetch(`${config.url}/v1/skills/${skillId}`, {
-      method: 'DELETE',
-      headers: {
-        Authorization: `Bearer ${token}`,
-      },
-      signal: controller.signal,
-    })
-
-    if (!response.ok) {
-      return `Error deleting skill: HTTP ${response.status}`
-    }
-
-    return `Skill "${skillId}" deleted`
-  } catch (error: unknown) {
-    const message = error instanceof Error ? error.message : String(error)
-    return `Error deleting skill: ${message}`
-  } finally {
-    clearTimeout(timeoutId)
-  }
-}
-
-/**
- * Creates opencode tool definitions for skill CRUD operations.
- * Returns a static Record with three tools: skill_list, skill_create, skill_delete.
- */
-export function createSkillToolDefinitions(
-  config: PluginConfig,
-  token: string,
-): Record<string, any> {
-  return {
-    skill_list: tool({
-      description: 'List all skills registered on the LiteLLM proxy',
-      args: {},
-      async execute(_args: Record<string, unknown>, _context: unknown): Promise<string> {
-        const skills = await listSkills(config, token)
-
-        if (skills.length === 0) {
-          return 'No skills found.'
-        }
-
-        const header = '| ID | Name | Description | Enabled |'
-        const sep = '|------|------|-------------|---------|'
-        const rows = skills
-          .map(
-            (s) =>
-              `| ${s.id} | ${s.name} | ${s.description} | ${s.enabled !== false ? 'yes' : 'no'} |`,
-          )
-          .join('\n')
-
-        return [header, sep, ...rows.split('\n')].join('\n')
-      },
-    }),
-
-    skill_create: tool({
-      description: 'Create a new skill on the LiteLLM proxy',
-      args: {
-        name: tool.schema.string().describe('Name of the skill'),
-        description: tool.schema.string().describe('Description of the skill'),
-        input_schema: tool.schema
-          .object({})
-          .passthrough()
-          .optional()
-          .describe('Input schema for the skill'),
-        code: tool.schema.string().optional().describe('Code for the skill'),
-      },
-      async execute(args: Record<string, unknown>, _context: unknown): Promise<string> {
-        return createSkill(
-          config,
-          token,
-          args.name as string,
-          args.description as string,
-          args.input_schema as Record<string, unknown> | undefined,
-          args.code as string | undefined,
-        )
-      },
-    }),
-
-    skill_delete: tool({
-      description: 'Delete a skill from the LiteLLM proxy',
-      args: {
-        skill_id: tool.schema.string().describe('ID of the skill to delete'),
-      },
-      async execute(args: Record<string, unknown>, _context: unknown): Promise<string> {
-        return deleteSkill(config, token, args.skill_id as string)
-      },
-    }),
-  }
-}
-
-/**
- * Creates a chat.message hook that injects active skills as context.
- * Uses in-memory cache with 60s TTL to avoid hammering the API.
- * Only injects for main agent sessions — skips all sub-agents.
- */
-export function createSkillsInjector(
-  config: PluginConfig,
-  token: string,
-): (
-  input: { sessionID: string; agent?: string; model?: any; messageID?: string; variant?: string },
-  output: { message: any; parts: any[] },
-) => Promise<void> {
-  return async (input, output) => {
-    // Only inject for main agent session — skip ALL sub-agents
-    if (input.agent) return
-
-    // Fetch skills with simple in-memory cache
-    let skills: Skill[] = []
-    if (skillsCache && Date.now() - skillsCache.timestamp < CACHE_TTL_MS) {
-      skills = skillsCache.data
-    } else {
-      skills = await listSkills(config, token)
-      skillsCache = { data: skills, timestamp: Date.now() }
-    }
-
-    const enabledSkills = skills.filter((s) => s.enabled !== false)
-    if (enabledSkills.length === 0) return
-
-    const context = enabledSkills
-      .map((s) => `<skill name="${s.name}">${s.description}</skill>`)
-      .join('\n')
-
-    output.parts.push({ type: 'text', text: context })
-  }
-}