dsh-plugin-local-infer 0.1.2 → 0.1.4

package/packages/ui/lib/routes/save.js

@@ -0,0 +1,159 @@
+/**
+ * The POST /local-infer/save route: it upserts a provider entry (an id
+ * updates the stored entry in place, an absent id updates a stored entry that
+ * already matches the engine, config, and platform in place, and only a save
+ * with no match mints a new id and prepends the entry), persists the global
+ * fields the card's toggles edit, re-syncs the service's platform registry with
+ * the saved map, and re-runs the registration for an already-registered model
+ * so its input types stay in step with the saved config.
+ * @module dsh-plugin-local-infer/ui/routes/save
+ */
+import { parsePlatformConfigs, readConfig, writeConfig } from "../config.js";
+import { syncPlatformConfigs } from "../ops/engine.js";
+import { syncRegisteredModel } from "../ops/model.js";
+import { defineRoute } from "../route.js";
+import { buildSummary } from "../viewmodels/summary.js";
+/**
+ * newProviderId mints the stable id a new provider entry carries: a
+ * timestamp base plus a random tail, so two Saves in the same tick never
+ * collide. The card edits and deletes against this id.
+ */
+function newProviderId() {
+    return `provider-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+/**
+ * saveRoute builds the POST /local-infer/save route definition the register
+ * step holds by an effect.
+ */
+export function saveRoute(localInfer) {
+    return defineRoute({
+        name: 'local-infer-save',
+        path: '/local-infer/save',
+        method: 'POST',
+        failStatus: 400,
+        tooLargeMessage: 'config payload too large',
+        run: async ({ body }, res) => {
+            const engine = typeof body.engine === 'string' ? body.engine : 'ninfer';
+            const config = body.config && typeof body.config === 'object' ? body.config : {};
+            const allowRunDeps = typeof body.allowRunDeps === 'boolean' ? body.allowRunDeps : false;
+            const platform = parsePlatformConfigs(body.platform);
+            // A body that predates the key keeps the descriptions visible.
+            const showHelp = typeof body.showHelp === 'boolean' ? body.showHelp : true;
+            const providerId = typeof body.id === 'string' && body.id.trim() !== '' ? body.id : undefined;
+            const stored = readConfig();
+            // A body that omits the log location (or sends a blank one) keeps the
+            // stored template, so an unsaved edit never wipes a custom path.
+            const logPath = typeof body.logPath === 'string' && body.logPath !== '' ? body.logPath : stored.logPath;
+            // The card's Auto Rebuild checkbox arrives as a body boolean; a body
+            // that omits the key (or carries a non-boolean) reads as absent so the
+            // upsert keeps the stored entry's flag instead of dropping it.
+            const autoRebuild = typeof body.autoRebuild === 'boolean' ? body.autoRebuild : undefined;
+            // carryAutoRebuild writes the Auto Rebuild flag onto an upserted
+            // entry: the body's boolean wins, a body that omits the key carries
+            // the stored entry's flag over, and an entry with neither keeps no key
+            // (the card draws the box unchecked, so no migration is needed).
+            const carryAutoRebuild = (provider, storedFlag) => {
+                const flag = autoRebuild ?? storedFlag;
+                if (flag !== undefined) {
+                    provider.autoRebuild = flag;
+                }
+            };
+            // Save upserts a provider entry: an id updates the stored entry in
+            // place, an absent id updates a stored entry that already matches the
+            // engine, config, and platform in place, and only a save with no match
+            // mints a new id and prepends the entry, so a Save always adds (or
+            // refreshes) a card entry at the top of the list without duplicating a
+            // provider that is already stored. The provider's platform config is the
+            // per-engine entry the deploy step reads, so a provider never carries a
+            // field it cannot price. A save that updates an entry in place carries
+            // the entry's launch record over, so editing a running provider's config
+            // never drops the record the restart re-link prices, and carries the
+            // entry's Auto Rebuild flag over when the body omits it, so an old save
+            // caller never drops a stored checkbox value. A settings-only
+            // save skips the upsert: it persists the global fields the toggle edits
+            // and keeps the stored list intact, so the help and allow-run toggles
+            // never mint a duplicate entry.
+            let providers;
+            if (body.settingsOnly === true) {
+                providers = stored.providers;
+            }
+            else if (providerId !== undefined) {
+                // An id updates the stored entry in place, carrying its launch record
+                // over so editing a running provider's config never drops the record
+                // the restart re-link prices.
+                const existing = stored.providers.find((entry) => entry.id === providerId);
+                const provider = {
+                    id: providerId,
+                    engine,
+                    config,
+                    platform: platform[engine] ?? {},
+                };
+                carryAutoRebuild(provider, existing?.autoRebuild);
+                if (existing?.launch !== undefined) {
+                    provider.launch = existing.launch;
+                }
+                providers = stored.providers.map((entry) => (entry.id === providerId ? provider : entry));
+            }
+            else {
+                // No id: a "New provider" save. If a stored entry already matches the
+                // engine, config, and platform, update it in place (carrying its launch
+                // record) instead of minting a duplicate: a "New provider" that restores
+                // the cached draft and Saves without a change would otherwise prepend a
+                // second copy of the same provider.
+                const platformConfig = platform[engine] ?? {};
+                const matching = stored.providers.find((entry) => entry.engine === engine &&
+                    JSON.stringify(entry.config) === JSON.stringify(config) &&
+                    JSON.stringify(entry.platform) === JSON.stringify(platformConfig));
+                if (matching !== undefined) {
+                    const provider = {
+                        id: matching.id,
+                        engine,
+                        config,
+                        platform: platformConfig,
+                    };
+                    carryAutoRebuild(provider, matching.autoRebuild);
+                    if (matching.launch !== undefined) {
+                        provider.launch = matching.launch;
+                    }
+                    providers = stored.providers.map((entry) => (entry.id === matching.id ? provider : entry));
+                }
+                else {
+                    const provider = {
+                        id: newProviderId(),
+                        engine,
+                        config,
+                        platform: platformConfig,
+                    };
+                    // A brand-new entry with no body key stays without the key.
+                    carryAutoRebuild(provider, undefined);
+                    providers = [provider, ...stored.providers];
+                }
+            }
+            writeConfig(engine, config, allowRunDeps, platform, showHelp, providers, logPath);
+            // Re-sync the service registry with the saved platform map, so the next
+            // launch reads the platform config the user just saved.
+            syncPlatformConfigs(localInfer, {
+                engine,
+                config,
+                allowRunDeps,
+                platform,
+                showHelp,
+                providers,
+                logPath,
+                lastLogs: stored.lastLogs,
+            });
+            // A Save on an already-registered model re-runs the registration, so
+            // the DSH model row's input types (the vision flag) stay in step with
+            // the config the user just saved. Best-effort: a profile without the
+            // settings seam, or an engine no adapter serves, leaves the save intact.
+            try {
+                await syncRegisteredModel(localInfer, engine, config);
+            }
+            catch {
+                // A sync that cannot run is a no-op for the save.
+            }
+            res.json(200, await buildSummary(localInfer, { engine, config }));
+        },
+    });
+}
+//# sourceMappingURL=save.js.map

package/packages/ui/lib/routes/stop.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The POST /local-infer/stop route: it renders the same plan the launch
+ * rendered and runs the service's stop entry point, so the stop targets the
+ * exact container or process the launch started (a re-adopted engine through
+ * the record's pid). The stop then clears the target entry's launch record,
+ * so a recycled pid cannot re-link an engine the user just stopped. A stop
+ * that fails persists a note to the last-run logs and the log file and
+ * answers 500, so the card's stop deadline settles the entry to the red Logs
+ * state with the broken step named.
+ * @module dsh-plugin-local-infer/ui/routes/stop
+ */
+import type { LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { LocalInferRoute } from '../route.ts';
+/**
+ * stopRoute builds the POST /local-infer/stop route definition the register
+ * step holds by an effect.
+ */
+export declare function stopRoute(localInfer: LocalInferService): LocalInferRoute;
+//# sourceMappingURL=stop.d.ts.map

package/packages/ui/lib/routes/stop.js

@@ -0,0 +1,32 @@
+/**
+ * The POST /local-infer/stop route: it renders the same plan the launch
+ * rendered and runs the service's stop entry point, so the stop targets the
+ * exact container or process the launch started (a re-adopted engine through
+ * the record's pid). The stop then clears the target entry's launch record,
+ * so a recycled pid cannot re-link an engine the user just stopped. A stop
+ * that fails persists a note to the last-run logs and the log file and
+ * answers 500, so the card's stop deadline settles the entry to the red Logs
+ * state with the broken step named.
+ * @module dsh-plugin-local-infer/ui/routes/stop
+ */
+import { stopEngine } from "../ops/engine.js";
+import { defineRoute } from "../route.js";
+import { launchRequestFromBody } from "../request.js";
+/**
+ * stopRoute builds the POST /local-infer/stop route definition the register
+ * step holds by an effect.
+ */
+export function stopRoute(localInfer) {
+    return defineRoute({
+        name: 'local-infer-stop',
+        path: '/local-infer/stop',
+        method: 'POST',
+        failStatus: 500,
+        tooLargeMessage: 'stop payload too large',
+        run: async ({ body }, res) => {
+            await stopEngine(localInfer, launchRequestFromBody(body));
+            res.json(200, { stopped: true });
+        },
+    });
+}
+//# sourceMappingURL=stop.js.map

package/packages/ui/lib/routes/stream.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The NDJSON stream helpers the get and launch routes share: the one-line
+ * writer, the throttled progress sink the routes hand the hf download's
+ * onChunk callback to, and the abort controller that watches the response
+ * for the card's Cancel. The helpers keep the two routes' stream wiring
+ * identical, so a change to the throttle cadence, the event line format, or
+ * the cancel rule lands in one place.
+ * @module dsh-plugin-local-infer/ui/routes/stream
+ */
+import type { HfProgress } from 'dsh-plugin-local-infer/core';
+import type { RouteResponder } from '../route.ts';
+export declare const PROGRESS_MIN_INTERVAL_MS = 500;
+/**
+ * ndjsonLine writes one NDJSON event line to the stream: the JSON-encoded
+ * event plus a newline, through the responder's chunk writer (a fake
+ * response without write() collects nothing).
+ */
+export declare function ndjsonLine(res: RouteResponder, line: unknown): void;
+/**
+ * throttledProgressSink builds the onChunk callback a stream route hands the
+ * hf download's progress sink to: the core chunk folder turns the tqdm lines
+ * into a structured state, and the sink emits the state at most once per
+ * PROGRESS_MIN_INTERVAL_MS, so a hot tqdm cadence never floods the stream.
+ * The first parseable state emits immediately (the last-emit timestamp
+ * starts at 0).
+ */
+export declare function throttledProgressSink(write: (progress: HfProgress) => void): (chunk: string) => void;
+/**
+ * abortOnResponseClose wires the card's cancel to the response: a client
+ * disconnect (the response's close before the route ends) aborts the
+ * returned controller, and markFinished settles the run so a close after
+ * the route ended reads as the normal end, not a cancel. A fake response
+ * without on() never fires the close, and the run degrades to running to
+ * completion.
+ */
+export declare function abortOnResponseClose(res: RouteResponder): {
+    signal: AbortSignal;
+    markFinished(): void;
+};
+//# sourceMappingURL=stream.d.ts.map

package/packages/ui/lib/routes/stream.js

@@ -0,0 +1,68 @@
+/**
+ * The NDJSON stream helpers the get and launch routes share: the one-line
+ * writer, the throttled progress sink the routes hand the hf download's
+ * onChunk callback to, and the abort controller that watches the response
+ * for the card's Cancel. The helpers keep the two routes' stream wiring
+ * identical, so a change to the throttle cadence, the event line format, or
+ * the cancel rule lands in one place.
+ * @module dsh-plugin-local-infer/ui/routes/stream
+ */
+import { foldHfProgressChunk } from '../../../core/lib/index.js';
+// The minimum interval between progress events: the tqdm cadence is hot (a
+// bar redraw per chunk), so a route emits at most one event per half second,
+// and the card's own throttle bounds the store updates.
+export const PROGRESS_MIN_INTERVAL_MS = 500;
+/**
+ * ndjsonLine writes one NDJSON event line to the stream: the JSON-encoded
+ * event plus a newline, through the responder's chunk writer (a fake
+ * response without write() collects nothing).
+ */
+export function ndjsonLine(res, line) {
+    res.write(JSON.stringify(line) + '\n');
+}
+/**
+ * throttledProgressSink builds the onChunk callback a stream route hands the
+ * hf download's progress sink to: the core chunk folder turns the tqdm lines
+ * into a structured state, and the sink emits the state at most once per
+ * PROGRESS_MIN_INTERVAL_MS, so a hot tqdm cadence never floods the stream.
+ * The first parseable state emits immediately (the last-emit timestamp
+ * starts at 0).
+ */
+export function throttledProgressSink(write) {
+    let folded;
+    let lastProgressAt = 0;
+    return (chunk) => {
+        const state = foldHfProgressChunk(chunk, folded);
+        if (state === undefined)
+            return;
+        folded = state;
+        const now = Date.now();
+        if (now - lastProgressAt >= PROGRESS_MIN_INTERVAL_MS) {
+            lastProgressAt = now;
+            write(state);
+        }
+    };
+}
+/**
+ * abortOnResponseClose wires the card's cancel to the response: a client
+ * disconnect (the response's close before the route ends) aborts the
+ * returned controller, and markFinished settles the run so a close after
+ * the route ended reads as the normal end, not a cancel. A fake response
+ * without on() never fires the close, and the run degrades to running to
+ * completion.
+ */
+export function abortOnResponseClose(res) {
+    const controller = new AbortController();
+    let finished = false;
+    res.onClose(() => {
+        if (!finished)
+            controller.abort();
+    });
+    return {
+        signal: controller.signal,
+        markFinished: () => {
+            finished = true;
+        },
+    };
+}
+//# sourceMappingURL=stream.js.map

package/packages/ui/lib/routes/summary.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The GET /local-infer/summary route: the card's read model. The handler
+ * parses the engine and config query params (an absent engine or a broken
+ * config falls back to the stored config) and answers with the summary the
+ * card renders.
+ * @module dsh-plugin-local-infer/ui/routes/summary
+ */
+import type { LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { LocalInferRoute } from '../route.ts';
+/**
+ * summaryRoute builds the GET /local-infer/summary route definition the
+ * register step holds by an effect.
+ */
+export declare function summaryRoute(localInfer: LocalInferService): LocalInferRoute;
+//# sourceMappingURL=summary.d.ts.map

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

@@ -0,0 +1,26 @@
+/**
+ * The GET /local-infer/summary route: the card's read model. The handler
+ * parses the engine and config query params (an absent engine or a broken
+ * config falls back to the stored config) and answers with the summary the
+ * card renders.
+ * @module dsh-plugin-local-infer/ui/routes/summary
+ */
+import { defineRoute } from "../route.js";
+import { depsRequestFromUrl } from "../request.js";
+import { buildSummary } from "../viewmodels/summary.js";
+/**
+ * summaryRoute builds the GET /local-infer/summary route definition the
+ * register step holds by an effect.
+ */
+export function summaryRoute(localInfer) {
+    return defineRoute({
+        name: 'local-infer-config',
+        path: '/local-infer/summary',
+        method: 'GET',
+        failStatus: 500,
+        run: async ({ url }, res) => {
+            res.json(200, await buildSummary(localInfer, depsRequestFromUrl(url)));
+        },
+    });
+}
+//# sourceMappingURL=summary.js.map

package/packages/ui/lib/routes/unregister.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The POST /local-infer/unregister route: it runs the service's removeModel
+ * entry point for the engine's provider and the model row the register step
+ * resolved, so the removal targets the exact entry the registration wrote.
+ * @module dsh-plugin-local-infer/ui/routes/unregister
+ */
+import type { LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { LocalInferRoute } from '../route.ts';
+/**
+ * unregisterRoute builds the POST /local-infer/unregister route definition
+ * the register step holds by an effect.
+ */
+export declare function unregisterRoute(localInfer: LocalInferService): LocalInferRoute;
+//# sourceMappingURL=unregister.d.ts.map

package/packages/ui/lib/routes/unregister.js

@@ -0,0 +1,26 @@
+/**
+ * The POST /local-infer/unregister route: it runs the service's removeModel
+ * entry point for the engine's provider and the model row the register step
+ * resolved, so the removal targets the exact entry the registration wrote.
+ * @module dsh-plugin-local-infer/ui/routes/unregister
+ */
+import { unregisterFor } from "../ops/model.js";
+import { defineRoute } from "../route.js";
+import { registerRequestFromBody } from "../request.js";
+/**
+ * unregisterRoute builds the POST /local-infer/unregister route definition
+ * the register step holds by an effect.
+ */
+export function unregisterRoute(localInfer) {
+    return defineRoute({
+        name: 'local-infer-unregister',
+        path: '/local-infer/unregister',
+        method: 'POST',
+        failStatus: 500,
+        tooLargeMessage: 'unregister payload too large',
+        run: async ({ body }, res) => {
+            res.json(200, await unregisterFor(localInfer, registerRequestFromBody(body)));
+        },
+    });
+}
+//# sourceMappingURL=unregister.js.map

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,94 @@
+/**
+ * The Play/Run helper for the deps panel: runInstallFor refuses with a 409
+ * while the trust gate is off (the copy/paste path is always the fallback),
+ * runs the install through the service, and refreshes the deps model from the
+ * re-check, so the "Get" gate opens only after a re-check passes.
+ * @module dsh-plugin-local-infer/ui/viewmodels/depsHelpers
+ */
+import { SUDO_CLI_NOTE } from '../../../core/lib/index.js';
+import { runLogKey } from '../../../service/lib/index.js';
+import { readConfig } from "../config.js";
+import { captureRunBaseline, finishRunSection, INSTALL_RUN_SEED } from "../ops/logs.js";
+import { registerSudoObserver } from "../ops/engine.js";
+import { RouteError } from "../route.js";
+import { buildDeps } from "./deps.js";
+/**
+ * runInstallFor is the Play/Run path: it refuses with a 409 while the
+ * trust gate is off (the copy/paste path is always the fallback), runs the
+ * install through the service, and refreshes the deps model from the
+ * re-check, so the "Get" gate opens only after a re-check passes. A run that
+ * actually starts brackets one live hub run under the runLogKey rule (the
+ * stored entry matching the engine and model, else the engine id): the seed
+ * is the "Installing deps..." separator, the service writes each install
+ * command's `$ <command>` line into the run (through onLog) before its child
+ * spawns, each per-dep install result appends in the Get step's
+ * `  <id>: <status>` shape, and the run ends at settle, a throwing install
+ * included. The settle text also folds through the shared run-section persister
+ * (finishRunSection over the pre-run baseline), so the last install run
+ * survives a card reload in the stored last-run logs and the log file, like
+ * the other provider processes; the baseline close keeps the sudo note the
+ * observer persists mid-run from landing twice. The run registers the sudo
+ * hook the launch and Get paths register, so a guarded dependency install
+ * waiting for a password on the CLI lands the shared SUDO_CLI_NOTE line in
+ * the live run and the persisted run. A 409 refusal starts no run.
+ */
+export async function runInstallFor(localInfer, request) {
+    const stored = readConfig();
+    if (stored.allowRunDeps !== true) {
+        throw new RouteError(409, 'one-click install is not allowed; copy the install string instead');
+    }
+    const model = await buildDeps(localInfer, request);
+    const hardware = await localInfer.detectHardware();
+    const runKey = runLogKey(stored.providers, model.engineId, undefined, request.config ?? stored.config);
+    // The install run owns a sudo hook under its run key (the shared
+    // registerSudoObserver wiring): a guarded install waiting on the CLI writes
+    // the core CLI note into the live hub and, through persistProcessLog inside
+    // the helper, into the persisted run and log file, so a hung install reads
+    // where the prompt landed. The disposer clears only this run's slot.
+    // One append feeds both readers: the live hub run and the run's collected
+    // settle text (persisted at the finally), no second copy of the text.
+    let collected = '';
+    const append = (line) => {
+        collected += line;
+        localInfer.appendRunLog(runKey, line);
+    };
+    const clearSudoObserver = registerSudoObserver(localInfer, runKey, `${SUDO_CLI_NOTE}\n`, append);
+    // The stored last-run logs as they stand before the run persists anything:
+    // the sudo observer persists its note while the run hangs on the prompt,
+    // and finishRunSection closes the run over the baseline so that provisional
+    // line and the collected run text persist once (the Get route's pattern).
+    const baseline = captureRunBaseline();
+    localInfer.beginRun(runKey, INSTALL_RUN_SEED);
+    try {
+        const result = await localInfer.runInstall(model.engineId, model.buildMode, hardware, {
+            // Each install command's `$ <command>` line reaches the live hub and the
+            // collected run before the guarded runner spawns the child, so the run
+            // reads the command ahead of the per-dep results below.
+            onLog: append,
+        });
+        // The per-dep results stream as the re-check reported them, in the same
+        // indented shape the Get step's dep block logs, so both readers (the
+        // live buffer and, later, a re-rendered Logs pane) say the same thing.
+        for (const entry of result.results) {
+            append(`  ${entry.id}: ${entry.status}${entry.detail !== undefined ? ` (${entry.detail})` : ''}\n`);
+        }
+        const deps = model.deps.map((dep) => {
+            const entry = result.results.find((entry) => entry.id === dep.id);
+            return entry === undefined ? dep : { ...dep, status: entry.status };
+        });
+        return {
+            result,
+            deps: { ...model, deps, allSatisfied: result.ok },
+        };
+    }
+    finally {
+        clearSudoObserver();
+        // The settle fold: the run's text (seed, command lines, per-dep results,
+        // any sudo note) persists as one section so a card reload still shows the
+        // last install run. A throwing install persists the partial section (the
+        // commands that ran) before the error reaches the route.
+        finishRunSection(baseline, `${INSTALL_RUN_SEED}${collected}`);
+        localInfer.endRun(runKey);
+    }
+}
+//# sourceMappingURL=depsHelpers.js.map

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

@@ -0,0 +1,145 @@
+/**
+ * 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 type { Config, DefaultProvenance, HardwareProfile, ProviderStatus, VramVerdict } from 'dsh-plugin-local-infer/core';
+import type { LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { StoredPlatformConfig } from '../config.ts';
+import type { FormModel } from '../form.ts';
+import type { MeterModel } from '../meter.ts';
+import type { WarningsModel } from '../warnings.ts';
+/**
+ * LocalInferSummary is the JSON the card renders: the engine list, the model
+ * list, the detected hardware, the form model for the selected engine, the
+ * 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. Every field is plain data, so it crosses
+ * the socket without a function left behind.
+ */
+export interface LocalInferSummary {
+    engines: {
+        id: string;
+        label: string;
+        supports: {
+            docker: boolean;
+            local: boolean;
+            binary?: boolean;
+        };
+        defaultBuildCommand?: string;
+        defaultDockerTag?: string;
+        defaultEngineDirectory: string;
+    }[];
+    models: {
+        id: string;
+        source: string;
+    }[];
+    hardware: HardwareProfile;
+    engineId: string;
+    formModel: FormModel;
+    meterModel: MeterModel;
+    verdict: VramVerdict;
+    warningsModel: WarningsModel;
+    config: Config;
+    platformConfigs: Record<string, StoredPlatformConfig>;
+    defaults: DefaultsModel;
+    modelDirectory: string;
+    modelDefaults: ModelDefaultModel[];
+    modelStatus: ModelStatusModel | null;
+    chatTemplateStatus: ChatTemplateStatusModel | null;
+    modelFiles: string[];
+    showHelp: boolean;
+    providers: ProviderSummaryEntry[];
+    logPath: string;
+    lastLogs: string;
+    unsureBanner: {
+        message: string;
+        killCommands: string[];
+    } | null;
+    registered: boolean;
+}
+/**
+ * ProviderSummaryEntry is the card-facing view of one saved provider config:
+ * the stable id the card edits and deletes against, the engine and model the
+ * title renders ("NInfer: <model>"), the running-state the status dot paints,
+ * the per-provider Auto Rebuild checkbox value the edit form and the entry
+ * launch read, and the full config and platform the expanded form draws from.
+ * An entry saved before the autoRebuild key existed carries no key, so the
+ * card draws the checkbox unchecked.
+ */
+export interface ProviderSummaryEntry {
+    id: string;
+    engine: string;
+    model: string;
+    status: ProviderStatus;
+    config: Config;
+    platform: StoredPlatformConfig;
+    autoRebuild?: boolean;
+}
+/**
+ * ModelDefaultModel is the card-facing view of one default model entry: the
+ * registry key the config `model` field carries, the label the dropdown
+ * shows, and the Hugging Face URL the no-CLI row links to.
+ */
+export interface ModelDefaultModel {
+    id: string;
+    label: string;
+    url: string;
+}
+/**
+ * ModelStatusModel is the model-status read model the card draws: whether the
+ * model is present in the model directory, whether the hf CLI is available,
+ * and the download command the Download button runs. The card shows the row
+ * only while the model is absent.
+ */
+export interface ModelStatusModel {
+    modelId: string;
+    label: string;
+    url: string;
+    present: boolean;
+    hfCli: boolean;
+    downloadCommand: string;
+}
+/**
+ * ChatTemplateStatusModel is the answer to "is the selected chat template in
+ * the model directory": the repo reference, its display label, whether the
+ * template file is present, whether the hf CLI is available, and the download
+ * command the card runs (and the System dependencies box shows when the auto-
+ * download is unavailable).
+ */
+export interface ChatTemplateStatusModel {
+    repo: string;
+    label: string;
+    present: boolean;
+    hfCli: boolean;
+    downloadCommand: string;
+}
+/**
+ * DefaultsModel is the resolved-defaults read model the card draws: the
+ * starting config the defaults resolver produced and the per-key provenance
+ * that names the source that supplied each value (a preset, the user, or a
+ * spec default).
+ */
+export interface DefaultsModel {
+    config: Config;
+    provenance: DefaultProvenance[];
+}
+/**
+ * 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 declare function buildSummary(localInfer: LocalInferService, request?: {
+    engine?: string;
+    config?: Config;
+}): Promise<LocalInferSummary>;
+//# sourceMappingURL=summary.d.ts.map