@heventure/model-provider-x 0.2.3 → 0.2.5-beta.0

package/README.md

@@ -135,6 +135,51 @@ node dist/cli/index.js setup --target codex --provider lmstudio --proxy
 node dist/cli/index.js setup --target opencode --provider lmstudio --direct
 ```
 
+## Model Metadata Registry
+
+Some OpenAI-compatible providers only return minimal `/v1/models` entries with `id`, `object`, and `owned_by`.
+For those providers, `model-provider-x` can enrich model capabilities from registries.
+
+The merge order is:
+
+1. User overrides such as `--modalities`.
+2. Provider or native runtime metadata.
+3. Project-local registry overrides.
+4. Built-in models.dev-shaped metadata.
+5. Conservative model-name heuristics.
+
+By default, the CLI reads `model-provider-x.models.jsonc` from the current working directory when it exists.
+You can also pass one or more registry files explicitly:
+
+```bash
+node dist/cli/index.js setup \
+  --provider custom \
+  --model-registry ./model-provider-x.models.jsonc
+```
+
+Example registry:
+
+```jsonc
+{
+  "providers": {
+    "mimo-pool": {
+      "models": {
+        "mimo-v2.5-tts": {
+          "type": "tts",
+          "modalities": {
+            "input": ["text"],
+            "output": ["audio"]
+          },
+          "limit": {
+            "context": 8192
+          }
+        }
+      }
+    }
+  }
+}
+```
+
 ## Commands
 
 ```bash

package/dist/cli/args.js

@@ -29,6 +29,18 @@ export function parseCliArgs(argv) {
                     .map((model) => model.trim())
                     .filter(Boolean);
                 break;
+            case "--model-registry":
+                if (!options.modelRegistryPaths) {
+                    options.modelRegistryPaths = [];
+                }
+                options.modelRegistryPaths.push(next());
+                break;
+            case "--modalities":
+                if (!options.modalities) {
+                    options.modalities = [];
+                }
+                options.modalities.push(parseModalitiesArg(next()));
+                break;
             case "--name":
                 options.providerName = next();
                 break;
@@ -107,6 +119,10 @@ Options:
   --proxy              Write agent config through the local compatibility proxy.
   --direct             Write agent config directly to the upstream provider.
   --models <list>      Comma-separated model ids. Skips interactive model selection.
+  --model-registry <path>
+                       JSONC model metadata override. Can be repeated.
+  --modalities <spec>  Model modalities in format <model>:<input>:<output>.
+                       Example: --modalities qwen-vl:image,text:text
   --config <path>      OpenCode config path to write when targeting OpenCode.
   --print              Print generated JSON and do not write config.
   --yes, -y            Accept defaults in non-interactive prompts.
@@ -134,3 +150,29 @@ function addModelByOneBasedIndex(selected, models, index) {
     }
     selected.add(model);
 }
+function parseModalitiesArg(value) {
+    const parts = value.split(":");
+    if (parts.length !== 3) {
+        throw new Error(`Invalid --modalities format: ${value}. Expected <model>:<input>:<output>`);
+    }
+    const [modelId, inputStr, outputStr] = parts;
+    if (!modelId) {
+        throw new Error("Model id is required in --modalities");
+    }
+    const parseModalityList = (s) => {
+        return s.split(",").map((m) => {
+            const trimmed = m.trim().toLowerCase();
+            if (["text", "image", "audio", "video", "pdf"].includes(trimmed)) {
+                return trimmed;
+            }
+            throw new Error(`Unknown modality: ${trimmed}`);
+        });
+    };
+    return {
+        modelId,
+        modalities: {
+            input: parseModalityList(inputStr),
+            output: parseModalityList(outputStr),
+        },
+    };
+}

package/dist/cli/index.js

@@ -1,11 +1,14 @@
 #!/usr/bin/env node
 import { createInterface } from "node:readline/promises";
+import { existsSync } from "node:fs";
 import { stdin as input, stdout as output } from "node:process";
 import { fileURLToPath } from "node:url";
 import { readProxyStatus, startProxyProcess, stopProxyProcess } from "../core/proxy-process.js";
 import { createProxyAuthToken, getDefaultToolConfigPath, readToolConfig, upsertProviderProfile, writeToolConfig } from "../core/tool-config.js";
 import { discoverOpenCodeConfigs, getDefaultConfigPath, writeProviderToConfig } from "../core/config.js";
 import { buildProviderConfig, detectProviderCapabilities, recommendProxyMode, validateAndFetchModels } from "../core/provider.js";
+import { DEFAULT_MODEL_REGISTRY_FILE } from "../core/model-registry.js";
+import { isKnownModel } from "../core/model-capabilities.js";
 import { startProxyServer } from "../proxy/server.js";
 import { defaultClaudeModelMapping, getDefaultClaudeSettingsPath, writeClaudeCodeSettings } from "../targets/claude-code.js";
 import { getDefaultCodexConfigPath, writeCodexConfig } from "../targets/codex.js";
