@heventure/model-provider-x 0.2.4 → 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,12 @@ 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 = [];
@@ -113,6 +119,8 @@ 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.

package/dist/cli/index.js

@@ -1,11 +1,13 @@
 #!/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";
@@ -72,12 +74,17 @@ 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 = fetched.modelDetails.filter((m) => selectedModels.includes(m.id));
+        const modelDetails = applyModelModalityOverrides(fetched.modelDetails.filter((m) => selectedModels.includes(m.id)), options);
         const fragment = buildProviderConfig({
             providerId,
             providerName,
@@ -145,10 +152,15 @@ 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) {
@@ -372,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()) {
@@ -671,14 +707,14 @@ async function resolveModelModalities(rl, command, selectedModels, fetchedModelD
 async function promptModelModalities(rl, modelId) {
     output.write(`\nModel: ${modelId} - Capabilities unknown\n`);
     if (canUseTui()) {
-        const inputModalities = await multiSelectChoices("Input modalities", [
+        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", [
+        const outputModalities = await multiSelectChoices(`Output modalities: ${modelId}`, [
             { label: "text", value: "text", hint: "default" },
             { label: "image", value: "image" },
             { label: "audio", value: "audio" },

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

@@ -113,12 +113,15 @@ export function parseCapabilitiesFromApi(model) {
     if (model.capabilities && typeof model.capabilities === "object") {
         const caps = model.capabilities;
         const input = ["text"];
-        if (caps.vision || caps.image || caps.multimodal) {
+        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"] };
         }

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,4 +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) {
@@ -12,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 = {};
@@ -27,26 +28,35 @@ 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 compatibleModels = body.data.filter(isOpenCodeCompatibleModel);
-    const models = [
-        ...new Set(compatibleModels
-            .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");
     }
-    const modelDetails = models.map((modelId) => {
-        const rawModel = compatibleModels.find((m) => m.id.trim() === modelId);
-        const apiCapabilities = rawModel ? parseCapabilitiesFromApi(rawModel) : undefined;
-        const mergedCapabilities = mergeModelCapabilities(modelId, apiCapabilities);
-        return {
-            id: modelId,
-            modalities: mergedCapabilities
-        };
-    });
+    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);
     const apiKey = input.apiKey?.trim() ?? "";
@@ -111,6 +121,15 @@ function buildModelConfig(modelId, modelInfo) {
     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) {
@@ -132,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.4",
+  "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"
   }
 }