@elizaos/plugin-local-inference 2.0.0-beta.1 → 2.0.3-beta.2

package/src/services/hardware.test.ts

@@ -0,0 +1,231 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { classifyDeviceTier } from "./device-tier";
+import {
+	__resetGpuDetectionCacheForTests,
+	__setGpuDetectionSpawnSyncForTests,
+} from "./gpu-detect";
+import {
+	detectCpuFeatures,
+	detectOpenVinoDevices,
+	deviceCapsFromProbe,
+	probeHardware,
+} from "./hardware";
+
+function detector(files: Record<string, string[] | true>) {
+	const existsSync = (path: string): boolean => path in files;
+	const readdirSync = (path: string): string[] => {
+		const value = files[path];
+		return Array.isArray(value) ? value : [];
+	};
+	return { existsSync, readdirSync };
+}
+
+describe("detectOpenVinoDevices", () => {
+	it("prefers NPU for ASR when OpenVINO runtime and accel node are present", () => {
+		const probe = detectOpenVinoDevices({
+			platform: "linux",
+			env: { OpenVINO_DIR: "/opt/intel/openvino_2026/runtime/cmake" },
+			...detector({
+				"/dev/accel": ["accel0"],
+			}),
+		});
+
+		expect(probe.runtimeAvailable).toBe(true);
+		expect(probe.devices).toEqual(["CPU", "NPU"]);
+		expect(probe.npu.accelNodes).toEqual(["/dev/accel/accel0"]);
+		expect(probe.recommendedAsrDevice).toBe("NPU");
+	});
+
+	it("warns when Intel render nodes exist without the Compute Runtime stack", () => {
+		const probe = detectOpenVinoDevices({
+			platform: "linux",
+			env: { OpenVINO_DIR: "/opt/intel/openvino_2026/runtime/cmake" },
+			...detector({
+				"/dev/dri": ["card0", "renderD128"],
+			}),
+		});
+
+		expect(probe.devices).toEqual(["CPU"]);
+		expect(probe.gpu.renderNodes).toEqual(["/dev/dri/renderD128"]);
+		expect(probe.gpu.computeRuntimeReady).toBe(false);
+		expect(probe.gpu.missingLinuxPackages).toEqual([
+			"intel-opencl-icd",
+			"libigc2",
+			"libigdfcl2",
+		]);
+		expect(probe.warnings[0]).toContain("Intel Compute Runtime packages");
+	});
+
+	it("does not report OpenVINO devices when the runtime is not installed", () => {
+		const probe = detectOpenVinoDevices({
+			platform: "linux",
+			env: {},
+			...detector({
+				"/dev/accel": ["accel0"],
+				"/dev/dri": ["renderD128"],
+				"/usr/lib/x86_64-linux-gnu/intel-opencl/libigdrcl.so": true,
+			}),
+		});
+
+		expect(probe.runtimeAvailable).toBe(false);
+		expect(probe.devices).toEqual([]);
+		expect(probe.recommendedAsrDevice).toBeNull();
+		expect(probe.warnings).toContain(
+			"Intel accelerator nodes are present, but OpenVINO Runtime was not found; source setupvars.sh or set OpenVINO_DIR.",
+		);
+	});
+
+	it("treats sandbox-denied optional system paths as unavailable", () => {
+		const existsSync = (path: string): boolean => {
+			throw Object.assign(
+				new Error(`mobile-fs-shim: path escapes workspace root: ${path}`),
+				{ code: "EACCES" },
+			);
+		};
+		const readdirSync = (path: string): string[] => {
+			throw new Error(`unexpected readdir for ${path}`);
+		};
+
+		const probe = detectOpenVinoDevices({
+			platform: "linux",
+			env: {},
+			existsSync,
+			readdirSync,
+		});
+
+		expect(probe.runtimeAvailable).toBe(false);
+		expect(probe.devices).toEqual([]);
+		expect(probe.gpu.renderNodes).toEqual([]);
+		expect(probe.npu.accelNodes).toEqual([]);
+		expect(probe.recommendedAsrDevice).toBeNull();
+	});
+});
+
+describe("detectCpuFeatures", () => {
+	it("maps Linux ARM cpuinfo feature tokens to the shared probe shape", () => {
+		const cpuinfo = [
+			"processor\t: 0",
+			"Features\t: fp asimd evtstrm aes asimddp i8mm sve sve2",
+			"",
+		].join("\n");
+
+		expect(
+			detectCpuFeatures({
+				platform: "linux",
+				arch: "arm64",
+				readFileSync: () => cpuinfo,
+			}),
+		).toEqual({
+			neon: true,
+			dotprod: true,
+			i8mm: true,
+			sve: true,
+			sve2: true,
+		});
+	});
+
+	it("maps Android ARM cpuinfo aliases without assuming missing features", () => {
+		const cpuinfo = "Features\t: fp neon dotprod\n";
+
+		expect(
+			detectCpuFeatures({
+				platform: "android",
+				arch: "arm64",
+				readFileSync: () => cpuinfo,
+			}),
+		).toEqual({
+			neon: true,
+			dotprod: true,
+			i8mm: false,
+			sve: false,
+			sve2: false,
+		});
+	});
+
+	it("uses Darwin sysctl keys where available and treats missing keys as false", () => {
+		const values: Record<string, string> = {
+			"hw.optional.arm.FEAT_DotProd": "1\n",
+			"hw.optional.arm.FEAT_I8MM": "0\n",
+		};
+
+		expect(
+			detectCpuFeatures({
+				platform: "darwin",
+				arch: "arm64",
+				execFileSync: (_file, args) => {
+					const key = args[1];
+					if (key in values) return values[key];
+					throw new Error(`unknown sysctl ${key}`);
+				},
+			}),
+		).toEqual({
+			neon: true,
+			dotprod: true,
+			i8mm: false,
+			sve: false,
+			sve2: false,
+		});
+	});
+
+	it("does not claim CPU backend support for ARM when NEON evidence is absent", () => {
+		expect(
+			deviceCapsFromProbe({
+				totalRamGb: 16,
+				freeRamGb: 12,
+				gpu: null,
+				cpuCores: 8,
+				platform: "linux",
+				arch: "arm64",
+				appleSilicon: false,
+				recommendedBucket: "mid",
+				source: "os-fallback",
+			}),
+		).toEqual({
+			availableBackends: [],
+			ramMb: 16 * 1024,
+			cpuFeatures: undefined,
+		});
+	});
+});
+
+describe("probeHardware GPU detection", () => {
+	afterEach(() => {
+		__setGpuDetectionSpawnSyncForTests(null);
+		__resetGpuDetectionCacheForTests();
+	});
+
+	const fakeSpawn =
+		(stdout: string, status: number) =>
+		(): { stdout: string; stderr: string; status: number; signal: null } => ({
+			stdout,
+			stderr: "",
+			status,
+			signal: null,
+		});
+
+	it("populates a CUDA GPU + VRAM from nvidia-smi and lifts the tier off CPU", async () => {
+		// reset clears BOTH the cache and any prior override, so reset first.
+		__resetGpuDetectionCacheForTests();
+		__setGpuDetectionSpawnSyncForTests(
+			fakeSpawn("NVIDIA GeForce RTX 4090, 24564\n", 0) as never,
+		);
+		const probe = await probeHardware();
+		expect(probe.gpu).not.toBeNull();
+		expect(probe.gpu?.backend).toBe("cuda");
+		expect(probe.gpu?.totalVramGb).toBeGreaterThanOrEqual(23);
+		// A 24 GB discrete GPU must not be mis-tiered as a CPU box.
+		expect(["MAX", "GOOD"]).toContain(classifyDeviceTier(probe).tier);
+	});
+
+	it("reports gpu:null when nvidia-smi is absent on a non-Apple host", async () => {
+		__resetGpuDetectionCacheForTests();
+		__setGpuDetectionSpawnSyncForTests(fakeSpawn("", 1) as never);
+		const probe = await probeHardware();
+		if (probe.appleSilicon) {
+			// Unified memory: the Apple GPU is always present.
+			expect(probe.gpu?.backend).toBe("metal");
+		} else {
+			expect(probe.gpu).toBeNull();
+		}
+	});
+});

