dsh-plugin-local-infer 0.1.2 → 0.1.4

package/packages/providers/lib/engines/infernix/infernixFedora.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The Infernix Fedora build profile. Fedora builds Infernix through the shared
+ * Linux route (the engine's own cmake preset), so this profile reuses the
+ * shared Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/infernix/infernixFedora
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const INFERNIX_FEDORA: EngineOsProfile;
+//# sourceMappingURL=infernixFedora.d.ts.map

package/packages/providers/lib/engines/infernix/infernixFedora.js

@@ -0,0 +1,9 @@
+/**
+ * The Infernix Fedora build profile. Fedora builds Infernix through the shared
+ * Linux route (the engine's own cmake preset), so this profile reuses the
+ * shared Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/infernix/infernixFedora
+ */
+import { INFERNIX_LINUX } from "./infernixLinux.js";
+export const INFERNIX_FEDORA = INFERNIX_LINUX;
+//# sourceMappingURL=infernixFedora.js.map

package/packages/providers/lib/engines/infernix/infernixLinux.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The Infernix shared Linux build profile. Every Linux distro (Arch, Debian,
+ * Fedora) builds Infernix through the engine's own cmake preset: configure the
+ * release preset, then build into the `build` directory, which is where the
+ * `infernix-serve` binary lands. The distro profiles reuse this profile, so a
+ * distro carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/infernix/infernixLinux
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const INFERNIX_LINUX: EngineOsProfile;
+/**
+ * infernixLinuxBinary returns the Infernix engine binary name on Linux: the
+ * plain `infernix-serve` (no .exe). The name comes from the shared Linux
+ * profile, so the spelling has one home.
+ */
+export declare function infernixLinuxBinary(): string;
+//# sourceMappingURL=infernixLinux.d.ts.map

package/packages/providers/lib/engines/infernix/infernixLinux.js

@@ -0,0 +1,35 @@
+/**
+ * The Infernix shared Linux build profile. Every Linux distro (Arch, Debian,
+ * Fedora) builds Infernix through the engine's own cmake preset: configure the
+ * release preset, then build into the `build` directory, which is where the
+ * `infernix-serve` binary lands. The distro profiles reuse this profile, so a
+ * distro carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/infernix/infernixLinux
+ */
+import { SYSTEM_DEPS } from "../../systemDeps.js";
+export const INFERNIX_LINUX = {
+    buildSteps: ['cd {dir} && cmake --preset release && cmake --build build -j'],
+    buildDir: 'build',
+    binary: 'infernix-serve',
+    // Infernix builds through the engine's own cmake preset, so its local list
+    // is the same toolchain as NInfer's: the compile toolchain, the ffmpeg and
+    // curl dev libraries, the CUDA toolkit, and the hf CLI.
+    deps: [
+        SYSTEM_DEPS.cmake,
+        SYSTEM_DEPS.ninja,
+        SYSTEM_DEPS.pkgConfig,
+        SYSTEM_DEPS.ffmpeg,
+        SYSTEM_DEPS.curl,
+        SYSTEM_DEPS.cudaToolkit,
+        SYSTEM_DEPS.hfCli,
+    ],
+};
+/**
+ * infernixLinuxBinary returns the Infernix engine binary name on Linux: the
+ * plain `infernix-serve` (no .exe). The name comes from the shared Linux
+ * profile, so the spelling has one home.
+ */
+export function infernixLinuxBinary() {
+    return INFERNIX_LINUX.binary ?? 'infernix-serve';
+}
+//# sourceMappingURL=infernixLinux.js.map

package/packages/providers/lib/engines/infernix/infernixMacOS.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The Infernix macOS build profile. macOS builds Infernix through the engine's
+ * own cmake preset, the same route as Linux, so this profile reuses the shared
+ * Linux build steps and build directory; the binary keeps its plain name (no
+ * .exe on macOS).
+ * @module dsh-plugin-local-infer/providers/engines/infernix/infernixMacOS
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const INFERNIX_MACOS: EngineOsProfile;
+/**
+ * infernixMacOSBinary returns the Infernix engine binary name on macOS: the
+ * plain `infernix-serve` (no .exe on macOS). The name comes from the shared
+ * Linux profile the macOS profile reuses, so the spelling has one home.
+ */
+export declare function infernixMacOSBinary(): string;
+//# sourceMappingURL=infernixMacOS.d.ts.map

package/packages/providers/lib/engines/infernix/infernixMacOS.js

@@ -0,0 +1,18 @@
+/**
+ * The Infernix macOS build profile. macOS builds Infernix through the engine's
+ * own cmake preset, the same route as Linux, so this profile reuses the shared
+ * Linux build steps and build directory; the binary keeps its plain name (no
+ * .exe on macOS).
+ * @module dsh-plugin-local-infer/providers/engines/infernix/infernixMacOS
+ */
+import { INFERNIX_LINUX } from "./infernixLinux.js";
+export const INFERNIX_MACOS = INFERNIX_LINUX;
+/**
+ * infernixMacOSBinary returns the Infernix engine binary name on macOS: the
+ * plain `infernix-serve` (no .exe on macOS). The name comes from the shared
+ * Linux profile the macOS profile reuses, so the spelling has one home.
+ */
+export function infernixMacOSBinary() {
+    return INFERNIX_MACOS.binary ?? 'infernix-serve';
+}
+//# sourceMappingURL=infernixMacOS.js.map

package/packages/providers/lib/engines/infernix/infernixWindows.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The Infernix Windows build profile. Infernix builds through the engine's own
+ * cmake preset on every platform, so the Windows host reads the same preset
+ * route as Linux; the published release zip ships the server and its DLLs, so
+ * the binary is the .exe.
+ * @module dsh-plugin-local-infer/providers/engines/infernix/infernixWindows
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const INFERNIX_WINDOWS: EngineOsProfile;
+/**
+ * infernixWindowsBinary returns the Infernix engine binary name on Windows:
+ * the `infernix-serve.exe` the published release zip ships with its DLLs. The
+ * name comes from the Windows profile, so the .exe spelling has one home.
+ */
+export declare function infernixWindowsBinary(): string;
+//# sourceMappingURL=infernixWindows.d.ts.map

package/packages/providers/lib/engines/infernix/infernixWindows.js

@@ -0,0 +1,34 @@
+/**
+ * The Infernix Windows build profile. Infernix builds through the engine's own
+ * cmake preset on every platform, so the Windows host reads the same preset
+ * route as Linux; the published release zip ships the server and its DLLs, so
+ * the binary is the .exe.
+ * @module dsh-plugin-local-infer/providers/engines/infernix/infernixWindows
+ */
+import { INFERNIX_LINUX } from "./infernixLinux.js";
+import { SYSTEM_DEPS } from "../../systemDeps.js";
+export const INFERNIX_WINDOWS = {
+    buildSteps: INFERNIX_LINUX.buildSteps,
+    buildDir: 'build',
+    binary: 'infernix-serve.exe',
+    // Infernix builds through the engine's own cmake preset, so its Windows
+    // local list is the same winget toolchain as NInfer's: CMake, Ninja, the
+    // MSVC compiler, the CUDA toolkit, the hf CLI, and git.
+    deps: [
+        SYSTEM_DEPS.cmake,
+        SYSTEM_DEPS.ninja,
+        SYSTEM_DEPS.visualStudio,
+        SYSTEM_DEPS.cudaToolkit,
+        SYSTEM_DEPS.hfCli,
+        SYSTEM_DEPS.git,
+    ],
+};
+/**
+ * infernixWindowsBinary returns the Infernix engine binary name on Windows:
+ * the `infernix-serve.exe` the published release zip ships with its DLLs. The
+ * name comes from the Windows profile, so the .exe spelling has one home.
+ */
+export function infernixWindowsBinary() {
+    return INFERNIX_WINDOWS.binary ?? 'infernix-serve.exe';
+}
+//# sourceMappingURL=infernixWindows.js.map

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

@@ -9,7 +9,7 @@
  * `LaunchPlan`. Adding a flag here is a data edit, never a core rewire. The
  * engine is not present on the reference host, so the surface is the
  * specified set the plan names, verified when the binary lands.
- * @module dsh-plugin-local-infer/providers/llamacpp
+ * @module dsh-plugin-local-infer/providers/engines/llamacpp/llamacpp
  */
 import type { Config, EnumOption, ParameterSpec } from 'dsh-plugin-local-infer/core';
 /**
@@ -49,4 +49,4 @@ export declare const LLAMACPP_PARAMETERS: readonly ParameterSpec[];
  * 27B artifact key. A config that names neither renders a bare plan.
  */
 export declare function llamaCppModelKey(config: Config): string;
-//# sourceMappingURL=llamacpp.d.ts.map
+//# sourceMappingURL=llamacpp.d.ts.map

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

@@ -9,7 +9,7 @@
  * `LaunchPlan`. Adding a flag here is a data edit, never a core rewire. The
  * engine is not present on the reference host, so the surface is the
  * specified set the plan names, verified when the binary lands.
- * @module dsh-plugin-local-infer/providers/llamacpp
+ * @module dsh-plugin-local-infer/providers/engines/llamacpp/llamacpp
  */
 /**
  * The KV cache quantization formats llama.cpp serves. `f16` is the full-
@@ -57,6 +57,7 @@ export const LLAMACPP_PARAMETERS = [
         defaultValue: 4096,
         group: 'Memory',
         toArgv: (value) => ['--ctx-size', String(value)],
+        deploy: { target: 'cli' },
     },
     {
         key: 'gpuLayers',
@@ -66,6 +67,7 @@ export const LLAMACPP_PARAMETERS = [
         defaultValue: 99,
         group: 'Memory',
         toArgv: (value) => ['--n-gpu-layers', String(value)],
+        deploy: { target: 'cli' },
     },
     {
         key: 'kvCacheType',
@@ -77,6 +79,7 @@ export const LLAMACPP_PARAMETERS = [
         // llama.cpp prices the key and value caches separately; the engine serves
         // both from the same tier, so one value spells both flags.
         toArgv: (value) => ['--cache-type-k', String(value), '--cache-type-v', String(value)],
+        deploy: { target: 'cli' },
     },
     {
         key: 'threads',
@@ -85,6 +88,7 @@ export const LLAMACPP_PARAMETERS = [
         form: { kind: 'number', min: 1, step: 1, unit: 'threads' },
         group: 'Engine',
         toArgv: (value) => ['--threads', String(value)],
+        deploy: { target: 'cli' },
     },
     {
         key: 'batchSize',
@@ -93,6 +97,7 @@ export const LLAMACPP_PARAMETERS = [
         form: { kind: 'number', min: 32, step: 32, unit: 'tokens' },
         group: 'Engine',
         toArgv: (value) => ['--batch-size', String(value)],
+        deploy: { target: 'cli' },
     },
     {
         key: 'parallel',
@@ -102,6 +107,7 @@ export const LLAMACPP_PARAMETERS = [
         defaultValue: 1,
         group: 'Concurrency',
         toArgv: (value) => ['--parallel', String(value)],
+        deploy: { target: 'cli' },
     },
     {
         key: 'temp',
@@ -111,6 +117,7 @@ export const LLAMACPP_PARAMETERS = [
         defaultValue: 0.9,
         group: 'Sampling',
         toArgv: (value) => ['--temp', String(value)],
+        deploy: { target: 'cli' },
     },
     {
         key: 'topP',
@@ -120,6 +127,7 @@ export const LLAMACPP_PARAMETERS = [
         defaultValue: 0.95,
         group: 'Sampling',
         toArgv: (value) => ['--top-p', String(value)],
+        deploy: { target: 'cli' },
     },
     {
         key: 'flashAttn',
@@ -129,6 +137,7 @@ export const LLAMACPP_PARAMETERS = [
         defaultValue: false,
         group: 'Engine',
         toArgv: (value) => (value === true ? ['--flash-attn'] : []),
+        deploy: { target: 'cli' },
     },
     {
         key: 'jinja',
@@ -138,6 +147,7 @@ export const LLAMACPP_PARAMETERS = [
         defaultValue: true,
         group: 'Engine',
         toArgv: (value) => (value === true ? ['--jinja'] : []),
+        deploy: { target: 'cli' },
     },
 ];
 /**
@@ -148,4 +158,4 @@ export const LLAMACPP_PARAMETERS = [
 export function llamaCppModelKey(config) {
     return typeof config.model === 'string' ? config.model : 'qwen3-27b';
 }
-//# sourceMappingURL=llamacpp.js.map
+//# sourceMappingURL=llamacpp.js.map

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

@@ -0,0 +1,50 @@
+/**
+ * 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/llamacpp/llamacppAdapter
+ */
+import { EngineAdapter } from '../../../../core/lib/index.js';
+import type { CommandLogger, 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, log?: CommandLogger): Promise<void>;
+    private buildMode;
+    private port;
+    private downloadModel;
+}
+//# sourceMappingURL=llamacppAdapter.d.ts.map

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

