@bendyline/gezel-inference 0.0.0-stage → 1.0.0

package/dist/python/uv-runtime.js

@@ -0,0 +1,492 @@
+/**
+ * UvRuntime — provisions Python virtualenvs for Gezel features that
+ * need to run Python tools (MLX, future Whisper / STT engines, etc.).
+ *
+ * Detection order on first `ensureVenv`:
+ *
+ *   1. **Bundled uv** at `process.env.GEZEL_UV_BIN` — packaged Gezel
+ *      owns the Python bootstrap and never invokes the macOS
+ *      `/usr/bin/python3` developer-tools shim.
+ *   2. **System `uv`** on PATH — development / bare-service fallback
+ *      when no bundled binary is available. uv installs its own Python.
+ *   3. **System `python3`** (or `python`) on PATH with version ≥
+ *      `minPythonVersion` (default 3.10) — create the venv with
+ *      stock `python -m venv` + pip. This is a last-resort fallback
+ *      for non-packaged installs only.
+ *
+ * The selected source is recorded per-venv in `uv.json`; subsequent
+ * `ensureVenv` calls for the same name with the same package list
+ * reuse the existing venv without re-probing.
+ *
+ * Storage layout:
+ *
+ *   <home>/engines/uv/
+ *   └── venvs/
+ *       └── <name>/
+ *           ├── uv.json                (this module's manifest)
+ *           ├── bin/python | Scripts\python.exe
+ *           └── lib/python3.x/...      (standard venv contents)
+ *
+ * Intentionally engine-agnostic — callers ask `ensureVenv('mlx',
+ * ['mlx-lm==X'])` and get a `VenvHandle` with the Python binary path
+ * and a `binPath(name)` helper for console scripts. How the venv got
+ * there is hidden behind the `source` field for Settings to display.
+ */
+import { exec as nodeExec, spawn as nodeSpawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { KeyedLock, createLogger, resolveDistributionProfile } from '@bendyline/gezel';
+import { windowsHeadlessSpawnOptions } from '@bendyline/gezel/native';
+const log = createLogger('uv');
+const DEFAULT_MIN_PY = '3.10';
+const DEFAULT_PREFERRED_PY = '3.11';
+export class UvRuntime {
+    home;
+    venvsRoot;
+    bundledUvBinOverride;
+    readBundledUvFromEnv;
+    spawn;
+    exec;
+    onLog;
+    /** Cached probe result so repeated `ensureVenv` calls skip the re-probe. */
+    probed = null;
+    /**
+     * Per-venv-name serialization tail. The MLX venv is now provisioned
+     * by two concurrent callers — the parallel warm fired when a model
+     * install starts, and the lazy first-chat `ensureVenv` — and on a
+     * cold machine both can miss the manifest fast-path and call
+     * `createVenv()`, which `rm -rf`s the venv dir. Two of those racing
+     * clobber each other's install. We chain same-name calls so the
+     * second observes the first's finished venv via the fast-path
+     * instead of rebuilding it.
+     */
+    venvLocks = new KeyedLock();
+    constructor(opts) {
+        this.home = opts.home;
+        this.venvsRoot = join(opts.home, 'engines', 'uv', 'venvs');
+        this.readBundledUvFromEnv = opts.bundledUvBin === undefined;
+        this.bundledUvBinOverride = opts.bundledUvBin ?? null;
+        this.spawn = opts.spawn ?? nodeSpawn;
+        const execFn = opts.exec ?? nodeExec;
+        this.exec = promisify(execFn);
+        this.onLog = opts.onLog ?? ((line) => log.info(line));
+    }
+    /**
+     * Idempotent: return a handle to the named venv with the requested
+     * packages installed. Creates the venv if missing; installs/upgrades
+     * packages when the recorded set differs from the request.
+     */
+    async ensureVenv(opts) {
+        if (!isSafeVenvName(opts.name)) {
+            throw new Error(`unsafe venv name: ${opts.name}`);
+        }
+        // Serialize per-name so a background warm and the lazy first-chat
+        // call for the same venv don't both run createVenv() concurrently
+        // (see `venvLocks`). The second caller, chained after the first,
+        // hits the manifest fast-path and returns the already-built venv.
+        return this.venvLocks.run(opts.name, () => this.ensureVenvSerial(opts));
+    }
+    async ensureVenvSerial(opts) {
+        const minPy = opts.minPythonVersion ?? DEFAULT_MIN_PY;
+        const preferredPy = opts.preferredPythonVersion ?? DEFAULT_PREFERRED_PY;
+        const packages = [...opts.packages].sort();
+        const indexConfig = {
+            ...(opts.indexUrl ? { indexUrl: opts.indexUrl } : {}),
+            ...(opts.extraIndexUrls && opts.extraIndexUrls.length > 0
+                ? { extraIndexUrls: [...opts.extraIndexUrls].sort() }
+                : {}),
+        };
+        const venvRoot = join(this.venvsRoot, opts.name);
+        const manifestPath = join(venvRoot, 'uv.json');
+        const pythonPath = venvPythonPath(venvRoot);
+        const existing = await readManifest(manifestPath);
+        if (existing &&
+            existsSync(pythonPath) &&
+            packageListsEqual(existing.packages, packages) &&
+            indexConfigEqual(existing, indexConfig)) {
+            return toHandle(existing, venvRoot);
+        }
+        const probe = await this.resolveInstaller(minPy);
+        await mkdir(this.venvsRoot, { recursive: true });
+        if (!existsSync(pythonPath)) {
+            await this.createVenv(probe, venvRoot, preferredPy);
+        }
+        if (packages.length > 0) {
+            await this.installPackages(probe, venvRoot, packages, indexConfig);
+        }
+        const pythonVersion = await this.readPythonVersion(venvPythonPath(venvRoot));
+        const now = new Date().toISOString();
+        const manifest = {
+            version: 1,
+            name: opts.name,
+            source: probe.source,
+            pythonVersion,
+            ...(probe.uvVersion ? { uvVersion: probe.uvVersion } : {}),
+            packages,
+            ...(indexConfig.indexUrl ? { indexUrl: indexConfig.indexUrl } : {}),
+            ...(indexConfig.extraIndexUrls ? { extraIndexUrls: indexConfig.extraIndexUrls } : {}),
+            installedAt: now,
+            installerPath: probe.installerPath,
+        };
+        await writeFile(manifestPath, JSON.stringify(manifest, null, 2), 'utf8');
+        return toHandle(manifest, venvRoot);
+    }
+    /** Delete a venv entirely. No-op when it doesn't exist. */
+    async removeVenv(name) {
+        if (!isSafeVenvName(name)) {
+            throw new Error(`unsafe venv name: ${name}`);
+        }
+        await rm(join(this.venvsRoot, name), { recursive: true, force: true });
+    }
+    /** List every venv with a valid manifest under `venvs/`. Sorted by name. */
+    async listVenvs() {
+        let entries = [];
+        try {
+            entries = await readdir(this.venvsRoot);
+        }
+        catch {
+            return [];
+        }
+        const out = [];
+        for (const name of entries.sort()) {
+            const manifest = await readManifest(join(this.venvsRoot, name, 'uv.json'));
+            if (manifest) {
+                out.push(toHandle(manifest, join(this.venvsRoot, name)));
+            }
+        }
+        return out;
+    }
+    /**
+     * Report on the current runtime without creating a venv — powers the
+     * Settings "Python runtime" status block.
+     *   - `source`: `null` when no suitable runtime exists on this host.
+     *   - `pythonVersion`: the interpreter version we'd use (system Python
+     *     or uv-managed; empty string for uv when no venv created yet).
+     */
+    async describeRuntime(minPythonVersion = DEFAULT_MIN_PY) {
+        const bundledUvBin = this.resolveBundledUvBin();
+        const bundledUvAvailable = bundledUvBin != null && existsSync(bundledUvBin);
+        try {
+            const probe = await this.resolveInstaller(minPythonVersion);
+            const out = {
+                source: probe.source,
+                installerPath: probe.installerPath,
+                bundledUvAvailable,
+            };
+            if (probe.uvVersion)
+                out.uvVersion = probe.uvVersion;
+            if (probe.pythonVersion)
+                out.pythonVersion = probe.pythonVersion;
+            return out;
+        }
+        catch (err) {
+            return {
+                source: null,
+                bundledUvAvailable,
+                reason: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    async resolveInstaller(minPy) {
+        // ── 0. Builds that may not provision Python at all ────────────
+        // Every rung below ends in creating a venv and installing wheels, which
+        // is downloading executable code. A store build must refuse here rather
+        // than probe successfully and fail later: finding a system interpreter it
+        // is then forbidden to install into produces a confusing failure deep in
+        // a model load instead of a sentence the user can act on.
+        //
+        // The frozen-runtime rung a packaged Python will resolve through belongs
+        // directly above this check, and turns the refusal into a resolution.
+        const distribution = resolveDistributionProfile();
+        if (distribution.pythonProvisioning === 'frozen-only') {
+            const err = new Error(distribution.refusalReason('python'));
+            err.isActionable = true;
+            throw err;
+        }
+        const bundledUvBin = this.resolveBundledUvBin();
+        // A runtime download can stamp GEZEL_UV_BIN after this manager was
+        // constructed (the CLI first-run bootstrap does exactly that). Prefer the
+        // newly available pinned binary even if an earlier call cached a system
+        // fallback, so the same daemon can continue without a restart.
+        if (bundledUvBin && existsSync(bundledUvBin) && this.probed?.installerPath !== bundledUvBin) {
+            this.probed = null;
+        }
+        if (this.probed)
+            return this.probed;
+        // ── 1. Bundled uv ────────────────────────────────────────────
+        // Packaged builds always take this branch. In particular, do not
+        // probe `python3` first on macOS: Apple's stub opens the intrusive
+        // "install Command Line Developer Tools" dialog just to answer
+        // `--version`, even though Gezel already ships everything needed to
+        // provision an isolated Python under GEZEL_HOME.
+        if (bundledUvBin && existsSync(bundledUvBin)) {
+            const version = await this.probeCommandVersion(`"${bundledUvBin}" --version`, /uv\s+(\d[\w.+-]*)/i);
+            this.probed = {
+                source: 'bundled-uv',
+                installerPath: bundledUvBin,
+                ...(version ? { uvVersion: version } : {}),
+            };
+            this.onLog(`[uv-runtime] using bundled uv ${version ?? '?'} at ${bundledUvBin}`);
+            return this.probed;
+        }
+        // ── 2. System uv on PATH ──────────────────────────────────────
+        const sysUv = await this.probeCommandVersion('uv --version', /uv\s+(\d[\w.+-]*)/i);
+        if (sysUv) {
+            this.probed = {
+                source: 'system-uv',
+                installerPath: 'uv',
+                uvVersion: sysUv,
+            };
+            this.onLog(`[uv-runtime] using system uv ${sysUv}`);
+            return this.probed;
+        }
+        // ── 3. System Python ≥ minPy ─────────────────────────────────
+        for (const candidate of systemPythonCandidates()) {
+            const version = await this.probeCommandVersion(`${candidate} --version`, /Python\s+(\d+\.\d+(?:\.\d+)?)/i);
+            if (version && versionGte(version, minPy)) {
+                this.probed = {
+                    source: 'system-python',
+                    installerPath: candidate,
+                    pythonVersion: version,
+                };
+                this.onLog(`[uv-runtime] using system Python ${version} (${candidate})`);
+                return this.probed;
+            }
+        }
+        const err = new Error('Python runtime unavailable. Packaged Gezel should include its own managed runtime; reinstall Gezel, or install uv / Python 3.11 when running gezeld from source.');
+        err.isActionable = true;
+        throw err;
+    }
+    resolveBundledUvBin() {
+        return this.readBundledUvFromEnv
+            ? (process.env.GEZEL_UV_BIN ?? null)
+            : this.bundledUvBinOverride;
+    }
+    async createVenv(probe, venvRoot, preferredPy) {
+        await rm(venvRoot, { recursive: true, force: true });
+        if (probe.source === 'system-python') {
+            await this.run(probe.installerPath, ['-m', 'venv', venvRoot]);
+            return;
+        }
+        // uv path (system or bundled) — uv picks/downloads Python itself.
+        await this.run(probe.installerPath, ['venv', '--python', preferredPy, venvRoot]);
+    }
+    async installPackages(probe, venvRoot, packages, indexConfig = {}) {
+        const pythonPath = venvPythonPath(venvRoot);
+        const indexArgs = indexInstallArgs(indexConfig);
+        if (probe.source === 'system-python') {
+            // Use the venv's own pip, pinned against its python.
+            await this.run(pythonPath, [
+                '-m',
+                'pip',
+                'install',
+                '--disable-pip-version-check',
+                ...indexArgs,
+                ...packages,
+            ]);
+            return;
+        }
+        await this.run(probe.installerPath, [
+            'pip',
+            'install',
+            '--python',
+            pythonPath,
+            ...indexArgs,
+            ...packages,
+        ]);
+    }
+    async readPythonVersion(pythonPath) {
+        const out = await this.exec(`"${pythonPath}" --version`, windowsHeadlessSpawnOptions()).catch(() => ({
+            stdout: '',
+            stderr: '',
+        }));
+        const m = `${out.stdout}\n${out.stderr}`.match(/Python\s+(\d+\.\d+(?:\.\d+)?)/i);
+        return m?.[1] ?? '';
+    }
+    async probeCommandVersion(cmd, pattern) {
+        try {
+            const { stdout, stderr } = await this.exec(cmd, {
+                timeout: 5_000,
+                ...windowsHeadlessSpawnOptions(),
+            });
+            const m = `${stdout}\n${stderr}`.match(pattern);
+            return m?.[1];
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Run a command inheriting env + piping output through onLog.
+     * Rejects on non-zero exit. Uses the injected `spawn` so tests can
+     * drive the lifecycle without real subprocesses.
+     */
+    run(command, args) {
+        return new Promise((resolve, reject) => {
+            const child = this.spawn(command, args, {
+                env: process.env,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                ...windowsHeadlessSpawnOptions(),
+            });
+            // Keep a ring buffer of the most recent meaningful (non-noise)
+            // lines so a non-zero exit can surface WHY it failed (e.g.
+            // "ERROR: Could not find a version that satisfies torch==2.5.1")
+            // instead of a bare "exited with code 1" that gives the user
+            // nothing actionable.
+            const recent = [];
+            const remember = (line) => {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    return;
+                recent.push(trimmed);
+                if (recent.length > 12)
+                    recent.shift();
+            };
+            const emit = (line) => {
+                if (!line)
+                    return;
+                remember(line);
+                if (isPipNoiseLine(line))
+                    return;
+                this.onLog(`[uv-runtime] ${line}`);
+            };
+            child.stdout?.on('data', (buf) => {
+                for (const line of buf.toString().split('\n'))
+                    emit(line);
+            });
+            child.stderr?.on('data', (buf) => {
+                for (const line of buf.toString().split('\n'))
+                    emit(line);
+            });
+            child.on('error', (err) => reject(err));
+            child.on('exit', (code) => {
+                if (code === 0) {
+                    resolve();
+                    return;
+                }
+                // Prefer the actual error lines (pip prints `ERROR:` / `error:`)
+                // over the whole tail, falling back to the last few lines.
+                const errLines = recent.filter((l) => /^(error|ERROR|×|error:)/.test(l));
+                const detail = (errLines.length > 0 ? errLines : recent.slice(-4)).join(' | ');
+                reject(new Error(`${command} ${args.join(' ')} exited with code ${code}${detail ? `: ${detail}` : ''}`));
+            });
+        });
+    }
+}
+/**
+ * Pip emits one line per transitive dep when it's already installed
+ * ("Requirement already satisfied: …") and one per wheel pulled from
+ * the local cache ("Using cached …"). Both are noise on a healthy
+ * install — failures surface through "ERROR:", "Could not find", and
+ * stderr tracebacks, none of which match these prefixes.
+ */
+function isPipNoiseLine(line) {
+    const trimmed = line.trimStart();
+    if (trimmed.startsWith('Requirement already satisfied:'))
+        return true;
+    if (trimmed.startsWith('Using cached '))
+        return true;
+    return false;
+}
+/**
+ * Build the `--index-url` / `--extra-index-url` flags shared by both
+ * the pip and uv install branches (both accept the same flag names).
+ */
+function indexInstallArgs(cfg) {
+    const args = [];
+    if (cfg.indexUrl)
+        args.push('--index-url', cfg.indexUrl);
+    for (const url of cfg.extraIndexUrls ?? [])
+        args.push('--extra-index-url', url);
+    return args;
+}
+/** Manifest fast-path: the recorded index config must match the request. */
+function indexConfigEqual(a, b) {
+    if ((a.indexUrl ?? '') !== (b.indexUrl ?? ''))
+        return false;
+    const ax = a.extraIndexUrls ?? [];
+    const bx = b.extraIndexUrls ?? [];
+    if (ax.length !== bx.length)
+        return false;
+    return ax.every((v, i) => v === bx[i]);
+}
+async function readManifest(path) {
+    let raw;
+    try {
+        raw = await readFile(path, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (parsed.version !== 1 ||
+        typeof parsed.name !== 'string' ||
+        typeof parsed.source !== 'string' ||
+        typeof parsed.pythonVersion !== 'string' ||
+        !Array.isArray(parsed.packages)) {
+        return null;
+    }
+    return parsed;
+}
+function toHandle(manifest, venvRoot) {
+    return {
+        name: manifest.name,
+        venvRoot,
+        pythonPath: venvPythonPath(venvRoot),
+        source: manifest.source,
+        pythonVersion: manifest.pythonVersion,
+        ...(manifest.uvVersion ? { uvVersion: manifest.uvVersion } : {}),
+        packages: manifest.packages,
+        installedAt: manifest.installedAt,
+        binPath: (scriptName) => venvBinPath(venvRoot, scriptName),
+    };
+}
+function venvPythonPath(venvRoot) {
+    return process.platform === 'win32'
+        ? join(venvRoot, 'Scripts', 'python.exe')
+        : join(venvRoot, 'bin', 'python');
+}
+function venvBinPath(venvRoot, scriptName) {
+    if (process.platform === 'win32') {
+        const name = scriptName.endsWith('.exe') ? scriptName : `${scriptName}.exe`;
+        return join(venvRoot, 'Scripts', name);
+    }
+    return join(venvRoot, 'bin', scriptName);
+}
+function systemPythonCandidates() {
+    if (process.platform === 'win32') {
+        return ['python', 'py -3'];
+    }
+    return ['python3', 'python'];
+}
+function packageListsEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    const sortedA = [...a].sort();
+    const sortedB = [...b].sort();
+    return sortedA.every((v, i) => v === sortedB[i]);
+}
+function isSafeVenvName(name) {
+    return /^[a-z0-9][a-z0-9._-]{0,63}$/i.test(name);
+}
+export function versionGte(actual, minimum) {
+    const a = actual.split('.').map((n) => Number.parseInt(n, 10) || 0);
+    const m = minimum.split('.').map((n) => Number.parseInt(n, 10) || 0);
+    for (let i = 0; i < Math.max(a.length, m.length); i++) {
+        const av = a[i] ?? 0;
+        const mv = m[i] ?? 0;
+        if (av > mv)
+            return true;
+        if (av < mv)
+            return false;
+    }
+    return true;
+}

package/dist/relevance/install.d.ts

@@ -0,0 +1,28 @@
+import type { RelevanceModelSpec } from '@bendyline/gezel';
+/**
+ * `GEZEL_RELEVANCE_MODELS_DIR` points every daemon at one shared folder —
+ * how evals, whose homes are fresh per trial, keep one verified copy instead
+ * of downloading the model on every run (the `GEZEL_HF_CACHE_DIR` pattern).
+ */
+export declare function relevanceModelsRoot(home: string): string;
+export declare function relevanceModelDir(home: string, id: string): string;
+export declare function installedRelevanceModel(home: string, spec: RelevanceModelSpec): Promise<boolean>;
+export type RelevanceInstallEvent = {
+    type: 'progress';
+    bytesDone: number;
+    bytesTotal: number;
+} | {
+    type: 'done';
+} | {
+    type: 'error';
+    error: string;
+};
+/**
+ * Download and verify a model. One install per id at a time: a second caller
+ * waits on the first and then sees the finished install. Downloads are the
+ * caller's to gate on the security policy's `allowAppNetwork`.
+ */
+export declare function installRelevanceModel(home: string, spec: RelevanceModelSpec, opts?: {
+    fetchImpl?: typeof fetch;
+}): AsyncGenerator<RelevanceInstallEvent>;
+export declare function removeRelevanceModel(home: string, id: string): Promise<void>;

package/dist/relevance/install.js

@@ -0,0 +1,114 @@
+import { mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { safeJoin } from '../fs/safe-paths.js';
+import { resolveModelDirectory } from '../models/model-id.js';
+import { downloadWithSha256 } from '../providers/audio/whisper-cpp.js';
+/**
+ * Relevance models live under `<home>/engines/relevance-models/<id>/`, laid
+ * out like their Hugging Face repo (config.json, tokenizer.json, onnx/…), so
+ * transformers.js loads them from the absolute folder with no network at
+ * search time. Every file is sha256-verified as it lands (`.partial`, then
+ * rename), and `installed.json` is written last — its presence, plus every
+ * file at its pinned size, is what "installed" means.
+ */
+const INSTALLED_MARKER = 'installed.json';
+/**
+ * `GEZEL_RELEVANCE_MODELS_DIR` points every daemon at one shared folder —
+ * how evals, whose homes are fresh per trial, keep one verified copy instead
+ * of downloading the model on every run (the `GEZEL_HF_CACHE_DIR` pattern).
+ */
+export function relevanceModelsRoot(home) {
+    const shared = process.env.GEZEL_RELEVANCE_MODELS_DIR?.trim();
+    return shared || join(home, 'engines', 'relevance-models');
+}
+export function relevanceModelDir(home, id) {
+    return resolveModelDirectory(relevanceModelsRoot(home), id);
+}
+export async function installedRelevanceModel(home, spec) {
+    const dir = relevanceModelDir(home, spec.id);
+    try {
+        const marker = JSON.parse(await readFile(join(dir, INSTALLED_MARKER), 'utf8'));
+        if (marker.id !== spec.id || marker.revision !== spec.source.revision)
+            return false;
+        for (const file of spec.files) {
+            const target = safeJoin(dir, file.path);
+            if (!target)
+                return false;
+            if ((await stat(target)).size !== file.bytes)
+                return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const inflight = new Map();
+/**
+ * Download and verify a model. One install per id at a time: a second caller
+ * waits on the first and then sees the finished install. Downloads are the
+ * caller's to gate on the security policy's `allowAppNetwork`.
+ */
+export async function* installRelevanceModel(home, spec, opts = {}) {
+    if (await installedRelevanceModel(home, spec)) {
+        yield { type: 'done' };
+        return;
+    }
+    const running = inflight.get(spec.id);
+    if (running) {
+        await running.catch(() => { });
+        yield (await installedRelevanceModel(home, spec))
+            ? { type: 'done' }
+            : { type: 'error', error: 'the concurrent install did not finish' };
+        return;
+    }
+    let finish = () => { };
+    inflight.set(spec.id, new Promise((resolve) => {
+        finish = resolve;
+    }));
+    try {
+        const dir = relevanceModelDir(home, spec.id);
+        await rm(join(dir, INSTALLED_MARKER), { force: true });
+        const total = spec.files.reduce((sum, file) => sum + file.bytes, 0);
+        let written = 0;
+        for (const file of spec.files) {
+            const dest = safeJoin(dir, file.path);
+            if (!dest) {
+                yield { type: 'error', error: `unsafe file path ${file.path}` };
+                return;
+            }
+            await mkdir(dirname(dest), { recursive: true });
+            const download = downloadWithSha256(opts.fetchImpl ?? fetch, {
+                url: `https://huggingface.co/${spec.source.repo}/resolve/${spec.source.revision}/${file.path}`,
+                destPath: dest,
+                expectedSha256: file.sha256,
+                approxSizeBytes: file.bytes,
+                writtenSoFar: written,
+                totalAllBytes: total,
+            });
+            for (;;) {
+                const next = await download.next();
+                if (next.done) {
+                    if (next.value.kind === 'error') {
+                        yield { type: 'error', error: `${file.path}: ${next.value.error}` };
+                        return;
+                    }
+                    written = next.value.writtenAll;
+                    break;
+                }
+                if (next.value.type === 'progress') {
+                    yield { type: 'progress', bytesDone: next.value.bytesWritten, bytesTotal: total };
+                }
+            }
+        }
+        await writeFile(join(dir, INSTALLED_MARKER), `${JSON.stringify({ id: spec.id, revision: spec.source.revision, installedAt: new Date().toISOString() }, null, 2)}\n`);
+        yield { type: 'done' };
+    }
+    finally {
+        inflight.delete(spec.id);
+        finish();
+    }
+}
+export async function removeRelevanceModel(home, id) {
+    await rm(relevanceModelDir(home, id), { recursive: true, force: true });
+}