package/src/services/hardware.ts

@@ -0,0 +1,410 @@
+/**
+ * Hardware probe for local inference sizing.
+ *
+ * Uses `capacitor-llama` when available to read GPU backend + VRAM. Falls back
+ * to Node's `os` module when the binding isn't installed — we don't require
+ * the plugin to be loaded for the probe endpoint to return useful data.
+ *
+ * Dynamic import is intentional: the binding pulls a native prebuilt that we
+ * don't want eagerly required at module-load time (breaks CI environments
+ * without the trusted-dependency flag).
+ */
+
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import { detectGpu } from "./gpu-detect";
+import type { Eliza1Backend, Eliza1DeviceCaps } from "./manifest";
+import type {
+	CpuFeatureProbe,
+	HardwareProbe,
+	ModelBucket,
+	OpenVinoDeviceKind,
+	OpenVinoHardwareProbe,
+} from "./types";
+
+const BYTES_PER_GB = 1024 ** 3;
+
+function bytesToGb(bytes: number): number {
+	return Math.round((bytes / BYTES_PER_GB) * 10) / 10;
+}
+
+/**
+ * Pick a default bucket based on total available memory and architecture.
+ *
+ * On Apple Silicon the GPU shares system RAM, so shared memory acts as VRAM.
+ * On discrete-GPU x86 boxes we weight VRAM higher than system RAM.
+ */
+function recommendBucket(
+	totalRamGb: number,
+	vramGb: number,
+	appleSilicon: boolean,
+): ModelBucket {
+	const effective = appleSilicon
+		? totalRamGb
+		: vramGb > 0
+			? Math.max(vramGb * 1.25, totalRamGb * 0.5)
+			: totalRamGb * 0.5;
+
+	if (effective >= 36) return "xl";
+	if (effective >= 18) return "large";
+	if (effective >= 9) return "mid";
+	return "small";
+}
+
+interface CpuFeatureDetectionHost {
+	platform?: NodeJS.Platform;
+	arch?: NodeJS.Architecture;
+	readFileSync?: (path: string, encoding: BufferEncoding) => string;
+	execFileSync?: (
+		file: string,
+		args: readonly string[],
+		options: { encoding: BufferEncoding; stdio: "pipe" },
+	) => string;
+}
+
+const DARWIN_ARM_FEATURE_SYSCTLS: Readonly<
+	Array<[keyof CpuFeatureProbe, string]>
+> = [
+	["dotprod", "hw.optional.arm.FEAT_DotProd"],
+	["i8mm", "hw.optional.arm.FEAT_I8MM"],
+	["sve", "hw.optional.arm.FEAT_SVE"],
+	["sve2", "hw.optional.arm.FEAT_SVE2"],
+];
+
+function emptyCpuFeatures(): CpuFeatureProbe {
+	return {
+		neon: false,
+		dotprod: false,
+		i8mm: false,
+		sve: false,
+		sve2: false,
+	};
+}
+
+function linuxArmFeatureTokens(cpuinfo: string): Set<string> {
+	const tokens = new Set<string>();
+	for (const line of cpuinfo.split(/\r?\n/)) {
+		const [rawKey, rawValue] = line.split(":", 2);
+		if (!rawKey || !rawValue) continue;
+		const key = rawKey.trim().toLowerCase();
+		if (key !== "features" && key !== "flags") continue;
+		for (const token of rawValue.trim().toLowerCase().split(/\s+/)) {
+			if (token) tokens.add(token);
+		}
+	}
+	return tokens;
+}
+
+export function detectCpuFeatures(
+	host: CpuFeatureDetectionHost = {},
+): CpuFeatureProbe | undefined {
+	const platform = host.platform ?? process.platform;
+	const arch = host.arch ?? process.arch;
+	if (arch !== "arm64" && arch !== "arm") return undefined;
+
+	if (platform === "linux" || platform === "android") {
+		const readFileSync = host.readFileSync ?? fs.readFileSync;
+		try {
+			const tokens = linuxArmFeatureTokens(
+				readFileSync("/proc/cpuinfo", "utf8"),
+			);
+			const features = emptyCpuFeatures();
+			features.neon = tokens.has("asimd") || tokens.has("neon");
+			features.dotprod = tokens.has("asimddp") || tokens.has("dotprod");
+			features.i8mm = tokens.has("i8mm") || tokens.has("asimdi8mm");
+			features.sve = tokens.has("sve");
+			features.sve2 = tokens.has("sve2");
+			return features;
+		} catch {
+			return undefined;
+		}
+	}
+
+	if (platform === "darwin") {
+		const run = host.execFileSync ?? execFileSync;
+		const features = emptyCpuFeatures();
+		// Arm64 Darwin requires Advanced SIMD/NEON. Some macOS releases do not
+		// expose a stable sysctl for it, so use the ABI guarantee for baseline.
+		features.neon = true;
+		for (const [feature, key] of DARWIN_ARM_FEATURE_SYSCTLS) {
+			try {
+				const value = run("sysctl", ["-n", key], {
+					encoding: "utf8",
+					stdio: "pipe",
+				});
+				const normalizedValue =
+					typeof value === "string" ? value.trim() : value.toString().trim();
+				features[feature] =
+					normalizedValue === "1" || normalizedValue.toLowerCase() === "true";
+			} catch {
+				features[feature] = false;
+			}
+		}
+		return features;
+	}
+
+	return undefined;
+}
+
+export function hasUsableArmCpuBackend(probe: HardwareProbe): boolean {
+	if (probe.arch !== "arm64" && probe.arch !== "arm") return true;
+	return probe.cpuFeatures?.neon === true;
+}
+
+/**
+ * Detect the host GPU + its VRAM for device-tier classification, VRAM
+ * admission, and `n_gpu_layers` sizing. Without this every box — including a
+ * 24 GB discrete workstation — probes as `gpu: null` and is mis-tiered as CPU.
+ *
+ *  - NVIDIA: `nvidia-smi` (the cheapest real pre-load VRAM number).
+ *  - Apple Silicon: unified memory, so system RAM IS the GPU working set.
+ *  - AMD/Intel (Vulkan): no cheap pre-load VRAM query exists; left `null` here
+ *    rather than guessed — the fused ABI surfaces real VRAM after model load.
+ */
+function detectProbeGpu(
+	appleSilicon: boolean,
+	totalRamBytes: number,
+	freeRamBytes: number,
+): HardwareProbe["gpu"] {
+	const nvidia = detectGpu();
+	if (nvidia.nvidiaPresent && nvidia.gpu) {
+		const totalVramGb = bytesToGb(nvidia.gpu.totalMemoryMiB * 1024 * 1024);
+		// nvidia-smi `memory.total` is capacity; an idle probe treats it as free.
+		// Real free-VRAM admission happens against the live backend post-load.
+		return { backend: "cuda", totalVramGb, freeVramGb: totalVramGb };
+	}
+	if (appleSilicon) {
+		return {
+			backend: "metal",
+			totalVramGb: bytesToGb(totalRamBytes),
+			freeVramGb: bytesToGb(freeRamBytes),
+		};
+	}
+	return null;
+}
+
+const OPENVINO_LINUX_GPU_PACKAGES = [
+	"intel-opencl-icd",
+	"libigc2",
+	"libigdfcl2",
+] as const;
+
+interface OpenVinoDetectionHost {
+	platform?: NodeJS.Platform;
+	env?: NodeJS.ProcessEnv;
+	existsSync?: (path: string) => boolean;
+	readdirSync?: (path: string) => string[];
+}
+
+function readableEntries(
+	dir: string,
+	host: Required<Pick<OpenVinoDetectionHost, "existsSync" | "readdirSync">>,
+	prefix: string,
+): string[] {
+	if (!pathExists(dir, host.existsSync)) return [];
+	try {
+		return host
+			.readdirSync(dir)
+			.filter((entry) => entry.startsWith(prefix))
+			.map((entry) => `${dir}/${entry}`);
+	} catch {
+		return [];
+	}
+}
+
+function pathExists(
+	path: string,
+	existsSync: Required<OpenVinoDetectionHost>["existsSync"],
+): boolean {
+	try {
+		return existsSync(path);
+	} catch {
+		return false;
+	}
+}
+
+function hasAny(
+	paths: string[],
+	existsSync: Required<OpenVinoDetectionHost>["existsSync"],
+): boolean {
+	return paths.some((candidate) => pathExists(candidate, existsSync));
+}
+
+export function detectOpenVinoDevices(
+	host: OpenVinoDetectionHost = {},
+): OpenVinoHardwareProbe {
+	const platform = host.platform ?? process.platform;
+	const env = host.env ?? process.env;
+	const existsSync = host.existsSync ?? fs.existsSync;
+	const readdirSync =
+		host.readdirSync ??
+		((dir: string) => fs.readdirSync(dir, { encoding: "utf8" }) as string[]);
+	const io = { existsSync, readdirSync };
+
+	const runtimeAvailable =
+		Boolean(env.OpenVINO_DIR || env.INTEL_OPENVINO_DIR) ||
+		hasAny(
+			[
+				"/opt/intel/openvino/setupvars.sh",
+				"/opt/intel/openvino_2026/setupvars.sh",
+				"/usr/lib/x86_64-linux-gnu/libopenvino.so",
+				"/usr/lib/x86_64-linux-gnu/libopenvino.so.0",
+				"/usr/lib/aarch64-linux-gnu/libopenvino.so",
+				"/usr/lib/aarch64-linux-gnu/libopenvino.so.0",
+			],
+			existsSync,
+		);
+
+	const renderNodes =
+		platform === "linux" ? readableEntries("/dev/dri", io, "renderD") : [];
+	const accelNodes =
+		platform === "linux" ? readableEntries("/dev/accel", io, "accel") : [];
+	const intelComputeRuntimeReady =
+		platform === "linux" &&
+		hasAny(
+			[
+				"/usr/lib/x86_64-linux-gnu/intel-opencl/libigdrcl.so",
+				"/usr/lib/x86_64-linux-gnu/libigc.so.1",
+				"/usr/lib/x86_64-linux-gnu/libigdfcl.so.1",
+				"/usr/lib/aarch64-linux-gnu/intel-opencl/libigdrcl.so",
+				"/usr/lib/aarch64-linux-gnu/libigc.so.1",
+				"/usr/lib/aarch64-linux-gnu/libigdfcl.so.1",
+			],
+			existsSync,
+		);
+	const devices: OpenVinoDeviceKind[] = [];
+	if (runtimeAvailable) devices.push("CPU");
+	if (runtimeAvailable && renderNodes.length > 0 && intelComputeRuntimeReady) {
+		devices.push("GPU");
+	}
+	if (runtimeAvailable && accelNodes.length > 0) devices.push("NPU");
+
+	const warnings: string[] = [];
+	if (renderNodes.length > 0 && !intelComputeRuntimeReady) {
+		warnings.push(
+			`OpenVINO GPU needs Intel Compute Runtime packages: ${OPENVINO_LINUX_GPU_PACKAGES.join(", ")}`,
+		);
+	}
+	if ((renderNodes.length > 0 || accelNodes.length > 0) && !runtimeAvailable) {
+		warnings.push(
+			"Intel accelerator nodes are present, but OpenVINO Runtime was not found; source setupvars.sh or set OpenVINO_DIR.",
+		);
+	}
+
+	return {
+		runtimeAvailable,
+		devices,
+		gpu: {
+			renderNodes,
+			computeRuntimeReady: intelComputeRuntimeReady,
+			missingLinuxPackages:
+				renderNodes.length > 0 && !intelComputeRuntimeReady
+					? [...OPENVINO_LINUX_GPU_PACKAGES]
+					: [],
+		},
+		npu: { accelNodes },
+		recommendedAsrDevice: devices.includes("NPU")
+			? "NPU"
+			: devices.includes("GPU")
+				? "GPU"
+				: devices.includes("CPU")
+					? "CPU"
+					: null,
+		warnings,
+	};
+}
+
+/**
+ * Read current system + GPU state. Cheap enough to call per-request; no
+ * internal caching so the UI always reflects live VRAM usage.
+ */
+export async function probeHardware(): Promise<HardwareProbe> {
+	const totalRamBytes = os.totalmem();
+	const freeRamBytes = os.freemem();
+	const cpuCores = os.cpus().length;
+	const platform = process.platform;
+	const arch = process.arch;
+	const appleSilicon = platform === "darwin" && arch === "arm64";
+	const openvino = detectOpenVinoDevices();
+	const cpuFeatures = detectCpuFeatures({ platform, arch });
+
+	const gpu = detectProbeGpu(appleSilicon, totalRamBytes, freeRamBytes);
+	const totalRamGb = bytesToGb(totalRamBytes);
+	return {
+		totalRamGb,
+		freeRamGb: bytesToGb(freeRamBytes),
+		gpu,
+		cpuCores,
+		cpuFeatures,
+		platform,
+		arch,
+		appleSilicon,
+		recommendedBucket: recommendBucket(
+			totalRamGb,
+			gpu?.totalVramGb ?? 0,
+			appleSilicon,
+		),
+		source: "os-fallback",
+		openvino,
+	};
+}
+
+/**
+ * Map a hardware probe onto the Eliza-1 device-capability snapshot used by
+ * the manifest validator and the bundle downloader.
+ *
+ * Backends: `cpu` is always present (the floor). A detected GPU backend is
+ * added when `capacitor-llama` reports one (`metal` on Apple Silicon, `cuda`
+ * on NVIDIA, `vulkan` on cross-vendor Linux/Android). We do not synthesize
+ * `rocm` from the probe — `capacitor-llama` reports AMD as `vulkan` on the
+ * builds we ship, and a bundle that only verified ROCm but not Vulkan is
+ * legitimately not installable here.
+ *
+ * `ramMb` is total system RAM. On Apple Silicon that is also the GPU's
+ * working memory; on discrete-GPU boxes the recommendation engine layers
+ * its own VRAM-vs-RAM heuristics on top, but the bundle's `ramBudgetMb.min`
+ * is a system-RAM floor in every manifest.
+ */
+export function deviceCapsFromProbe(probe: HardwareProbe): Eliza1DeviceCaps {
+	const backends: Eliza1Backend[] = hasUsableArmCpuBackend(probe)
+		? ["cpu"]
+		: [];
+	const gpuBackend = probe.gpu?.backend;
+	if (
+		gpuBackend === "metal" ||
+		gpuBackend === "cuda" ||
+		gpuBackend === "vulkan"
+	) {
+		backends.unshift(gpuBackend);
+	}
+	return {
+		availableBackends: backends,
+		ramMb: Math.round(probe.totalRamGb * 1024),
+		cpuFeatures: probe.cpuFeatures,
+	};
+}
+
+/**
+ * Compatibility assessment for a specific model given current hardware.
+ *
+ * Green/fits: comfortable headroom (model < 70% of effective memory).
+ * Yellow/tight: will run but may swap or stutter under load.
+ * Red/wontfit: exceeds available memory.
+ */
+export function assessFit(
+	probe: HardwareProbe,
+	modelSizeGb: number,
+	minRamGb: number,
+): "fits" | "tight" | "wontfit" {
+	const effectiveGb = probe.appleSilicon
+		? probe.totalRamGb
+		: probe.gpu
+			? Math.max(probe.gpu.totalVramGb, probe.totalRamGb * 0.5)
+			: probe.totalRamGb * 0.5;
+
+	if (effectiveGb < minRamGb) return "wontfit";
+	if (modelSizeGb > effectiveGb * 0.9) return "wontfit";
+	if (modelSizeGb > effectiveGb * 0.7) return "tight";
+	return "fits";
+}