@@ -71,17 +74,24 @@ export async function runCli(options) {
         const baseURL = await requiredOption(rl, options.baseURL ?? providerDefaults.baseURL, "API base URL");
         const apiKey = await resolveApiKey(rl, options.apiKey, providerDefaults.preset);
         output.write("Fetching models...\n");
-        const fetched = await validateAndFetchModels({ baseURL, apiKey });
+        const fetched = await validateAndFetchModels({
+            baseURL,
+            apiKey,
+            providerId,
+            modelRegistryPaths: resolveModelRegistryPaths(options)
+        });
         const selectedModels = options.models ??
             (canUseTui()
-                ? await multiSelectChoices("Select models", createModelChoices(fetched.models))
+                ? await multiSelectChoices("Select models", createModelChoices(fetched.modelDetails))
                 : parseModelSelection(await rl.question(formatModelPrompt(fetched.models)), fetched.models));
+        const modelDetails = applyModelModalityOverrides(fetched.modelDetails.filter((m) => selectedModels.includes(m.id)), options);
         const fragment = buildProviderConfig({
             providerId,
             providerName,
             baseURL: fetched.baseURL,
             apiKey,
             models: selectedModels,
+            modelDetails,
             opencodeApiType: options.opencodeApiType ?? "chat"
         });
         const provider = fragment.provider[providerId];
@@ -142,15 +152,21 @@ async function collectProviderInput(rl, command) {
 }
 async function collectProviderSelection(rl, command, providerInput) {
     output.write("Fetching models...\n");
-    const fetched = await validateAndFetchModels({ baseURL: providerInput.baseURL, apiKey: providerInput.apiKey });
+    const fetched = await validateAndFetchModels({
+        baseURL: providerInput.baseURL,
+        apiKey: providerInput.apiKey,
+        providerId: providerInput.providerId,
+        modelRegistryPaths: resolveModelRegistryPaths(command.options)
+    });
     const selectedModels = command.options.models ??
         (canUseTui()
-            ? await multiSelectChoices("Select models", createModelChoices(fetched.models))
+            ? await multiSelectChoices("Select models", createModelChoices(fetched.modelDetails))
             : parseModelSelection(await rl.question(formatModelPrompt(fetched.models)), fetched.models));
     const defaultModel = await resolveDefaultModel(rl, command, selectedModels);
     if (!defaultModel) {
         throw new Error("Select at least one model");
     }
+    const modelDetails = await resolveModelModalities(rl, command, selectedModels, fetched.modelDetails);
     const toolConfigPath = getDefaultToolConfigPath();
     const config = await upsertProviderProfile(toolConfigPath, {
         id: providerInput.providerId,
@@ -168,6 +184,7 @@ async function collectProviderSelection(rl, command, providerInput) {
         upstreamBaseURL: fetched.baseURL,
         apiKey: providerInput.apiKey,
         selectedModels,
+        modelDetails,
         defaultModel,
         config,
         toolConfigPath
@@ -186,6 +203,7 @@ async function writeOpenCodeSetup(rl, command, selection, useProxy, capabilities
         baseURL,
         apiKey,
         models: selection.selectedModels,
+        modelDetails: selection.modelDetails,
         opencodeApiType
     });
     const provider = fragment.provider[selection.providerId];
@@ -366,6 +384,30 @@ function tokenHint(token) {
     }
     return `${token.slice(0, 8)}...${token.slice(-4)}`;
 }
+function resolveModelRegistryPaths(options) {
+    const paths = [...(options.modelRegistryPaths ?? [])];
+    if (existsSync(DEFAULT_MODEL_REGISTRY_FILE) && !paths.includes(DEFAULT_MODEL_REGISTRY_FILE)) {
+        paths.push(DEFAULT_MODEL_REGISTRY_FILE);
+    }
+    return paths;
+}
+function applyModelModalityOverrides(modelDetails, options) {
+    if (!options.modalities?.length) {
+        return modelDetails;
+    }
+    const overrides = new Map(options.modalities.map((override) => [override.modelId, override.modalities]));
+    return modelDetails.map((model) => {
+        const modalities = overrides.get(model.id);
+        if (!modalities) {
+            return model;
+        }
+        return {
+            ...model,
+            modalities,
+            metadataSources: [...new Set([...(model.metadataSources ?? []), "user"])]
+        };
+    });
+}
 async function requiredOption(rl, value, label) {
     const answer = value ?? (await rl.question(`${label}: `));
     if (!answer.trim()) {
@@ -634,4 +676,73 @@ function slugify(value) {
         .replace(/[^a-z0-9]+/g, "-")
         .replace(/^-+|-+$/g, "");
 }
+async function resolveModelModalities(rl, command, selectedModels, fetchedModelDetails) {
+    const userModalityOverrides = new Map();
+    if (command.options.modalities) {
+        for (const override of command.options.modalities) {
+            userModalityOverrides.set(override.modelId, override.modalities);
+        }
+    }
+    const result = [];
+    for (const modelId of selectedModels) {
+        const fetched = fetchedModelDetails.find((m) => m.id === modelId);
+        const userOverride = userModalityOverrides.get(modelId);
+        if (userOverride) {
+            result.push({ id: modelId, modalities: userOverride });
+            continue;
+        }
+        if (fetched?.modalities) {
+            result.push(fetched);
+            continue;
+        }
+        if (command.options.yes || isKnownModel(modelId)) {
+            result.push(fetched ?? { id: modelId });
+            continue;
+        }
+        const modalities = await promptModelModalities(rl, modelId);
+        result.push({ id: modelId, modalities });
+    }
+    return result;
+}
+async function promptModelModalities(rl, modelId) {
+    output.write(`\nModel: ${modelId} - Capabilities unknown\n`);
+    if (canUseTui()) {
+        const inputModalities = await multiSelectChoices(`Input modalities: ${modelId}`, [
+            { label: "text", value: "text", hint: "default" },
+            { label: "image", value: "image" },
+            { label: "audio", value: "audio" },
+            { label: "video", value: "video" },
+            { label: "pdf", value: "pdf" },
+        ]);
+        const outputModalities = await multiSelectChoices(`Output modalities: ${modelId}`, [
+            { label: "text", value: "text", hint: "default" },
+            { label: "image", value: "image" },
+            { label: "audio", value: "audio" },
+            { label: "video", value: "video" },
+            { label: "pdf", value: "pdf" },
+        ]);
+        return {
+            input: inputModalities,
+            output: outputModalities,
+        };
+    }
+    const inputAnswer = await rl.question("Input modalities [text]: ");
+    const outputAnswer = await rl.question("Output modalities [text]: ");
+    const parseModalityList = (answer) => {
+        if (!answer.trim()) {
+            return ["text"];
+        }
+        return answer.split(",").map((m) => {
+            const trimmed = m.trim().toLowerCase();
+            if (["text", "image", "audio", "video", "pdf"].includes(trimmed)) {
+                return trimmed;
+            }
+            throw new Error(`Unknown modality: ${trimmed}`);
+        });
+    };
+    return {
+        input: parseModalityList(inputAnswer),
+        output: parseModalityList(outputAnswer),
+    };
+}
 void main();

package/dist/cli/model-choices.js

@@ -1,17 +1,49 @@
 const likelyUnsupportedModelName = /\b(?:embed|embedding|embeddings|bge|e5|nomic-embed)\b/i;
 export function createModelChoices(models) {
     return models.map((model) => {
-        if (!isLikelyUnsupportedModelName(model)) {
-            return { label: model, value: model, selected: true };
+        const info = typeof model === "string" ? { id: model } : model;
+        const unsupported = isLikelyUnsupportedModel(info);
+        const hint = modelHint(info, unsupported);
+        if (!unsupported) {
+            return modelChoice(info.id, hint, true);
         }
-        return {
-            label: model,
-            value: model,
-            hint: "suspected unsupported model",
-            selected: false
-        };
+        return modelChoice(info.id, hint, false);
     });
 }
 export function isLikelyUnsupportedModelName(model) {
     return likelyUnsupportedModelName.test(model);
 }
+function isLikelyUnsupportedModel(model) {
+    return model.type === "embedding" || isLikelyUnsupportedModelName(model.id);
+}
+function modelHint(model, unsupported) {
+    const hints = [
+        model.type,
+        model.architecture,
+        model.quantization,
+        model.contextLength ? `${formatContextLength(model.contextLength)} ctx` : undefined,
+        model.modalities?.input?.includes("image") ? "vision" : undefined,
+        model.capabilities?.toolCall ? "tools" : undefined,
+        model.capabilities?.reasoning ? "reasoning" : undefined,
+        model.state && model.state !== "loaded" ? model.state : undefined,
+        unsupported ? "suspected unsupported model" : undefined
+    ].filter((hint) => Boolean(hint));
+    return hints.length ? hints.join(", ") : undefined;
+}
+function formatContextLength(value) {
+    if (value >= 1000 && value % 1000 === 0) {
+        return `${value / 1000}k`;
+    }
+    if (value >= 1024 && value % 1024 === 0) {
+        return `${value / 1024}k`;
+    }
+    return String(value);
+}
+function modelChoice(modelId, hint, selected) {
+    return {
+        label: modelId,
+        value: modelId,
+        ...(hint ? { hint } : {}),
+        selected
+    };
+}

package/dist/core/model-capabilities.js

@@ -0,0 +1,177 @@
+const MODEL_CAPABILITIES = {
+    "gpt-4o": { input: ["text", "image"], output: ["text"] },
+    "gpt-4o-mini": { input: ["text", "image"], output: ["text"] },
+    "gpt-4-turbo": { input: ["text", "image"], output: ["text"] },
+    "gpt-4-vision-preview": { input: ["text", "image"], output: ["text"] },
+    "gpt-4.1": { input: ["text", "image"], output: ["text"] },
+    "gpt-4.1-mini": { input: ["text", "image"], output: ["text"] },
+    "gpt-4.1-nano": { input: ["text", "image"], output: ["text"] },
+    "gpt-5": { input: ["text", "image"], output: ["text"] },
+    "gpt-5-mini": { input: ["text", "image"], output: ["text"] },
+    "gpt-5-nano": { input: ["text", "image"], output: ["text"] },
+    "o1": { input: ["text", "image"], output: ["text"] },
+    "o1-mini": { input: ["text", "image"], output: ["text"] },
+    "o1-pro": { input: ["text", "image"], output: ["text"] },
+    "o3": { input: ["text", "image"], output: ["text"] },
+    "o3-mini": { input: ["text", "image"], output: ["text"] },
+    "o3-pro": { input: ["text", "image"], output: ["text"] },
+    "o4-mini": { input: ["text", "image"], output: ["text"] },
+    "claude-3-opus": { input: ["text", "image"], output: ["text"] },
+    "claude-3-sonnet": { input: ["text", "image"], output: ["text"] },
+    "claude-3-haiku": { input: ["text", "image"], output: ["text"] },
+    "claude-3.5-sonnet": { input: ["text", "image"], output: ["text"] },
+    "claude-3.5-haiku": { input: ["text", "image"], output: ["text"] },
+    "claude-4-opus": { input: ["text", "image"], output: ["text"] },
+    "claude-4-sonnet": { input: ["text", "image"], output: ["text"] },
+    "claude-4.5-opus": { input: ["text", "image"], output: ["text"] },
+    "claude-4.5-sonnet": { input: ["text", "image"], output: ["text"] },
+    "claude-4.5-haiku": { input: ["text", "image"], output: ["text"] },
+    "gemini-pro-vision": { input: ["text", "image"], output: ["text"] },
+    "gemini-1.5-pro": { input: ["text", "image", "audio", "video"], output: ["text"] },
+    "gemini-1.5-flash": { input: ["text", "image", "audio", "video"], output: ["text"] },
+    "gemini-2.0-flash": { input: ["text", "image", "audio", "video"], output: ["text"] },
+    "gemini-2.5-pro": { input: ["text", "image", "audio", "video"], output: ["text"] },
+    "gemini-2.5-flash": { input: ["text", "image", "audio", "video"], output: ["text"] },
+    "qwen-vl-plus": { input: ["text", "image"], output: ["text"] },
+    "qwen-vl-max": { input: ["text", "image"], output: ["text"] },
+    "qwen-vl-chat": { input: ["text", "image"], output: ["text"] },
+    "qwen2.5-vl-72b-instruct": { input: ["text", "image"], output: ["text"] },
+    "qwen2.5-vl-7b-instruct": { input: ["text", "image"], output: ["text"] },
+    "qwen2.5-vl-32b-instruct": { input: ["text", "image"], output: ["text"] },
+    "qwen3-vl-235b-a22b": { input: ["text", "image"], output: ["text"] },
+    "qwen3-vl-30b-a3b": { input: ["text", "image"], output: ["text"] },
+    "llama-3.2-11b-vision-instruct": { input: ["text", "image"], output: ["text"] },
+    "llama-3.2-90b-vision-instruct": { input: ["text", "image"], output: ["text"] },
+    "llama-4-scout-17b-16e-instruct": { input: ["text", "image"], output: ["text"] },
+    "llama-4-maverick-17b-128e-instruct": { input: ["text", "image"], output: ["text"] },
+    "deepseek-vl": { input: ["text", "image"], output: ["text"] },
+    "deepseek-vl2": { input: ["text", "image"], output: ["text"] },
+    "glm-4v": { input: ["text", "image"], output: ["text"] },
+    "glm-4.5v": { input: ["text", "image"], output: ["text"] },
+    "glm-4.6v": { input: ["text", "image"], output: ["text"] },
+    "glm-5v-turbo": { input: ["text", "image"], output: ["text"] },
+    "pixtral-large-2411": { input: ["text", "image"], output: ["text"] },
+    "pixtral-large-2502": { input: ["text", "image"], output: ["text"] },
+    "mistral-small-3.1-24b-instruct": { input: ["text", "image"], output: ["text"] },
+    "phi-4-multimodal": { input: ["text", "image", "audio"], output: ["text"] },
+    "gemma-3-4b-it": { input: ["text", "image"], output: ["text"] },
+    "gemma-3-12b-it": { input: ["text", "image"], output: ["text"] },
+    "gemma-3-27b-it": { input: ["text", "image"], output: ["text"] },
+    "gemma-4-26b-a4b-it": { input: ["text", "image"], output: ["text"] },
+    "gemma-4-31b-it": { input: ["text", "image"], output: ["text"] },
+};
+const VISION_KEYWORDS = [
+    "vision",
+    "vl",
+    "visual",
+    "multimodal",
+    "pixtral",
+];
+const KNOWN_MODALITY_MODELS = new Set(Object.keys(MODEL_CAPABILITIES));
+export function lookupModelCapabilities(modelId) {
+    const normalized = modelId.toLowerCase().trim();
+    if (MODEL_CAPABILITIES[normalized]) {
+        return MODEL_CAPABILITIES[normalized];
+    }
+    for (const [pattern, caps] of Object.entries(MODEL_CAPABILITIES)) {
+        if (normalized.includes(pattern) || pattern.includes(normalized)) {
+            return caps;
+        }
+    }
+    const withoutPrefix = normalized.includes("/")
+        ? normalized.split("/").pop()
+        : normalized;
+    if (MODEL_CAPABILITIES[withoutPrefix]) {
+        return MODEL_CAPABILITIES[withoutPrefix];
+    }
+    for (const [pattern, caps] of Object.entries(MODEL_CAPABILITIES)) {
+        if (withoutPrefix.includes(pattern) || pattern.includes(withoutPrefix)) {
+            return caps;
+        }
+    }
+    for (const keyword of VISION_KEYWORDS) {
+        if (normalized.includes(keyword)) {
+            return { input: ["text", "image"], output: ["text"] };
+        }
+    }
+    return undefined;
+}
+export function parseCapabilitiesFromApi(model) {
+    if (model.modalities && typeof model.modalities === "object") {
+        const m = model.modalities;
+        const result = {};
+        if (Array.isArray(m.input)) {
+            result.input = m.input.filter((v) => typeof v === "string");
+        }
+        if (Array.isArray(m.output)) {
+            result.output = m.output.filter((v) => typeof v === "string");
+        }
+        if (result.input || result.output) {
+            return result;
+        }
+    }
+    if (model.capabilities && typeof model.capabilities === "object") {
+        const caps = model.capabilities;
+        const input = ["text"];
+        if (caps.vision || caps.image || caps.multimodal || caps.image_input) {
+            input.push("image");
+        }
+        if (caps.audio || caps.speech) {
+            input.push("audio");
+        }
+        if (caps.video) {
+            input.push("video");
+        }
+        if (input.length > 1) {
+            return { input: input, output: ["text"] };
+        }
+    }
+    return undefined;
+}
+export function mergeModelCapabilities(modelId, apiCapabilities, userOverrides) {
+    if (userOverrides && (userOverrides.input || userOverrides.output)) {
+        return userOverrides;
+    }
+    if (apiCapabilities && (apiCapabilities.input || apiCapabilities.output)) {
+        return apiCapabilities;
+    }
+    return lookupModelCapabilities(modelId);
+}
+export function isKnownModel(modelId) {
+    const normalized = modelId.toLowerCase().trim();
+    if (KNOWN_MODALITY_MODELS.has(normalized)) {
+        return true;
+    }
+    const withoutPrefix = normalized.includes("/")
+        ? normalized.split("/").pop()
+        : normalized;
+    if (KNOWN_MODALITY_MODELS.has(withoutPrefix)) {
+        return true;
+    }
+    for (const keyword of VISION_KEYWORDS) {
+        if (normalized.includes(keyword)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function parseModalitiesFromString(value) {
+    const parts = value.split(":");
+    if (parts.length !== 2) {
+        throw new Error(`Invalid modalities format: ${value}. Expected <input>:<output>`);
+    }
+    const [inputStr, outputStr] = parts;
+    const parseModalityList = (s) => {
+        return s.split(",").map((m) => {
+            const trimmed = m.trim().toLowerCase();
+            if (["text", "image", "audio", "video", "pdf"].includes(trimmed)) {
+                return trimmed;
+            }
+            throw new Error(`Unknown modality: ${trimmed}`);
+        });
+    };
+    return {
+        input: parseModalityList(inputStr),
+        output: parseModalityList(outputStr),
+    };
+}

package/dist/core/model-registry.js

@@ -0,0 +1,191 @@
+import { readFile } from "node:fs/promises";
+import { parse } from "jsonc-parser";
+export const DEFAULT_MODEL_REGISTRY_FILE = "model-provider-x.models.jsonc";
+const BUILT_IN_MODELS_DEV_REGISTRY = {
+    source: "models-dev",
+    providers: {
+        openai: {
+            models: {
+                "gpt-oss-20b": {
+                    type: "llm",
+                    contextLength: 131072,
+                    capabilities: {
+                        reasoning: true,
+                        toolCall: true
+                    }
+                }
+            }
+        }
+    }
+};
+export async function loadModelRegistryFile(path) {
+    const text = await readFile(path, "utf8");
+    const value = parse(text);
+    if (!isObject(value)) {
+        throw new Error(`Model registry must be an object: ${path}`);
+    }
+    return normalizeRegistry(value, "local-registry");
+}
+export async function resolveModelRegistryMetadata(input) {
+    const registries = [
+        ...(input.includeBuiltIn === false ? [] : [BUILT_IN_MODELS_DEV_REGISTRY]),
+        ...(input.registries ?? [])
+    ];
+    let result;
+    for (const registry of registries) {
+        const model = lookupRegistryModel(registry, input.providerId, input.modelId);
+        if (!model) {
+            continue;
+        }
+        const info = normalizeRegistryModel(input.modelId, model, registry.source);
+        result = result ? mergeRegistryInfo(result, info) : info;
+    }
+    return result;
+}
+function normalizeRegistry(value, fallbackSource) {
+    return {
+        source: stringValue(value.source) ?? fallbackSource,
+        providers: normalizeProviders(value.providers),
+        models: normalizeModels(value.models)
+    };
+}
+function lookupRegistryModel(registry, providerId, modelId) {
+    const aliases = modelAliases(modelId);
+    if (providerId) {
+        const providerModels = registry.providers?.[providerId]?.models;
+        const match = lookupModel(providerModels, aliases);
+        if (match) {
+            return match;
+        }
+        const modelsDevProvider = registry[providerId];
+        if (isObject(modelsDevProvider)) {
+            const provider = normalizeProviders({ [providerId]: modelsDevProvider })?.[providerId];
+            const providerMatch = lookupModel(provider?.models, aliases);
+            if (providerMatch) {
+                return providerMatch;
+            }
+        }
+    }
+    return lookupModel(registry.models, aliases);
+}
+function lookupModel(models, aliases) {
+    if (!models) {
+        return undefined;
+    }
+    for (const alias of aliases) {
+        if (models[alias]) {
+            return models[alias];
+        }
+    }
+    return undefined;
+}
+function normalizeRegistryModel(modelId, model, source) {
+    const modalities = normalizeModalities(model);
+    const capabilities = model.capabilities;
+    const toolCall = booleanValue(capabilities?.toolCall ?? capabilities?.tool_call ?? model.tool_call);
+    const reasoning = booleanValue(capabilities?.reasoning ?? model.reasoning);
+    return cleanModelInfo({
+        id: model.id ?? modelId,
+        type: model.type,
+        architecture: model.architecture,
+        quantization: model.quantization,
+        parameterSize: model.parameterSize,
+        state: model.state,
+        contextLength: model.contextLength ?? model.limit?.context,
+        modalities,
+        capabilities: toolCall || reasoning ? { toolCall, reasoning } : undefined,
+        metadataSources: [source]
+    });
+}
+function normalizeModalities(model) {
+    if (model.modalities) {
+        return model.modalities;
+    }
+    if (model.input_modalities || model.output_modalities) {
+        return {
+            ...(model.input_modalities ? { input: model.input_modalities } : {}),
+            ...(model.output_modalities ? { output: model.output_modalities } : {})
+        };
+    }
+    return undefined;
+}
+function mergeRegistryInfo(base, next) {
+    return cleanModelInfo({
+        ...base,
+        ...next,
+        id: base.id || next.id,
+        type: next.type ?? base.type,
+        architecture: next.architecture ?? base.architecture,
+        quantization: next.quantization ?? base.quantization,
+        parameterSize: next.parameterSize ?? base.parameterSize,
+        state: next.state ?? base.state,
+        contextLength: next.contextLength ?? base.contextLength,
+        modalities: next.modalities ?? base.modalities,
+        capabilities: base.capabilities || next.capabilities
+            ? {
+                ...base.capabilities,
+                ...next.capabilities
+            }
+            : undefined,
+        metadataSources: [...new Set([...(base.metadataSources ?? []), ...(next.metadataSources ?? [])])]
+    });
+}
+function normalizeProviders(value) {
+    if (!isObject(value)) {
+        return undefined;
+    }
+    const providers = {};
+    for (const [providerId, providerValue] of Object.entries(value)) {
+        if (!isObject(providerValue)) {
+            continue;
+        }
+        const models = normalizeModels(providerValue.models);
+        if (models) {
+            providers[providerId] = { models };
+        }
+    }
+    return Object.keys(providers).length ? providers : undefined;
+}
+function normalizeModels(value) {
+    if (!isObject(value)) {
+        return undefined;
+    }
+    const models = {};
+    for (const [modelId, modelValue] of Object.entries(value)) {
+        if (isObject(modelValue)) {
+            models[modelId] = modelValue;
+        }
+    }
+    return Object.keys(models).length ? models : undefined;
+}
+function modelAliases(modelId) {
+    const normalized = modelId.trim();
+    const withoutPrefix = normalized.includes("/") ? normalized.split("/").pop() : normalized;
+    return [...new Set([normalized, withoutPrefix])];
+}
+function cleanModelInfo(model) {
+    const capabilities = model.capabilities?.toolCall || model.capabilities?.reasoning
+        ? model.capabilities
+        : undefined;
+    return {
+        id: model.id,
+        ...(model.type ? { type: model.type } : {}),
+        ...(model.architecture ? { architecture: model.architecture } : {}),
+        ...(model.quantization ? { quantization: model.quantization } : {}),
+        ...(model.parameterSize ? { parameterSize: model.parameterSize } : {}),
+        ...(model.state ? { state: model.state } : {}),
+        ...(model.contextLength ? { contextLength: model.contextLength } : {}),
+        ...(model.modalities ? { modalities: model.modalities } : {}),
+        ...(capabilities ? { capabilities } : {}),
+        ...(model.metadataSources?.length ? { metadataSources: model.metadataSources } : {})
+    };
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function booleanValue(value) {
+    return typeof value === "boolean" ? value : undefined;
+}

package/dist/core/provider.js

@@ -1,3 +1,5 @@
+import { parseCapabilitiesFromApi, mergeModelCapabilities } from "./model-capabilities.js";
+import { loadModelRegistryFile, resolveModelRegistryMetadata } from "./model-registry.js";
 export function normalizeBaseUrl(baseURL) {
     const normalized = baseURL.trim().replace(/\/+$/, "");
     if (!normalized) {
@@ -11,7 +13,7 @@ export function normalizeBaseUrl(baseURL) {
     }
     return normalized;
 }
-export async function validateAndFetchModels(input, fetchImpl = globalThis.fetch) {
+export async function validateAndFetchModels(input, fetchImpl = globalThis.fetch, lmStudioSdkLoader = loadLmStudioSdkModels) {
     const baseURL = normalizeBaseUrl(input.baseURL);
     const apiKey = input.apiKey?.trim() ?? "";
     const headers = {};
@@ -26,16 +28,34 @@ export async function validateAndFetchModels(input, fetchImpl = globalThis.fetch
     if (!isModelListResponse(body)) {
         throw new Error("Expected /models to return an object with a data array");
     }
-    const models = [
-        ...new Set(body.data
-            .filter(isOpenCodeCompatibleModel)
-            .map((model) => model.id.trim())
-            .filter(Boolean))
-    ];
+    const sourceModels = body.data.map((model) => normalizeModelInfo(model, "openai-models"));
+    const nativeModels = await fetchNativeRestModelDetails(baseURL, headers, fetchImpl);
+    const sdkModels = nativeModels.length > 0 && (lmStudioSdkLoader !== loadLmStudioSdkModels || fetchImpl === globalThis.fetch)
+        ? await safeLoadLmStudioSdkModels(lmStudioSdkLoader, baseURL)
+        : [];
+    const registries = await loadRegistries(input);
+    const registryModels = await Promise.all(sourceModels.map((model) => resolveModelRegistryMetadata({
+        providerId: input.providerId,
+        modelId: model.id,
+        registries
+    })));
+    const modelDetailsById = mergeModelDetails([...sourceModels, ...registryModels.filter(isModelInfo), ...nativeModels, ...sdkModels]);
+    const compatibleModels = sourceModels
+        .map((model) => mergeModelInfo(model, modelDetailsForId(model.id, modelDetailsById)))
+        .filter(isOpenCodeCompatibleModel);
+    const models = [...new Set(compatibleModels.map((model) => model.id.trim()).filter(Boolean))];
     if (models.length === 0) {
         throw new Error("Provider returned no OpenCode-compatible model ids");
     }
-    return { baseURL, models };
+    const modelDetails = models.map((modelId) => withMergedModalities(modelDetailsForId(modelId, modelDetailsById)));
+    return { baseURL, models, modelDetails };
+}
+async function loadRegistries(input) {
+    const loaded = await Promise.all((input.modelRegistryPaths ?? []).map((path) => loadModelRegistryFile(path)));
+    return [...(input.registries ?? []), ...loaded];
+}
+function isModelInfo(value) {
+    return Boolean(value);
 }
 export async function detectProviderCapabilities(input, fetchImpl = globalThis.fetch) {
     const baseURL = normalizeBaseUrl(input.baseURL);
@@ -78,7 +98,10 @@ export function buildProviderConfig(input) {
         options: {
             baseURL
         },
-        models: Object.fromEntries(input.models.map((model) => [model, { name: model }]))
+        models: Object.fromEntries(input.models.map((model) => {
+            const modelInfo = input.modelDetails?.find((m) => m.id === model);
+            return [model, buildModelConfig(model, modelInfo)];
+        }))
     };
     if (opencodeApiType !== "messages") {
         provider.options.setCacheKey = true;
@@ -93,6 +116,22 @@ export function buildProviderConfig(input) {
         }
     };
 }
+function buildModelConfig(modelId, modelInfo) {
+    const config = { name: modelId };
+    if (modelInfo?.modalities) {
+        config.modalities = modelInfo.modalities;
+    }
+    if (modelInfo?.capabilities?.reasoning) {
+        config.reasoning = true;
+    }
+    if (modelInfo?.capabilities?.toolCall) {
+        config.tool_call = true;
+    }
+    if (modelInfo?.contextLength) {
+        config.limit = { context: modelInfo.contextLength };
+    }
+    return config;
+}
 export function npmPackageForOpenCodeApiType(apiType) {
     if (apiType === "responses") {
         return "@ai-sdk/openai";
@@ -112,7 +151,249 @@ function isOpenCodeCompatibleModel(model) {
     if (typeof model.type !== "string") {
         return true;
     }
-    return ["llm", "chat", "completion", "text-generation"].includes(model.type.trim().toLowerCase());
+    return !["embedding", "embed", "rerank", "reranker"].includes(model.type.trim().toLowerCase());
+}
+async function fetchNativeRestModelDetails(baseURL, headers, fetchImpl) {
+    if (!isLikelyLmStudioBaseUrl(baseURL)) {
+        return [];
+    }
+    for (const endpoint of nativeLmStudioModelEndpoints(baseURL)) {
+        try {
+            const response = await fetchImpl(endpoint, { headers });
+            if (!response.ok) {
+                continue;
+            }
+            const body = await response.json();
+            const rawModels = modelListItems(body);
+            if (!rawModels) {
+                continue;
+            }
+            return rawModels.map((model) => normalizeModelInfo(model, "lmstudio-rest"));
+        }
+        catch {
+            continue;
+        }
+    }
+    return [];
+}
+function nativeLmStudioModelEndpoints(baseURL) {
+    const url = new URL(baseURL);
+    url.pathname = "/api/v1/models";
+    url.search = "";
+    url.hash = "";
+    const v1 = url.toString();
+    url.pathname = "/api/v0/models";
+    const v0 = url.toString();
+    return [v1, v0];
+}
+function isLikelyLmStudioBaseUrl(baseURL) {
+    const url = new URL(baseURL);
+    return ["localhost", "127.0.0.1", "::1"].includes(url.hostname) && url.port === "1234";
+}
+function normalizeModelInfo(raw, source) {
+    const id = String(raw.id ?? raw.key ?? raw.model ?? "").trim();
+    const capabilitiesObject = objectValue(raw.capabilities);
+    const modalities = parseCapabilitiesFromApi(raw);
+    const type = stringValue(raw.type);
+    const contextLength = numberValue(raw.max_context_length ?? raw.context_length ?? raw.contextLength);
+    const toolCall = capabilityFlag(raw.tool_call ??
+        raw.tool_calls ??
+        raw.toolCall ??
+        raw.supports_tool_calls ??
+        raw.supportsToolCalls ??
+        capabilitiesObject?.toolUse ??
+        capabilitiesObject?.tool_use ??
+        capabilitiesObject?.toolCall ??
+        capabilitiesObject?.tool_call ??
+        capabilitiesObject?.trainedForToolUse ??
+        capabilitiesObject?.trained_for_tool_use);
+    const reasoning = capabilityFlag(raw.reasoning ?? raw.supports_reasoning ?? capabilitiesObject?.reasoning);
+    return cleanModelInfo({
+        id,
+        type,
+        architecture: stringValue(raw.arch ?? raw.architecture),
+        quantization: stringValue(raw.quantization) ?? stringValue(objectValue(raw.quantization)?.name),
+        parameterSize: stringValue(raw.params_string ?? raw.paramsString ?? raw.parameterSize),
+        state: stringValue(raw.state) ?? (Array.isArray(raw.loaded_instances) && raw.loaded_instances.length > 0 ? "loaded" : undefined),
+        contextLength,
+        modalities,
+        capabilities: toolCall || reasoning ? { toolCall, reasoning } : undefined,
+        metadataSources: [source]
+    });
+}
+function mergeModelDetails(models) {
+    const result = new Map();
+    for (const model of models) {
+        if (!model.id) {
+            continue;
+        }
+        for (const alias of modelAliases(model.id)) {
+            const current = result.get(alias);
+            result.set(alias, current ? mergeModelInfo(current, model) : model);
+        }
+    }
+    return result;
+}
+function modelDetailsForId(modelId, models) {
+    return modelAliases(modelId).reduce((merged, alias) => {
+        const next = models.get(alias);
+        return next ? mergeModelInfo(merged, next) : merged;
+    }, { id: modelId });
+}
+function mergeModelInfo(base, next) {
+    return cleanModelInfo({
+        ...base,
+        ...next,
+        id: base.id || next.id,
+        type: next.type ?? base.type,
+        architecture: next.architecture ?? base.architecture,
+        quantization: next.quantization ?? base.quantization,
+        parameterSize: next.parameterSize ?? base.parameterSize,
+        state: next.state ?? base.state,
+        contextLength: next.contextLength ?? base.contextLength,
+        modalities: next.modalities ?? base.modalities,
+        capabilities: base.capabilities || next.capabilities
+            ? {
+                ...base.capabilities,
+                ...next.capabilities
+            }
+            : undefined,
+        metadataSources: [...new Set([...(base.metadataSources ?? []), ...(next.metadataSources ?? [])])]
+    });
+}
+function withMergedModalities(model) {
+    const modalities = mergeModelCapabilities(model.id, model.modalities);
+    return cleanModelInfo({
+        ...model,
+        modalities,
+        metadataSources: modalities
+            ? [...new Set([...(model.metadataSources ?? []), model.modalities ? undefined : "heuristics"].filter((v) => Boolean(v)))]
+            : model.metadataSources
+    });
+}
+function modelAliases(modelId) {
+    const normalized = modelId.trim();
+    const withoutPrefix = normalized.includes("/") ? normalized.split("/").pop() : normalized;
+    return [...new Set([normalized, withoutPrefix])];
+}
+function cleanModelInfo(model) {
+    const capabilities = model.capabilities?.toolCall || model.capabilities?.reasoning
+        ? model.capabilities
+        : undefined;
+    return {
+        id: model.id,
+        ...(model.type ? { type: model.type } : {}),
+        ...(model.architecture ? { architecture: model.architecture } : {}),
+        ...(model.quantization ? { quantization: model.quantization } : {}),
+        ...(model.parameterSize ? { parameterSize: model.parameterSize } : {}),
+        ...(model.state ? { state: model.state } : {}),
+        ...(model.contextLength ? { contextLength: model.contextLength } : {}),
+        ...(model.modalities ? { modalities: model.modalities } : {}),
+        ...(capabilities ? { capabilities } : {}),
+        ...(model.metadataSources?.length ? { metadataSources: model.metadataSources } : {})
+    };
+}
+function objectValue(value) {
+    return typeof value === "object" && value !== null ? value : undefined;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function numberValue(value) {
+    const number = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+    return Number.isFinite(number) && number > 0 ? number : undefined;
+}
+function booleanValue(value) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "string") {
+        if (["true", "yes", "1"].includes(value.toLowerCase())) {
+            return true;
+        }
+        if (["false", "no", "0"].includes(value.toLowerCase())) {
+            return false;
+        }
+    }
+    return undefined;
+}
+function capabilityFlag(value) {
+    if (typeof value === "object" && value !== null) {
+        return true;
+    }
+    return booleanValue(value);
+}
+function modelListItems(body) {
+    if (typeof body !== "object" || body === null) {
+        return undefined;
+    }
+    const data = body.data;
+    const models = body.models;
+    const items = Array.isArray(data) ? data : Array.isArray(models) ? models : undefined;
+    if (!items) {
+        return undefined;
+    }
+    if (!items.every((model) => typeof model === "object" && model !== null)) {
+        return undefined;
+    }
+    return items;
+}
+async function safeLoadLmStudioSdkModels(loader, baseURL) {
+    try {
+        return await loader(baseURL);
+    }
+    catch {
+        return [];
+    }
+}
+async function loadLmStudioSdkModels(baseURL) {
+    const sdk = await import("@lmstudio/sdk");
+    const Client = sdk.LMStudioClient;
+    if (!Client) {
+        return [];
+    }
+    const wsBaseURL = httpBaseUrlToWs(baseURL);
+    const connectedClient = new Client({ baseUrl: wsBaseURL, logger: silentLogger });
+    try {
+        const models = await connectedClient.system?.listDownloadedModels?.();
+        if (!Array.isArray(models)) {
+            return [];
+        }
+        return models.map((model) => {
+            const raw = model;
+            const id = stringValue(raw.modelKey ?? raw.path ?? raw.id ?? raw.displayName) ?? "";
+            const vision = booleanValue(raw.vision);
+            const trainedForToolUse = booleanValue(raw.trainedForToolUse ?? raw.trained_for_tool_use);
+            return cleanModelInfo({
+                id,
+                type: stringValue(raw.type) ?? "llm",
+                architecture: stringValue(raw.architecture),
+                quantization: stringValue(raw.quantization) ?? stringValue(objectValue(raw.quantization)?.name),
+                parameterSize: stringValue(raw.paramsString),
+                contextLength: numberValue(raw.maxContextLength ?? raw.max_context_length),
+                modalities: vision ? { input: ["text", "image"], output: ["text"] } : undefined,
+                capabilities: trainedForToolUse ? { toolCall: true } : undefined,
+                metadataSources: ["lmstudio-sdk"]
+            });
+        });
+    }
+    finally {
+        await connectedClient[Symbol.asyncDispose]?.();
+    }
+}
+const silentLogger = {
+    debug() { },
+    info() { },
+    warn() { },
+    error() { }
+};
+function httpBaseUrlToWs(baseURL) {
+    const url = new URL(baseURL);
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    url.pathname = "";
+    url.search = "";
+    url.hash = "";
+    return url.toString().replace(/\/$/, "");
 }
 async function probe(input, init, fetchImpl) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heventure/model-provider-x",
-  "version": "0.2.3",
+  "version": "0.2.5-beta.0",
   "description": "TUI configurator and local API proxy for wiring custom model providers into OpenCode and Claude Code.",
   "private": false,
   "license": "MIT",
@@ -46,5 +46,8 @@
     "typescript": "^5.9.0",
     "typescript-eslint": "^8.0.0",
     "vitest": "^3.0.0"
+  },
+  "optionalDependencies": {
+    "@lmstudio/sdk": "^1.5.0"
   }
 }