@danmademe/pi-provider-litellm 0.1.0

package/README.md

@@ -0,0 +1,110 @@
+# pi-provider-litellm
+
+> [!NOTE]
+> This extension requires [pi](https://github.com/earendil-works/pi) and a running [LiteLLM](https://github.com/BerriAI/litellm) proxy.
+
+Pi agent extension that auto-discovers and registers models, MCP tools, and skills from a LiteLLM proxy.
+
+## Features
+
+- **Model discovery** — queries `/health` and `/model/info` endpoints to discover available models, registers them under the `litellm` provider with cost, context window, and capability metadata
+- **MCP tools** — discovers tools from LiteLLM's MCP REST gateway (`/mcp-rest/tools/list`) and registers them as pi tools with JSON schema to TypeBox mapping
+- **Skills management** — `skill_list`, `skill_use`, `skill_register`, `skill_enable`, and `skill_disable` tools for managing LiteLLM skills
+- **Skills injection** — injects enabled skills as structured context into the agent's system prompt on session start, with 60-second caching
+
+All discovery runs in parallel with a 30s timeout. Each step fails gracefully — a failed model discovery won't block MCP tools or skills.
+
+## Installation
+
+```bash
+# From npm (once published)
+pi install npm:pi-provider-litellm
+
+# From local path
+pi install ~/Coding/Protector/AI/pi-provider-litellm
+```
+
+## Configuration
+
+Provide your LiteLLM proxy URL and API key via environment variables or settings.
+
+### Environment variables (recommended)
+
+```bash
+export LITELLM_URL="https://your-litellm-proxy.example.com"
+export LITELLM_KEY="sk-your-api-key"
+```
+
+Optional: override the provider name (defaults to `litellm`):
+
+```bash
+export LITELLM_PROVIDER_ID="my-proxy"
+```
+
+### Settings file
+
+Add to `~/.pi/agent/settings.json`:
+
+```json
+{
+  "pi-provider-litellm": {
+    "url": "https://your-litellm-proxy.example.com",
+    "token": "sk-your-api-key"
+  }
+}
+```
+
+Optional: override the provider name:
+
+```json
+{
+  "pi-provider-litellm": {
+    "url": "https://your-litellm-proxy.example.com",
+    "token": "sk-your-api-key",
+    "providerId": "my-proxy"
+  }
+}
+```
+
+Environment variables take precedence over the settings file.
+
+### Enabling models
+
+Models registered by this extension use the configured provider ID (default: `litellm`). To include them in your model cycling, add them to `enabledModels` in `settings.json`:
+
+```json
+{
+  "enabledModels": [
+    "litellm/qwen/qwen3.6-27b",
+    "litellm/anthropic/claude-sonnet"
+  ]
+}
+```
+
+> [!TIP]
+> The model ID in pi is `<providerId>/<model_name>`, where `<providerId>` defaults to `litellm` and `<model_name>` is the ID as reported by your LiteLLM proxy (e.g., `qwen/qwen3.6-27b`, `anthropic/claude-sonnet`).
+
+## Tools
+
+Once loaded, the extension registers the following tools:
+
+| Tool | Description |
+|------|-------------|
+| `skill_list` | List all available skills on the proxy |
+| `skill_use` | Fetch full content of a skill by name |
+| `skill_register` | Register a new skill from a git repository |
+| `skill_enable` | Enable a skill by name |
+| `skill_disable` | Disable a skill by name |
+| `mcp_<server>_<tool>` | Auto-discovered MCP tools from the proxy |
+
+## Development
+
+```bash
+npm install
+npm run typecheck
+npm run test:run
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@danmademe/pi-provider-litellm",
+  "version": "0.1.0",
+  "description": "Pi agent extension for LiteLLM proxy auto-discovery and model configuration",
+  "type": "module",
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "test:run": "vitest run"
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-agent",
+    "litellm",
+    "extension",
+    "auto-discovery"
+  ],
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "typebox": "*"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.9.0",
+    "vitest": "^4.0.0"
+  },
+  "author": "Daniel Cherubini",
+  "license": "MIT"
+}

package/src/index.ts

@@ -0,0 +1,90 @@
+import type { ExtensionAPI, BeforeAgentStartEvent, BeforeAgentStartEventResult } from '@earendil-works/pi-coding-agent'
+import { resolvePluginConfig, discoverModels, discoverMcpTools, listSkills, buildProviderConfig } from './litellm-api.js'
+import { createMcpToolDefinitions, createSkillToolDefinitions, createSkillsInjector } from './tools.js'
+import type { LiteLLMModelInfo, McpTool, PluginConfig } from './types.js'
+
+export default async function (pi: ExtensionAPI): Promise<void> {
+  const config = resolvePluginConfig()
+  if (!config) {
+    return
+  }
+
+  await discoverAndRegister(pi, config)
+
+  const injector = createSkillsInjector(config, config.apiKey)
+  const setupCompleteSessions = new Set<string>()
+  pi.on('before_agent_start', async (event: BeforeAgentStartEvent, ctx): Promise<BeforeAgentStartEventResult> => {
+    const sessionId = ctx.sessionManager.getSessionFile()
+    if (sessionId && setupCompleteSessions.has(sessionId)) return {}
+    if (sessionId) setupCompleteSessions.add(sessionId)
+
+    const summary = await injector.getSkillsSummary()
+    if (!summary) return {}
+    return { systemPrompt: event.systemPrompt + '\n\n' + summary }
+  })
+
+  pi.on('session_start', async (_event, _ctx) => {
+    setupCompleteSessions.clear()
+    injector.clearCache()
+    await discoverAndRegister(pi, config)
+  })
+
+  pi.on('session_shutdown', async (_event, _ctx) => {
+    injector.clearCache()
+  })
+}
+
+export async function discoverAndRegister(pi: ExtensionAPI, config: PluginConfig): Promise<void> {
+  try {
+    pi.unregisterProvider(config.providerId)
+  } catch {
+    // Provider not yet registered
+  }
+
+  const DISCOVERY_TIMEOUT_MS = 30_000
+
+  let modelsResult: PromiseSettledResult<Record<string, LiteLLMModelInfo>>
+  let mcpResult: PromiseSettledResult<McpTool[]>
+
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    setTimeout(() => reject(new Error('Discovery timeout')), DISCOVERY_TIMEOUT_MS)
+  })
+
+  try {
+    const results = await Promise.race([
+      Promise.allSettled([
+        discoverModels(config, config.apiKey),
+        discoverMcpTools(config, config.apiKey),
+        listSkills(config, config.apiKey),
+      ]),
+      timeoutPromise,
+    ])
+    const settledResults = results as [
+      PromiseSettledResult<Record<string, LiteLLMModelInfo>>,
+      PromiseSettledResult<McpTool[]>,
+      PromiseSettledResult<unknown>,
+    ]
+    modelsResult = settledResults[0]
+    mcpResult = settledResults[1]
+  } catch (error) {
+    modelsResult = { status: 'rejected', reason: error as Error }
+    mcpResult = { status: 'rejected', reason: error as Error }
+  }
+
+  if (modelsResult.status === 'fulfilled' && Object.keys(modelsResult.value).length > 0) {
+    const providerConfig = buildProviderConfig(config.url, config.apiKey, modelsResult.value)
+    pi.registerProvider(config.providerId, providerConfig)
+  }
+
+  if (mcpResult.status === 'fulfilled') {
+    const mcpTools = createMcpToolDefinitions(config, config.apiKey, mcpResult.value)
+    for (const tool of mcpTools) {
+      pi.registerTool(tool)
+    }
+  }
+
+  const skillTools = createSkillToolDefinitions(config, config.apiKey)
+  for (const tool of skillTools) {
+    pi.registerTool(tool)
+  }
+}

package/src/litellm-api.ts

@@ -0,0 +1,382 @@
+import os from 'node:os'
+import path from 'node:path'
+import fs from 'node:fs'
+import type {
+  LiteLLMHealthModel,
+  LiteLLMHealthResponse,
+  LiteLLMModelInfo,
+  McpTool,
+  Skill,
+  SkillPluginsResponse,
+  PluginConfig,
+  ProviderModelConfig,
+  ProviderConfig,
+} from './types.js'
+
+const DISCOVERY_TIMEOUT = 10_000
+const TOOL_EXEC_TIMEOUT = 30_000
+const SKILL_FETCH_TIMEOUT = 5_000
+
+async function fetchJson<T>(url: string, timeout: number, options?: RequestInit): Promise<T | null> {
+  try {
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), timeout)
+
+    const res = await fetch(url, {
+      ...options,
+      signal: controller.signal,
+    })
+
+    clearTimeout(timer)
+
+    if (!res.ok) return null
+    return (await res.json()) as T
+  } catch {
+    return null
+  }
+}
+
+async function fetchJsonWithStatus<T>(url: string, timeout: number, options?: RequestInit): Promise<{ data: T | null, status: number }> {
+  try {
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), timeout)
+
+    const res = await fetch(url, {
+      ...options,
+      signal: controller.signal,
+    })
+
+    clearTimeout(timer)
+
+    if (!res.ok) return { data: null, status: res.status }
+    return { data: (await res.json()) as T, status: res.status }
+  } catch {
+    return { data: null, status: 0 }
+  }
+}
+
+export async function discoverModels(config: PluginConfig, token: string): Promise<Record<string, LiteLLMModelInfo>> {
+  const { data: healthRes, status } = await fetchJsonWithStatus<LiteLLMHealthResponse>(
+    `${config.url}/health`,
+    DISCOVERY_TIMEOUT,
+    { headers: { 'Authorization': `Bearer ${token}` } }
+  )
+
+  if (status === 403) {
+    throw new Error('Access denied (403). Check your LiteLLM API key or contact your admin.')
+  }
+
+  if (!healthRes || !healthRes.healthy_endpoints?.length) return {}
+
+  const infoMap: Record<string, LiteLLMModelInfo> = {}
+
+  const results = await Promise.allSettled(
+    healthRes.healthy_endpoints.map(async (endpoint: LiteLLMHealthModel) => {
+      const raw = await fetchJson<unknown>(
+        `${config.url}/model/info?litellm_model_id=${encodeURIComponent(endpoint.model_id)}`,
+        DISCOVERY_TIMEOUT,
+        { headers: { 'Authorization': `Bearer ${token}` } }
+      )
+      return { endpoint, raw }
+    })
+  )
+
+  for (const result of results) {
+    if (result.status !== 'fulfilled') continue
+    const { raw } = result.value
+    if (!raw || typeof raw !== 'object') continue
+
+    // /model/info returns { data: [{ model_name, model_info, litellm_params }] }
+    const data = (raw as { data?: unknown[] }).data
+    if (!Array.isArray(data) || !data.length) continue
+    const entry = data[0] as Record<string, unknown>
+
+    const modelName = typeof entry.model_name === 'string' ? entry.model_name : null
+    if (!modelName) continue
+
+    const modelInfo = (entry.model_info ?? {}) as Record<string, unknown>
+    const litellmParams = (entry.litellm_params ?? {}) as Record<string, unknown>
+
+    // Merge model_info and litellm_params into a flat LiteLLMModelInfo
+    const merged: Record<string, unknown> = {
+      model_name: modelName,
+      ...modelInfo,
+      ...litellmParams,
+    }
+
+    // Normalize max_tokens if not set from model_info
+    if (!merged.max_input_tokens && merged.max_tokens) {
+      merged.max_input_tokens = merged.max_tokens
+    }
+    if (!merged.max_output_tokens && merged.max_tokens) {
+      merged.max_output_tokens = merged.max_tokens
+    }
+
+    infoMap[modelName] = merged as LiteLLMModelInfo
+  }
+
+  return infoMap
+}
+
+export async function discoverMcpTools(config: PluginConfig, token: string): Promise<McpTool[]> {
+  const res = await fetchJson<unknown>(
+    `${config.url}/mcp-rest/tools/list`,
+    DISCOVERY_TIMEOUT,
+    { headers: { 'Authorization': `Bearer ${token}` } }
+  )
+  if (!Array.isArray(res)) return []
+  return res as McpTool[]
+}
+
+export async function executeMcpTool(
+  config: PluginConfig,
+  token: string,
+  server: string,
+  toolName: string,
+  args: Record<string, unknown>
+): Promise<string> {
+  try {
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), TOOL_EXEC_TIMEOUT)
+
+    const res = await fetch(`${config.url}/mcp-rest/tools/call`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ server_name: server, tool_name: toolName, arguments: args }),
+      signal: controller.signal,
+    })
+
+    clearTimeout(timer)
+
+    if (!res.ok) {
+      return `Error: HTTP ${res.status} ${res.statusText}`
+    }
+
+    const data = await res.json()
+    return JSON.stringify(data)
+  } catch (err: unknown) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
+  }
+}
+
+export async function listSkills(config: PluginConfig, token: string): Promise<Skill[]> {
+  const res = await fetchJson<SkillPluginsResponse>(
+    `${config.url}/claude-code/plugins`,
+    DISCOVERY_TIMEOUT,
+    { headers: { 'Authorization': `Bearer ${token}` } }
+  )
+  return res?.plugins || []
+}
+
+export async function registerSkill(
+  config: PluginConfig,
+  token: string,
+  name: string,
+  gitUrl: string,
+  gitPath: string,
+  description?: string,
+  domain?: string
+): Promise<string> {
+  try {
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), DISCOVERY_TIMEOUT)
+
+    const res = await fetch(`${config.url}/claude-code/plugins`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        name,
+        git_url: gitUrl,
+        git_path: gitPath,
+        ...(description && { description }),
+        ...(domain && { domain }),
+      }),
+      signal: controller.signal,
+    })
+
+    clearTimeout(timer)
+
+    if (!res.ok) {
+      return `Error: HTTP ${res.status} ${res.statusText}`
+    }
+
+    const data = await res.json()
+    return JSON.stringify(data)
+  } catch (err: unknown) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
+  }
+}
+
+export async function enableSkill(config: PluginConfig, token: string, name: string): Promise<string> {
+  try {
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), DISCOVERY_TIMEOUT)
+
+    const res = await fetch(`${config.url}/claude-code/plugins/${encodeURIComponent(name)}/enable`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${token}`,
+      },
+      signal: controller.signal,
+    })
+
+    clearTimeout(timer)
+
+    if (!res.ok) {
+      return `Error: HTTP ${res.status} ${res.statusText}`
+    }
+
+    const data = await res.json()
+    return JSON.stringify(data)
+  } catch (err: unknown) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
+  }
+}
+
+export async function disableSkill(config: PluginConfig, token: string, name: string): Promise<string> {
+  try {
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), DISCOVERY_TIMEOUT)
+
+    const res = await fetch(`${config.url}/claude-code/plugins/${encodeURIComponent(name)}/disable`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${token}`,
+      },
+      signal: controller.signal,
+    })
+
+    clearTimeout(timer)
+
+    if (!res.ok) {
+      return `Error: HTTP ${res.status} ${res.statusText}`
+    }
+
+    const data = await res.json()
+    return JSON.stringify(data)
+  } catch (err: unknown) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
+  }
+}
+
+export async function fetchSkillContent(skill: Skill): Promise<string | null> {
+  const { source } = skill
+  const { url, path } = source
+
+  // Build GitHub raw URL from git URL
+  let rawUrl: string | null = null
+
+  if (url.includes('github.com')) {
+    const gitMatch = url.match(/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/)
+    if (gitMatch) {
+      const [, owner, repo] = gitMatch
+      const branch = 'main'
+      rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${branch}${path ? '/' + path : ''}/SKILL.md`
+    }
+  }
+
+  if (!rawUrl) return null
+
+  // 2 retries on 429/5xx with exponential backoff
+  for (let attempt = 0; attempt < 3; attempt++) {
+    if (attempt > 0) {
+      const backoff = Math.min(500 * 2 ** (attempt - 1), 1000)
+      await new Promise(r => setTimeout(r, backoff))
+    }
+    try {
+      const controller = new AbortController()
+      const timer = setTimeout(() => controller.abort(), SKILL_FETCH_TIMEOUT)
+
+      const res = await fetch(rawUrl, { signal: controller.signal })
+      clearTimeout(timer)
+
+      if (res.ok) {
+        return await res.text()
+      }
+
+      // Retry on 429 or 5xx
+      if ((res.status === 429 || res.status >= 500) && attempt < 2) {
+        continue
+      }
+      return null
+    } catch {
+      if (attempt < 2) continue
+      return null
+    }
+  }
+
+  return null
+}
+
+export function resolvePluginConfig(): PluginConfig | null {
+  // Check env vars first
+  const envUrl = process.env.LITELLM_URL
+  const envKey = process.env.LITELLM_KEY
+
+  if (envUrl && envKey) {
+    return { url: envUrl, apiKey: envKey, providerId: process.env.LITELLM_PROVIDER_ID ?? 'litellm' }
+  }
+
+  // Check settings.json
+  try {
+    const settingsPath = path.join(os.homedir(), '.pi', 'agent', 'settings.json')
+    const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8')) as Record<string, unknown>
+
+    const providerSettings = settings['pi-provider-litellm'] as Record<string, string> | undefined
+
+    if (providerSettings?.url && providerSettings?.token) {
+      return { url: providerSettings.url, apiKey: providerSettings.token, providerId: providerSettings.providerId ?? 'litellm' }
+    }
+  } catch {
+    // settings.json not found or invalid
+  }
+
+  return null
+}
+
+export function mapToProviderModel(info: LiteLLMModelInfo): ProviderModelConfig {
+  const input: ('text' | 'image')[] = ['text']
+  if (info.supports_vision) {
+    input.push('image')
+  }
+
+  return {
+    id: info.model_name ?? '',
+    name: info.model_name ?? '',
+    reasoning: info.supports_reasoning ?? false,
+    input,
+    cost: {
+      input: info.input_cost_per_token ? info.input_cost_per_token * 1_000_000 : 0,
+      output: info.output_cost_per_token ? info.output_cost_per_token * 1_000_000 : 0,
+      cacheRead: info.cache_read_input_token_cost ? info.cache_read_input_token_cost * 1_000_000 : 0,
+      cacheWrite: info.cache_creation_input_token_cost ? info.cache_creation_input_token_cost * 1_000_000 : 0,
+    },
+    contextWindow: info.max_input_tokens ?? info.max_tokens ?? 0,
+    maxTokens: info.max_output_tokens ?? info.max_tokens ?? 0,
+    compat: {
+      supportsDeveloperRole: false,
+      supportsReasoningEffort: false,
+    },
+  }
+}
+
+export function buildProviderConfig(
+  url: string,
+  apiKey: string,
+  models: Record<string, LiteLLMModelInfo>
+): ProviderConfig {
+  const mappedModels = Object.values(models).map(mapToProviderModel)
+
+  return {
+    baseUrl: url,
+    apiKey,
+    api: 'openai-completions',
+    models: mappedModels,
+  }
+}

