opencode-litellm-plugin 1.0.0

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "opencode-litellm-plugin",
+  "version": "1.0.0",
+  "description": "OpenCode plugin for LiteLLM — auto-discovers models, manages multiple servers, and supports reasoning variants",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": "Dan Jeffries",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dan-jeff/opencode-litellm-provider.git"
+  },
+  "bugs": {
+    "url": "https://github.com/dan-jeff/opencode-litellm-provider/issues"
+  },
+  "homepage": "https://github.com/dan-jeff/opencode-litellm-provider#readme",
+  "keywords": [
+    "opencode",
+    "litellm",
+    "plugin",
+    "llm",
+    "ai",
+    "provider"
+  ],
+  "files": [
+    "dist/index.js",
+    "src/",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && npx --yes bun build ./src/index.ts --outfile=./dist/index.js --target=bun",
+    "deploy": "node -e \"const fs = require('fs'); const os = require('os'); const path = require('path'); const targetDir = path.join(os.homedir(), '.config', 'opencode', 'plugins'); fs.mkdirSync(targetDir, { recursive: true }); fs.copyFileSync(path.join('dist', 'index.js'), path.join(targetDir, 'litellm.js'));\"",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "latest",
+    "zod": "latest"
+  },
+  "devDependencies": {
+    "typescript": "latest",
+    "@types/node": "latest",
+    "bun-types": "latest"
+  }
+}

package/src/client.ts

@@ -0,0 +1,99 @@
+export interface LiteLLMModel {
+  id: string;
+  name: string;
+  contextWindow: number;
+  maxOutputTokens: number;
+  supportsVision: boolean;
+  supportsToolCalls: boolean;
+  supportsReasoning: boolean;
+  litellmProvider: string | null;
+  supportedParams: string[];
+}
+
+export function normalizeUrl(url: string): string {
+  let normalized = url.trim();
+  if (normalized.endsWith('/')) {
+    normalized = normalized.slice(0, -1);
+  }
+  if (normalized.endsWith('/v1')) {
+    normalized = normalized.slice(0, -3);
+  }
+  return normalized;
+}
+
+/**
+ * Fetches available models from the LiteLLM server via /v1/models,
+ * then enriches with capability data from /model/info when available.
+ */
+export async function fetchModels(url: string, key: string): Promise<LiteLLMModel[]> {
+  const baseUrl = normalizeUrl(url);
+  const headers = {
+    'Authorization': `Bearer ${key}`,
+    'Content-Type': 'application/json',
+  };
+
+  // Fetch the model list
+  const response = await fetch(`${baseUrl}/v1/models`, {
+    method: 'GET',
+    headers,
+  });
+
+  if (!response.ok) {
+    let errorMessage = `Failed to fetch models: ${response.status} ${response.statusText}`;
+    try {
+      const errorData = await response.json();
+      if (errorData?.error) {
+        errorMessage += `. ${errorData.error.message || JSON.stringify(errorData.error)}`;
+      }
+    } catch (_) {}
+    throw new Error(errorMessage);
+  }
+
+  const data = await response.json();
+  if (!data || !Array.isArray(data.data)) {
+    return [];
+  }
+
+  // Try to fetch detailed model info for capabilities
+  let modelInfo: Record<string, any> = {};
+  try {
+    const infoResponse = await fetch(`${baseUrl}/model/info`, {
+      method: 'GET',
+      headers,
+    });
+    if (infoResponse.ok) {
+      const infoData = await infoResponse.json();
+      if (infoData?.data && Array.isArray(infoData.data)) {
+        for (const entry of infoData.data) {
+          const info = entry.model_info || {};
+          const id = entry.model_name || info.id;
+          if (id) modelInfo[id] = info;
+        }
+      }
+    }
+  } catch (_) {
+    // /model/info is optional — fall back to conservative defaults
+  }
+
+  return data.data.map((model: any) => {
+    const info = modelInfo[model.id] || {};
+    const params: string[] = info.supported_openai_params || [];
+
+    // supports_reasoning is often null even for reasoning models;
+    // check if reasoning_effort is an accepted param as a stronger signal
+    const reasoning = info.supports_reasoning === true
+      || params.includes('reasoning_effort');
+
+    return {
+      id: model.id,
+      name: model.name || model.id,
+      contextWindow: info.max_input_tokens || info.max_tokens || model.context_window || 128000,
+      maxOutputTokens: info.max_output_tokens || 4096,
+      supportsVision: info.supports_vision ?? false,
+      supportsToolCalls: info.supports_function_calling ?? true,
+      supportsReasoning: reasoning,
+      litellmProvider: info.litellm_provider || null,
+      supportedParams: params,
+    };
+  });
+}

