dsh-plugin-local-infer 0.1.2 → 0.1.4

package/packages/ui/lib/viewmodels/summary.js

@@ -0,0 +1,245 @@
+/**
+ * The summary view model: the JSON the card renders. buildSummary assembles
+ * the engine list, the detected hardware, the form model for the selected
+ * engine, the VRAM meter model for the current config, the verdict the banner
+ * renders, the guideline warning model the red banner and inline warnings
+ * render from, and the config the form edits. The estimate is the single
+ * source the meter and the verdict banner agree on, and the guideline results
+ * are the single source the red banner and the inline warnings agree on.
+ * @module dsh-plugin-local-infer/ui/viewmodels/summary
+ */
+import { buildModelEntry, chatTemplatePresent, dshEngineCacheDirectory, hfChatTemplateCommand, hfDownloadCommand, modelArtifactPresent, modelCacheEntriesForEngine, modelEntriesForEngine, resolveModelDirectory, } from '../../../core/lib/index.js';
+import { defaultModelFor, defaultModelsForEngine, ENGINES, enginePlatformDefaults, } from '../../../providers/lib/index.js';
+import { readConfig } from "../config.js";
+import { renderForm } from "../form.js";
+import { renderMeter } from "../meter.js";
+import { renderWarnings } from "../warnings.js";
+import { relinkStoredProviders, resolveAdapter } from "../ops/engine.js";
+import { resolveModelRow } from "../ops/model.js";
+import { chatTemplateLabel, isHfRepoReference, resolveModelRegistryId } from "./summaryHelpers.js";
+/**
+ * buildSummary assembles the card's read model for one engine and config: the
+ * static engine and model lists, the detected hardware, the form model the
+ * selected engine's parameter surface renders to, the meter model the
+ * service's estimate prices, and the warning model the service's guideline
+ * engine fires. The estimate is the single source the meter and the verdict
+ * banner agree on, and the guideline results are the single source the red
+ * banner and the inline warnings agree on.
+ */
+export async function buildSummary(localInfer, request) {
+    const stored = readConfig();
+    const engineId = request?.engine ?? stored.engine;
+    // ENGINES is a known non-empty constant, so the fallback is always defined.
+    const engine = ENGINES.find((entry) => entry.id === engineId) ?? ENGINES[0];
+    // The config the card edits is exactly what is stored or requested: the
+    // summary never backfills a default modelDirectory into it, so a Save of a
+    // default install writes no `modelDirectory` override and the card's field
+    // stays blank (blank means the derived default).
+    const config = request?.config ?? stored.config;
+    // The hub cache root: the plugin's model download home (created when
+    // absent), the base the cache-layout presence checks join onto and the
+    // fallback directory when nothing is cached yet.
+    const hubCacheRoot = localInfer.defaultModelDirectory();
+    const hardware = await localInfer.detectHardware();
+    // The model value the card carries maps onto the VramModel registry key the
+    // estimator prices: a default-model selection is already a registry key, a
+    // directory-scan selection is an artifact file name the default list maps
+    // to its registry key, and a missing value falls back to the engine's first
+    // default model. Pricing the resolved key is what keeps the meter from
+    // reading as not-measured (an empty chart) on a scanned model.
+    const modelId = resolveModelRegistryId(engine.id, config.model);
+    const pricedConfig = { ...config, model: modelId };
+    // Resolve the starting config over the registered presets and the engine's
+    // parameter surface, so the estimate and the model-aware guidelines price a
+    // sane budget (the preset's kvDtype and max-context) rather than a bare
+    // config that names no KV format. The resolved config carries the explicit
+    // values the user set over the preset defaults, and the engine's first
+    // default model when the user named none. The engine id rides into both
+    // entry points: the estimate's OS-reserve resolution runs the plugin-
+    // launched check against it, and the model-aware guidelines price the same
+    // usable budget the meter does.
+    const defaults = await localInfer.resolveDefaults(engine.id, modelId, hardware, pricedConfig);
+    const estimate = await localInfer.estimate(defaults.config, hardware, engine.id);
+    const guidelineResults = await localInfer.guidelines(defaults.config, hardware, engine.id);
+    // The selected default entry: the resolved directory, the model status, and
+    // the download commands all read it; undefined when no default names the
+    // model.
+    const entry = defaultModelFor(engine.id, modelId);
+    // The shared model-directory resolution reads the raw config field (never
+    // a backfilled copy): the override keeps the flat layout, and the hub-cache
+    // layout names the hf download result (the snapshot holding the selected
+    // artifact) or the hub cache root as the display directory, with the base
+    // the presence checks join onto. The display directory is never persisted
+    // back into the stored config.
+    const resolution = resolveModelDirectory(config.modelDirectory, entry, hubCacheRoot);
+    const modelDirectory = resolution.directory;
+    // The model scan lists the models the selected engine can serve: the hub
+    // cache's `models--*` directories (the repo ids, filtered by the engine's
+    // artifact types) when the model directory is the plugin default, else the
+    // flat directory's top-level entries. A missing directory reads as an empty
+    // list.
+    const modelFiles = resolution.useHubCache
+        ? modelCacheEntriesForEngine(localInfer.listModelCache(), engine.id)
+        : modelEntriesForEngine(localInfer.listModelDirectory(modelDirectory), engine.id);
+    // The model status checks the selected model against the model directory
+    // and probes the hf CLI, so the card shows its Download row (or the URL
+    // row) only while the model is absent.
+    let modelStatus = null;
+    if (entry !== undefined) {
+        const present = modelArtifactPresent(entry, resolution.baseDir, resolution.useHubCache);
+        const hfCli = (await localInfer.hfCliAvailable()) !== null;
+        modelStatus = {
+            modelId: entry.modelId,
+            label: entry.label,
+            url: entry.url,
+            present,
+            hfCli,
+            downloadCommand: hfDownloadCommand(entry, modelDirectory, resolution.useHubCache),
+        };
+    }
+    // The chat-template status checks the selected template against the model
+    // directory and probes the hf CLI, so the card auto-downloads an absent
+    // template (and the System dependencies box shows the download command when
+    // the CLI is missing). Only HF repo references are downloadable; a local
+    // path or an empty template reads as null.
+    const chatTemplateValue = typeof config.chatTemplate === 'string' ? config.chatTemplate : '';
+    let chatTemplateStatus = null;
+    if (isHfRepoReference(chatTemplateValue)) {
+        const present = chatTemplatePresent(chatTemplateValue, resolution.baseDir, resolution.useHubCache);
+        const hfCli = (await localInfer.hfCliAvailable()) !== null;
+        chatTemplateStatus = {
+            repo: chatTemplateValue,
+            label: chatTemplateLabel(chatTemplateValue),
+            present,
+            hfCli,
+            downloadCommand: hfChatTemplateCommand(chatTemplateValue, modelDirectory, resolution.useHubCache),
+        };
+    }
+    // The restart re-link: a provider entry whose launch record names a still-
+    // running engine (the DSH that launched it died, and the engine re-parented
+    // to init) is re-adopted as plugin-launched, so its status dot reads as
+    // running for its model and the OS-reserve resolver keeps the default. A
+    // record whose engine is dead is cleared (the previous-pid list with it),
+    // so a recycled pid cannot re-link to a config whose engine is down. The
+    // adopted engines also get a liveness watcher, so a later pkill settles the
+    // stored state without waiting for another summary read.
+    const linkedProviders = await relinkStoredProviders(localInfer, stored);
+    // The provider list the card renders as collapsed entries: each saved
+    // config's engine and model feed the detector, which resolves the running-
+    // state its status dot paints. A provider the detector cannot tie to a
+    // confirmed model reads as unsure, so the dot never overstates a live
+    // engine. The config rides into the detector so the signature prices the
+    // provider's own build mode and port, not the adapter's default-port guess.
+    const providerRefs = linkedProviders.map((provider) => {
+        const model = typeof provider.config.model === 'string' ? provider.config.model : undefined;
+        // exactOptionalPropertyTypes: include the model key only when it is a
+        // string, so a config that names no model never writes `undefined`.
+        return model !== undefined
+            ? { id: provider.id, engine: provider.engine, model, config: provider.config }
+            : { id: provider.id, engine: provider.engine, config: provider.config };
+    });
+    const providerStatuses = providerRefs.length > 0 ? await localInfer.providerStatuses(providerRefs) : {};
+    const providers = linkedProviders.map((provider) => ({
+        id: provider.id,
+        engine: provider.engine,
+        model: typeof provider.config.model === 'string' ? provider.config.model : '',
+        status: providerStatuses[provider.id] ?? 'unsure',
+        config: provider.config,
+        platform: provider.platform,
+        // exactOptionalPropertyTypes: carry the Auto Rebuild flag only when the
+        // stored entry has it, so an entry saved before the key existed carries
+        // no key and the card draws the checkbox unchecked.
+        ...(provider.autoRebuild !== undefined ? { autoRebuild: provider.autoRebuild } : {}),
+    }));
+    // The "unsure" banner: shown when no provider is confirmed running but at
+    // least one reads as unsure (a foreign engine the detector saw but could
+    // not tie to a model, or a busy card). The banner offers the host-OS stop
+    // commands (Stop-Process on Windows, kill on Linux and macOS) for the engine
+    // processes the detector saw holding VRAM, so the user can stop a provider
+    // launched in another session.
+    const anyRunning = providers.some((p) => p.status === 'running');
+    const anyUnsure = providers.some((p) => p.status === 'unsure');
+    const unsureBanner = !anyRunning && anyUnsure
+        ? {
+            message: 'Unable to link to a provider (it may have been launched in another session). \n To stop, run:',
+            killCommands: await localInfer.unsureBannerKillCommands(),
+        }
+        : null;
+    // The "Unknown Engine(s)" readout shows the VRAM the detector's foreign
+    // engine programs are holding: the OS-reserve segment is the GPU's used
+    // VRAM when a foreign engine is detected, so the readout names the
+    // footprint a provider launched in another session is eating off the
+    // card. Absent when no provider reads as unsure.
+    const unknownEngines = anyUnsure ? { bytes: estimate.breakdown.reserve } : null;
+    // The registered flag tells the card whether the current config's provider
+    // and model are already in the DSH settings, so the Remove button shows
+    // only when there is something to remove. A profile without the settings
+    // seam (a host that predates the typert remote) or a host without the
+    // engine adapter registered reads as unregistered. The row resolves through
+    // the same discovery plus modelRef fall-through the register step uses, so
+    // the flag names the same entry the register step wrote while the engine
+    // answers, and a down engine (no discovery) reads as unregistered.
+    let registered = false;
+    try {
+        const regAdapter = resolveAdapter(localInfer, engine.id);
+        const regPlan = regAdapter.renderLaunch(config, hardware);
+        const regRow = await resolveModelRow(regAdapter, regPlan, config);
+        const regEntry = buildModelEntry(regPlan, regRow);
+        registered = await localInfer.modelIsRegistered(regEntry.providerId, regRow.id);
+    }
+    catch {
+        // A missing adapter, a missing settings seam, or a refused read all
+        // read as unregistered, which hides the Remove button (a no-op removal).
+    }
+    return {
+        engines: ENGINES.map((entry) => {
+            // The platform defaults ride the engine entry so the card's Engine
+            // platform section seeds the build-command and docker-tag placeholders
+            // from the same data the deploy step consumes. The build command is the
+            // engine's first build step for the detected host OS, so a Windows host
+            // seeds the vcpkg route and a Linux host seeds the cmake route.
+            const defaults = enginePlatformDefaults(entry.id, hardware.os);
+            return {
+                id: entry.id,
+                label: entry.label,
+                supports: entry.supports,
+                ...(defaults.defaultBuildCommand !== undefined
+                    ? { defaultBuildCommand: defaults.defaultBuildCommand }
+                    : {}),
+                ...(defaults.defaultDockerTag !== undefined
+                    ? { defaultDockerTag: defaults.defaultDockerTag }
+                    : {}),
+                defaultEngineDirectory: dshEngineCacheDirectory(entry.id),
+            };
+        }),
+        models: localInfer.registeredVramModels().map((model) => ({ id: model.id, source: model.source })),
+        hardware,
+        engineId: engine.id,
+        // The hardware profile prices the form's hardware-dependent controls (the
+        // host-KV slider cap), so the render model and the meter agree on the
+        // machine they run on.
+        formModel: renderForm(engine.parameters, config, hardware),
+        meterModel: renderMeter(estimate.breakdown, estimate.verdict, hardware.gpu?.vramGiB ?? 0, estimate.source, estimate.reserveSource, unknownEngines),
+        verdict: estimate.verdict,
+        warningsModel: renderWarnings(guidelineResults),
+        config,
+        platformConfigs: stored.platform,
+        defaults: { config: defaults.config, provenance: defaults.provenance },
+        modelDirectory,
+        modelDefaults: defaultModelsForEngine(engine.id).map((entry) => ({
+            id: entry.modelId,
+            label: entry.label,
+            url: entry.url,
+        })),
+        modelStatus,
+        chatTemplateStatus,
+        modelFiles,
+        showHelp: stored.showHelp,
+        providers,
+        logPath: stored.logPath,
+        lastLogs: stored.lastLogs,
+        unsureBanner,
+        registered,
+    };
+}
+//# sourceMappingURL=summary.js.map

