@atomic-chat/core 0.5.1

package/dist/backend/select/tiers.js

@@ -0,0 +1,179 @@
+/**
+ * GPU tier probing and ideal-backend detection. Port of the decision halves of
+ * `detectIdealBackendType`, `tierEnumeratesDevices` and `hasCorroboratingGpu` in
+ * `extensions/llamacpp-upstream-extension/src/index.ts`.
+ *
+ * Nothing here reads hardware, disk or network: the probe result (`GpuProbeInfo[]`, cpu extensions)
+ * and the catalog are parameters; `--list-devices` is an injected function.
+ */
+import { hasEnoughGpuMemory } from './categories.js';
+import { getSupportedFeatures, normalizeFeatures } from './features.js';
+// ---------------------------------------------------------------------------------------------
+// Ideal backend detection (determineBestBackend / detectIdealBackendType / tierEnumeratesDevices)
+// ---------------------------------------------------------------------------------------------
+export function hasDiscreteGpu(gpus) {
+    return gpus.some((g) => g.vulkan_info?.device_type === 'DiscreteGpu' || !!g.nvidia_info);
+}
+/**
+ * Integrated-only hosts (Intel UHD / AMD Vega iGPU on shared RAM) report plenty of "VRAM" yet run
+ * Vulkan far slower than the CPU build, so Vulkan is never the *optimal* pick for them.
+ */
+export function integratedGpuOnly(gpus) {
+    return (!hasDiscreteGpu(gpus) &&
+        gpus.length > 0 &&
+        gpus.every((g) => g.vulkan_info?.device_type === 'IntegratedGpu'));
+}
+/**
+ * Whether the hardware probe corroborates that `backendType` could use a GPU here: CUDA needs an
+ * NVIDIA GPU, Vulkan any GPU, anything else (CPU) is trivially corroborated so the picker can fall
+ * through. Vendor strings as `tauri-plugin-hardware/src/types.rs` serialises them.
+ */
+export function hasCorroboratingGpu(backendType, gpus) {
+    if (backendType.includes('cuda'))
+        return gpus.some((g) => g.vendor === 'NVIDIA');
+    if (backendType.includes('vulkan'))
+        return gpus.length > 0;
+    return true;
+}
+/**
+ * The decision inside `tierEnumeratesDevices`: not installed → `unverified` (nothing to probe);
+ * devices listed → `works`; nothing listed but the probe corroborates a matching GPU → `unverified`
+ * (`--list-devices` is known to come back empty on hosts whose inference path uses CUDA fine, ADR
+ * 2026-05-26); nothing listed and no corroboration → `broken`, degrade to the next tier.
+ */
+export function classifyTierProbe(input) {
+    if (!input.installed)
+        return 'unverified';
+    if (input.devices && input.devices.length > 0)
+        return 'works';
+    return input.corroborated ? 'unverified' : 'broken';
+}
+/**
+ * Non-destructive runtime probe of one GPU tier: find the installed build of that type, run
+ * `--list-devices` through `deps.listDevices`, and classify. A throwing `listInstalled` is
+ * `unverified`; a throwing probe counts as "no devices". `onLog` receives the app's log lines.
+ */
+export async function tierEnumeratesDevices(backendType, gpus, deps, onLog) {
+    const log = onLog ?? (() => { });
+    let installed;
+    try {
+        installed = (await deps.listInstalled()).find((b) => b.backend === backendType);
+    }
+    catch (err) {
+        log(`Tier ${backendType} health-check: listInstalled threw (${err instanceof Error ? err.message : String(err)}); treating as unverified`);
+        return 'unverified';
+    }
+    if (!installed)
+        return 'unverified';
+    let devices = null;
+    let probeError = null;
+    try {
+        devices = await deps.listDevices(installed);
+    }
+    catch (err) {
+        probeError = err instanceof Error ? err.message : String(err);
+    }
+    const corroborated = hasCorroboratingGpu(backendType, gpus);
+    const verdict = classifyTierProbe({ installed: true, devices, corroborated });
+    const reason = probeError ? `--list-devices threw (${probeError})` : '--list-devices returned no devices';
+    if (verdict === 'unverified') {
+        log(`Tier ${backendType} (${installed.version}) ${reason} but NVML/Vulkan corroborates a matching GPU; keeping tier as recommendation (unverified)`);
+    }
+    else if (verdict === 'broken') {
+        log(`Tier ${backendType} (${installed.version}) is broken: ${reason} and the hardware plugin sees no matching GPU; degrading recommendation to next tier`);
+    }
+    return verdict;
+}
+/** First tier (top-down) whose probe is not `broken`, or `null`. */
+export async function pickFirstWorkingTier(tiers, probe) {
+    for (const tier of tiers) {
+        if ((await probe(tier)) !== 'broken')
+            return tier;
+    }
+    return null;
+}
+/**
+ * App regex for "any GPU backend in the catalog", kept verbatim. Note the `-` required right after
+ * the first digit: `win-cuda-13.3-x64` and `win-rocm-10.0-x64` do NOT match, only Vulkan ids do.
+ * It still works because ggml-org always publishes a Vulkan Windows asset next to CUDA.
+ */
+export function isGpuBackendId(backend) {
+    return /-(cuda-\d|rocm-\d|vulkan)-/.test(backend);
+}
+/**
+ * Windows GPU tiers in preference order: CUDA 13, CUDA 12, ROCm (VRAM-gated; `features.rocm` is
+ * already PCI-gated), Vulkan (VRAM-gated, never on integrated-only hosts). Each tier is the first
+ * catalog entry matching its pattern — the catalog is sorted newest first, so that is the newest tag.
+ */
+export function windowsGpuTiers(features, available, archSuffix, gpus) {
+    const pick = (pattern) => available.find((b) => pattern.test(b.backend))?.backend ?? null;
+    const cuda13 = pick(new RegExp(`^win-cuda-13\\.\\d+-${archSuffix}$`));
+    const cuda12 = pick(new RegExp(`^win-cuda-12\\.\\d+-${archSuffix}$`));
+    const rocm = pick(new RegExp(`^win-rocm-\\d+\\.\\d+-${archSuffix}$`));
+    const vulkan = pick(new RegExp(`^win-vulkan-${archSuffix}$`));
+    const enoughVram = hasEnoughGpuMemory(gpus);
+    const tiers = [];
+    if (features.cuda13 && cuda13)
+        tiers.push(cuda13);
+    if (features.cuda12 && cuda12)
+        tiers.push(cuda12);
+    if (features.rocm && enoughVram && rocm)
+        tiers.push(rocm);
+    if (features.vulkan && enoughVram && vulkan && !integratedGpuOnly(gpus))
+        tiers.push(vulkan);
+    return tiers;
+}
+/**
+ * Which backend this host should ideally run. Windows: the first GPU tier that survives the probe;
+ * a GPU-capable host with no GPU backend in the catalog is `detection-failed` (the manifest was
+ * unreachable — ggml-org always publishes CUDA + Vulkan Windows assets), otherwise `cpu-optimal`.
+ * Linux x64: Vulkan when the loader enumerates a device with ≥ 2 GiB; a GPU the loader cannot see
+ * is `detection-failed` (ask again next launch, ATO-464); no accelerator is `cpu-optimal`. macOS and
+ * everything else: `cpu-optimal`. Any thrown error is `detection-failed`.
+ *
+ * The caller wraps this in its 20 s `withTimeout` (timeout → `detection-failed`) and, on Windows,
+ * supplies `listAvailableBackends` / `probeTier`.
+ */
+export async function detectIdealBackendType(input) {
+    const warn = input.onWarn ?? (() => { });
+    try {
+        const { osType, gpus } = input;
+        const features = normalizeFeatures(getSupportedFeatures(osType, input.cpuExtensions, gpus));
+        const enoughVram = hasEnoughGpuMemory(gpus);
+        const integratedOnly = integratedGpuOnly(gpus);
+        const archSuffix = input.arch.includes('aarch64') || input.arch.includes('arm64') ? 'arm64' : 'x64';
+        if (osType === 'windows') {
+            const available = await input.listAvailableBackends();
+            const tiers = windowsGpuTiers(features, available, archSuffix, gpus);
+            const picked = await pickFirstWorkingTier(tiers, input.probeTier);
+            if (picked)
+                return { kind: 'gpu', backend: picked };
+            const gpuCapable = features.cuda13 ||
+                features.cuda12 ||
+                (features.rocm && enoughVram) ||
+                (features.vulkan && enoughVram && !integratedOnly);
+            const anyGpuBackendAvailable = available.some((b) => isGpuBackendId(b.backend));
+            if (gpuCapable && !anyGpuBackendAvailable) {
+                warn('detectIdealBackendType: GPU-capable host but no GPU backend in catalog — treating as detection failure (release stream likely unreachable)');
+                return { kind: 'detection-failed' };
+            }
+            return { kind: 'cpu-optimal' };
+        }
+        if (osType === 'linux') {
+            const anyVulkanDevice = enoughVram;
+            if (features.vulkan && archSuffix === 'x64' && anyVulkanDevice) {
+                return { kind: 'gpu', backend: 'linux-vulkan-x64' };
+            }
+            if (!features.vulkan && archSuffix === 'x64' && gpus.length > 0) {
+                return { kind: 'detection-failed' };
+            }
+            return { kind: 'cpu-optimal' };
+        }
+        return { kind: 'cpu-optimal' };
+    }
+    catch (err) {
+        warn(`detectIdealBackendType failed: ${err instanceof Error ? err.message : String(err)}`);
+        return { kind: 'detection-failed' };
+    }
+}
+//# sourceMappingURL=tiers.js.map

