@bendyline/gezel-inference 1.0.0 → 1.0.2

package/dist/system/amdgpu-adapters.js

@@ -0,0 +1,55 @@
+/**
+ * The amdgpu devices Linux describes in sysfs, for the carve-out decision in
+ * gpu-carve-out.ts — the Linux counterpart of the DXCore adapter listing the
+ * device-health helper reads on Windows. Everything read here is
+ * world-readable, so the machine service's unprivileged account sees it too.
+ */
+import { readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+const DRM_ROOT = '/sys/class/drm';
+const AMD_PCI_VENDOR = 0x1002;
+/**
+ * One entry per amdgpu device: `dedicatedBytes` from `mem_info_vram_total`,
+ * `sharedSystemBytes` from `mem_info_gtt_total` (the system RAM the kernel
+ * lets it map). Connector entries (`card0-HDMI-A-1`) and render nodes are
+ * skipped. Empty off Linux, without amdgpu, or when sysfs cannot be read.
+ */
+export function readAmdgpuAdapters(io = {}) {
+    const readFile = io.readFile ?? ((path) => readFileSync(path, 'utf8'));
+    const readDir = io.readDir ?? ((path) => readdirSync(path));
+    const read = (path) => {
+        try {
+            return readFile(path).trim();
+        }
+        catch {
+            return undefined;
+        }
+    };
+    let cards;
+    try {
+        cards = readDir(DRM_ROOT).filter((entry) => /^card\d+$/.test(entry));
+    }
+    catch {
+        return [];
+    }
+    const adapters = [];
+    for (const card of cards) {
+        const device = join(DRM_ROOT, card, 'device');
+        if (Number.parseInt(read(join(device, 'vendor')) ?? '', 16) !== AMD_PCI_VENDOR)
+            continue;
+        const vram = byteCount(read(join(device, 'mem_info_vram_total')));
+        if (vram === undefined)
+            continue;
+        const gtt = byteCount(read(join(device, 'mem_info_gtt_total')));
+        adapters.push({
+            vendorId: AMD_PCI_VENDOR,
+            dedicatedBytes: vram,
+            ...(gtt !== undefined ? { sharedSystemBytes: gtt } : {}),
+        });
+    }
+    return adapters;
+}
+function byteCount(raw) {
+    const value = raw ? Number(raw) : Number.NaN;
+    return Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}

package/dist/system/gpu-carve-out.d.ts

@@ -0,0 +1,84 @@
+/**
+ * How much memory firmware set aside for an integrated GPU, if any.
+ *
+ * Two kinds of integrated GPU report "VRAM" through Vulkan, and they mean
+ * opposite things:
+ *
+ * - A **shared view** (Intel, Snapdragon, most iGPUs): the number is a slice
+ *   of the same RAM the OS already counts. Adding it double-counts, which is
+ *   why integrated hosts budget from system RAM alone.
+ * - A **carve-out** (an AMD APU's "UMA frame buffer", set in firmware or by
+ *   AMD's Variable Graphics Memory): memory removed before the OS ever counts
+ *   RAM. It sits in neither `os.totalmem()` nor any free-RAM reading, and only
+ *   the GPU can use it. Budgeting from system RAM alone loses it entirely, so
+ *   on a 16 GB laptop raising the carve-out from 3 GB to 8 GB cut the budget
+ *   from ~9 GB to ~4 GB.
+ *
+ * Windows answers directly when the device-health helper can list adapters
+ * (DXCore): an integrated adapter's dedicated memory IS its carve-out. Where
+ * installed RAM is known too, the two must agree — the carve-out has to fit
+ * in the memory that is installed but missing from the OS's count — so one
+ * odd driver figure cannot inflate the budget.
+ *
+ * Without an adapter listing, the GPU's Vulkan-reported memory stands in: a
+ * carve-out fits inside that same gap, a shared view is far larger than it
+ * (a few hundred MB of firmware reservations is the usual gap without one).
+ *
+ * Linux answers through the amdgpu driver instead (see
+ * {@link linuxGpuCarveOutBytes}). Installed RAM is not readable there without
+ * root, and the Vulkan figure cannot stand in: llama.cpp sums every heap of an
+ * integrated GPU, and RADV reports an APU's GTT — borrowed system RAM — beside
+ * the carve-out.
+ *
+ * Anything uncertain answers null — integrated GPUs budgeted from system RAM
+ * alone, as before.
+ */
+export declare function gpuCarveOutBytes(input: {
+    /** Physically installed RAM, or null when it could not be read. */
+    installedRamBytes: number | null;
+    /** RAM the OS reports (`os.totalmem()`). */
+    visibleRamBytes: number;
+    /** Memory the integrated GPU reports for itself through Vulkan. */
+    deviceBytes: number;
+    /** Windows' figure for the integrated adapter's own memory, when listed. */
+    adapterDedicatedBytes?: number | null;
+}): number | null;
+/**
+ * An AMD APU's carve-out on Linux: amdgpu's `mem_info_vram_total`, which on an
+ * APU is the frame buffer firmware reserved before the kernel counted RAM, so
+ * it is absent from MemTotal. Read only for the one amdgpu device there is —
+ * sysfs does not say which of two is integrated — and only when it fits in
+ * what Vulkan reports, which for an integrated GPU is the carve-out plus GTT.
+ * The caller has already decided the GPU llama.cpp picked is integrated.
+ */
+export declare function linuxGpuCarveOutBytes(input: {
+    /** amdgpu devices from sysfs (`readAmdgpuAdapters`). */
+    adapters: readonly GpuAdapterFacts[];
+    visibleRamBytes: number;
+    /** Memory the integrated GPU reports for itself through Vulkan. */
+    deviceBytes: number;
+}): number | null;
+/**
+ * Everything an AMD APU can reach on Linux: its carve-out plus GTT, the
+ * window of system RAM amdgpu lets it map (half of RAM on recent kernels
+ * unless `ttm.pages_limit` raises it). Past that, allocations fail however
+ * much RAM is free. Null without both figures for the one amdgpu device.
+ */
+export declare function linuxGpuAddressableBytes(adapters: readonly GpuAdapterFacts[]): number | null;
+/** The part of a helper adapter record (`DeviceGpuAdapter`) this module reads. */
+export interface GpuAdapterFacts {
+    name?: string;
+    vendorId: number;
+    integrated?: boolean;
+    dedicatedBytes?: number;
+    /** System RAM the adapter may borrow on top of its own (Linux: GTT). */
+    sharedSystemBytes?: number;
+}
+/**
+ * The adapter Windows lists for the GPU llama.cpp picked: the one with the
+ * same name, else the only adapter there is. Null when that is ambiguous —
+ * the name-based guesses then stand.
+ */
+export declare function matchGpuAdapter<T extends GpuAdapterFacts>(adapters: readonly T[], deviceName: string): T | null;
+/** GPU maker from its PCI vendor id. */
+export declare function gpuVendorFromPciId(vendorId: number): 'amd' | 'intel' | 'nvidia' | undefined;

package/dist/system/gpu-carve-out.js

@@ -0,0 +1,111 @@
+/**
+ * How much memory firmware set aside for an integrated GPU, if any.
+ *
+ * Two kinds of integrated GPU report "VRAM" through Vulkan, and they mean
+ * opposite things:
+ *
+ * - A **shared view** (Intel, Snapdragon, most iGPUs): the number is a slice
+ *   of the same RAM the OS already counts. Adding it double-counts, which is
+ *   why integrated hosts budget from system RAM alone.
+ * - A **carve-out** (an AMD APU's "UMA frame buffer", set in firmware or by
+ *   AMD's Variable Graphics Memory): memory removed before the OS ever counts
+ *   RAM. It sits in neither `os.totalmem()` nor any free-RAM reading, and only
+ *   the GPU can use it. Budgeting from system RAM alone loses it entirely, so
+ *   on a 16 GB laptop raising the carve-out from 3 GB to 8 GB cut the budget
+ *   from ~9 GB to ~4 GB.
+ *
+ * Windows answers directly when the device-health helper can list adapters
+ * (DXCore): an integrated adapter's dedicated memory IS its carve-out. Where
+ * installed RAM is known too, the two must agree — the carve-out has to fit
+ * in the memory that is installed but missing from the OS's count — so one
+ * odd driver figure cannot inflate the budget.
+ *
+ * Without an adapter listing, the GPU's Vulkan-reported memory stands in: a
+ * carve-out fits inside that same gap, a shared view is far larger than it
+ * (a few hundred MB of firmware reservations is the usual gap without one).
+ *
+ * Linux answers through the amdgpu driver instead (see
+ * {@link linuxGpuCarveOutBytes}). Installed RAM is not readable there without
+ * root, and the Vulkan figure cannot stand in: llama.cpp sums every heap of an
+ * integrated GPU, and RADV reports an APU's GTT — borrowed system RAM — beside
+ * the carve-out.
+ *
+ * Anything uncertain answers null — integrated GPUs budgeted from system RAM
+ * alone, as before.
+ */
+/** Rounding slack between the installed figure, the OS's count, and the device report. */
+const MATCH_TOLERANCE_BYTES = 64 * 1024 ** 2;
+export function gpuCarveOutBytes(input) {
+    const { installedRamBytes, visibleRamBytes, deviceBytes } = input;
+    const missing = installedRamBytes === null ? null : installedRamBytes - visibleRamBytes;
+    const fits = (bytes) => missing === null || bytes <= missing + MATCH_TOLERANCE_BYTES ? bytes : null;
+    const adapter = input.adapterDedicatedBytes;
+    if (adapter !== undefined && adapter !== null) {
+        if (!(adapter > 0))
+            return null;
+        const agreed = fits(adapter);
+        return agreed === null ? null : missing === null ? agreed : Math.min(agreed, missing);
+    }
+    if (missing === null || !(missing > 0) || !(deviceBytes > 0))
+        return null;
+    return fits(deviceBytes) === null ? null : Math.min(deviceBytes, missing);
+}
+/**
+ * An AMD APU's carve-out on Linux: amdgpu's `mem_info_vram_total`, which on an
+ * APU is the frame buffer firmware reserved before the kernel counted RAM, so
+ * it is absent from MemTotal. Read only for the one amdgpu device there is —
+ * sysfs does not say which of two is integrated — and only when it fits in
+ * what Vulkan reports, which for an integrated GPU is the carve-out plus GTT.
+ * The caller has already decided the GPU llama.cpp picked is integrated.
+ */
+export function linuxGpuCarveOutBytes(input) {
+    const carveOut = soleAmdgpuAdapter(input.adapters)?.dedicatedBytes;
+    if (carveOut === undefined || carveOut > input.deviceBytes + MATCH_TOLERANCE_BYTES)
+        return null;
+    return gpuCarveOutBytes({
+        installedRamBytes: null,
+        visibleRamBytes: input.visibleRamBytes,
+        deviceBytes: input.deviceBytes,
+        adapterDedicatedBytes: carveOut,
+    });
+}
+/**
+ * Everything an AMD APU can reach on Linux: its carve-out plus GTT, the
+ * window of system RAM amdgpu lets it map (half of RAM on recent kernels
+ * unless `ttm.pages_limit` raises it). Past that, allocations fail however
+ * much RAM is free. Null without both figures for the one amdgpu device.
+ */
+export function linuxGpuAddressableBytes(adapters) {
+    const adapter = soleAmdgpuAdapter(adapters);
+    const gtt = adapter?.sharedSystemBytes;
+    if (adapter?.dedicatedBytes === undefined || gtt === undefined || !(gtt > 0))
+        return null;
+    return adapter.dedicatedBytes + gtt;
+}
+/** The one amdgpu device, or null when there are none or several. */
+function soleAmdgpuAdapter(adapters) {
+    const amd = adapters.filter((adapter) => gpuVendorFromPciId(adapter.vendorId) === 'amd' && adapter.dedicatedBytes !== undefined);
+    return amd.length === 1 ? (amd[0] ?? null) : null;
+}
+const nameKey = (name) => name.toLowerCase().replaceAll('(tm)', '').replaceAll('(r)', '').replace(/\s+/g, ' ').trim();
+/**
+ * The adapter Windows lists for the GPU llama.cpp picked: the one with the
+ * same name, else the only adapter there is. Null when that is ambiguous —
+ * the name-based guesses then stand.
+ */
+export function matchGpuAdapter(adapters, deviceName) {
+    const named = adapters.filter((adapter) => adapter.name !== undefined && nameKey(adapter.name) === nameKey(deviceName));
+    if (named.length === 1)
+        return named[0] ?? null;
+    return adapters.length === 1 ? (adapters[0] ?? null) : null;
+}
+/** GPU maker from its PCI vendor id. */
+export function gpuVendorFromPciId(vendorId) {
+    if (vendorId === 0x1002 || vendorId === 0x1022)
+        return 'amd';
+    if (vendorId === 0x8086)
+        return 'intel';
+    if (vendorId === 0x10de)
+        return 'nvidia';
+    return undefined;
+}

package/dist/system/memory.d.ts

@@ -18,6 +18,18 @@ export interface MemoryProfile {
     gpuVramBytes: number | null;
     /** Whether the reported GPU pool is separate from or shared with system RAM. */
     gpuMemoryKind: GpuMemoryKind;
+    /**
+     * Memory firmware set aside for an integrated GPU, outside
+     * `totalRamBytes` (see gpu-carve-out.ts). Present only when measured; a
+     * budget built from this profile must pass it on as `reservedGpuBytes`.
+     */
+    gpuReservedBytes?: number;
+    /**
+     * The most memory an integrated GPU can reach (Linux amdgpu: carve-out
+     * plus GTT; see gpu-carve-out.ts). Present only when measured; a budget
+     * built from this profile must pass it on as `gpuAddressableBytes`.
+     */
+    gpuAddressableBytes?: number;
     /** Where `usableBytes` comes from. Drives the UI's wording. */
     source: MemorySource;
     /**
@@ -71,7 +83,11 @@ export declare function memoryProfileForLlamaGpu(platform: string, totalRamBytes
     name: string;
     vendor?: LlamaGpuVendor;
     memoryKind: LlamaGpuMemoryKind;
-}): MemoryProfile;
+}, 
+/** An integrated GPU's firmware carve-out (gpu-carve-out.ts); ignored otherwise. */
+reservedGpuBytes?: number | null, 
+/** The most an integrated GPU can reach (Linux GTT, gpu-carve-out.ts); ignored otherwise. */
+addressableGpuBytes?: number | null): MemoryProfile;
 /**
  * Capacity changes only on GPU hot-plug / VM reconfiguration, while the live
  * strip may poll once a second. Keep the expensive nvidia-smi / llama device

package/dist/system/memory.js

@@ -1,9 +1,11 @@
 import { execFile } from 'node:child_process';
 import { freemem, platform as osPlatform, totalmem } from 'node:os';
 import { promisify } from 'node:util';
-import { windowsHeadlessSpawnOptions, } from '@bendyline/gezel/native';
+import { readDeviceSystemFacts, windowsHeadlessSpawnOptions, } from '@bendyline/gezel/native';
 import { detectLlamaGpuVram, } from '../providers/llama-cpp/devices.js';
 import { autoDetectBudgetBytes, computeCapacityBudget, setDetectedGpuVramBytes, } from '../providers/native/capacity-budget.js';
+import { readAmdgpuAdapters } from './amdgpu-adapters.js';
+import { gpuCarveOutBytes, gpuVendorFromPciId, linuxGpuAddressableBytes, linuxGpuCarveOutBytes, matchGpuAdapter, } from './gpu-carve-out.js';
 const exec = promisify(execFile);
 let cachedMemoryProfile = null;
 let pendingMemoryProfile = null;
@@ -72,17 +74,53 @@ export async function detectMemoryProfile() {
     // `--list-devices` — the same number the MoE offload planner uses. Use it
     // so a Radeon box gets a real GPU budget (and the "runs on CPU" copy stops
     // lying) instead of the 50%-of-RAM CPU fallback below.
-    const gpu = await detectLlamaGpuVram();
-    if (gpu !== null) {
-        const profile = memoryProfileForLlamaGpu(plat, totalRam, gpu);
+    const probed = await detectLlamaGpuVram();
+    if (probed !== null) {
+        // Windows' own description of the same GPU, when the helper can list it,
+        // replaces the guesses made from its name.
+        const facts = await systemFacts();
+        const adapter = facts?.adapters ? matchGpuAdapter(facts.adapters, probed.name) : null;
+        const vendor = (adapter ? gpuVendorFromPciId(adapter.vendorId) : undefined) ?? probed.vendor;
+        const gpu = {
+            ...probed,
+            memoryKind: adapter?.integrated === undefined
+                ? probed.memoryKind
+                : adapter.integrated
+                    ? 'integrated'
+                    : 'discrete',
+            ...(vendor ? { vendor } : {}),
+        };
+        const reservedGpuBytes = gpu.memoryKind !== 'integrated'
+            ? null
+            : plat === 'win32'
+                ? gpuCarveOutBytes({
+                    installedRamBytes: facts?.installedRamBytes ?? null,
+                    visibleRamBytes: totalRam,
+                    deviceBytes: gpu.vramBytes,
+                    adapterDedicatedBytes: adapter?.integrated ? (adapter.dedicatedBytes ?? null) : null,
+                })
+                : plat === 'linux' && gpu.vendor === 'amd'
+                    ? linuxGpuCarveOutBytes({
+                        adapters: amdgpuAdapters(),
+                        visibleRamBytes: totalRam,
+                        deviceBytes: gpu.vramBytes,
+                    })
+                    : null;
+        // Linux bounds an APU by GTT as well; Windows' shared-memory limit is
+        // not read, so the RAM share stands there as before.
+        const addressableGpuBytes = gpu.memoryKind === 'integrated' && plat === 'linux' && gpu.vendor === 'amd'
+            ? linuxGpuAddressableBytes(amdgpuAdapters())
+            : null;
+        const profile = memoryProfileForLlamaGpu(plat, totalRam, gpu, reservedGpuBytes, addressableGpuBytes);
         // The ambient capacity broker accepts only a VRAM byte count. Publishing
         // an integrated adapter's shared allocation there would add it to RAM a
-        // second time, so publish null for that host class.
-        setDetectedGpuVramBytes(profile.gpuMemoryKind === 'integrated' ? null : gpu.vramBytes, profile.gpuMemoryKind === 'integrated' || profile.gpuMemoryKind === 'unified');
-        // Vendor comes from the device name in the SAME probe (e.g. "AMD Radeon
-        // …" / "Intel Arc …"), so the label always matches the card we sized —
-        // never "AMD" for an Intel GPU. Undefined for unrecognized names → the
-        // UI shows a generic "GPU".
+        // second time, so publish null for that host class — and its carve-out,
+        // which is the one part of it that is not RAM, separately.
+        setDetectedGpuVramBytes(profile.gpuMemoryKind === 'integrated' ? null : gpu.vramBytes, profile.gpuMemoryKind === 'integrated' || profile.gpuMemoryKind === 'unified', profile.gpuReservedBytes ?? null, profile.gpuAddressableBytes ?? null);
+        // Vendor comes from the SAME probe — the matched adapter's PCI id, else
+        // the device name (e.g. "AMD Radeon …" / "Intel Arc …") — so the label
+        // always matches the card we sized, never "AMD" for an Intel GPU.
+        // Undefined for unrecognized devices → the UI shows a generic "GPU".
         return profile;
     }
     setDetectedGpuVramBytes(null);
@@ -105,7 +143,11 @@ export async function detectMemoryProfile() {
  * double-counting an integrated adapter's shared allocation. Exported as the
  * pure policy seam for regression tests and diagnostics tooling.
  */
-export function memoryProfileForLlamaGpu(platform, totalRamBytes, gpu) {
+export function memoryProfileForLlamaGpu(platform, totalRamBytes, gpu, 
+/** An integrated GPU's firmware carve-out (gpu-carve-out.ts); ignored otherwise. */
+reservedGpuBytes = null, 
+/** The most an integrated GPU can reach (Linux GTT, gpu-carve-out.ts); ignored otherwise. */
+addressableGpuBytes = null) {
     const ratioLooksUnified = gpu.vramBytes >= totalRamBytes * 0.75;
     const gpuMemoryKind = gpu.memoryKind === 'integrated'
         ? 'integrated'
@@ -115,21 +157,37 @@ export function memoryProfileForLlamaGpu(platform, totalRamBytes, gpu) {
                 ? 'unified'
                 : 'unknown';
     const shared = gpuMemoryKind === 'integrated' || gpuMemoryKind === 'unified';
+    const reserved = gpuMemoryKind === 'integrated' && reservedGpuBytes !== null && reservedGpuBytes > 0
+        ? reservedGpuBytes
+        : null;
+    const addressable = gpuMemoryKind === 'integrated' && addressableGpuBytes !== null && addressableGpuBytes > 0
+        ? addressableGpuBytes
+        : null;
     const budget = computeCapacityBudget({
         systemRamBytes: totalRamBytes,
         gpuVramBytes: gpu.vramBytes,
         unifiedMemory: shared,
+        reservedGpuBytes: reserved,
+        gpuAddressableBytes: addressable,
     });
     return {
         platform,
         totalRamBytes,
         gpuVramBytes: gpu.vramBytes,
         gpuMemoryKind,
+        ...(reserved !== null ? { gpuReservedBytes: reserved } : {}),
+        ...(addressable !== null ? { gpuAddressableBytes: addressable } : {}),
         source: gpuMemoryKind === 'integrated' ? 'gpu-integrated' : 'gpu-vulkan',
         // A consumer iGPU is effectively system-memory-paced. Keep the same
         // conservative fast-fit ceiling as CPU fallback while the broker may
-        // admit up to its single-pool unified ceiling.
-        usableBytes: gpuMemoryKind === 'integrated' ? Math.floor(totalRamBytes * 0.5) : budget.fastBytes,
+        // admit up to its single-pool unified ceiling. A carve-out adds what the
+        // budget credits from it (`vramBytes`), since none of it is in RAM. Where
+        // GTT is known, what the GPU can reach at all (`fastBytes`) bounds both.
+        usableBytes: gpuMemoryKind !== 'integrated'
+            ? budget.fastBytes
+            : addressable !== null
+                ? Math.min(Math.floor(totalRamBytes * 0.5) + budget.vramBytes, budget.fastBytes)
+                : Math.floor(totalRamBytes * 0.5) + budget.vramBytes,
         budgetBytes: budget.budgetBytes,
         ...(gpu.vendor ? { gpuVendor: gpu.vendor } : {}),
     };
@@ -487,12 +545,45 @@ function isKnownUnifiedNvidiaDevice(name) {
     const normalized = name.toLowerCase();
     return /\bgb10\b/.test(normalized) || normalized.includes('dgx spark');
 }
+/**
+ * A hybrid-graphics laptop powers its discrete GPU down when idle, and the
+ * first `nvidia-smi` after that waits for it to wake: 2.25–2.36 s on an RTX
+ * 5070 Ti laptop (2026-10-15), against ~0.1 s warm. The old 2 s limit read
+ * that as "no NVIDIA GPU", so the machine was sized as CPU-only for the next
+ * minute and offered a 2.4 GB model with a 12 GB card idle beside it. Startup
+ * never awaits this probe, so the margin only costs a caller that asks for the
+ * profile while the driver is truly hung.
+ */
+const NVIDIA_MEMORY_PROBE_TIMEOUT_MS = 10_000;
+let cachedSystemFacts = null;
+/**
+ * Static facts from the bundled device-health helper — installed RAM and
+ * Windows' list of GPUs — read once per process: neither changes without a
+ * reboot. Null off Windows. Empty without the helper, or from one that
+ * predates the `system` command, which leaves every decision on the
+ * name-based guesses it made before.
+ */
+function systemFacts() {
+    cachedSystemFacts ??= readSystemFacts();
+    return cachedSystemFacts;
+}
+async function readSystemFacts() {
+    if (osPlatform() !== 'win32')
+        return null;
+    return readDeviceSystemFacts();
+}
+let cachedAmdgpuAdapters = null;
+/** amdgpu devices from sysfs, read once per process like the Windows facts. */
+function amdgpuAdapters() {
+    cachedAmdgpuAdapters ??= readAmdgpuAdapters();
+    return cachedAmdgpuAdapters;
+}
 async function probeNvidiaMemory() {
     try {
         const { stdout } = await exec('nvidia-smi', ['--query-gpu=name,memory.total', '--format=csv,noheader,nounits'], 
         // Keep this short-lived console probe invisible without detaching it
         // from the daemon that owns and awaits it.
-        { timeout: 2000, ...windowsHeadlessSpawnOptions() });
+        { timeout: NVIDIA_MEMORY_PROBE_TIMEOUT_MS, ...windowsHeadlessSpawnOptions() });
         return parseNvidiaMemoryProbe(stdout);
     }
     catch {

package/dist/transformers-cache.d.ts

@@ -68,6 +68,8 @@ export interface ModelFileSource {
     remoteHost: string;
     remotePathTemplate: string;
     fetchImpl?: typeof fetch;
+    /** Abandons the download (shutdown); the partial file is removed as on any failure. */
+    signal?: AbortSignal;
 }
 /**
  * Make sure a pinned model file sits in the transformers cache whole.

package/dist/transformers-cache.js

@@ -230,11 +230,12 @@ async function sweepPartialDownloads(target) {
         .filter((name) => name.startsWith(prefix))
         .map((name) => rm(join(dirname(target), name), { force: true }).catch(() => { })));
 }
-async function downloadVerified(url, target, pinned, fetchImpl) {
+async function downloadVerified(url, target, pinned, fetchImpl, signal) {
     const partial = `${target}${PARTIAL_DOWNLOAD_INFIX}${process.pid}-${randomUUID().slice(0, 8)}`;
     let handle;
     try {
-        const response = await fetchImpl(url);
+        signal?.throwIfAborted();
+        const response = await fetchImpl(url, signal ? { signal } : undefined);
         if (!response.ok || !response.body) {
             throw new Error(`HTTP ${response.status} downloading ${pinned.file}`);
         }
@@ -245,6 +246,8 @@ async function downloadVerified(url, target, pinned, fetchImpl) {
         const hash = createHash('sha256');
         let received = 0;
         for await (const chunk of response.body) {
+            // A fetchImpl that ignores the signal still stops at the next chunk.
+            signal?.throwIfAborted();
             hash.update(chunk);
             received += chunk.byteLength;
             let offset = 0;
@@ -302,7 +305,7 @@ export async function ensureVerifiedModelFile(cacheDir, modelId, pinned, source)
     }
     await rm(marker, { force: true });
     await rm(target, { force: true });
-    await downloadVerified(remoteFileUrl(source, modelId, pinned), target, pinned, source.fetchImpl ?? fetch);
+    await downloadVerified(remoteFileUrl(source, modelId, pinned), target, pinned, source.fetchImpl ?? fetch, source.signal);
     await writeMarker(marker, target, pinned.digest);
     return 'downloaded';
 }

package/dist/utils/service-worker-entry.d.ts

@@ -16,6 +16,10 @@ export declare const SERVICE_WORKER_ENTRIES: {
     readonly 'static-index': {
         readonly built: "index-store/static-index-worker.js";
     };
+    readonly 'dashboard-composite': {
+        readonly built: "ambient/dashboard-composite-worker.js";
+        readonly source: "ambient/dashboard-composite-worker.ts";
+    };
     readonly 'document-convert': {
         readonly built: "index-store/convert-worker.js";
         readonly source: "index-store/convert-worker.ts";

package/dist/utils/service-worker-entry.js

@@ -13,6 +13,10 @@ export const SERVICE_WORKER_ENTRIES = {
     embeddings: { built: 'memory/embed-worker.js' },
     'image-embeddings': { built: 'memory/image-embed-worker.js' },
     'static-index': { built: 'index-store/static-index-worker.js' },
+    'dashboard-composite': {
+        built: 'ambient/dashboard-composite-worker.js',
+        source: 'ambient/dashboard-composite-worker.ts',
+    },
     'document-convert': {
         built: 'index-store/convert-worker.js',
         source: 'index-store/convert-worker.ts',

package/package.json

@@ -1,16 +1,20 @@
 {
   "name": "@bendyline/gezel-inference",
-  "version": "1.0.0",
-  "description": "Shared on-device inference, model management and knowledge runtime for Gezel hosts.",
+  "version": "1.0.2",
+  "description": "Gezel's on-device inference runtime: native engines, local model management, embeddings, knowledge search, and OpenAI-compatible routes.",
   "license": "MIT",
   "keywords": [
     "gezel",
     "ai",
-    "agents",
     "local-first",
-    "daemon",
-    "server",
-    "llm"
+    "llm",
+    "inference",
+    "on-device",
+    "local-ai",
+    "llama.cpp",
+    "mlx",
+    "embeddings",
+    "openai-compatible"
   ],
   "homepage": "https://github.com/bendyline/gezel",
   "bugs": {
@@ -69,10 +73,10 @@
     "!dist/**/__pycache__"
   ],
   "dependencies": {
-    "@bendyline/gezel": "1.2.5",
-    "@bendyline/gezel-catalog": "1.2.5",
-    "@bendyline/gezel-client": "1.2.5",
-    "@bendyline/gezel-knowledge": "1.2.5",
+    "@bendyline/gezel": "1.2.7",
+    "@bendyline/gezel-catalog": "1.2.7",
+    "@bendyline/gezel-client": "1.2.7",
+    "@bendyline/gezel-knowledge": "1.2.7",
     "hono": "4.13.9",
     "tar": "7.5.21",
     "undici": "8.11.2",