opencode-provider-litellm 0.1.1 → 0.3.0

package/src/skills.test.ts

@@ -0,0 +1,449 @@
+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

@@ -0,0 +1,240 @@
+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 })
+  }
+}

package/src/types.ts

@@ -8,6 +8,21 @@ export interface LiteLLMModel {
   max_model_len?: number
 }
 
+export interface McpTool {
+  name: string
+  server_name: string
+  description: string
+  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