opencode-dynamic-custom-providers 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 b3nw
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,132 @@
+# OpenCode Dynamic Custom Providers
+
+This plugin extends OpenCode with dynamic model discovery for OpenAI-compatible providers, enriched with metadata from [models.dev](https://models.dev).
+
+## Features
+
+### 1. Automatic Model Discovery at Startup
+The server plugin's `config` hook discovers models from any provider with a `baseURL` on every OpenCode startup. Models are always up-to-date without manual intervention.
+
+### 2. models.dev Metadata Enrichment
+Discovered models are cross-referenced against the [models.dev](https://models.dev) catalog (the same source OpenCode uses natively) to enrich them with accurate context windows, output limits, costs, capabilities (tool calling, reasoning, temperature), and input/output modalities.
+
+### 3. `/add-provider` Slash Command
+A TUI slash command for interactively adding new providers:
+- Prompts for Provider ID, Base URL, and API Key
+- Validates inputs and checks for duplicates
+- Discovers models to confirm the endpoint works before saving
+- Writes `dynamic: true` so models are re-discovered on each startup
+
+### 4. `/reload-models` Slash Command
+A TUI slash command (also available as `/refresh-models`) that re-discovers models from all providers with a `baseURL` without restarting OpenCode. Clears the models.dev cache and updates the live config in one step.
+
+### 5. `refresh-models` Agent Tool
+An in-session tool the agent can call to clear the models.dev metadata cache. Restart OpenCode after to re-discover all models with fresh metadata.
+
+## Installation
+
+```bash
+opencode plugin opencode-dynamic-custom-providers
+```
+
+### Alternative: Install from GitHub
+```bash
+opencode plugin git+ssh://git@github.com/b3nw/opencode-dynamic-custom-providers.git
+```
+
+### Alternative: Local Clone (for Development)
+```bash
+git clone https://github.com/b3nw/opencode-dynamic-custom-providers
+opencode plugin ./opencode-dynamic-custom-providers
+```
+
+## Configuration
+
+### Adding a Provider via TUI
+Run `/add-provider` in the OpenCode TUI and follow the prompts. The provider will be added with `dynamic: true` so models are discovered automatically on each startup.
+
+### Adding a Provider Manually
+Add a provider to `opencode.json` with a `baseURL`. Models will be discovered automatically:
+
+```json
+{
+  "provider": {
+    "my-proxy": {
+      "name": "My Proxy",
+      "options": {
+        "baseURL": "https://api.proxy.com/v1"
+      }
+    }
+  }
+}
+```
+
+For explicit opt-in, set `"dynamic": true`:
+
+```json
+{
+  "provider": {
+    "my-proxy": {
+      "name": "My Proxy",
+      "dynamic": true,
+      "options": {
+        "baseURL": "https://api.proxy.com/v1"
+      }
+    }
+  }
+}
+```
+
+### API Key Authentication
+
+API keys can be set in three ways:
+
+1. **Via the `/add-provider` TUI command** (stored securely via OpenCode's auth system)
+2. **In config** under `options.apiKey`:
+   ```json
+   {
+     "provider": {
+       "my-proxy": {
+         "options": {
+           "baseURL": "https://api.proxy.com/v1",
+           "apiKey": "sk-..."
+         }
+       }
+     }
+   }
+   ```
+3. **Via environment variable** using the pattern `OPENCODE_LOCAL_<PROVIDER_ID>_API_KEY`:
+   ```bash
+   export OPENCODE_LOCAL_MY_PROXY_API_KEY=sk-...
+   ```
+
+## How It Works
+
+1. On startup, the server plugin's `config` hook iterates all providers with a `baseURL`
+2. For each eligible provider (no models defined, or `dynamic: true`), it fetches `/v1/models`
+3. Each discovered model ID is cross-referenced against the models.dev catalog
+4. Matching models get enriched metadata (context window, costs, capabilities, modalities)
+5. Enriched models are injected into the live config before OpenCode loads providers
+6. The provider is set to use `@ai-sdk/openai-compatible` as the SDK package
+
+## Discovery Trigger
+
+A provider is eligible for discovery when it has `options.baseURL` and either:
+- Has `dynamic: true` set in config, **or**
+- Has no `models` key (or empty models) in config
+
+Providers that already have models defined in config are left unchanged unless `dynamic: true` is set.
+
+## Limitations
+- **Startup latency**: Each dynamic provider adds a network request at startup (15s timeout per endpoint, plus models.dev fetch on first run)
+- **models.dev coverage**: Models not in the models.dev catalog get sensible defaults (128k context window, 4096 output limit, text-only modalities)
+- **Capabilities detection**: Endpoint-reported capabilities (`supported_parameters`, `capabilities`) are merged with models.dev data; neither source alone is complete for all proxies
+
+## Development
+
+```bash
+git clone https://github.com/b3nw/opencode-dynamic-custom-providers
+cd opencode-dynamic-custom-providers
+npm install
+npm run build
+```

package/dist/discovery.d.ts

@@ -0,0 +1,51 @@
+export declare function normalizeModelId(id: string): string;
+export declare function clearModelsDevCache(): void;
+interface EndpointModelResponse {
+    id: string;
+    name?: string;
+    context_length?: number;
+    max_completion_tokens?: number;
+    max_output_tokens?: number;
+    max_model_len?: number;
+    context_window?: number;
+    input_cost?: number;
+    output_cost?: number;
+    capabilities?: {
+        tool_choice?: boolean;
+        function_calling?: boolean;
+        reasoning?: boolean;
+        vision?: boolean;
+        temperature?: boolean;
+        structured_output?: boolean;
+    };
+    supported_parameters?: string[];
+}
+export declare function fetchEndpointModels(baseURL: string, apiKey?: string): Promise<EndpointModelResponse[]>;
+export interface EnrichedModel {
+    name: string;
+    family?: string;
+    release_date?: string;
+    status?: string;
+    attachment?: boolean;
+    reasoning?: boolean;
+    temperature?: boolean;
+    tool_call?: boolean;
+    cost?: {
+        input: number;
+        output: number;
+        cache_read?: number;
+        cache_write?: number;
+    };
+    limit: {
+        context: number;
+        input?: number;
+        output: number;
+    };
+    modalities?: {
+        input: string[];
+        output: string[];
+    };
+}
+export type DisplayStyle = "name" | "slug";
+export declare function discoverAndEnrich(baseURL: string, apiKey?: string, displayStyle?: DisplayStyle): Promise<Record<string, EnrichedModel>>;
+export {};

package/dist/discovery.js

@@ -0,0 +1,240 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { createRequire } from "node:module";
+import { isValidUrl, sanitizeModelId } from "./security.js";
+const require = createRequire(import.meta.url);
+const { version: PKG_VERSION } = require("../package.json");
+const MODELS_DEV_URL = "https://models.dev/api.json";
+const CACHE_DIR = path.join(os.homedir() || "/tmp", ".cache", "opencode-dynamic-providers");
+const CACHE_FILE = path.join(CACHE_DIR, "models-dev.json");
+const CACHE_TTL = 6 * 60 * 60 * 1000; // 6 hours
+// ── models.dev cache + lookup ──
+// Module-level singleton: built once per process on first access, then shared
+// across all providers in a single startup cycle. Cleared by clearModelsDevCache()
+// (e.g. via the reload-models TUI command) so the next discoverAndEnrich call
+// rebuilds it with fresh data.
+let lookupMap = null;
+export function normalizeModelId(id) {
+    let normalized = id.toLowerCase();
+    if (normalized.startsWith("models/")) {
+        normalized = normalized.slice(7);
+    }
+    const slashIndex = normalized.lastIndexOf("/");
+    if (slashIndex !== -1) {
+        normalized = normalized.slice(slashIndex + 1);
+    }
+    return normalized.replaceAll(":", "-");
+}
+function readCacheEntry() {
+    try {
+        if (!fs.existsSync(CACHE_FILE))
+            return null;
+        const content = fs.readFileSync(CACHE_FILE, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(data) {
+    try {
+        if (!fs.existsSync(CACHE_DIR)) {
+            fs.mkdirSync(CACHE_DIR, { mode: 0o700, recursive: true });
+        }
+        fs.writeFileSync(CACHE_FILE, JSON.stringify({ timestamp: Date.now(), data }, null, 2), { mode: 0o600 });
+    }
+    catch {
+        // ignore write errors
+    }
+}
+async function fetchModelsDevCatalog() {
+    const entry = readCacheEntry();
+    const isFresh = entry && (Date.now() - entry.timestamp <= CACHE_TTL);
+    if (isFresh && entry)
+        return entry.data;
+    try {
+        const res = await fetch(MODELS_DEV_URL, {
+            headers: { "User-Agent": `opencode-dynamic-custom-providers/${PKG_VERSION}` },
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (res.ok) {
+            const data = await res.json();
+            writeCache(data);
+            return data;
+        }
+    }
+    catch {
+        // Ignore fetch error, fall back to stale cache if available
+    }
+    if (entry) {
+        return entry.data;
+    }
+    return {};
+}
+function buildLookupMap(catalog) {
+    const map = new Map();
+    for (const provider of Object.values(catalog)) {
+        if (!provider.models)
+            continue;
+        for (const model of Object.values(provider.models)) {
+            const key = normalizeModelId(model.id);
+            if (!map.has(key)) {
+                map.set(key, model);
+            }
+        }
+    }
+    return map;
+}
+async function getLookupMap() {
+    if (lookupMap)
+        return lookupMap;
+    const catalog = await fetchModelsDevCatalog();
+    lookupMap = buildLookupMap(catalog);
+    return lookupMap;
+}
+export function clearModelsDevCache() {
+    lookupMap = null;
+    try {
+        if (fs.existsSync(CACHE_FILE))
+            fs.unlinkSync(CACHE_FILE);
+    }
+    catch {
+        // ignore
+    }
+}
+// ── endpoint discovery ──
+export async function fetchEndpointModels(baseURL, apiKey) {
+    if (!isValidUrl(baseURL))
+        return [];
+    const url = new URL(baseURL);
+    const modelsPath = url.pathname.endsWith("/models")
+        ? url.pathname
+        : `${url.pathname.replace(/\/+$/, "")}/models`;
+    const modelsUrl = new URL(modelsPath, url.origin);
+    modelsUrl.search = url.search;
+    const headers = { "Content-Type": "application/json" };
+    if (apiKey) {
+        headers["Authorization"] = `Bearer ${apiKey}`;
+    }
+    const res = await fetch(modelsUrl.toString(), {
+        headers,
+        signal: AbortSignal.timeout(15_000),
+    });
+    if (!res.ok) {
+        throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+    }
+    const rawData = await res.json();
+    const data = Array.isArray(rawData)
+        ? rawData
+        : Array.isArray(rawData?.data)
+            ? rawData.data
+            : null;
+    if (!data) {
+        throw new Error("Unexpected response format from /v1/models");
+    }
+    return data.filter((item) => typeof item?.id === "string");
+}
+function parseEndpointCapabilities(item) {
+    let toolCall = false;
+    let reasoning = false;
+    let temperature = false;
+    if (item.capabilities) {
+        if (item.capabilities.function_calling || item.capabilities.tool_choice)
+            toolCall = true;
+        if (item.capabilities.reasoning)
+            reasoning = true;
+        if (item.capabilities.temperature)
+            temperature = true;
+    }
+    if (item.supported_parameters) {
+        if (item.supported_parameters.includes("tools") || item.supported_parameters.includes("tool_choice")) {
+            toolCall = true;
+        }
+        if (item.supported_parameters.includes("temperature")) {
+            temperature = true;
+        }
+    }
+    return { toolCall, reasoning, temperature };
+}
+function endpointContextWindow(item) {
+    const v = item.context_window ?? item.max_model_len ?? item.context_length;
+    return typeof v === "number" ? v : undefined;
+}
+function endpointMaxOutput(item) {
+    const v = item.max_completion_tokens ?? item.max_output_tokens;
+    return typeof v === "number" ? v : undefined;
+}
+export async function discoverAndEnrich(baseURL, apiKey, displayStyle = "slug") {
+    const rawModels = await fetchEndpointModels(baseURL, apiKey);
+    const lookup = await getLookupMap();
+    const result = {};
+    for (const item of rawModels) {
+        const id = sanitizeModelId(item.id);
+        const key = normalizeModelId(id);
+        const meta = lookup.get(key);
+        const caps = parseEndpointCapabilities(item);
+        const epContext = endpointContextWindow(item);
+        const epOutput = endpointMaxOutput(item);
+        const displayName = displayStyle === "slug"
+            ? id
+            : (item.name && item.name !== item.id ? item.name : undefined) ?? meta?.name ?? id;
+        const model = {
+            name: displayName,
+            limit: {
+                context: epContext ?? meta?.limit.context ?? 128_000,
+                input: meta?.limit.input,
+                output: epOutput ?? meta?.limit.output ?? 4096,
+            },
+            modalities: meta?.modalities ?? { input: ["text"], output: ["text"] },
+        };
+        // Capabilities: prefer models.dev when available, fall back to endpoint-detected
+        if (meta) {
+            model.reasoning = caps.reasoning || meta.reasoning;
+            model.temperature = caps.temperature || meta.temperature;
+            model.tool_call = caps.toolCall || meta.tool_call;
+            model.attachment = meta.attachment;
+            model.family = meta.family;
+            model.release_date = meta.release_date;
+            model.status = meta.status;
+            model.cost = {
+                input: meta.cost?.input ?? 0,
+                output: meta.cost?.output ?? 0,
+                cache_read: meta.cost?.cache_read,
+                cache_write: meta.cost?.cache_write,
+            };
+        }
+        else {
+            // No models.dev match — use whatever the endpoint told us, with safe defaults.
+            // tool_call defaults to false for unknown models to avoid sending tool calls
+            // to endpoints that don't support them.
+            if (caps.reasoning)
+                model.reasoning = true;
+            if (caps.temperature)
+                model.temperature = true;
+            if (caps.toolCall)
+                model.tool_call = true;
+            if (typeof item.input_cost === "number" || typeof item.output_cost === "number") {
+                model.cost = {
+                    input: typeof item.input_cost === "number" ? item.input_cost : 0,
+                    output: typeof item.output_cost === "number" ? item.output_cost : 0,
+                };
+            }
+        }
+        // Strip false/undefined booleans so OpenCode's fallback chain works cleanly
+        if (!model.reasoning)
+            delete model.reasoning;
+        if (!model.temperature)
+            delete model.temperature;
+        if (!model.attachment)
+            delete model.attachment;
+        if (model.family === undefined)
+            delete model.family;
+        if (model.release_date === undefined)
+            delete model.release_date;
+        if (model.status === undefined)
+            delete model.status;
+        result[id] = model;
+    }
+    return result;
+}

package/dist/security.d.ts

@@ -0,0 +1,3 @@
+export declare function isValidUrl(url: string): boolean;
+export declare function sanitizeModelId(id: string): string;
+export declare function sanitizeErrorMessage(error: unknown): string;

package/dist/security.js

@@ -0,0 +1,34 @@
+const VALID_PROTOCOLS = new Set(["http:", "https:"]);
+export function isValidUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return VALID_PROTOCOLS.has(parsed.protocol);
+    }
+    catch {
+        return false;
+    }
+}
+export function sanitizeModelId(id) {
+    return id.trim().replaceAll(/[^a-zA-Z0-9/_\-:.]/g, "_");
+}
+export function sanitizeErrorMessage(error) {
+    let message = error instanceof Error ? error.message : String(error);
+    // Strip query parameters from any URLs inside the error message
+    message = message.replaceAll(/https?:\/\/[^\s"'`<>]+/gi, (match) => {
+        try {
+            const url = new URL(match);
+            if (url.search) {
+                url.search = "";
+                return url.toString();
+            }
+            return match;
+        }
+        catch {
+            return match.split("?")[0];
+        }
+    });
+    return message
+        .replaceAll(/Bearer\s+[^\s]+/gi, "Bearer [REDACTED]")
+        .replaceAll(/api[_-]?key[=:]\s*[^\s&]+/gi, "api_key=[REDACTED]")
+        .replaceAll(/sk-[a-zA-Z0-9_-]+/g, "sk-[REDACTED]");
+}

package/dist/server.d.ts

@@ -0,0 +1,24 @@
+import type { Plugin } from "@opencode-ai/plugin";
+import { type DisplayStyle } from "./discovery.js";
+export declare const id = "opencode-dynamic-custom-providers";
+export interface ProviderConfig {
+    name?: string;
+    npm?: string;
+    api?: string;
+    dynamic?: boolean;
+    displayStyle?: DisplayStyle;
+    options?: {
+        baseURL?: string;
+        apiKey?: string;
+        [key: string]: unknown;
+    };
+    models?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export declare function getApiKey(provider: ProviderConfig, providerId: string): string | undefined;
+export declare const server: Plugin;
+declare const _default: {
+    id: string;
+    server: Plugin;
+};
+export default _default;

package/dist/server.js

@@ -0,0 +1,92 @@
+import { tool } from "@opencode-ai/plugin";
+import { discoverAndEnrich, clearModelsDevCache } from "./discovery.js";
+import { isValidUrl, sanitizeErrorMessage } from "./security.js";
+export const id = "opencode-dynamic-custom-providers";
+function shouldDiscover(provider) {
+    const baseURL = provider.options?.baseURL;
+    if (!baseURL || !isValidUrl(baseURL))
+        return false;
+    if (provider.dynamic === true)
+        return true;
+    const models = provider.models;
+    return !models || Object.keys(models).length === 0;
+}
+export function getApiKey(provider, providerId) {
+    if (provider.options?.apiKey)
+        return provider.options.apiKey;
+    const envKey = `OPENCODE_LOCAL_${providerId.toUpperCase().replaceAll(/[^A-Z0-9]/g, "_")}_API_KEY`;
+    return process.env[envKey];
+}
+export const server = async ({ client }) => {
+    await client.app.log({
+        body: {
+            level: "info",
+            message: "Plugin initialized",
+            service: id,
+        },
+    });
+    return {
+        config: async (cfg) => {
+            if (!cfg.provider)
+                return;
+            for (const [providerId, providerConfig] of Object.entries(cfg.provider)) {
+                if (!shouldDiscover(providerConfig))
+                    continue;
+                const baseURL = providerConfig.options.baseURL;
+                const apiKey = getApiKey(providerConfig, providerId);
+                try {
+                    await client.app.log({
+                        body: {
+                            level: "info",
+                            message: `Discovering models from ${providerId} at ${baseURL}`,
+                            service: id,
+                        },
+                    });
+                    const displayStyle = providerConfig.displayStyle ?? "slug";
+                    const models = await discoverAndEnrich(baseURL, apiKey, displayStyle);
+                    const count = Object.keys(models).length;
+                    if (count === 0) {
+                        await client.app.log({
+                            body: {
+                                level: "warn",
+                                message: `No models discovered from ${providerId}`,
+                                service: id,
+                            },
+                        });
+                        continue;
+                    }
+                    providerConfig.models = { ...(providerConfig.models ?? {}), ...models };
+                    providerConfig.npm = providerConfig.npm ?? "@ai-sdk/openai-compatible";
+                    providerConfig.api = providerConfig.api ?? baseURL;
+                    await client.app.log({
+                        body: {
+                            level: "info",
+                            message: `Discovered ${count} model(s) from ${providerId}`,
+                            service: id,
+                        },
+                    });
+                }
+                catch (error) {
+                    await client.app.log({
+                        body: {
+                            level: "warn",
+                            message: `Failed to discover models from ${providerId}: ${sanitizeErrorMessage(error)}`,
+                            service: id,
+                        },
+                    });
+                }
+            }
+        },
+        tool: {
+            "refresh-models": tool({
+                description: "Clear the models.dev metadata cache and trigger re-discovery on next restart",
+                args: {},
+                async execute() {
+                    clearModelsDevCache();
+                    return "Model metadata cache cleared. Restart OpenCode to re-discover models from all dynamic providers.";
+                },
+            }),
+        },
+    };
+};
+export default { id, server };

package/dist/tui.d.ts

@@ -0,0 +1,8 @@
+import type { TuiPlugin } from "@opencode-ai/plugin/tui";
+export declare const id = "opencode-dynamic-custom-providers";
+export declare const tui: TuiPlugin;
+declare const _default: {
+    id: string;
+    tui: TuiPlugin;
+};
+export default _default;

package/dist/tui.js

@@ -0,0 +1,197 @@
+import { discoverAndEnrich, clearModelsDevCache } from "./discovery.js";
+import { isValidUrl, sanitizeErrorMessage } from "./security.js";
+import { getApiKey } from "./server.js";
+export const id = "opencode-dynamic-custom-providers";
+function showPrompt(api, title, placeholder) {
+    return new Promise((resolve) => {
+        api.ui.dialog.replace(() => api.ui.DialogPrompt({
+            title,
+            placeholder,
+            onConfirm: (value) => resolve(value),
+            onCancel: () => resolve(null),
+        }), () => resolve(null));
+    });
+}
+function showConfirm(api, title, message) {
+    return new Promise((resolve) => {
+        api.ui.dialog.replace(() => api.ui.DialogConfirm({
+            title,
+            message,
+            onConfirm: () => resolve(true),
+            onCancel: () => resolve(false),
+        }), () => resolve(false));
+    });
+}
+function showSelect(api, title, options) {
+    return new Promise((resolve) => {
+        api.ui.dialog.replace(() => api.ui.DialogSelect({
+            title,
+            options: options.map((o) => ({
+                ...o,
+                onSelect: () => resolve(o.value),
+            })),
+        }), () => resolve(null));
+    });
+}
+export const tui = async (api) => {
+    api.command.register(() => [
+        {
+            title: "Reload Models",
+            value: "reload-models",
+            description: "Re-discover models from all dynamic providers without restarting",
+            slash: {
+                name: "reload-models",
+                aliases: ["refresh-models"],
+            },
+            onSelect: async () => {
+                const { data: config } = await api.client.config.get();
+                const providers = config?.provider ?? {};
+                const dynamicProviders = Object.entries(providers).filter(([, p]) => !!p.options?.baseURL && isValidUrl(p.options.baseURL));
+                if (dynamicProviders.length === 0) {
+                    api.ui.toast({ message: "No dynamic providers configured.", variant: "warning" });
+                    return;
+                }
+                api.ui.toast({ message: `Reloading models from ${dynamicProviders.length} provider(s)...`, variant: "info" });
+                clearModelsDevCache();
+                let totalModels = 0;
+                let failures = 0;
+                for (const [providerId, providerConfig] of dynamicProviders) {
+                    const baseURL = providerConfig.options.baseURL;
+                    const apiKey = getApiKey(providerConfig, providerId);
+                    const displayStyle = providerConfig.displayStyle ?? "slug";
+                    try {
+                        const models = await discoverAndEnrich(baseURL, apiKey, displayStyle);
+                        const count = Object.keys(models).length;
+                        if (count > 0) {
+                            providerConfig.models = { ...(providerConfig.models ?? {}), ...models };
+                            totalModels += count;
+                        }
+                        else if (providerConfig.models && Object.keys(providerConfig.models).length > 0) {
+                            api.ui.toast({
+                                message: `${providerId} returned 0 models (keeping previous models). Check endpoint status.`,
+                                variant: "warning",
+                            });
+                        }
+                    }
+                    catch (error) {
+                        failures++;
+                        api.ui.toast({
+                            message: `Failed to reload ${providerId}: ${sanitizeErrorMessage(error)}`,
+                            variant: "error",
+                        });
+                    }
+                }
+                if (totalModels > 0) {
+                    await api.client.config.update({ config: { provider: providers } });
+                }
+                if (failures === 0) {
+                    api.ui.toast({
+                        message: `Reloaded ${totalModels} model(s) from ${dynamicProviders.length} provider(s).`,
+                        variant: "success",
+                    });
+                }
+                else if (totalModels > 0) {
+                    api.ui.toast({
+                        message: `Reloaded ${totalModels} model(s) with ${failures} failure(s). Check provider URLs/keys.`,
+                        variant: "warning",
+                    });
+                }
+            },
+        },
+        {
+            title: "Add Provider",
+            value: "add-provider",
+            description: "Add a new OpenAI-compatible custom provider with dynamic model discovery",
+            slash: {
+                name: "add-provider",
+            },
+            onSelect: async () => {
+                const rawProviderId = await showPrompt(api, "Provider ID", "e.g., my-proxy (alphanumeric only)");
+                if (!rawProviderId)
+                    return;
+                const providerId = rawProviderId.trim();
+                if (!/^[a-zA-Z0-9_-]+$/.test(providerId)) {
+                    api.ui.toast({ message: "Invalid Provider ID. Use alphanumeric, hyphens, or underscores only.", variant: "error" });
+                    return;
+                }
+                const { data: config } = await api.client.config.get();
+                const providers = config?.provider ?? {};
+                if (providers[providerId]) {
+                    const overwrite = await showConfirm(api, "Provider already exists", `A provider with ID '${providerId}' already exists. Overwrite it?`);
+                    if (!overwrite)
+                        return;
+                }
+                const rawBaseURL = await showPrompt(api, "Base URL", "https://api.example.com/v1");
+                if (!rawBaseURL)
+                    return;
+                const baseURL = rawBaseURL.trim().replace(/\/+$/, "");
+                if (!isValidUrl(baseURL)) {
+                    api.ui.toast({ message: "Invalid Base URL. Please enter a full URL (including https://).", variant: "error" });
+                    return;
+                }
+                const rawApiKey = await showPrompt(api, "API Key (Optional)", "sk-...");
+                const apiKey = rawApiKey?.trim() || undefined;
+                const displayStyle = await showSelect(api, "Model Display Names", [
+                    {
+                        title: "Full Slug",
+                        value: "slug",
+                        description: "vertex/gemini-3.1-pro (best for proxies)",
+                    },
+                    {
+                        title: "Friendly Name",
+                        value: "name",
+                        description: "Gemini 3.1 Pro (may be ambiguous)",
+                    },
+                ]);
+                if (!displayStyle)
+                    return;
+                api.ui.toast({ message: `Discovering models from ${baseURL}...`, variant: "info" });
+                try {
+                    const models = await discoverAndEnrich(baseURL, apiKey, displayStyle);
+                    const modelCount = Object.keys(models).length;
+                    if (modelCount === 0) {
+                        api.ui.toast({ message: "No models found at the given endpoint. Provider not added.", variant: "warning" });
+                        return;
+                    }
+                    const providerEntry = {
+                        name: providerId,
+                        npm: "@ai-sdk/openai-compatible",
+                        api: baseURL,
+                        options: { baseURL },
+                        dynamic: true,
+                        displayStyle,
+                    };
+                    if (apiKey) {
+                        let storedInAuthStore = false;
+                        try {
+                            await api.client.auth.set({
+                                providerID: providerId,
+                                auth: { type: "api", key: apiKey },
+                            });
+                            storedInAuthStore = true;
+                        }
+                        catch {
+                            // Auth store unavailable — fall back to config file
+                        }
+                        if (!storedInAuthStore) {
+                            providerEntry.options.apiKey = apiKey;
+                        }
+                    }
+                    providers[providerId] = providerEntry;
+                    await api.client.config.update({ config: { provider: providers } });
+                    api.ui.toast({
+                        message: `Provider '${providerId}' added (${modelCount} models discovered). Restart opencode to use it.`,
+                        variant: "success",
+                    });
+                }
+                catch (error) {
+                    api.ui.toast({
+                        message: `Failed to discover models: ${sanitizeErrorMessage(error)}`,
+                        variant: "error",
+                    });
+                }
+            },
+        },
+    ]);
+};
+export default { id, tui };

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "opencode-dynamic-custom-providers",
+  "version": "2.0.0",
+  "description": "Dynamic model discovery for OpenAI-compatible providers in OpenCode with models.dev enrichment",
+  "type": "module",
+  "main": "./dist/server.js",
+  "types": "./dist/server.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/server.d.ts",
+      "default": "./dist/server.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "default": "./dist/server.js"
+    },
+    "./tui": {
+      "types": "./dist/tui.d.ts",
+      "default": "./dist/tui.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "npm run build && node tests/security.test.mjs && node tests/discovery.test.mjs",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm test"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "ai",
+    "openai",
+    "dynamic",
+    "discovery",
+    "models.dev"
+  ],
+  "author": "b3nw",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/b3nw/opencode-dynamic-custom-providers.git"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.14.0"
+  },
+  "devDependencies": {
+    "@opencode-ai/sdk": "^1.14.0",
+    "@opentui/solid": "^0.2.0",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": "^1.14.0"
+  },
+  "engines": {
+    "opencode": ">=1.14.0"
+  }
+}