opencode-provider-litellm 0.1.0 → 0.2.0

package/src/mcp-tools.ts

@@ -0,0 +1,253 @@
+import { tool } from '@opencode-ai/plugin'
+import type { PluginConfig, McpTool } from './types.js'
+
+/**
+ * Discovers MCP tools available on the LiteLLM proxy by calling
+ * GET /mcp-rest/tools/list.
+ *
+ * Returns an empty array on any error (network, 4xx, 5xx, parse failure).
+ * Uses a 10s timeout via AbortController.
+ */
+export async function discoverMcpTools(
+  config: PluginConfig,
+  token: string,
+): Promise<McpTool[]> {
+  const controller = new AbortController()
+  const timeoutId = setTimeout(() => controller.abort(), 10_000)
+
+  try {
+    const response = await fetch(`${config.url}/mcp-rest/tools/list`, {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+      signal: controller.signal,
+    })
+
+    if (!response.ok) {
+      return []
+    }
+
+    const body = await response.json()
+
+    if (!Array.isArray(body)) {
+      return []
+    }
+
+    return body as McpTool[]
+  } catch {
+    return []
+  } finally {
+    clearTimeout(timeoutId)
+  }
+}
+
+/**
+ * Executes a specific MCP tool on the LiteLLM proxy by calling
+ * POST /mcp-rest/tools/call.
+ *
+ * Returns the result as a formatted string. On error, returns an error
+ * message string instead of throwing.
+ * Uses a 30s timeout via AbortController.
+ */
+export async function executeMcpTool(
+  config: PluginConfig,
+  token: string,
+  server: string,
+  toolName: string,
+  args: Record<string, unknown>,
+): Promise<string> {
+  const controller = new AbortController()
+  const timeoutId = setTimeout(() => controller.abort(), 30_000)
+
+  try {
+    const response = await fetch(`${config.url}/mcp-rest/tools/call`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ server, tool: toolName, args }),
+      signal: controller.signal,
+    })
+
+    if (!response.ok) {
+      return `Error calling ${toolName} on ${server}: HTTP ${response.status}`
+    }
+
+    const body = await response.json()
+
+    if (body && typeof body === 'object' && 'result' in body) {
+      return JSON.stringify(body.result, null, 2)
+    }
+
+    return JSON.stringify(body, null, 2)
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error)
+    return `Error calling ${toolName} on ${server}: ${message}`
+  } finally {
+    clearTimeout(timeoutId)
+  }
+}
+
+/**
+ * Sanitize a server name or tool name for use in opencode tool identifiers.
+ * Lowercase, replace any non-alphanumeric chars with underscore.
+ */
+function sanitizeName(name: string): string {
+  return name.toLowerCase().replace(/[^a-z0-9]/g, '_')
+}
+
+/**
+ * Check if a JSON Schema property can be mapped to a zod type.
+ * Returns true for: string, number, integer, boolean, array of strings.
+ * Returns false for: nested objects, $ref, anyOf, etc.
+ */
+function isMappableSchema(propSchema: unknown): boolean {
+  if (!propSchema || typeof propSchema !== 'object') return false
+
+  const schema = propSchema as Record<string, unknown>
+
+  // Reject if it has $ref or anyOf
+  if ('$ref' in schema || 'anyOf' in schema || 'oneOf' in schema || 'allOf' in schema) {
+    return false
+  }
+
+  const type = schema.type as string | undefined
+  if (!type) return false
+
+  if (type === 'string' || type === 'number' || type === 'integer' || type === 'boolean') {
+    return true
+  }
+
+  if (type === 'array') {
+    const items = schema.items as Record<string, unknown> | undefined
+    if (items && items.type === 'string') {
+      return true
+    }
+    return false
+  }
+
+  return false
+}
+
+/**
+ * Build zod args from a JSON Schema input_schema.
+ * Returns null if the schema cannot be mapped (use single-arg fallback).
+ */
+function buildZodArgs(inputSchema: Record<string, unknown>): Record<string, unknown> | null {
+  const properties = inputSchema.properties as Record<string, unknown> | undefined
+  const required = (inputSchema.required as string[] | undefined) ?? []
+
+  if (!properties || typeof properties !== 'object') {
+    return null
+  }
+
+  // Check if all properties are mappable
+  for (const key of Object.keys(properties)) {
+    if (!isMappableSchema(properties[key])) {
+      return null
+    }
+  }
+
+  const zodArgs: Record<string, unknown> = {}
+
+  for (const [key, propSchema] of Object.entries(properties)) {
+    const schema = propSchema as Record<string, unknown>
+    const type = schema.type as string | undefined
+    const isRequired = required.includes(key)
+
+    let zodField: unknown
+
+    switch (type) {
+      case 'string':
+        zodField = tool.schema.string().describe(key)
+        break
+      case 'number':
+      case 'integer':
+        zodField = tool.schema.number().describe(key)
+        break
+      case 'boolean':
+        zodField = tool.schema.boolean().describe(key)
+        break
+      case 'array': {
+        const items = schema.items as Record<string, unknown> | undefined
+        if (items && items.type === 'string') {
+          zodField = tool.schema.array(tool.schema.string()).describe(key)
+        } else {
+          return null
+        }
+        break
+      }
+      default:
+        return null
+    }
+
+    if (!isRequired) {
+      // @ts-expect-error — optional() is available on all zod types
+      zodField = zodField.optional()
+    }
+
+    zodArgs[key] = zodField
+  }
+
+  return zodArgs
+}
+
+/**
+ * Creates opencode tool definitions for all discovered MCP tools.
+ *
+ * Each MCP tool is registered as `mcp_${serverName}_${toolName}` with
+ * a description appended with the server name.
+ *
+ * Returns an empty object if no tools are discovered.
+ */
+export async function createMcpToolDefinitions(
+  config: PluginConfig,
+  token: string,
+): Promise<Record<string, any>> {
+  const mcpTools = await discoverMcpTools(config, token)
+
+  if (mcpTools.length === 0) {
+    return {}
+  }
+
+  const definitions: Record<string, any> = {}
+
+  for (const mcpTool of mcpTools) {
+    const serverName = mcpTool.server_name
+    const toolName = mcpTool.name
+
+    const safeServer = sanitizeName(serverName)
+    const safeTool = sanitizeName(toolName)
+    const opencodeName = `mcp_${safeServer}_${safeTool}`
+
+    const description = `${mcpTool.description} (via ${serverName} MCP server)`
+
+    // Build args from input_schema
+    const zodArgs = buildZodArgs(mcpTool.input_schema)
+
+    let args: Record<string, any>
+    if (zodArgs) {
+      args = zodArgs
+    } else {
+      // Fallback: single-arg mode
+      args = {
+        args: tool.schema
+          .record(tool.schema.string(), tool.schema.unknown())
+          .describe('Tool arguments as key-value pairs'),
+      }
+    }
+
+    definitions[opencodeName] = tool({
+      description,
+      args: args as Parameters<typeof tool>[0]['args'],
+      async execute(args: Record<string, unknown>, _context: unknown): Promise<string> {
+        return executeMcpTool(config, token, serverName, toolName, args)
+      },
+    })
+  }
+
+  return definitions
+}

