@nodetool-ai/websocket 0.7.0-rc.22 → 0.8.1

package/dist/models-api.js

@@ -1,173 +1,7 @@
-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";
+import { getSecret as getStoredSecret } from "@nodetool-ai/models";
+import { listRegisteredProviderIds, PythonProvider, registerProvider } from "@nodetool-ai/runtime";
+import { resolveWorkerHfToken } from "@nodetool-ai/huggingface";
+import { modelRankings, rankedForTask } from "@nodetool-ai/model-pricing";
 /**
  * Register Python-only providers (HuggingFace Local, MLX) discovered
  * via the Python stdio bridge. Call after the bridge has connected.
@@ -176,555 +10,191 @@ export async function registerPythonProviders(bridge) {
     const providers = await bridge.listProviders();
     const registered = [];
     for (const info of providers) {
-        if (listRegisteredProviderIds().includes(info.id))
+        const existingIds = listRegisteredProviderIds();
+        // The TypeScript runtime already owns `huggingface` for the hosted
+        // Inference API, while the Python worker uses the same id for local model
+        // execution. Keep both available under stable public ids and retain the
+        // worker id separately for bridge calls.
+        const publicId = info.id === "huggingface" && existingIds.includes(info.id)
+            ? "huggingface-local"
+            : info.id;
+        if (existingIds.includes(publicId))
             continue;
         const secrets = {};
-        registerProvider(info.id, PythonProvider, {
+        registerProvider(publicId, PythonProvider, {
             _bridge: bridge,
-            _id: info.id,
+            _id: publicId,
+            _bridgeProviderId: info.id,
+            _capabilities: info.capabilities,
             ...secrets
+        }, {}, {
+            access: info.access ?? "in_process",
+            displayName: info.display_name ?? publicId
         });
-        registered.push(info.id);
+        registered.push(publicId);
     }
     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)
+/**
+ * The `type` a merged entry carries, by task — the same value the hand-pinned
+ * RECOMMENDED_MODELS entries of that task carry. A task absent from this table
+ * has no ranked surface here, so the merge is a no-op for it.
+ */
+const RANKED_TASK_MODEL_TYPE = {
+    text_to_image: "image_model",
+    image_to_image: "image_model",
+    text_to_video: "video_model",
+    image_to_video: "video_model",
+    video_to_video: "video_model",
+    reference_to_video: "video_model",
+    text_to_speech: "tts_model",
+    text_to_music: "music_model"
+};
+/**
+ * Append the ranked leaderboard for one task to the hand-pinned entries that
+ * already answer an endpoint. RECOMMENDED_MODELS is the override list: its
+ * entries keep their order and always come first; ranked models follow, best
+ * rank first.
+ *
+ * One entry per canonical model, taking its first route — a model reachable
+ * through FAL and kie is one row, not two. A canonical model any of whose
+ * routes is already pinned is skipped, so an override is never duplicated by
+ * the leaderboard.
+ *
+ * An empty artifact returns `base` unchanged, which is the shipped state until
+ * the rankings sync writes a snapshot.
+ */
+export function mergeRankedRecommendations(base, task, artifact = modelRankings) {
+    const type = RANKED_TASK_MODEL_TYPE[task];
+    if (!type)
+        return base;
+    const seen = new Set(base.map((model) => `${model.provider ?? ""}::${model.id}`));
+    const merged = [...base];
+    for (const entry of rankedForTask(task, artifact)) {
+        const keys = entry.routes.map((route) => `${route.provider}::${route.modelId}`);
+        if (keys.some((key) => seen.has(key)))
             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);
+        const route = entry.routes[0];
+        if (!route)
+            continue;
+        for (const key of keys) {
+            seen.add(key);
         }
+        merged.push({
+            id: route.modelId,
+            type,
+            name: entry.name,
+            repo_id: null,
+            path: null,
+            downloaded: false,
+            provider: route.provider
+        });
     }
-    return filtered;
-}
-function selectRecommended(modality, task) {
-    return RECOMMENDED_MODELS.filter((model) => model.modality === modality && (!task || model.task === task));
+    return merged;
 }
