dsh-plugin-local-infer 0.1.1 → 0.1.3

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

@@ -0,0 +1,127 @@
+/**
+ * The per-engine acquisition data and the Get step. Each engine declares its
+ * git source (the upstream repo, the branch the rebase targets, and the build
+ * steps the checkout runs) as data here; the adapters' deploy steps and the
+ * /local-infer/get route both consume the same constants, so a build command
+ * has one home. The sync step clones a missing checkout, and a clean existing
+ * checkout is fetched and rebased onto the upstream branch; a checkout with
+ * local changes aborts, because a rebase would eat the user's work.
+ * @module dsh-plugin-local-infer/providers/acquire
+ */
+import type { LifecycleHost } from '../../core/lib/index.js';
+/**
+ * EngineSource is the per-engine acquisition data: the upstream git repo the
+ * clone step uses when no fork is provided, the branch the fetch/rebase step
+ * rebases onto, and the build steps run in the checkout after a clone or a
+ * rebase. A build step is a shell command line; the `{dir}` placeholder is
+ * replaced with the checkout directory before the step runs.
+ */
+export interface EngineSource {
+    repo: string;
+    branch: string;
+    buildSteps: readonly string[];
+}
+/**
+ * The remote name a user-provided fork is added under, so the checkout's own
+ * origin (the upstream it was cloned from) survives the fork override.
+ */
+export declare const FORK_REMOTE = "dsh-fork";
+/**
+ * The per-engine git sources, keyed by engine id. NInfer and Infernix build
+ * through cmake (Infernix through its own preset); llama.cpp builds through
+ * the same cmake shape as NInfer; Hyper-Qwen is the compose-driven vLLM
+ * engine, so it carries no local build steps (the compose up pulls the
+ * image); Strata builds through its own setup.sh (the README's
+ * Build-from-source route), which the source-build mode runs in the checkout.
+ */
+export declare const ENGINE_SOURCES: Record<string, EngineSource>;
+/**
+ * AcquireLog receives one line (or chunk) of Get output as it lands, so the
+ * route can stream it to the card's Logs section.
+ */
+export type AcquireLog = (chunk: string) => void;
+/**
+ * EngineStepResult reports one Get step (sync or build): whether it passed,
+ * whether it aborted on a rule (a dirty checkout), and a detail the Logs
+ * section shows when it did not pass.
+ */
+export interface EngineStepResult {
+    ok: boolean;
+    aborted?: boolean;
+    detail?: string;
+}
+/**
+ * engineSource reads the registered acquisition data for an engine id, or
+ * undefined when none is registered.
+ */
+export declare function engineSource(engineId: string): EngineSource | undefined;
+/**
+ * engineBuildSteps reads the build steps an engine runs in its checkout, so
+ * the adapter's deploy step and the Get build step share one list.
+ */
+export declare function engineBuildSteps(engineId: string): readonly string[];
+/**
+ * syncEngineRepo brings the engine checkout to the listed source. A missing
+ * checkout is a fresh clone of the fork (or the engine's upstream repo when
+ * no fork is provided). An existing checkout with local changes aborts, so
+ * the user's work is never rebased away; a clean checkout fetches the listed
+ * fork (added as the named fork remote when provided, origin when not) and
+ * rebases onto its branch. Every command echoes into log as it runs.
+ */
+export declare function syncEngineRepo(host: LifecycleHost, request: {
+    engineId: string;
+    directory: string;
+    fork?: string;
+}, log: AcquireLog): Promise<EngineStepResult>;
+/**
+ * SyncRebuildRequest names the checkout the conditional rebuild prices: the
+ * engine, its directory, the optional fork remote, the engine binary the
+ * symlink step links when a rebuild leaves it out of the path, and the
+ * Play/Run trust gate that decides whether that symlink runs (on) or is
+ * written to the logs (off).
+ */
+export interface SyncRebuildRequest {
+    engineId: string;
+    directory: string;
+    fork?: string;
+    binary?: string;
+    allowRunDeps?: boolean;
+    buildCommands?: string;
+    onBuildStart?: () => void;
+}
+/**
+ * SyncRebuildResult reports the conditional rebuild: whether it passed,
+ * whether a build actually ran (a fresh clone, or a rebase of a checkout that
+ * was behind), a detail for a failure, and the captured log text (the decision,
+ * the build command, and its output) the deploy step threads to the card's
+ * Logs section.
+ */
+export interface SyncRebuildResult {
+    ok: boolean;
+    rebuilt: boolean;
+    detail?: string;
+    logs: string;
+}
+/**
+ * syncAndRebuildEngine brings the engine checkout to the listed source and
+ * rebuilds it only when it needs to. A missing checkout is a fresh clone of
+ * the fork (or the upstream repo) and always builds. An existing checkout is
+ * fetched and priced against the remote branch: when it is behind and clean,
+ * the primary branch is checked out, rebased onto the remote branch, and the
+ * working tree is cleaned (git clean -fxd) before the build; when it is not
+ * behind, or it carries local changes, the build is skipped so a launch does
+ * not rebuild a checkout that is current. The decision, the build command,
+ * and its output stream through log and are returned as the result's logs.
+ * After a rebuild, the engine binary is checked against the path; when a build
+ * that did not install it leaves it out, a symlink into /usr/local/bin is
+ * added (run when the trust gate is on, written to the logs when it is off).
+ */
+export declare function syncAndRebuildEngine(host: LifecycleHost, request: SyncRebuildRequest, log: AcquireLog): Promise<SyncRebuildResult>;
+/**
+ * buildEngineRepo runs the engine's build steps in the checkout, streaming
+ * each step's output through log. An engine with no build steps (the compose
+ * engines) passes through with a note; a failing step stops the build with
+ * the step's detail.
+ */
+export declare function buildEngineRepo(host: LifecycleHost, engineId: string, directory: string, log: AcquireLog, buildCommands?: string): Promise<EngineStepResult>;
+//# sourceMappingURL=acquire.d.ts.map

