@bendyline/gezel-inference 1.0.7 → 1.0.9

package/dist/providers/native/local-engine-runtime.js

@@ -1,15 +1,17 @@
 import { randomUUID } from 'node:crypto';
 import { join } from 'node:path';
-import { createLogger } from '@bendyline/gezel';
-import { estimateLlamaCppResidentBytes } from '@bendyline/gezel';
+import { createLogger, ds4SsdStreamingSupported } from '@bendyline/gezel';
+import { estimateLlamaCppResidentBytes, llamaCppDraftResidentBytes, } from '@bendyline/gezel';
 import { resolveCatalogLlamaCppEngineConfig } from '../catalog-model-config.js';
-import { buildDs4Provider, resolveDs4LaunchCtx, resolveDs4VisionLaunch, } from '../ds4/build-provider.js';
+import { buildDs4Provider, ds4RamTieredContext, resolveDs4LaunchCtx, resolveDs4VisionLaunch, } from '../ds4/build-provider.js';
 import { ds4VisionResidentBytes } from '../ds4/residency.js';
+import { currentLlamaCppBackend } from '../llama-cpp/backend-health.js';
 import { buildLlamaCppProvider, ensureLlamaEngineStatus } from '../llama-cpp/build-provider.js';
 import { readGgufSummaryAsync } from '../llama-cpp/gguf-metadata-async.js';
 import { effectiveLazyTensorBytes } from '../llama-cpp/gguf-metadata.js';
 import { isGemmaModel, planLlamaCppKv, resolveLlamaCppKvCacheType, } from '../llama-cpp/kv-cache-type.js';
 import { estimateExactPerSlotKvBytesF16, estimateKvReserveBytes, estimateWindowedKvLinearization, } from '../llama-cpp/offload-planner.js';
+import { drafterCostsContext, llamaCppSidecarLoads, resolveSpecDraft, } from '../llama-cpp/spec-draft.js';
 import { buildMlxProvider, resolveMlxEffectiveNumCtx } from '../mlx/build-provider.js';
 import { readMlxModelGeometry } from '../mlx/model-geometry.js';
 import { ModelNotInstalledError } from '../types.js';