package/src/plugin.test.ts

@@ -15,9 +15,22 @@ vi.mock('./utils.js', () => ({
   mapLiteLLMModel: vi.fn(),
 }))
 
+// Mock the MCP tools module
+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)
@@ -61,6 +74,19 @@ describe('LiteLLMPlugin', () => {
       url: 'https://litellm.example.com',
       apiKey: 'test-api-key',
     })
+
+    // Default MCP mock: returns one tool
+    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 () => {
@@ -177,4 +203,113 @@ describe('LiteLLMPlugin', () => {
     const result = await hooks.auth?.methods[0].authorize?.()
     expect(result).toEqual({ type: 'failed' })
   })
+
+  it('tool hook returns merged MCP + Skills tools', async () => {
+    const hooks = await LiteLLMPlugin(mockInput, {
+      url: 'https://litellm.example.com',
+      apiKey: 'test-api-key',
+    })
+
+    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 () => {
+    await LiteLLMPlugin(mockInput, {
+      url: 'https://litellm.example.com',
+      apiKey: 'test-api-key',
+    })
+
+    expect(createMcpToolDefinitions).toHaveBeenCalledWith(
+      { url: 'https://litellm.example.com', apiKey: 'test-api-key' },
+      'test-api-key',
+    )
+  })
+
+  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 () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    vi.mocked(createMcpToolDefinitions).mockRejectedValue(new Error('MCP server unavailable'))
+
+    const hooks = await LiteLLMPlugin(mockInput, {
+      url: 'https://litellm.example.com',
+      apiKey: 'test-api-key',
+    })
+
+    expect(warnSpy).toHaveBeenCalledWith(
+      '[opencode-provider-litellm] MCP tool discovery failed: Error: MCP server unavailable',
+    )
+
+    // 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')
+
+    warnSpy.mockRestore()
+  })
+
+  it('plugin works with env vars (no inline config)', async () => {
+    process.env.LITELLM_URL = 'https://env.litellm.example.com'
+    process.env.LITELLM_KEY = 'env-api-key'
+
+    vi.mocked(resolvePluginConfig).mockReturnValue({
+      url: 'https://env.litellm.example.com',
+      apiKey: 'env-api-key',
+    })
+
+    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',
+    )
+
+    delete process.env.LITELLM_URL
+    delete process.env.LITELLM_KEY
+  })
 })

package/src/plugin.ts

@@ -1,6 +1,8 @@
 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.
@@ -25,6 +27,14 @@ 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)
+  } catch (e) {
+    console.warn(`[opencode-provider-litellm] MCP tool discovery failed: ${e}`)
+  }
+
   return {
     /**
      * Config hook — discovers models from the LiteLLM proxy and injects
@@ -100,5 +110,19 @@ 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),
   }
 }