opencode-koji 0.1.0

package/README.md

@@ -0,0 +1,68 @@
+# OpenCode Koji Plugin
+
+Auto-discovers models from [Koji](https://github.com/danielcherubini/koji) local AI server and provides OpenCode with model configuration.
+
+## Features
+
+- **Auto-detection**: Finds koji running on default ports (11434, 8080)
+- **Model Discovery**: Queries `/koji/v1/opencode/models` for rich model metadata
+- **Configuration Enhancement**: Adds model metadata (context limits, name, etc.)
+- **Graceful Fallback**: Works even if koji is offline
+
+## Installation
+
+Add to your `opencode.json`:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["opencode-koji"]
+}
+```
+
+Or install via npm:
+
+```bash
+npm install opencode-koji
+```
+
+## Usage
+
+Simply install the plugin - it will auto-detect koji and discover models.
+
+### Manual Configuration
+
+If you want to use a custom koji instance:
+
+```json
+{
+  "provider": {
+    "koji": {
+      "npm": "@ai-sdk/openai-compatible",
+      "name": "Koji (local)",
+      "options": {
+        "baseURL": "http://localhost:11434/v1"
+      }
+    }
+  }
+}
+```
+
+The plugin will still enhance this with auto-discovered models, merging with any manually configured ones.
+
+## How It Works
+
+1. On opencode startup, the `config` hook is called
+2. Plugin checks for existing `koji` provider or auto-detects on default ports
+3. Queries `GET /koji/v1/opencode/models` from koji
+4. Merges discovered models into opencode's configuration
+5. Models appear in `/models` list automatically
+
+## Requirements
+
+- Koji running with `koji serve`
+- OpenCode with plugin support
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "opencode-koji",
+  "version": "0.1.0",
+  "description": "OpenCode plugin for koji local AI server auto-discovery and model configuration",
+  "type": "module",
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix"
+  },
+  "keywords": [
+    "opencode",
+    "koji",
+    "plugin",
+    "local-llm",
+    "openai-compatible"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.0.166"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@vitest/coverage-v8": "^4.0.0",
+    "typescript": "^5.9.0",
+    "vitest": "^4.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { KojiPlugin } from './plugin'

package/src/plugin/config-hook.ts

@@ -0,0 +1,97 @@
+import type { PluginInput } from '@opencode-ai/plugin'
+import { normalizeBaseURL, checkKojiHealth, discoverKojiModels, autoDetectKoji, formatModelName, parseModelCapabilities } from '../utils/koji-api'
+
+const DEFAULT_KOJI_URL = "http://127.0.0.1:11434"
+
+interface ToastNotifier {
+  info(message: string): Promise<void>
+  warning(message: string): Promise<void>
+  error(message: string): Promise<void>
+}
+
+function createToastNotifier(client: PluginInput['client']): ToastNotifier {
+  return {
+    async info(_message: string) {
+      // Stub - can be enhanced later with actual toasts
+    },
+    async warning(_message: string) {
+    },
+    async error(_message: string) {
+    },
+  }
+}
+
+export function createConfigHook(client: PluginInput['client']) {
+  const toastNotifier = createToastNotifier(client)
+
+  return async (config: any) => {
+    if (!config || typeof config !== 'object') {
+      return
+    }
+
+    let kojiProvider = config.provider?.koji
+    let baseURL: string
+
+    if (kojiProvider?.options?.baseURL) {
+      baseURL = normalizeBaseURL(kojiProvider.options.baseURL)
+    } else {
+      const detectedURL = await autoDetectKoji()
+      if (!detectedURL) {
+        console.log('[opencode-koji] Koji not detected on default ports (11434, 8080)')
+        return
+      }
+      baseURL = detectedURL
+
+      if (!config.provider) {
+        config.provider = {}
+      }
+
+      config.provider.koji = {
+        npm: "@ai-sdk/openai-compatible",
+        name: "Koji (local)",
+        options: {
+          baseURL: `${baseURL}/v1`,
+        },
+        models: {},
+      }
+      kojiProvider = config.provider.koji
+    }
+
+    const isHealthy = await checkKojiHealth(baseURL)
+    if (!isHealthy) {
+      console.warn(`[opencode-koji] Koji appears offline at ${baseURL}`)
+      return
+    }
+
+    const models = await discoverKojiModels(baseURL)
+    if (models.length === 0) {
+      console.warn('[opencode-koji] No models discovered - ensure koji serve is running')
+      return
+    }
+
+    const existingModels = kojiProvider.models || {}
+    const discoveredModels: Record<string, any> = {}
+
+    for (const model of models) {
+      // model.id is already the API id (lowercased HF name), no sanitization needed
+      const modelKey = model.id
+
+      if (!existingModels[modelKey] && !existingModels[model.id]) {
+        const modelConfig = parseModelCapabilities(model)
+        modelConfig.name = model.name || modelKey
+
+        discoveredModels[modelKey] = modelConfig
+      }
+    }
+
+    if (Object.keys(discoveredModels).length > 0) {
+      config.provider.koji.models = {
+        ...existingModels,
+        ...discoveredModels,
+      }
+      console.log(`[opencode-koji] Discovered ${Object.keys(discoveredModels).length} models`)
+    }
+
+    await toastNotifier.info(`Loaded ${models.length} models from koji`)
+  }
+}

package/src/plugin/index.ts

@@ -0,0 +1,19 @@
+import type { Plugin, PluginInput } from '@opencode-ai/plugin'
+import { createConfigHook } from './config-hook'
+
+export const KojiPlugin: Plugin = async (input: PluginInput) => {
+  console.log('[opencode-koji] Koji plugin initializing')
+
+  const { client } = input
+
+  if (!client || typeof client !== 'object') {
+    console.error('[opencode-koji] Invalid client provided to plugin')
+    return {
+      config: async () => {},
+    }
+  }
+
+  return {
+    config: createConfigHook(client),
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,40 @@
+export interface KojiModel {
+  id: string
+  name: string
+  model?: string
+  backend?: string
+  context_length?: number
+  limit?: {
+    context: number
+    output: number
+  }
+  modalities?: {
+    input: string[]
+    output: string[]
+  }
+  quant?: string
+  gpu_layers?: number
+}
+
+export interface KojiModelsResponse {
+  models: KojiModel[]
+}
+
+export interface KojiProviderConfig {
+  npm?: string
+  name?: string
+  options?: {
+    baseURL?: string
+    apiKey?: string
+  }
+  models?: Record<string, any>
+}
+
+export interface DiscoveredModel {
+  id: string
+  key: string
+  name: string
+  config: Record<string, any>
+}
+
+export type LoadingStatus = 'not_loaded' | 'loading' | 'loaded' | 'error'

package/src/utils/koji-api.ts

@@ -0,0 +1,98 @@
+import type { KojiModel, KojiModelsResponse } from '../types'
+
+const DEFAULT_KOJI_URL = "http://localhost:11434"
+const KOJI_OPENCODE_MODELS_ENDPOINT = "/koji/v1/opencode/models"
+const KOJI_V1_MODELS_ENDPOINT = "/v1/models"
+
+export function normalizeBaseURL(baseURL: string = DEFAULT_KOJI_URL): string {
+  let normalized = baseURL.replace(/\/+$/, '')
+  if (normalized.endsWith('/v1')) {
+    normalized = normalized.slice(0, -3)
+  }
+  return normalized
+}
+
+export function buildAPIURL(baseURL: string, endpoint: string = KOJI_OPENCODE_MODELS_ENDPOINT): string {
+  const normalized = normalizeBaseURL(baseURL)
+  return `${normalized}${endpoint}`
+}
+
+export async function checkKojiHealth(baseURL: string = DEFAULT_KOJI_URL): Promise<boolean> {
+  try {
+    const url = buildAPIURL(baseURL, KOJI_OPENCODE_MODELS_ENDPOINT)
+    const response = await fetch(url, {
+      method: "GET",
+      signal: AbortSignal.timeout(3000),
+    })
+    return response.ok
+  } catch {
+    return false
+  }
+}
+
+export async function discoverKojiModels(baseURL: string = DEFAULT_KOJI_URL): Promise<KojiModel[]> {
+  try {
+    const url = buildAPIURL(baseURL, KOJI_OPENCODE_MODELS_ENDPOINT)
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      signal: AbortSignal.timeout(5000),
+    })
+
+    if (!response.ok) {
+      console.warn(`[opencode-koji] Koji returned ${response.status}: ${response.statusText}`)
+      return []
+    }
+
+    const data = (await response.json()) as { models: KojiModel[] }
+    return data.models ?? []
+  } catch (error) {
+    console.warn(`[opencode-koji] Failed to discover models: ${error instanceof Error ? error.message : String(error)}`)
+    return []
+  }
+}
+
+export async function autoDetectKoji(): Promise<string | null> {
+  const ports = [11434, 8080]
+  for (const port of ports) {
+    const baseURL = `http://127.0.0.1:${port}`
+    const isHealthy = await checkKojiHealth(baseURL)
+    if (isHealthy) {
+      console.log(`[opencode-koji] Auto-detected koji at ${baseURL}`)
+      return baseURL
+    }
+  }
+  return null
+}
+
+export function formatModelName(model: KojiModel): string {
+  if (model.name && model.name !== model.id) {
+    return model.name
+  }
+  const parts = model.id.split('/')
+  const modelName = parts[parts.length - 1] ?? model.id
+  return modelName.replace(/[-_]/g, ' ').replace(/\s+/g, ' ').trim()
+}
+
+export function parseModelCapabilities(model: KojiModel): Record<string, any> {
+  const config: Record<string, any> = {
+    id: model.id,
+  }
+
+  if (model.limit) {
+    config.limit = model.limit
+  } else if (model.context_length) {
+    config.limit = {
+      context: model.context_length,
+      output: model.context_length,
+    }
+  }
+
+  if (model.modalities) {
+    config.modalities = model.modalities
+  }
+
+  return config
+}