dsh-plugin-local-infer 0.1.1 → 0.1.3

package/packages/providers/lib/engines/infernixAdapter.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The Infernix engine adapter. InfernixAdapter is the local-only engine for
+ * Infernix, the C++/CUDA fork of NInfer (https://github.com/wallawalla47/infernix)
+ * tuned for Qwen models on a single RTX 50-series GPU. `renderLaunch` renders a
+ * local `infernix-serve` process from the `INFERNIX_PARAMETERS` surface (the
+ * Infernix-only fields, from `--ngram-volume` to the quality routes, spell
+ * onto the argv only for this engine); `deploy` builds the engine in the
+ * engine directory (the engine's own cmake preset), downloads the model
+ * artifact (and the n-gram volume, for the multi-file Flash-Next repo) into
+ * the model directory, and starts the engine; `healthCheck` polls the health
+ * URL; `stop` signals the tracked process. The engine ships no docker image,
+ * so the adapter supports the local build mode only.
+ * @module dsh-plugin-local-infer/providers/engines/infernixAdapter
+ */
+import { EngineAdapter } from '../../../core/lib/index.js';
+import type { Config, DeployOptions, DeployResult, EngineLaunchSignature, EnginePlatformConfig, HealthCheckOptions, HealthResult, HardwareProfile, LaunchPlan, LaunchProgress, LifecycleHost, ParameterSpec } from '../../../core/lib/index.js';
+/**
+ * InfernixAdapter is the local-only engine for Infernix, the C++/CUDA fork
+ * of NInfer (https://github.com/wallawalla47/infernix) tuned for Qwen models
+ * on a single RTX 50-series GPU. `renderLaunch` renders a local
+ * `infernix-serve` process from the `INFERNIX_PARAMETERS` surface (the
+ * Infernix-only fields, from `--ngram-volume` to the quality routes, spell
+ * onto the argv only for this engine); `deploy` builds the engine in the
+ * engine directory (the engine's own cmake preset), downloads the model
+ * artifact (and the n-gram volume, for the multi-file Flash-Next repo) into
+ * the model directory, and starts the engine; `healthCheck` polls the health
+ * URL; `stop` signals the tracked process. The engine ships no docker image,
+ * so the adapter supports the local build mode only.
+ */
+export declare class InfernixAdapter extends EngineAdapter {
+    readonly id = "infernix";
+    readonly supports: {
+        docker: boolean;
+        local: boolean;
+    };
+    private readonly host;
+    private readonly children;
+    constructor(host?: LifecycleHost);
+    parameters(): readonly ParameterSpec[];
+    modelRef(config: Config): {
+        id: string;
+        name: string;
+    };
+    launchSignature(config?: Config): EngineLaunchSignature;
+    renderLaunch(config: Config, _hw: HardwareProfile): LaunchPlan;
+    deploy(plan: LaunchPlan, platform?: EnginePlatformConfig, onProgress?: LaunchProgress, options?: DeployOptions): Promise<DeployResult>;
+    healthCheck(plan: LaunchPlan, options?: HealthCheckOptions): Promise<HealthResult>;
+    stop(plan: LaunchPlan): Promise<void>;
+    private port;
+    private planKey;
+    private downloadModel;
+}
+//# sourceMappingURL=infernixAdapter.d.ts.map

package/packages/providers/lib/engines/infernixAdapter.js

@@ -0,0 +1,202 @@
+/**
+ * The Infernix engine adapter. InfernixAdapter is the local-only engine for
+ * Infernix, the C++/CUDA fork of NInfer (https://github.com/wallawalla47/infernix)
+ * tuned for Qwen models on a single RTX 50-series GPU. `renderLaunch` renders a
+ * local `infernix-serve` process from the `INFERNIX_PARAMETERS` surface (the
+ * Infernix-only fields, from `--ngram-volume` to the quality routes, spell
+ * onto the argv only for this engine); `deploy` builds the engine in the
+ * engine directory (the engine's own cmake preset), downloads the model
+ * artifact (and the n-gram volume, for the multi-file Flash-Next repo) into
+ * the model directory, and starts the engine; `healthCheck` polls the health
+ * URL; `stop` signals the tracked process. The engine ships no docker image,
+ * so the adapter supports the local build mode only.
+ * @module dsh-plugin-local-infer/providers/engines/infernixAdapter
+ */
+import { join } from 'node:path';
+import { EngineAdapter } from '../../../core/lib/index.js';
+import { customArgFlags, flagsFromSpecs, nodeLifecycleHost, pollHealth, } from "../adapters.js";
+import { syncAndRebuildEngine } from "../acquire.js";
+import { INFERNIX_MODEL_ARTIFACTS, INFERNIX_PARAMETERS, infernixArtifactFor, infernixDraftModelPath, infernixModelKey, } from "./infernix.js";
+/**
+ * InfernixAdapter is the local-only engine for Infernix, the C++/CUDA fork
+ * of NInfer (https://github.com/wallawalla47/infernix) tuned for Qwen models
+ * on a single RTX 50-series GPU. `renderLaunch` renders a local
+ * `infernix-serve` process from the `INFERNIX_PARAMETERS` surface (the
+ * Infernix-only fields, from `--ngram-volume` to the quality routes, spell
+ * onto the argv only for this engine); `deploy` builds the engine in the
+ * engine directory (the engine's own cmake preset), downloads the model
+ * artifact (and the n-gram volume, for the multi-file Flash-Next repo) into
+ * the model directory, and starts the engine; `healthCheck` polls the health
+ * URL; `stop` signals the tracked process. The engine ships no docker image,
+ * so the adapter supports the local build mode only.
+ */
+export class InfernixAdapter extends EngineAdapter {
+    id = 'infernix';
+    supports = { docker: false, local: true };
+    host;
+    children = new Map();
+    constructor(host = nodeLifecycleHost) {
+        super();
+        this.host = host;
+    }
+    parameters() {
+        return INFERNIX_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. A model
+        // key that names a local artifact file (a directory-scanned model)
+        // reuses the 27B alias, the same fallback the NInfer adapter applies.
+        const artifact = infernixArtifactFor(infernixModelKey(config));
+        return { id: artifact.modelId, name: artifact.modelId };
+    }
+    launchSignature(config = {}) {
+        // The local plan runs the infernix-serve binary (the .exe on Windows),
+        // so the binary name is the command-line marker the reserve probe
+        // matches on, and the port the plan binds rides along.
+        return { binary: 'infernix-serve', port: this.port(config) };
+    }
+    renderLaunch(config, _hw) {
+        const port = this.port(config);
+        const modelKey = infernixModelKey(config);
+        const artifact = infernixArtifactFor(modelKey);
+        // A model key that names a local artifact file (a directory-scanned
+        // model, a .ninfer or .infernix name) overrides the artifact map's file,
+        // so a file the user has on disk launches as-is.
+        const file = modelKey.endsWith('.ninfer') || modelKey.endsWith('.infernix')
+            ? modelKey
+            : artifact.file;
+        const modelDirectory = typeof config.modelDirectory === 'string' ? config.modelDirectory : '';
+        const modelPath = modelDirectory === '' ? file : join(modelDirectory, file);
+        // The engine binary is the .exe on a Windows host, where the published
+        // release zip ships the server and its DLLs.
+        const binary = process.platform === 'win32' ? 'infernix-serve.exe' : 'infernix-serve';
+        const flags = flagsFromSpecs(INFERNIX_PARAMETERS, config);
+        // The dflash2 backend always loads a drafter through --draft-model, so the
+        // flag is spelled here from the resolved path (the selected DFlash2 preset,
+        // or the Custom Draft model field) rather than by a spec toArgv. A config
+        // that names no drafter path is the misconfiguration the dflash2
+        // guideline names, so the flag is spelled only when a path resolves.
+        if (config.spec === 'dflash2') {
+            const draftPath = infernixDraftModelPath(config);
+            if (draftPath !== null) {
+                flags.push('--draft-model', draftPath);
+            }
+        }
+        const customArgs = customArgFlags(config);
+        return {
+            engineId: this.id,
+            kind: 'process',
+            argv: [
+                binary,
+                modelPath,
+                '--host',
+                '127.0.0.1',
+                '--port',
+                String(port),
+                '--model-id',
+                artifact.modelId,
+                ...flags,
+                ...customArgs,
+            ],
+            env: {},
+            modelId: modelKey,
+            ...(modelDirectory === '' ? {} : { modelDirectory }),
+            port,
+            healthUrl: `http://127.0.0.1:${port}/health`,
+        };
+    }
+    async deploy(plan, platform, onProgress, options) {
+        if (plan.kind !== 'process') {
+            // Infernix renders process plans only; a docker or compose plan is a
+            // no-op.
+            return { ok: true };
+        }
+        const engineDir = platform?.engineDirectory;
+        let buildLogs = '';
+        // Auto Rebuild off (the card's checkbox): the git sync (fetch, rebase,
+        // rebuild) is skipped and the checkout launches as-is.
+        if (engineDir !== undefined && options?.autoRebuild !== false) {
+            // The git sync is the checkout download: the card's button reads
+            // "Downloading..." for it, not "Building...".
+            onProgress?.('download');
+            // The conditional rebuild fetches the checkout, prices it against the
+            // remote branch, and rebuilds only when it is behind (or a fresh
+            // clone). The engine's own quick start (the cmake preset, then the
+            // preset's build) rides the acquisition-data build steps. The decision,
+            // the build command, and its output are captured into buildLogs and
+            // threaded to the card's Logs section.
+            const sync = await syncAndRebuildEngine(this.host, {
+                engineId: this.id,
+                directory: engineDir,
+                ...(platform?.engineFork !== undefined ? { fork: platform.engineFork } : {}),
+                ...(plan.argv?.[0] !== undefined ? { binary: plan.argv[0] } : {}),
+                ...(options?.allowRunDeps !== undefined ? { allowRunDeps: options.allowRunDeps } : {}),
+                ...(platform?.buildCommands !== undefined
+                    ? { buildCommands: platform.buildCommands }
+                    : {}),
+                // Report the build phase the moment the build steps start, so the
+                // card's button reads "Building..." while the build is in flight.
+                onBuildStart: () => onProgress?.('build'),
+            }, () => { });
+            buildLogs = sync.logs;
+            if (!sync.ok) {
+                return { ok: false, detail: sync.detail ?? 'unknown', logs: buildLogs };
+            }
+            // The build output reads as a fresh Logs section: a "Building..."
+            // separator leads the build decision and output, the same line the
+            // card writes when the build step event lands.
+            if (sync.rebuilt && buildLogs !== '') {
+                buildLogs = `--- Building...\n${buildLogs}`;
+            }
+        }
+        const withLogs = (result) => buildLogs !== '' ? { ...result, logs: buildLogs } : result;
+        onProgress?.('download');
+        const download = await this.downloadModel(plan);
+        if (!download.ok)
+            return withLogs(download);
+        const handle = this.host.spawn(plan.argv ?? [], plan.env ?? {}, engineDir);
+        this.children.set(this.planKey(plan), handle);
+        return withLogs({ ok: true, handle });
+    }
+    async healthCheck(plan, options) {
+        return pollHealth(this.host, plan, options);
+    }
+    async stop(plan) {
+        const handle = this.children.get(this.planKey(plan));
+        if (handle !== undefined) {
+            handle.kill();
+            this.children.delete(this.planKey(plan));
+        }
+    }
+    port(config) {
+        // 8080 is the infernix-serve CLI default, so the form seeds it and the
+        // adapter falls back to it when a config names no port.
+        return typeof config.port === 'number' ? config.port : 8080;
+    }
+    planKey(plan) {
+        return `${plan.engineId}:${plan.port}`;
+    }
+    async downloadModel(plan) {
+        const artifact = plan.modelId !== undefined ? INFERNIX_MODEL_ARTIFACTS[plan.modelId] : undefined;
+        // A model key that names a local artifact file carries no artifact entry,
+        // so the file the user has on disk launches as-is without a download.
+        if (artifact === undefined)
+            return { ok: true };
+        const target = plan.modelDirectory ?? '.';
+        // A multi-file artifact (the Flash-Next shards) downloads the whole repo,
+        // which carries the n-gram volume beside the shards, so the
+        // --ngram-volume flag points at a file the same download left on disk.
+        // A single-file artifact downloads the file alone.
+        const repo = artifact.repo;
+        const files = artifact.files ?? [];
+        const download = files.length > 1
+            ? await this.host.run(`hf download ${repo} --local-dir ${target}`)
+            : await this.host.run(`hf download ${repo} ${artifact.file} --local-dir ${target}`);
+        if (!download.ok) {
+            return { ok: false, detail: `model download failed: ${download.detail ?? 'unknown'}` };
+        }
+        return { ok: true };
+    }
+}
+//# sourceMappingURL=infernixAdapter.js.map

package/packages/providers/lib/engines/llamacppAdapter.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The llama.cpp engine adapter. 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.
+ * @module dsh-plugin-local-infer/providers/engines/llamacppAdapter
+ */
+import { EngineAdapter } from '../../../core/lib/index.js';
+import type { Config, DeployOptions, DeployResult, EngineLaunchSignature, EnginePlatformConfig, HealthCheckOptions, HealthResult, HardwareProfile, LaunchPlan, LaunchProgress, LifecycleHost, ParameterSpec } from '../../../core/lib/index.js';
+/**
+ * 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 declare const LLAMACPP_DOCKER_IMAGE = "ghcr.io/ggml-org/llama.cpp";
+/**
+ * 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 declare class LlamaCppAdapter extends EngineAdapter {
+    readonly id = "llamacpp";
+    readonly supports: {
+        docker: boolean;
+        local: boolean;
+    };
+    private readonly host;
+    private readonly children;
+    constructor(host?: LifecycleHost);
+    parameters(): readonly ParameterSpec[];
+    modelRef(config: Config): {
+        id: string;
+        name: string;
+    };
+    launchSignature(config?: Config): EngineLaunchSignature;
+    renderLaunch(config: Config, _hw: HardwareProfile): LaunchPlan;
+    deploy(plan: LaunchPlan, platform?: EnginePlatformConfig, onProgress?: LaunchProgress, options?: DeployOptions): Promise<DeployResult>;
+    healthCheck(plan: LaunchPlan, options?: HealthCheckOptions): Promise<HealthResult>;
+    stop(plan: LaunchPlan): Promise<void>;
+    private buildMode;
+    private port;
+    private planKey;
+    private downloadModel;
+}
+//# sourceMappingURL=llamacppAdapter.d.ts.map

package/packages/providers/lib/engines/llamacppAdapter.js

@@ -0,0 +1,232 @@
+/**
+ * The llama.cpp engine adapter. 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.
+ * @module dsh-plugin-local-infer/providers/engines/llamacppAdapter
+ */
+import { basename, dirname, join } from 'node:path';
+import { EngineAdapter } from '../../../core/lib/index.js';
+import { customArgFlags, flagsFromSpecs, nodeLifecycleHost, pollHealth, trackChild, } from "../adapters.js";
+import { syncAndRebuildEngine } from "../acquire.js";
+import { LLAMACPP_MODEL_ARTIFACTS, LLAMACPP_PARAMETERS, llamaCppModelKey, } from "./llamacpp.js";
+/**
+ * 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, onProgress, options) {
+        if (plan.kind === 'process') {
+            const engineDir = platform?.engineDirectory;
+            let buildLogs = '';
+            // Auto Rebuild off (the card's checkbox): the git sync (fetch, rebase,
+            // rebuild) is skipped and the checkout launches as-is.
+            if (engineDir !== undefined && options?.autoRebuild !== false) {
+                // The git sync is the checkout download: the card's button reads
+                // "Downloading..." for it, not "Building...".
+                onProgress?.('download');
+                // The conditional rebuild fetches the checkout, prices it against the
+                // remote branch, and rebuilds only when it is behind (or a fresh
+                // clone). The decision, the build command, and its output are captured
+                // into buildLogs and threaded to the card's Logs section.
+                const sync = await syncAndRebuildEngine(this.host, {
+                    engineId: this.id,
+                    directory: engineDir,
+                    ...(platform?.engineFork !== undefined ? { fork: platform.engineFork } : {}),
+                    ...(plan.argv?.[0] !== undefined ? { binary: plan.argv[0] } : {}),
+                    ...(options?.allowRunDeps !== undefined ? { allowRunDeps: options.allowRunDeps } : {}),
+                    ...(platform?.buildCommands !== undefined
+                        ? { buildCommands: platform.buildCommands }
+                        : {}),
+                    // Report the build phase the moment the build steps start, so the
+                    // card's button reads "Building..." while the build is in flight.
+                    onBuildStart: () => onProgress?.('build'),
+                }, () => { });
+                buildLogs = sync.logs;
+                if (!sync.ok) {
+                    return { ok: false, detail: sync.detail ?? 'unknown', logs: buildLogs };
+                }
+                // The build output reads as a fresh Logs section: a "Building..."
+                // separator leads the build decision and output, the same line the
+                // card writes when the build step event lands.
+                if (sync.rebuilt && buildLogs !== '') {
+                    buildLogs = `--- Building...\n${buildLogs}`;
+                }
+            }
+            const withLogs = (result) => buildLogs !== '' ? { ...result, logs: buildLogs } : result;
+            onProgress?.('download');
+            const download = await this.downloadModel(plan);
+            if (!download.ok)
+                return withLogs(download);
+            const handle = this.host.spawn(plan.argv ?? [], plan.env ?? {}, engineDir);
+            trackChild(this.children, this.planKey(plan), handle);
+            return withLogs({ ok: true, handle });
+        }
+        if (plan.kind === 'docker') {
+            // The image pull is the docker build step: the card's button reads
+            // "Building..." for it.
+            onProgress?.('build');
+            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 ?? {});
+            trackChild(this.children, this.planKey(plan), handle);
+            return { ok: true, handle };
+        }
+        // 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 };
+    }
+}
+//# sourceMappingURL=llamacppAdapter.js.map

package/packages/providers/lib/{ninfer.d.ts → engines/ninfer.d.ts}

@@ -39,6 +39,13 @@ export declare const CHAT_TEMPLATE_OPTIONS: readonly ComboOption[];
  * click, not just the constraint.
  */
 export declare const SPEC_GATE_MESSAGE = "Pick a speculation backend first (mtp, dflash, or dflash2)";
+/**
+ * The gate message the form shows while the LM-head draft field is greyed out.
+ * The LM-head drafter is an MTP-backend feature, so the field unlocks only
+ * while the MTP speculation backend is selected, for every provider that
+ * spells the flag.
+ */
+export declare const LM_HEAD_DRAFT_GATE_MESSAGE = "LM-head draft is only available with the MTP speculation backend";
 /**
  * The NInfer `ParameterSpec` surface, in form order. The `group` field is the
  * form section; specs without a group render under `General`. `requires`

package/packages/providers/lib/{ninfer.js → engines/ninfer.js}

@@ -66,6 +66,13 @@ export const CHAT_TEMPLATE_OPTIONS = [
  * click, not just the constraint.
  */
 export const SPEC_GATE_MESSAGE = 'Pick a speculation backend first (mtp, dflash, or dflash2)';
+/**
+ * The gate message the form shows while the LM-head draft field is greyed out.
+ * The LM-head drafter is an MTP-backend feature, so the field unlocks only
+ * while the MTP speculation backend is selected, for every provider that
+ * spells the flag.
+ */
+export const LM_HEAD_DRAFT_GATE_MESSAGE = 'LM-head draft is only available with the MTP speculation backend';
 /**
  * The NInfer `ParameterSpec` surface, in form order. The `group` field is the
  * form section; specs without a group render under `General`. `requires`
@@ -213,7 +220,7 @@ export const NINFER_PARAMETERS = [
         form: { kind: 'boolean' },
         defaultValue: false,
         group: 'Speculation',
-        requires: (config) => config.spec && config.spec !== 'none' ? null : SPEC_GATE_MESSAGE,
+        requires: (config) => config.spec === 'mtp' ? null : LM_HEAD_DRAFT_GATE_MESSAGE,
         toArgv: (value) => (value === true ? ['--lm-head-draft'] : []),
     },
     {

package/packages/providers/lib/engines/ninferAdapter.d.ts

@@ -0,0 +1,82 @@
+/**
+ * The NInfer engine adapter. NInferModelArtifact is the per-model deploy data:
+ * the `.ninfer` artifact file, the Hugging Face repo the model download pulls
+ * it from, and the `--model-id` alias the server advertises. The data is the
+ * surface; adding a model is a data edit here, never an adapter rewire.
+ * 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.
+ * @module dsh-plugin-local-infer/providers/engines/ninferAdapter
+ */
+import { EngineAdapter } from '../../../core/lib/index.js';
+import type { Config, DeployOptions, DeployResult, EngineLaunchSignature, EnginePlatformConfig, HealthCheckOptions, HealthResult, HardwareProfile, LaunchPlan, LaunchProgress, LifecycleHost, ParameterSpec } from '../../../core/lib/index.js';
+/**
+ * NInferModelArtifact is the per-model deploy data: the `.ninfer` artifact
+ * file, the Hugging Face repo the model download pulls it from, and the
+ * `--model-id` alias the server advertises. The data is the surface; adding a
+ * model is a data edit here, never an adapter rewire.
+ */
+export interface NInferModelArtifact {
+    file: string;
+    repo: string;
+    modelId: string;
+}
+/**
+ * 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 declare const NINFER_MODEL_ARTIFACTS: Record<string, NInferModelArtifact>;
+/**
+ * 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 declare 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 declare class NInferAdapter extends EngineAdapter {
+    readonly id = "ninfer";
+    readonly supports: {
+        docker: boolean;
+        local: boolean;
+    };
+    private readonly host;
+    private readonly children;
+    constructor(host?: LifecycleHost);
+    parameters(): readonly ParameterSpec[];
+    modelRef(config: Config): {
+        id: string;
+        name: string;
+    };
+    launchSignature(config?: Config): EngineLaunchSignature;
+    renderLaunch(config: Config, _hw: HardwareProfile): LaunchPlan;
+    deploy(plan: LaunchPlan, platform?: EnginePlatformConfig, onProgress?: LaunchProgress, options?: DeployOptions): Promise<DeployResult>;
+    healthCheck(plan: LaunchPlan, options?: HealthCheckOptions): Promise<HealthResult>;
+    stop(plan: LaunchPlan): Promise<void>;
+    private buildMode;
+    private port;
+    private planKey;
+    private downloadModel;
+    /**
+     * 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.
+     */
+    private resolveChatTemplate;
+}
+//# sourceMappingURL=ninferAdapter.d.ts.map