@nodetool-ai/websocket 0.7.0-rc.11

package/dist/trpc/routers/models.js

@@ -0,0 +1,1107 @@
+import { router } from "../index.js";
+import { protectedProcedure } from "../middleware.js";
+import { createLogger } from "@nodetool-ai/config";
+import { getProvider, isProviderConfigured, listRegisteredProviderIds, providerCapabilities, RECOMMENDED_MODELS } from "@nodetool-ai/runtime";
+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 { MODEL_SEARCH_KINDS } from "@nodetool-ai/protocol";
+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 { z } from "zod";
+import { getSecret } from "@nodetool-ai/models";
+// ── 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`
+// field silently disappeared and broke the client-side provider filter.
+const unifiedModelSchema = z.object({
+    id: z.string(),
+    type: z.string().nullish(),
+    name: z.string(),
+    provider: z.string().nullish(),
+    repo_id: z.string().nullish(),
+    path: z.string().nullish(),
+    artifact_family: z.string().nullish(),
+    artifact_component: z.string().nullish(),
+    artifact_confidence: z.number().nullish(),
+    artifact_evidence: z.array(z.string()).nullish(),
+    cache_path: z.string().nullish(),
+    allow_patterns: z.array(z.string()).nullish(),
+    ignore_patterns: z.array(z.string()).nullish(),
+    description: z.string().nullish(),
+    readme: z.string().nullish(),
+    downloaded: z.boolean().nullish(),
+    size_on_disk: z.number().nullish(),
+    pipeline_tag: z.string().nullish(),
+    tags: z.array(z.string()).nullish(),
+    has_model_index: z.boolean().nullish(),
+    downloads: z.number().nullish(),
+    likes: z.number().nullish(),
+    supported_tasks: z.array(z.string()).nullish(),
+    trending_score: z.number().nullish(),
+    image: z.string().nullish(),
+    supports_tools: z.boolean().nullish(),
+    voices: z.array(z.string()).nullish()
+});
+const modelsListOutput = z.array(unifiedModelSchema);
+const providersOutput = z.array(z.object({
+    provider: z.string(),
+    capabilities: z.array(z.string())
+}));
+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(),
+    model_type: z.string().nullable().optional(),
+    path: z.string().nullable().optional(),
+    allow_patterns: z
+        .union([z.string(), z.array(z.string())])
+        .nullable()
+        .optional(),
+    ignore_patterns: z
+        .union([z.string(), z.array(z.string())])
+        .nullable()
+        .optional()
+});
+const hfFastCacheStatusInput = z.array(hfFastCacheStatusItem);
+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 hfByTypeInput = z.object({
+    model_type: z.string().min(1)
+});
+const tjsByTypeInput = z.object({
+    model_type: z.string().min(1)
+});
+const hfDeleteInput = z.object({
+    repo_id: z.string().min(1)
+});
+const ollamaModelSchema = z.object({
+    type: z.string(),
+    name: z.string(),
+    repo_id: z.string(),
+    modified_at: z.string(),
+    size: z.number(),
+    digest: z.string(),
+    details: z.record(z.string(), z.unknown())
+});
+const ollamaModelsOutput = z.array(ollamaModelSchema);
+const providerInput = z.object({
+    provider: z.string().min(1)
+});
+// ── Constants ──────────────────────────────────────────────────────
+const LLAMA_CPP_MODEL_TYPES = new Set([
+    "llama_cpp_model",
+    "llama_cpp",
+    "hf.gguf"
+]);
+// ── Helpers ────────────────────────────────────────────────────────
+function isProduction() {
+    const value = (process.env.NODETOOL_ENV ??
+        process.env.NODE_ENV ??
+        "").toLowerCase();
+    return value === "production";
+}
+function dedupeModels(models) {
+    const seen = new Set();
+    const deduped = [];
+    for (const model of models) {
+        const key = `${model.repo_id ?? ""}::${model.path ?? ""}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            deduped.push(model);
+        }
+    }
+    return deduped;
+}
+function normalizePatterns(patterns) {
+    if (patterns == null)
+        return null;
+    if (typeof patterns === "string")
+        return patterns ? [patterns] : null;
+    const cleaned = patterns.filter((p) => Boolean(p));
+    return cleaned.length > 0 ? cleaned : null;
+}
+function wildcardToRegExp(pattern) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    const regex = `^${escaped.replaceAll("*", ".*").replaceAll("?", ".")}$`;
+    return new RegExp(regex);
+}
+function matchesPattern(value, pattern) {
+    return wildcardToRegExp(pattern).test(value);
+}
+function isIgnored(path, ignorePatterns) {
+    if (!ignorePatterns || ignorePatterns.length === 0)
+        return false;
+    return ignorePatterns.some((pattern) => matchesPattern(path, pattern));
+}
+function isDownloadedFromFiles(files, allowPatterns, ignorePatterns) {
+    if (files.length === 0)
+        return false;
+    if (allowPatterns && allowPatterns.length > 0) {
+        return allowPatterns.every((pattern) => files.some((path) => matchesPattern(path, pattern) && !isIgnored(path, ignorePatterns)));
+    }
+    return files.some((path) => !isIgnored(path, ignorePatterns));
+}
+function getHfCacheRoot() {
+    const cacheEnv = process.env.HUGGINGFACE_HUB_CACHE ?? process.env.HF_HOME;
+    return cacheEnv
+        ? join(cacheEnv, "hub")
+        : join(homedir(), ".cache", "huggingface", "hub");
+}
+function repoToCacheDir(repoId) {
+    return `models--${repoId.replaceAll("/", "--")}`;
+}
+async function pathExists(path) {
+    try {
+        await access(path, fsConstants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function listSnapshotDirs(repoId) {
+    const snapshotsRoot = join(getHfCacheRoot(), repoToCacheDir(repoId), "snapshots");
+    if (!(await pathExists(snapshotsRoot)))
+        return [];
+    const entries = await readdir(snapshotsRoot, { withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => join(snapshotsRoot, entry.name));
+}
+async function repoFileInCache(repoId, relativePath) {
+    const snapshotDirs = await listSnapshotDirs(repoId);
+    for (const snapshotDir of snapshotDirs) {
+        if (await pathExists(join(snapshotDir, relativePath))) {
+            return true;
+        }
+    }
+    return false;
+}
+async function listRepoCachedFiles(repoId) {
+    const snapshotDirs = await listSnapshotDirs(repoId);
+    const collected = new Set();
+    async function walk(root, current) {
+        const entries = await readdir(current, { withFileTypes: true });
+        for (const entry of entries) {
+            const full = join(current, entry.name);
+            if (entry.isDirectory()) {
+                await walk(root, full);
+                continue;
+            }
+            if (entry.isFile() || entry.isSymbolicLink()) {
+                const rel = full.slice(root.length + 1).replaceAll("\\", "/");
+                collected.add(rel);
+            }
+        }
+    }
+    for (const snapshotDir of snapshotDirs) {
+        await walk(snapshotDir, snapshotDir);
+    }
+    return [...collected];
+}
+async function hasCachedFiles(repoId) {
+    return (await listRepoCachedFiles(repoId)).length > 0;
+}
+async function isLlamaCppModelCached(repoId, filePath) {
+    if (await repoFileInCache(repoId, filePath)) {
+        return true;
+    }
+    const cacheRoot = process.env.LLAMA_CPP_CACHE_DIR ??
+        join(homedir(), "Library", "Caches", "llama.cpp", "hf");
+    const repoDir = join(cacheRoot, repoToCacheDir(repoId), "snapshots");
+    if (!(await pathExists(repoDir)))
+        return false;
+    const snapshots = await readdir(repoDir, { withFileTypes: true });
+    for (const snapshot of snapshots) {
+        if (!snapshot.isDirectory())
+            continue;
+        if (await pathExists(join(repoDir, snapshot.name, filePath))) {
+            return true;
+        }
+        if (await pathExists(join(repoDir, snapshot.name, basename(filePath)))) {
+            return true;
+        }
+    }
+    return false;
+}
+async function getAvailableProviderIds(userId) {
+    const ids = listRegisteredProviderIds();
+    const checks = await Promise.all(ids.map(async (id) => ({
+        id,
+        available: await isProviderConfigured(id, userId)
+    })));
+    return checks.filter((c) => c.available).map((c) => c.id);
+}
+async function instantiateProvider(provider, userId) {
+    if (!(await isProviderConfigured(provider, userId))) {
+        log.debug("Provider not configured", { provider, userId });
+        return null;
+    }
+    try {
+        return await getProvider(provider, userId);
+    }
+    catch (error) {
+        log.warn("Provider instantiation failed", {
+            provider,
+            userId,
+            error: summarizeError(error)
+        });
+        return null;
+    }
+}
+/**
+ * Run `fn`, log and return `fallback` on error. Unmasks silent provider
+ * failures so the server log shows why a `*ByProvider` query came back empty.
+ */
+function summarizeError(error) {
+    if (!(error instanceof Error)) {
+        return { message: String(error) };
+    }
+    const summary = {
+        name: error.name,
+        message: error.message
+    };
+    const cause = error.cause;
+    if (cause instanceof Error) {
+        const causeSummary = {
+            name: cause.name,
+            message: cause.message
+        };
+        const causeWithFields = cause;
+        if (causeWithFields.code) {
+            causeSummary.code = causeWithFields.code;
+        }
+        if (causeWithFields.errno != null) {
+            causeSummary.errno = causeWithFields.errno;
+        }
+        if (causeWithFields.syscall) {
+            causeSummary.syscall = causeWithFields.syscall;
+        }
+        if (causeWithFields.address) {
+            causeSummary.address = causeWithFields.address;
+        }
+        if (causeWithFields.port != null) {
+            causeSummary.port = causeWithFields.port;
+        }
+        summary.cause = causeSummary;
+    }
+    return summary;
+}
+async function safeProviderCall(label, context, fn, fallback) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        log.warn(`${label} failed`, { ...context, error: summarizeError(error) });
+        return fallback;
+    }
+}
+async function isServerReachable(url) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 2000);
+    try {
+        const response = await fetch(url, { signal: controller.signal });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function 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([
+        isServerReachable(`${ollamaUrl}/api/tags`),
+        llamaUrl
+            ? isServerReachable(`${llamaUrl}/v1/models`)
+            : Promise.resolve(false)
+    ]);
+    return { ollama, llama_cpp: llama };
+}
+async function serverAllowsModel(model, servers) {
+    if (model.provider === "ollama")
+        return servers.ollama ?? false;
+    if (model.provider === "llama_cpp")
+        return servers.llama_cpp ?? false;
+    if (model.provider === "lmstudio")
+        return servers.lmstudio ?? false;
+    if (model.provider === "vllm")
+        return servers.vllm ?? false;
+    if (model.provider)
+        return await isProviderConfigured(model.provider);
+    return true;
+}
+async function getRecommendedModels(checkServers) {
+    const models = [...RECOMMENDED_MODELS];
+    if (!checkServers)
+        return models;
+    const servers = await getServerAvailability();
+    const filtered = [];
+    for (const model of models) {
+        if (await serverAllowsModel(model, servers)) {
+            filtered.push(model);
+        }
+    }
+    return filtered;
+}
+function selectRecommended(modality, task) {
+    return RECOMMENDED_MODELS.filter((model) => model.modality === modality && (!task || model.task === task));
+}
+// ── Transformers.js helpers ────────────────────────────────────────
+function tjsRefToUnified(ref, modelType, downloaded, sizeBytes) {
+    return {
+        id: ref.repo_id,
+        type: modelType,
+        name: ref.repo_id,
+        provider: "transformers_js",
+        repo_id: ref.repo_id,
+        path: ref.path ?? null,
+        downloaded,
+        size_on_disk: sizeBytes ?? null
+    };
+}
+/**
+ * Find which `tjs.<task>` types each cached repo is recommended under.
+ * A repo can match multiple types if listed in several recommended lists
+ * (rare, but supported); we just return the set of (type, ref) pairings.
+ */
+function tjsCachedAsRecommended(repoId) {
+    const out = [];
+    for (const type of TJS_MODEL_TYPES) {
+        const match = recommendedFor(type).find((r) => r.repo_id === repoId);
+        if (match)
+            out.push(match);
+    }
+    return out;
+}
+function toUnifiedLanguageModel(model, supportsTools) {
+    return {
+        id: model.id,
+        type: "language_model",
+        name: model.name,
+        provider: model.provider,
+        repo_id: null,
+        path: model.id,
+        downloaded: model.provider === "ollama" || model.provider === "llama_cpp",
+        tags: [model.provider],
+        supports_tools: supportsTools ?? null
+    };
+}
+function toUnifiedModel(model, type) {
+    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",
+        tags: [model.provider],
+        voices: model.voices ?? null
+    };
+}
+function toOllamaModel(model) {
+    return {
+        type: "llama_model",
+        name: model.name,
+        repo_id: model.id,
+        modified_at: "",
+        size: 0,
+        digest: "",
+        details: {}
+    };
+}
+async function getAllModels(userId) {
+    const all = [];
+    all.push(...RECOMMENDED_MODELS);
+    const availableIds = await getAvailableProviderIds(userId);
+    for (const providerId of availableIds) {
+        try {
+            const instance = await instantiateProvider(providerId, userId);
+            if (!instance)
+                continue;
+            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]));
+            });
+        }
+        catch {
+            // Provider unavailable — skip
+        }
+    }
+    if (!isProduction()) {
+        try {
+            const hfModels = await readCachedHfModels();
+            all.push(...hfModels);
+        }
+        catch {
+            // HF models unavailable — continue without them
+        }
+        try {
+            const cached = await scanTransformersJsCache(getTransformersJsCacheDir());
+            for (const c of cached) {
+                // Surface each cached repo under its first matched recommended type
+                // (e.g. "tjs.text_generation") so it lands in the right sidebar bucket;
+                // fall back to "tjs.cached" for repos not in any recommended list.
+                const recommendedTypes = TJS_MODEL_TYPES.filter((t) => recommendedFor(t).some((r) => r.repo_id === c.repo_id));
+                const modelType = recommendedTypes[0] ?? "tjs.cached";
+                all.push(tjsRefToUnified({ repo_id: c.repo_id }, modelType, true, c.size_bytes));
+            }
+        }
+        catch {
+            // 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
+    };
+}
+// ── availableForKind helpers ───────────────────────────────────────
+const availableForKindInput = z.object({
+    kind: z.enum(MODEL_SEARCH_KINDS)
+});
+const KIND_TO_MODALITY = {
+    text_generation: "language",
+    embedding: "language",
+    text_to_image: "image",
+    image_to_image: "image",
+    text_to_speech: "tts",
+    speech_to_text: "asr",
+    text_to_video: "video",
+    image_to_video: "video"
+};
+async function collectProviderModelsForKind(userId, kind) {
+    const out = [];
+    const providerIds = await getAvailableProviderIds(userId);
+    for (const providerId of providerIds) {
+        await safeProviderCall("availableForKind", { provider: providerId, kind, userId }, async () => {
+            const instance = await instantiateProvider(providerId, userId);
+            if (!instance)
+                return;
+            switch (kind) {
+                case "text_generation": {
+                    const models = await instance.getAvailableLanguageModels();
+                    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;
+                }
+                case "embedding": {
+                    const models = await instance.getAvailableEmbeddingModels();
+                    for (const m of models)
+                        out.push(toUnifiedModel(m, "embedding_model"));
+                    return;
+                }
+                case "text_to_image":
+                case "image_to_image": {
+                    const models = await instance.getAvailableImageModels();
+                    for (const m of models) {
+                        if (m.supportedTasks && !m.supportedTasks.includes(kind))
+                            continue;
+                        out.push(toUnifiedModel(m, "image_model"));
+                    }
+                    return;
+                }
+                case "text_to_speech": {
+                    const models = await instance.getAvailableTTSModels();
+                    for (const m of models)
+                        out.push(toUnifiedModel(m, "tts_model"));
+                    return;
+                }
+                case "speech_to_text": {
+                    const models = await instance.getAvailableASRModels();
+                    for (const m of models)
+                        out.push(toUnifiedModel(m, "asr_model"));
+                    return;
+                }
+                case "text_to_video":
+                case "image_to_video": {
+                    const models = await instance.getAvailableVideoModels();
+                    for (const m of models) {
+                        if (m.supportedTasks && !m.supportedTasks.includes(kind))
+                            continue;
+                        out.push(toUnifiedModel(m, "video_model"));
+                    }
+                    return;
+                }
+            }
+        }, undefined);
+    }
+    return out;
+}
+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));
+}
+// ── Router ─────────────────────────────────────────────────────────
+export const modelsRouter = router({
+    /**
+     * List providers and their capabilities.
+     */
+    providers: protectedProcedure
+        .output(providersOutput)
+        .query(async ({ ctx }) => {
+        const userId = ctx.userId;
+        const infos = [];
+        for (const providerId of await getAvailableProviderIds(userId)) {
+            const instance = await instantiateProvider(providerId, userId);
+            if (!instance)
+                continue;
+            infos.push({
+                provider: providerId,
+                capabilities: providerCapabilities(instance)
+            });
+        }
+        return infos;
+    }),
+    /**
+     * Get recommended models, optionally checking local server availability.
+     */
+    recommended: protectedProcedure
+        .input(recommendedInput)
+        .query(async ({ input }) => {
+        return getRecommendedModels(input.check_servers ?? false);
+    }),
+    /**
+     * Recommended image models (all tasks).
+     */
+    recommendedImage: protectedProcedure
+        .query(() => selectRecommended("image")),
+    /**
+     * Recommended text-to-image models.
+     */
+    recommendedImageTextToImage: protectedProcedure
+        .query(() => selectRecommended("image", "text_to_image")),
+    /**
+     * Recommended image-to-image models.
+     */
+    recommendedImageImageToImage: protectedProcedure
+        .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
+        .query(() => selectRecommended("language", "embedding")),
+    /**
+     * Recommended ASR models.
+     */
+    recommendedAsr: protectedProcedure
+        .query(() => selectRecommended("asr")),
+    /**
+     * Recommended TTS models.
+     */
+    recommendedTts: protectedProcedure
+        .query(() => selectRecommended("tts")),
+    /**
+     * Recommended text-to-video models.
+     */
+    recommendedVideoTextToVideo: protectedProcedure
+        .query(() => selectRecommended("video", "text_to_video")),
+    /**
+     * Recommended image-to-video models.
+     */
+    recommendedVideoImageToVideo: protectedProcedure
+        .query(() => selectRecommended("video", "image_to_video")),
+    /**
+     * All models available to the user for a given task kind. Aggregates the
+     * configured providers' enumerated models and merges the curated
+     * RECOMMENDED_MODELS list as a fallback. Deduped by `(provider, id)`.
+     * Powers `ui_search_models` for the workflow-builder agent.
+     */
+    availableForKind: protectedProcedure
+        .input(availableForKindInput)
+        .query(async ({ ctx, input }) => {
+        const fromProviders = await collectProviderModelsForKind(ctx.userId, input.kind);
+        const curated = curatedForKind(input.kind);
+        const seen = new Set();
+        const deduped = [];
+        for (const m of [...fromProviders, ...curated]) {
+            const key = `${m.provider ?? ""}|${m.id}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            deduped.push(m);
+        }
+        return deduped;
+    }),
+    /**
+     * All models (recommended + provider models + HF cached).
+     */
+    all: protectedProcedure
+        .query(async ({ ctx }) => getAllModels(ctx.userId)),
+    /**
+     * HuggingFace cached models.
+     */
+    huggingfaceList: protectedProcedure
+        .output(modelsListOutput)
+        .query(async () => {
+        if (isProduction())
+            return [];
+        try {
+            return await readCachedHfModels();
+        }
+        catch {
+            return [];
+        }
+    }),
+    /**
+     * Delete a HuggingFace cached model.
+     */
+    huggingfaceDelete: protectedProcedure
+        .input(hfDeleteInput)
+        .output(z.boolean())
+        .mutation(async ({ input }) => {
+        if (isProduction())
+            return false;
+        try {
+            return await deleteCachedHfModel(input.repo_id);
+        }
+        catch {
+            return false;
+        }
+    }),
+    /**
+     * Search HuggingFace cached models.
+     */
+    huggingfaceSearch: protectedProcedure
+        .input(hfSearchInput)
+        .output(modelsListOutput)
+        .query(async ({ input }) => {
+        if (isProduction())
+            return [];
+        const rawQuery = input.query;
+        const type = input.type;
+        const query = rawQuery && !rawQuery.includes("*") ? `*${rawQuery}*` : rawQuery;
+        try {
+            return await searchCachedHfModels(query ? [query] : undefined, type ? [type] : undefined);
+        }
+        catch {
+            return [];
+        }
+    }),
+    /**
+     * HuggingFace models by type.
+     */
+    huggingfaceByType: protectedProcedure
+        .input(hfByTypeInput)
+        .output(modelsListOutput)
+        .query(async ({ input }) => {
+        try {
+            return await getModelsByHfType(input.model_type);
+        }
+        catch {
+            return [];
+        }
+    }),
+    /**
+     * Transformers.js cached models (everything in the configured cache dir).
+     */
+    transformersJsList: protectedProcedure
+        .output(modelsListOutput)
+        .query(async () => {
+        try {
+            const cached = await scanTransformersJsCache(getTransformersJsCacheDir());
+            return cached.map((c) => tjsRefToUnified({ repo_id: c.repo_id }, "tjs.cached", true, c.size_bytes));
+        }
+        catch {
+            return [];
+        }
+    }),
+    /**
+     * Transformers.js models for a given `tjs.<task>` type.
+     *
+     * Merges the curated recommended list with anything already present in the
+     * 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`).
+     */
+    transformersJsByType: protectedProcedure
+        .input(tjsByTypeInput)
+        .output(modelsListOutput)
+        .query(async ({ input }) => {
+        const modelType = input.model_type;
+        const recs = recommendedFor(modelType);
+        const cacheDir = getTransformersJsCacheDir();
+        const cached = await scanTransformersJsCache(cacheDir).catch(() => []);
+        const cacheSizes = new Map(cached.map((c) => [c.repo_id, c.size_bytes]));
+        const out = [];
+        const seen = new Set();
+        for (const ref of recs) {
+            out.push(tjsRefToUnified(ref, modelType, cacheSizes.has(ref.repo_id), cacheSizes.get(ref.repo_id) ?? null));
+            seen.add(ref.repo_id);
+        }
+        // Surface any cached repo that isn't recommended for this type but
+        // also doesn't have a "home" type — so users see everything they
+        // downloaded for this task without losing the recommended sort.
+        for (const c of cached) {
+            if (seen.has(c.repo_id))
+                continue;
+            const homes = tjsCachedAsRecommended(c.repo_id);
+            if (homes.length > 0)
+                continue;
+            out.push(tjsRefToUnified({ repo_id: c.repo_id }, modelType, true, c.size_bytes));
+        }
+        return out;
+    }),
+    /**
+     * Recommended Transformers.js models for a given `tjs.<task>` type.
+     *
+     * Same curated list as the recommended-first half of `transformersJsByType`,
+     * minus the off-list cached repos. Used by the model picker's
+     * "Recommended downloads" panel so users can see what's worth fetching even
+     * if nothing is cached yet.
+     */
+    transformersJsRecommended: protectedProcedure
+        .input(tjsByTypeInput)
+        .output(modelsListOutput)
+        .query(async ({ input }) => {
+        const modelType = input.model_type;
+        const recs = recommendedFor(modelType);
+        if (recs.length === 0)
+            return [];
+        const cacheDir = getTransformersJsCacheDir();
+        const cached = await scanTransformersJsCache(cacheDir).catch(() => []);
+        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 () => {
+        const instance = await instantiateProvider("ollama", ctx.userId);
+        if (!instance)
+            return [];
+        const models = await instance.getAvailableLanguageModels();
+        return models.map(toOllamaModel);
+    }, [])),
+    /**
+     * LLM models by provider.
+     */
+    llmByProvider: protectedProcedure
+        .input(providerInput)
+        .output(modelsListOutput)
+        .query(async ({ ctx, input }) => safeProviderCall("llmByProvider", { provider: input.provider, userId: ctx.userId }, async () => {
+        const instance = await instantiateProvider(input.provider, ctx.userId);
+        if (!instance)
+            return [];
+        const models = await instance.getAvailableLanguageModels();
+        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.
+     */
+    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 }) => {
+        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);
+            if (!instance)
+                return [];
+            const models = await instance.getAvailableTTSModels();
+            return models.map((m) => toUnifiedModel(m, "tts_model"));
+        }, [])));
+        return results.flat();
+    }),
+    /**
+     * TTS models by provider.
+     */
+    ttsByProvider: protectedProcedure
+        .input(providerInput)
+        .output(modelsListOutput)
+        .query(async ({ ctx, input }) => 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"));
+    }, [])),
+    /**
+     * All ASR models across all providers.
+     */
+    asr: protectedProcedure.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 results.flat();
+    }),
+    /**
+     * ASR models by provider.
+     */
+    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"));
+    }, [])),
+    /**
+     * All video models across all providers.
+     */
+    video: protectedProcedure.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);
+            if (!instance)
+                return [];
+            const models = await instance.getAvailableVideoModels();
+            return models.map((m) => toUnifiedModel(m, "video_model"));
+        }, [])));
+        return results.flat();
+    }),
+    /**
+     * Video models by provider.
+     */
+    videoByProvider: protectedProcedure
+        .input(providerInput)
+        .output(modelsListOutput)
+        .query(async ({ ctx, input }) => safeProviderCall("videoByProvider", { provider: input.provider, userId: ctx.userId }, async () => {
+        const instance = await instantiateProvider(input.provider, ctx.userId);
+        if (!instance)
+            return [];
+        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)
+        })));
+    }),
+    /**
+     * 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.
+     */
+    huggingfaceCacheStatus: protectedProcedure
+        .input(hfFastCacheStatusInput)
+        .output(hfFastCacheStatusOutput)
+        .mutation(async ({ input }) => {
+        return Promise.all(input.map(async (item) => {
+            const allowPatterns = normalizePatterns(item.allow_patterns);
+            const ignorePatterns = normalizePatterns(item.ignore_patterns);
+            if (item.model_type && LLAMA_CPP_MODEL_TYPES.has(item.model_type)) {
+                if (!item.path)
+                    return { key: item.key, downloaded: false };
+                return {
+                    key: item.key,
+                    downloaded: await isLlamaCppModelCached(item.repo_id, item.path)
+                };
+            }
+            if (item.path) {
+                return {
+                    key: item.key,
+                    downloaded: await repoFileInCache(item.repo_id, item.path)
+                };
+            }
+            const files = await listRepoCachedFiles(item.repo_id);
+            return {
+                key: item.key,
+                downloaded: isDownloadedFromFiles(files, allowPatterns, ignorePatterns)
+            };
+        }));
+    }),
+    /**
+     * Pull an Ollama model (stub — streaming not supported via tRPC).
+     */
+    pullOllamaModel: protectedProcedure
+        .input(z.object({ model: z.string().min(1) }))
+        .output(z.object({
+        status: z.string(),
+        message: z.string()
+    }))
+        .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