package/dist/backend/select/tiers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiers.js","sourceRoot":"","sources":["../../../src/backend/select/tiers.ts"],"names":[],"mappings":"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"}

package/dist/backend/turboquant.d.ts

@@ -0,0 +1,134 @@
+/**
+ * The TurboQuant fork's backend policy — the `llamacpp` provider's half of `backend/`.
+ *
+ * Ported from: src-tauri/plugins/tauri-plugin-llamacpp/src/backend.rs (`map_old_backend_to_new`,
+ * `determine_supported_backends`, `unified_release_rank`, `compare_backend_versions_for_sort`,
+ * `get_supported_features` with the Linux ROCm probe, `get_backend_category`, `prioritize_backends`,
+ * `copy_backend_dlls`, `is_cuda_installed`) and extensions/llamacpp-extension/src/backend.ts
+ * (`isTurboQuantRelease`, `isStableReleaseTag`, `defaultAssetName`, `getBackendDownloadUrl`,
+ * `getIndexedAssetName`, `getCudart*`, `findUpstreamCudaBinWithCudart`) and index.ts
+ * (`determineBestBackend`, `ensureCudartReady`).
+ *
+ * Why it cannot share the upstream functions: the fork names its builds differently
+ * (`windows-x64-cuda-13.3`, not `win-cuda-13.3-x64`), publishes Linux CUDA and ROCm builds upstream
+ * does not, and versions them as `b<build>-<fork semver>`. Every upstream rule applied to these ids
+ * silently misses: a CPU pack has no category, a fork build sorts below a plain `b8149`, and every
+ * Windows TurboQuant pack is filtered out as unsupported.
+ */
+import type { DataLayout } from '../config/index.js';
+import type { Downloader, ProxyConfig } from '../downloads/index.js';
+import type { BackendFeatures, BackendVersion, GpuProbeInfo, SupportedFeatures } from './types.js';
+export declare const TURBOQUANT_DOWNLOAD_BASE = "https://github.com/AtomicBot-ai/atomic-llama-cpp-turboquant/releases/download";
+export declare const TURBOQUANT_RELEASE_INDEX_URL = "https://github.com/AtomicBot-ai/atomic-llama-cpp-turboquant/releases/latest/download/index.json";
+/** The extension's disk copy of the last good release index (`<data>/llamacpp/release-index.cache.json`). */
+export declare const TURBOQUANT_RELEASE_INDEX_CACHE_FILE = "release-index.cache.json";
+export declare const GGML_ORG_CUDART_DOWNLOAD_BASE = "https://github.com/ggml-org/llama.cpp/releases/download";
+/** The ggml-org tag that ships `cudart-llama-bin-win-cuda-{12.4,13.3}-x64.zip` (a real pin, see the extension). */
+export declare const GGML_ORG_CUDART_PINNED_TAG = "b10205";
+/**
+ * A GPU below this many MiB keeps the CPU build ahead of Vulkan and ROCm (the extension's
+ * `determineBestBackend`). Upstream lowered its own threshold to 2 GiB; the fork never did.
+ */
+export declare const TURBOQUANT_GPU_MIN_VRAM_MIB: number;
+/** Windows CUDA driver floors of the fork plugin; CUDA 12's is lower than upstream's (527.41 vs 551.61). */
+export declare const TURBOQUANT_CUDA_DRIVER_FLOORS: {
+    readonly linux: {
+        readonly cuda11: "450.80.02";
+        readonly cuda12: "525.60.13";
+        readonly cuda13: "580";
+    };
+    readonly windows: {
+        readonly cuda11: "452.39";
+        readonly cuda12: "527.41";
+        readonly cuda13: "581.15";
+    };
+};
+/** RDNA2–RDNA4 as amdkfd `gfx_target_version` values: the architectures the fork's ROCm build carries. */
+export declare const ROCM_SUPPORTED_GFX_TARGET_VERSIONS: readonly number[];
+/** A build of the fork: a legacy `turboquant-<id>-<sha>` tag or a unified `b10018-1.3.0` one. */
+export declare function isTurboQuantRelease(versionOrPair: string): boolean;
+/** An installable stable release: unified tags only (legacy and `dev-latest` are prereleases). */
+export declare function isStableReleaseTag(versionOrPair: string): boolean;
+/** `(build, major, minor, patch)` of a unified tag, as Rust `unified_release_rank` parses it (u32 parts). */
+export declare function unifiedReleaseRank(version: string): [number, number, number, number] | undefined;
+/**
+ * Newest first. Unified tags decide by rank and outrank every legacy tag; legacy tags carry no
+ * order, so they fall through to the Windows numeric compare (legacy janhq `win-*` ids), install
+ * order, then the strings.
+ */
+export declare function compareTurboquantBackendsForSort(left: BackendVersion, right: BackendVersion): number;
+/** Any persisted id (legacy janhq or clean) onto the fork's clean ids. Idempotent. */
+export declare function mapOldTurboquantBackendToNew(oldBackend: string): string;
+/** What the ROCm decision needs from the host: amdkfd architectures and whether HIP is installed. */
+export interface RocmHostProbe {
+    gfxTargetVersions: readonly number[];
+    hasRuntime: boolean;
+}
+/** Every input must be affirmative; anything uncertain stays on Vulkan, which works. */
+export declare function rocmSupportedLinux(hasAmdGpu: boolean, probe: RocmHostProbe): boolean;
+export interface RocmProbeFs {
+    readdir: (path: string) => Promise<string[]>;
+    readFile: (path: string) => Promise<string>;
+    exists: (path: string) => Promise<boolean>;
+}
+/**
+ * The Linux host facts, read the way the plugin reads them: `gfx_target_version` from
+ * `/sys/class/kfd/kfd/topology/nodes/<n>/properties` (zeros are CPU nodes), and `libamdhip64.so`
+ * in a ROCm prefix or on the default library path. Linux paths, so joined as POSIX whatever the host.
+ */
+export declare function probeLinuxRocmHost(fs?: RocmProbeFs): Promise<RocmHostProbe>;
+/** `get_supported_features` of the fork: its own Windows CUDA 12 floor, and ROCm on Linux only. */
+export declare function getTurboquantSupportedFeatures(osType: string, cpuExtensions: readonly string[], gpus: readonly GpuProbeInfo[], rocm?: RocmHostProbe): SupportedFeatures;
+/**
+ * Backend ids the fork publishes for `<osType>-<arch>`. Linux x64 always offers Vulkan (it carries a
+ * portable CPU path and is the bundled fallback); Linux arm64 has only the CUDA 13 build; Windows
+ * arm64 gets a placeholder that matches no asset, exactly as the plugin reports it.
+ */
+export declare function determineTurboquantSupportedBackends(osType: string, arch: string, features: BackendFeatures): string[];
+/** The extension's hardware gate, on every OS: keep what maps onto a supported id. */
+export declare function filterTurboquantBackendsBySupport(backends: readonly BackendVersion[], supported: readonly string[]): BackendVersion[];
+/** Rust `get_backend_category` of the fork; `-cpu` ids are `common_cpus` here. */
+export declare function getTurboquantBackendCategory(backend: string): string | null;
+/** Rust `prioritize_backends`: the newest build of the first category present, else the first entry. */
+export declare function prioritizeTurboquantBackends(backends: readonly BackendVersion[], hasEnoughGpuMemory: boolean): string;
+/** The extension's `determineBestBackend`: 6 GiB on any GPU counts as enough memory. */
+export declare function determineBestTurboquantBackend(backends: readonly BackendVersion[], gpus: readonly GpuProbeInfo[]): string;
+/** `llama-turboquant-<id>.{zip|tar.gz}`: the id prefix decides, then the host OS. */
+export declare function turboquantDefaultAssetName(backend: string, platform?: NodeJS.Platform): string;
+export declare function turboquantArchiveUrl(version: string, backend: string, assetName?: string, platform?: NodeJS.Platform): string;
+/**
+ * The asset the release index names for `tag/backend`, from the extension's disk cache of the index.
+ * The extension read its in-memory copy; the disk copy is the same data and survives a restart.
+ */
+export declare function readTurboquantIndexedAsset(layout: DataLayout, version: string, backend: string): Promise<string | undefined>;
+/** CUDA toolkit minor (`13.3`) of a Windows CUDA id of the fork, else `null`. */
+export declare function turboquantCudaToolkit(backend: string): string | null;
+export declare function turboquantCudartArchiveName(backend: string): string | null;
+export declare function turboquantCudartUrl(backend: string, tag?: string): string | null;
+/**
+ * An installed upstream CUDA pack of the same minor that carries the runtime DLL — the no-network
+ * source. Version folders are tried in reverse string order, as the extension did.
+ */
+export declare function findUpstreamCudaDonor(layout: DataLayout, toolkit: string): Promise<string | undefined>;
+/** Rust `copy_backend_dlls`: `.dll` files whose lowercase name starts with a prefix; the source stays. */
+export declare function copyBackendDlls(srcDir: string, dstDir: string, prefixes: readonly string[]): Promise<number>;
+export interface CudartRepairDeps {
+    layout: DataLayout;
+    downloader: Pick<Downloader, 'download'>;
+    platform?: NodeJS.Platform;
+    proxy?: ProxyConfig | null;
+    log?: (message: string) => void;
+}
+/** Repair an already-installed upstream pack as well as a newly downloaded one. The old app ran
+ * this before every load; installing the companion only during install misses older packs. */
+export declare function ensureUpstreamCudart(version: string, backend: string, backendDir: string, taskId: string, deps: CudartRepairDeps): Promise<'not-needed' | 'present' | 'downloaded'>;
+/**
+ * Make a Windows TurboQuant CUDA pack carry its CUDA runtime: nothing to do when `cudart64_<major>`
+ * is already in `build/bin`; otherwise copy it from an upstream pack of the same minor, and only
+ * then download the pinned ggml-org companion and move its DLLs in. Some fork release zips ship
+ * without the runtime, and without it `--list-devices` is empty on a host with no CUDA toolkit.
+ *
+ * Returns what it did. Throws only for a download or an archive with no DLLs; the callers — install
+ * and load — treat that as a warning, as the extension did, because the pack may still run.
+ */
+export declare function ensureTurboquantCudart(backend: string, backendDir: string, taskId: string, deps: CudartRepairDeps): Promise<'not-needed' | 'present' | 'copied' | 'downloaded'>;