package/packages/providers/lib/acquire.js

@@ -0,0 +1,346 @@
+/**
+ * The per-engine acquisition data and the Get step. Each engine declares its
+ * git source (the upstream repo, the branch the rebase targets, and the build
+ * steps the checkout runs) as data here; the adapters' deploy steps and the
+ * /local-infer/get route both consume the same constants, so a build command
+ * has one home. The sync step clones a missing checkout, and a clean existing
+ * checkout is fetched and rebased onto the upstream branch; a checkout with
+ * local changes aborts, because a rebase would eat the user's work.
+ * @module dsh-plugin-local-infer/providers/acquire
+ */
+/**
+ * The remote name a user-provided fork is added under, so the checkout's own
+ * origin (the upstream it was cloned from) survives the fork override.
+ */
+export const FORK_REMOTE = 'dsh-fork';
+/**
+ * The per-engine git sources, keyed by engine id. NInfer and Infernix build
+ * through cmake (Infernix through its own preset); llama.cpp builds through
+ * the same cmake shape as NInfer; Hyper-Qwen is the compose-driven vLLM
+ * engine, so it carries no local build steps (the compose up pulls the
+ * image); Strata builds through its own setup.sh (the README's
+ * Build-from-source route), which the source-build mode runs in the checkout.
+ */
+export const ENGINE_SOURCES = {
+    ninfer: {
+        repo: 'https://github.com/Neroued/ninfer',
+        branch: 'master',
+        buildSteps: [
+            'cmake -S {dir} -B {dir}/build -G Ninja -DCMAKE_BUILD_TYPE=Release && cmake --build {dir}/build -j',
+        ],
+    },
+    hyperqwen: {
+        repo: 'https://github.com/vllm-project/vllm',
+        branch: 'main',
+        buildSteps: [],
+    },
+    llamacpp: {
+        repo: 'https://github.com/ggml-org/llama.cpp',
+        branch: 'master',
+        buildSteps: [
+            'cmake -S {dir} -B {dir}/build -G Ninja -DCMAKE_BUILD_TYPE=Release && cmake --build {dir}/build -j',
+        ],
+    },
+    infernix: {
+        repo: 'https://github.com/Wallawalla47/Infernix',
+        branch: 'main',
+        buildSteps: ['cd {dir} && cmake --preset release && cmake --build build -j'],
+    },
+    strata: {
+        // The README's Build-from-source route: git clone the repo, then run the
+        // engine's own setup.sh. `--yes` takes the recommended answer to every
+        // question (no prompts) and `--no-start` builds and installs the engine
+        // without starting the server, which the adapter's launch step then does.
+        repo: 'https://github.com/Niko1221/Strata',
+        branch: 'main',
+        buildSteps: ['cd {dir} && ./setup.sh --yes --no-start'],
+    },
+};
+/**
+ * engineSource reads the registered acquisition data for an engine id, or
+ * undefined when none is registered.
+ */
+export function engineSource(engineId) {
+    return ENGINE_SOURCES[engineId];
+}
+/**
+ * engineBuildSteps reads the build steps an engine runs in its checkout, so
+ * the adapter's deploy step and the Get build step share one list.
+ */
+export function engineBuildSteps(engineId) {
+    return ENGINE_SOURCES[engineId]?.buildSteps ?? [];
+}
+/**
+ * runLogged runs one shell command through the host's streaming surface when
+ * it has one (echoing the command and streaming its output through log), and
+ * through plain run otherwise. The streamed copy is also collected, so a
+ * caller can price the command's stdout (the dirty-check, for one).
+ */
+async function runLogged(host, command, log, options) {
+    let output = '';
+    const collect = (chunk) => {
+        output += chunk;
+        log(chunk);
+    };
+    if (options?.echo !== false) {
+        log(`$ ${command}\n`);
+    }
+    if (host.runStream !== undefined) {
+        const outcome = await host.runStream(command, collect);
+        return { ...outcome, output };
+    }
+    const outcome = await host.run(command);
+    return { ...outcome, output };
+}
+/**
+ * syncEngineRepo brings the engine checkout to the listed source. A missing
+ * checkout is a fresh clone of the fork (or the engine's upstream repo when
+ * no fork is provided). An existing checkout with local changes aborts, so
+ * the user's work is never rebased away; a clean checkout fetches the listed
+ * fork (added as the named fork remote when provided, origin when not) and
+ * rebases onto its branch. Every command echoes into log as it runs.
+ */
+export async function syncEngineRepo(host, request, log) {
+    const source = engineSource(request.engineId);
+    if (source === undefined) {
+        return {
+            ok: false,
+            detail: `no engine source is registered for "${request.engineId}"`,
+        };
+    }
+    const directory = request.directory;
+    const fork = request.fork !== undefined && request.fork.trim() !== '' ? request.fork : undefined;
+    const present = await host.run(`[ -d ${directory}/.git ]`);
+    if (present.ok) {
+        const status = await runLogged(host, `git -C ${directory} status --short`, log);
+        if (!status.ok) {
+            return { ok: false, detail: `git status failed: ${status.detail ?? 'unknown'}` };
+        }
+        if (status.output.trim() !== '') {
+            log(`!! ${directory} has local changes. Get aborted; commit or revert them first.\n`);
+            return {
+                ok: false,
+                aborted: true,
+                detail: 'the engine repository has local changes',
+            };
+        }
+        if (fork !== undefined) {
+            // Add the fork under its own remote name; re-Get updates the URL in
+            // place so an edited Engine Fork field takes effect on the next run.
+            const add = await runLogged(host, `git -C ${directory} remote add ${FORK_REMOTE} ${fork}`, log);
+            if (!add.ok) {
+                await runLogged(host, `git -C ${directory} remote set-url ${FORK_REMOTE} ${fork}`, log);
+            }
+        }
+        const remote = fork !== undefined ? FORK_REMOTE : 'origin';
+        const fetch = await runLogged(host, `git -C ${directory} fetch ${remote}`, log);
+        if (!fetch.ok) {
+            return { ok: false, detail: `git fetch ${remote} failed: ${fetch.detail ?? 'unknown'}` };
+        }
+        const rebase = await runLogged(host, `git -C ${directory} rebase ${remote}/${source.branch} || ` +
+            `{ git -C ${directory} rebase --abort; exit 1; }`, log);
+        if (!rebase.ok) {
+            return {
+                ok: false,
+                detail: `git rebase ${remote}/${source.branch} failed: ${rebase.detail ?? 'unknown'}`,
+            };
+        }
+        return { ok: true };
+    }
+    const clone = await runLogged(host, `git clone ${fork ?? source.repo} ${directory}`, log);
+    if (!clone.ok) {
+        return { ok: false, detail: `git clone failed: ${clone.detail ?? 'unknown'}` };
+    }
+    return { ok: true };
+}
+/**
+ * syncAndRebuildEngine brings the engine checkout to the listed source and
+ * rebuilds it only when it needs to. A missing checkout is a fresh clone of
+ * the fork (or the upstream repo) and always builds. An existing checkout is
+ * fetched and priced against the remote branch: when it is behind and clean,
+ * the primary branch is checked out, rebased onto the remote branch, and the
+ * working tree is cleaned (git clean -fxd) before the build; when it is not
+ * behind, or it carries local changes, the build is skipped so a launch does
+ * not rebuild a checkout that is current. The decision, the build command,
+ * and its output stream through log and are returned as the result's logs.
+ * After a rebuild, the engine binary is checked against the path; when a build
+ * that did not install it leaves it out, a symlink into /usr/local/bin is
+ * added (run when the trust gate is on, written to the logs when it is off).
+ */
+export async function syncAndRebuildEngine(host, request, log) {
+    const source = engineSource(request.engineId);
+    if (source === undefined) {
+        return {
+            ok: false,
+            rebuilt: false,
+            detail: `no engine source is registered for "${request.engineId}"`,
+            logs: '',
+        };
+    }
+    const directory = request.directory;
+    const fork = request.fork !== undefined && request.fork.trim() !== '' ? request.fork : undefined;
+    const remote = fork !== undefined ? FORK_REMOTE : 'origin';
+    const chunks = [];
+    const emit = (chunk) => {
+        chunks.push(chunk);
+        log(chunk);
+    };
+    const present = await host.run(`[ -d ${directory}/.git ]`);
+    let rebuilt = false;
+    if (!present.ok) {
+        // A missing checkout is a fresh clone of the fork (or the upstream repo),
+        // which always needs a build.
+        emit(`>> cloning ${fork ?? source.repo} into ${directory}\n`);
+        const clone = await runLogged(host, `git clone ${fork ?? source.repo} ${directory}`, emit);
+        if (!clone.ok) {
+            return {
+                ok: false,
+                rebuilt: false,
+                detail: `git clone failed: ${clone.detail ?? 'unknown'}`,
+                logs: chunks.join(''),
+            };
+        }
+        rebuilt = true;
+    }
+    else {
+        if (fork !== undefined) {
+            // Add the fork under its own remote name; a re-launch updates the URL in
+            // place so an edited fork field takes effect on the next run.
+            const add = await runLogged(host, `git -C ${directory} remote add ${FORK_REMOTE} ${fork}`, emit, { echo: false });
+            if (!add.ok) {
+                await runLogged(host, `git -C ${directory} remote set-url ${FORK_REMOTE} ${fork}`, emit, { echo: false });
+            }
+        }
+        const status = await runLogged(host, `git -C ${directory} status --short`, emit, { echo: false });
+        if (!status.ok) {
+            return {
+                ok: false,
+                rebuilt: false,
+                detail: `git status failed: ${status.detail ?? 'unknown'}`,
+                logs: chunks.join(''),
+            };
+        }
+        if (status.output.trim() !== '') {
+            emit(`!! ${directory} has local changes; the rebase and rebuild are skipped.\n`);
+            return { ok: true, rebuilt: false, logs: chunks.join('') };
+        }
+        // The fetch is best-effort: an offline host prices the checkout it has.
+        await runLogged(host, `git -C ${directory} fetch ${remote} || true`, emit, { echo: false });
+        // Price whether the current branch is behind the remote branch. A fetch
+        // that failed (offline) or a missing remote branch reads as not-behind, so
+        // the checkout builds as-is.
+        const count = await runLogged(host, `git -C ${directory} rev-list --count HEAD..${remote}/${source.branch} 2>/dev/null || echo 0`, emit, { echo: false });
+        const behind = (count.output.trim() || '0') !== '0';
+        if (behind) {
+            emit(`>> ${directory} is behind ${remote}/${source.branch}; rebasing and rebuilding.\n`);
+            const checkout = await runLogged(host, `git -C ${directory} checkout ${source.branch}`, emit);
+            if (!checkout.ok) {
+                return {
+                    ok: false,
+                    rebuilt: false,
+                    detail: `git checkout ${source.branch} failed: ${checkout.detail ?? 'unknown'}`,
+                    logs: chunks.join(''),
+                };
+            }
+            const rebase = await runLogged(host, `git -C ${directory} rebase ${remote}/${source.branch} || ` +
+                `{ git -C ${directory} rebase --abort; exit 1; }`, emit);
+            if (!rebase.ok) {
+                return {
+                    ok: false,
+                    rebuilt: false,
+                    detail: `git rebase ${remote}/${source.branch} failed: ${rebase.detail ?? 'unknown'}`,
+                    logs: chunks.join(''),
+                };
+            }
+            const clean = await runLogged(host, `git -C ${directory} clean -fxd`, emit);
+            if (!clean.ok) {
+                return {
+                    ok: false,
+                    rebuilt: false,
+                    detail: `git clean -fxd failed: ${clean.detail ?? 'unknown'}`,
+                    logs: chunks.join(''),
+                };
+            }
+            rebuilt = true;
+        }
+        else {
+            emit(`>> ${directory} is up to date with ${remote}/${source.branch}; the rebuild is skipped.\n`);
+        }
+    }
+    if (rebuilt) {
+        // The user's local build command (the card's Build commands field)
+        // overrides the engine's default build steps: it runs in the checkout, so
+        // it is wrapped with a cd into the directory. Absent falls back to the
+        // engine's acquisition build steps.
+        const buildCommands = request.buildCommands !== undefined && request.buildCommands.trim() !== ''
+            ? request.buildCommands
+            : undefined;
+        const steps = buildCommands !== undefined
+            ? [`cd ${directory} && ${buildCommands}`]
+            : source.buildSteps;
+        // Report the build phase before the first step runs, so the card's button
+        // reads "Building..." while the build is in flight, not after it completes.
+        request.onBuildStart?.();
+        for (const step of steps) {
+            const command = step.replaceAll('{dir}', directory);
+            const outcome = await runLogged(host, command, emit);
+            if (!outcome.ok) {
+                return {
+                    ok: false,
+                    rebuilt: true,
+                    detail: `build failed: ${outcome.detail ?? 'unknown'}`,
+                    logs: chunks.join(''),
+                };
+            }
+        }
+        // A rebuild that did not install the binary (no make install) leaves it
+        // out of the path. Check, and add a symlink when the trust gate allows.
+        const binary = request.binary;
+        if (binary !== undefined) {
+            const which = await host.run(`command -v ${binary}`);
+            if (!which.ok) {
+                const link = `sudo ln -sf ${directory}/build/${binary} /usr/local/bin/${binary}`;
+                if (request.allowRunDeps === true) {
+                    const result = await runLogged(host, link, emit);
+                    if (!result.ok) {
+                        emit(`!! ${link} failed: ${result.detail ?? 'unknown'}\n`);
+                    }
+                }
+                else {
+                    emit(`!! ${binary} is not on the path; run ${link} (the provider command must be on the path to launch)\n`);
+                }
+            }
+        }
+    }
+    return { ok: true, rebuilt, logs: chunks.join('') };
+}
+/**
+ * buildEngineRepo runs the engine's build steps in the checkout, streaming
+ * each step's output through log. An engine with no build steps (the compose
+ * engines) passes through with a note; a failing step stops the build with
+ * the step's detail.
+ */
+export async function buildEngineRepo(host, engineId, directory, log, buildCommands) {
+    const source = engineSource(engineId);
+    if (source === undefined) {
+        return { ok: false, detail: `no engine source is registered for "${engineId}"` };
+    }
+    // The user's local build command (the card's Build commands field) overrides
+    // the engine's default build steps: it runs in the checkout, so it is wrapped
+    // with a cd into the directory. Absent falls back to the engine's steps.
+    const commands = buildCommands !== undefined && buildCommands.trim() !== '' ? buildCommands : undefined;
+    const steps = commands !== undefined ? [`cd ${directory} && ${commands}`] : source.buildSteps;
+    if (steps.length === 0) {
+        log(`no local build steps for ${engineId}\n`);
+        return { ok: true };
+    }
+    for (const step of steps) {
+        const command = step.replaceAll('{dir}', directory);
+        const outcome = await runLogged(host, command, log);
+        if (!outcome.ok) {
+            return { ok: false, detail: `build failed: ${outcome.detail ?? 'unknown'}` };
+        }
+    }
+    return { ok: true };
+}
+//# sourceMappingURL=acquire.js.map

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

