dsh-plugin-local-infer 0.1.2 → 0.1.4

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

@@ -0,0 +1,17 @@
+/**
+ * EngineOsProfile is the per-engine, per-OS build configuration: the build
+ * steps run in the checkout (the `{dir}` placeholder is substituted before a
+ * step runs), the directory, relative to the checkout, where the build leaves
+ * the engine binary, the binary name on this OS (the .exe on Windows), and the
+ * shell the build steps run in (absent runs the host's default shell).
+ *
+ * The profile is the single source the acquisition build step, the platform
+ * defaults, and the binary symlink step read, so a build command and its
+ * output directory have one home. The distro-specific Linux profiles (Arch,
+ * Debian, Fedora) reuse the shared Linux profile, so they carry no build steps
+ * of their own. The optional deps list carries the host build dependencies the
+ * platform's local build needs.
+ * @module dsh-plugin-local-infer/providers/engines/engineOs
+ */
+export {};
+//# sourceMappingURL=engineOs.js.map

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

@@ -4,7 +4,7 @@
  * `docker-compose.yml`, and the `single-user`/`batch` start scripts. The
  * concepts mirror the NInfer surface; the spelling is a `.env` key the
  * `HyperQwenAdapter` (Phase 5) writes into the compose environment.
- * @module dsh-plugin-local-infer/providers/hyperqwen
+ * @module dsh-plugin-local-infer/providers/engines/hyperqwen/hyperqwen
  */
 import type { EnumOption, ParameterSpec } from 'dsh-plugin-local-infer/core';
 /**
@@ -28,4 +28,4 @@ export declare const KV_OPTIONS: readonly EnumOption[];
  * adapter composes them into the launch plan.
  */
 export declare const HYPERQWEN_PARAMETERS: readonly ParameterSpec[];
-//# sourceMappingURL=hyperqwen.d.ts.map
+//# sourceMappingURL=hyperqwen.d.ts.map

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

@@ -4,7 +4,7 @@
  * `docker-compose.yml`, and the `single-user`/`batch` start scripts. The
  * concepts mirror the NInfer surface; the spelling is a `.env` key the
  * `HyperQwenAdapter` (Phase 5) writes into the compose environment.