package/src/tools.ts

@@ -0,0 +1,309 @@
+import { Type, type TSchema } from 'typebox'
+import type {
+  ToolDefinition,
+  AgentToolResult,
+  AgentToolUpdateCallback,
+  ExtensionContext,
+} from '@earendil-works/pi-coding-agent'
+import type { McpTool, PluginConfig, Skill } from './types.js'
+import {
+  executeMcpTool,
+  listSkills,
+  registerSkill,
+  enableSkill,
+  disableSkill,
+  fetchSkillContent,
+} from './litellm-api.js'
+
+export function sanitizeName(name: string): string {
+  return name.toLowerCase().replace(/[^a-z0-9]/g, '_')
+}
+
+function mapProperty(type: string, schema: Record<string, unknown>): TSchema | null {
+  if (schema.$ref != null) return null
+  if (schema.anyOf != null) return null
+  if (schema.oneOf != null) return null
+  if (schema.allOf != null) return null
+
+  // enum → Type.Union of literals
+  if (Array.isArray(schema.enum)) {
+    const valid = schema.enum.every((v) => typeof v === 'string' || typeof v === 'number')
+    if (!valid) return null
+    return Type.Union(schema.enum.map((v) => Type.Literal(v as string | number)))
+  }
+
+  // const → Type.Literal
+  if ('const' in schema && schema.const != null) {
+    const v = schema.const
+    if (typeof v !== 'string' && typeof v !== 'number') return null
+    return Type.Literal(v)
+  }
+
+  switch (type) {
+    case 'string': {
+      const opts: Record<string, unknown> = {}
+      if (typeof schema.minLength === 'number') opts.minLength = schema.minLength
+      if (typeof schema.maxLength === 'number') opts.maxLength = schema.maxLength
+      return Object.keys(opts).length ? Type.String(opts) : Type.String()
+    }
+    case 'number':
+    case 'integer': {
+      const opts: Record<string, unknown> = {}
+      if (typeof schema.minimum === 'number') opts.minimum = schema.minimum
+      if (typeof schema.maximum === 'number') opts.maximum = schema.maximum
+      return Object.keys(opts).length ? Type.Number(opts) : Type.Number()
+    }
+    case 'boolean':
+      return Type.Boolean()
+    case 'array': {
+      const items = schema.items as Record<string, unknown> | undefined
+      if (!items || typeof items !== 'object') return null
+      const itemType = items.type as string | undefined
+      if (itemType === 'string') return Type.Array(Type.String())
+      if (itemType === 'number' || itemType === 'integer') return Type.Array(Type.Number())
+      return null
+    }
+    default:
+      return null
+  }
+}
+
+export function buildTypeBoxSchema(inputSchema: Record<string, unknown>): TSchema | null {
+  const properties = inputSchema.properties as Record<string, unknown> | undefined
+  if (!properties || typeof properties !== 'object') return null
+
+  // Check for unsupported patterns at top level
+  if (inputSchema.$ref != null) return null
+  if (inputSchema.anyOf != null) return null
+  if (inputSchema.oneOf != null) return null
+  if (inputSchema.allOf != null) return null
+
+  const schemaProps: Record<string, TSchema> = {}
+  const required: string[] = []
+  const requiredList = inputSchema.required as string[] | undefined
+
+  for (const [key, val] of Object.entries(properties)) {
+    const prop = val as Record<string, unknown>
+    const propType = prop.type as string | undefined
+    if (!propType) return null
+
+    // Reject nested objects
+    if (propType === 'object') return null
+
+    // Check for nested $ref, anyOf, etc.
+    if (prop.$ref != null) return null
+    if (prop.anyOf != null) return null
+    if (prop.oneOf != null) return null
+    if (prop.allOf != null) return null
+
+    const mapped = mapProperty(propType, prop)
+    if (mapped === null) return null
+
+    schemaProps[key] = mapped
+    if (Array.isArray(requiredList) && requiredList.includes(key)) {
+      required.push(key)
+    }
+  }
+
+  if (required.length) {
+    return Type.Object(schemaProps, { required })
+  }
+
+  return Type.Object(schemaProps)
+}
+
+export function createMcpToolDefinitions(
+  config: PluginConfig,
+  token: string,
+  mcpTools: McpTool[],
+): ToolDefinition[] {
+  return mcpTools.map((tool) => {
+    const server = tool.server_name
+    const toolName = tool.name
+    const sanitizedName = `mcp_${sanitizeName(server)}_${sanitizeName(toolName)}`
+    const description = `${tool.description} (via ${server} MCP server)`
+    const parameters = buildTypeBoxSchema(tool.input_schema) ?? Type.Object({ args: Type.String() })
+
+    return {
+      name: sanitizedName,
+      label: sanitizedName,
+      description,
+      parameters,
+      async execute(
+        toolCallId: string,
+        params: Record<string, unknown>,
+        _signal: AbortSignal | undefined,
+        _onUpdate: AgentToolUpdateCallback<unknown> | undefined,
+        _ctx: ExtensionContext,
+      ): Promise<AgentToolResult<{ server: string; tool: string }>> {
+        // If using fallback args schema, parse it
+        const args = typeof params === 'object' && params !== null && 'args' in params
+          ? (typeof params.args === 'string' ? (() => { try { return JSON.parse(params.args) } catch { return params.args } })() : params.args)
+          : params
+
+        const result = await executeMcpTool(config, token, server, toolName, args as Record<string, unknown>)
+        return {
+          content: [{ type: 'text', text: result }],
+          details: { server, tool: toolName },
+        }
+      },
+    }
+  })
+}
+
+export function createSkillToolDefinitions(
+  config: PluginConfig,
+  token: string,
+): ToolDefinition[] {
+  return [
+    {
+      name: 'skill_list',
+      label: 'skill_list',
+      description: 'List all available skills',
+      parameters: Type.Object({}),
+      async execute(
+        _toolCallId: string,
+        _params: Record<string, unknown>,
+        _signal: AbortSignal | undefined,
+        _onUpdate: AgentToolUpdateCallback<unknown> | undefined,
+        _ctx: ExtensionContext,
+      ): Promise<AgentToolResult<undefined>> {
+        const skills = await listSkills(config, token)
+        if (!skills.length) {
+          return { content: [{ type: 'text', text: 'No skills found.' }], details: undefined }
+        }
+        const header = '| Name | Version | Enabled | Description |'
+        const sep = '|------|---------|---------|-------------|'
+        const rows = skills.map((s) =>
+          `| ${s.name} | ${s.version} | ${s.enabled ? 'yes' : 'no'} | ${s.description ?? '-'} |`,
+        )
+        return {
+          content: [{ type: 'text', text: [header, sep, ...rows].join('\n') }],
+          details: undefined,
+        }
+      },
+    },
+    {
+      name: 'skill_use',
+      label: 'skill_use',
+      description: 'Get the full content of a skill by name',
+      parameters: Type.Object({ name: Type.String() }),
+      async execute(
+        _toolCallId: string,
+        params: { name: string },
+        _signal: AbortSignal | undefined,
+        _onUpdate: AgentToolUpdateCallback<unknown> | undefined,
+        _ctx: ExtensionContext,
+      ): Promise<AgentToolResult<undefined>> {
+        const skills = await listSkills(config, token)
+        const skill = skills.find((s) => s.name === params.name)
+        if (!skill) {
+          return { content: [{ type: 'text', text: `Skill "${params.name}" not found.` }], details: undefined }
+        }
+        const content = await fetchSkillContent(skill)
+        const text = content
+          ? `<skill name="${skill.name}">\n${content}\n</skill>`
+          : `Skill "${skill.name}" found but content could not be fetched.`
+        return { content: [{ type: 'text', text }], details: undefined }
+      },
+    },
+    {
+      name: 'skill_register',
+      label: 'skill_register',
+      description: 'Register a new skill from a git repository',
+      parameters: Type.Object({
+        name: Type.String(),
+        git_url: Type.String(),
+        git_path: Type.String(),
+        description: Type.String(),
+        domain: Type.Optional(Type.String()),
+      }),
+      async execute(
+        _toolCallId: string,
+        params: { name: string; git_url: string; git_path: string; description: string; domain?: string },
+        _signal: AbortSignal | undefined,
+        _onUpdate: AgentToolUpdateCallback<unknown> | undefined,
+        _ctx: ExtensionContext,
+      ): Promise<AgentToolResult<undefined>> {
+        const result = await registerSkill(
+          config,
+          token,
+          params.name,
+          params.git_url,
+          params.git_path,
+          params.description,
+          params.domain,
+        )
+        return { content: [{ type: 'text', text: result }], details: undefined }
+      },
+    },
+    {
+      name: 'skill_enable',
+      label: 'skill_enable',
+      description: 'Enable a skill by name',
+      parameters: Type.Object({ name: Type.String() }),
+      async execute(
+        _toolCallId: string,
+        params: { name: string },
+        _signal: AbortSignal | undefined,
+        _onUpdate: AgentToolUpdateCallback<unknown> | undefined,
+        _ctx: ExtensionContext,
+      ): Promise<AgentToolResult<undefined>> {
+        const result = await enableSkill(config, token, params.name)
+        return { content: [{ type: 'text', text: result }], details: undefined }
+      },
+    },
+    {
+      name: 'skill_disable',
+      label: 'skill_disable',
+      description: 'Disable a skill by name',
+      parameters: Type.Object({ name: Type.String() }),
+      async execute(
+        _toolCallId: string,
+        params: { name: string },
+        _signal: AbortSignal | undefined,
+        _onUpdate: AgentToolUpdateCallback<unknown> | undefined,
+        _ctx: ExtensionContext,
+      ): Promise<AgentToolResult<undefined>> {
+        const result = await disableSkill(config, token, params.name)
+        return { content: [{ type: 'text', text: result }], details: undefined }
+      },
+    },
+  ]
+}
+
+export interface SkillsInjector {
+  getSkillsSummary(): Promise<string | null>
+  clearCache(): void
+}
+
+export function createSkillsInjector(
+  config: PluginConfig,
+  token: string,
+): SkillsInjector {
+  let cache: { skills: Skill[]; timestamp: number } | null = null
+  const TTL = 60_000 // 60 seconds
+
+  const getCachedSkills = async (): Promise<Skill[]> => {
+    const now = Date.now()
+    if (cache && now - cache.timestamp < TTL) {
+      return cache.skills
+    }
+    const skills = await listSkills(config, token)
+    cache = { skills, timestamp: now }
+    return skills
+  }
+
+  return {
+    async getSkillsSummary(): Promise<string | null> {
+      const skills = await getCachedSkills()
+      const enabled = skills.filter((s) => s.enabled)
+      if (!enabled.length) return null
+      const lines = enabled.map((s) => `- ${s.name}: ${s.description ?? '(no description)'}`)
+      return `<available-skills>\n${lines.join('\n')}\n</available-skills>`
+    },
+    clearCache(): void {
+      cache = null
+    },
+  }
+}