@@ -1,32 +1,13 @@
 /**
- * The concrete engine adapters: NInfer (docker and local) and Hyper-Qwen
- * (compose). Each composes the provider `ParameterSpec` data into a
- * `LaunchPlan` and drives its deploy, health-check, and stop steps through an
- * injectable `LifecycleHost`, so the tests stub the host and never run a real
- * build, docker, or network in CI. The node implementation
- * (`nodeLifecycleHost`) is what the service wires in on a live host.
+ * The shared engine-adapter helpers: the spec-to-argv and spec-to-env
+ * translators the concrete adapters (the `engines/*Adapter.ts` files) compose
+ * into a `LaunchPlan`, the card's Custom Arguments translators, the
+ * `LifecycleHost` the deploy, health-check, and stop steps drive, and the
+ * health poll. The node implementation (`nodeLifecycleHost`) is what the
+ * service wires in on a live host.
  * @module dsh-plugin-local-infer/providers/adapters
  */
-import { EngineAdapter } from '../../core/lib/index.js';
-import type { Config, DebugLogger, DeployResult, EngineLaunchSignature, EnginePlatformConfig, HealthCheckOptions, HealthResult, HardwareProfile, LaunchPlan, 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>;
+import type { Config, DebugLogger, HealthCheckOptions, HealthResult, LaunchPlan, LifecycleHost, ParameterSpec, ProcessHandle } from '../../core/lib/index.js';
 /**
  * flagsFromSpecs turns a spec surface and a config into the CLI flag list: each
  * spec's `toArgv` runs over the config value (falling back to the spec
@@ -75,6 +56,14 @@ export declare function createNodeLifecycleHost(debug?: DebugLogger): LifecycleH
  * in debug mode.
  */
 export declare const nodeLifecycleHost: LifecycleHost;
+/**
+ * trackChild stores a spawned handle in the adapter's children map and ties
+ * the entry's lifetime to the child's: when the child ends (a crash, a pkill,
+ * or the adapter's own stop kill) the entry is dropped, so a later stop never
+ * signals a pid a recycled process has taken over. A handle whose host cannot
+ * watch (onExit absent) stays tracked until stop removes it.
+ */
+export declare function trackChild(children: Map<string, ProcessHandle>, key: string, handle: ProcessHandle): void;
 /**
  * pollHealth polls a plan's health URL until a 200 or the attempt cap, the
  * same loop the qwen-ninfer launcher runs. A poll interval of 0 skips the
@@ -82,151 +71,9 @@ export declare const nodeLifecycleHost: LifecycleHost;
  */
 export declare function pollHealth(host: LifecycleHost, plan: LaunchPlan, options?: HealthCheckOptions): Promise<HealthResult>;
 /**
- * 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): 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;
-}
-/**
- * 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): Promise<DeployResult>;
-    healthCheck(plan: LaunchPlan, options?: HealthCheckOptions): Promise<HealthResult>;
-    stop(plan: LaunchPlan): Promise<void>;
-    private port;
-    private profile;
-}
-/**
- * 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): Promise<DeployResult>;
-    healthCheck(plan: LaunchPlan, options?: HealthCheckOptions): Promise<HealthResult>;
-    stop(plan: LaunchPlan): Promise<void>;
-    private buildMode;
-    private port;
-    private planKey;
-    private downloadModel;
-}
-/**
- * The Strata docker image the adapter pulls and runs. Strata is the
- * placeholder engine: the image and the parameter data land when the engine
- * is available, and the adapter renders a bare docker plan until then.
- */
-export declare const STRATA_DOCKER_IMAGE = "ghcr.io/strata/strata";
-/**
- * StrataAdapter is the placeholder docker-only engine. `renderLaunch` renders
- * a `docker run` of the Strata image (no spec surface yet, so no flags);
- * `deploy` pulls the image and starts the container; `healthCheck` polls the
- * health URL; `stop` stops the named container. The parameter surface and the
- * per-model data land with the engine, as data edits, never an adapter rewire.
+ * delay waits `ms` milliseconds. The health polls use it between attempts; a
+ * poll interval of 0 skips the wait, which the tests use to run the loop
+ * without a real sleep.
  */
-export declare class StrataAdapter extends EngineAdapter {
-    readonly id = "strata";
-    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): Promise<DeployResult>;
-    healthCheck(plan: LaunchPlan, options?: HealthCheckOptions): Promise<HealthResult>;
-    stop(plan: LaunchPlan): Promise<void>;
-    private port;
-    private planKey;
-}
+export declare function delay(ms: number): Promise<void>;
 //# sourceMappingURL=adapters.d.ts.map