dsh-plugin-local-infer 0.1.2 → 0.1.3

package/packages/providers/lib/deps.d.ts

@@ -152,6 +152,26 @@ export declare const SYSTEM_DEPS: {
             };
         };
     };
+    git: {
+        id: string;
+        purpose: string;
+        requiresSudo: true;
+        detect: (hw: HardwareProfile) => Promise<boolean>;
+        install: {
+            apt: {
+                commands: string[];
+            };
+            dnf: {
+                commands: string[];
+            };
+            pacman: {
+                commands: string[];
+            };
+            brew: {
+                commands: string[];
+            };
+        };
+    };
     docker: {
         id: string;
         purpose: string;
@@ -219,8 +239,10 @@ export declare const SYSTEM_DEPS: {
  * docker lists are the container runtime plus the GPU toolkit plus the hf
  * CLI. Infernix builds through the engine's own cmake preset, so its local
  * list is the same toolchain as NInfer's, and its docker list stays empty
- * because the engine ships no container image. llama.cpp and Strata carry
- * the specified-not-verified lists until their adapters land in Phase 5.
+ * because the engine ships no container image. llama.cpp carries a thin
+ * cmake-plus-hf list. Strata carries one list per build mode: the source
+ * build needs git and curl, the binary install needs curl, and the docker
+ * mode needs the container runtime plus the GPU toolkit.
  */
 export declare const ENGINE_DEP_PLANS: Record<string, EngineDepPlan>;
 //# sourceMappingURL=deps.d.ts.map

package/packages/providers/lib/deps.js

@@ -136,6 +136,18 @@ export const SYSTEM_DEPS = {
             },
         },
     },
+    git: {
+        id: 'git',
+        purpose: 'clones the engine source',
+        requiresSudo: true,
+        detect: probe('git', ['--version']),
+        install: {
+            apt: { commands: ['sudo apt install git'] },
+            dnf: { commands: ['sudo dnf install git'] },
+            pacman: { commands: ['sudo pacman -S --noconfirm git'] },
+            brew: { commands: ['brew install git'] },
+        },
+    },
     docker: {
         id: 'docker',
         purpose: 'runs the engine in a container',
@@ -191,8 +203,10 @@ export const SYSTEM_DEPS = {
  * docker lists are the container runtime plus the GPU toolkit plus the hf
  * CLI. Infernix builds through the engine's own cmake preset, so its local
  * list is the same toolchain as NInfer's, and its docker list stays empty
- * because the engine ships no container image. llama.cpp and Strata carry
- * the specified-not-verified lists until their adapters land in Phase 5.
+ * because the engine ships no container image. llama.cpp carries a thin
+ * cmake-plus-hf list. Strata carries one list per build mode: the source
+ * build needs git and curl, the binary install needs curl, and the docker
+ * mode needs the container runtime plus the GPU toolkit.
  */
 export const ENGINE_DEP_PLANS = {
     ninfer: {
@@ -228,8 +242,13 @@ export const ENGINE_DEP_PLANS = {
         docker: [],
     },
     strata: {
-        local: [],
-        docker: [SYSTEM_DEPS.docker, SYSTEM_DEPS.hfCli],
+        // The source build git-clones the repo and runs setup.sh, which downloads
+        // what it needs; the binary install is the one-line curl script; the docker
+        // mode needs the container runtime plus the GPU toolkit (the model downloads
+        // inside the container, so no hf CLI).
+        local: [SYSTEM_DEPS.git, SYSTEM_DEPS.curl],
+        docker: [SYSTEM_DEPS.docker, SYSTEM_DEPS.nvidiaContainerToolkit],
+        binary: [SYSTEM_DEPS.curl],
     },
 };
 //# sourceMappingURL=deps.js.map

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

@@ -0,0 +1,38 @@
+/**
+ * The Hyper-Qwen engine adapter. 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`.
+ * @module dsh-plugin-local-infer/providers/engines/hyperqwenAdapter
+ */
+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';
+/**
+ * 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 declare class HyperQwenAdapter extends EngineAdapter {
+    readonly id = "hyperqwen";
+    readonly supports: {
+        docker: boolean;
+        local: boolean;
+    };
+    private readonly host;
+    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 profile;
+}
+//# sourceMappingURL=hyperqwenAdapter.d.ts.map

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

@@ -0,0 +1,105 @@
+/**
+ * The Hyper-Qwen engine adapter. 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`.
+ * @module dsh-plugin-local-infer/providers/engines/hyperqwenAdapter
+ */
+import { EngineAdapter, formatLaunchCommand } from '../../../core/lib/index.js';
+import { customArgEnv, envFromSpecs, nodeLifecycleHost, pollHealth } from "../adapters.js";
+import { HYPERQWEN_PARAMETERS } from "./hyperqwen.js";
+/**
+ * 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, platform, onProgress, _options) {
+        // The card's docker-tag field carries the compose arguments (the profile
+        // the up step selects); the deploy step applies it to the plan so the up
+        // line and the card's Logs section agree.
+        if (platform?.dockerTag !== undefined) {
+            plan.composeArgs = platform.dockerTag;
+        }
+        // The core formatter is the single source of the compose up line: the
+        // card's Logs section prints the same string this run gets.
+        const command = formatLaunchCommand(plan);
+        if (command === undefined) {
+            return { ok: false, detail: 'compose plan carries no command' };
+        }
+        // The compose up is the docker build step: the card's button reads
+        // "Building..." for it.
+        onProgress?.('build');
+        const up = await this.host.run(command);
+        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) {
+        // The down step brings down the containers the up step started, so it
+        // runs the same compose arguments (the profile the up selected); an
+        // absent composeArgs falls back to the engine's default profile.
+        const composeArgs = plan.composeArgs?.split(/\s+/).filter((token) => token !== '');
+        const args = composeArgs !== undefined && composeArgs.length > 0
+            ? composeArgs.join(' ')
+            : `--profile ${plan.profile ?? 'single'}`;
+        await this.host.run(`docker compose -f ${plan.composeFile ?? 'docker-compose.yml'} ${args} down`);
+    }
+    port(config) {
+        return typeof config.port === 'number' ? config.port : 18020;
+    }
+    profile(config) {
+        return typeof config.profile === 'string' ? config.profile : 'single';
+    }
+}
+//# sourceMappingURL=hyperqwenAdapter.js.map

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

@@ -404,7 +404,7 @@ export const INFERNIX_PARAMETERS = [
     {
         key: 'lmHeadDraft',
         label: 'LM-head draft',
-        description: 'Drafts from the small proposal head instead of the full output head, cutting the per-draft projection cost. An MTP-backend feature, so the field unlocks only while MTP is selected.',
+        description: 'Drafts from the small proposal head instead of the full output head, cutting the per-draft projection cost.',
         form: { kind: 'boolean' },
         defaultValue: false,
         group: 'Speculation',

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