- * @module dsh-plugin-local-infer/providers/hyperqwen
+ * @module dsh-plugin-local-infer/providers/engines/hyperqwen/hyperqwen
  */
 /**
  * The speculative-decoding backends Hyper-Qwen serves. The launcher's own
@@ -57,6 +57,7 @@ export const HYPERQWEN_PARAMETERS = [
         defaultValue: 'mtp',
         group: 'Speculation',
         toEnv: (value) => ['SPEC', String(value)],
+        deploy: { target: 'env' },
     },
     {
         key: 'draftTokens',
@@ -69,6 +70,7 @@ export const HYPERQWEN_PARAMETERS = [
             ? null
             : 'SPEC must be dflash or dflash2; mtp uses its fixed draft count',
         toEnv: (value) => ['DFLASH_TOKENS', String(value)],
+        deploy: { target: 'env' },
     },
     {
         key: 'ctx',
@@ -78,6 +80,7 @@ export const HYPERQWEN_PARAMETERS = [
         defaultValue: 'fast',
         group: 'Memory',
         toEnv: (value) => ['CTX', String(value)],
+        deploy: { target: 'env' },
     },
     {
         key: 'kv',
@@ -87,6 +90,7 @@ export const HYPERQWEN_PARAMETERS = [
         defaultValue: 'fp8',
         group: 'Memory',
         toEnv: (value) => ['KV', String(value)],
+        deploy: { target: 'env' },
     },
     {
         key: 'gpuUtil',
@@ -96,6 +100,7 @@ export const HYPERQWEN_PARAMETERS = [
         defaultValue: 0.93,
         group: 'Memory',
         toEnv: (value) => ['GPU_UTIL', String(value)],
+        deploy: { target: 'env' },
     },
     {
         key: 'maxLen',
@@ -104,6 +109,7 @@ export const HYPERQWEN_PARAMETERS = [
         form: { kind: 'number', min: 2048, step: 1024, unit: 'tokens' },
         group: 'Memory',
         toEnv: (value) => ['MAX_LEN', String(value)],
+        deploy: { target: 'env' },
     },
     {
         key: 'maxSeqs',
@@ -112,6 +118,7 @@ export const HYPERQWEN_PARAMETERS = [
         form: { kind: 'number', min: 1, max: 8, step: 1, unit: 'sequences' },
         group: 'Concurrency',
         toEnv: (value) => ['MAX_SEQS', String(value)],
+        deploy: { target: 'env' },
     },
     {
         key: 'vision',
@@ -121,6 +128,7 @@ export const HYPERQWEN_PARAMETERS = [
         defaultValue: false,
         group: 'Engine',
         toEnv: (value) => ['VISION', value === true ? '1' : '0'],
+        deploy: { target: 'env' },
     },
     {
         key: 'pinMemory',
@@ -130,6 +138,7 @@ export const HYPERQWEN_PARAMETERS = [
         defaultValue: false,
         group: 'Engine',
         toEnv: (value) => ['VLLM_WSL2_ENABLE_PIN_MEMORY', value === true ? '1' : '0'],
+        deploy: { target: 'env' },
     },
     {
         key: 'prefixCache',
@@ -139,6 +148,7 @@ export const HYPERQWEN_PARAMETERS = [
         defaultValue: true,
         group: 'Engine',
         toEnv: (value) => ['PREFIX_CACHE', value === true ? '1' : '0'],
+        deploy: { target: 'env' },
     },
     {
         key: 'apiKey',
@@ -147,6 +157,7 @@ export const HYPERQWEN_PARAMETERS = [
         form: { kind: 'text', placeholder: 'openssl rand -hex 24' },
         group: 'Network',
         toEnv: (value) => ['VLLM_API_KEY', String(value ?? '')],
+        deploy: { target: 'env' },
     },
     {
         key: 'port',
@@ -156,6 +167,7 @@ export const HYPERQWEN_PARAMETERS = [
         defaultValue: 18020,
         group: 'Network',
         toEnv: (value) => ['PORT', String(value)],
+        deploy: { target: 'env' },
     },
 ];
-//# sourceMappingURL=hyperqwen.js.map
+//# sourceMappingURL=hyperqwen.js.map

package/packages/providers/lib/engines/hyperqwen/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/hyperqwen/hyperqwenAdapter
+ */
+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';
+/**
+ * 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, log?: CommandLogger): Promise<void>;
+    private port;
+    private profile;
+}
+//# sourceMappingURL=hyperqwenAdapter.d.ts.map

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

@@ -0,0 +1,115 @@
+/**
+ * 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/hyperqwen/hyperqwenAdapter
+ */
+import { EngineAdapter, autoRebuildEnabled, formatLaunchCommand } from '../../../../core/lib/index.js';
+import { auditRun, 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. Auto Rebuild
+        // off (the card's checkbox) renders the `--pull missing` line, so the up
+        // step starts the already-present image with the plan's parameters.
+        const autoRebuild = autoRebuildEnabled(options?.autoRebuild);
+        const command = formatLaunchCommand(plan, autoRebuild);
+        if (command === undefined) {
+            return { ok: false, detail: 'compose plan carries no command' };
+        }
+        if (autoRebuild) {
+            // The compose up is the docker build step: the card's button reads
+            // "Building..." for it. A spawn-only launch (Auto Rebuild off) acquires
+            // nothing, so it announces no build phase, the same rule the
+            // pull-guarded docker adapters follow. The `$ <command>` line reaches
+            // the launch run's log sink before the child spawns, so the run reads
+            // the command first.
+            onProgress?.('build');
+        }
+        const up = await auditRun(this.host, command, options?.onLog);
+        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, log) {
+        // 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. The
+        // `$ <command>` line reaches the stop run's log sink before the child.
+        const composeArgs = plan.composeArgs?.split(/\s+/).filter((token) => token !== '');
+        const args = composeArgs !== undefined && composeArgs.length > 0
+            ? composeArgs.join(' ')
+            : `--profile ${plan.profile ?? 'single'}`;
+        await auditRun(this.host, `docker compose -f ${plan.composeFile ?? 'docker-compose.yml'} ${args} down`, log);
+    }
+    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/hyperqwen/hyperqwenArch.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The Hyper-Qwen Arch Linux build profile. Hyper-Qwen is compose-driven (the
+ * compose up pulls the vLLM image), so it carries no local build steps; this
+ * profile reuses the shared Linux profile.
+ * @module dsh-plugin-local-infer/providers/engines/hyperqwen/hyperqwenArch
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const HYPERQWEN_ARCH: EngineOsProfile;
+//# sourceMappingURL=hyperqwenArch.d.ts.map