package/packages/ui/lib/viewmodels/summaryHelpers.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The small pure helpers the summary view model prices: the HF repo
+ * reference check the chat-template status runs, the template display label,
+ * and the model-value-to-registry-key map the estimator prices.
+ * @module dsh-plugin-local-infer/ui/viewmodels/summaryHelpers
+ */
+/**
+ * isHfRepoReference reports whether a chat template value is a Hugging Face
+ * repo reference (an owner/name pair) rather than a local path: it carries a
+ * slash and does not start with one. Only repo references are auto-downloaded
+ * into the model directory; a local path is used in place.
+ */
+export declare function isHfRepoReference(value: string): boolean;
+/**
+ * chatTemplateLabel resolves the display label for a chat template repo: the
+ * preset's label when the repo is a shipped preset, else the repo itself.
+ */
+export declare function chatTemplateLabel(repo: string): string;
+/**
+ * resolveModelRegistryId maps the card's model value onto the VramModel
+ * registry key the estimator prices. The card's Model field carries either a
+ * registry key (a default-model selection) or an artifact file name (a
+ * directory-scan selection, e.g. a .ninfer file); the default list maps the
+ * file name to the registry key the estimator knows, so a scanned model prices
+ * a real VramModel rather than reading as not-measured. A value that is
+ * already a registry key passes through, and a missing value falls back to
+ * the engine's first default model.
+ */
+export declare function resolveModelRegistryId(engineId: string, model: unknown): string;
+//# sourceMappingURL=summaryHelpers.d.ts.map

