@nodetool-ai/websocket 0.7.0-rc.23 → 0.8.2

package/dist/trpc/routers/models.js

@@ -1,17 +1,48 @@
 import { router } from "../index.js";
 import { protectedProcedure } from "../middleware.js";
+import { TRPCError } from "@trpc/server";
 import { createLogger } from "@nodetool-ai/config";
-import { getProvider, isProviderConfigured, listRegisteredProviderIds, providerCapabilities, RECOMMENDED_MODELS } from "@nodetool-ai/runtime";
+import { discoverASRModels, discoverVadModels } from "@nodetool-ai/whisper-cpp";
+import { getProvider, getRegisteredProvider, 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, deleteCachedHfModel, getHuggingfaceFileInfos } from "@nodetool-ai/huggingface";
-import { getTransformersJsCacheDir, isRepoCached, recommendedFor, scanTransformersJsCache, TJS_MODEL_TYPES } from "@nodetool-ai/transformers-js-nodes";
+import { readCachedHfModels, searchCachedHfModels, getModelsByHfType, filterModelsByHfType, deleteCachedHfModel } 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 } from "node:path";
+import { basename, join, resolve, sep } from "node:path";
 import { z } from "zod";
-import { getSecret } from "@nodetool-ai/models";
+import { isString } from "../../lib/wire-values.js";
+import { readyProviderExecution, resolveModelExecutionAvailability } from "../../model-execution-availability.js";
+const modelArtifactRefSchema = z.object({
+    source: z.literal("huggingface"),
+    repo_id: z.string(),
+    revision: 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"]),
+    reason_code: z.string().nullish(),
+    reason: z.string().nullish(),
+    artifact_ref: modelArtifactRefSchema.nullish()
+});
+const modelExecutionAvailabilitySchema = z.object({
+    kind: z.enum(["local", "server", "api", "unavailable"]),
+    state: z.enum(["ready", "download_required", "unavailable"]),
+    label: z.enum(["Local", "Server", "API", "Unavailable"]),
+    reason: z.string().nullish(),
+    execution_site: z.enum(["nodetool_host", "provider"]).nullish(),
+    runtime_name: z.string().nullish()
+});
 // ── Local schemas (mirrored in packages/protocol/src/api-schemas/models.ts) ──
 // Mirrors UnifiedModel in @nodetool-ai/protocol. Any field omitted here is
 // stripped by the tRPC output validator — which is exactly how the `provider`
@@ -43,33 +74,27 @@ const unifiedModelSchema = z.object({
     trending_score: z.number().nullish(),
     image: z.string().nullish(),
     supports_tools: z.boolean().nullish(),
-    voices: z.array(z.string()).nullish()
+    voices: z.array(z.string()).nullish(),
+    capabilities: z.array(z.string()).nullish(),
+    languages: z.array(z.string()).nullish(),
+    sample_rate: z.number().nullish(),
+    requires_reference_text: z.boolean().nullish(),
+    adapter: modelAdapterInfoSchema.nullish(),
+    execution: modelExecutionAvailabilitySchema.nullish(),
+    durations: z.array(z.number()).nullish(),
+    resolutions: z.array(z.string()).nullish(),
+    aspect_ratios: z.array(z.string()).nullish()
 });
 const modelsListOutput = z.array(unifiedModelSchema);
 const providersOutput = z.array(z.object({
     provider: z.string(),
-    capabilities: z.array(z.string())
+    capabilities: z.array(z.string()),
+    access: z.enum(["in_process", "local_service", "remote_api"]).optional(),
+    display_name: z.string().optional()
 }));
 const recommendedInput = z.object({
     check_servers: z.boolean().optional().default(false)
 });