package/packages/providers/lib/engines/hyperqwen/hyperqwenArch.js

@@ -0,0 +1,9 @@
+/**
+ * The Hyper-Qwen Arch Linux build profile. Hyper-Qwen is compose-driven (the
+ * compose up pulls the vLLM image), so it carries no local build steps; this
+ * profile reuses the shared Linux profile.
+ * @module dsh-plugin-local-infer/providers/engines/hyperqwen/hyperqwenArch
+ */
+import { HYPERQWEN_LINUX } from "./hyperqwenLinux.js";
+export const HYPERQWEN_ARCH = HYPERQWEN_LINUX;
+//# sourceMappingURL=hyperqwenArch.js.map

package/packages/providers/lib/engines/hyperqwen/hyperqwenDebian.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The Hyper-Qwen Debian build profile. Hyper-Qwen is compose-driven (the
+ * compose up pulls the vLLM image), so it carries no local build steps; this
+ * profile reuses the shared Linux profile.
+ * @module dsh-plugin-local-infer/providers/engines/hyperqwen/hyperqwenDebian
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const HYPERQWEN_DEBIAN: EngineOsProfile;
+//# sourceMappingURL=hyperqwenDebian.d.ts.map

package/packages/providers/lib/engines/hyperqwen/hyperqwenDebian.js

@@ -0,0 +1,9 @@
+/**
+ * The Hyper-Qwen Debian build profile. Hyper-Qwen is compose-driven (the
+ * compose up pulls the vLLM image), so it carries no local build steps; this
+ * profile reuses the shared Linux profile.
+ * @module dsh-plugin-local-infer/providers/engines/hyperqwen/hyperqwenDebian
+ */
+import { HYPERQWEN_LINUX } from "./hyperqwenLinux.js";
+export const HYPERQWEN_DEBIAN = HYPERQWEN_LINUX;
+//# sourceMappingURL=hyperqwenDebian.js.map

package/packages/providers/lib/engines/hyperqwen/hyperqwenFedora.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The Hyper-Qwen Fedora build profile. Hyper-Qwen is compose-driven (the
+ * compose up pulls the vLLM image), so it carries no local build steps; this
+ * profile reuses the shared Linux profile.
+ * @module dsh-plugin-local-infer/providers/engines/hyperqwen/hyperqwenFedora
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const HYPERQWEN_FEDORA: EngineOsProfile;
+//# sourceMappingURL=hyperqwenFedora.d.ts.map

package/packages/providers/lib/engines/hyperqwen/hyperqwenFedora.js

@@ -0,0 +1,9 @@
+/**
+ * The Hyper-Qwen Fedora build profile. Hyper-Qwen is compose-driven (the
+ * compose up pulls the vLLM image), so it carries no local build steps; this
+ * profile reuses the shared Linux profile.
+ * @module dsh-plugin-local-infer/providers/engines/hyperqwen/hyperqwenFedora
+ */
+import { HYPERQWEN_LINUX } from "./hyperqwenLinux.js";
+export const HYPERQWEN_FEDORA = HYPERQWEN_LINUX;
+//# sourceMappingURL=hyperqwenFedora.js.map

package/packages/providers/lib/engines/hyperqwen/hyperqwenLinux.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The Hyper-Qwen shared Linux build profile. Hyper-Qwen is the compose-driven
+ * vLLM engine: the compose up pulls the image, so it carries no local build
+ * steps, no build directory, and no local binary. The distro profiles (Arch,
+ * Debian, Fedora) reuse this profile.
+ * @module dsh-plugin-local-infer/providers/engines/hyperqwen/hyperqwenLinux
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const HYPERQWEN_LINUX: EngineOsProfile;
+//# sourceMappingURL=hyperqwenLinux.d.ts.map

package/packages/providers/lib/engines/hyperqwen/hyperqwenLinux.js