@@ -594,7 +596,8 @@ export class LocalEngineRuntime {
                         const config = await this.store.readConfig();
                         const externalBaseUrl = process.env.GEZEL_DS4_SERVER_URL ?? config.ds4BaseUrl;
                         if (!externalBaseUrl) {
-                            const { ds4ProjectedResidentBytes, ds4ResidentBytesForMode, ds4ResidentLine, shouldUseDs4SsdStreaming, } = await import('../ds4/residency.js');
+                            const { ds4ProjectedResidentBytes, ds4ResidentBytesForMode, ds4ResidentLine, planDs4MeasuredLaunch, shouldUseDs4SsdStreaming, } = await import('../ds4/residency.js');
+                            const { totalMemoryBytes } = await import('../../system/host-memory.js');
                             // Bill the window this model will actually launch with. The
                             // authored footprint is a measurement at `residentCtxTokens`, so
                             // without this a raised context reserves the old number and the
@@ -603,29 +606,51 @@ export class LocalEngineRuntime {
                             const ds4Block = cm.ds4;
                             const installed = await this.ds4Models?.resolveModel(modelId).catch(() => null);
                             const visionResidentBytes = await this.resolveDs4VisionResidentBytes(config, modelId, installed, ds4Block);
-                            const line = ds4ResidentLine({
-                                residentBytes: bytes,
-                                kvBytesPerToken: ds4Block?.kvBytesPerToken,
-                                residentCtxTokens: ds4Block?.residentCtxTokens,
+                            const totalRamBytes = totalMemoryBytes();
+                            const ds4Override = config.modelContextOverrides?.[`ds4:${modelId}`];
+                            const contextFloor = minViableLocalContextTokens();
+                            const numCtx = resolveDs4LaunchCtx({
+                                configured: ds4Override ?? config.ds4NumCtx,
+                                ramTieredCtx: ds4RamTieredContext(totalRamBytes),
+                                catalogMaxCtx: ds4Block?.maxLaunchCtx,
+                                minViableContextTokens: ds4Override !== undefined ? Math.min(contextFloor, ds4Override) : contextFloor,
                             });
-                            if (line) {
-                                const { totalMemoryBytes } = await import('../../system/host-memory.js');
-                                bytes = ds4ProjectedResidentBytes(line, resolveDs4LaunchCtx({
-                                    configured: config.modelContextOverrides?.[`ds4:${modelId}`] ?? config.ds4NumCtx,
-                                    ramTieredCtx: totalMemoryBytes() / 1024 ** 3 >= 192 ? 262_144 : 131_072,
-                                    catalogMaxCtx: ds4Block?.maxLaunchCtx,
-                                    minViableContextTokens: minViableLocalContextTokens(),
-                                }));
-                            }
-                            bytes = ds4ResidentBytesForMode(bytes, shouldUseDs4SsdStreaming({
+                            const streamingSupported = ds4SsdStreamingSupported(ds4Block, process.platform);
+                            const ssdStreaming = shouldUseDs4SsdStreaming({
                                 configured: config.ds4SsdStreaming,
-                                ...(ds4Block?.ssdStreamingSupported !== undefined
-                                    ? { ssdStreamingSupported: ds4Block.ssdStreamingSupported }
+                                ...(streamingSupported !== undefined
+                                    ? { ssdStreamingSupported: streamingSupported }
                                     : {}),
                                 modelSizeBytes: ds4Block?.residentWeightBytes ?? block.approxSizeBytes,
+                                totalRamBytes,
                                 ...(visionResidentBytes > 0 ? { companionBytes: visionResidentBytes } : {}),
-                            }), ds4Block?.ssdStreamingSupported);
-                            bytes += visionResidentBytes;
+                            });
+                            const measured = planDs4MeasuredLaunch({
+                                source: ds4Block,
+                                numCtx,
+                                ssdStreaming,
+                                totalRamBytes,
+                                budgetBytes: ssdStreaming && ds4Block?.streamingMemory
+                                    ? await (await import('./device-capacity.js')).deviceModelBudgetBytes(config)
+                                    : undefined,
+                                sidecarBytes: visionResidentBytes,
+                                configuredCacheGb: config.ds4CacheExpertsGb,
+                            });
+                            if (measured) {
+                                bytes = measured.workingSetBytes;
+                            }
+                            else {
+                                const line = ds4ResidentLine({
+                                    residentBytes: bytes,
+                                    kvBytesPerToken: ds4Block?.kvBytesPerToken,
+                                    residentCtxTokens: ds4Block?.residentCtxTokens,
+                                });
+                                if (line)
+                                    bytes = ds4ProjectedResidentBytes(line, numCtx);
+                                bytes =
+                                    ds4ResidentBytesForMode(bytes, ssdStreaming, streamingSupported) +
+                                        visionResidentBytes;
+                            }
                         }
                     }
                 }
@@ -1047,7 +1072,9 @@ export class LocalEngineRuntime {
                 throw new ModelNotInstalledError(name, modelId);
             }
             const { totalMemoryBytes } = await import('../../system/host-memory.js');
-            const ramTieredCtx = totalMemoryBytes() / 1024 ** 3 >= 192 ? 262_144 : 131_072;
+            // The launcher's own tier: 64K below 96 GiB, so a smaller Mac is quoted
+            // the window and footprint it will actually launch with.
+            const ramTieredCtx = ds4RamTieredContext(totalMemoryBytes());
             const ds4Override = config.modelContextOverrides?.[`ds4:${modelId}`];
             const ds4Floor = ds4Override !== undefined ? Math.min(contextFloor, ds4Override) : contextFloor;
             const effective = resolveDs4LaunchCtx({
@@ -1086,36 +1113,69 @@ export class LocalEngineRuntime {
             // `fixed + slope × ctx` line llama.cpp/MLX rows carry, so the slider
             // prices a drag instead of claiming the footprint never moves. Entries
             // without a measured slope keep the flat number and say so.
-            const { ds4ProjectedResidentBytes, ds4ResidentBytesForMode, ds4ResidentLine, shouldUseDs4SsdStreaming, } = await import('../ds4/residency.js');
+            const { ds4ProjectedResidentBytes, ds4ResidentBytesForMode, ds4ResidentLine, planDs4MeasuredLaunch, shouldUseDs4SsdStreaming, } = await import('../ds4/residency.js');
             const ds4Line = ds4ResidentLine({
                 residentBytes: ds4Source?.residentBytes,
                 kvBytesPerToken: ds4Source?.kvBytesPerToken,
                 residentCtxTokens: ds4Source?.residentCtxTokens,
             });
             const visionResidentBytes = await this.resolveDs4VisionResidentBytes(config, modelId, installed, ds4Source);
+            const streamingSupported = ds4SsdStreamingSupported(ds4Source, process.platform);
             const ssdStreaming = shouldUseDs4SsdStreaming({
                 configured: config.ds4SsdStreaming,
-                ...(ds4Source?.ssdStreamingSupported !== undefined
-                    ? { ssdStreamingSupported: ds4Source.ssdStreamingSupported }
-                    : {}),
+                ...(streamingSupported !== undefined ? { ssdStreamingSupported: streamingSupported } : {}),
                 modelSizeBytes: ds4Source?.residentWeightBytes ??
                     ds4Source?.approxSizeBytes ??
                     installed?.approxSizeBytes,
                 ...(visionResidentBytes > 0 ? { companionBytes: visionResidentBytes } : {}),
             });
-            const plannedResidentBytes = ds4Line
-                ? ds4ResidentBytesForMode(ds4ProjectedResidentBytes(ds4Line, effective), ssdStreaming, ds4Source?.ssdStreamingSupported) + visionResidentBytes
-                : await this.resolveResidentBytes('ds4', modelId);
+            // A measurement for this launch's mode prices it exactly — the window
+            // moves only that mode's slope, and a streamed launch carries the cache
+            // the launcher would choose. Unmeasured entries keep the authored line.
+            const measured = planDs4MeasuredLaunch({
+                source: ds4Source,
+                numCtx: effective,
+                ssdStreaming,
+                totalRamBytes: totalMemoryBytes(),
+                budgetBytes: ssdStreaming && ds4Source?.streamingMemory
+                    ? await (await import('./device-capacity.js')).deviceModelBudgetBytes(config)
+                    : undefined,
+                sidecarBytes: visionResidentBytes,
+                configuredCacheGb: config.ds4CacheExpertsGb,
+            });
+            const plannedResidentBytes = measured
+                ? measured.workingSetBytes
+                : ds4Line
+                    ? ds4ResidentBytesForMode(ds4ProjectedResidentBytes(ds4Line, effective), ssdStreaming, streamingSupported) + visionResidentBytes
+                    : await this.resolveResidentBytes('ds4', modelId);
             return {
                 contextWindow: useResidentOr(effective, Math.min(effective, ds4Floor)),
                 plannedResidentBytes,
-                ...(ds4Line
+                ssdStreaming,
+                ...(measured
                     ? {
-                        weightsResidentBytes: ds4ResidentBytesForMode(ds4Line.contextFreeBytes, ssdStreaming, ds4Source?.ssdStreamingSupported) + visionResidentBytes,
+                        memoryMeasured: true,
+                        weightsResidentBytes: measured.contextFreeBytes,
                         kvFixedBytesPerSlot: 0,
-                        kvBytesPerTokenPerSlot: ds4Line.kvBytesPerToken,
+                        kvBytesPerTokenPerSlot: measured.bytesPerToken,
+                        ...(measured.cache
+                            ? {
+                                expertCache: {
+                                    cacheBytes: measured.cache.cacheGb * 1024 ** 3,
+                                    requestedBytes: measured.cache.requestedGb * 1024 ** 3,
+                                    clamped: measured.cache.clamped,
+                                    safe: measured.cache.safe,
+                                },
+                            }
+                            : {}),
                     }
-                    : {}),
+                    : ds4Line
+                        ? {
+                            weightsResidentBytes: ds4ResidentBytesForMode(ds4Line.contextFreeBytes, ssdStreaming, streamingSupported) + visionResidentBytes,
+                            kvFixedBytesPerSlot: 0,
+                            kvBytesPerTokenPerSlot: ds4Line.kvBytesPerToken,
+                        }
+                        : {}),
                 ...(nativeWindow ? { nativeContextWindow: nativeWindow } : {}),
                 ...(ds4Override !== undefined ? { overrideContextTokens: ds4Override } : {}),
                 ...(ds4AutoContextWindow !== undefined ? { autoContextWindow: ds4AutoContextWindow } : {}),
@@ -1190,9 +1250,32 @@ export class LocalEngineRuntime {
             ? effectiveLazyTensorBytes(summary, config.llamaCppLazyMode ?? manifestEngineConfig?.lazyMode ?? 'auto')
             : 0;
         const residentWeightFileBytes = Math.max(0, installed.approxSizeBytes - lazyTensorBytes);
-        const residentWeightsBytes = estimateLlamaCppResidentBytes(residentWeightFileBytes, {
+        const { perModel: previewEngineConfig } = await resolveSpecDraft({
+            perModel: manifestEngineConfig,
+            backend: currentLlamaCppBackend(),
+            configSpecType: config.llamaCppSpecType,
+            configDraftModelPath: config.llamaCppDraftModelPath,
+            installedDraftModelPath: installed.draftModelPath,
+            resolveDraftPath: async (id) => (await this.llamaCppModels?.resolveModelPath(id)) ?? null,
+        });
+        const previewSpecType = config.llamaCppSpecType ?? previewEngineConfig?.spec?.type;
+        const draftBudgetBytes = llamaCppSidecarLoads({
+            specType: previewSpecType,
+            targetHasMtp: (summary?.nextnPredictLayers ?? 0) > 0,
+            perBackend: !!manifestEngineConfig?.spec?.byBackend,
+        }) && installed.draftModelPath
+            ? (installed.draftModelSizeBytes ?? 0)
+            : 0;
+        const catalogDetail = draftBudgetBytes > 0 ? await this.catalog.get('chat-model', modelId).catch(() => null) : null;
+        const draftResidentBytes = llamaCppDraftResidentBytes(catalogDetail?.manifest.kind === 'chat-model'
+            ? catalogDetail.manifest.llamaCpp?.draftModel
+            : undefined, installed.draftModelPath);
+        const residentBytesWith = (draftBytes) => estimateLlamaCppResidentBytes(residentWeightFileBytes, {
             mmprojBytes: visionBudgetBytes,
+            draftBytes,
+            draftResidentBytes,
         });
+        let residentWeightsBytes = residentBytesWith(draftBudgetBytes);
         const exactPerSlotKvF16 = summary
             ? estimateExactPerSlotKvBytesF16({
                 blockCount: summary.blockCount,
@@ -1452,6 +1535,7 @@ export class LocalEngineRuntime {
                 maxSlots: defaultLocalEngineSlots(fastBudgetBytes),
             });
             kv = kvPlan.kvCacheType;
+            const draftFits = planFitsAt(kv, kvPlan.ctxCapTokens ?? grantedCtx, 1);
             // Mirror the launch: the f16-by-context-cap trade shrinks the granted
             // window here too, so the settings preview shows what will really run.
             if (kvPlan.ctxCapTokens !== undefined && kvPlan.ctxCapTokens < grantedCtx) {
@@ -1462,7 +1546,7 @@ export class LocalEngineRuntime {
                 ceiling: passCeiling(kv, grantedCtx),
                 tierDefault: defaultLocalEngineSlots(fastBudgetBytes),
             });
-            if ((config.llamaCppSpecType ?? manifestEngineConfig?.spec?.type) === 'draft-mtp')
+            if (previewSpecType === 'draft-mtp')
                 slots = 1;
             try {
                 if (!summary)
@@ -1544,7 +1628,14 @@ export class LocalEngineRuntime {
                         // SWA model without a readable layout, over budget on full
                         // math: the launch path leaves such a launch untouched — preview
                         // the requested window.
-                        return { grantedCtx, slots, kvCacheType: kv, plannedFieldsOk: false };
+                        return {
+                            grantedCtx,
+                            slots,
+                            kvCacheType: kv,
+                            plannedFieldsOk: false,
+                            draftFits,
+                            kvPlan,
+                        };
                     }
                 }
                 if (!admission.minimumSatisfied) {
@@ -1588,9 +1679,21 @@ export class LocalEngineRuntime {
                     throw error;
                 log.warn(`[llama-cpp] could not inspect ${modelId} while previewing admission: ${error instanceof Error ? error.message : String(error)}`);
             }
-            return { grantedCtx, slots, kvCacheType: kv, plannedFieldsOk: true };
+            return { grantedCtx, slots, kvCacheType: kv, plannedFieldsOk: true, draftFits, kvPlan };
         };
-        const plan = llamaPlanPass(explicitContextWindow, contextFloor);
+        let plan = llamaPlanPass(explicitContextWindow, contextFloor);
+        // The launch leaves out a catalog drafter that would cap the target window
+        // or cost its KV precision; the preview has to land on the same plan.
+        if (draftBudgetBytes > 0 && !config.llamaCppSpecType && !config.llamaCppDraftModelPath) {
+            residentWeightsBytes = residentBytesWith(0);
+            const withoutDrafter = llamaPlanPass(explicitContextWindow, contextFloor);
+            if (drafterCostsContext(plan.kvPlan, withoutDrafter.kvPlan, plan.draftFits)) {
+                plan = withoutDrafter;
+            }
+            else {
+                residentWeightsBytes = residentBytesWith(draftBudgetBytes);
+            }
+        }
         let autoContextWindow;
         if (overrideActive) {
             try {

package/dist/providers/native/process-identity.d.ts

@@ -1,2 +1,40 @@
+export declare function processAlive(pid: number): boolean;
 /** Birth stamps survive coordinator restarts and distinguish a reused PID. */
 export declare function readProcessIdentities(pids: readonly number[]): Promise<ReadonlyMap<number, string>>;
+/**
+ * How long a stamp read for a still-live PID is trusted. A PID can die and be
+ * reused between two liveness checks; this bounds how long such a dead
+ * engine's reservation outlives it. That is the safe direction: memory looks
+ * taken for a few seconds longer, never free twice.
+ */
+export declare const VERIFIED_IDENTITY_TTL_MS = 10000;
+export interface ProcessIdentityCacheOptions {
+    read?: (pids: readonly number[]) => Promise<ReadonlyMap<number, string>>;
+    alive?: (pid: number) => boolean;
+    now?: () => number;
+    ttlMs?: number;
+}
+/**
+ * Reading a birth stamp starts `ps`, or PowerShell on Windows. The capacity
+ * ledger used to read every PID it holds on each command, which ran before
+ * every engine request. A stamp read for a PID that is still alive is reused
+ * for a short while, and the PIDs that do need reading go in one batch.
+ *
+ * A cached stamp may only confirm the stamp a reservation already recorded.
+ * A stamp about to be recorded, or one that disagrees, is read again: another
+ * coordinator may have recorded a newer process at that PID, and trusting an
+ * older stamp there would free a live engine's memory.
+ */
+export declare class ProcessIdentityCache {
+    private readonly options;
+    private readonly verified;
+    constructor(options?: ProcessIdentityCacheOptions);
+    /**
+     * `record`: PIDs whose stamp is about to be written onto a reservation.
+     * `confirm`: each PID's stamps as reservations recorded them.
+     * PIDs that are dead, or whose stamp cannot be read, are left out.
+     */
+    lookup(record: Iterable<number>, confirm: ReadonlyMap<number, readonly string[]>): Promise<ReadonlyMap<number, string>>;
+}
+/** One cache per process: every ledger in it asks about the same OS processes. */
+export declare const sharedProcessIdentities: ProcessIdentityCache;

package/dist/providers/native/process-identity.js

@@ -11,6 +11,15 @@ const PROBE_PID_LIMIT = {
     darwin: 99_999,
     win32: 2_147_483_647,
 };
+export function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== 'ESRCH';
+    }
+}
 /** Birth stamps survive coordinator restarts and distinguish a reused PID. */
 export async function readProcessIdentities(pids) {
     const limit = PROBE_PID_LIMIT[process.platform] ?? Number.MAX_SAFE_INTEGER;
@@ -68,3 +77,80 @@ export async function readProcessIdentities(pids) {
     }
     return identities;
 }
+/**
+ * How long a stamp read for a still-live PID is trusted. A PID can die and be
+ * reused between two liveness checks; this bounds how long such a dead
+ * engine's reservation outlives it. That is the safe direction: memory looks
+ * taken for a few seconds longer, never free twice.
+ */
+export const VERIFIED_IDENTITY_TTL_MS = 10_000;
+/**
+ * Reading a birth stamp starts `ps`, or PowerShell on Windows. The capacity
+ * ledger used to read every PID it holds on each command, which ran before
+ * every engine request. A stamp read for a PID that is still alive is reused
+ * for a short while, and the PIDs that do need reading go in one batch.
+ *
+ * A cached stamp may only confirm the stamp a reservation already recorded.
+ * A stamp about to be recorded, or one that disagrees, is read again: another
+ * coordinator may have recorded a newer process at that PID, and trusting an
+ * older stamp there would free a live engine's memory.
+ */
+export class ProcessIdentityCache {
+    options;
+    verified = new Map();
+    constructor(options = {}) {
+        this.options = options;
+    }
+    /**
+     * `record`: PIDs whose stamp is about to be written onto a reservation.
+     * `confirm`: each PID's stamps as reservations recorded them.
+     * PIDs that are dead, or whose stamp cannot be read, are left out.
+     */
+    async lookup(record, confirm) {
+        const alive = this.options.alive ?? processAlive;
+        const ttl = this.options.ttlMs ?? VERIFIED_IDENTITY_TTL_MS;
+        const now = (this.options.now ?? (() => performance.now()))();
+        for (const [pid, entry] of this.verified) {
+            if (now - entry.at >= ttl)
+                this.verified.delete(pid);
+        }
+        const live = (pid) => {
+            if (alive(pid))
+                return true;
+            // Forget a PID seen dead, so whatever process takes it next is read.
+            this.verified.delete(pid);
+            return false;
+        };
+        const identities = new Map();
+        const unread = new Set();
+        for (const pid of record)
+            if (live(pid))
+                unread.add(pid);
+        for (const [pid, stamps] of confirm) {
+            if (unread.has(pid) || !live(pid))
+                continue;
+            const cached = this.verified.get(pid)?.identity;
+            if (cached !== undefined && stamps.every((stamp) => stamp === cached)) {
+                identities.set(pid, cached);
+            }
+            else {
+                unread.add(pid);
+            }
+        }
+        if (unread.size === 0)
+            return identities;
+        const read = await (this.options.read ?? readProcessIdentities)([...unread]).catch(() => new Map());
+        for (const pid of unread) {
+            const identity = read.get(pid);
+            if (identity === undefined) {
+                this.verified.delete(pid);
+                continue;
+            }
+            this.verified.set(pid, { identity, at: now });
+            identities.set(pid, identity);
+        }
+        return identities;
+    }
+}
+/** One cache per process: every ledger in it asks about the same OS processes. */
+export const sharedProcessIdentities = new ProcessIdentityCache();

package/dist/providers/native/supervisor.d.ts

@@ -516,7 +516,14 @@ export declare class NativeEngineSupervisor {
     private clearFreezeTimer;
     private clearHealthTimer;
 }
-/** High-precision fatal signatures; attribution happens only if the child exits. */
+/**
+ * High-precision fatal signatures; attribution happens only if the child exits.
+ *
+ * The `cuda-*` kinds also cover ROCm builds: ggml's ROCm backend is its CUDA
+ * code compiled with HIP, and it prints the same errors under the name `ROCm`
+ * (`ROCm error: out of memory`). The kinds are wire values, so they keep their
+ * names rather than growing a ROCm twin each.
+ */
 export declare function classifyNativeEnginePanic(line: string): {
     kind: NativeEnginePanicKind;
     line: string;

package/dist/providers/native/supervisor.js

@@ -1415,13 +1415,20 @@ export class NativeEngineSupervisor {
         }
     }
 }
-/** High-precision fatal signatures; attribution happens only if the child exits. */
+/**
+ * High-precision fatal signatures; attribution happens only if the child exits.
+ *
+ * The `cuda-*` kinds also cover ROCm builds: ggml's ROCm backend is its CUDA
+ * code compiled with HIP, and it prints the same errors under the name `ROCm`
+ * (`ROCm error: out of memory`). The kinds are wire values, so they keep their
+ * names rather than growing a ROCm twin each.
+ */
 export function classifyNativeEnginePanic(line) {
     const clipped = line.trim().slice(0, 1_000);
-    if (/CUDA error:\s*invalid (?:configuration )?argument/i.test(line)) {
+    if (/(?:CUDA|ROCm) error:\s*invalid (?:configuration )?argument/i.test(line)) {
         return { kind: 'cuda-invalid-argument', line: clipped };
     }
-    if (/CUDA error:\s*(?:out of memory|memory allocation)/i.test(line)) {
+    if (/(?:CUDA|ROCm) error:\s*(?:out of memory|memory allocation)/i.test(line)) {
         return { kind: 'cuda-out-of-memory', line: clipped };
     }
     // Vulkan's spellings of the same condition — the backend a non-CUDA
@@ -1429,16 +1436,18 @@ export function classifyNativeEnginePanic(line) {
     if (/ErrorOutOfDeviceMemory|OutOfDeviceMemoryError|ggml_vulkan:.*(?:allocation|memory).*failed/i.test(line)) {
         return { kind: 'vulkan-out-of-memory', line: clipped };
     }
-    if (/CUDA error:\s*(?:an )?illegal memory access/i.test(line)) {
+    if (/(?:CUDA|ROCm) error:\s*(?:an )?illegal memory access/i.test(line)) {
         return { kind: 'cuda-illegal-memory-access', line: clipped };
     }
-    if (/CUDA error:.*device-side assert/i.test(line)) {
+    if (/(?:CUDA|ROCm) error:.*device-side assert/i.test(line)) {
         return { kind: 'cuda-device-assert', line: clipped };
     }
-    if (/CUDA error:\s*(?:no kernel image is available|the provided PTX was compiled with an unsupported toolchain)/i.test(line)) {
+    if (/(?:CUDA|ROCm) error:\s*(?:no kernel image is available|invalid device function|the provided PTX was compiled with an unsupported toolchain)/i.test(line) ||
+        // rocBLAS names the architecture it has no kernel library for, then aborts.
+        /rocBLAS error: Cannot read .*TensileLibrary.*for GPU arch/i.test(line)) {
         return { kind: 'cuda-unsupported-device', line: clipped };
     }
-    if (/CUDA error:/i.test(line))
+    if (/(?:CUDA|ROCm) error:/i.test(line))
         return { kind: 'cuda-error', line: clipped };
     if (/assert(?:ion)? failed|GGML_ASSERT/i.test(line)) {
         return { kind: 'assertion-failed', line: clipped };

package/dist/providers/types.d.ts

@@ -600,6 +600,10 @@ export interface EngineLaunchSnapshot {
 export interface ModelInfo {
     id: string;
     name: string;
+    /** One short line a picker shows beside the name. */
+    description?: string;
+    /** Heading a picker lists this model under; see core's `ModelInfoSchema`. */
+    group?: string;
     supportsReasoning?: boolean;
     reasoningEfforts?: string[];
     defaultReasoningEffort?: string;

package/dist/remotes/types.d.ts

@@ -11,7 +11,7 @@ export interface PairedRemote {
     remoteId: string;
     /** Base URL A reaches the server at, e.g. `https://192.168.1.50:6229`. */
     baseUrl: string;
-    /** Human label shown in A's model picker / Remote Servers panel. */
+    /** Human label shown in A's model picker / Remote servers panel. */
     displayName: string;
     /** Per-device bearer token the server issued A (scope `remote-inference`). */
     token: string;

package/dist/runtime-lock.d.ts

@@ -1,3 +1,6 @@
+import { type LockIdentity, currentLockIdentity, parseLockFile, procStartTicks, sharesPidNamespace } from '@bendyline/gezel/native';
+export type { LockIdentity };
+export { currentLockIdentity, parseLockFile, procStartTicks, sharesPidNamespace };
 /**
  * Thrown when a gezel home already has a live daemon. The CLI's `gezel
  * start` / the supervisor surface this as an actionable message rather
@@ -12,33 +15,6 @@ export declare class SingleInstanceError extends Error {
 export interface RuntimeLock {
     release(): Promise<void>;
 }
-/**
- * Who holds a lock. A pid alone identifies a process only inside one pid
- * namespace on one boot: two containers sharing a volume each see the
- * other's pid as dead (or as an unrelated process), which let a one-shot
- * `docker run … gezel do` reclaim a serving container's live lock. The
- * namespace, boot and host fields say when a pid check is meaningful; a
- * holder outside our namespace is judged by the lock file's heartbeat.
- */
-export interface LockIdentity {
-    pid: number;
-    hostname?: string;
-    bootId?: string;
-    pidNs?: string;
-    /** Process start time in clock ticks since boot (`/proc/<pid>/stat` field 22). */
-    startTicks?: string;
-    /** Random per-process id; tells our own heartbeat whether the lock is still ours. */
-    instance?: string;
-}
-export declare function procStartTicks(pid: number | 'self'): string | undefined;
-export declare function currentLockIdentity(): LockIdentity;
-export declare function parseLockFile(text: string): LockIdentity | null;
-/**
- * Whether a pid check against `holder` means anything here. Any field the
- * holder recorded must match ours; a legacy pid-only record is assumed to be
- * in our namespace, which is how it was judged before.
- */
-export declare function sharesPidNamespace(holder: LockIdentity, me: LockIdentity): boolean;
 /**
  * Acquire an exclusive single-instance lock for a gezel home so two daemons
  * can't share one `~/.gezel/` and race its on-disk state (config, sessions,