-const hfCacheCheckInput = z.object({
-    repo_id: z.string().min(1),
-    allow_pattern: z
-        .union([z.string(), z.array(z.string())])
-        .nullable()
-        .optional(),
-    ignore_pattern: z
-        .union([z.string(), z.array(z.string())])
-        .nullable()
-        .optional()
-});
-const hfCacheCheckOutput = z.object({
-    repo_id: z.string(),
-    all_present: z.boolean(),
-    total_files: z.number(),
-    missing: z.array(z.string())
-});
 const hfFastCacheStatusItem = z.object({
     key: z.string(),
     repo_id: z.string(),
@@ -89,28 +114,18 @@ const hfFastCacheStatusOutput = z.array(z.object({
     key: z.string(),
     downloaded: z.boolean()
 }));
-const tryCacheFilesInput = z.array(z.object({
-    repo_id: z.string().optional(),
-    path: z.string().optional()
-}));
-const tryCacheFilesOutput = z.array(z.object({
-    repo_id: z.string(),
-    path: z.string(),
-    downloaded: z.boolean()
-}));
-const tryCacheReposInput = z.array(z.string());
-const tryCacheReposOutput = z.array(z.object({
-    repo_id: z.string(),
-    downloaded: z.boolean()
-}));
-const hfFileInfoInput = z.array(z.object({
-    repo_id: z.string(),
-    path: z.string()
-}));
 const hfSearchInput = z.object({
     query: z.string().optional(),
     type: z.string().optional()
 });
+const hfHubSearchInput = z.object({
+    /** Free-text search passed to the Hub's `search` param. */
+    query: z.string().optional(),
+    /** HF pipeline tag filter, e.g. "audio-text-to-text". */
+    pipeline_tag: z.string().optional(),
+    /** Max results (Hub caps high; we keep it modest for the UI). */
+    limit: z.number().int().min(1).max(100).optional()
+});
 const hfByTypeInput = z.object({
     model_type: z.string().min(1)
 });
@@ -120,6 +135,33 @@ const tjsByTypeInput = z.object({
 const hfDeleteInput = z.object({
     repo_id: z.string().min(1)
 });
+/** Where a model route operates: the local cache (default) or an attached worker. */
+const modelScope = z.enum(["local", "worker"]).default("local");
+/**
+ * Resolve the worker bridge for a `scope: "worker"` request. Requires an
+ * attached worker whose image speaks the `models.*` bridge protocol; throws a
+ * CONFLICT otherwise so the UI can surface a clear reason.
+ */
+async function requireWorkerBridge(ctx) {
+    if (!ctx.workerManager) {
+        // Server wiring problem, not a runtime state the client can act on.
+        throw new TRPCError({
+            code: "INTERNAL_SERVER_ERROR",
+            message: "Worker support is not configured on this server"
+        });
+    }
+    const active = await ctx.workerManager.getActiveWorker();
+    if (!active) {
+        throw new TRPCError({ code: "CONFLICT", message: "No worker attached" });
+    }
+    if (!ctx.pythonBridge.supportsModelManagement()) {
+        throw new TRPCError({
+            code: "CONFLICT",
+            message: "This worker's image is too old for model management. Upgrade the worker image."
+        });
+    }
+    return ctx.pythonBridge;
+}
 const ollamaModelSchema = z.object({
     type: z.string(),
     name: z.string(),
@@ -150,7 +192,7 @@ function dedupeModels(models) {
     const seen = new Set();
     const deduped = [];
     for (const model of models) {
-        const key = `${model.repo_id ?? ""}::${model.path ?? ""}`;
+        const key = `${model.provider ?? ""}::${model.repo_id ?? model.id ?? ""}::${model.path ?? ""}`;
         if (!seen.has(key)) {
             seen.add(key);
             deduped.push(model);
@@ -161,18 +203,43 @@ function dedupeModels(models) {
 function normalizePatterns(patterns) {
     if (patterns == null)
         return null;
-    if (typeof patterns === "string")
+    if (isString(patterns))
         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);
+// Linear (two-pointer) glob matcher. `*` matches any run of characters, `?`
+// matches a single character; all other characters are literal. This avoids
+// the catastrophic backtracking of a naive `*` -> `.*` regex compiled from
+// client-supplied patterns (ReDoS), while matching the same glob semantics.
+// Exported for regression tests.
+export function matchesPattern(value, pattern) {
+    let v = 0;
+    let p = 0;
+    let starIdx = -1;
+    let matchIdx = 0;
+    while (v < value.length) {
+        if (p < pattern.length && (pattern[p] === "?" || pattern[p] === value[v])) {
+            v++;
+            p++;
+        }
+        else if (p < pattern.length && pattern[p] === "*") {
+            starIdx = p;
+            matchIdx = v;
+            p++;
+        }
+        else if (starIdx !== -1) {
+            p = starIdx + 1;
+            matchIdx++;
+            v = matchIdx;
+        }
+        else {
+            return false;
+        }
+    }
+    while (p < pattern.length && pattern[p] === "*")
+        p++;
+    return p === pattern.length;
 }
 function isIgnored(path, ignorePatterns) {
     if (!ignorePatterns || ignorePatterns.length === 0)
@@ -205,6 +272,19 @@ async function pathExists(path) {
         return false;
     }
 }
+// Joins a client-supplied relative path under `baseDir` and rejects any result
+// that escapes the base directory (via `..` segments or an absolute path).
+// Returns null when the path would escape — callers treat that as "not found"
+// so a traversal attempt can't be used as a filesystem existence oracle.
+// Exported for regression tests.
+export function safeJoinWithin(baseDir, relativePath) {
+    const resolvedBase = resolve(baseDir);
+    const full = resolve(resolvedBase, relativePath);
+    if (full !== resolvedBase && !full.startsWith(resolvedBase + sep)) {
+        return null;
+    }
+    return full;
+}
 async function listSnapshotDirs(repoId) {
     const snapshotsRoot = join(getHfCacheRoot(), repoToCacheDir(repoId), "snapshots");
     if (!(await pathExists(snapshotsRoot)))
@@ -216,12 +296,11 @@ async function listSnapshotDirs(repoId) {
 }
 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;
+    const checks = await Promise.all(snapshotDirs.map((snapshotDir) => {
+        const full = safeJoinWithin(snapshotDir, relativePath);
+        return full ? pathExists(full) : Promise.resolve(false);
+    }));
+    return checks.some((exists) => exists);
 }
 async function listRepoCachedFiles(repoId) {
     const snapshotDirs = await listSnapshotDirs(repoId);
@@ -245,9 +324,6 @@ async function listRepoCachedFiles(repoId) {
     }
     return [...collected];
 }
-async function hasCachedFiles(repoId) {
-    return (await listRepoCachedFiles(repoId)).length > 0;
-}
 async function isLlamaCppModelCached(repoId, filePath) {
     if (await repoFileInCache(repoId, filePath)) {
         return true;
@@ -261,30 +337,35 @@ async function isLlamaCppModelCached(repoId, filePath) {
     for (const snapshot of snapshots) {
         if (!snapshot.isDirectory())
             continue;
-        if (await pathExists(join(repoDir, snapshot.name, filePath))) {
+        const snapshotDir = join(repoDir, snapshot.name);
+        const full = safeJoinWithin(snapshotDir, filePath);
+        if (full && (await pathExists(full))) {
             return true;
         }
-        if (await pathExists(join(repoDir, snapshot.name, basename(filePath)))) {
+        // basename() strips any traversal segments, so this join stays contained.
+        if (await pathExists(join(snapshotDir, basename(filePath)))) {
             return true;
         }
     }
     return false;
 }
-async function getAvailableProviderIds(userId) {
+export async function getAvailableProviderIds(userId) {
     const ids = listRegisteredProviderIds();
+    const getSecret = secretResolverFor(userId);
     const checks = await Promise.all(ids.map(async (id) => ({
         id,
-        available: await isProviderConfigured(id, userId)
+        available: await isProviderConfigured(id, getSecret)
     })));
     return checks.filter((c) => c.available).map((c) => c.id);
 }
 async function instantiateProvider(provider, userId) {
-    if (!(await isProviderConfigured(provider, userId))) {
+    const getSecret = secretResolverFor(userId);
+    if (!(await isProviderConfigured(provider, getSecret))) {
         log.debug("Provider not configured", { provider, userId });
         return null;
     }
     try {
-        return await getProvider(provider, userId);
+        return await getProvider(provider, getSecret);
     }
     catch (error) {
         log.warn("Provider instantiation failed", {
@@ -356,20 +437,35 @@ async function isServerReachable(url) {
         clearTimeout(timer);
     }
 }
-async function getServerAvailability() {
-    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([
+async function getServerAvailability(userId) {
+    if (isProduction()) {
+        return { ollama: false, llama_cpp: false, lmstudio: false, vllm: false };
+    }
+    // Resolve URLs the same way getProvider() does: secret store → env →
+    // default. Otherwise a user-set URL in Settings → API Keys wouldn't filter
+    // the recommended-models list correctly.
+    const getSecret = secretResolverFor(userId);
+    const resolve = async (key, fallback) => {
+        const fromStore = await getSecret(key);
+        return (fromStore || process.env[key] || fallback).replace(/\/+$/, "");
+    };
+    const [ollamaUrl, llamaUrl, lmstudioUrl, vllmUrl] = await Promise.all([
+        resolve("OLLAMA_API_URL", OLLAMA_DEFAULT_URL),
+        resolve("LLAMA_CPP_URL", ""),
+        resolve("LMSTUDIO_API_URL", LMSTUDIO_DEFAULT_URL),
+        resolve("VLLM_BASE_URL", "")
+    ]);
+    const [ollama, llama, lmstudio, vllm] = await Promise.all([
         isServerReachable(`${ollamaUrl}/api/tags`),
         llamaUrl
             ? isServerReachable(`${llamaUrl}/v1/models`)
-            : Promise.resolve(false)
+            : Promise.resolve(false),
+        isServerReachable(`${lmstudioUrl}/v1/models`),
+        vllmUrl ? isServerReachable(`${vllmUrl}/v1/models`) : Promise.resolve(false)
     ]);
-    return { ollama, llama_cpp: llama };
+    return { ollama, llama_cpp: llama, lmstudio, vllm };
 }
-async function serverAllowsModel(model, servers) {
+async function serverAllowsModel(model, servers, userId) {
     if (model.provider === "ollama")
         return servers.ollama ?? false;
     if (model.provider === "llama_cpp")
@@ -379,22 +475,98 @@ async function serverAllowsModel(model, servers) {
     if (model.provider === "vllm")
         return servers.vllm ?? false;
     if (model.provider)
-        return await isProviderConfigured(model.provider);
+        return await isProviderConfigured(model.provider, secretResolverFor(userId));
     return true;
 }
-async function getRecommendedModels(checkServers) {
-    const models = [...RECOMMENDED_MODELS];
+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 = await withWhisperDownloadStatus([...RECOMMENDED_MODELS], userId);
     if (!checkServers)
         return models;
-    const servers = await getServerAvailability();
+    const servers = await getServerAvailability(userId);
     const filtered = [];
     for (const model of models) {
-        if (await serverAllowsModel(model, servers)) {
+        if (await serverAllowsModel(model, servers, userId)) {
             filtered.push(model);
         }
     }
     return filtered;
 }
+/** Map a HF Hub API model record onto our UnifiedModel shape. */
+function hubModelToUnified(m, fallbackTag) {
+    const repoId = m.id ?? m.modelId;
+    if (!repoId)
+        return null;
+    const tag = m.pipeline_tag ?? fallbackTag ?? undefined;
+    // Hub pipeline tags are dash-cased ("audio-text-to-text"); our model types
+    // are the same task underscore-cased and prefixed "hf.".
+    const type = tag ? `hf.${tag.replace(/-/g, "_")}` : "hf.model";
+    return {
+        id: repoId,
+        type,
+        name: repoId,
+        repo_id: repoId,
+        provider: "huggingface",
+        downloaded: false,
+        pipeline_tag: m.pipeline_tag ?? null,
+        tags: m.tags ?? null,
+        downloads: m.downloads ?? null,
+        likes: m.likes ?? null,
+        trending_score: m.trendingScore ?? null
+    };
+}
+/**
+ * Search the live HuggingFace Hub (https://huggingface.co/api/models) by
+ * free-text and/or pipeline tag. Returns downloadable repos sorted by
+ * popularity. Network/HTTP failures degrade to an empty list.
+ */
+async function searchHuggingFaceHub(query, pipelineTag, limit) {
+    if (!query && !pipelineTag)
+        return [];
+    const params = new URLSearchParams();
+    if (query)
+        params.set("search", query);
+    if (pipelineTag)
+        params.set("pipeline_tag", pipelineTag);
+    params.set("limit", String(limit));
+    params.set("sort", "downloads");
+    params.set("direction", "-1");
+    const headers = { Accept: "application/json" };
+    const token = process.env.HF_TOKEN || process.env.HUGGING_FACE_HUB_TOKEN;
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    try {
+        const res = await fetch(`https://huggingface.co/api/models?${params.toString()}`, { headers });
+        if (!res.ok) {
+            log.warn("HF Hub search failed: %d %s", res.status, res.statusText);
+            return [];
+        }
+        const data = (await res.json());
+        return data
+            .map((m) => hubModelToUnified(m, pipelineTag))
+            .filter((m) => m !== null);
+    }
+    catch (err) {
+        log.warn("HF Hub search error: %s", err.message);
+        return [];
+    }
+}
 function selectRecommended(modality, task) {
     return RECOMMENDED_MODELS.filter((model) => model.modality === modality && (!task || model.task === task));
 }
@@ -426,29 +598,65 @@ function tjsCachedAsRecommended(repoId) {
     return out;
 }
 function toUnifiedLanguageModel(model, supportsTools) {
+    const registration = getRegisteredProvider(model.provider);
     return {
         id: model.id,
         type: "language_model",
         name: model.name,
         provider: model.provider,
         repo_id: null,
-        path: model.id,
+        path: null,
         downloaded: model.provider === "ollama" || model.provider === "llama_cpp",
         tags: [model.provider],
-        supports_tools: supportsTools ?? null
+        supports_tools: supportsTools ?? null,
+        execution: registration
+            ? readyProviderExecution(registration.metadata)
+            : null
     };
 }
 function toUnifiedModel(model, type) {
+    const registration = getRegisteredProvider(model.provider);
     return {
         id: model.id,
         type,
         name: model.name,
         provider: model.provider,
         repo_id: null,
-        path: model.id,
-        downloaded: model.provider === "ollama" || model.provider === "llama_cpp",
+        path: null,
+        downloaded: model.provider === "ollama" ||
+            model.provider === "llama_cpp" ||
+            model.provider === "whisper_cpp" ||
+            model.provider === "whisper_cpp_server",
         tags: [model.provider],
-        voices: model.voices ?? null
+        voices: model.voices ?? null,
+        capabilities: model.capabilities ?? null,
+        languages: model.languages ?? null,
+        sample_rate: model.sampleRate ?? null,
+        requires_reference_text: model.requiresReferenceText ?? null,
+        adapter: model.adapter
+            ? {
+                state: model.adapter.state,
+                reason_code: model.adapter.reasonCode ?? null,
+                reason: model.adapter.reason ?? null,
+                artifact_ref: model.adapter.artifactRef
+                    ? {
+                        source: model.adapter.artifactRef.source,
+                        repo_id: model.adapter.artifactRef.repoId,
+                        revision: model.adapter.artifactRef.revision ?? 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,
+        durations: model.durations ?? null,
+        resolutions: model.resolutions ?? null,
+        aspect_ratios: model.aspectRatios ?? null,
+        execution: registration
+            ? readyProviderExecution(registration.metadata)
+            : null
     };
 }
 function toOllamaModel(model) {
@@ -462,27 +670,66 @@ function toOllamaModel(model) {
         details: {}
     };
 }
-async function getAllModels(userId) {
+function providerExecutionMap(configuredProviderIds) {
+    const configured = new Set(configuredProviderIds);
+    const providers = new Map();
+    for (const providerId of listRegisteredProviderIds()) {
+        const metadata = getRegisteredProvider(providerId)?.metadata;
+        if (!metadata)
+            continue;
+        providers.set(providerId, {
+            ...metadata,
+            configured: configured.has(providerId)
+        });
+    }
+    return providers;
+}
+async function resolveProviderModelExecution(models, configuredProviderIds) {
+    if (!models.some((model) => model.adapter)) {
+        return resolveModelExecutionAvailability(models, providerExecutionMap(configuredProviderIds));
+    }
+    let cachedModels = [];
+    try {
+        cachedModels = await readCachedHfModels();
+    }
+    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);
-    for (const providerId of availableIds) {
+    const providerModelsPromises = availableIds.map(async (providerId) => {
         try {
             const instance = await instantiateProvider(providerId, userId);
             if (!instance)
-                continue;
+                return [];
             const models = await instance.getAvailableLanguageModels();
-            const toolFlags = await Promise.all(models.map((m) => instance
-                .hasToolSupport(m.id)
-                .catch(() => null)));
-            models.forEach((m, i) => {
-                all.push(toUnifiedLanguageModel(m, toolFlags[i]));
-            });
+            const toolFlags = await Promise.all(models.map((m) => instance.hasToolSupport(m.id).catch(() => null)));
+            return models.map((m, i) => toUnifiedLanguageModel(m, toolFlags[i]));
         }
         catch {
             // Provider unavailable — skip
+            return [];
         }
+    });
+    const providerModelsArrays = await Promise.all(providerModelsPromises);
+    for (const models of providerModelsArrays) {
+        all.push(...models);
     }
+    const localProviderIds = availableIds.filter((providerId) => getRegisteredProvider(providerId)?.metadata.access !== "remote_api");
+    all.push(...(await collectProviderCatalogModels(userId, localProviderIds)));
     if (!isProduction()) {
         try {
             const hfModels = await readCachedHfModels();
@@ -506,27 +753,7 @@ async function getAllModels(userId) {
             // Transformers.js cache unavailable — continue without it
         }
     }
-    return dedupeModels(all);
-}
-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
-    };
+    return resolveModelExecutionAvailability(dedupeModels(all), providerExecutionMap(availableIds));
 }
 // ── availableForKind helpers ───────────────────────────────────────
 const availableForKindInput = z.object({
@@ -538,9 +765,13 @@ const KIND_TO_MODALITY = {
     text_to_image: "image",
     image_to_image: "image",
     text_to_speech: "tts",
+    text_to_music: "music",
+    audio_to_audio: "audio_to_audio",
     speech_to_text: "asr",
     text_to_video: "video",
-    image_to_video: "video"
+    image_to_video: "video",
+    video_to_video: "video",
+    reference_to_video: "video"
 };
 async function collectProviderModelsForKind(userId, kind) {
     const out = [];
@@ -553,7 +784,9 @@ async function collectProviderModelsForKind(userId, kind) {
             switch (kind) {
                 case "text_generation": {
                     const models = await instance.getAvailableLanguageModels();
-                    const toolFlags = await Promise.all(models.map((m) => instance.hasToolSupport(m.id).catch(() => null)));
+                    const toolFlags = await Promise.all(models.map((m) => instance
+                        .hasToolSupport(m.id)
+                        .catch(() => null)));
                     models.forEach((m, i) => out.push(toUnifiedLanguageModel(m, toolFlags[i])));
                     return;
                 }
@@ -579,6 +812,18 @@ async function collectProviderModelsForKind(userId, kind) {
                         out.push(toUnifiedModel(m, "tts_model"));
                     return;
                 }
+                case "text_to_music": {
+                    const models = await instance.getAvailableMusicModels();
+                    for (const m of models)
+                        out.push(toUnifiedModel(m, "music_model"));
+                    return;
+                }
+                case "audio_to_audio": {
+                    const models = await instance.getAvailableAudioToAudioModels();
+                    for (const m of models)
+                        out.push(toUnifiedModel(m, "audio_to_audio_model"));
+                    return;
+                }
                 case "speech_to_text": {
                     const models = await instance.getAvailableASRModels();
                     for (const m of models)
@@ -586,7 +831,9 @@ async function collectProviderModelsForKind(userId, kind) {
                     return;
                 }
                 case "text_to_video":
-                case "image_to_video": {
+                case "image_to_video":
+                case "video_to_video":
+                case "reference_to_video": {
                     const models = await instance.getAvailableVideoModels();
                     for (const m of models) {
                         if (m.supportedTasks && !m.supportedTasks.includes(kind))
@@ -600,13 +847,45 @@ async function collectProviderModelsForKind(userId, kind) {
     }
     return out;
 }
+/**
+ * Every remote model the user's configured providers can enumerate, across all
+ * non-language-model types (embeddings, images, TTS, music, ASR, video), for the
+ * SDK model catalog. Unlike `collectProviderModelsForKind` this makes one pass
+ * per provider (each `getAvailable*Models` called once, no task filtering) so
+ * text_to_image and image_to_image capable models are both included. Language
+ * models are not collected here — `getAllModels` already enumerates them.
+ */
+export async function collectProviderCatalogModels(userId, providerIdsOverride) {
+    const providerIds = providerIdsOverride ?? (await getAvailableProviderIds(userId));
+    const perProvider = await Promise.all(providerIds.map((providerId) => safeProviderCall("catalogModels", { provider: providerId, userId }, async () => {
+        const instance = await instantiateProvider(providerId, userId);
+        if (!instance)
+            return [];
+        const collect = (fetchModels, type) => safeProviderCall(`catalogModels:${type}`, { provider: providerId, userId }, async () => (await fetchModels()).map((m) => toUnifiedModel(m, type)), []);
+        const lists = await Promise.all([
+            collect(() => instance.getAvailableImageModels(), "image_model"),
+            collect(() => instance.getAvailableEmbeddingModels(), "embedding_model"),
+            collect(() => instance.getAvailableTTSModels(), "tts_model"),
+            collect(() => instance.getAvailableMusicModels(), "music_model"),
+            collect(() => instance.getAvailableAudioToAudioModels(), "audio_to_audio_model"),
+            collect(() => instance.getAvailableASRModels(), "asr_model"),
+            collect(() => instance.getAvailableVideoModels(), "video_model")
+        ]);
+        return lists.flat();
+    }, [])));
+    return perProvider.flat();
+}
 function curatedForKind(kind) {
     const modality = KIND_TO_MODALITY[kind];
     // For text_generation/embedding/image/video, RECOMMENDED_MODELS entries are
-    // tagged with the specific task. TTS and ASR entries have no task field —
-    // modality alone is enough.
-    const taskRequired = kind !== "text_to_speech" && kind !== "speech_to_text";
-    return RECOMMENDED_MODELS.filter((r) => r.modality === modality && (!taskRequired || r.task === kind));
+    // tagged with the specific task. TTS, ASR and music entries have no task
+    // field — modality alone is enough.
+    const taskRequired = kind !== "text_to_speech" &&
+        kind !== "speech_to_text" &&
+        kind !== "text_to_music";
+    return RECOMMENDED_MODELS.filter((r) => r.modality === modality &&
+        r.type !== "hf.whisper_cpp_vad" &&
+        (!taskRequired || r.task === kind));
 }
 // ── Router ─────────────────────────────────────────────────────────
 export const modelsRouter = router({
@@ -617,14 +896,26 @@ export const modelsRouter = router({
         .output(providersOutput)
         .query(async ({ ctx }) => {
         const userId = ctx.userId;
+        // The registry is a process global but a custom provider's catalog is
+        // per user, so the caller's own definitions have to be in it before the
+        // enumeration below — otherwise a second account's endpoints are the
+        // ones listed, or none are after a restart.
+        await syncCustomProviderRegistry(userId);
         const infos = [];
-        for (const providerId of await getAvailableProviderIds(userId)) {
-            const instance = await instantiateProvider(providerId, userId);
+        const providerIds = await getAvailableProviderIds(userId);
+        const instances = await Promise.all(providerIds.map(async (providerId) => ({
+            providerId,
+            instance: await instantiateProvider(providerId, userId)
+        })));
+        for (const { providerId, instance } of instances) {
             if (!instance)
                 continue;
+            const metadata = getRegisteredProvider(providerId)?.metadata;
             infos.push({
                 provider: providerId,
-                capabilities: providerCapabilities(instance)
+                capabilities: instance.getCapabilities(),
+                access: metadata?.access ?? "remote_api",
+                display_name: metadata?.displayName ?? providerId
             });
         }
         return infos;
@@ -634,58 +925,35 @@ export const modelsRouter = router({
      */
     recommended: protectedProcedure
         .input(recommendedInput)
-        .query(async ({ input }) => {
-        return getRecommendedModels(input.check_servers ?? false);
+        .output(modelsListOutput)
+        .query(async ({ input, ctx }) => {
+        return getRecommendedModels(input.check_servers ?? false, ctx.userId);
     }),
     /**
-     * Recommended image models (all tasks).
-     */
-    recommendedImage: protectedProcedure
-        .query(() => selectRecommended("image")),
-    /**
-     * Recommended text-to-image models.
+     * 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")),
-    /**
-     * Recommended image-to-image models.
-     */
     recommendedImageImageToImage: protectedProcedure
+        .output(modelsListOutput)
         .query(() => selectRecommended("image", "image_to_image")),
-    /**
-     * Recommended language models (all tasks).
-     */
-    recommendedLanguage: protectedProcedure
-        .query(() => selectRecommended("language")),
-    /**
-     * Recommended text-generation models.
-     */
-    recommendedLanguageTextGeneration: protectedProcedure
-        .query(() => selectRecommended("language", "text_generation")),
-    /**
-     * Recommended embedding models.
-     */
     recommendedLanguageEmbedding: protectedProcedure
+        .output(modelsListOutput)
         .query(() => selectRecommended("language", "embedding")),
-    /**
-     * Recommended ASR models.
-     */
-    recommendedAsr: protectedProcedure
-        .query(() => selectRecommended("asr")),
-    /**
-     * Recommended TTS models.
-     */
+    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")),
-    /**
-     * Recommended text-to-video models.
-     */
     recommendedVideoTextToVideo: protectedProcedure
+        .output(modelsListOutput)
         .query(() => selectRecommended("video", "text_to_video")),
-    /**
-     * Recommended image-to-video models.
-     */
     recommendedVideoImageToVideo: protectedProcedure
+        .output(modelsListOutput)
         .query(() => selectRecommended("video", "image_to_video")),
     /**
      * All models available to the user for a given task kind. Aggregates the
@@ -695,6 +963,7 @@ export const modelsRouter = router({
      */
     availableForKind: protectedProcedure
         .input(availableForKindInput)
+        .output(modelsListOutput)
         .query(async ({ ctx, input }) => {
         const fromProviders = await collectProviderModelsForKind(ctx.userId, input.kind);
         const curated = curatedForKind(input.kind);
@@ -713,13 +982,20 @@ export const modelsRouter = router({
      * All models (recommended + provider models + HF cached).
      */
     all: protectedProcedure
+        .output(modelsListOutput)
         .query(async ({ ctx }) => getAllModels(ctx.userId)),
     /**
-     * HuggingFace cached models.
+     * HuggingFace cached models. `scope: "worker"` lists the attached worker's
+     * cache via the Python bridge; the default `"local"` scans the local FS.
      */
     huggingfaceList: protectedProcedure
+        .input(z.object({ scope: modelScope }).optional())
         .output(modelsListOutput)
-        .query(async () => {
+        .query(async ({ ctx, input }) => {
+        if (input?.scope === "worker") {
+            const bridge = await requireWorkerBridge(ctx);
+            return (await bridge.listCachedModels());
+        }
         if (isProduction())
             return [];
         try {
@@ -730,12 +1006,17 @@ export const modelsRouter = router({
         }
     }),
     /**
-     * Delete a HuggingFace cached model.
+     * Delete a HuggingFace cached model. `scope: "worker"` deletes from the
+     * attached worker's cache via the Python bridge.
      */
     huggingfaceDelete: protectedProcedure
-        .input(hfDeleteInput)
+        .input(hfDeleteInput.extend({ scope: modelScope }))
         .output(z.boolean())
-        .mutation(async ({ input }) => {
+        .mutation(async ({ ctx, input }) => {
+        if (input.scope === "worker") {
+            const bridge = await requireWorkerBridge(ctx);
+            return bridge.deleteCachedModel(input.repo_id);
+        }
         if (isProduction())
             return false;
         try {
@@ -765,28 +1046,33 @@ export const modelsRouter = router({
         }
     }),
     /**
-     * HuggingFace models by type.
+     * Search the live HuggingFace Hub by free-text and/or pipeline tag.
+     * Unlike `huggingfaceSearch` (which only scans the local cache), this hits
+     * the online Hub so the Model Manager can browse & download any public repo.
      */
-    huggingfaceByType: protectedProcedure
-        .input(hfByTypeInput)
+    huggingfaceHubSearch: protectedProcedure
+        .input(hfHubSearchInput)
         .output(modelsListOutput)
         .query(async ({ input }) => {
-        try {
-            return await getModelsByHfType(input.model_type);
-        }
-        catch {
-            return [];
-        }
+        return await searchHuggingFaceHub(input.query, input.pipeline_tag, input.limit ?? 50);
     }),
     /**
-     * Transformers.js cached models (everything in the configured cache dir).
+     * HuggingFace models by type.
      */
-    transformersJsList: protectedProcedure
+    huggingfaceByType: protectedProcedure
+        .input(hfByTypeInput.extend({ scope: modelScope }))
         .output(modelsListOutput)
-        .query(async () => {
+        .query(async ({ ctx, input }) => {
+        if (input.scope === "worker") {
+            const bridge = await requireWorkerBridge(ctx);
+            // SAFETY: the worker sends full `UnifiedModel` JSON, but the bridge
+            // types the reply as `UnifiedModelLike`, which declares neither `type`
+            // nor `path` — the two fields this filter reads.
+            const cached = (await bridge.listCachedModels());
+            return filterModelsByHfType(cached, input.model_type);
+        }
         try {
-            const cached = await scanTransformersJsCache(getTransformersJsCacheDir());
-            return cached.map((c) => tjsRefToUnified({ repo_id: c.repo_id }, "tjs.cached", true, c.size_bytes));
+            return await getModelsByHfType(input.model_type);
         }
         catch {
             return [];
@@ -799,12 +1085,14 @@ export const modelsRouter = router({
      * Transformers.js cache directory. Recommended entries always appear,
      * marked `downloaded` based on cache presence; off-list cached repos that
      * happen to be recommended under another type are NOT shown here (they only
-     * show up under their own type or via `transformersJsList`).
+     * show up under their own type).
      */
     transformersJsByType: protectedProcedure
         .input(tjsByTypeInput)
         .output(modelsListOutput)
         .query(async ({ input }) => {
+        if (isProduction())
+            return [];
         const modelType = input.model_type;
         const recs = recommendedFor(modelType);
         const cacheDir = getTransformersJsCacheDir();
@@ -841,6 +1129,8 @@ export const modelsRouter = router({
         .input(tjsByTypeInput)
         .output(modelsListOutput)
         .query(async ({ input }) => {
+        if (isProduction())
+            return [];
         const modelType = input.model_type;
         const recs = recommendedFor(modelType);
         if (recs.length === 0)
@@ -850,26 +1140,7 @@ export const modelsRouter = router({
         const cacheSizes = new Map(cached.map((c) => [c.repo_id, c.size_bytes]));
         return recs.map((ref) => tjsRefToUnified(ref, modelType, cacheSizes.has(ref.repo_id), cacheSizes.get(ref.repo_id) ?? null));
     }),
-    /**
-     * Check whether a single Transformers.js repo is present in the cache.
-     */
-    transformersJsIsCached: protectedProcedure
-        .input(z.object({ repo_id: z.string().min(1) }))
-        .output(z.boolean())
-        .query(async ({ input }) => {
-        try {
-            return await isRepoCached(getTransformersJsCacheDir(), input.repo_id);
-        }
-        catch {
-            return false;
-        }
-    }),
-    /**
-     * Ollama models.
-     */
-    ollama: protectedProcedure
-        .output(ollamaModelsOutput)
-        .query(async ({ ctx }) => safeProviderCall("ollama models", { provider: "ollama", userId: ctx.userId }, async () => {
+    ollama: protectedProcedure.output(ollamaModelsOutput).query(async ({ ctx }) => safeProviderCall("ollama models", { provider: "ollama", userId: ctx.userId }, async () => {
         const instance = await instantiateProvider("ollama", ctx.userId);
         if (!instance)
             return [];
@@ -877,8 +1148,18 @@ export const modelsRouter = router({
         return models.map(toOllamaModel);
     }, [])),
     /**
-     * LLM models by provider.
+     * Delete a model from the local Ollama server. Returns false when Ollama is
+     * not configured or does not have the model.
      */
+    ollamaDelete: protectedProcedure
+        .input(z.object({ model: z.string().min(1) }))
+        .output(z.boolean())
+        .mutation(async ({ ctx, input }) => safeProviderCall("ollama delete", { provider: "ollama", userId: ctx.userId }, async () => {
+        const instance = await instantiateProvider("ollama", ctx.userId);
+        if (!(instance instanceof OllamaProvider))
+            return false;
+        return instance.deleteModel(input.model);
+    }, false)),
     llmByProvider: protectedProcedure
         .input(providerInput)
         .output(modelsListOutput)
@@ -887,28 +1168,78 @@ export const modelsRouter = router({
         if (!instance)
             return [];
         const models = await instance.getAvailableLanguageModels();
-        const toolFlags = await Promise.all(models.map((m) => instance
-            .hasToolSupport(m.id)
-            .catch(() => null)));
+        const toolFlags = await Promise.all(models.map((m) => instance.hasToolSupport(m.id).catch(() => null)));
         return models.map((m, i) => toUnifiedLanguageModel(m, toolFlags[i]));
     }, [])),
     /**
-     * Image models by provider.
+     * Aspect ratios / resolutions / (video) durations a given model supports.
+     * Empty arrays are intentional — the client falls back to the full static
+     * lists when a model declares no constraints.
      */
+    mediaOptions: protectedProcedure
+        .input(z.object({
+        provider: z.string().min(1),
+        model: z.string().min(1),
+        task: z.enum(["image", "video"])
+    }))
+        .output(z.object({
+        aspectRatios: z.array(z.string()),
+        resolutions: z.array(z.string()),
+        durations: z.array(z.number()).nullish()
+    }))
+        .query(async ({ ctx, input }) => safeProviderCall("mediaOptions", { provider: input.provider, task: input.task, userId: ctx.userId }, async () => {
+        const instance = await instantiateProvider(input.provider, ctx.userId);
+        if (!instance) {
+            return { aspectRatios: [], resolutions: [], durations: null };
+        }
+        if (input.task === "image") {
+            const models = await instance.getAvailableImageModels();
+            const m = models.find((x) => x.id === input.model);
+            return {
+                aspectRatios: m?.aspectRatios ?? [],
+                resolutions: m?.resolutions ?? [],
+                durations: null
+            };
+        }
+        const models = await instance.getAvailableVideoModels();
+        const m = models.find((x) => x.id === input.model);
+        return {
+            aspectRatios: m?.aspectRatios ?? [],
+            resolutions: m?.resolutions ?? [],
+            durations: m?.durations ?? null
+        };
+    }, { aspectRatios: [], resolutions: [], durations: null })),
     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"));
-    }, [])),
-    /**
-     * All TTS models across all providers.
-     */
-    tts: protectedProcedure.query(async ({ ctx }) => {
+        .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 () => {
             const instance = await instantiateProvider(providerId, ctx.userId);
@@ -917,52 +1248,90 @@ export const modelsRouter = router({
             const models = await instance.getAvailableTTSModels();
             return models.map((m) => toUnifiedModel(m, "tts_model"));
         }, [])));
-        return results.flat();
+        return resolveProviderModelExecution(results.flat(), availableIds);
     }),
-    /**
-     * TTS models by provider.
-     */
     ttsByProvider: protectedProcedure
         .input(providerInput)
         .output(modelsListOutput)
-        .query(async ({ ctx, input }) => safeProviderCall("ttsByProvider", { provider: input.provider, userId: ctx.userId }, async () => {
+        .query(async ({ ctx, input }) => {
+        const models = await safeProviderCall("ttsByProvider", { provider: input.provider, userId: ctx.userId }, async () => {
+            const instance = await instantiateProvider(input.provider, ctx.userId);
+            if (!instance)
+                return [];
+            const models = await instance.getAvailableTTSModels();
+            return models.map((m) => toUnifiedModel(m, "tts_model"));
+        }, []);
+        return resolveProviderModelExecution(models, [input.provider]);
+    }),
+    music: protectedProcedure.output(modelsListOutput).query(async ({ ctx }) => {
+        const availableIds = await getAvailableProviderIds(ctx.userId);
+        const results = await Promise.all(availableIds.map((providerId) => safeProviderCall("music (aggregate)", { provider: providerId, userId: ctx.userId }, async () => {
+            const instance = await instantiateProvider(providerId, ctx.userId);
+            if (!instance)
+                return [];
+            const models = await instance.getAvailableMusicModels();
+            return models.map((m) => toUnifiedModel(m, "music_model"));
+        }, [])));
+        return results.flat();
+    }),
+    musicByProvider: protectedProcedure
+        .input(providerInput)
+        .output(modelsListOutput)
+        .query(async ({ ctx, input }) => safeProviderCall("musicByProvider", { provider: input.provider, userId: ctx.userId }, async () => {
         const instance = await instantiateProvider(input.provider, ctx.userId);
         if (!instance)
             return [];
-        const models = await instance.getAvailableTTSModels();
-        return models.map((m) => toUnifiedModel(m, "tts_model"));
+        const models = await instance.getAvailableMusicModels();
+        return models.map((m) => toUnifiedModel(m, "music_model"));
     }, [])),
-    /**
-     * All ASR models across all providers.
-     */
-    asr: protectedProcedure.query(async ({ ctx }) => {
+    audioToAudio: protectedProcedure
+        .output(modelsListOutput)
+        .query(async ({ ctx }) => {
         const availableIds = await getAvailableProviderIds(ctx.userId);
-        const results = await Promise.all(availableIds.map((providerId) => safeProviderCall("asr (aggregate)", { provider: providerId, userId: ctx.userId }, async () => {
+        const results = await Promise.all(availableIds.map((providerId) => safeProviderCall("audioToAudio (aggregate)", { provider: providerId, userId: ctx.userId }, async () => {
             const instance = await instantiateProvider(providerId, ctx.userId);
             if (!instance)
                 return [];
-            const models = await instance.getAvailableASRModels();
-            return models.map((m) => toUnifiedModel(m, "asr_model"));
+            const models = await instance.getAvailableAudioToAudioModels();
+            return models.map((m) => toUnifiedModel(m, "audio_to_audio_model"));
         }, [])));
         return results.flat();
     }),
-    /**
-     * ASR models by provider.
-     */
-    asrByProvider: protectedProcedure
+    audioToAudioByProvider: protectedProcedure
         .input(providerInput)
         .output(modelsListOutput)
-        .query(async ({ ctx, input }) => safeProviderCall("asrByProvider", { provider: input.provider, userId: ctx.userId }, async () => {
+        .query(async ({ ctx, input }) => safeProviderCall("audioToAudioByProvider", { 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"));
+        const models = await instance.getAvailableAudioToAudioModels();
+        return models.map((m) => toUnifiedModel(m, "audio_to_audio_model"));
     }, [])),
-    /**
-     * All video models across all providers.
-     */
-    video: protectedProcedure.query(async ({ ctx }) => {
+    asr: protectedProcedure.output(modelsListOutput).query(async ({ ctx }) => {
+        const availableIds = await getAvailableProviderIds(ctx.userId);
+        const results = await Promise.all(availableIds.map((providerId) => safeProviderCall("asr (aggregate)", { provider: providerId, userId: ctx.userId }, async () => {
+            const instance = await instantiateProvider(providerId, ctx.userId);
+            if (!instance)
+                return [];
+            const models = await instance.getAvailableASRModels();
+            return models.map((m) => toUnifiedModel(m, "asr_model"));
+        }, [])));
+        return resolveProviderModelExecution(results.flat(), availableIds);
+    }),
+    asrByProvider: protectedProcedure
+        .input(providerInput)
+        .output(modelsListOutput)
+        .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 () => {
             const instance = await instantiateProvider(providerId, ctx.userId);
@@ -973,9 +1342,6 @@ export const modelsRouter = router({
         }, [])));
         return results.flat();
     }),
-    /**
-     * Video models by provider.
-     */
     videoByProvider: protectedProcedure
         .input(providerInput)
         .output(modelsListOutput)
@@ -986,61 +1352,19 @@ export const modelsRouter = router({
         const models = await instance.getAvailableVideoModels();
         return models.map((m) => toUnifiedModel(m, "video_model"));
     }, [])),
-    /**
-     * Embedding models by provider.
-     */
     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"));
-    }, [])),
-    /**
-     * Ollama model info (stub).
-     */
-    ollamaModelInfo: protectedProcedure.output(z.null()).query(() => null),
-    /**
-     * Check whether specific files exist in the HuggingFace cache.
-     */
-    huggingfaceTryCacheFiles: protectedProcedure
-        .input(tryCacheFilesInput)
-        .output(tryCacheFilesOutput)
-        .mutation(async ({ input }) => {
-        return Promise.all(input.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
-            };
-        }));
-    }),
-    /**
-     * Check whether repos have cached files.
-     */
-    huggingfaceTryCacheRepos: protectedProcedure
-        .input(tryCacheReposInput)
-        .output(tryCacheReposOutput)
-        .mutation(async ({ input }) => {
-        return Promise.all(input.map(async (repoId) => ({
-            repo_id: repoId,
-            downloaded: await hasCachedFiles(repoId)
-        })));
+        .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]);
     }),
-    /**
-     * Detailed check whether specific patterns exist in the HuggingFace cache.
-     */
-    huggingfaceCheckCache: protectedProcedure
-        .input(hfCacheCheckInput)
-        .output(hfCacheCheckOutput)
-        .mutation(async ({ input }) => checkHfCache(input)),
     /**
      * Fast batch cache status check for multiple models.
      */
@@ -1084,24 +1408,6 @@ export const modelsRouter = router({
         .mutation(() => ({
         status: "unavailable",
         message: "Streaming Ollama model pulls are not available in the TS standalone server. Use the Ollama API directly or the Python backend."
-    })),
-    /**
-     * Get HuggingFace file info (size, sha256, etc.).
-     */
-    huggingfaceFileInfo: protectedProcedure
-        .input(hfFileInfoInput)
-        .output(z.array(z.record(z.string(), z.unknown())))
-        .mutation(async ({ input }) => {
-        if (isProduction())
-            return [];
-        try {
-            const token = (await getSecret("HF_TOKEN", "1")) ?? undefined;
-            const infos = await getHuggingfaceFileInfos(input.map((i) => ({ repo_id: i.repo_id, path: i.path })), token);
-            return infos;
-        }
-        catch {
-            return [];
-        }
-    })
+    }))
 });
 //# sourceMappingURL=models.js.map