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

package/README.md

@@ -145,7 +145,7 @@ 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.
+4. Built-in models.dev metadata (5000+ models from 140+ providers).
 5. Conservative model-name heuristics.
 
 By default, the CLI reads `model-provider-x.models.jsonc` from the current working directory when it exists.
@@ -180,6 +180,16 @@ Example registry:
 }
 ```
 
+### Updating Models.dev Data
+
+The built-in models.dev data is bundled with the package. To update it to the latest version:
+
+```bash
+npm run update-models-dev
+```
+
+This fetches the latest model metadata from [models.dev](https://models.dev) and updates `src/data/models-dev.json`.
+
 ## Commands
 
 ```bash

package/dist/core/model-registry.js

@@ -1,23 +1,28 @@
 import { readFile } from "node:fs/promises";
 import { parse } from "jsonc-parser";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
 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
-                    }
-                }
-            }
-        }
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const MODELS_DEV_DATA_PATH = resolve(__dirname, "../data/models-dev.json");
+let modelsDevCache = null;
+async function loadModelsDevRegistry() {
+    if (modelsDevCache) {
+        return modelsDevCache;
+    }
+    try {
+        const text = await readFile(MODELS_DEV_DATA_PATH, "utf-8");
+        const data = JSON.parse(text);
+        modelsDevCache = {
+            source: data.source ?? "models-dev",
+            providers: data.providers
+        };
+        return modelsDevCache;
+    }
+    catch {
+        return { source: "models-dev", providers: {} };
     }
-};
+}
 export async function loadModelRegistryFile(path) {
     const text = await readFile(path, "utf8");
     const value = parse(text);
@@ -27,8 +32,9 @@ export async function loadModelRegistryFile(path) {
     return normalizeRegistry(value, "local-registry");
 }
 export async function resolveModelRegistryMetadata(input) {
+    const builtInRegistry = input.includeBuiltIn === false ? undefined : await loadModelsDevRegistry();
     const registries = [
-        ...(input.includeBuiltIn === false ? [] : [BUILT_IN_MODELS_DEV_REGISTRY]),
+        ...(builtInRegistry ? [builtInRegistry] : []),
         ...(input.registries ?? [])
     ];
     let result;
@@ -51,6 +57,7 @@ function normalizeRegistry(value, fallbackSource) {
 }
 function lookupRegistryModel(registry, providerId, modelId) {
     const aliases = modelAliases(modelId);
+    // First try the specified provider
     if (providerId) {
         const providerModels = registry.providers?.[providerId]?.models;
         const match = lookupModel(providerModels, aliases);
@@ -66,6 +73,15 @@ function lookupRegistryModel(registry, providerId, modelId) {
             }
         }
     }
+    // Search across all providers if not found in specified provider
+    if (registry.providers) {
+        for (const [, provider] of Object.entries(registry.providers)) {
+            const match = lookupModel(provider.models, aliases);
+            if (match) {
+                return match;
+            }
+        }
+    }
     return lookupModel(registry.models, aliases);
 }
 function lookupModel(models, aliases) {
@@ -159,9 +175,33 @@ function normalizeModels(value) {
     return Object.keys(models).length ? models : undefined;
 }
 function modelAliases(modelId) {
-    const normalized = modelId.trim();
+    const normalized = modelId.trim().toLowerCase();
     const withoutPrefix = normalized.includes("/") ? normalized.split("/").pop() : normalized;
-    return [...new Set([normalized, withoutPrefix])];
+    // Strip common suffixes for fuzzy matching
+    const suffixes = [
+        "-it", "-qat", "-instruct", "-chat", "-gguf", "-gptq", "-awq", "-exl2",
+        "-fp16", "-fp32", "-int4", "-int8", "-4bit", "-8bit", "-16bit",
+        "-preview", "-latest", "-beta", "-alpha", "-rc", "-snapshot",
+        "-mlx", "-mlxc", "-bnb", "-hqq",
+        "-ud", "-xl", "-xs", "-small", "-medium", "-large", "-mini", "-nano", "-micro",
+        "-turbo", "-fast", "-pro", "-plus", "-max", "-ultra", "-flash", "-lite",
+        "-mtp", "-moe", "-a17b", "-a22b", "-a3b", "-a10b", "-a12b", "-a55b",
+        "-chat", "-base", "-raw", "-uncensored", "-abliterated"
+    ];
+    let fuzzy = withoutPrefix;
+    for (const suffix of suffixes) {
+        if (fuzzy.endsWith(suffix)) {
+            fuzzy = fuzzy.slice(0, -suffix.length);
+            break;
+        }
+    }
+    // Also try removing version suffixes like "-v1", "-v2", etc.
+    const versionMatch = fuzzy.match(/-v\d+$/);
+    const withoutVersion = versionMatch ? fuzzy.slice(0, -versionMatch[0].length) : fuzzy;
+    // Try removing parameter size suffixes like "-12b", "-7b", "-70b", etc.
+    const paramMatch = fuzzy.match(/-\d+[bBmMkKtT]$/);
+    const withoutParams = paramMatch ? fuzzy.slice(0, -paramMatch[0].length) : fuzzy;
+    return [...new Set([normalized, withoutPrefix, fuzzy, withoutVersion, withoutParams])];
 }
 function cleanModelInfo(model) {
     const capabilities = model.capabilities?.toolCall || model.capabilities?.reasoning