package/src/services/hf-search.d.ts

@@ -0,0 +1,26 @@
+/**
+ * HuggingFace Hub search for GGUF models.
+ *
+ * Calls `https://huggingface.co/api/models` with `filter=gguf` to narrow
+ * results to repos that actually ship GGUF quantisations. Each matching
+ * repo is expanded with `/api/models/<repo>` to pick a representative
+ * quant file (preferring Q4_K_M when present). Results are shaped like
+ * `CatalogModel` so the existing ModelCard renders them directly.
+ *
+ * We deliberately do not persist these — they're dynamic, and a curated
+ * entry with the same hfRepo always takes precedence in the UI.
+ */
+import type { CatalogModel } from "./types";
+/**
+ * Search HuggingFace for GGUF repos matching `query`, returning
+ * catalog-shaped entries ready for the Model Hub UI.
+ */
+export declare function searchHuggingFaceGguf(query: string, limit?: number): Promise<CatalogModel[]>;
+/**
+ * Search ModelScope for GGUF repos. ModelScope exposes reliable owner-list
+ * and repo-file APIs, so this accepts either `owner/model` or an owner name
+ * and filters the returned repos for GGUF files.
+ */
+export declare function searchModelScopeGguf(query: string, limit?: number): Promise<CatalogModel[]>;
+export declare function searchModelHubGguf(query: string, hub?: "huggingface" | "modelscope", limit?: number): Promise<CatalogModel[]>;
+//# sourceMappingURL=hf-search.d.ts.map

package/src/services/hf-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hf-search.d.ts","sourceRoot":"","sources":["hf-search.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAe,MAAM,SAAS,CAAC;AAgLzD;;;GAGG;AACH,wBAAsB,qBAAqB,CAC1C,KAAK,EAAE,MAAM,EACb,KAAK,SAAK,GACR,OAAO,CAAC,YAAY,EAAE,CAAC,CAmFzB;AAiGD;;;;GAIG;AACH,wBAAsB,oBAAoB,CACzC,KAAK,EAAE,MAAM,EACb,KAAK,SAAK,GACR,OAAO,CAAC,YAAY,EAAE,CAAC,CAyBzB;AAED,wBAAsB,kBAAkB,CACvC,KAAK,EAAE,MAAM,EACb,GAAG,GAAE,aAAa,GAAG,YAA4B,EACjD,KAAK,SAAK,GACR,OAAO,CAAC,YAAY,EAAE,CAAC,CAIzB"}