dsh-plugin-local-infer 0.1.1 → 0.1.3

package/packages/providers/lib/adapters.js

@@ -1,58 +1,13 @@
 /**
- * The concrete engine adapters: NInfer (docker and local) and Hyper-Qwen
- * (compose). Each composes the provider `ParameterSpec` data into a
- * `LaunchPlan` and drives its deploy, health-check, and stop steps through an
- * injectable `LifecycleHost`, so the tests stub the host and never run a real
- * build, docker, or network in CI. The node implementation
- * (`nodeLifecycleHost`) is what the service wires in on a live host.
+ * The shared engine-adapter helpers: the spec-to-argv and spec-to-env
+ * translators the concrete adapters (the `engines/*Adapter.ts` files) compose
+ * into a `LaunchPlan`, the card's Custom Arguments translators, the
+ * `LifecycleHost` the deploy, health-check, and stop steps drive, and the
+ * health poll. The node implementation (`nodeLifecycleHost`) is what the
+ * service wires in on a live host.
  * @module dsh-plugin-local-infer/providers/adapters
  */
 import { exec, spawn as nodeSpawn } from 'node:child_process';
-import { basename, dirname, join } from 'node:path';
-import { EngineAdapter } from '../../core/lib/index.js';
-import { NINFER_PARAMETERS } from "./ninfer.js";
-import { HYPERQWEN_PARAMETERS } from "./hyperqwen.js";
-import { LLAMACPP_MODEL_ARTIFACTS, LLAMACPP_PARAMETERS, llamaCppModelKey, } from "./llamacpp.js";
-import { STRATA_PARAMETERS } from "./strata.js";
-/**
- * The NInfer model artifacts, keyed by the model registry id. The 27B entry
- * is the default the DEFAULT_MODELS list names; the 35B-A3B entries are the
- * Qwen3.8 measured artifact (`qwen3-35b`) and the Qwen3.6 default
- * (`qwen36-35b`).
- */
-export const NINFER_MODEL_ARTIFACTS = {
-    'qwen3-27b': {
-        file: 'qwen3_8_27b_nvfp4.ninfer',
-        repo: 'neroued/Qwen3.8-27B-nvfp4-NInfer',
-        modelId: 'Qwen3.8-27B',
-    },
-    // The Swift 1.5 ablated 27B the local launcher bootstraps: the nvfp4-full
-    // DFlash2 artifact the qwen-ninfer script serves. It reuses the 27B model id
-    // the engine advertises, so a chat turn routes to the same alias.
-    'qwen3-27b-swift15': {
-        file: 'qwen3_8_27b_swift15abl_nvfp4full-dflash2.ninfer',
-        repo: 'kaushikvira/Qwen3.8-27B-swift15-uncensored-ajgazin-nvfp4full-dflash2-NInfer-v3',
-        modelId: 'Qwen3.8-27B',
-    },
-    'qwen3-35b': {
-        file: 'qwen3_8_35b_a3b.ninfer',
-        repo: 'Neroued/Qwen3.8-35B-A3B-NInfer',
-        modelId: 'Qwen3.8-35B-A3B',
-    },
-    'qwen36-35b': {
-        file: 'qwen3_6_35b_a3b.ninfer',
-        repo: 'neroued/Qwen3.6-35B-A3B-NInfer',
-        modelId: 'Qwen3.6-35B-A3B',
-    },
-};
-/**
- * artifactFor resolves the artifact a model id deploys. An id no entry names
- * falls back to the 27B artifact, so a bare config always renders a plan.
- */
-function artifactFor(modelId) {
-    const artifact = modelId !== undefined ? NINFER_MODEL_ARTIFACTS[modelId] : undefined;
-    return artifact ?? NINFER_MODEL_ARTIFACTS['qwen3-27b'];
-}
 /**
  * flagsFromSpecs turns a spec surface and a config into the CLI flag list: each
  * spec's `toArgv` runs over the config value (falling back to the spec
@@ -169,6 +124,35 @@ export function createNodeLifecycleHost(debug) {
                 });
             });
         },
+        async runStream(command, onOutput) {
+            log?.(`run: ${command}`);
+            return new Promise(resolve => {
+                // No overall timeout: a full CUDA build legitimately runs long, and
+                // the card prices a stalled step with its own output-idle watchdog.
+                const child = nodeSpawn(command, { shell: true, stdio: ['ignore', 'pipe', 'pipe'] });
+                let output = '';
+                const append = (chunk) => {
+                    const text = chunk.toString('utf8');
+                    onOutput(text);
+                    output += text;
+                    if (output.length > 2048) {
+                        output = output.slice(-1024);
+                    }
+                };
+                child.stdout.on('data', append);
+                child.stderr.on('data', append);
+                child.on('error', error => {
+                    resolve({ ok: false, detail: error.message });
+                });
+                child.on('close', code => {
+                    if (code === 0) {
+                        resolve({ ok: true });
+                        return;
+                    }
+                    resolve({ ok: false, detail: `exit ${code}: ${output.trim().slice(-1024)}` });
+                });
+            });
+        },
         spawn(argv, env, cwd) {
             log?.(`spawn: ${argv.join(' ')}${cwd !== undefined ? ` (cwd: ${cwd})` : ''}`);
             const child = nodeSpawn(argv[0] ?? '', argv.slice(1), {
@@ -190,6 +174,51 @@ export function createNodeLifecycleHost(debug) {
             };
             child.stdout?.on('data', append);
             child.stderr?.on('data', append);
+            // An EventEmitter with no 'error' listener turns the event into a thrown
+            // uncaughtException, which takes the DSH host down with it. A spawn that
+            // cannot start (a missing engine binary, an ENOENT) and a stream that
+            // breaks on a crashing child both emit 'error' here, so every path gets
+            // a listener and the failure lands in the logs instead of the crash.
+            child.stdout?.on('error', (error) => {
+                logs = (logs + `stdout error: ${error.message}\n`).slice(-65536);
+            });
+            child.stderr?.on('error', (error) => {
+                logs = (logs + `stderr error: ${error.message}\n`).slice(-65536);
+            });
+            // The one-shot exit contract: 'error' names a child that never ran,
+            // 'exit' carries the code or signal, and 'close' follows once the pipes
+            // drain. The first settled source wins, so the handle's onExit listener
+            // (crash, pkill, or clean stop) fires exactly once with the detail.
+            const listeners = new Set();
+            let exitInfo = null;
+            const settle = (info) => {
+                if (exitInfo !== null)
+                    return;
+                exitInfo = info;
+                for (const listener of listeners) {
+                    try {
+                        listener(info);
+                    }
+                    catch {
+                        // A listener that throws must not re-raise into the child's event
+                        // pipeline and take the host down the way an unlistened 'error' did.
+                    }
+                }
+                listeners.clear();
+            };
+            let exitSignal = null;
+            child.on('error', (error) => {
+                logs = (logs + `spawn error: ${error.message}\n`).slice(-65536);
+                // The error fires before the stdio drains; settle immediately so a
+                // launch of a missing binary reports rather than hangs the watcher.
+                settle({ code: null, signal: null, error: error.message });
+            });
+            child.on('exit', (_code, signal) => {
+                exitSignal = signal;
+            });
+            child.on('close', (code, signal) => {
+                settle({ code, signal: signal ?? exitSignal });
+            });
             return {
                 pid: child.pid ?? -1,
                 kill: () => {
@@ -198,6 +227,16 @@ export function createNodeLifecycleHost(debug) {
                 get logs() {
                     return logs;
                 },
+                onExit: (listener) => {
+                    // A listener registered after the child already ended fires
+                    // immediately, so a late attach (the service wiring after deploy)
+                    // never misses the crash that landed in between.
+                    if (exitInfo !== null) {
+                        listener(exitInfo);
+                        return;
+                    }
+                    listeners.add(listener);
+                },
             };
         },
         async fetch(url) {
@@ -219,6 +258,24 @@ export function createNodeLifecycleHost(debug) {
  * in debug mode.
  */
 export const nodeLifecycleHost = createNodeLifecycleHost();
