dsh-plugin-local-infer 0.1.2 → 0.1.3

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

@@ -0,0 +1,53 @@
+/**
+ * Strata parameter surface. The declarative `ParameterSpec` data for the
+ * Strata engine (https://github.com/Niko1221/Strata), sourced from the
+ * repository's `docs/AI_SETUP.md` (the `strata launch` flags) and
+ * `docs/DOCKER.md` (the container environment variables). Each spec carries
+ * both a `toArgv` spelling (the `strata launch` flag the binary and source
+ * build modes pass) and a `toEnv` spelling (the container variable the docker
+ * mode passes), so the one surface renders every build mode.
+ *
+ * The data is the surface; the `StrataAdapter` composes it into a `LaunchPlan`.
+ * Adding a flag here is a data edit, never an adapter rewire.
+ * @module dsh-plugin-local-infer/providers/strata
+ */
+import type { Config, EnumOption, ParameterSpec } from 'dsh-plugin-local-infer/core';
+/**
+ * The model families Strata serves. `qwen` is the Qwen3.8-Flash-Next family
+ * (the default); the others are the size-specific variants the README's
+ * Models section names.
+ */
+export declare const STRATA_FAMILY_OPTIONS: readonly EnumOption[];
+/**
+ * The picture-reader modes. `on` lets the engine pick the CPU reader under a
+ * 24 GB card and the GPU reader from 24 GB; `gpu` and `cpu` force a side.
+ */
+export declare const STRATA_VISION_OPTIONS: readonly EnumOption[];
+/**
+ * The tuning modes. `skip` is the engine default (no tuning run); `quick` is
+ * a one-time run of up to about 20 minutes; `thorough` is a longer run.
+ */
+export declare const STRATA_TUNE_OPTIONS: readonly EnumOption[];
+/**
+ * The access modes. `local` listens on 127.0.0.1 only and needs no key; every
+ * other mode makes a key for you, because the server is then reachable beyond
+ * this machine.
+ */
+export declare const STRATA_ACCESS_OPTIONS: readonly EnumOption[];
+/**
+ * The Strata `ParameterSpec` surface, in form order. The `group` field is the
+ * form section; specs without a group render under `General`. The `toArgv`
+ * spelling is the `strata launch` flag the binary and source-build modes pass;
+ * the `toEnv` spelling is the container variable the docker mode passes. A
+ * spec with no `toEnv` (access, dataDir) has no docker counterpart, and a spec
+ * with no `toArgv` (port) is spelled by the adapter from the value.
+ */
+export declare const STRATA_PARAMETERS: readonly ParameterSpec[];
+/**
+ * The Strata model key a config carries: the string model value, falling back
+ * to an empty string so a bare config renders a plan the engine sizes for the
+ * card (the engine picks the model when none is named). A value that names a
+ * local artifact file passes through unchanged.
+ */
+export declare function strataModelKey(config: Config): string;
+//# sourceMappingURL=strata.d.ts.map

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