@@ -0,0 +1,14 @@
+/**
+ * The Hyper-Qwen shared Linux build profile. Hyper-Qwen is the compose-driven
+ * vLLM engine: the compose up pulls the image, so it carries no local build
+ * steps, no build directory, and no local binary. The distro profiles (Arch,
+ * Debian, Fedora) reuse this profile.
+ * @module dsh-plugin-local-infer/providers/engines/hyperqwen/hyperqwenLinux
+ */
+export const HYPERQWEN_LINUX = {
+    buildSteps: [],
+    // Hyper-Qwen is docker-only: the compose up pulls the vLLM image, so the
+    // local build needs nothing outside the host.
+    deps: [],
+};
+//# sourceMappingURL=hyperqwenLinux.js.map

package/packages/providers/lib/engines/hyperqwen/hyperqwenMacOS.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The Hyper-Qwen macOS build profile. Hyper-Qwen is compose-driven (the
+ * compose up pulls the vLLM image), so it carries no local build steps on any
+ * platform; this profile reuses the shared Linux profile.
+ * @module dsh-plugin-local-infer/providers/engines/hyperqwen/hyperqwenMacOS
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const HYPERQWEN_MACOS: EngineOsProfile;
+//# sourceMappingURL=hyperqwenMacOS.d.ts.map

package/packages/providers/lib/engines/hyperqwen/hyperqwenMacOS.js

@@ -0,0 +1,9 @@
+/**
+ * The Hyper-Qwen macOS build profile. Hyper-Qwen is compose-driven (the
+ * compose up pulls the vLLM image), so it carries no local build steps on any
+ * platform; this profile reuses the shared Linux profile.
+ * @module dsh-plugin-local-infer/providers/engines/hyperqwen/hyperqwenMacOS
+ */
+import { HYPERQWEN_LINUX } from "./hyperqwenLinux.js";
+export const HYPERQWEN_MACOS = HYPERQWEN_LINUX;
+//# sourceMappingURL=hyperqwenMacOS.js.map

package/packages/providers/lib/engines/hyperqwen/hyperqwenWindows.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The Hyper-Qwen Windows build profile. Hyper-Qwen is compose-driven (the
+ * compose up pulls the vLLM image), so it carries no local build steps on any
+ * platform; this profile reuses the shared Linux profile.
+ * @module dsh-plugin-local-infer/providers/engines/hyperqwen/hyperqwenWindows
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const HYPERQWEN_WINDOWS: EngineOsProfile;
+//# sourceMappingURL=hyperqwenWindows.d.ts.map

package/packages/providers/lib/engines/hyperqwen/hyperqwenWindows.js

@@ -0,0 +1,9 @@
+/**
+ * The Hyper-Qwen Windows build profile. Hyper-Qwen is compose-driven (the
+ * compose up pulls the vLLM image), so it carries no local build steps on any
+ * platform; this profile reuses the shared Linux profile.
+ * @module dsh-plugin-local-infer/providers/engines/hyperqwen/hyperqwenWindows
+ */
+import { HYPERQWEN_LINUX } from "./hyperqwenLinux.js";
+export const HYPERQWEN_WINDOWS = HYPERQWEN_LINUX;
+//# sourceMappingURL=hyperqwenWindows.js.map

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

@@ -14,7 +14,7 @@
  * 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
+ * @module dsh-plugin-local-infer/providers/engines/infernix/infernix
  */
 import type { Config, EnumOption, ParameterSpec } from 'dsh-plugin-local-infer/core';
 /**
@@ -142,9 +142,12 @@ export declare function infernixDraftModelPath(config: Config): string | null;
  * 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.
+ * leaves the model directory ready to launch. Every command renders through
+ * the core hfDownloadFileCommand builder, the single source of the
+ * `--format human` flag contract (the flag overrides the non-TTY default so
+ * the hf CLI prints tqdm progress lines to stderr).
  */
-export declare function infernixGetDownloads(config: Config, modelDir: string): string[];
+export declare function infernixGetDownloads(config: Config, modelDir: string, useHubCache?: boolean): string[];
 /**
  * The Infernix `ParameterSpec` surface, in form order. The `group` field is
  * the form section; specs without a group render under `General`. The
@@ -167,4 +170,4 @@ export declare function infernixModelKey(config: Config): string;
  * a bare config always renders a plan.
  */
 export declare function infernixArtifactFor(modelKey: string): InfernixModelArtifact;
-//# sourceMappingURL=infernix.d.ts.map
+//# sourceMappingURL=infernix.d.ts.map