@bendyline/gezel-inference 1.0.6 → 1.0.8

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
@@ -6,7 +9,8 @@
 export declare class SingleInstanceError extends Error {
     readonly holderPid: number;
     readonly lockPath: string;
-    constructor(holderPid: number, lockPath: string);
+    readonly holderHost?: string | undefined;
+    constructor(holderPid: number, lockPath: string, holderHost?: string | undefined);
 }
 export interface RuntimeLock {
     release(): Promise<void>;
@@ -15,15 +19,25 @@ export interface RuntimeLock {
  * 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,
  * tasks, runtime files). Atomic `O_CREAT|O_EXCL` create of
- * `<runtimeDir>/lock` holding the owner pid; a stale lock (dead holder) is
+ * `<runtimeDir>/lock` holding the owner's identity; a stale lock is
  * reclaimed. Throws {@link SingleInstanceError} when a live daemon holds it.
  *
- * The returned `release()` removes the lock — call it on graceful shutdown.
- * A hard crash leaves a stale lock that the next start reclaims via the
- * pid-liveness check.
+ * While held, the lock file's mtime is touched every few seconds: that
+ * heartbeat is how a daemon in another container (another pid namespace)
+ * is told apart from a dead one.
+ *
+ * The returned `release()` stops the heartbeat and removes the lock — call
+ * it on graceful shutdown. A hard crash leaves a stale lock the next start
+ * reclaims.
  */
 export declare function acquireSingleInstanceLock(opts: {
     runtimeDir: string;
     lockPath: string;
     isAlive?: (pid: number) => boolean;
+    identity?: LockIdentity;
+    startTicksOf?: (pid: number) => string | undefined;
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+    heartbeatIntervalMs?: number;
+    staleAfterMs?: number;
 }): Promise<RuntimeLock>;

package/dist/runtime-lock.js

@@ -1,4 +1,6 @@
-import { mkdir, open, readFile, rm } from 'node:fs/promises';
+import { mkdir, open, readFile, rm, stat, utimes } from 'node:fs/promises';
+import { LOCK_HEARTBEAT_INTERVAL_MS, LOCK_STALE_AFTER_MS, currentLockIdentity, foreignHolderMessage, parseLockFile, procStartTicks, sharesPidNamespace, } from '@bendyline/gezel/native';
+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
@@ -7,15 +9,21 @@ import { mkdir, open, readFile, rm } from 'node:fs/promises';
 export class SingleInstanceError extends Error {
     holderPid;
     lockPath;
-    constructor(holderPid, lockPath) {
-        super(holderPid > 0
-            ? `Another gezel daemon is already running for this home (pid ${holderPid}). Stop it first with \`gezel stop\`, or use a different GEZEL_HOME.`
-            : `Could not acquire the single-instance lock at ${lockPath}.`);
+    holderHost;
+    constructor(holderPid, lockPath, holderHost) {
+        super(holderHost !== undefined
+            ? foreignHolderMessage({ pid: holderPid, hostname: holderHost })
+            : holderPid > 0
+                ? `Another gezel daemon is already running for this home (pid ${holderPid}). Stop it first with \`gezel stop\`, or use a different GEZEL_HOME.`
+                : `Could not acquire the single-instance lock at ${lockPath}.`);
         this.holderPid = holderPid;
         this.lockPath = lockPath;
+        this.holderHost = holderHost;
         this.name = 'SingleInstanceError';
     }
 }
+// A holder's identity (core's lock-identity.ts) is what let a one-shot
+// `docker run … gezel do` stop reclaiming a serving container's live lock.
 function defaultIsAlive(pid) {
     try {
         process.kill(pid, 0);
@@ -27,55 +35,104 @@ function defaultIsAlive(pid) {
         return err.code === 'EPERM';
     }
 }
-async function readHolderPid(lockPath) {
+/**
+ * The pid stays on the first line so a daemon from before the identity
+ * record (which parses the leading integer) still reads it as held instead
+ * of stale.
+ */
+function serializeIdentity(identity) {
+    return `${identity.pid}\n${JSON.stringify({ v: 1, ...identity })}\n`;
+}
+async function readHolder(lockPath) {
+    try {
+        return parseLockFile(await readFile(lockPath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+async function lockMtimeMs(lockPath) {
     try {
-        const pid = Number.parseInt((await readFile(lockPath, 'utf8')).trim(), 10);
-        return Number.isFinite(pid) ? pid : null;
+        return (await stat(lockPath)).mtimeMs;
     }
     catch {
         return null;
     }
 }
+/**
+ * A holder outside our pid namespace is alive while its heartbeat moves.
+ * A fresh-looking mtime may be a holder that died moments ago (a killed
+ * container restarting onto its own volume), so wait until the heartbeat
+ * either advances (alive) or ages past the stale bound (dead).
+ */
+async function foreignHolderIsAlive(lockPath, opts) {
+    const first = await lockMtimeMs(lockPath);
+    if (first === null)
+        return false;
+    for (;;) {
+        if (opts.now() - first > opts.staleAfterMs)
+            return false;
+        await opts.sleep(1_000);
+        const current = await lockMtimeMs(lockPath);
+        if (current === null)
+            return false;
+        if (current !== first)
+            return true;
+    }
+}
 /**
  * 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,
  * tasks, runtime files). Atomic `O_CREAT|O_EXCL` create of
- * `<runtimeDir>/lock` holding the owner pid; a stale lock (dead holder) is
+ * `<runtimeDir>/lock` holding the owner's identity; a stale lock is
  * reclaimed. Throws {@link SingleInstanceError} when a live daemon holds it.
  *
- * The returned `release()` removes the lock — call it on graceful shutdown.
- * A hard crash leaves a stale lock that the next start reclaims via the
- * pid-liveness check.
+ * While held, the lock file's mtime is touched every few seconds: that
+ * heartbeat is how a daemon in another container (another pid namespace)
+ * is told apart from a dead one.
+ *
+ * The returned `release()` stops the heartbeat and removes the lock — call
+ * it on graceful shutdown. A hard crash leaves a stale lock the next start
+ * reclaims.
  */
 export async function acquireSingleInstanceLock(opts) {
     const isAlive = opts.isAlive ?? defaultIsAlive;
+    const me = opts.identity ?? currentLockIdentity();
+    const startTicksOf = opts.startTicksOf ?? procStartTicks;
+    const now = opts.now ?? Date.now;
+    const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const staleAfterMs = opts.staleAfterMs ?? LOCK_STALE_AFTER_MS;
     await mkdir(opts.runtimeDir, { recursive: true });
     for (let attempt = 0; attempt < 3; attempt++) {
         try {
             const handle = await open(opts.lockPath, 'wx'); // fails with EEXIST if present
             try {
-                await handle.writeFile(`${process.pid}\n`);
+                await handle.writeFile(serializeIdentity(me));
             }
             finally {
                 await handle.close();
             }
-            return {
-                async release() {
-                    // Only remove the lock if it's still ours — defends against a
-                    // narrow race where another process reclaimed our stale lock.
-                    const holder = await readHolderPid(opts.lockPath);
-                    if (holder === null || holder === process.pid) {
-                        await rm(opts.lockPath, { force: true }).catch(() => { });
-                    }
-                },
-            };
+            return holdLock(opts.lockPath, me, opts.heartbeatIntervalMs ?? LOCK_HEARTBEAT_INTERVAL_MS);
         }
         catch (err) {
             if (err.code !== 'EEXIST')
                 throw err;
-            const holder = await readHolderPid(opts.lockPath);
-            if (holder !== null && holder !== process.pid && isAlive(holder)) {
-                throw new SingleInstanceError(holder, opts.lockPath);
+            const holder = await readHolder(opts.lockPath);
+            if (holder) {
+                if (!sharesPidNamespace(holder, me)) {
+                    if (await foreignHolderIsAlive(opts.lockPath, { now, sleep, staleAfterMs })) {
+                        throw new SingleInstanceError(holder.pid, opts.lockPath, holder.hostname ?? 'unknown');
+                    }
+                }
+                else if (holder.pid !== me.pid && isAlive(holder.pid)) {
+                    // A recorded start time that no longer matches means the pid was
+                    // reused by an unrelated process after the holder died.
+                    const reused = holder.startTicks !== undefined &&
+                        startTicksOf(holder.pid) !== undefined &&
+                        startTicksOf(holder.pid) !== holder.startTicks;
+                    if (!reused)
+                        throw new SingleInstanceError(holder.pid, opts.lockPath);
+                }
             }
             // Stale (dead holder / our own pid / unreadable) — reclaim and retry.
             await rm(opts.lockPath, { force: true }).catch(() => { });
@@ -83,3 +140,36 @@ export async function acquireSingleInstanceLock(opts) {
     }
     throw new SingleInstanceError(-1, opts.lockPath);
 }
+function holdLock(lockPath, me, intervalMs) {
+    const isOurs = (holder) => holder === null ||
+        (me.instance !== undefined && holder.instance !== undefined
+            ? holder.instance === me.instance
+            : holder.pid === me.pid);
+    let timer = setInterval(() => {
+        void (async () => {
+            const holder = await readHolder(lockPath);
+            if (holder === null || !isOurs(holder)) {
+                // Someone else owns the file now; touching it would keep their lock
+                // looking alive on our behalf.
+                clearInterval(timer);
+                timer = undefined;
+                return;
+            }
+            const at = new Date();
+            await utimes(lockPath, at, at).catch(() => { });
+        })();
+    }, intervalMs);
+    timer.unref?.();
+    return {
+        async release() {
+            if (timer)
+                clearInterval(timer);
+            timer = undefined;
+            // Only remove the lock if it's still ours — defends against a
+            // narrow race where another process reclaimed our stale lock.
+            if (isOurs(await readHolder(lockPath))) {
+                await rm(lockPath, { force: true }).catch(() => { });
+            }
+        },
+    };
+}

package/dist/system/host-memory.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Memory and CPU as this process may actually use them. `os.totalmem()` and
+ * `os.availableParallelism()` describe the host; inside a container started
+ * with `--memory 8g --cpus 4` on a 64 GB, 16-core machine they still say 64
+ * and 16, so a model sized from them gets the container killed by its own
+ * cgroup. Every sizing decision reads these instead.
+ */
+export interface HostLimitsProbe {
+    totalmem: () => number;
+    freemem: () => number;
+    constrainedMemory: () => number | undefined;
+    availableMemory: () => number | undefined;
+    availableParallelism: () => number;
+    /** Every logical CPU the host has, whatever this process may use. */
+    hostCpuCount: () => number;
+    readFile: (path: string) => string | undefined;
+}
+/**
+ * The cgroup memory limit when it is below the host's RAM, else null.
+ * Node reads cgroup v1 and v2; "no limit" comes back as 0 or as a value at
+ * or above physical RAM, depending on the libuv release.
+ */
+export declare function containerMemoryLimitBytes(probe?: HostLimitsProbe): number | null;
+/** RAM this process may use: host RAM, or the container's limit when lower. */
+export declare function totalMemoryBytes(probe?: HostLimitsProbe): number;
+/** Free RAM, never more than the container's limit leaves. */
+export declare function freeMemoryBytes(probe?: HostLimitsProbe): number;
+/**
+ * Caps a host-wide free-memory reading (`MemAvailable`, `vm_stat`) to what
+ * the container still has. Unchanged outside a container.
+ */
+export declare function capToContainer(hostFreeBytes: number, probe?: HostLimitsProbe): number;
+/**
+ * CPUs this process may keep busy: the scheduler's CPU set, further capped
+ * by a cgroup v2 `cpu.max` quota (or v1 `cfs_quota_us`) rounded up.
+ */
+export declare function availableCpuCount(probe?: HostLimitsProbe): number;
+export declare function cgroupCpuQuota(probe?: HostLimitsProbe): number | null;
+/**
+ * The CPUs a container (a `--cpus` quota or a `--cpuset-cpus` set) leaves this
+ * process when that is fewer than the host has, else null. Engines that size
+ * their own thread pool from the host's cores, as llama.cpp does, oversubscribe
+ * such a limit badly: 32 threads under a 4-CPU quota spend most of each period
+ * throttled. Measured in a 4-CPU container: a 0.8B model decoded at 3.7 t/s.
+ */
+export declare function containerCpuLimit(probe?: HostLimitsProbe): number | null;

package/dist/system/host-memory.js

@@ -0,0 +1,89 @@
+import { readFileSync } from 'node:fs';
+import { availableParallelism, cpus, freemem, totalmem } from 'node:os';
+function readTrimmed(path) {
+    try {
+        return readFileSync(path, 'utf8').trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+const nodeProbe = {
+    totalmem,
+    freemem,
+    constrainedMemory: () => typeof process.constrainedMemory === 'function' ? process.constrainedMemory() : undefined,
+    availableMemory: () => typeof process.availableMemory === 'function' ? process.availableMemory() : undefined,
+    availableParallelism,
+    hostCpuCount: () => cpus().length,
+    readFile: (path) => (process.platform === 'linux' ? readTrimmed(path) : undefined),
+};
+/**
+ * The cgroup memory limit when it is below the host's RAM, else null.
+ * Node reads cgroup v1 and v2; "no limit" comes back as 0 or as a value at
+ * or above physical RAM, depending on the libuv release.
+ */
+export function containerMemoryLimitBytes(probe = nodeProbe) {
+    const host = probe.totalmem();
+    const limit = probe.constrainedMemory();
+    if (typeof limit === 'number' && Number.isFinite(limit) && limit > 0 && limit < host) {
+        return limit;
+    }
+    return null;
+}
+/** RAM this process may use: host RAM, or the container's limit when lower. */
+export function totalMemoryBytes(probe = nodeProbe) {
+    return containerMemoryLimitBytes(probe) ?? probe.totalmem();
+}
+/** Free RAM, never more than the container's limit leaves. */
+export function freeMemoryBytes(probe = nodeProbe) {
+    return capToContainer(probe.freemem(), probe);
+}
+/**
+ * Caps a host-wide free-memory reading (`MemAvailable`, `vm_stat`) to what
+ * the container still has. Unchanged outside a container.
+ */
+export function capToContainer(hostFreeBytes, probe = nodeProbe) {
+    if (containerMemoryLimitBytes(probe) === null)
+        return hostFreeBytes;
+    const available = probe.availableMemory();
+    if (typeof available !== 'number' || !Number.isFinite(available) || available < 0) {
+        return hostFreeBytes;
+    }
+    return Math.min(hostFreeBytes, available);
+}
+/**
+ * CPUs this process may keep busy: the scheduler's CPU set, further capped
+ * by a cgroup v2 `cpu.max` quota (or v1 `cfs_quota_us`) rounded up.
+ */
+export function availableCpuCount(probe = nodeProbe) {
+    const cpus = Math.max(1, probe.availableParallelism());
+    const quota = cgroupCpuQuota(probe);
+    return quota === null ? cpus : Math.max(1, Math.min(cpus, Math.ceil(quota)));
+}
+export function cgroupCpuQuota(probe = nodeProbe) {
+    const v2 = probe.readFile('/sys/fs/cgroup/cpu.max');
+    if (v2) {
+        const [max, period] = v2.split(/\s+/);
+        const quota = Number(max);
+        const per = Number(period);
+        if (max !== 'max' && quota > 0 && per > 0)
+            return quota / per;
+        return null;
+    }
+    const v1Quota = Number(probe.readFile('/sys/fs/cgroup/cpu/cpu.cfs_quota_us'));
+    const v1Period = Number(probe.readFile('/sys/fs/cgroup/cpu/cpu.cfs_period_us'));
+    if (v1Quota > 0 && v1Period > 0)
+        return v1Quota / v1Period;
+    return null;
+}
+/**
+ * The CPUs a container (a `--cpus` quota or a `--cpuset-cpus` set) leaves this
+ * process when that is fewer than the host has, else null. Engines that size
+ * their own thread pool from the host's cores, as llama.cpp does, oversubscribe
+ * such a limit badly: 32 threads under a 4-CPU quota spend most of each period
+ * throttled. Measured in a 4-CPU container: a 0.8B model decoded at 3.7 t/s.
+ */
+export function containerCpuLimit(probe = nodeProbe) {
+    const allowed = availableCpuCount(probe);
+    return allowed < probe.hostCpuCount() ? allowed : null;
+}

package/dist/system/memory.js

@@ -1,11 +1,12 @@
 import { execFile } from 'node:child_process';
-import { freemem, platform as osPlatform, totalmem } from 'node:os';
+import { platform as osPlatform } from 'node:os';
 import { promisify } from 'node:util';
 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';
+import { freeMemoryBytes, totalMemoryBytes } from './host-memory.js';
 const exec = promisify(execFile);
 let cachedMemoryProfile = null;
 let pendingMemoryProfile = null;
@@ -25,7 +26,7 @@ let pendingMemoryProfile = null;
  */
 export async function detectMemoryProfile() {
     const plat = osPlatform();
-    const totalRam = totalmem();
+    const totalRam = totalMemoryBytes();
     if (plat === 'darwin') {
         setDetectedGpuVramBytes(null);
         return {
@@ -311,7 +312,7 @@ export function sampleMachineMemoryUsage(opts) {
     const residentModels = opts.residentModels ?? [];
     const sampledAt = opts.sampledAt ?? new Date().toISOString();
     if (mainMemory) {
-        const freeRamBytes = clamp(finiteNonNegative(opts.darwinSystemMemory?.freeBytes ?? opts.freeRamBytes ?? freemem()), 0, totalRamBytes);
+        const freeRamBytes = clamp(finiteNonNegative(opts.darwinSystemMemory?.freeBytes ?? opts.freeRamBytes ?? freeMemoryBytes()), 0, totalRamBytes);
         const cachedBytes = opts.darwinSystemMemory
             ? clamp(finiteNonNegative(opts.darwinSystemMemory.cachedBytes), 0, totalRamBytes - freeRamBytes)
             : null;
@@ -512,7 +513,7 @@ function clamp(value, min, max) {
  * held back only ~3 GiB for the OS, so a 95 GB chat model and a 10 GB image
  * model were co-admitted and the image engine died with a CUDA OOM at init.
  */
-export function parseNvidiaMemoryProbe(stdout, systemRamBytes = totalmem()) {
+export function parseNvidiaMemoryProbe(stdout, systemRamBytes = totalMemoryBytes()) {
     const devices = [];
     for (const rawLine of stdout.split(/\r?\n/)) {
         // GPU names can theoretically contain commas. Split on the final field,

package/dist/transformers-cache.js

@@ -19,6 +19,7 @@ import { createReadStream } from 'node:fs';
 import { mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { basename, dirname, join, resolve } from 'node:path';
 import { createLogger } from '@bendyline/gezel';
+import { disableOnnxRuntimeTelemetry } from '@bendyline/gezel/native';
 import { isPathInside } from './fs/safe-paths.js';
 const log = createLogger('service');
 /**
@@ -330,6 +331,7 @@ export function isMissingModule(err, specifier) {
     return new RegExp(String.raw `Cannot find (?:package|module) '${escaped}'`).test(err.message);
 }
 async function defaultLoadEnv() {
+    disableOnnxRuntimeTelemetry();
     const mod = (await import('@huggingface/transformers'));
     return mod.env;
 }

package/dist/utils/download-common.d.ts

@@ -14,7 +14,7 @@ export declare const downloadLog: import("@bendyline/gezel").Logger;
  * transparent about who we are is the right posture for a third-party client
  * fetching public weights on the user's behalf.
  */
-export declare const GEZEL_DOWNLOAD_UA = "gezel/0.0.0 (+https://github.com/bendyline/gezel)";
+export declare const GEZEL_DOWNLOAD_UA: string;
 /**
  * Headers for an HF control-plane request. An optional operator token raises
  * public-model rate limits, but is never forwarded to Xet/CAS/CDN hosts.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bendyline/gezel-inference",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Gezel's on-device inference runtime: native engines, local model management, embeddings, knowledge search, and OpenAI-compatible routes.",
   "license": "MIT",
   "keywords": [
@@ -73,16 +73,16 @@
     "!dist/**/__pycache__"
   ],
   "dependencies": {
-    "@bendyline/gezel": "1.2.11",
-    "@bendyline/gezel-catalog": "1.2.11",
-    "@bendyline/gezel-client": "1.2.11",
-    "@bendyline/gezel-knowledge": "1.2.9",
-    "hono": "4.13.9",
+    "@bendyline/gezel": "1.2.13",
+    "@bendyline/gezel-catalog": "1.2.13",
+    "@bendyline/gezel-client": "1.2.13",
+    "@bendyline/gezel-knowledge": "1.2.10",
+    "hono": "4.13.14",
     "tar": "7.5.21",
-    "undici": "8.11.2",
+    "undici": "8.12.3",
     "yauzl": "^3.4.0",
     "yazl": "^3.3.1",
-    "zod": "^4.4.3"
+    "zod": "4.6.7"
   },
   "peerDependencies": {
     "@huggingface/transformers": "^4.3.1"