+/**
+ * trackChild stores a spawned handle in the adapter's children map and ties
+ * the entry's lifetime to the child's: when the child ends (a crash, a pkill,
+ * or the adapter's own stop kill) the entry is dropped, so a later stop never
+ * signals a pid a recycled process has taken over. A handle whose host cannot
+ * watch (onExit absent) stays tracked until stop removes it.
+ */
+export function trackChild(children, key, handle) {
+    children.set(key, handle);
+    handle.onExit?.(() => {
+        // Compare identity before deleting: a newer launch that already replaced
+        // this key's entry keeps its handle, and only the ended child's entry
+        // goes.
+        if (children.get(key) === handle) {
+            children.delete(key);
+        }
+    });
+}
 /**
  * pollHealth polls a plan's health URL until a 200 or the attempt cap, the
  * same loop the qwen-ninfer launcher runs. A poll interval of 0 skips the
@@ -243,616 +300,14 @@ export async function pollHealth(host, plan, options) {
         detail: `health check did not return 200 within ${maxAttempts} attempts`,
     };
 }
-function delay(ms) {
+/**
+ * delay waits `ms` milliseconds. The health polls use it between attempts; a
+ * poll interval of 0 skips the wait, which the tests use to run the loop
+ * without a real sleep.
+ */
+export function delay(ms) {
     return new Promise(resolve => {
         setTimeout(resolve, ms);
     });
 }
