@heventure/model-provider-x 0.2.4 → 0.2.5

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 {