@@ -0,0 +1,197 @@
+/**
+ * Strata parameter surface. The declarative `ParameterSpec` data for the
+ * Strata engine (https://github.com/Niko1221/Strata), sourced from the
+ * repository's `docs/AI_SETUP.md` (the `strata launch` flags) and
+ * `docs/DOCKER.md` (the container environment variables). Each spec carries
+ * both a `toArgv` spelling (the `strata launch` flag the binary and source
+ * build modes pass) and a `toEnv` spelling (the container variable the docker
+ * mode passes), so the one surface renders every build mode.
+ *
+ * The data is the surface; the `StrataAdapter` composes it into a `LaunchPlan`.
+ * Adding a flag here is a data edit, never an adapter rewire.
+ * @module dsh-plugin-local-infer/providers/strata
+ */
+/**
+ * The model families Strata serves. `qwen` is the Qwen3.8-Flash-Next family
+ * (the default); the others are the size-specific variants the README's
+ * Models section names.
+ */
+export const STRATA_FAMILY_OPTIONS = [
+    { value: 'qwen', label: 'qwen', note: 'the Qwen3.8-Flash-Next family; the default' },
+    { value: 'swift', label: 'swift', note: 'Swift 1.5; thinks shorter before it answers' },
+    { value: 'coder', label: 'coder', note: 'keeps the experts code uses; the 32 GB code pick' },
+    {
+        value: 'unsloth',
+        label: 'unsloth',
+        note: 'Unsloth UD-IQ4_XS / Q4_K_XL; closest to the full model',
+    },
+];
+/**
+ * The picture-reader modes. `on` lets the engine pick the CPU reader under a
+ * 24 GB card and the GPU reader from 24 GB; `gpu` and `cpu` force a side.
+ */
+export const STRATA_VISION_OPTIONS = [
+    { value: 'off', label: 'off', note: 'no picture reading' },
+    {
+        value: 'on',
+        label: 'on',
+        note: 'read pictures; the reader runs on the CPU under 24 GB, the GPU from 24 GB',
+    },
+    { value: 'gpu', label: 'gpu', note: 'force the GPU picture reader' },
+    { value: 'cpu', label: 'cpu', note: 'force the CPU picture reader' },
+];
+/**
+ * The tuning modes. `skip` is the engine default (no tuning run); `quick` is
+ * a one-time run of up to about 20 minutes; `thorough` is a longer run.
+ */
+export const STRATA_TUNE_OPTIONS = [
+    { value: 'skip', label: 'skip', note: 'no tuning; the engine default' },
+    { value: 'quick', label: 'quick', note: 'up to about 20 minutes, once' },
+    { value: 'thorough', label: 'thorough', note: 'a longer tuning run' },
+];
+/**
+ * The access modes. `local` listens on 127.0.0.1 only and needs no key; every
+ * other mode makes a key for you, because the server is then reachable beyond
+ * this machine.
+ */
+export const STRATA_ACCESS_OPTIONS = [
+    { value: 'local', label: 'local', note: 'listen on 127.0.0.1 only; no key needed' },
+    { value: 'lan', label: 'lan', note: 'reachable from the network; a key is made for you' },
+    {
+        value: 'cloudflare',
+        label: 'cloudflare',
+        note: 'a Cloudflare tunnel; a key is made for you',
+    },
+    { value: 'tailscale', label: 'tailscale', note: 'a Tailscale network; a key is made for you' },
+];
+/**
+ * The Strata `ParameterSpec` surface, in form order. The `group` field is the
+ * form section; specs without a group render under `General`. The `toArgv`
+ * spelling is the `strata launch` flag the binary and source-build modes pass;
+ * the `toEnv` spelling is the container variable the docker mode passes. A
+ * spec with no `toEnv` (access, dataDir) has no docker counterpart, and a spec
+ * with no `toArgv` (port) is spelled by the adapter from the value.
+ */
+export const STRATA_PARAMETERS = [
+    {
+        key: 'port',
+        label: 'Port',
+        description: 'The loopback port the engine serves its OpenAI endpoint and health check on. The registrar publishes it as the model base URL.',
+        // The port is a typed number, not a range strip: a 1..65535 drag slider is
+        // noise, so `slider: false` renders the plain number entry only.
+        form: { kind: 'number', min: 1, max: 65535, step: 1, slider: false },
+        // 8080 is the port the strata launch CLI binds by default, so the form
+        // seeds the value the adapter's own fallback uses when a config names no
+        // port.
+        defaultValue: 8080,
+        group: 'Engine',
+        // The port contributes no flag of its own: renderLaunch spells the local
+        // --port and the docker host-port mapping from this value, and the health
+        // URL and container name derive from it too.
+    },
+    {
+        key: 'family',
+        label: 'Model family',
+        description: 'The model version when a size exists in several families. qwen is the Qwen3.8-Flash-Next family; the others are the size-specific variants.',
+        form: { kind: 'enum', options: [...STRATA_FAMILY_OPTIONS] },
+        defaultValue: 'qwen',
+        group: 'Model',
+        toArgv: (value) => ['--family', String(value)],
+        toEnv: (value) => ['FAMILY', String(value)],
+    },
+    {
+        key: 'context',
+        label: 'Context',
+        description: 'How much text the model remembers at once: 32k, 64k, 128k, 256k, or a token count. Leave unset and the engine picks the largest that fits.',
+        form: { kind: 'text', placeholder: '128k' },
+        group: 'Memory',
+        toArgv: (value) => (value ? ['--context', String(value)] : []),
+        // envFromSpecs only calls toEnv when the value is set, so the pair is
+        // always well-formed here.
+        toEnv: (value) => ['CONTEXT', String(value)],
+    },
+    {
+        key: 'vision',
+        label: 'Vision input',
+        description: 'Whether the model reads pictures. On by default when the model can read them; the reader runs on the CPU under a 24 GB card and on the GPU from 24 GB.',
+        form: { kind: 'enum', options: [...STRATA_VISION_OPTIONS] },
+        defaultValue: 'on',
+        group: 'Engine',
+        toArgv: (value) => ['--vision', String(value)],
+        toEnv: (value) => ['VISION', String(value)],
+    },
+    {
+        key: 'parallel',
+        label: 'Parallel requests',
+        description: 'How many requests decode at once, 1 to 8. More lanes share the model and cut per-request throughput. Leave unset and the engine fits the count to the card.',
+        form: { kind: 'number', min: 1, max: 8, step: 1, unit: 'lanes' },
+        group: 'Concurrency',
+        toArgv: (value) => (value === undefined ? [] : ['--parallel', String(value)]),
+        toEnv: (value) => ['PARALLEL', String(value)],
+    },
+    {
+        key: 'gpu',
+        label: 'GPU',
+        description: 'Card numbers the model shares, e.g. 0 or 0,1. Empty lets the engine choose the card with the most VRAM.',
+        form: { kind: 'text', placeholder: '0' },
+        group: 'Engine',
+        toArgv: (value) => (value ? ['--gpu', String(value)] : []),
+        toEnv: (value) => ['GPU', String(value)],
+    },
+    {
+        key: 'tune',
+        label: 'Tune',
+        description: 'Find the fastest settings first. quick is a one-time run of up to about 20 minutes; thorough is longer. skip is the default.',
+        form: { kind: 'enum', options: [...STRATA_TUNE_OPTIONS] },
+        defaultValue: 'skip',
+        group: 'Engine',
+        toArgv: (value) => ['--tune', String(value)],
+        toEnv: (value) => ['TUNE', String(value)],
+    },
+    {
+        key: 'access',
+        label: 'Access',
+        description: 'Who may connect. local listens on 127.0.0.1 only and needs no key; beyond local the engine makes a key for you. The docker mode reaches this through the API key and the published port instead.',
+        form: { kind: 'enum', options: [...STRATA_ACCESS_OPTIONS] },
+        defaultValue: 'local',
+        group: 'Engine',
+        // local is the engine default, so the bare value spells no flag.
+        toArgv: (value) => (value === 'local' ? [] : ['--access', String(value)]),
+    },
+    {
+        key: 'apiKey',
+        label: 'API key',
+        description: 'The key clients must send when access is beyond local. Leave unset and the engine makes one and keeps it in its data volume.',
+        form: { kind: 'text', placeholder: 'openssl rand -hex 24' },
+        group: 'Engine',
+        toArgv: (value) => (value ? ['--api-key', String(value)] : []),
+        toEnv: (value) => ['API_KEY', String(value)],
+    },
+    {
+        key: 'modelPath',
+        label: 'Model path',
+        description: 'GGUF files you already have: a folder of shards or one .gguf file. Nothing is downloaded for the model itself when this is set.',
+        form: { kind: 'path' },
+        group: 'Artifacts',
+        toArgv: (value) => (value ? ['--model-path', String(value)] : []),
+        toEnv: (value) => ['MODEL_PATH', String(value)],
+    },
+    {
+        key: 'dataDir',
+        label: 'Data directory',
+        description: 'Where new model files go. Models you already have stay where they are and stay usable.',
+        form: { kind: 'path' },
+        group: 'Artifacts',
+        toArgv: (value) => (value ? ['--data-dir', String(value)] : []),
+    },
+];
+/**
+ * The Strata model key a config carries: the string model value, falling back
+ * to an empty string so a bare config renders a plan the engine sizes for the
+ * card (the engine picks the model when none is named). A value that names a
+ * local artifact file passes through unchanged.
+ */
+export function strataModelKey(config) {
+    return typeof config.model === 'string' ? config.model : '';
+}
+//# sourceMappingURL=strata.js.map

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