@@ -0,0 +1,274 @@
+/**
+ * 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/llamacpp/llamacppAdapter
+ */
+import { basename, dirname, join } from 'node:path';
+import { EngineAdapter, autoRebuildEnabled, hfDownloadCommand, hfHubCacheDirectory, hubCacheSnapshotFilePath, modelArtifactPresent, modelDownloadTarget, } from '../../../../core/lib/index.js';
+import { auditRun, customArgFlags, flagsFromSpecs, nodeLifecycleHost, pollHealth, stopProcessPlan, trackChild, } from "../../adapters.js";
+import { syncEngineForDeploy } from "../../acquire.js";
+import { LLAMACPP_MODEL_ARTIFACTS, LLAMACPP_PARAMETERS, llamaCppModelKey, } from "./llamacpp.js";
+import { llamacppLinuxBinary } from "./llamacppLinux.js";
+import { llamacppMacOSBinary } from "./llamacppMacOS.js";
+import { llamacppWindowsBinary } from "./llamacppWindows.js";
+/**
+ * The llama.cpp engine binary is OS-specific (the .exe on Windows), so the
+ * launch binary comes from the host OS's binary function. The adapter's
+ * renderLaunch reads this map by the hardware profile's os, keeping the per-OS
+ * name in its own OS file.
+ */
+const LLAMACPP_BINARY = {
+    linux: llamacppLinuxBinary,
+    macos: llamacppMacOSBinary,
+    windows: llamacppWindowsBinary,
+};
+/**
+ * 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`,
+                os: _hw.os,
+            };
+        }
+        // The hub-cache layout (the model directory is the plugin default)
+        // resolves the concrete snapshot file the engine reads; a user override
+        // keeps the flat model-directory path. A not-yet-downloaded model falls
+        // back to the bare file name, the same as the flat layout's missing-file
+        // case.
+        const modelPath = modelDirectory === ''
+            ? (hubCacheSnapshotFilePath(hfHubCacheDirectory(), artifact.repo, file) ?? file)
+            : join(modelDirectory, file);
+        const customArgs = customArgFlags(config);
+        return {
+            engineId: this.id,
+            kind: 'process',
+            argv: [
+                // The engine binary is OS-specific (the .exe on Windows), so the name
+                // comes from the host OS's binary function.
+                LLAMACPP_BINARY[_hw.os](),
+                '--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`,
+            os: _hw.os,
+        };
+    }
+    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 && autoRebuildEnabled(options?.autoRebuild)) {
+                // 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 syncEngineForDeploy(this.host, {
+                    engineId: this.id,
+                    directory: engineDir,
+                    ...(platform !== undefined ? { platform } : {}),
+                    ...(options !== undefined ? { options } : {}),
+                    // The host OS the build steps pick for: a Windows host reads the
+                    // engine's Windows build steps when the user carries no build-
+                    // command override.
+                    ...(plan.os !== undefined ? { os: plan.os } : {}),
+                    ...(onProgress !== undefined ? { onProgress } : {}),
+                });
+                buildLogs = sync.buildLogs;
+                if (!sync.ok) {
+                    return { ok: false, detail: sync.detail ?? 'unknown', logs: buildLogs };
+                }
+            }
+            const withLogs = (result) => buildLogs !== '' ? { ...result, logs: buildLogs } : result;
+            onProgress?.('download');
+            const download = await this.downloadModel(plan, options?.onLog);
+            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') {
+            // Auto Rebuild off (the card's checkbox): the image pull is skipped and
+            // the already-present image starts. The image pull is the docker build
+            // step: the card's button reads "Building..." for it, and its
+            // `$ <command>` line reaches the launch run's log sink before the child
+            // spawns.
+            if (autoRebuildEnabled(options?.autoRebuild)) {
+                onProgress?.('build');
+                const pull = await auditRun(this.host, `docker pull ${LLAMACPP_DOCKER_IMAGE}`, options?.onLog);
+                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) {
+        // The tracked handle rides into the poll, so a child that exits (a
+        // crash) ends the poll early with a failed result.
+        return pollHealth(this.host, plan, options, this.children.get(this.planKey(plan)));
+    }
+    async stop(plan, log) {
+        if (plan.kind === 'docker' && plan.containerName !== undefined) {
+            await auditRun(this.host, `docker stop ${plan.containerName}`, log);
+        }
+        const handle = this.children.get(this.planKey(plan));
+        if (handle !== undefined) {
+            handle.kill();
+            this.children.delete(this.planKey(plan));
+            return;
+        }
+        // No tracked child (an engine a DSH restart re-adopted): signal the pid
+        // the stored launch record stamped on the plan, so the stop reaches a
+        // process this adapter instance did not spawn.
+        await stopProcessPlan(this.host, plan, log);
+    }
+    buildMode(config) {
+        return config.buildMode === 'docker' ? 'docker' : 'local';
+    }
+    port(config) {
+        // 8080 is the port the llama-server CLI binds by default, so a bare
+        // config launches on it.
+        return typeof config.port === 'number' ? config.port : 8080;
+    }
+    async downloadModel(plan, log) {
+        const artifact = plan.modelId !== undefined ? LLAMACPP_MODEL_ARTIFACTS[plan.modelId] : undefined;
+        if (artifact === undefined)
+            return { ok: true };
+        // The hub-cache layout (no --local-dir) applies when the model directory is
+        // the plugin default; a user override keeps the flat --local-dir target.
+        const { baseDir, useHubCache } = modelDownloadTarget(plan.modelDirectory);
+        const entry = {
+            engineId: this.id,
+            modelId: plan.modelId ?? '',
+            label: artifact.modelId,
+            url: `https://huggingface.co/${artifact.repo}`,
+            file: artifact.file,
+        };
+        // A model the shared Get-steps routine already downloaded is on disk, so
+        // the deploy step skips the re-fetch and a launch after a Get does no
+        // duplicate download. Presence is the deterministic snapshot the resolved
+        // layout holds (modelArtifactPresent), never a bare blobs folder: a cache
+        // whose snapshot links are missing re-runs the cheap hf download, which
+        // reuses the blobs and writes the links.
+        if (modelArtifactPresent(entry, baseDir, useHubCache))
+            return { ok: true };
+        const download = await auditRun(this.host, hfDownloadCommand(entry, baseDir, useHubCache), log);
+        if (!download.ok) {
+            return { ok: false, detail: `model download failed: ${download.detail ?? 'unknown'}` };
+        }
+        return { ok: true };
+    }
+}
+//# sourceMappingURL=llamacppAdapter.js.map

package/packages/providers/lib/engines/llamacpp/llamacppArch.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The llama.cpp Arch Linux build profile. Arch builds llama.cpp through the
+ * shared Linux route (cmake with the Ninja generator), so this profile reuses
+ * the shared Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/llamacpp/llamacppArch
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const LLAMACPP_ARCH: EngineOsProfile;
+//# sourceMappingURL=llamacppArch.d.ts.map

package/packages/providers/lib/engines/llamacpp/llamacppArch.js

@@ -0,0 +1,9 @@
+/**
+ * The llama.cpp Arch Linux build profile. Arch builds llama.cpp through the
+ * shared Linux route (cmake with the Ninja generator), so this profile reuses
+ * the shared Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/llamacpp/llamacppArch
+ */
+import { LLAMACPP_LINUX } from "./llamacppLinux.js";
+export const LLAMACPP_ARCH = LLAMACPP_LINUX;
+//# sourceMappingURL=llamacppArch.js.map