package/src/types.ts

@@ -0,0 +1,73 @@
+import type { ProviderModelConfig, ProviderConfig } from '@earendil-works/pi-coding-agent'
+
+export type { ProviderModelConfig, ProviderConfig }
+
+// LiteLLM /health endpoint response
+export interface LiteLLMHealthModel {
+  model: string
+  model_id: string
+}
+
+export interface LiteLLMHealthResponse {
+  healthy_endpoints?: LiteLLMHealthModel[]
+}
+
+// LiteLLM /model/info response
+export interface LiteLLMModelInfo {
+  model_name?: string
+  max_tokens?: number
+  max_input_tokens?: number
+  max_output_tokens?: number
+  supports_function_calling?: boolean
+  supports_reasoning?: boolean
+  supports_vision?: boolean
+  supports_audio_input?: boolean
+  supports_pdf_input?: boolean
+  input_cost_per_token?: number
+  output_cost_per_token?: number
+  cache_read_input_token_cost?: number
+  cache_creation_input_token_cost?: number
+}
+
+// MCP tool from /mcp-rest/tools/list
+export interface McpTool {
+  name: string
+  server_name: string
+  description: string
+  input_schema: Record<string, unknown>
+}
+
+// Skill types from /claude-code/plugins
+export interface SkillSource {
+  source: string
+  url: string
+  path?: string
+}
+
+export interface Skill {
+  id: string
+  name: string
+  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 SkillPluginsResponse {
+  plugins?: Skill[]
+}
+
+// Plugin config resolved from env or settings
+export interface PluginConfig {
+  url: string
+  apiKey: string
+  providerId: string
+}