@@ -0,0 +1,98 @@
+/**
+ * The Strata engine adapter. StrataAdapter is the Strata engine, three build
+ * modes. `renderLaunch` renders a `docker run` of the ghcr image (docker
+ * mode), a `strata launch` process (binary mode), or a `setup.sh` run with the
+ * model (local mode); `deploy` pulls the image, installs the Terminal, or
+ * git-syncs the checkout and resolves `setup.sh` to an absolute path in it
+ * before spawning (spawn resolves a bare name against PATH, not the cwd);
+ * `healthCheck` polls the health URL; `stop` stops the named container, runs
+ * `strata launch --stop`, or signals the tracked process. The model the
+ * engine serves is the config model (or the engine's own pick when none is
+ * named), and the engine downloads it itself, so the deploy step runs no model
+ * download of its own. When the config names no model, `discoverModel`
+ * queries the running engine's model endpoint through the terminal for the id
+ * it actually loaded (family and size sized to the host), so the registrar
+ * publishes the served model, not a placeholder.
+ * @module dsh-plugin-local-infer/providers/engines/strataAdapter
+ */
+import { EngineAdapter } from '../../../core/lib/index.js';
+import type { Config, DeployOptions, DeployResult, EngineLaunchSignature, EngineLaunchState, EnginePlatformConfig, HealthCheckOptions, HealthResult, HardwareProfile, LaunchPlan, LaunchProgress, LifecycleHost, ParameterSpec } from '../../../core/lib/index.js';
+/**
+ * The Strata docker image the adapter pulls and runs. The image is the
+ * upstream GitHub Container Registry artifact for the newest release's CUDA 13
+ * flavor (NVIDIA RTX 20/30/40/50 series, driver 580 or newer); the README pins
+ * a version tag when updates should only land on purpose.
+ */
+export declare const STRATA_DOCKER_IMAGE = "ghcr.io/niko1221/strata:latest-cuda13";
+/**
+ * The one-line install the Strata binary build mode runs: it downloads the
+ * `strata` Terminal from the latest release, checks its SHA-256, unpacks it into
+ * the user's home folder, and puts `strata` on the PATH. Sourced from
+ * docs/AI_SETUP.md step 2 (Linux and Mac; Windows uses the PowerShell twin).
+ */
+export declare const STRATA_BINARY_INSTALL = "curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh -o install.sh && sh install.sh";
+/**
+ * strataPreReadyState reads the phase the strata process is in from the tail of
+ * its accumulated output. The Terminal downloads the engine and the model files
+ * before it can serve, and prints a progress line for each (Downloading,
+ * Unpacking, Checking the package signature, Getting the model files, ...), so
+ * a tail that carries one of those reads as downloading. A tail past the
+ * download (the engine starting, the API binding) reads as starting. The tail
+ * is the most recent output, so a finished download no longer reads as
+ * downloading even though its progress lines are still in the buffer.
+ */
+export declare function strataPreReadyState(logs: string): Exclude<EngineLaunchState, 'ready' | 'failed'>;
+/**
+ * strataServedModelId reads the served model id out of a /v1/models answer:
+ * the id of the first entry in the JSON `data` list. The engine names the
+ * model it auto-selected with family and size (qwen3.8-flash-next-iq3_s), so
+ * the registrar can publish the id the engine actually serves. A body that is
+ * not JSON, or carries no usable id (an error page, a truncated answer), reads
+ * as no discovery.
+ */
+export declare function strataServedModelId(body: string): string | undefined;
+/**
+ * StrataAdapter is the Strata engine, three build modes. `renderLaunch` renders
+ * a `docker run` of the ghcr image (docker mode), a `strata launch` process
+ * (binary mode), or a `setup.sh` run with the model (local mode); `deploy` pulls
+ * the image, installs the Terminal, or git-syncs the checkout and resolves
+ * `setup.sh` to an absolute path in it before spawning (spawn resolves a bare
+ * name against PATH, not the cwd); `healthCheck` polls the health URL; `stop`
+ * stops the named container, runs `strata launch --stop`, or signals the
+ * tracked process. The model the engine serves is the config model (or the
+ * engine's own pick when none is named), and the engine downloads it itself, so
+ * the deploy step runs no model download of its own. When the config names no
+ * model, `discoverModel` queries the running engine's model endpoint through
+ * the terminal for the id it actually loaded (family and size sized to the
+ * host), so the registrar publishes the served model, not a placeholder.
+ */
+export declare class StrataAdapter extends EngineAdapter {
+    readonly id = "strata";
+    readonly supports: {
+        docker: boolean;
+        local: boolean;
+        binary: boolean;
+    };
+    private readonly host;
+    private readonly children;
+    constructor(host?: LifecycleHost);
+    parameters(): readonly ParameterSpec[];
+    modelRef(config: Config): {
+        id: string;
+        name: string;
+    };
+    discoverModel(config: Config): Promise<{
+        id: string;
+        name: string;
+    } | undefined>;
+    modelInput(config: Config): 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;
+}
+//# sourceMappingURL=strataAdapter.d.ts.map