package/packages/ui/lib/viewmodels/summaryHelpers.js

@@ -0,0 +1,42 @@
+/**
+ * The small pure helpers the summary view model prices: the HF repo
+ * reference check the chat-template status runs, the template display label,
+ * and the model-value-to-registry-key map the estimator prices.
+ * @module dsh-plugin-local-infer/ui/viewmodels/summaryHelpers
+ */
+import { CHAT_TEMPLATE_OPTIONS, defaultModelsForEngine } from '../../../providers/lib/index.js';
+/**
+ * isHfRepoReference reports whether a chat template value is a Hugging Face
+ * repo reference (an owner/name pair) rather than a local path: it carries a
+ * slash and does not start with one. Only repo references are auto-downloaded
+ * into the model directory; a local path is used in place.
+ */
+export function isHfRepoReference(value) {
+    return value !== '' && !value.startsWith('/') && value.includes('/');
+}
+/**
+ * chatTemplateLabel resolves the display label for a chat template repo: the
+ * preset's label when the repo is a shipped preset, else the repo itself.
+ */
+export function chatTemplateLabel(repo) {
+    const preset = CHAT_TEMPLATE_OPTIONS.find((option) => option.value === repo);
+    return preset?.label ?? repo;
+}
+/**
+ * resolveModelRegistryId maps the card's model value onto the VramModel
+ * registry key the estimator prices. The card's Model field carries either a
+ * registry key (a default-model selection) or an artifact file name (a
+ * directory-scan selection, e.g. a .ninfer file); the default list maps the
+ * file name to the registry key the estimator knows, so a scanned model prices
+ * a real VramModel rather than reading as not-measured. A value that is
+ * already a registry key passes through, and a missing value falls back to
+ * the engine's first default model.
+ */
+export function resolveModelRegistryId(engineId, model) {
+    if (typeof model === 'string' && model !== '') {
+        const entry = defaultModelsForEngine(engineId).find((candidate) => candidate.file === model);
+        return entry?.modelId ?? model;
+    }
+    return defaultModelsForEngine(engineId)[0]?.modelId ?? engineId;
+}
+//# sourceMappingURL=summaryHelpers.js.map