-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()) {
+/**
+ * Relay a worker-scoped model download: forward each bridge `progress` frame
+ * onto the /ws/download socket using the same JSON shape the local download
+ * manager emits, so the web ModelDownloadStore consumes it unchanged.
+ *
+ * No attached worker (or an image too old for `models.*`) yields an `error`
+ * progress frame instead. A mid-download failure (e.g. the worker detaching)
+ * surfaces as an `error` frame too.
+ *
+ * `requestId` is the stable cancel key: it must match the id the web sends in
+ * `cancel_download` (`path ? repo_id + "/" + path : repo_id`) so the bridge can
+ * correlate a later `cancelModelDownload(requestId)` to this download. The
+ * default reproduces that composite so callers that don't track cancellation
+ * still get a sensible, matching id.
+ */
+export async function relayWorkerDownload(socket, bridge, workerManager, msg, requestId = msg.path
+    ? `${msg.repo_id ?? ""}/${msg.path}`
+    : (msg.repo_id ?? ""), userId = "1") {
+    const repoId = msg.repo_id ?? "";
+    // The worker already emits a terminal `error`-status progress frame on
+    // failure (forwarded verbatim below); track it so the catch doesn't send a
+    // second, redundant error frame.
+    let sawError = false;
+    const fail = (error) => {
         try {
-            const hfModels = await readCachedHfModels();
-            all.push(...hfModels);
+            socket.send(JSON.stringify({
+                status: "error",
+                repo_id: repoId,
+                path: msg.path ?? null,
+                model_type: msg.model_type ?? null,
+                downloaded_bytes: 0,
+                total_bytes: 0,
+                downloaded_files: 0,
+                current_files: [],
+                total_files: 0,
+                error
+            }));
         }
         catch {
-            // HF models unavailable — continue without them
+            /* socket gone */
         }
-    }
-    return dedupeModels(all);
-}
-async function parseJsonBody(request) {
-    const contentType = request.headers.get("content-type") ?? "";
-    if (!contentType.toLowerCase().includes("application/json")) {
-        return null;
-    }
+    };
+    if (!workerManager) {
+        fail("Worker support is not configured on this server");
+        return;
+    }
+    const active = await workerManager.getActiveWorker();
+    if (!active) {
+        fail("No worker attached");
+        return;
+    }
+    if (!bridge || !bridge.supportsModelManagement()) {
+        fail("This worker's image is too old for model management.");
+        return;
+    }
+    // The worker has no HuggingFace credential of its own, so a gated repo 401s
+    // unless this server supplies one. Resolved here, never taken from `msg` —
+    // that JSON comes from the client.
+    const token = await resolveWorkerHfToken((key) => getStoredSecret(key, userId));
     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);
+        const onProgress = (update) => {
+            if (update.status === "error") {
+                sawError = true;
             }
-        }
-    }
-    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);
+                socket.send(JSON.stringify(update));
             }
             catch {
-                return jsonResponse([]);
+                /* socket gone */
             }
-        }
-        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);
+        };
+        if (msg.backend) {
+            if (!msg.model_type) {
+                fail("A model_type is required for worker model preparation");
+                return;
             }
-            catch {
-                return jsonResponse(false);
+            if (!bridge.supportsModelPreparation(msg.backend)) {
+                fail(`Worker does not provide model preparation backend: ${msg.backend}`);
+                return;
             }
+            await bridge.prepareModel({
+                backend: msg.backend,
+                model_type: msg.model_type,
+                repo_id: repoId,
+                token
+            }, onProgress, requestId);
         }
-        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 {
+        else {
+            await bridge.downloadModel({
                 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");
+                path: msg.path ?? null,
+                allow_patterns: msg.allow_patterns ?? null,
+                ignore_patterns: msg.ignore_patterns ?? null,
+                model_type: msg.model_type ?? null,
+                token
+            }, onProgress, requestId);
         }
-        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([]);
+    catch (err) {
+        // Suppress the redundant error frame if the worker already forwarded one.
+        if (!sawError) {
+            fail(err instanceof Error ? err.message : String(err));
         }
     }
-    return null;
-}
-export function toUnifiedModelsFromLanguage(models) {
-    return models.map((model) => toUnifiedModel(model, "language_model"));
 }
 //# sourceMappingURL=models-api.js.map