package/src/config.ts

@@ -0,0 +1,80 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+export interface LiteLLMConfig {
+  alias: string;
+  url: string;
+  key: string;
+}
+
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'opencode');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'auth.json');
+
+function ensureConfigExists(): void {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  if (!fs.existsSync(CONFIG_FILE)) {
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify({ litellm: [] }, null, 2));
+  } else {
+    try {
+      const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
+      const json = JSON.parse(data);
+      if (!json.litellm) {
+        json.litellm = [];
+        fs.writeFileSync(CONFIG_FILE, JSON.stringify(json, null, 2));
+      }
+    } catch (error) {
+      fs.writeFileSync(CONFIG_FILE, JSON.stringify({ litellm: [] }, null, 2));
+    }
+  }
+}
+
+export function getConfigs(): LiteLLMConfig[] {
+  ensureConfigExists();
+  try {
+    const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
+    const json = JSON.parse(data);
+    return json.litellm || [];
+  } catch (error) {
+    return [];
+  }
+}
+
+export function addConfig(config: LiteLLMConfig): void {
+  ensureConfigExists();
+  try {
+    const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
+    const json = JSON.parse(data);
+    const configs: LiteLLMConfig[] = json.litellm || [];
+
+    const index = configs.findIndex((c) => c.alias === config.alias);
+    if (index !== -1) {
+      configs[index] = config;
+    } else {
+      configs.push(config);
+    }
+
+    json.litellm = configs;
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(json, null, 2), 'utf-8');
+  } catch (error) {
+    console.error('Error adding configuration:', error);
+  }
+}
+
+export function removeConfig(alias: string): void {
+  ensureConfigExists();
+  try {
+    const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
+    const json = JSON.parse(data);
+    const configs: LiteLLMConfig[] = json.litellm || [];
+
+    const filteredConfigs = configs.filter((c) => c.alias !== alias);
+
+    json.litellm = filteredConfigs;
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(json, null, 2), 'utf-8');
+  } catch (error) {
+    console.error('Error removing configuration:', error);
+  }
+}

package/src/index.ts