package/packages/ui/lib/warnings.d.ts

@@ -53,4 +53,4 @@ export declare function toneFor(level: GuidelineLevel): WarningTone;
  * key so the form renders each warning next to the parameter it names.
  */
 export declare function renderWarnings(results: readonly GuidelineResult[]): WarningsModel;
-//# sourceMappingURL=warnings.d.ts.map
+//# sourceMappingURL=warnings.d.ts.map

package/packages/ui/lib/warnings.js

@@ -66,4 +66,4 @@ export function renderWarnings(results) {
         inline,
     };
 }
-//# sourceMappingURL=warnings.js.map
+//# sourceMappingURL=warnings.js.map

package/packages/ui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-local-infer-ui",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Web UI for the dsh local-inference plugin: the form-type-aware parameter form, the live VRAM Est. meter, the red hardware-warning banner, the engine lifecycle controls (build / deploy / stop), and the register-as-model confirmation",
   "keywords": [
     "dsh",
@@ -30,13 +30,13 @@
   },
   "dependencies": {
     "dsh-plugin-local-infer-core": "workspace:^",
-    "dsh-plugin-local-infer-service": "workspace:^",
-    "dsh-plugin-local-infer-providers": "workspace:^"
+    "dsh-plugin-local-infer-providers": "workspace:^",
+    "dsh-plugin-local-infer-service": "workspace:^"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": ">=4.0.1"
   },
   "devDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1"