package/packages/providers/lib/engines/llamacpp/llamacppDebian.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The llama.cpp Debian build profile. Debian builds llama.cpp through the
+ * shared Linux route (cmake with the Ninja generator), so this profile reuses
+ * the shared Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/llamacpp/llamacppDebian
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const LLAMACPP_DEBIAN: EngineOsProfile;
+//# sourceMappingURL=llamacppDebian.d.ts.map

package/packages/providers/lib/engines/llamacpp/llamacppDebian.js

@@ -0,0 +1,9 @@
+/**
+ * The llama.cpp Debian build profile. Debian builds llama.cpp through the
+ * shared Linux route (cmake with the Ninja generator), so this profile reuses
+ * the shared Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/llamacpp/llamacppDebian
+ */
+import { LLAMACPP_LINUX } from "./llamacppLinux.js";
+export const LLAMACPP_DEBIAN = LLAMACPP_LINUX;
+//# sourceMappingURL=llamacppDebian.js.map

package/packages/providers/lib/engines/llamacpp/llamacppFedora.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The llama.cpp Fedora build profile. Fedora builds llama.cpp through the
+ * shared Linux route (cmake with the Ninja generator), so this profile reuses
+ * the shared Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/llamacpp/llamacppFedora
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const LLAMACPP_FEDORA: EngineOsProfile;
+//# sourceMappingURL=llamacppFedora.d.ts.map

package/packages/providers/lib/engines/llamacpp/llamacppFedora.js

@@ -0,0 +1,9 @@
+/**
+ * The llama.cpp Fedora build profile. Fedora builds llama.cpp through the
+ * shared Linux route (cmake with the Ninja generator), so this profile reuses
+ * the shared Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/llamacpp/llamacppFedora
+ */
+import { LLAMACPP_LINUX } from "./llamacppLinux.js";
+export const LLAMACPP_FEDORA = LLAMACPP_LINUX;
+//# sourceMappingURL=llamacppFedora.js.map