@bendyline/gezel-inference 1.0.1 → 1.0.3

package/dist/providers/llama-cpp/cache-adapter.d.ts

@@ -123,7 +123,7 @@ export declare class LlamaCppCacheAdapter implements EngineCacheAdapter {
      */
     private allocationTail;
     private engineGeneration;
-    private readonly slotCount;
+    private slotCount;
     private readonly resolveBaseUrl;
     private readonly resolveAuthToken;
     private readonly fetchImpl;
@@ -168,6 +168,12 @@ export declare class LlamaCppCacheAdapter implements EngineCacheAdapter {
      */
     private slotActionsUnsupported;
     constructor(opts: LlamaCppCacheAdapterOptions);
+    /**
+     * Follow an engine relaunched with a different `--parallel` count. Every
+     * binding goes with it: a session pinned to a slot the new engine lacks
+     * would send an `id_slot` the server rejects.
+     */
+    setSlotCount(slotCount: number): void;
     /** The provider survives engine restarts, but its resident slot contents do not. */
     resetEngineState(): void;
     /**

package/dist/providers/llama-cpp/cache-adapter.js

@@ -181,6 +181,15 @@ export class LlamaCppCacheAdapter {
             throw new Error('Invalid llama disk cache budget');
         this.diskCacheBudgetBytes = budget * 1024 * 1024;
     }
+    /**
+     * Follow an engine relaunched with a different `--parallel` count. Every
+     * binding goes with it: a session pinned to a slot the new engine lacks
+     * would send an `id_slot` the server rejects.
+     */
+    setSlotCount(slotCount) {
+        this.slotCount = Math.max(1, Math.floor(slotCount));
+        this.resetEngineState();
+    }
     /** The provider survives engine restarts, but its resident slot contents do not. */
     resetEngineState() {
         this.engineGeneration++;
@@ -306,7 +315,8 @@ export class LlamaCppCacheAdapter {
             if (!entry || typeof entry !== 'object')
                 continue;
             const slot = entry.id;
-            const cachedTokens = entry.n_cache_tokens;
+            // The slot's resident tokens (prompt plus generated); there is no `n_cache_tokens`.
+            const cachedTokens = entry.n_prompt_tokens;
             if (typeof slot !== 'number' || typeof cachedTokens !== 'number' || cachedTokens <= 0) {
                 continue;
             }

package/dist/providers/llama-cpp/devices.d.ts

@@ -31,6 +31,14 @@ export interface LlamaDeviceProbe {
     probedAt: string;
     /** True when returned from the on-disk cache rather than a fresh spawn. */
     cached: boolean;
+    /**
+     * The RAM the OS reported when the probe ran. Changing an integrated GPU's
+     * firmware carve-out changes this figure and the GPU's own, so a mismatch
+     * means the cached devices describe a machine that no longer exists.
+     */
+    systemRamBytes?: number;
+    /** {@link llamaBinaryFingerprint} of the build that answered. */
+    binary?: string;
 }
 export interface NvidiaRuntimeDevice {
     index: number;
@@ -69,19 +77,31 @@ export declare function maxGpuVramBytes(devices: LlamaDevice[]): number;
  * (e.g. "AMD Radeon RX 7900 XTX") in a tier rationale. Pure — unit-tested.
  */
 export declare function pickBestGpuDevice(devices: LlamaDevice[]): LlamaDevice | null;
+/**
+ * Which build a cached listing came from: its path (the backend) and its
+ * size and mtime (the release, since a native update rewrites the files).
+ * A listing taken from the CPU build, or from the build an update replaced,
+ * said "no GPU" about a 32 GB Radeon and was served for the rest of the day
+ * (2026-10-19).
+ */
+export declare function llamaBinaryFingerprint(binaryPath: string): string;
 /**
  * Probe device memory by running `<binaryPath> --list-devices`, caching
  * the result. Reads the cache when present (VRAM capacity is stable per
- * machine); pass `force` to re-probe. Any failure (spawn error, no
+ * machine), the OS still reports the RAM it was probed with, and the same
+ * build answered it; an empty listing is re-asked hourly. Pass `force` to
+ * re-probe. Any failure (spawn error, no
  * cache, unparseable output) resolves to an empty device list — the
  * planner then simply does nothing and the engine's own `--fit`/`-ngl
- * auto` takes over. `nowIso` is injectable for deterministic tests.
+ * auto` takes over. `nowIso` and `systemRamBytes` are injectable for
+ * deterministic tests.
  */
 export declare function probeLlamaDevices(opts: {
     binaryPath: string;
     home: string;
     force?: boolean;
     nowIso?: () => string;
+    systemRamBytes?: number;
 }): Promise<LlamaDeviceProbe>;
 /**
  * Best-effort VRAM for a non-NVIDIA GPU (AMD Radeon, Intel Arc, any Vulkan

package/dist/providers/llama-cpp/devices.js

@@ -16,7 +16,8 @@
  * `backend.json` pattern in `core/native/llama-backend.ts`.
  */
 import { execFile } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { totalmem } from 'node:os';
 import { delimiter, dirname, join } from 'node:path';
 import { promisify } from 'node:util';
 import { windowsHeadlessSpawnOptions } from '@bendyline/gezel/native';
@@ -121,23 +122,59 @@ export function pickBestGpuDevice(devices) {
 function cachePath(home) {
     return join(home, 'engines', 'llama-cpp', 'devices.json');
 }
+/**
+ * An empty listing is re-asked after this long. A CPU build always answers
+ * "(none)", but so can a GPU build whose driver was mid-update, and a cached
+ * "no GPU" sizes every model against system RAM.
+ */
+const EMPTY_DEVICES_RETRY_MS = 60 * 60 * 1000;
+/**
+ * Which build a cached listing came from: its path (the backend) and its
+ * size and mtime (the release, since a native update rewrites the files).
+ * A listing taken from the CPU build, or from the build an update replaced,
+ * said "no GPU" about a 32 GB Radeon and was served for the rest of the day
+ * (2026-10-19).
+ */
+export function llamaBinaryFingerprint(binaryPath) {
+    try {
+        const { size, mtimeMs } = statSync(binaryPath);
+        return `${binaryPath}|${size}|${Math.floor(mtimeMs)}`;
+    }
+    catch {
+        return binaryPath;
+    }
+}
 /**
  * Probe device memory by running `<binaryPath> --list-devices`, caching
  * the result. Reads the cache when present (VRAM capacity is stable per
- * machine); pass `force` to re-probe. Any failure (spawn error, no
+ * machine), the OS still reports the RAM it was probed with, and the same
+ * build answered it; an empty listing is re-asked hourly. Pass `force` to
+ * re-probe. Any failure (spawn error, no
  * cache, unparseable output) resolves to an empty device list — the
  * planner then simply does nothing and the engine's own `--fit`/`-ngl
- * auto` takes over. `nowIso` is injectable for deterministic tests.
+ * auto` takes over. `nowIso` and `systemRamBytes` are injectable for
+ * deterministic tests.
  */
 export async function probeLlamaDevices(opts) {
     const { binaryPath, home, force } = opts;
     const now = opts.nowIso ?? (() => new Date().toISOString());
+    const systemRamBytes = opts.systemRamBytes ?? totalmem();
     const path = cachePath(home);
+    const binary = llamaBinaryFingerprint(binaryPath);
     if (!force && existsSync(path)) {
         try {
             const cached = JSON.parse(readFileSync(path, 'utf8'));
-            if (Array.isArray(cached.devices))
+            // A cache without the RAM figure or the binary predates that check and
+            // re-probes once.
+            const emptyExpired = Array.isArray(cached.devices) &&
+                cached.devices.length === 0 &&
+                !(Date.parse(now()) - Date.parse(cached.probedAt) < EMPTY_DEVICES_RETRY_MS);
+            if (Array.isArray(cached.devices) &&
+                cached.systemRamBytes === systemRamBytes &&
+                cached.binary === binary &&
+                !emptyExpired) {
                 return { ...cached, cached: true };
+            }
         }
         catch {
             // fall through to a fresh probe
@@ -165,7 +202,13 @@ export async function probeLlamaDevices(opts) {
         // Leave devices empty — caller treats "no devices" as "no offload target".
         return { devices, probedAt: now(), cached: false };
     }
-    const probe = { devices, probedAt: now(), cached: false };
+    const probe = {
+        devices,
+        probedAt: now(),
+        cached: false,
+        systemRamBytes,
+        binary,
+    };
     try {
         mkdirSync(dirname(path), { recursive: true });
         writeFileSync(path, JSON.stringify(probe, null, 2), 'utf8');

package/dist/providers/llama-cpp/engine-flags.d.ts

@@ -126,24 +126,6 @@ export interface EngineFlagInput {
      * when the client also replays `reasoning_content`.
      */
     reasoningPreserve?: boolean | undefined;
-    /**
-     * The model's GGUF `general.architecture`, for the Gemma-family auto
-     * defaults (sliding-window full cache). Undefined disables the arch
-     * heuristic; an explicit config/manifest `swaFull` still applies.
-     */
-    architecture?: string | undefined;
-    /** The resolved model id, a fallback for `architecture` (see isGemmaModel). */
-    modelId?: string | undefined;
-    /**
-     * Whether resident weights plus the full SWA KV cache fit the host's
-     * fast-memory pool (VRAM on a discrete GPU). The exact estimate honors
-     * per-layer SWA dimensions and shared-KV layers. `false` declines the
-     * auto-default so a low-memory device keeps the model's full context on
-     * the windowed cache instead of spilling or OOMing. `undefined` (unknown
-     * host/metadata) and `true` retain the compatibility default. An explicit
-     * config/manifest `swaFull` wins regardless.
-     */
-    swaFullAutoFits?: boolean | undefined;
     /**
      * The llama-server build's backend (`cuda`, `vulkan`, `metal`, `cpu`).
      * Only a GPU backend can receive the GPU-resident thread default.

package/dist/providers/llama-cpp/engine-flags.js

@@ -21,7 +21,6 @@
  * dependency; the real `GezelConfig` / `LlamaCppEngineConfig` satisfy
  * these shapes by construction.
  */
-import { isGemmaModel } from './kv-cache-type.js';
 /** Default `--cache-reuse` chunk when neither config nor manifest set it. */
 export const DEFAULT_CACHE_REUSE = 256;
 /**
@@ -101,7 +100,7 @@ function normalizeFlagKey(key) {
  * `args` array.
  */
 export function buildLlamaCppEngineArgs(input) {
-    const { config, perModel, planner, kvCacheType, slots, ggufHasMtp, installedDraftModelPath, reasoningFormat, reasoningPreserve, architecture, modelId, swaFullAutoFits, backend, hostCpuCount, } = input;
+    const { config, perModel, planner, kvCacheType, slots, ggufHasMtp, installedDraftModelPath, reasoningFormat, reasoningPreserve, backend, hostCpuCount, } = input;
     const args = [];
     // ── GPU-layer offload (`--n-gpu-layers`) ──────────────────────────
     const nGpuLayers = config.llamaCppNGpuLayers ?? perModel?.nGpuLayers ?? planner?.nGpuLayers;
@@ -176,26 +175,20 @@ export function buildLlamaCppEngineArgs(input) {
     //
     // So the engine already declines it precisely when it cannot honour it,
     // which is what the warning is for. Withholding the flag ourselves only
-    // cost reuse on multi-slot dense engines. Note the coupling this exposes:
-    // the memory-driven `--swa-full` decision below also silently decides
-    // whether Gemma gets any cross-request prefix reuse at all.
+    // cost reuse on multi-slot dense engines. Gemma therefore gets it only
+    // with a pinned `--swa-full` below.
     const explicitCacheReuse = config.llamaCppCacheReuse ?? perModel?.cacheReuse;
     const cacheReuse = explicitCacheReuse ?? DEFAULT_CACHE_REUSE;
     if (cacheReuse > 0)
         args.push('--cache-reuse', String(cacheReuse));
     // ── SWA full cache (`--swa-full`) ─────────────────────────────────
-    // Tri-state: explicit config/manifest `true`/`false` wins; `undefined`
-    // at both layers falls through to the Gemma-family auto-default. Gemma's
-    // sliding-window attention refuses cross-request prefix reuse under the
-    // memory-efficient windowed cache; the full cache preserves old SWA KV
-    // for cache operations by allocating full-context storage on every
-    // cache-owning layer. The cost varies sharply with model geometry, so
-    // Auto is gated on `swaFullAutoFits`: when weights + full KV do not fit
-    // fast memory, Gemma launches with the windowed cache instead.
-    const swaFull = config.llamaCppSwaFull ??
-        perModel?.swaFull ??
-        (swaFullAutoFits !== false && isGemmaModel({ architecture, modelId }));
-    if (swaFull)
+    // Opt-in only: an explicit config/manifest `swaFull`. Gemma used to get
+    // it by default for cross-request prefix reuse, until a paired A/B on
+    // gemma4-31b (2026-10-15) showed the full cache decodes 17-25% slower at
+    // every context depth, because decode reads each sliding-window layer's
+    // whole cache, and costs 51 GB more at 64K. Trials ran 19% longer in
+    // total despite the better reuse.
+    if (config.llamaCppSwaFull ?? perModel?.swaFull)
         args.push('--swa-full');
     // ── Thread / batch overrides ──────────────────────────────────────
     // The GPU-resident default needs positive evidence that no model compute
@@ -248,7 +241,8 @@ export function buildLlamaCppEngineArgs(input) {
         const nMax = config.llamaCppSpecDraftNMax ?? perModel?.spec?.nMax;
         if (typeof nMax === 'number')
             args.push('--spec-draft-n-max', String(nMax));
-        // v0.6.0 supports probabilistic selection only for MTP/simple drafts.
+        // v0.7.0 supports probabilistic selection only for MTP/simple drafts
+        // (DFlash/LiLiCorr ignore it).
         // Leave the upstream greedy default untouched unless explicitly set.
         if ((safeSpecType === 'draft-mtp' || safeSpecType === 'draft-simple') &&
             config.llamaCppSpecDraftSampling) {

package/dist/providers/llama-cpp/gguf-metadata.js

@@ -32,8 +32,9 @@ const GgufValueType = {
     INT64: 11,
     FLOAT64: 12,
 };
-// `general.file_type` enum from llama.cpp/src/llama.h. Only the
-// common values — the enum has ~30 entries and upstream adds more.
+// `general.file_type` enum (`llama_ftype`) from llama.cpp's include/llama.h.
+// Copy new values from upstream rather than guessing: this table once mapped
+// 30 to BF16 (upstream 30 is IQ4_XS, BF16 is 32) and had no NVFP4 at all.
 // Anything unrecognised is reported by number.
 const FILE_TYPE_NAMES = {
     0: 'ALL_F32',
@@ -54,8 +55,24 @@ const FILE_TYPE_NAMES = {
     18: 'MOSTLY_Q6_K',
     19: 'MOSTLY_IQ2_XXS',
     20: 'MOSTLY_IQ2_XS',
+    21: 'MOSTLY_Q2_K_S',
+    22: 'MOSTLY_IQ3_XS',
     23: 'MOSTLY_IQ3_XXS',
-    30: 'MOSTLY_BF16',
+    24: 'MOSTLY_IQ1_S',
+    25: 'MOSTLY_IQ4_NL',
+    26: 'MOSTLY_IQ3_S',
+    27: 'MOSTLY_IQ3_M',
+    28: 'MOSTLY_IQ2_S',
+    29: 'MOSTLY_IQ2_M',
+    30: 'MOSTLY_IQ4_XS',
+    31: 'MOSTLY_IQ1_M',
+    32: 'MOSTLY_BF16',
+    36: 'MOSTLY_TQ1_0',
+    37: 'MOSTLY_TQ2_0',
+    38: 'MOSTLY_MXFP4_MOE',
+    39: 'MOSTLY_NVFP4',
+    40: 'MOSTLY_Q1_0',
+    41: 'MOSTLY_Q2_0',
 };
 /**
  * The quantization tag a GGUF declares about itself, in the shape the model

package/dist/providers/llama-cpp/gpu-startup-watch.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Did a GPU build of llama-server actually get its GPU? Read from the
+ * engine's own startup output, because nothing else says.
+ *
+ * The bundled builds load their GPU backend with dlopen (`GGML_BACKEND_DL`),
+ * and in a release build ggml skips a backend that fails to load without a
+ * word. A CUDA backend that loads but cannot initialize prints one error line
+ * and registers no devices. Either way the engine starts, answers, and runs
+ * every token on the CPU — at a fraction of the speed the person's hardware
+ * and Settings promise — while gezel reports the CUDA or Vulkan build it
+ * launched.
+ *
+ * llama.cpp names every GPU it will use while loading a model
+ * (`using device CUDA0 (NVIDIA GB10) …`), integrated GPUs included. A GPU
+ * build that reached readiness after loading a model without that line ran
+ * without its GPU. The explicit lines say why when there is a why to say.
+ */
+export type GpuUnusedReason = 
+/** The CUDA runtime loaded and refused to start: `failed to initialize CUDA`. */
+'init-failed'
+/** The backend loaded and found no device it could use. */
+ | 'no-devices'
+/** No sign of the GPU backend at all: it failed to load, silently. */
+ | 'not-loaded';
+export interface GpuUnused {
+    backend: 'cuda' | 'vulkan';
+    reason: GpuUnusedReason;
+    /** The engine's own words, when it gave any. */
+    detail?: string;
+}
+export declare class GpuStartupWatch {
+    private readonly backend;
+    private usingGpu;
+    private sawModelLoad;
+    private initFailure;
+    private noDevices;
+    constructor(backend: string | undefined);
+    observe(line: string): void;
+    /** At readiness: what kept the GPU out, or null when it is in use or this is no GPU build. */
+    verdict(): GpuUnused | null;
+}

package/dist/providers/llama-cpp/gpu-startup-watch.js

@@ -0,0 +1,58 @@
+/**
+ * Did a GPU build of llama-server actually get its GPU? Read from the
+ * engine's own startup output, because nothing else says.
+ *
+ * The bundled builds load their GPU backend with dlopen (`GGML_BACKEND_DL`),
+ * and in a release build ggml skips a backend that fails to load without a
+ * word. A CUDA backend that loads but cannot initialize prints one error line
+ * and registers no devices. Either way the engine starts, answers, and runs
+ * every token on the CPU — at a fraction of the speed the person's hardware
+ * and Settings promise — while gezel reports the CUDA or Vulkan build it
+ * launched.
+ *
+ * llama.cpp names every GPU it will use while loading a model
+ * (`using device CUDA0 (NVIDIA GB10) …`), integrated GPUs included. A GPU
+ * build that reached readiness after loading a model without that line ran
+ * without its GPU. The explicit lines say why when there is a why to say.
+ */
+const USING_GPU = /\busing device (?:CUDA|Vulkan|ROCm|SYCL|MTL)\d+\b/;
+const CUDA_INIT_FAILED = /ggml_cuda_init: failed to initialize CUDA:\s*(.+?)\s*$/;
+const VULKAN_NO_DEVICES = /ggml_vulkan: No devices found/;
+/**
+ * Lines llama.cpp prints at the same verbosity as `using device`, while
+ * loading a model. Without one the output is too quiet to conclude anything.
+ */
+const MODEL_LOAD = /\b(?:llama_model_loader:|load_tensors:|print_info:|llama_model_load_from_file_impl:)/;
+export class GpuStartupWatch {
+    backend;
+    usingGpu = false;
+    sawModelLoad = false;
+    initFailure;
+    noDevices = false;
+    constructor(backend) {
+        this.backend = backend;
+    }
+    observe(line) {
+        if (USING_GPU.test(line))
+            this.usingGpu = true;
+        if (MODEL_LOAD.test(line))
+            this.sawModelLoad = true;
+        const failure = CUDA_INIT_FAILED.exec(line);
+        if (failure?.[1])
+            this.initFailure = failure[1];
+        if (VULKAN_NO_DEVICES.test(line))
+            this.noDevices = true;
+    }
+    /** At readiness: what kept the GPU out, or null when it is in use or this is no GPU build. */
+    verdict() {
+        const backend = this.backend;
+        if ((backend !== 'cuda' && backend !== 'vulkan') || this.usingGpu)
+            return null;
+        if (backend === 'cuda' && this.initFailure) {
+            return { backend, reason: 'init-failed', detail: this.initFailure };
+        }
+        if (backend === 'vulkan' && this.noDevices)
+            return { backend, reason: 'no-devices' };
+        return this.sawModelLoad ? { backend, reason: 'not-loaded' } : null;
+    }
+}

package/dist/providers/llama-cpp/models.d.ts

@@ -236,6 +236,11 @@ export interface LlamaCppModelManagerOptions {
         engine: 'llama-cpp' | 'ds4';
         id: string;
     }) => void;
+    /**
+     * The llama-server backend installs are judged against for a catalog
+     * source's `excludeBackends`. Test seam — defaults to the process's own.
+     */
+    resolveBackend?: () => string | undefined;
 }
 export declare class LlamaCppModelManager {
     private readonly modelsRoot;
@@ -244,6 +249,7 @@ export declare class LlamaCppModelManager {
     private readonly fetchImpl;
     private readonly engine;
     private readonly onInstalled?;
+    private readonly resolveBackend;
     /**
      * In-flight installs. `install()` registers an entry on first yield
      * and clears it in the iterator's `finally` block, so consumers

package/dist/providers/llama-cpp/models.js

@@ -35,13 +35,14 @@ import { createHash } from 'node:crypto';
 import { createReadStream } from 'node:fs';
 import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { basename, join, resolve } from 'node:path';
-import { createLogger } from '@bendyline/gezel';
+import { createLogger, llamaCppBackendExclusion, llamaCppBackendLabel } from '@bendyline/gezel';
 import { listBundleModelFiles, publishStagedModel, safeBundleModelPath, } from '../../models/bundle-storage.js';
 import { evaluateCatalogDrift } from '../../models/catalog-drift.js';
 import { catalogPayloadFingerprint, describeCatalogPayload, } from '../../models/catalog-payload-identity.js';
 import { MODEL_HASH_READ_BUFFER_BYTES, assertModelStorePathSafe, findModelRoot, findRenamedModelId, hashModelPayloadFiles, inspectModelDirectory, listIncompleteModelDownloads, listOverlayModelIds, makeSharedModelReadable, modelExistsOnlyReadOnly, modelStorageRoots, pruneModelPayloadFiles, readOnlyModelError, removeModelDir, verifyReadOnlyModelPayload, } from '../../models/storage-roots.js';
 import { checkDiskSpace, describeDiskShortfall } from '../../utils/disk-space.js';
 import { downloadWithRetry } from '../../utils/download-with-retry.js';
+import { currentLlamaCppBackend } from './backend-health.js';
 import { ggufQuantizationTag, readGgufSummary } from './gguf-metadata.js';
 import { backfillGgufQuantization } from './gguf-quantization-backfill.js';
 /**
@@ -58,6 +59,7 @@ export class LlamaCppModelManager {
     fetchImpl;
     engine;
     onInstalled;
+    resolveBackend;
     /**
      * In-flight installs. `install()` registers an entry on first yield
      * and clears it in the iterator's `finally` block, so consumers
@@ -78,6 +80,7 @@ export class LlamaCppModelManager {
         this.catalog = opts.catalog;
         this.fetchImpl = opts.fetchImpl ?? fetch;
         this.onInstalled = opts.onInstalled;
+        this.resolveBackend = opts.resolveBackend ?? currentLlamaCppBackend;
     }
     /**
      * The catalog source block this manager downloads from — `ds4` for the
@@ -435,6 +438,17 @@ export class LlamaCppModelManager {
                 };
                 return;
             }
+            if (this.engine === 'llama-cpp') {
+                const backend = this.resolveBackend();
+                const excluded = llamaCppBackendExclusion(manifest.llamaCpp, backend);
+                if (excluded && backend) {
+                    yield {
+                        type: 'error',
+                        error: `chat-model "${catalogId}" is not available on the ${llamaCppBackendLabel(backend)} llama.cpp engine: ${excluded}`,
+                    };
+                    return;
+                }
+            }
             tracked.totalBytes = installSrc.approxSizeBytes;
             yield* this.runInstall(catalogId, manifest, tracked, skipSha, includeMmproj);
         }
@@ -734,7 +748,10 @@ export class LlamaCppModelManager {
         installed.fileSha256 = await hashModelPayloadFiles(itemDir, verifiedDigests);
         await writeFile(join(itemDir, 'manifest.json'), JSON.stringify(installed, null, 2), 'utf8');
         await makeSharedModelReadable(itemDir);
-        const warning = summary.chatTemplateMissing
+        // ds4-server renders each family's prompt itself and never reads
+        // tokenizer.chat_template; DeepSeek V4.1 ships no Jinja template at all,
+        // and its first install warned that replies "may be incoherent".
+        const warning = summary.chatTemplateMissing && this.engine === 'llama-cpp'
             ? 'Model has no embedded chat template (tokenizer.chat_template is missing). llama-server will fall back to a generic template that may not match this model — replies may be incoherent. Consider a different quant of the same model.'
             : undefined;
         try {
@@ -964,6 +981,10 @@ includeMmproj = true) {
     // after install without a second download.
     if (src.draftModel) {
         out.push({
+            ...(src.draftModel.huggingfaceRepo
+                ? { huggingfaceRepo: src.draftModel.huggingfaceRepo }
+                : {}),
+            ...(src.draftModel.revision ? { revision: src.draftModel.revision } : {}),
             repoPath: src.draftModel.filename,
             destFilename: basename(src.draftModel.filename),
             sha256: src.draftModel.sha256,

package/dist/providers/llama-cpp/offload-planner.d.ts

@@ -166,6 +166,29 @@ export declare function planMoeOffload(input: MoeOffloadInput): MoeOffloadDecisi
 export declare function degradeMoeOffloadDecision(decision: MoeOffloadDecision | undefined): MoeOffloadDecision | null;
 /** Dense counterpart of {@link degradeMoeOffloadDecision}. */
 export declare function degradeDenseFfnOffloadDecision(decision: MoeOffloadDecision | undefined, blockCount: number | undefined): MoeOffloadDecision | null;
+/**
+ * Room an extra engine slot must leave on the card. Other programs' graphics
+ * memory moves while a model runs (a browser, a video, the desktop), and a
+ * two-slot launch planned to within a gigabyte or two died with a Vulkan
+ * out-of-memory when they took more (2026-10-19, a 32 GB card).
+ */
+export declare const EXTRA_SLOT_GPU_CUSHION_BYTES: number;
+/**
+ * Fewer slots before system RAM. Keep `slots` only when the model stays
+ * fully on the GPU with {@link EXTRA_SLOT_GPU_CUSHION_BYTES} to spare;
+ * otherwise drop to one slot when that alone keeps it fully on the GPU. A
+ * model that needs system RAM even at one slot keeps its slots and the
+ * planner's split. `plan` prices one slot count against one VRAM pool.
+ */
+export declare function shedSlotsForGpuResidency(input: {
+    slots: number;
+    vramBytes: number;
+    plan: (slots: number, vramBytes: number) => MoeOffloadDecision;
+}): {
+    slots: number;
+    decision: MoeOffloadDecision;
+    shed: boolean;
+};
 export interface KvReserveInput {
     blockCount?: number | undefined;
     embeddingLength?: number | undefined;
@@ -286,10 +309,9 @@ export interface WindowedKvLinearization {
  * than the layer ratio — global layers carry fewer KV heads at wider head
  * dims (31b: 10 layers × 4 heads × 512+512 vs 50 layers × 16 heads ×
  * 256+256) — so full-attention math overstates the windowed cache ~14×
- * and using it for admission over-clamps or over-denies exactly the
- * launches the `--swa-full` decline is trying to keep whole (the
- * 2026-08-04 gemma4-26b sweep shipped 19–56K windows on a 65536 request
- * this way).
+ * and using it for admission over-clamps or over-denies launches the
+ * windowed cache holds easily (the 2026-08-04 gemma4-26b sweep shipped
+ * 19–56K windows on a 65536 request this way).
  *
  * Returns undefined when the header lacks the SWA layout (no window, no
  * pattern, length mismatches) so callers fall back to their conservative
@@ -323,17 +345,3 @@ export declare function estimateExactPerSlotKvBytesF16(input: Omit<WindowedKvInp
  */
 export declare function estimateLinearHybridKvLinearization(input: WindowedKvInput): WindowedKvLinearization | undefined;
 export declare function estimateWindowedKvLinearization(input: WindowedKvInput): WindowedKvLinearization | undefined;
-export interface SwaFullFastMemoryFitInput {
-    residentWeightsBytes: number;
-    fullKvBytes: number;
-    /** Already safety-discounted fast-memory budget (VRAM on a discrete GPU). */
-    fastBudgetBytes: number;
-    /** Fast-memory reservations held by models that are already resident. */
-    committedOtherBytes?: number | undefined;
-}
-/**
- * Whether Auto may keep `--swa-full` without spilling the model or KV cache
- * out of the fast pool. The capacity budget already reserves driver/OS
- * headroom, so this comparison must not discount it a second time.
- */
-export declare function fitsSwaFullInFastMemory(input: SwaFullFastMemoryFitInput): boolean;

package/dist/providers/llama-cpp/offload-planner.js

@@ -272,6 +272,33 @@ export function degradeDenseFfnOffloadDecision(decision, blockCount) {
     }
     return null;
 }
+/**
+ * Room an extra engine slot must leave on the card. Other programs' graphics
+ * memory moves while a model runs (a browser, a video, the desktop), and a
+ * two-slot launch planned to within a gigabyte or two died with a Vulkan
+ * out-of-memory when they took more (2026-10-19, a 32 GB card).
+ */
+export const EXTRA_SLOT_GPU_CUSHION_BYTES = 2 * 1024 ** 3;
+/**
+ * Fewer slots before system RAM. Keep `slots` only when the model stays
+ * fully on the GPU with {@link EXTRA_SLOT_GPU_CUSHION_BYTES} to spare;
+ * otherwise drop to one slot when that alone keeps it fully on the GPU. A
+ * model that needs system RAM even at one slot keeps its slots and the
+ * planner's split. `plan` prices one slot count against one VRAM pool.
+ */
+export function shedSlotsForGpuResidency(input) {
+    const decision = input.plan(input.slots, input.vramBytes);
+    const keep = { slots: input.slots, decision, shed: false };
+    if (input.slots <= 1 || input.vramBytes <= 0)
+        return keep;
+    const roomy = input.plan(input.slots, Math.max(0, input.vramBytes - EXTRA_SLOT_GPU_CUSHION_BYTES));
+    if (roomy.fullGpuResidency)
+        return keep;
+    const single = input.plan(1, input.vramBytes);
+    if (!single.fullGpuResidency)
+        return keep;
+    return { slots: 1, decision: single, shed: true };
+}
 /** Bytes per KV element for llama-server's `--cache-type-k/v` values. */
 const KV_BYTES_PER_ELEMENT = {
     f32: 4,
@@ -406,10 +433,9 @@ const SWA_UBATCH_MARGIN_TOKENS = 2048;
  * than the layer ratio — global layers carry fewer KV heads at wider head
  * dims (31b: 10 layers × 4 heads × 512+512 vs 50 layers × 16 heads ×
  * 256+256) — so full-attention math overstates the windowed cache ~14×
- * and using it for admission over-clamps or over-denies exactly the
- * launches the `--swa-full` decline is trying to keep whole (the
- * 2026-08-04 gemma4-26b sweep shipped 19–56K windows on a 65536 request
- * this way).
+ * and using it for admission over-clamps or over-denies launches the
+ * windowed cache holds easily (the 2026-08-04 gemma4-26b sweep shipped
+ * 19–56K windows on a 65536 request this way).
  *
  * Returns undefined when the header lacks the SWA layout (no window, no
  * pattern, length mismatches) so callers fall back to their conservative
@@ -512,13 +538,3 @@ export function estimateWindowedKvLinearization(input) {
         fixedBytes: Math.round(swaElemsPerToken * bytesPerElement * (slidingWindow + SWA_UBATCH_MARGIN_TOKENS) * loops),
     };
 }
-/**
- * Whether Auto may keep `--swa-full` without spilling the model or KV cache
- * out of the fast pool. The capacity budget already reserves driver/OS
- * headroom, so this comparison must not discount it a second time.
- */
-export function fitsSwaFullInFastMemory(input) {
-    const required = Math.max(0, input.residentWeightsBytes) + Math.max(0, input.fullKvBytes);
-    const available = Math.max(0, input.fastBudgetBytes - Math.max(0, input.committedOtherBytes ?? 0));
-    return Number.isFinite(required) && Number.isFinite(available) && required <= available;
-}