+    "@deepseek-ai/cordis": "^4.0.6-alpha.2"
   }
 }

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

@@ -1,15 +0,0 @@
-/**
- * Strata parameter surface. Strata is the placeholder engine: the plan names
- * it as a docker-only engine whose parameter data lands when the engine is
- * available. The surface is empty until then, so the form renders no fields
- * and the adapter renders a bare docker plan; adding a spec here is a data
- * edit, never an adapter rewire.
- * @module dsh-plugin-local-infer/providers/strata
- */
-import type { ParameterSpec } from 'dsh-plugin-local-infer/core';
-/**
- * The Strata `ParameterSpec` surface, empty until the engine's flag set lands.
- * The `StrataAdapter` composes this (currently nothing) into a docker plan.
- */
-export declare const STRATA_PARAMETERS: readonly ParameterSpec[];
-//# sourceMappingURL=strata.d.ts.map

package/packages/providers/lib/strata.js

@@ -1,14 +0,0 @@
-/**
- * Strata parameter surface. Strata is the placeholder engine: the plan names
- * it as a docker-only engine whose parameter data lands when the engine is
- * available. The surface is empty until then, so the form renders no fields
- * and the adapter renders a bare docker plan; adding a spec here is a data
- * edit, never an adapter rewire.
- * @module dsh-plugin-local-infer/providers/strata
- */
-/**
- * The Strata `ParameterSpec` surface, empty until the engine's flag set lands.
- * The `StrataAdapter` composes this (currently nothing) into a docker plan.
- */
-export const STRATA_PARAMETERS = [];
-//# sourceMappingURL=strata.js.map