@nodetool-ai/websocket 0.8.1 → 0.8.3

package/dist/trpc/routers/models.d.ts

@@ -81,6 +81,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -97,6 +99,15 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
         }[];
         meta: object;
     }>;
+    /**
+     * Every ranked route as a `<provider>:<model_id>` key, best model first.
+     * The model menu orders an empty query with it.
+     */
+    rankedKeys: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: string[];
+        meta: object;
+    }>;
     recommendedImageTextToImage: import("@trpc/server").TRPCQueryProcedure<{
         input: void;
         output: {
@@ -140,6 +151,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -199,6 +212,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -258,6 +273,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -317,6 +334,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -376,6 +395,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -435,6 +456,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -494,6 +517,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -561,6 +586,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -623,6 +650,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -688,6 +717,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -765,6 +796,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -833,6 +866,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -898,6 +933,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -968,6 +1005,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -1037,6 +1076,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -1122,6 +1163,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -1201,6 +1244,71 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
+                } | null | undefined;
+            } | null | undefined;
+            execution?: {
+                kind: "api" | "local" | "server" | "unavailable";
+                state: "download_required" | "ready" | "unavailable";
+                label: "API" | "Local" | "Server" | "Unavailable";
+                reason?: string | null | undefined;
+                execution_site?: "nodetool_host" | "provider" | null | undefined;
+                runtime_name?: string | null | undefined;
+            } | null | undefined;
+            durations?: number[] | null | undefined;
+            resolutions?: string[] | null | undefined;
+            aspect_ratios?: string[] | null | undefined;
+        }[];
+        meta: object;
+    }>;
+    rerankByProvider: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            provider: string;
+        };
+        output: {
+            id: string;
+            type?: string | null | undefined;
+            name: string;
+            provider?: string | null | undefined;
+            repo_id?: string | null | undefined;
+            path?: string | null | undefined;
+            artifact_family?: string | null | undefined;
+            artifact_component?: string | null | undefined;
+            artifact_confidence?: number | null | undefined;
+            artifact_evidence?: string[] | null | undefined;
+            cache_path?: string | null | undefined;
+            allow_patterns?: string[] | null | undefined;
+            ignore_patterns?: string[] | null | undefined;
+            description?: string | null | undefined;
+            readme?: string | null | undefined;
+            downloaded?: boolean | null | undefined;
+            size_on_disk?: number | null | undefined;
+            pipeline_tag?: string | null | undefined;
+            tags?: string[] | null | undefined;
+            has_model_index?: boolean | null | undefined;
+            downloads?: number | null | undefined;
+            likes?: number | null | undefined;
+            supported_tasks?: string[] | null | undefined;
+            trending_score?: number | null | undefined;
+            image?: string | null | undefined;
+            supports_tools?: boolean | null | undefined;
+            voices?: string[] | null | undefined;
+            capabilities?: string[] | null | undefined;
+            languages?: string[] | null | undefined;
+            sample_rate?: number | null | undefined;
+            requires_reference_text?: boolean | null | undefined;
+            adapter?: {
+                state: "installed" | "missing_dependency" | "unknown";
+                reason_code?: string | null | undefined;
+                reason?: string | null | undefined;
+                artifact_ref?: {
+                    source: "huggingface";
+                    repo_id: string;
+                    revision?: string | null | undefined;
+                    path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -1260,6 +1368,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -1321,6 +1431,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -1380,6 +1492,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -1441,6 +1555,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -1500,6 +1616,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -1561,6 +1679,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -1620,6 +1740,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -1681,6 +1803,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -1740,6 +1864,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -1801,6 +1927,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {
@@ -1862,6 +1990,8 @@ export declare const modelsRouter: import("@trpc/server").TRPCBuiltRouter<{
                     repo_id: string;
                     revision?: string | null | undefined;
                     path?: string | null | undefined;
+                    allow_patterns?: string[] | null | undefined;
+                    model_type?: string | null | undefined;
                 } | null | undefined;
             } | null | undefined;
             execution?: {

package/dist/trpc/routers/models.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../../src/trpc/routers/models.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../../src/trpc/routers/models.ts"],"names":[],"mappings":"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"}

package/dist/trpc/routers/models.js

@@ -1,21 +1,22 @@
 import { router } from "../index.js";
 import { protectedProcedure } from "../middleware.js";
 import { TRPCError } from "@trpc/server";
-import { createLogger } from "@nodetool-ai/config";
-import { getProvider, getRegisteredProvider, isProviderConfigured, listRegisteredProviderIds, RECOMMENDED_MODELS, OLLAMA_DEFAULT_URL, OllamaProvider, LMSTUDIO_DEFAULT_URL } from "@nodetool-ai/runtime";
+import { createLogger, getHfHubCacheDir } from "@nodetool-ai/config";
+import { discoverASRModels, discoverVadModels } from "@nodetool-ai/whisper-cpp";
+import { getProvider, getRegisteredProvider, imageModelTasks, isProviderConfigured, listRegisteredProviderIds, RECOMMENDED_MODELS, OLLAMA_DEFAULT_URL, OllamaProvider, LMSTUDIO_DEFAULT_URL } from "@nodetool-ai/runtime";
 import { getSecret as getStoredSecret } from "@nodetool-ai/models";
 import { syncCustomProviderRegistry } from "../../custom-providers.js";
 function secretResolverFor(userId) {
     return (key) => getStoredSecret(key, userId).then((v) => v ?? undefined);
 }
 const log = createLogger("nodetool.websocket.trpc.models");
-import { readCachedHfModels, searchCachedHfModels, getModelsByHfType, filterModelsByHfType, deleteCachedHfModel } from "@nodetool-ai/huggingface";
+import { readCachedHfModels, searchCachedHfModels, getModelsByHfType, filterModelsByHfType, deleteCachedHfModel, isLlamaCppModelCached as isFlatLlamaCppModelCached } from "@nodetool-ai/huggingface";
 import { getTransformersJsCacheDir, recommendedFor, scanTransformersJsCache, TJS_MODEL_TYPES } from "@nodetool-ai/transformers-js-nodes";
 import { MODEL_SEARCH_KINDS } from "@nodetool-ai/protocol";
+import { rankedModelKeys } from "../../models-api.js";
 import { access, readdir } from "node:fs/promises";
 import { constants as fsConstants } from "node:fs";
-import { homedir } from "node:os";
-import { basename, join, resolve, sep } from "node:path";
+import { join, resolve, sep } from "node:path";
 import { z } from "zod";
 import { isString } from "../../lib/wire-values.js";
 import { readyProviderExecution, resolveModelExecutionAvailability } from "../../model-execution-availability.js";
@@ -23,7 +24,9 @@ const modelArtifactRefSchema = z.object({
     source: z.literal("huggingface"),
     repo_id: z.string(),
     revision: z.string().nullish(),
-    path: z.string().nullish()
+    path: z.string().nullish(),
+    allow_patterns: z.array(z.string()).nullish(),
+    model_type: z.string().nullish()
 });
 const modelAdapterInfoSchema = z.object({
     state: z.enum(["installed", "missing_dependency", "unknown"]),
@@ -251,10 +254,7 @@ function isDownloadedFromFiles(files, allowPatterns, 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");
+    return getHfHubCacheDir();
 }
 function repoToCacheDir(repoId) {
     return `models--${repoId.replaceAll("/", "--")}`;
@@ -320,30 +320,14 @@ async function listRepoCachedFiles(repoId) {
     }
     return [...collected];
 }
+/** A GGUF is downloaded when it is in the HF hub cache (the `llama_cpp_model`
+ * download path) or in llama.cpp's flat cache (the `llama_cpp` download path,
+ * which writes `{org}_{repo}_{file}` to {@link getLlamaCppCacheDir}). */
 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;
-        const snapshotDir = join(repoDir, snapshot.name);
-        const full = safeJoinWithin(snapshotDir, filePath);
-        if (full && (await pathExists(full))) {
-            return true;
-        }
-        // basename() strips any traversal segments, so this join stays contained.
-        if (await pathExists(join(snapshotDir, basename(filePath)))) {
-            return true;
-        }
-    }
-    return false;
+    return isFlatLlamaCppModelCached(repoId, filePath);
 }
 export async function getAvailableProviderIds(userId) {
     const ids = listRegisteredProviderIds();
@@ -474,8 +458,25 @@ async function serverAllowsModel(model, servers, userId) {
         return await isProviderConfigured(model.provider, secretResolverFor(userId));
     return true;
 }
+async function withWhisperDownloadStatus(models, userId) {
+    const modelsDir = await secretResolverFor(userId)("WHISPER_CPP_MODELS_DIR");
+    const whisperFiles = new Map((await Promise.all([
+        discoverASRModels(modelsDir),
+        discoverVadModels(modelsDir)
+    ]))
+        .flat()
+        .map((model) => [model.id.split(/[\\/]/).at(-1), model.id]));
+    return Promise.all(models.map(async (model) => model.provider === "whisper_cpp" && model.repo_id && model.path
+        ? {
+            ...model,
+            id: whisperFiles.get(model.path) ?? model.id,
+            downloaded: whisperFiles.has(model.path) ||
+                (await repoFileInCache(model.repo_id, model.path))
+        }
+        : model));
+}
 async function getRecommendedModels(checkServers, userId) {
-    const models = [...RECOMMENDED_MODELS];
+    const models = await withWhisperDownloadStatus([...RECOMMENDED_MODELS], userId);
     if (!checkServers)
         return models;
     const servers = await getServerAvailability(userId);
@@ -602,7 +603,10 @@ function toUnifiedModel(model, type) {
         provider: model.provider,
         repo_id: null,
         path: null,
-        downloaded: model.provider === "ollama" || model.provider === "llama_cpp",
+        downloaded: model.provider === "ollama" ||
+            model.provider === "llama_cpp" ||
+            model.provider === "whisper_cpp" ||
+            model.provider === "whisper_cpp_server",
         tags: [model.provider],
         voices: model.voices ?? null,
         capabilities: model.capabilities ?? null,
@@ -619,12 +623,16 @@ function toUnifiedModel(model, type) {
                         source: model.adapter.artifactRef.source,
                         repo_id: model.adapter.artifactRef.repoId,
                         revision: model.adapter.artifactRef.revision ?? null,
-                        path: model.adapter.artifactRef.path ?? null
+                        path: model.adapter.artifactRef.path ?? null,
+                        allow_patterns: model.adapter.artifactRef.allowPatterns ?? null,
+                        model_type: model.adapter.artifactRef.modelType ?? null
                     }
                     : null
             }
             : null,
-        supported_tasks: model.supportedTasks ?? null,
+        supported_tasks: (type === "image_model"
+            ? imageModelTasks(model)
+            : model.supportedTasks) ?? null,
         durations: model.durations ?? null,
         resolutions: model.resolutions ?? null,
         aspect_ratios: model.aspectRatios ?? null,
@@ -669,11 +677,20 @@ async function resolveProviderModelExecution(models, configuredProviderIds) {
     catch {
         // A failed cache scan means local adapters remain download-required.
     }
+    if (models.some((model) => model.adapter?.artifact_ref?.model_type?.startsWith("tjs."))) {
+        try {
+            const cached = await scanTransformersJsCache(getTransformersJsCacheDir());
+            cachedModels.push(...cached.map((c) => tjsRefToUnified({ repo_id: c.repo_id }, "tjs.cached", true, c.size_bytes)));
+        }
+        catch {
+            // Transformers.js adapters remain download-required.
+        }
+    }
     return resolveModelExecutionAvailability([...models, ...cachedModels], providerExecutionMap(configuredProviderIds)).slice(0, models.length);
 }
 export async function getAllModels(userId) {
     const all = [];
-    all.push(...RECOMMENDED_MODELS);
+    all.push(...(await getRecommendedModels(false, userId)));
     const availableIds = await getAvailableProviderIds(userId);
     const providerModelsPromises = availableIds.map(async (providerId) => {
         try {
@@ -848,7 +865,9 @@ function curatedForKind(kind) {
     const taskRequired = kind !== "text_to_speech" &&
         kind !== "speech_to_text" &&
         kind !== "text_to_music";
-    return RECOMMENDED_MODELS.filter((r) => r.modality === modality && (!taskRequired || r.task === kind));
+    return RECOMMENDED_MODELS.filter((r) => r.modality === modality &&
+        r.type !== "hf.whisper_cpp_vad" &&
+        (!taskRequired || r.task === kind));
 }
 // ── Router ─────────────────────────────────────────────────────────
 export const modelsRouter = router({
@@ -892,6 +911,13 @@ export const modelsRouter = router({
         .query(async ({ input, ctx }) => {
         return getRecommendedModels(input.check_servers ?? false, ctx.userId);
     }),
+    /**
+     * Every ranked route as a `<provider>:<model_id>` key, best model first.
+     * The model menu orders an empty query with it.
+     */
+    rankedKeys: protectedProcedure
+        .output(z.array(z.string()))
+        .query(() => rankedModelKeys()),
     recommendedImageTextToImage: protectedProcedure
         .output(modelsListOutput)
         .query(() => selectRecommended("image", "text_to_image")),
@@ -901,9 +927,7 @@ export const modelsRouter = router({
     recommendedLanguageEmbedding: protectedProcedure
         .output(modelsListOutput)
         .query(() => selectRecommended("language", "embedding")),
-    recommendedAsr: protectedProcedure
-        .output(modelsListOutput)
-        .query(() => selectRecommended("asr")),
+    recommendedAsr: protectedProcedure.output(modelsListOutput).query(({ ctx }) => withWhisperDownloadStatus(selectRecommended("asr").filter((model) => model.type !== "hf.whisper_cpp_vad"), ctx.userId)),
     recommendedTts: protectedProcedure
         .output(modelsListOutput)
         .query(() => selectRecommended("tts")),
@@ -1029,6 +1053,9 @@ export const modelsRouter = router({
             const cached = (await bridge.listCachedModels());
             return filterModelsByHfType(cached, input.model_type);
         }
+        // Scans the server's own HuggingFace cache, like huggingfaceList.
+        if (isProduction())
+            return [];
         try {
             return await getModelsByHfType(input.model_type);
         }
@@ -1170,13 +1197,33 @@ export const modelsRouter = router({
     imageByProvider: protectedProcedure
         .input(providerInput)
         .output(modelsListOutput)
-        .query(async ({ ctx, input }) => safeProviderCall("imageByProvider", { provider: input.provider, userId: ctx.userId }, async () => {
-        const instance = await instantiateProvider(input.provider, ctx.userId);
-        if (!instance)
-            return [];
-        const models = await instance.getAvailableImageModels();
-        return models.map((m) => toUnifiedModel(m, "image_model"));
-    }, [])),
+        .query(async ({ ctx, input }) => {
+        const models = await safeProviderCall("imageByProvider", { provider: input.provider, userId: ctx.userId }, async () => {
+            const instance = await instantiateProvider(input.provider, ctx.userId);
+            if (!instance)
+                return [];
+            const models = await instance.getAvailableImageModels();
+            return models.map((m) => toUnifiedModel(m, "image_model"));
+        }, []);
+        // Only a local model has files to download. Remote catalogs keep the
+        // execution state that toUnifiedModel gave them.
+        return models.some((model) => model.adapter)
+            ? resolveProviderModelExecution(models, [input.provider])
+            : models;
+    }),
+    rerankByProvider: protectedProcedure
+        .input(providerInput)
+        .output(modelsListOutput)
+        .query(async ({ ctx, input }) => {
+        const models = await safeProviderCall("rerankByProvider", { provider: input.provider, userId: ctx.userId }, async () => {
+            const instance = await instantiateProvider(input.provider, ctx.userId);
+            if (!instance)
+                return [];
+            const models = await instance.getAvailableRerankModels();
+            return models.map((m) => toUnifiedModel(m, "rerank_model"));
+        }, []);
+        return resolveProviderModelExecution(models, [input.provider]);
+    }),
     tts: protectedProcedure.output(modelsListOutput).query(async ({ ctx }) => {
         const availableIds = await getAvailableProviderIds(ctx.userId);
         const results = await Promise.all(availableIds.map((providerId) => safeProviderCall("tts (aggregate)", { provider: providerId, userId: ctx.userId }, async () => {
@@ -1254,18 +1301,21 @@ export const modelsRouter = router({
             const models = await instance.getAvailableASRModels();
             return models.map((m) => toUnifiedModel(m, "asr_model"));
         }, [])));
-        return results.flat();
+        return resolveProviderModelExecution(results.flat(), availableIds);
     }),
     asrByProvider: protectedProcedure
         .input(providerInput)
         .output(modelsListOutput)
-        .query(async ({ ctx, input }) => safeProviderCall("asrByProvider", { provider: input.provider, userId: ctx.userId }, async () => {
-        const instance = await instantiateProvider(input.provider, ctx.userId);
-        if (!instance)
-            return [];
-        const models = await instance.getAvailableASRModels();
-        return models.map((m) => toUnifiedModel(m, "asr_model"));
-    }, [])),
+        .query(async ({ ctx, input }) => {
+        const models = await safeProviderCall("asrByProvider", { provider: input.provider, userId: ctx.userId }, async () => {
+            const instance = await instantiateProvider(input.provider, ctx.userId);
+            if (!instance)
+                return [];
+            const models = await instance.getAvailableASRModels();
+            return models.map((m) => toUnifiedModel(m, "asr_model"));
+        }, []);
+        return resolveProviderModelExecution(models, [input.provider]);
+    }),
     video: protectedProcedure.output(modelsListOutput).query(async ({ ctx }) => {
         const availableIds = await getAvailableProviderIds(ctx.userId);
         const results = await Promise.all(availableIds.map((providerId) => safeProviderCall("video (aggregate)", { provider: providerId, userId: ctx.userId }, async () => {
@@ -1290,13 +1340,16 @@ export const modelsRouter = router({
     embeddingByProvider: protectedProcedure
         .input(providerInput)
         .output(modelsListOutput)
-        .query(async ({ ctx, input }) => safeProviderCall("embeddingByProvider", { provider: input.provider, userId: ctx.userId }, async () => {
-        const instance = await instantiateProvider(input.provider, ctx.userId);
-        if (!instance)
-            return [];
-        const models = await instance.getAvailableEmbeddingModels();
-        return models.map((m) => toUnifiedModel(m, "embedding_model"));
-    }, [])),
+        .query(async ({ ctx, input }) => {
+        const models = await safeProviderCall("embeddingByProvider", { provider: input.provider, userId: ctx.userId }, async () => {
+            const instance = await instantiateProvider(input.provider, ctx.userId);
+            if (!instance)
+                return [];
+            const models = await instance.getAvailableEmbeddingModels();
+            return models.map((m) => toUnifiedModel(m, "embedding_model"));
+        }, []);
+        return resolveProviderModelExecution(models, [input.provider]);
+    }),
     /**
      * Fast batch cache status check for multiple models.
      */
@@ -1304,6 +1357,11 @@ export const modelsRouter = router({
         .input(hfFastCacheStatusInput)
         .output(hfFastCacheStatusOutput)
         .mutation(async ({ input }) => {
+        // The caches it probes are the server's, which production never offers
+        // to its users.
+        if (isProduction()) {
+            return input.map((item) => ({ key: item.key, downloaded: false }));
+        }
         return Promise.all(input.map(async (item) => {
             const allowPatterns = normalizePatterns(item.allow_patterns);
             const ignorePatterns = normalizePatterns(item.ignore_patterns);