-/**
- * The NInfer docker image the adapter pulls and runs. The engineFork platform
- * config overrides the git source for a local build; the image stays the
- * upstream ghcr artifact.
- */
-export const NINFER_DOCKER_IMAGE = 'ghcr.io/iamwavecut/ninfer-all';
-/**
- * NInferAdapter is the canonical both-capable engine. `renderLaunch` renders a
- * local `ninfer-serve` process or a `docker run` of the ghcr image from the
- * same spec surface; `deploy` builds the engine in the engine directory (or
- * pulls the image), downloads the model into the model directory, and starts
- * the engine; `healthCheck` polls the health URL; `stop` signals the tracked
- * process and stops the named container.
- */
-export class NInferAdapter extends EngineAdapter {
-    id = 'ninfer';
-    supports = { docker: true, local: true };
-    host;
-    children = new Map();
-    constructor(host = nodeLifecycleHost) {
-        super();
-        this.host = host;
-    }
-    parameters() {
-        return NINFER_PARAMETERS;
-    }
-    modelRef(config) {
-        // The id the engine advertises on its OpenAI endpoint is the artifact's
-        // --model-id alias, not the VramModel registry key the config names, so
-        // the registrar publishes the alias and a chat turn routes to it.
-        const artifact = artifactFor(typeof config.model === 'string' ? config.model : 'qwen3-27b');
-        return { id: artifact.modelId, name: artifact.modelId };
-    }
-    launchSignature(config = {}) {
-        // The local plan runs the ninfer-serve binary; the docker plan's host
-        // process is docker run of the ghcr image, so the image name is the
-        // command-line marker the reserve probe matches on.
-        const port = this.port(config);
-        if (this.buildMode(config) === 'docker') {
-            return { binary: NINFER_DOCKER_IMAGE, port };
-        }
-        return { binary: 'ninfer-serve', port };
-    }
-    renderLaunch(config, _hw) {
-        const port = this.port(config);
-        const modelId = typeof config.model === 'string' ? config.model : 'qwen3-27b';
-        const artifact = artifactFor(modelId);
-        // A model key that names a local artifact file (a directory-scanned
-        // model) overrides the artifact map's file, so a file the user has on
-        // disk launches as-is.
-        const file = modelId.endsWith('.ninfer') ? modelId : artifact.file;
-        const modelDirectory = typeof config.modelDirectory === 'string' ? config.modelDirectory : '';
-        const flags = flagsFromSpecs(NINFER_PARAMETERS, config);
-        if (this.buildMode(config) === 'docker') {
-            const modelPath = modelDirectory === '' ? file : join(modelDirectory, file);
-            const containerModelPath = `/models/${basename(file)}`;
-            const modelMount = modelDirectory === ''
-                ? `${file}:${containerModelPath}`
-                : `${dirname(modelPath)}:/models`;
-            const containerName = `ninfer-${port}`;
-            const customArgs = customArgFlags(config);
-            return {
-                engineId: this.id,
-                kind: 'docker',
-                argv: [
-                    'docker',
-                    'run',
-                    '--rm',
-                    '--gpus',
-                    'all',
-                    '--name',
-                    containerName,
-                    '-p',
-                    `127.0.0.1:${port}:8080`,
-                    '--ulimit',
-                    'memlock=-1',
-                    '-v',
-                    'ninfer-cache:/cache',
-                    '-v',
-                    modelMount,
-                    NINFER_DOCKER_IMAGE,
-                    'serve',
-                    containerModelPath,
-                    '--model-id',
-                    artifact.modelId,
-                    ...flags,
-                    ...customArgs,
-                ],
-                env: {},
-                containerName,
-                modelId,
-                ...(modelDirectory === '' ? {} : { modelDirectory }),
-                port,
-                healthUrl: `http://127.0.0.1:${port}/health`,
-            };
-        }
-        const modelPath = modelDirectory === '' ? file : join(modelDirectory, file);
-        const customArgs = customArgFlags(config);
-        return {
-            engineId: this.id,
-            kind: 'process',
-            argv: [
-                'ninfer-serve',
-                modelPath,
-                '--host',
-                '127.0.0.1',
-                '--port',
-                String(port),
-                '--model-id',
-                artifact.modelId,
-                ...flags,
-                ...customArgs,
-            ],
-            env: {},
-            modelId,
-            ...(modelDirectory === '' ? {} : { modelDirectory }),
-            port,
-            healthUrl: `http://127.0.0.1:${port}/health`,
-        };
-    }
-    async deploy(plan, platform) {
-        if (plan.kind === 'process') {
-            const engineDir = platform?.engineDirectory;
-            if (engineDir !== undefined) {
-                const fork = platform?.engineFork;
-                if (fork !== undefined) {
-                    // Mirror the qwen-ninfer launcher: an existing checkout (a .git under
-                    // the engine directory) is updated in place with a best-effort fetch
-                    // and a hard reset to the fork's master, then built as-is; a missing
-                    // checkout is a fresh clone. The fetch is best-effort (a `; true`
-                    // pins the branch to success) so an offline host still builds the
-                    // checkout it has; only a missing checkout that cannot be cloned
-                    // fails the step.
-                    const sync = await this.host.run(`if [ -d ${engineDir}/.git ]; then ` +
-                        `git -C ${engineDir} fetch ${fork} 2>/dev/null && git -C ${engineDir} reset --hard ${fork}/master 2>/dev/null; true; ` +
-                        `else git clone ${fork} ${engineDir}; fi`);
-                    if (!sync.ok) {
-                        return { ok: false, detail: `git sync failed: ${sync.detail ?? 'unknown'}` };
-                    }
-                }
-                const build = await this.host.run(`cmake -S ${engineDir} -B ${engineDir}/build -G Ninja -DCMAKE_BUILD_TYPE=Release && ` +
-                    `cmake --build ${engineDir}/build -j`);
-                if (!build.ok) {
-                    return { ok: false, detail: `build failed: ${build.detail ?? 'unknown'}` };
-                }
-            }
-            const download = await this.downloadModel(plan);
-            if (!download.ok)
-                return download;
-            // A chat template the user picked as an HF repo reference (the combo
-            // control's known choices) is not a path the engine can read, so the
-            // deploy step downloads it into the model directory and rewrites the
-            // --chat-template flag to the local file before the spawn.
-            const templateResult = await this.resolveChatTemplate(plan);
-            if (!templateResult.ok)
-                return templateResult;
-            const handle = this.host.spawn(plan.argv ?? [], plan.env ?? {}, engineDir);
-            this.children.set(this.planKey(plan), handle);
-            return { ok: true, handle };
-        }
-        if (plan.kind === 'docker') {
-            const pull = await this.host.run(`docker pull ${NINFER_DOCKER_IMAGE}`);
-            if (!pull.ok) {
-                return { ok: false, detail: `docker pull failed: ${pull.detail ?? 'unknown'}` };
-            }
-            const handle = this.host.spawn(plan.argv ?? [], plan.env ?? {});
-            this.children.set(this.planKey(plan), handle);
-            return { ok: true, handle };
-        }
-        // NInfer renders process and docker plans; a compose plan is a no-op.
-        return { ok: true };
-    }
-    async healthCheck(plan, options) {
-        return pollHealth(this.host, plan, options);
-    }
-    async stop(plan) {
-        if (plan.kind === 'docker' && plan.containerName !== undefined) {
-            await this.host.run(`docker stop ${plan.containerName}`);
-        }
-        const handle = this.children.get(this.planKey(plan));
-        if (handle !== undefined) {
-            handle.kill();
-            this.children.delete(this.planKey(plan));
-        }
-    }
-    buildMode(config) {
-        return config.buildMode === 'docker' ? 'docker' : 'local';
-    }
-    port(config) {
-        return typeof config.port === 'number' ? config.port : 18020;
-    }
-    planKey(plan) {
-        return `${plan.engineId}:${plan.port}`;
-    }
-    async downloadModel(plan) {
-        const artifact = plan.modelId !== undefined ? NINFER_MODEL_ARTIFACTS[plan.modelId] : undefined;
-        if (artifact === undefined)
-            return { ok: true };
-        const target = plan.modelDirectory ?? '.';
-        const download = await this.host.run(`hf download ${artifact.repo} ${artifact.file} --local-dir ${target}`);
-        if (!download.ok) {
-            return { ok: false, detail: `model download failed: ${download.detail ?? 'unknown'}` };
-        }
-        return { ok: true };
-    }
-    /**
-     * resolveChatTemplate rewrites a --chat-template flag that carries an HF repo
-     * reference into the local file the engine reads. A value with a slash that
-     * is not an absolute path (the combo control's known choices) is a repo the
-     * deploy step downloads into the model directory; an already-local path is
-     * left as-is. The download is best-effort: a template that is already on
-     * disk is used without a re-fetch, and a missing hf CLI leaves the flag
-     * untouched so the engine reports the missing template itself.
-     */
-    async resolveChatTemplate(plan) {
-        const argv = plan.argv;
-        if (argv === undefined)
-            return { ok: true };
-        const index = argv.indexOf('--chat-template');
-        if (index === -1)
-            return { ok: true };
-        const value = argv[index + 1];
-        if (value === undefined)
-            return { ok: true };
-        // An absolute path (a leading /) is already local; a value with no slash
-        // is a bare file name the engine resolves against its own directory.
-        if (value.startsWith('/') || !value.includes('/'))
-            return { ok: true };
-        // An HF repo reference: download the template file into the model
-        // directory and point the flag at the local copy.
-        const target = plan.modelDirectory ?? '.';
-        const localPath = `${target.endsWith('/') ? '' : `${target}/`}chat_template.jinja`;
-        // A template already on disk skips the re-fetch; the hf CLI is optional,
-        // so a download failure is reported but does not abort the launch.
-        const probe = await this.host.run(`[ -f ${localPath} ]`);
-        if (!probe.ok) {
-            const download = await this.host.run(`hf download ${value} chat_template.jinja --local-dir ${target}`);
-            if (!download.ok) {
-                return {
-                    ok: false,
-                    detail: `chat template download failed: ${download.detail ?? 'unknown'}`,
-                };
-            }
-        }
-        argv[index + 1] = localPath;
-        return { ok: true };
-    }
-}
-/**
- * HyperQwenAdapter is the docker-compose engine. `renderLaunch` renders a
- * compose plan (the compose file, the profile, and the `.env` the spec surface
- * maps to); `deploy` runs `docker compose up`; `healthCheck` polls the health
- * URL; `stop` runs `docker compose down`.
- */
-export class HyperQwenAdapter extends EngineAdapter {
-    id = 'hyperqwen';
-    supports = { docker: true, local: false };
-    host;
-    constructor(host = nodeLifecycleHost) {
-        super();
-        this.host = host;
-    }
-    parameters() {
-        return HYPERQWEN_PARAMETERS;
-    }
-    modelRef(_config) {
-        // vLLM serves the model under the name the compose file passes, and the
-        // plugin tracks no per-model data for Hyper-Qwen yet, so the engine id is
-        // the stable entry the registrar publishes until that data lands.
-        return { id: 'hyperqwen', name: 'Hyper-Qwen' };
-    }
-    launchSignature(config = {}) {
-        // The compose host process is `docker compose ... up`, so the marker is
-        // the command, not an image. The toEnv keys (SPEC, CTX, KV, ...) name the
-        // .env the compose file reads, not the host process env, so they ride
-        // along as the env-key element the matcher checks when a process line
-        // carries env data.
-        const port = this.port(config);
-        const envKeys = Object.keys(envFromSpecs(HYPERQWEN_PARAMETERS, config));
-        return { binary: 'docker compose', port, envKeys };
-    }
-    renderLaunch(config, _hw) {
-        const port = this.port(config);
-        const profile = this.profile(config);
-        // The spec env and the card's Custom Arguments merge into one env map: the
-        // spec keys are the .env the compose file reads, and the custom rows are
-        // the user's own overrides appended after them.
-        const env = { ...envFromSpecs(HYPERQWEN_PARAMETERS, config), ...customArgEnv(config) };
-        const composeFile = typeof config.composeFile === 'string' ? config.composeFile : 'docker-compose.yml';
-        return {
-            engineId: this.id,
-            kind: 'compose',
-            env,
-            composeFile,
-            profile,
-            port,
-            healthUrl: `http://127.0.0.1:${port}/health`,
-        };
-    }
-    async deploy(plan) {
-        const up = await this.host.run(`docker compose -f ${plan.composeFile} --profile ${plan.profile} up --pull always -d`);
-        if (!up.ok) {
-            return { ok: false, detail: `compose up failed: ${up.detail ?? 'unknown'}` };
-        }
-        return { ok: true };
-    }
-    async healthCheck(plan, options) {
-        return pollHealth(this.host, plan, options);
-    }
-    async stop(plan) {
-        await this.host.run(`docker compose -f ${plan.composeFile} --profile ${plan.profile} down`);
-    }
-    port(config) {
-        return typeof config.port === 'number' ? config.port : 18020;
-    }
-    profile(config) {
-        return typeof config.profile === 'string' ? config.profile : 'single';
-    }
-}
-/**
- * The llama.cpp docker image the adapter pulls and runs. The engineFork
- * platform config overrides the git source for a local build; the image stays
- * the upstream ggml artifact.
- */
-export const LLAMACPP_DOCKER_IMAGE = 'ghcr.io/ggml-org/llama.cpp';
-/**
- * llamaCppArtifact resolves the artifact a model key deploys. A key no entry
- * names falls back to the 27B artifact, so a bare config always renders a plan.
- */
-function llamaCppArtifact(modelKey) {
-    const artifact = modelKey !== undefined ? LLAMACPP_MODEL_ARTIFACTS[modelKey] : undefined;
-    return artifact ?? LLAMACPP_MODEL_ARTIFACTS['qwen3-27b'];
-}
-/**
- * LlamaCppAdapter is the llama.cpp engine, both-capable like NInfer.
- * `renderLaunch` renders a local `llama-server` process or a `docker run` of the
- * ggml image from the same `LLAMACPP_PARAMETERS` surface; `deploy` builds the
- * engine in the engine directory (or pulls the image), downloads the GGUF model
- * into the model directory, and starts the engine; `healthCheck` polls the health
- * URL; `stop` signals the tracked process and stops the named container.
- */
-export class LlamaCppAdapter extends EngineAdapter {
-    id = 'llamacpp';
-    supports = { docker: true, local: true };
-    host;
-    children = new Map();
-    constructor(host = nodeLifecycleHost) {
-        super();
-        this.host = host;
-    }
-    parameters() {
-        return LLAMACPP_PARAMETERS;
-    }
-    modelRef(config) {
-        // The engine serves the model under the artifact's advertised id, so the
-        // registrar publishes that alias and a chat turn routes to it.
-        const artifact = llamaCppArtifact(llamaCppModelKey(config));
-        return { id: artifact.modelId, name: artifact.modelId };
-    }
-    launchSignature(config = {}) {
-        // The local plan runs the llama-server binary; the docker plan's host
-        // process is docker run of the ggml image, so the image name is the
-        // command-line marker the reserve probe matches on.
-        const port = this.port(config);
-        if (this.buildMode(config) === 'docker') {
-            return { binary: LLAMACPP_DOCKER_IMAGE, port };
-        }
-        return { binary: 'llama-server', port };
-    }
-    renderLaunch(config, _hw) {
-        const port = this.port(config);
-        const modelId = llamaCppModelKey(config);
-        const artifact = llamaCppArtifact(modelId);
-        // A model key that names a local GGUF file (a directory-scanned model)
-        // overrides the artifact map's file, so a file the user has on disk
-        // launches as-is.
-        const file = modelId.endsWith('.gguf') ? modelId : artifact.file;
-        const modelDirectory = typeof config.modelDirectory === 'string' ? config.modelDirectory : '';
-        const flags = flagsFromSpecs(LLAMACPP_PARAMETERS, config);
-        if (this.buildMode(config) === 'docker') {
-            const modelPath = modelDirectory === '' ? file : join(modelDirectory, file);
-            const containerModelPath = `/models/${basename(file)}`;
-            const modelMount = modelDirectory === ''
-                ? `${file}:${containerModelPath}`
-                : `${dirname(modelPath)}:/models`;
-            const containerName = `llamacpp-${port}`;
-            const customArgs = customArgFlags(config);
-            return {
-                engineId: this.id,
-                kind: 'docker',
-                argv: [
-                    'docker',
-                    'run',
-                    '--rm',
-                    '--gpus',
-                    'all',
-                    '--name',
-                    containerName,
-                    '-p',
-                    `127.0.0.1:${port}:8080`,
-                    '-v',
-                    modelMount,
-                    LLAMACPP_DOCKER_IMAGE,
-                    '--model',
-                    containerModelPath,
-                    ...flags,
-                    ...customArgs,
-                ],
-                env: {},
-                containerName,
-                modelId,
-                ...(modelDirectory === '' ? {} : { modelDirectory }),
-                port,
-                healthUrl: `http://127.0.0.1:${port}/health`,
-            };
-        }
-        const modelPath = modelDirectory === '' ? file : join(modelDirectory, file);
-        const customArgs = customArgFlags(config);
-        return {
-            engineId: this.id,
-            kind: 'process',
-            argv: [
-                'llama-server',
-                '--model',
-                modelPath,
-                '--host',
-                '127.0.0.1',
-                '--port',
-                String(port),
-                ...flags,
-                ...customArgs,
-            ],
-            env: {},
-            modelId,
-            ...(modelDirectory === '' ? {} : { modelDirectory }),
-            port,
-            healthUrl: `http://127.0.0.1:${port}/health`,
-        };
-    }
-    async deploy(plan, platform) {
-        if (plan.kind === 'process') {
-            const engineDir = platform?.engineDirectory;
-            if (engineDir !== undefined) {
-                const fork = platform?.engineFork;
-                if (fork !== undefined) {
-                    // Mirror the qwen-ninfer launcher: an existing checkout is updated in
-                    // place with a best-effort fetch and a hard reset to the fork's
-                    // master, then built as-is; a missing checkout is a fresh clone. The
-                    // fetch is best-effort (a `; true` pins the branch to success) so an
-                    // offline host still builds the checkout it has.
-                    const sync = await this.host.run(`if [ -d ${engineDir}/.git ]; then ` +
-                        `git -C ${engineDir} fetch ${fork} 2>/dev/null && git -C ${engineDir} reset --hard ${fork}/master 2>/dev/null; true; ` +
-                        `else git clone ${fork} ${engineDir}; fi`);
-                    if (!sync.ok) {
-                        return { ok: false, detail: `git sync failed: ${sync.detail ?? 'unknown'}` };
-                    }
-                }
-                const build = await this.host.run(`cmake -S ${engineDir} -B ${engineDir}/build -G Ninja -DCMAKE_BUILD_TYPE=Release && ` +
-                    `cmake --build ${engineDir}/build -j`);
-                if (!build.ok) {
-                    return { ok: false, detail: `build failed: ${build.detail ?? 'unknown'}` };
-                }
-            }
-            const download = await this.downloadModel(plan);
-            if (!download.ok)
-                return download;
-            const handle = this.host.spawn(plan.argv ?? [], plan.env ?? {}, engineDir);
-            this.children.set(this.planKey(plan), handle);
-            return { ok: true };
-        }
-        if (plan.kind === 'docker') {
-            const pull = await this.host.run(`docker pull ${LLAMACPP_DOCKER_IMAGE}`);
-            if (!pull.ok) {
-                return { ok: false, detail: `docker pull failed: ${pull.detail ?? 'unknown'}` };
-            }
-            const handle = this.host.spawn(plan.argv ?? [], plan.env ?? {});
-            this.children.set(this.planKey(plan), handle);
-            return { ok: true };
-        }
-        // llama.cpp renders process and docker plans; a compose plan is a no-op.
-        return { ok: true };
-    }
-    async healthCheck(plan, options) {
-        return pollHealth(this.host, plan, options);
-    }
-    async stop(plan) {
-        if (plan.kind === 'docker' && plan.containerName !== undefined) {
-            await this.host.run(`docker stop ${plan.containerName}`);
-        }
-        const handle = this.children.get(this.planKey(plan));
-        if (handle !== undefined) {
-            handle.kill();
-            this.children.delete(this.planKey(plan));
-        }
-    }
-    buildMode(config) {
-        return config.buildMode === 'docker' ? 'docker' : 'local';
-    }
-    port(config) {
-        return typeof config.port === 'number' ? config.port : 8080;
-    }
-    planKey(plan) {
-        return `${plan.engineId}:${plan.port}`;
-    }
-    async downloadModel(plan) {
-        const artifact = plan.modelId !== undefined ? LLAMACPP_MODEL_ARTIFACTS[plan.modelId] : undefined;
-        if (artifact === undefined)
-            return { ok: true };
-        const target = plan.modelDirectory ?? '.';
-        const download = await this.host.run(`hf download ${artifact.repo} ${artifact.file} --local-dir ${target}`);
-        if (!download.ok) {
-            return { ok: false, detail: `model download failed: ${download.detail ?? 'unknown'}` };
-        }
-        return { ok: true };
-    }
-}
-/**
- * The Strata docker image the adapter pulls and runs. Strata is the
- * placeholder engine: the image and the parameter data land when the engine
- * is available, and the adapter renders a bare docker plan until then.
- */
-export const STRATA_DOCKER_IMAGE = 'ghcr.io/strata/strata';
-/**
- * StrataAdapter is the placeholder docker-only engine. `renderLaunch` renders
- * a `docker run` of the Strata image (no spec surface yet, so no flags);
- * `deploy` pulls the image and starts the container; `healthCheck` polls the
- * health URL; `stop` stops the named container. The parameter surface and the
- * per-model data land with the engine, as data edits, never an adapter rewire.
- */
-export class StrataAdapter extends EngineAdapter {
-    id = 'strata';
-    supports = { docker: true, local: false };
-    host;
-    children = new Map();
-    constructor(host = nodeLifecycleHost) {
-        super();
-        this.host = host;
-    }
-    parameters() {
-        return STRATA_PARAMETERS;
-    }
-    modelRef(_config) {
-        // Strata serves the model under the name the container passes, and the
-        // plugin tracks no per-model data for Strata yet, so the engine id is the
-        // stable entry the registrar publishes until that data lands.
-        return { id: 'strata', name: 'Strata' };
-    }
-    launchSignature(config = {}) {
-        // Strata is docker-only, so the signature is the image name the docker
-        // run carries plus the port the plan binds.
-        return { binary: STRATA_DOCKER_IMAGE, port: this.port(config) };
-    }
-    renderLaunch(config, _hw) {
-        const port = this.port(config);
-        const containerName = `strata-${port}`;
-        const customArgs = customArgFlags(config);
-        return {
-            engineId: this.id,
-            kind: 'docker',
-            argv: [
-                'docker',
-                'run',
-                '--rm',
-                '--gpus',
-                'all',
-                '--name',
-                containerName,
-                '-p',
-                `127.0.0.1:${port}:8080`,
-                STRATA_DOCKER_IMAGE,
-                ...customArgs,
-            ],
-            env: {},
-            containerName,
-            port,
-            healthUrl: `http://127.0.0.1:${port}/health`,
-        };
-    }
-    async deploy(plan) {
-        const pull = await this.host.run(`docker pull ${STRATA_DOCKER_IMAGE}`);
-        if (!pull.ok) {
-            return { ok: false, detail: `docker pull failed: ${pull.detail ?? 'unknown'}` };
-        }
-        const handle = this.host.spawn(plan.argv ?? [], plan.env ?? {});
-        this.children.set(this.planKey(plan), handle);
-        return { ok: true };
-    }
-    async healthCheck(plan, options) {
-        return pollHealth(this.host, plan, options);
-    }
-    async stop(plan) {
-        if (plan.containerName !== undefined) {
-            await this.host.run(`docker stop ${plan.containerName}`);
-        }
-        const handle = this.children.get(this.planKey(plan));
-        if (handle !== undefined) {
-            handle.kill();
-            this.children.delete(this.planKey(plan));
-        }
-    }
-    port(config) {
-        return typeof config.port === 'number' ? config.port : 8080;
-    }
-    planKey(plan) {
-        return `${plan.engineId}:${plan.port}`;
-    }
-}
 //# sourceMappingURL=adapters.js.map