@@ -0,0 +1,231 @@
+import { Plugin, PluginInput } from '@opencode-ai/plugin';
+import { getConfigs, addConfig, removeConfig, LiteLLMConfig } from './config';
+import { fetchModels, normalizeUrl, LiteLLMModel } from './client';
+import { createConnectTool } from './tools';
+
+// Provider-specific reasoning effort levels
+const REASONING_VARIANTS: Record<string, Record<string, any>> = {
+  openai: {
+    off:    { reasoningEffort: "off" },
+    low:    { reasoningEffort: "low" },
+    medium: { reasoningEffort: "medium" },
+    high:   { reasoningEffort: "high" },
+    xhigh:  { reasoningEffort: "xhigh" },
+  },
+  chatgpt: {
+    off:    { reasoningEffort: "off" },
+    low:    { reasoningEffort: "low" },
+    medium: { reasoningEffort: "medium" },
+    high:   { reasoningEffort: "high" },
+    xhigh:  { reasoningEffort: "xhigh" },
+  },
+  gemini: {
+    off:    { reasoningEffort: "off" },
+    low:    { reasoningEffort: "low" },
+    medium: { reasoningEffort: "medium" },
+    high:   { reasoningEffort: "high" },
+  },
+  anthropic: {
+    off:    { reasoningEffort: "off" },
+    low:    { reasoningEffort: "low" },
+    medium: { reasoningEffort: "medium" },
+    high:   { reasoningEffort: "high" },
+  },
+  deepseek: {
+    off:    { reasoningEffort: "off" },
+    low:    { reasoningEffort: "low" },
+    medium: { reasoningEffort: "medium" },
+    high:   { reasoningEffort: "high" },
+  },
+};
+
+const DEFAULT_REASONING_VARIANTS: Record<string, any> = {
+  low:    { reasoningEffort: "low" },
+  medium: { reasoningEffort: "medium" },
+  high:   { reasoningEffort: "high" },
+};
+
+function getReasoningVariants(m: LiteLLMModel): Record<string, any> {
+  if (m.litellmProvider && REASONING_VARIANTS[m.litellmProvider]) {
+    return REASONING_VARIANTS[m.litellmProvider];
+  }
+  return DEFAULT_REASONING_VARIANTS;
+}
+
+/**
+ * OpenCode LiteLLM provider plugin entry point.
+ */
+export const litellmPlugin: Plugin = async (_ctx: PluginInput) => {
+  console.log('[litellm] Plugin initializing...');
+
+  // Cache for fetched models to avoid redundant API calls
+  const modelCache = new Map<string, LiteLLMModel[]>();
+
+  return {
+    /**
+     * Config hook — dynamically registers providers and models from all
+     * configured LiteLLM servers.
+     */
+    config: async (config: any) => {
+      if (!config.provider) config.provider = {};
+
+      const serverConfigs = getConfigs();
+
+      for (const sc of serverConfigs) {
+        const providerID = `litellm-${sc.alias}`;
+        const baseUrl = normalizeUrl(sc.url);
+
+        // Fetch models if not cached
+        let models: LiteLLMModel[] = modelCache.get(sc.alias) || [];
+        if (models.length === 0) {
+          try {
+            console.log(`[litellm] Fetching models for ${sc.alias}...`);
+            models = await fetchModels(sc.url, sc.key);
+            modelCache.set(sc.alias, models);
+          } catch (error) {
+            console.error(`[litellm] Model fetch failed for ${sc.alias}:`, error);
+          }
+        }
+
+        config.provider[providerID] = {
+          id: providerID,
+          name: `LiteLLM (${sc.alias})`,
+          npm: "@ai-sdk/openai",
+          api: "openai",
+          options: {
+            baseURL: `${baseUrl}/v1`,
+            apiKey: sc.key,
+          },
+          models: {},
+        };
+
+        if (models.length > 0) {
+          for (const m of models) {
+            const modelConfig: any = {
+              id: m.id,
+              name: m.name || m.id,
+              limit: {
+                context: m.contextWindow,
+                output: m.maxOutputTokens,
+              },
+              capabilities: {
+                temperature: true,
+                reasoning: m.supportsReasoning,
+                attachment: m.supportsVision,
+                toolcall: m.supportsToolCalls,
+                input: {
+                  text: true,
+                  image: m.supportsVision,
+                  pdf: m.supportsVision,
+                },
+                output: { text: true },
+              },
+            };
+
+            if (m.supportsReasoning) {
+              modelConfig.variants = getReasoningVariants(m);
+            }
+
+            config.provider[providerID].models[m.id] = modelConfig;
+          }
+        } else {
+          config.provider[providerID].models["placeholder"] = {
+            id: "placeholder",
+            name: "No models found (check connection)",
+            limit: { context: 4096, output: 4096 },
+          };
+        }
+      }
+
+      console.log(`[litellm] Config hook completed. Registered ${serverConfigs.length} providers.`);
+    },
+
+    /**
+     * Auth hook — handles initial provider setup and credential verification.
+     * Management (list, remove) lives in the litellm:connect tool.
+     */
+    auth: {
+      provider: "litellm",
+      methods: [
+        {
+          type: "api" as const,
+          label: "Connect to LiteLLM",
+          prompts: [
+            {
+              type: "text" as const,
+              key: "alias",
+              message: "Alias for this server (e.g. 'work', 'staging')",
+              placeholder: "my-server",
+              validate(value: string) {
+                if (!value || value.trim().length === 0) return "Alias is required";
+                if (!/^[a-zA-Z0-9_-]+$/.test(value.trim()))
+                  return "Alias must be alphanumeric (hyphens and underscores allowed)";
+                return undefined;
+              },
+            },
+            {
+              type: "text" as const,
+              key: "url",
+              message: "LiteLLM base URL",
+              placeholder: "https://litellm.example.com",
+              validate(value: string) {
+                if (!value || value.trim().length === 0) return "URL is required";
+                try {
+                  new URL(value.trim());
+                } catch {
+                  return "Must be a valid URL (e.g. https://litellm.example.com)";
+                }
+                return undefined;
+              },
+            },
+            {
+              type: "text" as const,
+              key: "apiKey",
+              message: "API key",
+              placeholder: "sk-...",
+              validate(value: string) {
+                if (!value || value.trim().length === 0) return "API key is required";
+                return undefined;
+              },
+            },
+          ],
+          async authorize(inputs?: Record<string, string>) {
+            const alias = inputs?.alias?.trim();
+            const url = inputs?.url?.trim();
+            const apiKey = inputs?.apiKey?.trim();
+
+            if (!alias || !url || !apiKey) {
+              return { type: "failed" as const };
+            }
+
+            try {
+              console.log(`[litellm] Verifying connection for ${alias} at ${url}...`);
+              const models = await fetchModels(url, apiKey);
+              console.log(`[litellm] Verified ${alias}: ${models.length} models available.`);
+
+              // Persist to our config and cache
+              modelCache.set(alias, models);
+              addConfig({ alias, url, key: apiKey });
+
+              return {
+                type: "success" as const,
+                key: apiKey,
+                provider: `litellm-${alias}`,
+              };
+            } catch (error: any) {
+              console.error(`[litellm] Verification failed for ${alias}:`, error.message);
+              return { type: "failed" as const };
+            }
+          },
+        },
+      ],
+    },
+
+    /**
+     * Register management tools.
+     */
+    tool: {
+      'litellm_connect': createConnectTool(modelCache),
+    },
+  };
+};

