@nodetool-ai/websocket 0.7.0-rc.11

package/dist/models-api.js

@@ -0,0 +1,730 @@
+import { access, readdir } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+import { getProvider, isProviderConfigured, listRegisteredProviderIds, providerCapabilities, RECOMMENDED_MODELS } from "@nodetool-ai/runtime";
+import { readCachedHfModels, searchCachedHfModels, getModelsByHfType, deleteCachedHfModel, getHuggingfaceFileInfos } from "@nodetool-ai/huggingface";
+const LLAMA_CPP_MODEL_TYPES = new Set([
+    "llama_cpp_model",
+    "llama_cpp",
+    "hf.gguf"
+]);
+function jsonResponse(data, init) {
+    return new Response(JSON.stringify(data), {
+        status: init?.status ?? 200,
+        headers: {
+            "content-type": "application/json",
+            ...(init?.headers ?? {})
+        }
+    });
+}
+function errorResponse(status, detail) {
+    return jsonResponse({ detail }, { status });
+}
+function isProduction() {
+    const value = (process.env.NODETOOL_ENV ??
+        process.env.NODE_ENV ??
+        "").toLowerCase();
+    return value === "production";
+}
+function dedupeModels(models) {
+    const seen = new Set();
+    const deduped = [];
+    for (const model of models) {
+        const key = `${model.repo_id ?? ""}::${model.path ?? ""}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            deduped.push(model);
+        }
+    }
+    return deduped;
+}
+function normalizePatterns(patterns) {
+    if (patterns == null)
+        return null;
+    if (typeof patterns === "string")
+        return patterns ? [patterns] : null;
+    const cleaned = patterns.filter((p) => Boolean(p));
+    return cleaned.length > 0 ? cleaned : null;
+}
+function wildcardToRegExp(pattern) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    const regex = `^${escaped.replaceAll("*", ".*").replaceAll("?", ".")}$`;
+    return new RegExp(regex);
+}
+function matchesPattern(value, pattern) {
+    return wildcardToRegExp(pattern).test(value);
+}
+function isIgnored(path, ignorePatterns) {
+    if (!ignorePatterns || ignorePatterns.length === 0)
+        return false;
+    return ignorePatterns.some((pattern) => matchesPattern(path, pattern));
+}
+function isDownloadedFromFiles(files, allowPatterns, ignorePatterns) {
+    if (files.length === 0)
+        return false;
+    if (allowPatterns && allowPatterns.length > 0) {
+        return allowPatterns.every((pattern) => files.some((path) => matchesPattern(path, pattern) && !isIgnored(path, ignorePatterns)));
+    }
+    return files.some((path) => !isIgnored(path, ignorePatterns));
+}
+function getHfCacheRoot() {
+    const cacheEnv = process.env.HUGGINGFACE_HUB_CACHE ?? process.env.HF_HOME;
+    return cacheEnv
+        ? join(cacheEnv, "hub")
+        : join(homedir(), ".cache", "huggingface", "hub");
+}
+function repoToCacheDir(repoId) {
+    return `models--${repoId.replaceAll("/", "--")}`;
+}
+async function pathExists(path) {
+    try {
+        await access(path, fsConstants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function listSnapshotDirs(repoId) {
+    const snapshotsRoot = join(getHfCacheRoot(), repoToCacheDir(repoId), "snapshots");
+    if (!(await pathExists(snapshotsRoot)))
+        return [];
+    const entries = await readdir(snapshotsRoot, { withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => join(snapshotsRoot, entry.name));
+}
+async function repoFileInCache(repoId, relativePath) {
+    const snapshotDirs = await listSnapshotDirs(repoId);
+    for (const snapshotDir of snapshotDirs) {
+        if (await pathExists(join(snapshotDir, relativePath))) {
+            return true;
+        }
+    }
+    return false;
+}
+async function listRepoCachedFiles(repoId) {
+    const snapshotDirs = await listSnapshotDirs(repoId);
+    const collected = new Set();
+    async function walk(root, current) {
+        const entries = await readdir(current, { withFileTypes: true });
+        for (const entry of entries) {
+            const full = join(current, entry.name);
+            if (entry.isDirectory()) {
+                await walk(root, full);
+                continue;
+            }
+            if (entry.isFile() || entry.isSymbolicLink()) {
+                const rel = full.slice(root.length + 1).replaceAll("\\", "/");
+                collected.add(rel);
+            }
+        }
+    }
+    for (const snapshotDir of snapshotDirs) {
+        await walk(snapshotDir, snapshotDir);
+    }
+    return [...collected];
+}
+async function hasCachedFiles(repoId) {
+    return (await listRepoCachedFiles(repoId)).length > 0;
+}
+function toUnifiedLanguageModel(model) {
+    return {
+        id: model.id,
+        type: "language_model",
+        name: model.name,
+        repo_id: null,
+        path: model.id,
+        downloaded: model.provider === "ollama" || model.provider === "llama_cpp",
+        tags: [model.provider]
+    };
+}
+function toUnifiedModel(model, type) {
+    return {
+        id: model.id,
+        type,
+        name: model.name,
+        repo_id: null,
+        path: model.id,
+        downloaded: model.provider === "ollama" || model.provider === "llama_cpp",
+        tags: [model.provider]
+    };
+}
+function toOllamaModel(model) {
+    return {
+        type: "llama_model",
+        name: model.name,
+        repo_id: model.id,
+        modified_at: "",
+        size: 0,
+        digest: "",
+        details: {}
+    };
+}
+// ---------------------------------------------------------------------------
+// Provider access — delegates to the runtime's single provider registry.
+// No duplicate registry here; the runtime's registerProvider() calls in
+// providers/index.ts are the single source of truth.
+// ---------------------------------------------------------------------------
+import { PythonProvider, registerProvider } from "@nodetool-ai/runtime";
+/**
+ * Register Python-only providers (HuggingFace Local, MLX) discovered
+ * via the Python stdio bridge. Call after the bridge has connected.
+ */
+export async function registerPythonProviders(bridge) {
+    const providers = await bridge.listProviders();
+    const registered = [];
+    for (const info of providers) {
+        if (listRegisteredProviderIds().includes(info.id))
+            continue;
+        const secrets = {};
+        registerProvider(info.id, PythonProvider, {
+            _bridge: bridge,
+            _id: info.id,
+            ...secrets
+        });
+        registered.push(info.id);
+    }
+    return registered;
+}
+/** Returns only providers whose required credentials are present (env or DB) for the given user. */
+async function getAvailableProviderIds(userId = "1") {
+    const ids = listRegisteredProviderIds();
+    const checks = await Promise.all(ids.map(async (id) => ({
+        id,
+        available: await isProviderConfigured(id, userId)
+    })));
+    return checks.filter((c) => c.available).map((c) => c.id);
+}
+async function instantiateProvider(provider, userId = "1") {
+    if (!(await isProviderConfigured(provider, userId)))
+        return null;
+    try {
+        return await getProvider(provider, userId);
+    }
+    catch {
+        return null;
+    }
+}
+async function getProvidersInfo(userId = "1") {
+    const infos = [];
+    for (const provider of await getAvailableProviderIds(userId)) {
+        const instance = await instantiateProvider(provider, userId);
+        if (!instance)
+            continue;
+        infos.push({ provider, capabilities: providerCapabilities(instance) });
+    }
+    return infos;
+}
+async function withProvider(provider, run, userId = "1") {
+    const instance = await instantiateProvider(provider, userId);
+    if (!instance) {
+        throw new Error(`Provider ${provider} not available`);
+    }
+    return run(instance);
+}
+async function getLanguageModelsByProvider(provider, userId = "1") {
+    try {
+        return await withProvider(provider, (instance) => instance.getAvailableLanguageModels(), userId);
+    }
+    catch {
+        return [];
+    }
+}
+async function getImageModelsByProvider(provider, userId = "1") {
+    try {
+        return await withProvider(provider, (instance) => instance.getAvailableImageModels(), userId);
+    }
+    catch {
+        return [];
+    }
+}
+async function getTtsModelsByProvider(provider, userId = "1") {
+    try {
+        return await withProvider(provider, (instance) => instance.getAvailableTTSModels(), userId);
+    }
+    catch {
+        return [];
+    }
+}
+async function getAsrModelsByProvider(provider, userId = "1") {
+    try {
+        return await withProvider(provider, (instance) => instance.getAvailableASRModels(), userId);
+    }
+    catch {
+        return [];
+    }
+}
+async function getVideoModelsByProvider(provider, userId = "1") {
+    try {
+        return await withProvider(provider, (instance) => instance.getAvailableVideoModels(), userId);
+    }
+    catch {
+        return [];
+    }
+}
+async function getEmbeddingModelsByProvider(provider, userId = "1") {
+    try {
+        return await withProvider(provider, (instance) => instance.getAvailableEmbeddingModels(), userId);
+    }
+    catch {
+        return [];
+    }
+}
+async function isServerReachable(url) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 2000);
+    try {
+        const response = await fetch(url, { signal: controller.signal });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function serverAllowsModel(model, servers) {
+    // Local server providers need reachability check
+    if (model.provider === "ollama")
+        return servers.ollama ?? false;
+    if (model.provider === "llama_cpp")
+        return servers.llama_cpp ?? false;
+    if (model.provider === "lmstudio")
+        return servers.lmstudio ?? false;
+    if (model.provider === "vllm")
+        return servers.vllm ?? false;
+    // API-key providers: available if key is set (env or secrets DB)
+    if (model.provider)
+        return await isProviderConfigured(model.provider);
+    return true;
+}
+async function getServerAvailability() {
+    // Skip localhost probes in production — local servers won't be available
+    if (isProduction())
+        return { ollama: false, llama_cpp: false };
+    const ollamaUrl = (process.env.OLLAMA_API_URL ?? "http://127.0.0.1:11434").replace(/\/+$/, "");
+    const llamaUrl = process.env.LLAMA_CPP_URL?.replace(/\/+$/, "") ?? "";
+    const [ollama, llama] = await Promise.all([
+        isServerReachable(`${ollamaUrl}/api/tags`),
+        llamaUrl
+            ? isServerReachable(`${llamaUrl}/v1/models`)
+            : Promise.resolve(false)
+    ]);
+    return { ollama, llama_cpp: llama };
+}
+async function recommendedModels(checkServers) {
+    const models = [...RECOMMENDED_MODELS];
+    if (!checkServers)
+        return models;
+    const servers = await getServerAvailability();
+    const filtered = [];
+    for (const model of models) {
+        if (await serverAllowsModel(model, servers)) {
+            filtered.push(model);
+        }
+    }
+    return filtered;
+}
+function selectRecommended(modality, task) {
+    return RECOMMENDED_MODELS.filter((model) => model.modality === modality && (!task || model.task === task));
+}
+async function getAllModels(userId = "1") {
+    const all = [];
+    // Always include recommended models as a baseline
+    all.push(...RECOMMENDED_MODELS);
+    // Include language models from all available providers
+    const availableIds = await getAvailableProviderIds(userId);
+    for (const providerId of availableIds) {
+        try {
+            const models = await getLanguageModelsByProvider(providerId, userId);
+            all.push(...models.map(toUnifiedLanguageModel));
+        }
+        catch {
+            // Provider unavailable — skip
+        }
+    }
+    // Include HuggingFace cached/recommended models
+    if (!isProduction()) {
+        try {
+            const hfModels = await readCachedHfModels();
+            all.push(...hfModels);
+        }
+        catch {
+            // HF models unavailable — continue without them
+        }
+    }
+    return dedupeModels(all);
+}
+async function parseJsonBody(request) {
+    const contentType = request.headers.get("content-type") ?? "";
+    if (!contentType.toLowerCase().includes("application/json")) {
+        return null;
+    }
+    try {
+        return (await request.json());
+    }
+    catch {
+        return null;
+    }
+}
+function pathFromModelsPrefix(pathname) {
+    const base = "/api/models";
+    if (pathname === base)
+        return "";
+    if (pathname.startsWith(`${base}/`))
+        return pathname.slice(base.length);
+    return pathname;
+}
+function parseProvider(path, prefix) {
+    if (!path.startsWith(prefix))
+        return null;
+    const value = decodeURIComponent(path.slice(prefix.length));
+    if (!value)
+        return null;
+    return value;
+}
+async function checkHfCache(body) {
+    const allowPatterns = normalizePatterns(body.allow_pattern);
+    const ignorePatterns = normalizePatterns(body.ignore_pattern);
+    const files = await listRepoCachedFiles(body.repo_id);
+    const missing = [];
+    if (allowPatterns) {
+        for (const pattern of allowPatterns) {
+            const matched = files.some((path) => matchesPattern(path, pattern) && !isIgnored(path, ignorePatterns));
+            if (!matched) {
+                missing.push(pattern);
+            }
+        }
+    }
+    return {
+        repo_id: body.repo_id,
+        all_present: missing.length === 0,
+        total_files: files.length,
+        missing
+    };
+}
+async function isLlamaCppModelCached(repoId, filePath) {
+    if (await repoFileInCache(repoId, filePath)) {
+        return true;
+    }
+    const cacheRoot = process.env.LLAMA_CPP_CACHE_DIR ??
+        join(homedir(), "Library", "Caches", "llama.cpp", "hf");
+    const repoDir = join(cacheRoot, repoToCacheDir(repoId), "snapshots");
+    if (!(await pathExists(repoDir)))
+        return false;
+    const snapshots = await readdir(repoDir, { withFileTypes: true });
+    for (const snapshot of snapshots) {
+        if (!snapshot.isDirectory())
+            continue;
+        if (await pathExists(join(repoDir, snapshot.name, filePath))) {
+            return true;
+        }
+        if (await pathExists(join(repoDir, snapshot.name, basename(filePath)))) {
+            return true;
+        }
+    }
+    return false;
+}
+async function fastCacheStatus(items) {
+    return Promise.all(items.map(async (item) => {
+        const allowPatterns = normalizePatterns(item.allow_patterns);
+        const ignorePatterns = normalizePatterns(item.ignore_patterns);
+        if (item.model_type && LLAMA_CPP_MODEL_TYPES.has(item.model_type)) {
+            if (!item.path)
+                return { key: item.key, downloaded: false };
+            return {
+                key: item.key,
+                downloaded: await isLlamaCppModelCached(item.repo_id, item.path)
+            };
+        }
+        if (item.path) {
+            return {
+                key: item.key,
+                downloaded: await repoFileInCache(item.repo_id, item.path)
+            };
+        }
+        const files = await listRepoCachedFiles(item.repo_id);
+        return {
+            key: item.key,
+            downloaded: isDownloadedFromFiles(files, allowPatterns, ignorePatterns)
+        };
+    }));
+}
+export async function handleModelsApiRequest(request) {
+    const url = new URL(request.url);
+    const path = pathFromModelsPrefix(url.pathname);
+    const userId = request.headers.get("x-user-id") ?? "1";
+    if (path === "/providers") {
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        return jsonResponse(await getProvidersInfo(userId));
+    }
+    if (path === "/recommended") {
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        const checkServers = url.searchParams.get("check_servers") === "true";
+        return jsonResponse(await recommendedModels(checkServers));
+    }
+    if (path === "/recommended/image") {
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        return jsonResponse(selectRecommended("image"));
+    }
+    if (path === "/recommended/image/text-to-image") {
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        return jsonResponse(selectRecommended("image", "text_to_image"));
+    }
+    if (path === "/recommended/image/image-to-image") {
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        return jsonResponse(selectRecommended("image", "image_to_image"));
+    }
+    if (path === "/recommended/language") {
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        return jsonResponse(selectRecommended("language"));
+    }
+    if (path === "/recommended/language/text-generation") {
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        return jsonResponse(selectRecommended("language", "text_generation"));
+    }
+    if (path === "/recommended/language/embedding") {
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        return jsonResponse(selectRecommended("language", "embedding"));
+    }
+    if (path === "/recommended/asr") {
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        return jsonResponse(selectRecommended("asr"));
+    }
+    if (path === "/recommended/tts") {
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        return jsonResponse(selectRecommended("tts"));
+    }
+    if (path === "/recommended/video/text-to-video") {
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        return jsonResponse(selectRecommended("video", "text_to_video"));
+    }
+    if (path === "/recommended/video/image-to-video") {
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        return jsonResponse(selectRecommended("video", "image_to_video"));
+    }
+    if (path === "/all") {
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        return jsonResponse(await getAllModels(userId));
+    }
+    if (path === "/huggingface") {
+        if (request.method === "GET") {
+            if (isProduction())
+                return jsonResponse([]);
+            try {
+                const models = await readCachedHfModels();
+                return jsonResponse(models);
+            }
+            catch {
+                return jsonResponse([]);
+            }
+        }
+        if (request.method === "DELETE") {
+            const repoId = url.searchParams.get("repo_id");
+            if (!repoId)
+                return errorResponse(400, "Missing repo_id parameter");
+            if (isProduction())
+                return jsonResponse(false);
+            try {
+                const deleted = await deleteCachedHfModel(repoId);
+                return jsonResponse(deleted);
+            }
+            catch {
+                return jsonResponse(false);
+            }
+        }
+        return errorResponse(405, "Method not allowed");
+    }
+    if (path === "/huggingface/search") {
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        if (isProduction())
+            return jsonResponse([]);
+        const rawQuery = url.searchParams.get("query") ?? undefined;
+        const type = url.searchParams.get("type") ?? undefined;
+        // Wrap bare queries with wildcards so "whisper" matches "openai/whisper-small"
+        const query = rawQuery && !rawQuery.includes("*") ? `*${rawQuery}*` : rawQuery;
+        try {
+            const models = await searchCachedHfModels(query ? [query] : undefined, type ? [type] : undefined);
+            return jsonResponse(models);
+        }
+        catch {
+            return jsonResponse([]);
+        }
+    }
+    if (path.startsWith("/huggingface/type/")) {
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        const modelType = decodeURIComponent(path.slice("/huggingface/type/".length));
+        if (!modelType)
+            return jsonResponse([]);
+        try {
+            const models = await getModelsByHfType(modelType);
+            return jsonResponse(models);
+        }
+        catch {
+            return jsonResponse([]);
+        }
+    }
+    if (path === "/ollama") {
+        if (request.method === "DELETE") {
+            if (isProduction())
+                return jsonResponse(false);
+            return jsonResponse(false);
+        }
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        const models = await getLanguageModelsByProvider("ollama", userId);
+        return jsonResponse(models.map((model) => toOllamaModel(model)));
+    }
+    const llmProvider = parseProvider(path, "/llm/");
+    if (llmProvider) {
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        return jsonResponse(await getLanguageModelsByProvider(llmProvider, userId));
+    }
+    const imageProvider = parseProvider(path, "/image/");
+    if (imageProvider) {
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        return jsonResponse(await getImageModelsByProvider(imageProvider, userId));
+    }
+    if (path === "/tts") {
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        const availableIds = await getAvailableProviderIds(userId);
+        const providers = await Promise.all(availableIds.map((provider) => getTtsModelsByProvider(provider, userId)));
+        return jsonResponse(providers.flat());
+    }
+    const ttsProvider = parseProvider(path, "/tts/");
+    if (ttsProvider) {
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        return jsonResponse(await getTtsModelsByProvider(ttsProvider, userId));
+    }
+    const asrProvider = parseProvider(path, "/asr/");
+    if (asrProvider) {
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        return jsonResponse(await getAsrModelsByProvider(asrProvider, userId));
+    }
+    const videoProvider = parseProvider(path, "/video/");
+    if (videoProvider) {
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        return jsonResponse(await getVideoModelsByProvider(videoProvider, userId));
+    }
+    const embeddingProvider = parseProvider(path, "/embedding/");
+    if (embeddingProvider) {
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        return jsonResponse(await getEmbeddingModelsByProvider(embeddingProvider, userId));
+    }
+    if (path === "/ollama_model_info") {
+        if (request.method !== "GET")
+            return errorResponse(405, "Method not allowed");
+        return jsonResponse(null);
+    }
+    if (path === "/huggingface/try_cache_files") {
+        if (request.method !== "POST")
+            return errorResponse(405, "Method not allowed");
+        const body = await parseJsonBody(request);
+        if (!body)
+            return errorResponse(400, "Invalid JSON body");
+        const checked = await Promise.all(body.map(async (entry) => {
+            const repoId = entry.repo_id ?? "";
+            const repoPath = entry.path ?? "";
+            return {
+                repo_id: repoId,
+                path: repoPath,
+                downloaded: repoId.length > 0 && repoPath.length > 0
+                    ? await repoFileInCache(repoId, repoPath)
+                    : false
+            };
+        }));
+        return jsonResponse(checked);
+    }
+    if (path === "/huggingface/try_cache_repos") {
+        if (request.method !== "POST")
+            return errorResponse(405, "Method not allowed");
+        const body = await parseJsonBody(request);
+        if (!body)
+            return errorResponse(400, "Invalid JSON body");
+        const checked = await Promise.all(body.map(async (repoId) => ({
+            repo_id: repoId,
+            downloaded: await hasCachedFiles(repoId)
+        })));
+        return jsonResponse(checked);
+    }
+    if (path === "/huggingface/check_cache") {
+        if (request.method !== "POST")
+            return errorResponse(405, "Method not allowed");
+        const body = await parseJsonBody(request);
+        if (!body ||
+            typeof body.repo_id !== "string" ||
+            body.repo_id.length === 0) {
+            return errorResponse(400, "Invalid JSON body");
+        }
+        return jsonResponse(await checkHfCache(body));
+    }
+    if (path === "/huggingface/cache_status") {
+        if (request.method !== "POST")
+            return errorResponse(405, "Method not allowed");
+        const body = await parseJsonBody(request);
+        if (!body)
+            return errorResponse(400, "Invalid JSON body");
+        return jsonResponse(await fastCacheStatus(body));
+    }
+    if (path === "/pull_ollama_model") {
+        if (request.method !== "POST")
+            return errorResponse(405, "Method not allowed");
+        if (isProduction())
+            return errorResponse(503, {
+                status: "unavailable",
+                message: "Not available in production"
+            });
+        // Streaming Ollama model pulls require Server-Sent Events with progress deltas.
+        // The TS standalone server does not implement this streaming protocol yet.
+        // Clients should use the Python backend or manage Ollama pulls directly via the Ollama HTTP API.
+        return errorResponse(501, "Streaming Ollama model pulls are not available in the TS standalone server. Use the Ollama API directly or the Python backend.");
+    }
+    if (path === "/huggingface/file_info") {
+        if (request.method !== "POST")
+            return errorResponse(405, "Method not allowed");
+        if (isProduction())
+            return jsonResponse([]);
+        const body = await parseJsonBody(request);
+        if (!body)
+            return errorResponse(400, "Invalid JSON body");
+        try {
+            const { getSecret } = await import("@nodetool-ai/models");
+            const token = (await getSecret("HF_TOKEN", "1")) ?? undefined;
+            const infos = await getHuggingfaceFileInfos(body, token);
+            return jsonResponse(infos);
+        }
+        catch {
+            return jsonResponse([]);
+        }
+    }
+    return null;
+}
+export function toUnifiedModelsFromLanguage(models) {
+    return models.map((model) => toUnifiedModel(model, "language_model"));
+}
+//# sourceMappingURL=models-api.js.map