dsh-plugin-local-infer 0.1.1 → 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;
@@ -217,8 +237,12 @@ export declare const SYSTEM_DEPS: {
  * The per-engine dep plans, keyed by engine id. The local NInfer list is the
  * qwen-ninfer header's toolchain plus the CUDA toolkit and the hf CLI; the
  * docker lists are the container runtime plus the GPU toolkit plus the hf
- * CLI. llama.cpp and Strata carry the specified-not-verified lists until
- * their adapters land in Phase 5.
+ * 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 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',
@@ -189,8 +201,12 @@ export const SYSTEM_DEPS = {
  * The per-engine dep plans, keyed by engine id. The local NInfer list is the
  * qwen-ninfer header's toolchain plus the CUDA toolkit and the hf CLI; the
  * docker lists are the container runtime plus the GPU toolkit plus the hf
- * CLI. llama.cpp and Strata carry the specified-not-verified lists until
- * their adapters land in Phase 5.
+ * 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 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: {
@@ -213,9 +229,26 @@ export const ENGINE_DEP_PLANS = {
         local: [SYSTEM_DEPS.cmake, SYSTEM_DEPS.hfCli],
         docker: [SYSTEM_DEPS.docker, SYSTEM_DEPS.hfCli],
     },
+    infernix: {
+        local: [
+            SYSTEM_DEPS.cmake,
+            SYSTEM_DEPS.ninja,
+            SYSTEM_DEPS.pkgConfig,
+            SYSTEM_DEPS.ffmpeg,
+            SYSTEM_DEPS.curl,
+            SYSTEM_DEPS.cudaToolkit,
+            SYSTEM_DEPS.hfCli,
+        ],
+        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/engines/infernix.d.ts

@@ -0,0 +1,170 @@
+/**
+ * Infernix parameter surface. The declarative `ParameterSpec` data for the
+ * Infernix engine (https://github.com/wallawalla47/infernix), a C++/CUDA
+ * fork of NInfer tuned for Qwen models on a single RTX 50-series GPU,
+ * sourced from the project's `docs/cli.md` and `docs/serving.md`. The
+ * spelling is an `infernix-serve` CLI flag the `InfernixAdapter` passes onto
+ * the process.
+ *
+ * The surface carries the flags the NInfer surface shares (KV format,
+ * context, speculation, sampling) plus the Infernix-only fields: the
+ * `--ngram-volume` PLE table for Qwen3.8-Flash-Next, the `--draft-model`
+ * DFlash2 companion drafter, the n-gram copy proposal set, the offloaded-
+ * expert memory tiers, and the quality routes. Those fields live only on
+ * this surface, so the form renderer shows them only while the Infernix
+ * engine is selected, and the adapters of the other engines never spell
+ * them. Adding a flag here is a data edit, never a core rewire.
+ * @module dsh-plugin-local-infer/providers/infernix
+ */
+import type { Config, EnumOption, ParameterSpec } from 'dsh-plugin-local-infer/core';
+/**
+ * The KV cache quantization formats Infernix serves, in the order the form
+ * dropdown lists them. The set differs from NInfer's: the 2-bit and 4-bit-
+ * K vector-quantized tiers (vq2, k4v2) replace the KVarN rk tiers, and both
+ * hold three to four times the context of INT8 in the same VRAM.
+ */
+export declare const INFERNIX_KV_DTYPE_OPTIONS: readonly EnumOption[];
+/**
+ * The speculative-decoding backends. `none` loads no speculative backend at
+ * all, which is the smallest resident profile.
+ */
+export declare const INFERNIX_SPEC_OPTIONS: readonly EnumOption[];
+/**
+ * The PLE n-gram table residency modes for Qwen3.8-Flash-Next. `auto` takes
+ * pinned RAM only when the RAM ledger keeps every expert in RAM beside it.
+ */
+export declare const INFERNIX_NGRAM_RESIDENCY_OPTIONS: readonly EnumOption[];
+/**
+ * The reasoning-loop guard modes. The guard ends a reply, or closes the
+ * thinking, when the open thinking keeps repeating whole passages.
+ */
+export declare const INFERNIX_REASONING_LOOP_OPTIONS: readonly EnumOption[];
+/**
+ * The gate message the form shows while the speculation fields are greyed
+ * out. It names the fix (pick a backend) and the backends that unlock the
+ * fields, so a first-time user knows the next 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 dflash2-only fields are greyed
+ * out. It names the fix (pick dflash2) and the reason, so a first-time user
+ * knows the next click, not just the constraint.
+ */
+export declare const DFLASH2_GATE_MESSAGE = "Pick the dflash2 speculation backend first; the DFlash2 drafter loads with dflash2";
+/**
+ * InfernixModelArtifact is the per-model deploy data: the `.infernix` (or
+ * `.ninfer`) artifact files, the Hugging Face repo the model download pulls
+ * them from, and the model id the server advertises on its OpenAI endpoint.
+ * A multi-file artifact (Qwen3.8-Flash-Next) names every shard in `files`
+ * and the engine loads the first shard from the model directory. The data
+ * is the surface; adding a model is a data edit here, never an adapter
+ * rewire.
+ */
+export interface InfernixModelArtifact {
+    file: string;
+    files?: string[];
+    repo: string;
+    modelId: string;
+}
+/**
+ * The Infernix model artifacts, keyed by the config model key. The 27B
+ * NVIDIA NVFP4 entry is the default the DEFAULT_MODELS list names; an id no
+ * entry names falls back to it, so a bare config always renders a plan. The
+ * Flash-Next entry is the recommended Dense8 conversion: its download pulls
+ * the whole repo, which carries the FP8 n-gram volume beside the shards, so
+ * the `--ngram-volume` flag points at a file the same download left on disk.
+ */
+export declare const INFERNIX_MODEL_ARTIFACTS: Record<string, InfernixModelArtifact>;
+/**
+ * InfernixDFlash2Model is one common DFlash2 drafter the form's DFlash2 model
+ * dropdown offers: the `.infernix` artifact file the hf CLI pulls, the Hugging
+ * Face repo it lives in, and the label the dropdown shows. The DFlash2 drafter
+ * is a companion model that runs beside a Flash-Next conversion, so it
+ * downloads separately from the main model and loads through `--draft-model`.
+ * The data is the surface; adding a drafter is a data edit here, never an
+ * adapter rewire.
+ */
+export interface InfernixDFlash2Model {
+    file: string;
+    repo: string;
+    label: string;
+}
+/**
+ * The common DFlash2 drafters the Infernix DFlash2 model dropdown offers, in
+ * dropdown order. The Flash-Next DFlash2 is Inco AI's drafter (the 776 MB
+ * `.infernix` artifact) that the Infernix README recommends beside any
+ * Flash-Next conversion. The list is the single source the dropdown, the
+ * `--draft-model` path resolver, and the Get download step read.
+ */
+export declare const INFERNIX_DFLASH2_MODELS: readonly InfernixDFlash2Model[];
+/**
+ * The dropdown value the DFlash2 model field's Custom entry carries. A
+ * selection of this value (or no selection) makes the effective `--draft-model`
+ * path fall through to the Draft model path field, so a drafter no list entry
+ * names still loads.
+ */
+export declare const DFLASH2_CUSTOM_VALUE = "custom";
+/**
+ * dflash2PresetOptions renders the DFlash2 model dropdown options: one entry
+ * per common drafter (the label, the repo as the note) plus the Custom entry
+ * last. The option value is the drafter's artifact file, so the selection
+ * resolves back to the model data by file name.
+ */
+export declare function dflash2PresetOptions(): readonly EnumOption[];
+/**
+ * InfernixNgramVolume is the PLE n-gram table a model key reads: the `.ngram`
+ * file and the Hugging Face repo the Get step pulls it from. The volume is kept
+ * apart from the model shards and read from an NVMe drive, so the
+ * `--ngram-volume` flag points at a file the same download leaves on disk.
+ */
+export interface InfernixNgramVolume {
+    file: string;
+    repo: string;
+}
+/**
+ * The PLE n-gram volumes, keyed by the config model key. The Flash-Next entry
+ * is the FP8 volume (the recommended one), which ships beside the Dense8 model
+ * shards in the same repo, so a Get of the Flash-Next model pulls the table
+ * into the model directory.
+ */
+export declare const INFERNIX_NGRAM_VOLUMES: Record<string, InfernixNgramVolume>;
+/**
+ * infernixDraftModelPath resolves the effective `--draft-model` path a config
+ * carries: the selected DFlash2 preset's artifact (the model directory plus the
+ * drafter file, the layout the hf CLI download leaves) when a preset is
+ * selected, else the Custom Draft model path field. Returns null when neither
+ * names a path, which is the misconfiguration the dflash2 guideline names.
+ */
+export declare function infernixDraftModelPath(config: Config): string | null;
+/**
+ * infernixGetDownloads renders the hf CLI download commands a Get run pulls
+ * for a config: the selected DFlash2 drafter (into the model directory, the
+ * layout the `--draft-model` path expects) when a preset is selected, and the
+ * model key's PLE n-gram volume (into the model directory) when the key names
+ * one. The commands are the single source the Get route streams, so a Get
+ * leaves the model directory ready to launch.
+ */
+export declare function infernixGetDownloads(config: Config, modelDir: string): string[];
+/**
+ * The Infernix `ParameterSpec` surface, in form order. The `group` field is
+ * the form section; specs without a group render under `General`. The
+ * Infernix-only fields (ngramVolume, draftModel, the n-gram proposal set,
+ * the expert memory tiers, the quality routes) appear only on this surface,
+ * so the form shows them only while the Infernix engine is selected.
+ */
+export declare const INFERNIX_PARAMETERS: readonly ParameterSpec[];
+/**
+ * The Infernix model key a config carries: the string model value, falling
+ * back to the 27B artifact key so a bare config always renders a plan. A
+ * value that names a local artifact file (a directory-scanned model, a
+ * `.ninfer` or `.infernix` name) passes through unchanged.
+ */
+export declare function infernixModelKey(config: Config): string;
+/**
+ * infernixArtifactFor resolves the artifact a model key deploys. A key that
+ * names a local artifact file passes through the artifact map's 27B entry
+ * for the model id, and an id no entry names falls back to the 27B entry, so
+ * a bare config always renders a plan.
+ */
+export declare function infernixArtifactFor(modelKey: string): InfernixModelArtifact;
+//# sourceMappingURL=infernix.d.ts.map