opencode-provider-litellm 0.3.0 → 0.3.1

package/package.json

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

package/src/skills.test.ts

@@ -3,13 +3,37 @@ import { tool } from '@opencode-ai/plugin'
 import type { PluginConfig, Skill } from './types.js'
 import {
   listSkills,
-  createSkill,
-  deleteSkill,
+  listPublicSkills,
+  registerSkill,
+  enableSkill,
+  disableSkill,
+  fetchSkillContent,
   createSkillToolDefinitions,
   createSkillsInjector,
   resetSkillsCache,
 } from './skills.js'
 
+const mockSkill: Skill = {
+  id: 'skill-1',
+  name: 'code-review',
+  version: '1.0.0',
+  description: 'Reviews code for best practices',
+  source: {
+    source: 'git-subdir',
+    url: 'https://github.com/org/repo',
+    path: 'skills/code-review',
+  },
+  author: null,
+  homepage: null,
+  keywords: null,
+  category: null,
+  domain: null,
+  namespace: null,
+  enabled: true,
+  created_at: '2026-01-01T00:00:00Z',
+  updated_at: '2026-01-01T00:00:00Z',
+}
+
 describe('listSkills', () => {
   const config: PluginConfig = {
     url: 'https://litellm.example.com',
@@ -21,24 +45,21 @@ describe('listSkills', () => {
     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 },
-    ]
+  it('returns skills from plugins response', async () => {
+    const mockPlugins = { plugins: [mockSkill] }
 
     const mockFetch = vi.fn().mockResolvedValue({
       ok: true,
       status: 200,
-      json: async () => mockSkills,
+      json: async () => mockPlugins,
     })
     vi.stubGlobal('fetch', mockFetch)
 
     const result = await listSkills(config, token)
 
-    expect(result).toEqual(mockSkills)
+    expect(result).toEqual([mockSkill])
     expect(mockFetch).toHaveBeenCalledWith(
-      'https://litellm.example.com/v1/skills',
+      'https://litellm.example.com/claude-code/plugins',
       expect.objectContaining({
         method: 'GET',
         headers: expect.objectContaining({
@@ -68,6 +89,18 @@ describe('listSkills', () => {
     expect(result).toEqual([])
   })
 
+  it('returns [] on invalid response format', async () => {
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => { plugins: null },
+    })
+    vi.stubGlobal('fetch', mockFetch)
+
+    const result = await listSkills(config, token)
+    expect(result).toEqual([])
+  })
+
   it('respects timeout (AbortError after 10s)', async () => {
     vi.useFakeTimers()
 
@@ -95,7 +128,48 @@ describe('listSkills', () => {
   })
 })
 
-describe('createSkill', () => {
+describe('listPublicSkills', () => {
+  const config: PluginConfig = {
+    url: 'https://litellm.example.com',
+    apiKey: 'test-api-key',
+  }
+
+  beforeEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('returns public skills without auth', async () => {
+    const mockResponse = { plugins: [mockSkill] }
+
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => mockResponse,
+    })
+    vi.stubGlobal('fetch', mockFetch)
+
+    const result = await listPublicSkills(config)
+
+    expect(result).toEqual([mockSkill])
+    expect(mockFetch).toHaveBeenCalledWith(
+      'https://litellm.example.com/public/skill_hub',
+      expect.objectContaining({
+        method: 'GET',
+        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 listPublicSkills(config)
+    expect(result).toEqual([])
+  })
+})
+
+describe('registerSkill', () => {
   const config: PluginConfig = {
     url: 'https://litellm.example.com',
     apiKey: 'test-api-key',
@@ -110,22 +184,42 @@ describe('createSkill', () => {
     const mockFetch = vi.fn().mockResolvedValue({
       ok: true,
       status: 200,
-      json: async () => ({ id: 'skill-new-1', name: 'my-skill' }),
+      json: async () => ({
+        status: 'success',
+        action: 'created',
+        plugin: { id: 'new-skill-1', name: 'my-skill' },
+      }),
     })
     vi.stubGlobal('fetch', mockFetch)
 
-    const result = await createSkill(config, token, 'my-skill', 'A test skill')
+    const result = await registerSkill(
+      config,
+      token,
+      'my-skill',
+      'https://github.com/org/repo',
+      'skills/my-skill',
+      'A test skill',
+    )
 
-    expect(result).toBe('Skill "my-skill" created (id: skill-new-1)')
+    expect(result).toBe('Skill "my-skill" registered (id: new-skill-1)')
     expect(mockFetch).toHaveBeenCalledWith(
-      'https://litellm.example.com/v1/skills',
+      'https://litellm.example.com/claude-code/plugins',
       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 }),
+        body: JSON.stringify({
+          name: 'my-skill',
+          source: {
+            source: 'git-subdir',
+            url: 'https://github.com/org/repo',
+            path: 'skills/my-skill',
+          },
+          description: 'A test skill',
+          domain: null,
+        }),
         signal: expect.any(AbortSignal),
       }),
     )
@@ -135,9 +229,15 @@ describe('createSkill', () => {
     const mockFetch = vi.fn().mockRejectedValue(new Error('connection refused'))
     vi.stubGlobal('fetch', mockFetch)
 
-    const result = await createSkill(config, token, 'my-skill', 'A test skill')
+    const result = await registerSkill(
+      config,
+      token,
+      'my-skill',
+      'https://github.com/org/repo',
+      'skills/my-skill',
+    )
 
-    expect(result).toBe('Error creating skill: connection refused')
+    expect(result).toBe('Error registering skill: connection refused')
   })
 
   it('returns error string on non-ok response', async () => {
@@ -147,43 +247,54 @@ describe('createSkill', () => {
     })
     vi.stubGlobal('fetch', mockFetch)
 
-    const result = await createSkill(config, token, 'my-skill', 'A test skill')
+    const result = await registerSkill(
+      config,
+      token,
+      'my-skill',
+      'https://github.com/org/repo',
+      'skills/my-skill',
+    )
 
-    expect(result).toContain('Error creating skill')
+    expect(result).toContain('Error registering skill')
   })
 
-  it('includes input_schema and code when provided', async () => {
+  it('includes domain when provided', async () => {
     const mockFetch = vi.fn().mockResolvedValue({
       ok: true,
       status: 200,
-      json: async () => ({ id: 'skill-3', name: 'complex-skill' }),
+      json: async () => ({ plugin: { id: 'skill-3', name: 'domain-skill' } }),
     })
     vi.stubGlobal('fetch', mockFetch)
 
-    await createSkill(
+    await registerSkill(
       config,
       token,
-      'complex-skill',
-      'A complex skill',
-      { type: 'object', properties: { value: { type: 'string' } } },
-      'print("hello")',
+      'domain-skill',
+      'https://github.com/org/repo',
+      'skills/domain-skill',
+      'A domain skill',
+      'Productivity',
     )
 
     expect(mockFetch).toHaveBeenCalledWith(
-      'https://litellm.example.com/v1/skills',
+      'https://litellm.example.com/claude-code/plugins',
       expect.objectContaining({
         body: JSON.stringify({
-          name: 'complex-skill',
-          description: 'A complex skill',
-          input_schema: { type: 'object', properties: { value: { type: 'string' } } },
-          code: 'print("hello")',
+          name: 'domain-skill',
+          source: {
+            source: 'git-subdir',
+            url: 'https://github.com/org/repo',
+            path: 'skills/domain-skill',
+          },
+          description: 'A domain skill',
+          domain: 'Productivity',
         }),
       }),
     )
   })
 })
 
-describe('deleteSkill', () => {
+describe('enableSkill', () => {
   const config: PluginConfig = {
     url: 'https://litellm.example.com',
     apiKey: 'test-api-key',
@@ -201,13 +312,13 @@ describe('deleteSkill', () => {
     })
     vi.stubGlobal('fetch', mockFetch)
 
-    const result = await deleteSkill(config, token, 'skill-1')
+    const result = await enableSkill(config, token, 'my-skill')
 
-    expect(result).toBe('Skill "skill-1" deleted')
+    expect(result).toBe('Skill "my-skill" enabled')
     expect(mockFetch).toHaveBeenCalledWith(
-      'https://litellm.example.com/v1/skills/skill-1',
+      'https://litellm.example.com/claude-code/plugins/my-skill/enable',
       expect.objectContaining({
-        method: 'DELETE',
+        method: 'POST',
         headers: expect.objectContaining({
           Authorization: 'Bearer test-token',
         }),
@@ -220,9 +331,9 @@ describe('deleteSkill', () => {
     const mockFetch = vi.fn().mockRejectedValue(new Error('connection refused'))
     vi.stubGlobal('fetch', mockFetch)
 
-    const result = await deleteSkill(config, token, 'skill-1')
+    const result = await enableSkill(config, token, 'my-skill')
 
-    expect(result).toBe('Error deleting skill: connection refused')
+    expect(result).toBe('Error enabling skill: connection refused')
   })
 
   it('returns error string on non-ok response', async () => {
@@ -232,9 +343,122 @@ describe('deleteSkill', () => {
     })
     vi.stubGlobal('fetch', mockFetch)
 
-    const result = await deleteSkill(config, token, 'skill-1')
+    const result = await enableSkill(config, token, 'my-skill')
 
-    expect(result).toContain('Error deleting skill')
+    expect(result).toContain('Error enabling skill')
+  })
+})
+
+describe('disableSkill', () => {
+  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 disableSkill(config, token, 'my-skill')
+
+    expect(result).toBe('Skill "my-skill" disabled')
+    expect(mockFetch).toHaveBeenCalledWith(
+      'https://litellm.example.com/claude-code/plugins/my-skill/disable',
+      expect.objectContaining({
+        method: 'POST',
+        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 disableSkill(config, token, 'my-skill')
+
+    expect(result).toBe('Error disabling 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 disableSkill(config, token, 'my-skill')
+
+    expect(result).toContain('Error disabling skill')
+  })
+})
+
+describe('fetchSkillContent', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('returns SKILL.md content from GitHub', async () => {
+    const mockContent = '# Test Skill\n\nThis is a test skill.'
+
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      text: async () => mockContent,
+    })
+    vi.stubGlobal('fetch', mockFetch)
+
+    const result = await fetchSkillContent(mockSkill)
+
+    expect(result).toBe(mockContent)
+    expect(mockFetch).toHaveBeenCalledWith(
+      'https://raw.githubusercontent.com/org/repo/master/skills/code-review/SKILL.md',
+      expect.any(Object),
+    )
+  })
+
+  it('returns null on non-ok response', async () => {
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: false,
+      status: 404,
+    })
+    vi.stubGlobal('fetch', mockFetch)
+
+    const result = await fetchSkillContent(mockSkill)
+    expect(result).toBeNull()
+  })
+
+  it('returns null on network error', async () => {
+    const mockFetch = vi.fn().mockRejectedValue(new Error('network error'))
+    vi.stubGlobal('fetch', mockFetch)
+
+    const result = await fetchSkillContent(mockSkill)
+    expect(result).toBeNull()
+  })
+
+  it('returns null for unsupported source type', async () => {
+    const mockFetch = vi.fn()
+    vi.stubGlobal('fetch', mockFetch)
+
+    const unsupportedSkill: Skill = {
+      ...mockSkill,
+      source: { source: 'inline', url: 'not-a-git-url' },
+    }
+
+    const result = await fetchSkillContent(unsupportedSkill)
+    expect(result).toBeNull()
+    expect(mockFetch).not.toHaveBeenCalled()
   })
 })
 
@@ -249,41 +473,50 @@ describe('createSkillToolDefinitions', () => {
     vi.restoreAllMocks()
   })
 
-  it('returns 3 tools with correct names', () => {
+  it('returns 4 tools with correct names', () => {
     const result = createSkillToolDefinitions(config, token)
 
-    expect(Object.keys(result)).toHaveLength(3)
+    expect(Object.keys(result)).toHaveLength(4)
     expect(result).toHaveProperty('skill_list')
-    expect(result).toHaveProperty('skill_create')
-    expect(result).toHaveProperty('skill_delete')
+    expect(result).toHaveProperty('skill_register')
+    expect(result).toHaveProperty('skill_enable')
+    expect(result).toHaveProperty('skill_disable')
   })
 
   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')
+    expect(result.skill_list.description).toBe('List all skills registered on the LiteLLM Skills Gateway')
+  })
+
+  it('skill_register has correct description', () => {
+    const result = createSkillToolDefinitions(config, token)
+
+    expect(result.skill_register.description).toBe('Register a new skill on the LiteLLM Skills Gateway pointing to a git source')
   })
 
-  it('skill_create has correct description', () => {
+  it('skill_enable has correct description', () => {
     const result = createSkillToolDefinitions(config, token)
 
-    expect(result.skill_create.description).toBe('Create a new skill on the LiteLLM proxy')
+    expect(result.skill_enable.description).toBe('Enable (publish) a skill on the LiteLLM Skills Gateway')
   })
 
-  it('skill_delete has correct description', () => {
+  it('skill_disable has correct description', () => {
     const result = createSkillToolDefinitions(config, token)
 
-    expect(result.skill_delete.description).toBe('Delete a skill from the LiteLLM proxy')
+    expect(result.skill_disable.description).toBe('Disable (unpublish) a skill on the LiteLLM Skills Gateway')
   })
 
   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 },
-      ],
+      json: async () => ({
+        plugins: [
+          { ...mockSkill, name: 'code-review', description: 'Reviews code', enabled: true },
+          { ...mockSkill, name: 'security-scan', description: 'Scans security', enabled: false },
+        ],
+      }),
     })
     vi.stubGlobal('fetch', mockFetch)
 
@@ -297,25 +530,47 @@ describe('createSkillToolDefinitions', () => {
     expect(output).toContain('Scans security')
   })
 
-  it('skill_create execute calls createSkill', async () => {
+  it('skill_register execute calls registerSkill', async () => {
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => ({ plugin: { id: 'new-skill', name: 'new-skill' } }),
+    })
+    vi.stubGlobal('fetch', mockFetch)
+
+    const result = createSkillToolDefinitions(config, token)
+
+    const output = await result.skill_register.execute(
+      {
+        name: 'new-skill',
+        git_url: 'https://github.com/org/repo',
+        git_path: 'skills/new-skill',
+        description: 'A new skill',
+      },
+      {} as any,
+    )
+
+    expect(output).toBe('Skill "new-skill" registered (id: new-skill)')
+  })
+
+  it('skill_enable execute calls enableSkill', 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' },
+    const output = await result.skill_enable.execute(
+      { name: 'skill-to-enable' },
       {} as any,
     )
 
-    expect(output).toBe('Skill "new-skill" created (id: skill-new)')
+    expect(output).toBe('Skill "skill-to-enable" enabled')
   })
 
-  it('skill_delete execute calls deleteSkill', async () => {
+  it('skill_disable execute calls disableSkill', async () => {
     const mockFetch = vi.fn().mockResolvedValue({
       ok: true,
       status: 200,
@@ -324,12 +579,12 @@ describe('createSkillToolDefinitions', () => {
 
     const result = createSkillToolDefinitions(config, token)
 
-    const output = await result.skill_delete.execute(
-      { skill_id: 'skill-to-delete' },
+    const output = await result.skill_disable.execute(
+      { name: 'skill-to-disable' },
       {} as any,
     )
 
-    expect(output).toBe('Skill "skill-to-delete" deleted')
+    expect(output).toBe('Skill "skill-to-disable" disabled')
   })
 })
 
@@ -349,10 +604,12 @@ describe('createSkillsInjector', () => {
     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' },
-      ],
+      json: async () => ({
+        plugins: [
+          { ...mockSkill, name: 'code-review', description: 'Reviews code', enabled: true },
+          { ...mockSkill, name: 'security-scan', description: 'Scans security', enabled: true },
+        ],
+      }),
     })
     vi.stubGlobal('fetch', mockFetch)
 
@@ -373,9 +630,7 @@ describe('createSkillsInjector', () => {
     const mockFetch = vi.fn().mockResolvedValue({
       ok: true,
       status: 200,
-      json: async () => [
-        { id: 'skill-1', name: 'code-review', description: 'Reviews code', enabled: true },
-      ],
+      json: async () => ({ plugins: [mockSkill] }),
     })
     vi.stubGlobal('fetch', mockFetch)
 
@@ -386,9 +641,7 @@ describe('createSkillsInjector', () => {
 
     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()
   })
 
@@ -396,9 +649,11 @@ describe('createSkillsInjector', () => {
     const mockFetch = vi.fn().mockResolvedValue({
       ok: true,
       status: 200,
-      json: async () => [
-        { id: 'skill-1', name: 'disabled-skill', description: 'Disabled', enabled: false },
-      ],
+      json: async () => ({
+        plugins: [
+          { ...mockSkill, name: 'disabled-skill', description: 'Disabled', enabled: false },
+        ],
+      }),
     })
     vi.stubGlobal('fetch', mockFetch)
 
@@ -412,23 +667,45 @@ describe('createSkillsInjector', () => {
     expect(output.parts).toEqual([])
   })
 
+  it('uses "No description" for null descriptions', async () => {
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        plugins: [
+          { ...mockSkill, name: 'no-desc-skill', description: null, enabled: true },
+        ],
+      }),
+    })
+    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[0].text).toContain('<skill name="no-desc-skill">No description</skill>')
+  })
+
   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 },
-      ],
+      json: async () => ({
+        plugins: [
+          { ...mockSkill, 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)
   })
@@ -442,7 +719,6 @@ describe('createSkillsInjector', () => {
     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

@@ -15,7 +15,7 @@ export function resetSkillsCache(): void {
 }
 
 /**
- * Fetches all skills from the LiteLLM proxy.
+ * Fetches all skills from the LiteLLM Skills Gateway.
  * Returns an empty array on any error (network, 4xx, 5xx, parse failure).
  * Uses a 10s timeout via AbortController.
  */
@@ -27,7 +27,7 @@ export async function listSkills(
   const timeoutId = setTimeout(() => controller.abort(), 10_000)
 
   try {
-    const response = await fetch(`${config.url}/v1/skills`, {
+    const response = await fetch(`${config.url}/claude-code/plugins`, {
       method: 'GET',
       headers: {
         Authorization: `Bearer ${token}`,
@@ -41,11 +41,11 @@ export async function listSkills(
 
     const body = await response.json()
 
-    if (!Array.isArray(body)) {
+    if (!body || !Array.isArray(body.plugins)) {
       return []
     }
 
-    return body as Skill[]
+    return body.plugins as Skill[]
   } catch {
     return []
   } finally {
@@ -54,23 +54,55 @@ export async function listSkills(
 }
 
 /**
- * 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.
+ * Fetches only enabled (public) skills from the LiteLLM Skill Hub.
+ * No auth required. Useful for discovery without credentials.
  */
-export async function createSkill(
+export async function listPublicSkills(config: PluginConfig): Promise<Skill[]> {
+  const controller = new AbortController()
+  const timeoutId = setTimeout(() => controller.abort(), 10_000)
+
+  try {
+    const response = await fetch(`${config.url}/public/skill_hub`, {
+      method: 'GET',
+      signal: controller.signal,
+    })
+
+    if (!response.ok) {
+      return []
+    }
+
+    const body = await response.json()
+
+    if (!body || !Array.isArray(body.plugins)) {
+      return []
+    }
+
+    return body.plugins as Skill[]
+  } catch {
+    return []
+  } finally {
+    clearTimeout(timeoutId)
+  }
+}
+
+/**
+ * Registers a new skill on the LiteLLM Skills Gateway.
+ * The skill points to a git source containing a SKILL.md file.
+ */
+export async function registerSkill(
   config: PluginConfig,
   token: string,
   name: string,
-  description: string,
-  inputSchema?: Record<string, unknown>,
-  code?: string,
+  gitUrl: string,
+  gitPath: string,
+  description?: string,
+  domain?: string,
 ): Promise<string> {
   const controller = new AbortController()
   const timeoutId = setTimeout(() => controller.abort(), 10_000)
 
   try {
-    const response = await fetch(`${config.url}/v1/skills`, {
+    const response = await fetch(`${config.url}/claude-code/plugins`, {
       method: 'POST',
       headers: {
         Authorization: `Bearer ${token}`,
@@ -78,44 +110,79 @@ export async function createSkill(
       },
       body: JSON.stringify({
         name,
-        description,
-        input_schema: inputSchema,
-        code,
+        source: {
+          source: 'git-subdir',
+          url: gitUrl,
+          path: gitPath,
+        },
+        description: description || null,
+        domain: domain || null,
       }),
       signal: controller.signal,
     })
 
     if (!response.ok) {
-      return `Error creating skill: HTTP ${response.status}`
+      return `Error registering skill: HTTP ${response.status}`
     }
 
     const body = await response.json()
-    const id = body.id ?? 'unknown'
-    return `Skill "${name}" created (id: ${id})`
+    const id = body?.plugin?.id ?? 'unknown'
+    return `Skill "${name}" registered (id: ${id})`
   } catch (error: unknown) {
     const message = error instanceof Error ? error.message : String(error)
-    return `Error creating skill: ${message}`
+    return `Error registering 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.
+ * Enables (publishes) a skill on the LiteLLM Skills Gateway.
+ */
+export async function enableSkill(
+  config: PluginConfig,
+  token: string,
+  name: string,
+): Promise<string> {
+  const controller = new AbortController()
+  const timeoutId = setTimeout(() => controller.abort(), 10_000)
+
+  try {
+    const response = await fetch(`${config.url}/claude-code/plugins/${name}/enable`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${token}`,
+      },
+      signal: controller.signal,
+    })
+
+    if (!response.ok) {
+      return `Error enabling skill: HTTP ${response.status}`
+    }
+
+    return `Skill "${name}" enabled`
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error)
+    return `Error enabling skill: ${message}`
+  } finally {
+    clearTimeout(timeoutId)
+  }
+}
+
+/**
+ * Disables (unpublishes) a skill on the LiteLLM Skills Gateway.
  */
-export async function deleteSkill(
+export async function disableSkill(
   config: PluginConfig,
   token: string,
-  skillId: string,
+  name: 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',
+    const response = await fetch(`${config.url}/claude-code/plugins/${name}/disable`, {
+      method: 'POST',
       headers: {
         Authorization: `Bearer ${token}`,
       },
@@ -123,21 +190,83 @@ export async function deleteSkill(
     })
 
     if (!response.ok) {
-      return `Error deleting skill: HTTP ${response.status}`
+      return `Error disabling skill: HTTP ${response.status}`
     }
 
-    return `Skill "${skillId}" deleted`
+    return `Skill "${name}" disabled`
   } catch (error: unknown) {
     const message = error instanceof Error ? error.message : String(error)
-    return `Error deleting skill: ${message}`
+    return `Error disabling 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.
+ * Fetches the SKILL.md content from a skill's git source.
+ * Currently supports GitHub raw URLs.
+ */
+export async function fetchSkillContent(skill: Skill): Promise<string | null> {
+  const controller = new AbortController()
+  const timeoutId = setTimeout(() => controller.abort(), 10_000)
+
+  try {
+    const rawUrl = buildRawGitUrl(skill.source)
+    if (!rawUrl) return null
+
+    const response = await fetch(rawUrl, {
+      signal: controller.signal,
+    })
+
+    if (!response.ok) return null
+
+    return await response.text()
+  } catch {
+    return null
+  } finally {
+    clearTimeout(timeoutId)
+  }
+}
+
+/**
+ * Builds a raw git URL for the SKILL.md file from a skill's source.
+ * Currently supports GitHub git-subdir sources.
+ */
+function buildRawGitUrl(source: Skill['source']): string | null {
+  if (source.source !== 'git-subdir') return null
+
+  const url = source.url
+  if (!url.includes('github.com')) return null
+
+  const isRaw = url.startsWith('https://raw.githubusercontent.com')
+  if (isRaw) {
+    const branch = extractBranch(url)
+    const path = source.path || ''
+    return `https://raw.githubusercontent.com/${url.replace('https://raw.githubusercontent.com/', '').split('/').slice(0, 2).join('/')}/${branch}/${path}/SKILL.md`
+  }
+
+  const match = url.match(/https:\/\/github\.com\/([^/]+)\/([^/]+)(?:\/.*)?/)
+  if (!match) return null
+
+  const [, owner, repo] = match
+  const branch = extractBranch(url) || 'master'
+  const path = source.path || ''
+
+  return `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/${path}/SKILL.md`
+}
+
+/**
+ * Extracts the branch name from a GitHub URL.
+ * Falls back to 'master' if not found.
+ */
+function extractBranch(url: string): string | null {
+  const match = url.match(/\/tree\/([^/]+)/)
+  return match ? match[1] : null
+}
+
+/**
+ * Creates opencode tool definitions for skill management operations.
+ * Returns tools: skill_list, skill_register, skill_enable, skill_disable.
  */
 export function createSkillToolDefinitions(
   config: PluginConfig,
@@ -145,7 +274,7 @@ export function createSkillToolDefinitions(
 ): Record<string, any> {
   return {
     skill_list: tool({
-      description: 'List all skills registered on the LiteLLM proxy',
+      description: 'List all skills registered on the LiteLLM Skills Gateway',
       args: {},
       async execute(_args: Record<string, unknown>, _context: unknown): Promise<string> {
         const skills = await listSkills(config, token)
@@ -154,12 +283,12 @@ export function createSkillToolDefinitions(
           return 'No skills found.'
         }
 
-        const header = '| ID | Name | Description | Enabled |'
-        const sep = '|------|------|-------------|---------|'
+        const header = '| Name | Description | Enabled | Source |'
+        const sep = '|--------|-------------|---------|--------|'
         const rows = skills
           .map(
             (s) =>
-              `| ${s.id} | ${s.name} | ${s.description} | ${s.enabled !== false ? 'yes' : 'no'} |`,
+              `| ${s.name} | ${s.description || '-'} | ${s.enabled ? 'yes' : 'no'} | ${s.source.url} |`,
           )
           .join('\n')
 
@@ -167,37 +296,45 @@ export function createSkillToolDefinitions(
       },
     }),
 
-    skill_create: tool({
-      description: 'Create a new skill on the LiteLLM proxy',
+    skill_register: tool({
+      description: 'Register a new skill on the LiteLLM Skills Gateway pointing to a git source',
       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'),
+        git_url: tool.schema.string().describe('GitHub repository URL containing the skill'),
+        git_path: tool.schema.string().describe('Path within the repo to the skill directory (must contain SKILL.md)'),
+        description: tool.schema.string().optional().describe('Description of the skill'),
+        domain: tool.schema.string().optional().describe('Domain/category for the skill'),
       },
       async execute(args: Record<string, unknown>, _context: unknown): Promise<string> {
-        return createSkill(
+        return registerSkill(
           config,
           token,
           args.name as string,
-          args.description as string,
-          args.input_schema as Record<string, unknown> | undefined,
-          args.code as string | undefined,
+          args.git_url as string,
+          args.git_path as string,
+          args.description as string | undefined,
+          args.domain as string | undefined,
         )
       },
     }),
 
-    skill_delete: tool({
-      description: 'Delete a skill from the LiteLLM proxy',
+    skill_enable: tool({
+      description: 'Enable (publish) a skill on the LiteLLM Skills Gateway',
+      args: {
+        name: tool.schema.string().describe('Name of the skill to enable'),
+      },
+      async execute(args: Record<string, unknown>, _context: unknown): Promise<string> {
+        return enableSkill(config, token, args.name as string)
+      },
+    }),
+
+    skill_disable: tool({
+      description: 'Disable (unpublish) a skill on the LiteLLM Skills Gateway',
       args: {
-        skill_id: tool.schema.string().describe('ID of the skill to delete'),
+        name: tool.schema.string().describe('Name of the skill to disable'),
       },
       async execute(args: Record<string, unknown>, _context: unknown): Promise<string> {
-        return deleteSkill(config, token, args.skill_id as string)
+        return disableSkill(config, token, args.name as string)
       },
     }),
   }
@@ -216,10 +353,8 @@ export function createSkillsInjector(
   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
@@ -232,7 +367,7 @@ export function createSkillsInjector(
     if (enabledSkills.length === 0) return
 
     const context = enabledSkills
-      .map((s) => `<skill name="${s.name}">${s.description}</skill>`)
+      .map((s) => `<skill name="${s.name}">${s.description || 'No description'}</skill>`)
       .join('\n')
 
     output.parts.push({ type: 'text', text: context })

package/src/types.ts

@@ -15,12 +15,27 @@ export interface McpTool {
   input_schema: Record<string, unknown>
 }
 
+export interface SkillSource {
+  source: string
+  url: string
+  path?: string
+}
+
 export interface Skill {
   id: string
   name: string
-  description: string
-  enabled?: boolean
-  [key: string]: unknown
+  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 {