package/src/tools.ts

@@ -0,0 +1,67 @@
+import { tool, ToolDefinition } from '@opencode-ai/plugin';
+import { fetchModels, LiteLLMModel } from './client';
+import { addConfig, getConfigs, removeConfig } from './config';
+
+const z = tool.schema;
+
+/**
+ * Creates the LiteLLM connection tool with access to the model cache.
+ */
+export const createConnectTool = (modelCache: Map<string, LiteLLMModel[]>): ToolDefinition => {
+  return tool({
+    description: 'Manage LiteLLM server connections',
+    args: {
+      action: z.enum(['add', 'list', 'remove']),
+      alias: z.string().optional(),
+      url: z.string().optional(),
+      key: z.string().optional(),
+    },
+    async execute(args) {
+      const action = args.action as string;
+      const alias = args.alias as string | undefined;
+      const url = args.url as string | undefined;
+      const key = args.key as string | undefined;
+
+      if (action === 'add') {
+        if (!alias || !url || !key) {
+          throw new Error('Missing required arguments for "add" action: alias, url, and key are required.');
+        }
+        
+        // Test the connection by fetching models.
+        const models = await fetchModels(url, key);
+        
+        // If successful, save the configuration.
+        addConfig({ alias, url, key });
+        
+        // Update the cache so the config hook can use it immediately.
+        modelCache.set(alias, models);
+        
+        return `Successfully connected to LiteLLM server "${alias}" with ${models.length} models available.`;
+      }
+
+      if (action === 'list') {
+        const configs = getConfigs();
+        
+        if (configs.length === 0) {
+          return 'No LiteLLM servers configured.';
+        }
+        
+        const list = configs.map((c) => `- ${c.alias}: ${c.url}`).join('\n');
+        return `Configured LiteLLM servers:\n${list}`;
+      }
+
+      if (action === 'remove') {
+        if (!alias) {
+          throw new Error('Missing required argument for "remove" action: alias is required.');
+        }
+        
+        removeConfig(alias);
+        modelCache.delete(alias); // Clear the cache for this alias.
+        
+        return `Successfully removed LiteLLM server "${alias}".`;
+      }
+
+      throw new Error(`Unsupported action: ${action}`);
+    },
+  });
+};