dsh-plugin-local-infer 0.1.2 → 0.1.3

package/packages/ui/lib/routes/chat-template.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The POST /local-infer/chat-template route: the card's auto-download (and
+ * the System-dependencies fallback) pulls a selected template into the model
+ * directory through this route, so a picked preset works out of the box.
+ * @module dsh-plugin-local-infer/ui/routes/chat-template
+ */
+import type { LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { LocalInferRoute } from '../route.ts';
+/**
+ * chatTemplateRoute builds the POST /local-infer/chat-template route
+ * definition the register step holds by an effect.
+ */
+export declare function chatTemplateRoute(localInfer: LocalInferService): LocalInferRoute;
+//# sourceMappingURL=chat-template.d.ts.map

package/packages/ui/lib/routes/chat-template.js

@@ -0,0 +1,37 @@
+/**
+ * The POST /local-infer/chat-template route: the card's auto-download (and
+ * the System-dependencies fallback) pulls a selected template into the model
+ * directory through this route, so a picked preset works out of the box.
+ * @module dsh-plugin-local-infer/ui/routes/chat-template
+ */
+import { defineRoute } from "../route.js";
+import { chatTemplateDownloadFor } from "../ops/hf.js";
+/**
+ * chatTemplateRoute builds the POST /local-infer/chat-template route
+ * definition the register step holds by an effect.
+ */
+export function chatTemplateRoute(localInfer) {
+    return defineRoute({
+        name: 'local-infer-chat-template',
+        path: '/local-infer/chat-template',
+        method: 'POST',
+        failStatus: 500,
+        tooLargeMessage: 'chat template payload too large',
+        run: async ({ body }, res) => {
+            // exactOptionalPropertyTypes: build the request object with only the
+            // keys that are present, so an absent value never writes `undefined`.
+            const request = {};
+            if (typeof body.engine === 'string') {
+                request.engine = body.engine;
+            }
+            if (typeof body.template === 'string') {
+                request.template = body.template;
+            }
+            if (typeof body.directory === 'string') {
+                request.directory = body.directory;
+            }
+            res.json(200, await chatTemplateDownloadFor(localInfer, request));
+        },
+    });
+}
+//# sourceMappingURL=chat-template.js.map

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

@@ -0,0 +1,16 @@
+/**
+ * The GET /local-infer/deps route: the deps panel 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 dep plan, the
+ * per-dep statuses, the copy/paste install string, and the Play/Run trust
+ * gate.
+ * @module dsh-plugin-local-infer/ui/routes/deps
+ */
+import type { LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { LocalInferRoute } from '../route.ts';
+/**
+ * depsRoute builds the GET /local-infer/deps route definition the register
+ * step holds by an effect.
+ */
+export declare function depsRoute(localInfer: LocalInferService): LocalInferRoute;
+//# sourceMappingURL=deps.d.ts.map

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

@@ -0,0 +1,27 @@
+/**
+ * The GET /local-infer/deps route: the deps panel 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 dep plan, the
+ * per-dep statuses, the copy/paste install string, and the Play/Run trust
+ * gate.
+ * @module dsh-plugin-local-infer/ui/routes/deps
+ */
+import { defineRoute } from "../route.js";
+import { depsRequestFromUrl } from "../request.js";
+import { buildDeps } from "../viewmodels/deps.js";
+/**
+ * depsRoute builds the GET /local-infer/deps route definition the register
+ * step holds by an effect.
+ */
+export function depsRoute(localInfer) {
+    return defineRoute({
+        name: 'local-infer-deps',
+        path: '/local-infer/deps',
+        method: 'GET',
+        failStatus: 500,
+        run: async ({ url }, res) => {
+            res.json(200, await buildDeps(localInfer, depsRequestFromUrl(url)));
+        },
+    });
+}
+//# sourceMappingURL=deps.js.map

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

@@ -0,0 +1,16 @@
+/**
+ * The POST /local-infer/download route: it runs the hf CLI download for the
+ * request's default model, resolving the entry through the providers'
+ * default list (a 404 when no entry names the pair) and the directory
+ * against the request, the stored config, and the plugin's default model
+ * directory in that order.
+ * @module dsh-plugin-local-infer/ui/routes/download
+ */
+import type { LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { LocalInferRoute } from '../route.ts';
+/**
+ * downloadRoute builds the POST /local-infer/download route definition the
+ * register step holds by an effect.
+ */
+export declare function downloadRoute(localInfer: LocalInferService): LocalInferRoute;
+//# sourceMappingURL=download.d.ts.map

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

@@ -0,0 +1,48 @@
+/**
+ * The POST /local-infer/download route: it runs the hf CLI download for the
+ * request's default model, resolving the entry through the providers'
+ * default list (a 404 when no entry names the pair) and the directory
+ * against the request, the stored config, and the plugin's default model
+ * directory in that order.
+ * @module dsh-plugin-local-infer/ui/routes/download
+ */
+import { defineRoute } from "../route.js";
+import { downloadFor } from "../ops/hf.js";
+import { persistDownloadLog } from "../ops/logs.js";
+/**
+ * downloadRoute builds the POST /local-infer/download route definition the
+ * register step holds by an effect.
+ */
+export function downloadRoute(localInfer) {
+    return defineRoute({
+        name: 'local-infer-download',
+        path: '/local-infer/download',
+        method: 'POST',
+        failStatus: 500,
+        tooLargeMessage: 'download payload too large',
+        run: async ({ body }, res) => {
+            // exactOptionalPropertyTypes: build the request object with only the
+            // keys that are present, so an absent value never writes `undefined`.
+            const request = {};
+            if (typeof body.engine === 'string') {
+                request.engine = body.engine;
+            }
+            if (typeof body.model === 'string') {
+                request.model = body.model;
+            }
+            if (typeof body.directory === 'string') {
+                request.directory = body.directory;
+            }
+            const result = await downloadFor(localInfer, request);
+            // The "Downloading..." separator leads the persisted run, so the Logs
+            // section and the log file read the download as a fresh process section,
+            // the same line the card writes when the Download button is clicked.
+            const line = result.ok
+                ? 'download complete\n'
+                : `!! download failed${result.detail !== undefined ? `: ${result.detail}` : ''}\n`;
+            persistDownloadLog(`--- Downloading...\n${line}`);
+            res.json(200, result);
+        },
+    });
+}
+//# sourceMappingURL=download.js.map

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

@@ -0,0 +1,18 @@
+/**
+ * The POST /local-infer/get route: the Get step. Its answer streams as plain
+ * text, so the card appends the git sync, the dependency run, and the build
+ * output to its Logs section as it lands. The full run persists as the
+ * last-run logs.
+ * @module dsh-plugin-local-infer/ui/routes/get
+ */
+import type { LifecycleHost } from 'dsh-plugin-local-infer/core';
+import type { LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { LocalInferRoute } from '../route.ts';
+/**
+ * getRoute builds the POST /local-infer/get route definition the register
+ * step holds by an effect. The optional getHost is the lifecycle host the
+ * git and build steps run through; it defaults to the node host, and a test
+ * injects a stub so the route never clones a real repo in CI.
+ */
+export declare function getRoute(localInfer: LocalInferService, getHost?: LifecycleHost): LocalInferRoute;
+//# sourceMappingURL=get.d.ts.map

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

@@ -0,0 +1,57 @@
+/**
+ * The POST /local-infer/get route: the Get step. Its answer streams as plain
+ * text, so the card appends the git sync, the dependency run, and the build
+ * output to its Logs section as it lands. The full run persists as the
+ * last-run logs.
+ * @module dsh-plugin-local-infer/ui/routes/get
+ */
+import { parseStoredPlatformConfig } from "../config.js";
+import { getEngine } from "../ops/engine.js";
+import { persistGetLogs } from "../ops/logs.js";
+import { defineRoute } from "../route.js";
+/**
+ * getRoute builds the POST /local-infer/get route definition the register
+ * step holds by an effect. The optional getHost is the lifecycle host the
+ * git and build steps run through; it defaults to the node host, and a test
+ * injects a stub so the route never clones a real repo in CI.
+ */
+export function getRoute(localInfer, getHost) {
+    return defineRoute({
+        name: 'local-infer-get',
+        path: '/local-infer/get',
+        method: 'POST',
+        failStatus: 400,
+        tooLargeMessage: 'get payload too large',
+        run: async ({ body }, res) => {
+            const request = {};
+            if (typeof body.engine === 'string') {
+                request.engine = body.engine;
+            }
+            if (body.config && typeof body.config === 'object') {
+                request.config = body.config;
+            }
+            const platform = parseStoredPlatformConfig(body.platform);
+            if (platform !== undefined) {
+                request.platform = platform;
+            }
+            res.textStream();
+            let collected = '';
+            const log = (text) => {
+                collected += text;
+                res.write(text);
+            };
+            try {
+                await getEngine(localInfer, request, log, getHost);
+            }
+            catch (error) {
+                log(`!! get failed: ${String(error?.message ?? error)}\n`);
+            }
+            // The "Getting..." separator leads the persisted run, so the Logs
+            // section and the log file read the run as a fresh process section, the
+            // same line the card writes when the Get button is clicked.
+            persistGetLogs(`--- Getting...\n${collected}`);
+            res.end();
+        },
+    });
+}
+//# sourceMappingURL=get.js.map

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

@@ -0,0 +1,16 @@
+/**
+ * The POST /local-infer/install route: 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 answers with the
+ * install result and the refreshed deps model, so the card re-renders the
+ * gate from the same re-check the install ran.
+ * @module dsh-plugin-local-infer/ui/routes/install
+ */
+import type { LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { LocalInferRoute } from '../route.ts';
+/**
+ * installRoute builds the POST /local-infer/install route definition the
+ * register step holds by an effect.
+ */
+export declare function installRoute(localInfer: LocalInferService): LocalInferRoute;
+//# sourceMappingURL=install.d.ts.map

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

@@ -0,0 +1,36 @@
+/**
+ * The POST /local-infer/install route: 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 answers with the
+ * install result and the refreshed deps model, so the card re-renders the
+ * gate from the same re-check the install ran.
+ * @module dsh-plugin-local-infer/ui/routes/install
+ */
+import { defineRoute } from "../route.js";
+import { runInstallFor } from "../viewmodels/depsHelpers.js";
+/**
+ * installRoute builds the POST /local-infer/install route definition the
+ * register step holds by an effect.
+ */
+export function installRoute(localInfer) {
+    return defineRoute({
+        name: 'local-infer-install',
+        path: '/local-infer/install',
+        method: 'POST',
+        failStatus: 500,
+        tooLargeMessage: 'install payload too large',
+        run: async ({ body }, res) => {
+            // exactOptionalPropertyTypes: build the request object with only the
+            // keys that are present, so an absent value never writes `undefined`.
+            const request = {};
+            if (typeof body.engine === 'string') {
+                request.engine = body.engine;
+            }
+            if (body.config && typeof body.config === 'object') {
+                request.config = body.config;
+            }
+            res.json(200, await runInstallFor(localInfer, request));
+        },
+    });
+}
+//# sourceMappingURL=install.js.map

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

@@ -0,0 +1,18 @@
+/**
+ * The POST /local-infer/launch route: it renders the plan the registered
+ * adapter produces and runs the service's launch entry point (deploy, then
+ * the health poll). The launch streams its progress as NDJSON: a step event
+ * as each phase (prereqs, download, build, launch) begins, then a final
+ * result event. The card's Launch control reads the step that is running and
+ * times out only the launch (health-poll) step; the rebuild steps run as
+ * long as they need to.
+ * @module dsh-plugin-local-infer/ui/routes/launch
+ */
+import type { LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { LocalInferRoute } from '../route.ts';
+/**
+ * launchRoute builds the POST /local-infer/launch route definition the
+ * register step holds by an effect.
+ */
+export declare function launchRoute(localInfer: LocalInferService): LocalInferRoute;
+//# sourceMappingURL=launch.d.ts.map

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

@@ -0,0 +1,50 @@
+/**
+ * The POST /local-infer/launch route: it renders the plan the registered
+ * adapter produces and runs the service's launch entry point (deploy, then
+ * the health poll). The launch streams its progress as NDJSON: a step event
+ * as each phase (prereqs, download, build, launch) begins, then a final
+ * result event. The card's Launch control reads the step that is running and
+ * times out only the launch (health-poll) step; the rebuild steps run as
+ * long as they need to.
+ * @module dsh-plugin-local-infer/ui/routes/launch
+ */
+import { launchEngine } from "../ops/engine.js";
+import { defineRoute, RouteError } from "../route.js";
+import { launchRequestFromBody } from "../request.js";
+/**
+ * launchRoute builds the POST /local-infer/launch route definition the
+ * register step holds by an effect.
+ */
+export function launchRoute(localInfer) {
+    return defineRoute({
+        name: 'local-infer-launch',
+        path: '/local-infer/launch',
+        method: 'POST',
+        failStatus: 500,
+        tooLargeMessage: 'launch payload too large',
+        run: async ({ body }, res) => {
+            res.ndjsonStream();
+            const writeLine = (line) => {
+                res.write(JSON.stringify(line) + '\n');
+            };
+            const onProgress = (step) => {
+                writeLine({ step });
+            };
+            try {
+                const result = await launchEngine(localInfer, launchRequestFromBody(body), onProgress);
+                writeLine({ result });
+            }
+            catch (error) {
+                // A launch that breaks before a plan renders (an unknown engine, a
+                // hardware probe failure) still settles the card's control to the red
+                // Logs state through a result event, not a bare 500.
+                const detail = error instanceof RouteError
+                    ? error.message
+                    : String(error?.message ?? error);
+                writeLine({ result: { healthy: false, detail } });
+            }
+            res.end();
+        },
+    });
+}
+//# sourceMappingURL=launch.js.map

package/packages/ui/lib/routes/provider-delete.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The POST /local-infer/provider-delete route: it removes the stored
+ * provider entry named by the body's id, keeps the rest of the list and the
+ * active config intact, and re-syncs the service's platform registry so a
+ * launch never reads a platform config the user just removed.
+ * @module dsh-plugin-local-infer/ui/routes/provider-delete
+ */
+import type { LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { LocalInferRoute } from '../route.ts';
+/**
+ * providerDeleteRoute builds the POST /local-infer/provider-delete route
+ * definition the register step holds by an effect.
+ */
+export declare function providerDeleteRoute(localInfer: LocalInferService): LocalInferRoute;
+//# sourceMappingURL=provider-delete.d.ts.map

package/packages/ui/lib/routes/provider-delete.js

@@ -0,0 +1,37 @@
+/**
+ * The POST /local-infer/provider-delete route: it removes the stored
+ * provider entry named by the body's id, keeps the rest of the list and the
+ * active config intact, and re-syncs the service's platform registry so a
+ * launch never reads a platform config the user just removed.
+ * @module dsh-plugin-local-infer/ui/routes/provider-delete
+ */
+import { readConfig, writeConfig } from "../config.js";
+import { syncPlatformConfigs } from "../ops/engine.js";
+import { defineRoute } from "../route.js";
+import { buildSummary } from "../viewmodels/summary.js";
+/**
+ * providerDeleteRoute builds the POST /local-infer/provider-delete route
+ * definition the register step holds by an effect.
+ */
+export function providerDeleteRoute(localInfer) {
+    return defineRoute({
+        name: 'local-infer-provider-delete',
+        path: '/local-infer/provider-delete',
+        method: 'POST',
+        failStatus: 400,
+        tooLargeMessage: 'payload too large',
+        run: async ({ body }, res) => {
+            const id = typeof body.id === 'string' ? body.id : undefined;
+            if (id === undefined) {
+                res.json(400, { error: 'the provider id is required' });
+                return;
+            }
+            const stored = readConfig();
+            const providers = stored.providers.filter((entry) => entry.id !== id);
+            writeConfig(stored.engine, stored.config, stored.allowRunDeps, stored.platform, stored.showHelp, providers, stored.logPath, stored.lastLogs);
+            syncPlatformConfigs(localInfer, stored);
+            res.json(200, await buildSummary(localInfer));
+        },
+    });
+}
+//# sourceMappingURL=provider-delete.js.map

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

@@ -0,0 +1,16 @@
+/**
+ * The POST /local-infer/register route: it renders the plan through the
+ * registered adapter, resolves the model row and the context window, and
+ * runs the service's register entry point, which upserts the provider and
+ * model through the settings seam. The result carries the entry the
+ * registrar wrote, so the card names the model it published.
+ * @module dsh-plugin-local-infer/ui/routes/register
+ */
+import type { LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { LocalInferRoute } from '../route.ts';
+/**
+ * registerRoute builds the POST /local-infer/register route definition the
+ * register step holds by an effect.
+ */
+export declare function registerRoute(localInfer: LocalInferService): LocalInferRoute;
+//# sourceMappingURL=register.d.ts.map

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

@@ -0,0 +1,28 @@
+/**
+ * The POST /local-infer/register route: it renders the plan through the
+ * registered adapter, resolves the model row and the context window, and
+ * runs the service's register entry point, which upserts the provider and
+ * model through the settings seam. The result carries the entry the
+ * registrar wrote, so the card names the model it published.
+ * @module dsh-plugin-local-infer/ui/routes/register
+ */
+import { registerFor } from "../ops/model.js";
+import { defineRoute } from "../route.js";
+import { registerRequestFromBody } from "../request.js";
+/**
+ * registerRoute builds the POST /local-infer/register route definition the
+ * register step holds by an effect.
+ */
+export function registerRoute(localInfer) {
+    return defineRoute({
+        name: 'local-infer-register',
+        path: '/local-infer/register',
+        method: 'POST',
+        failStatus: 500,
+        tooLargeMessage: 'register payload too large',
+        run: async ({ body }, res) => {
+            res.json(200, await registerFor(localInfer, registerRequestFromBody(body)));
+        },
+    });
+}
+//# sourceMappingURL=register.js.map

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

@@ -0,0 +1,18 @@
+/**
+ * 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 type { LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { LocalInferRoute } from '../route.ts';
+/**
+ * saveRoute builds the POST /local-infer/save route definition the register
+ * step holds by an effect.
+ */
+export declare function saveRoute(localInfer: LocalInferService): LocalInferRoute;
+//# sourceMappingURL=save.d.ts.map

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

@@ -0,0 +1,139 @@
+/**
+ * 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;
+            // 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. 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] ?? {},
+                };
+                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,
+                    };
+                    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,
+                    };
+                    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,16 @@
+/**
+ * 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. The stop then clears the
+ * target entry's launch record, so a recycled pid cannot re-link an engine
+ * the user just stopped.
+ * @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