dsh-plugin-local-infer 0.1.2 → 0.1.4

package/packages/ui/lib/ops/logs.d.ts

@@ -0,0 +1,78 @@
+/**
+ * The last-run log persistence the card's process steps use: persistProcessLog
+ * appends one run's output (a Get's commands and output, a model download's
+ * result, a stop's failure note) to the stored last-run logs (the card's Logs
+ * section shows it after a reload) and writes the run to the configured log
+ * file, the same per-run file rule the launch step applies; captureRunBaseline
+ * and finishRunSection close a streamed run so its provisional mid-run notes
+ * and its final text persist once.
+ * @module dsh-plugin-local-infer/ui/ops/logs
+ */
+import type { StoredConfig } from '../config.ts';
+/**
+ * The run seeds are the `--- <process>...` separator lines that lead each
+ * provider process's run: the persisted section and the live run-log buffer
+ * share the constant, so the streamed run reads like the persisted one. The
+ * launch, get, and download steps already wrote these lines; the live hub
+ * reuses them.
+ */
+export declare const GET_RUN_SEED = "--- Getting engine and model...\n";
+export declare const LAUNCH_RUN_SEED = "--- Launching...\n";
+export declare const DOWNLOAD_RUN_SEED = "--- Downloading...\n";
+export declare const INSTALL_RUN_SEED = "--- Installing deps...\n";
+export declare const STOP_RUN_SEED = "--- Stopping...\n";
+/**
+ * CANCELED_LINE is the "Canceled" line a client-disconnect cancel appends to
+ * the persisted run, so the Logs section and the log file read the run as
+ * canceled, the same line the card writes to its Logs buffer on the Cancel.
+ * Every canceled run (Get, launch, download, chat template) writes it from
+ * here.
+ */
+export declare const CANCELED_LINE = "--- Canceled\n";
+/**
+ * persistProcessLog appends one process run's output to the stored last-run
+ * logs (capped to the launch logs' tail, so a long build cannot grow the
+ * config without bound) and writes the run to the configured log file. A
+ * missing log location (the field is optional) skips the file, the same rule
+ * the launch step uses. An empty output is a no-op.
+ */
+export declare function persistProcessLog(output: string): void;
+/**
+ * captureRunBaseline reads the stored last-run logs at the start of a run.
+ * The route passes it to finishRunSection when the run settles, so the
+ * finished run replaces the run's own provisional mid-run appends instead of
+ * appending the same text a second time under the section (the sudo CLI note
+ * persists while the run hangs on the password prompt and then rides the
+ * collected run text too).
+ */
+export declare function captureRunBaseline(): string;
+/**
+ * finishRunSection closes one settled run: the stored last-run logs become
+ * the run's baseline plus the finished run section, replacing (not stacking
+ * over) the run's provisional mid-run appends, so a line that both persisted
+ * mid-run and rides the collected section persists exactly once. Tradeoff,
+ * accepted on purpose: another writer's append that landed between the
+ * baseline and the close is overwritten; the run owns the card's control
+ * while it runs, and the launch path already overwrites the stored logs
+ * wholesale (ops/engine.ts persistLaunchLogs). The section lands in the
+ * configured log file under the same per-run file rule persistProcessLog
+ * uses. An empty section is a no-op.
+ */
+export declare function finishRunSection(baseline: string, section: string): void;
+/**
+ * capRunLogs keeps one stored run's text within the shared LOG_TAIL_BYTES
+ * tail, the same bound the live hub buffer and every lastLogs writer apply.
+ * joinRunLogs and the wholesale launch persisters (ops/engine.ts
+ * persistStoredLogs, persistLaunchLogs) share this one cap rule.
+ */
+export declare function capRunLogs(logs: string): string;
+/**
+ * writeRunFile writes one run's text to the configured log file named for
+ * its engine and model. The launch persisters pass the launch's own engine
+ * and config; the append paths pass the stored ones (the defaults). A
+ * missing log location (the field is optional) skips the file; a file that
+ * cannot be written must not fail the run, since the in-memory last-run logs
+ * still reach the card. Every run writer shares this one file rule.
+ */
+export declare function writeRunFile(stored: StoredConfig, output: string, engineId?: string, modelId?: string | undefined): void;
+//# sourceMappingURL=logs.d.ts.map

package/packages/ui/lib/ops/logs.js

@@ -0,0 +1,119 @@
+/**
+ * The last-run log persistence the card's process steps use: persistProcessLog
+ * appends one run's output (a Get's commands and output, a model download's
+ * result, a stop's failure note) to the stored last-run logs (the card's Logs
+ * section shows it after a reload) and writes the run to the configured log
+ * file, the same per-run file rule the launch step applies; captureRunBaseline
+ * and finishRunSection close a streamed run so its provisional mid-run notes
+ * and its final text persist once.
+ * @module dsh-plugin-local-infer/ui/ops/logs
+ */
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname } from 'node:path';
+import { LOG_TAIL_BYTES, resolveLogPath } from '../../../core/lib/index.js';
+import { readConfig, writeStored } from "../config.js";
+/**
+ * The run seeds are the `--- <process>...` separator lines that lead each
+ * provider process's run: the persisted section and the live run-log buffer
+ * share the constant, so the streamed run reads like the persisted one. The
+ * launch, get, and download steps already wrote these lines; the live hub
+ * reuses them.
+ */
+export const GET_RUN_SEED = '--- Getting engine and model...\n';
+export const LAUNCH_RUN_SEED = '--- Launching...\n';
+export const DOWNLOAD_RUN_SEED = '--- Downloading...\n';
+export const INSTALL_RUN_SEED = '--- Installing deps...\n';
+export const STOP_RUN_SEED = '--- Stopping...\n';
+/**
+ * CANCELED_LINE is the "Canceled" line a client-disconnect cancel appends to
+ * the persisted run, so the Logs section and the log file read the run as
+ * canceled, the same line the card writes to its Logs buffer on the Cancel.
+ * Every canceled run (Get, launch, download, chat template) writes it from
+ * here.
+ */
+export const CANCELED_LINE = '--- Canceled\n';
+/**
+ * persistProcessLog appends one process run's output to the stored last-run
+ * logs (capped to the launch logs' tail, so a long build cannot grow the
+ * config without bound) and writes the run to the configured log file. A
+ * missing log location (the field is optional) skips the file, the same rule
+ * the launch step uses. An empty output is a no-op.
+ */
+export function persistProcessLog(output) {
+    if (output === '')
+        return;
+    const stored = readConfig();
+    writeStored(stored, { lastLogs: joinRunLogs(stored.lastLogs, output) });
+    writeRunFile(stored, output);
+}
+/**
+ * captureRunBaseline reads the stored last-run logs at the start of a run.
+ * The route passes it to finishRunSection when the run settles, so the
+ * finished run replaces the run's own provisional mid-run appends instead of
+ * appending the same text a second time under the section (the sudo CLI note
+ * persists while the run hangs on the password prompt and then rides the
+ * collected run text too).
+ */
+export function captureRunBaseline() {
+    return readConfig().lastLogs;
+}
+/**
+ * finishRunSection closes one settled run: the stored last-run logs become
+ * the run's baseline plus the finished run section, replacing (not stacking
+ * over) the run's provisional mid-run appends, so a line that both persisted
+ * mid-run and rides the collected section persists exactly once. Tradeoff,
+ * accepted on purpose: another writer's append that landed between the
+ * baseline and the close is overwritten; the run owns the card's control
+ * while it runs, and the launch path already overwrites the stored logs
+ * wholesale (ops/engine.ts persistLaunchLogs). The section lands in the
+ * configured log file under the same per-run file rule persistProcessLog
+ * uses. An empty section is a no-op.
+ */
+export function finishRunSection(baseline, section) {
+    if (section === '')
+        return;
+    const stored = readConfig();
+    writeStored(stored, { lastLogs: joinRunLogs(baseline, section) });
+    writeRunFile(stored, section);
+}
+/**
+ * capRunLogs keeps one stored run's text within the shared LOG_TAIL_BYTES
+ * tail, the same bound the live hub buffer and every lastLogs writer apply.
+ * joinRunLogs and the wholesale launch persisters (ops/engine.ts
+ * persistStoredLogs, persistLaunchLogs) share this one cap rule.
+ */
+export function capRunLogs(logs) {
+    return logs.slice(-LOG_TAIL_BYTES);
+}
+/**
+ * joinRunLogs appends one run's text under the stored last-run logs (or the
+ * finished run's baseline), newline-separated, capped to the launch logs'
+ * tail so a long build cannot grow the config without bound. persistProcessLog
+ * and finishRunSection share the join and cap rule.
+ */
+function joinRunLogs(base, output) {
+    return capRunLogs(`${base}${base === '' ? '' : '\n'}${output}`);
+}
+/**
+ * writeRunFile writes one run's text to the configured log file named for
+ * its engine and model. The launch persisters pass the launch's own engine
+ * and config; the append paths pass the stored ones (the defaults). A
+ * missing log location (the field is optional) skips the file; a file that
+ * cannot be written must not fail the run, since the in-memory last-run logs
+ * still reach the card. Every run writer shares this one file rule.
+ */
+export function writeRunFile(stored, output, engineId = stored.engine, modelId = typeof stored.config.model === 'string' ? stored.config.model : undefined) {
+    if (stored.logPath === undefined || stored.logPath === '')
+        return;
+    const logPath = resolveLogPath(stored.logPath, engineId, modelId, new Date(), homedir());
+    try {
+        mkdirSync(dirname(logPath), { recursive: true });
+        writeFileSync(logPath, output);
+    }
+    catch {
+        // A log file that cannot be written (a read-only dir, a bad path) must not
+        // fail the run; the in-memory last-run logs still reach the card.
+    }
+}
+//# sourceMappingURL=logs.js.map

package/packages/ui/lib/ops/model.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The DSH model registration operations: registerFor upserts the provider
+ * and model through the settings seam, unregisterFor removes the exact entry
+ * the registration wrote, and syncRegisteredModel re-runs the registration on
+ * a save so the registered model's input types stay in step with the config.
+ * resolveModelRow and resolveContextWindow resolve the row and context window
+ * the registrar publishes.
+ * @module dsh-plugin-local-infer/ui/ops/model
+ */
+import type { Config, ModelRow, RegisterResult, VramModel } from 'dsh-plugin-local-infer/core';
+import type { LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { RegisterRequest } from '../request.ts';
+/**
+ * resolveContextWindow picks the context window the registrar publishes: the
+ * config's maxContext when it names one, else the native ceiling of the
+ * VramModel the config resolves to (the named model, or the single
+ * registered model), else the 32768 spec default. The DSH contextWindow must
+ * not promise a context the engine cannot serve, so the ceiling is the
+ * model's own, not an optimistic number.
+ */
+export declare function resolveContextWindow(config: Config, models: readonly VramModel[]): number;
+/**
+ * resolveModelRow picks the model row the registrar publishes for an engine
+ * and config: the adapter's discovered model (what the running engine
+ * advertises on its model endpoint, read live) when the adapter discovers
+ * one, else the adapter's static modelRef, else the plan's model id, else the
+ * engine id. The display name follows the same fall-through. The discovery
+ * step awaits a terminal query, so the row is resolved asynchronously; an
+ * engine that is down discovers nothing and falls back through modelRef, so
+ * register, save-sync, unregister, and the summary flag stay consistent with
+ * whatever the engine answers while it is up.
+ */
+export declare function resolveModelRow(adapter: {
+    id: string;
+    modelRef?(config: Config): {
+        id: string;
+        name: string;
+    } | undefined;
+    discoverModel?(config: Config): Promise<{
+        id: string;
+        name: string;
+    } | undefined>;
+}, plan: {
+    modelId?: string;
+}, config: Config): Promise<ModelRow>;
+/**
+ * registerFor 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.
+ */
+export declare function registerFor(localInfer: LocalInferService, request?: RegisterRequest): Promise<RegisterResult>;
+/**
+ * syncRegisteredModel re-runs the registration for a saved config when the
+ * model is already registered in the DSH settings, so the registered model's
+ * input types (the vision flag) stay in step with the saved config. A model
+ * that is not registered (a fresh save) is a no-op, and a profile without the
+ * settings seam throws, which the save route catches and swallows so the save
+ * itself never fails on a sync that cannot run.
+ */
+export declare function syncRegisteredModel(localInfer: LocalInferService, engine: string, config: Config): Promise<void>;
+/**
+ * unregisterFor 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.
+ */
+export declare function unregisterFor(localInfer: LocalInferService, request?: RegisterRequest): Promise<{
+    removed: boolean;
+}>;
+//# sourceMappingURL=model.d.ts.map

package/packages/ui/lib/ops/model.js

@@ -0,0 +1,123 @@
+/**
+ * The DSH model registration operations: registerFor upserts the provider
+ * and model through the settings seam, unregisterFor removes the exact entry
+ * the registration wrote, and syncRegisteredModel re-runs the registration on
+ * a save so the registered model's input types stay in step with the config.
+ * resolveModelRow and resolveContextWindow resolve the row and context window
+ * the registrar publishes.
+ * @module dsh-plugin-local-infer/ui/ops/model
+ */
+import { buildModelEntry, providerIdFor } from '../../../core/lib/index.js';
+/**
+ * DEFAULT_CONTEXT_WINDOW is the context window the registrar publishes when
+ * neither the config nor the resolved VramModel names one: the 32K spec
+ * default, a context the engines can serve without a measured ceiling.
+ */
+const DEFAULT_CONTEXT_WINDOW = 32_768;
+import { readConfig } from "../config.js";
+import { resolveAdapter } from "./engine.js";
+/**
+ * resolveContextWindow picks the context window the registrar publishes: the
+ * config's maxContext when it names one, else the native ceiling of the
+ * VramModel the config resolves to (the named model, or the single
+ * registered model), else the 32768 spec default. The DSH contextWindow must
+ * not promise a context the engine cannot serve, so the ceiling is the
+ * model's own, not an optimistic number.
+ */
+export function resolveContextWindow(config, models) {
+    const configured = config.maxContext;
+    if (typeof configured === 'number' && configured > 0) {
+        return configured;
+    }
+    let model;
+    if (typeof config.model === 'string') {
+        model = models.find((entry) => entry.id === config.model);
+    }
+    else if (models.length === 1) {
+        model = models[0];
+    }
+    return model?.nativeMaxContext ?? DEFAULT_CONTEXT_WINDOW;
+}
+/**
+ * resolveModelRow picks the model row the registrar publishes for an engine
+ * and config: the adapter's discovered model (what the running engine
+ * advertises on its model endpoint, read live) when the adapter discovers
+ * one, else the adapter's static modelRef, else the plan's model id, else the
+ * engine id. The display name follows the same fall-through. The discovery
+ * step awaits a terminal query, so the row is resolved asynchronously; an
+ * engine that is down discovers nothing and falls back through modelRef, so
+ * register, save-sync, unregister, and the summary flag stay consistent with
+ * whatever the engine answers while it is up.
+ */
+export async function resolveModelRow(adapter, plan, config) {
+    const ref = (await adapter.discoverModel?.(config)) ?? adapter.modelRef?.(config);
+    const id = ref?.id ?? plan.modelId ?? adapter.id;
+    return { id, name: ref?.name ?? id, contextWindow: 0 };
+}
+/**
+ * registerFor 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.
+ */
+export async function registerFor(localInfer, request) {
+    const stored = readConfig();
+    const engineId = request?.engine ?? stored.engine;
+    const config = request?.config ?? stored.config;
+    const adapter = resolveAdapter(localInfer, engineId);
+    const hardware = await localInfer.detectHardware();
+    const plan = adapter.renderLaunch(config, hardware);
+    const row = await resolveModelRow(adapter, plan, config);
+    row.contextWindow = resolveContextWindow(config, localInfer.registeredVramModels());
+    // The adapter's declared modalities publish the input types on the DSH
+    // model row (Strata's vision enum, on by default, declares ['text',
+    // 'image']); an adapter that declares none keeps the boolean vision flag: a
+    // vision engine advertises ['text', 'image'] and a text-only engine
+    // ['text']. The registrar copies it into the entry it writes.
+    row.input =
+        adapter.modelInput?.(config) ?? (config.vision === true ? ['text', 'image'] : ['text']);
+    const options = request?.agentDefault === true ? { agentDefault: true } : undefined;
+    return localInfer.registerModel(plan, row, options);
+}
+/**
+ * syncRegisteredModel re-runs the registration for a saved config when the
+ * model is already registered in the DSH settings, so the registered model's
+ * input types (the vision flag) stay in step with the saved config. A model
+ * that is not registered (a fresh save) is a no-op, and a profile without the
+ * settings seam throws, which the save route catches and swallows so the save
+ * itself never fails on a sync that cannot run.
+ */
+export async function syncRegisteredModel(localInfer, engine, config) {
+    const adapter = resolveAdapter(localInfer, engine);
+    const hardware = await localInfer.detectHardware();
+    const plan = adapter.renderLaunch(config, hardware);
+    const row = await resolveModelRow(adapter, plan, config);
+    const buildMode = plan.kind === 'docker' ? 'docker' : 'local';
+    const providerId = providerIdFor(adapter.id, row.id, buildMode);
+    if (await localInfer.modelIsRegistered(providerId, row.id)) {
+        await registerFor(localInfer, { engine, config });
+    }
+}
+/**
+ * unregisterFor 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.
+ */
+export async function unregisterFor(localInfer, request) {
+    const stored = readConfig();
+    const engineId = request?.engine ?? stored.engine;
+    const config = request?.config ?? stored.config;
+    const adapter = resolveAdapter(localInfer, engineId);
+    const hardware = await localInfer.detectHardware();
+    const plan = adapter.renderLaunch(config, hardware);
+    const row = await resolveModelRow(adapter, plan, config);
+    // The removal must target the exact entry the register step wrote, so the
+    // provider id is computed through buildModelEntry (the same function the
+    // register step uses) rather than a parallel providerIdFor call, which
+    // could drift if plan.engineId and adapter.id ever diverge.
+    const entry = buildModelEntry(plan, row);
+    await localInfer.removeModel(entry.providerId, row.id);
+    return { removed: true };
+}
+//# sourceMappingURL=model.js.map

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

@@ -0,0 +1,106 @@
+/**
+ * The request types the card's routes parse and the parsers that build them.
+ * Every request carries only the keys the card sent: absent values fall back
+ * to the stored config per key, the same rule every route applies. The
+ * parsers read a `Record<string, unknown>` body (or a URL query) and build
+ * the request with only the keys that are present, so
+ * exactOptionalPropertyTypes never sees a `key: undefined` write.
+ * @module dsh-plugin-local-infer/ui/request
+ */
+import type { Config } from 'dsh-plugin-local-infer/core';
+import type { StoredPlatformConfig } from './config.ts';
+/**
+ * DepsRequest is the query the card sends for the deps panel: the engine and
+ * the config the build mode reads from. Absent values fall back to the stored
+ * config, the same rule the summary route applies.
+ */
+export interface DepsRequest {
+    engine?: string;
+    config?: Config;
+}
+/**
+ * DownloadRequest is the query the card sends for the download route: the
+ * engine, model, and directory the hf CLI download targets. Absent values
+ * fall back to the stored config, the same rule the summary route applies.
+ */
+export interface DownloadRequest {
+    engine?: string;
+    model?: string;
+    directory?: string;
+}
+/**
+ * ChatTemplateDownloadRequest is the query the card sends for the chat-template
+ * download route: the engine, the template repo reference, and the directory
+ * the hf CLI targets. Absent values fall back to the stored config, the same
+ * rule the summary route applies.
+ */
+export interface ChatTemplateDownloadRequest {
+    engine?: string;
+    template?: string;
+    directory?: string;
+}
+/**
+ * LaunchRequest is the query the card sends for the launch and stop routes: the
+ * engine and the config the plan renders from. `platform` carries the card's
+ * unsaved Engine Directory / Engine Fork edits for the engine, so a launch uses
+ * them without a prior save. `providerId` names the saved provider entry the
+ * launch drives, so the route persists the launch record (or clears it on a
+ * stop) on that entry. `autoRebuild` is the card's "Auto Rebuild" checkbox:
+ * when false, the deploy step skips the git sync (fetch, rebase, rebuild) and
+ * launches the checkout as-is. Absent values fall back to the stored config,
+ * the same rule the summary route applies.
+ */
+export interface LaunchRequest {
+    engine?: string;
+    config?: Config;
+    platform?: StoredPlatformConfig;
+    providerId?: string;
+    autoRebuild?: boolean;
+}
+/**
+ * GetRequest is the query the card sends for the Get route: the engine and
+ * the config the dep plan and the build mode read from, and the platform
+ * override (the card's unsaved Engine Directory / Engine Fork edits), the
+ * same rule the launch request applies. Absent values fall back to the
+ * stored config.
+ */
+export interface GetRequest {
+    engine?: string;
+    config?: Config;
+    platform?: StoredPlatformConfig;
+}
+/**
+ * RegisterRequest is the query the card sends for the register and
+ * unregister routes: the engine and the config the plan renders from, and
+ * agentDefault, which points the agent default model at the registered
+ * engine. Absent values fall back to the stored config, the same rule the
+ * summary route applies.
+ */
+export interface RegisterRequest {
+    engine?: string;
+    config?: Config;
+    agentDefault?: boolean;
+}
+/**
+ * depsRequestFromUrl parses the engine and config query params the GET routes
+ * (summary, deps) read. An absent engine falls back to the stored engine, and
+ * a config that cannot be parsed falls back to the stored config, the same
+ * rule the POST routes apply to a broken body key.
+ */
+export declare function depsRequestFromUrl(url: URL): DepsRequest;
+/**
+ * launchRequestFromBody parses the launch and stop POST body: the engine,
+ * config, and platform override the plan renders from, falling back to the
+ * stored config per key. The stop route ignores the platform key.
+ * `providerId` names the saved provider entry the launch record (or its
+ * stop's clear) targets, and `autoRebuild` carries the card's Auto Rebuild
+ * checkbox.
+ */
+export declare function launchRequestFromBody(body: Record<string, unknown>): LaunchRequest;
+/**
+ * registerRequestFromBody parses the register and unregister POST body: the
+ * engine and config the plan renders from, plus agentDefault for the register
+ * route, falling back to the stored config per key.
+ */
+export declare function registerRequestFromBody(body: Record<string, unknown>): RegisterRequest;
+//# sourceMappingURL=request.d.ts.map

package/packages/ui/lib/request.js

@@ -0,0 +1,80 @@
+/**
+ * The request types the card's routes parse and the parsers that build them.
+ * Every request carries only the keys the card sent: absent values fall back
+ * to the stored config per key, the same rule every route applies. The
+ * parsers read a `Record<string, unknown>` body (or a URL query) and build
+ * the request with only the keys that are present, so
+ * exactOptionalPropertyTypes never sees a `key: undefined` write.
+ * @module dsh-plugin-local-infer/ui/request
+ */
+import { parseStoredPlatformConfig } from "./config.js";
+/**
+ * depsRequestFromUrl parses the engine and config query params the GET routes
+ * (summary, deps) read. An absent engine falls back to the stored engine, and
+ * a config that cannot be parsed falls back to the stored config, the same
+ * rule the POST routes apply to a broken body key.
+ */
+export function depsRequestFromUrl(url) {
+    const request = {};
+    const engineParam = url.searchParams.get('engine');
+    if (engineParam !== null) {
+        request.engine = engineParam;
+    }
+    const configParam = url.searchParams.get('config');
+    if (configParam !== null) {
+        try {
+            request.config = JSON.parse(configParam);
+        }
+        catch {
+            // A config that cannot parse reads as absent, so the stored config wins.
+        }
+    }
+    return request;
+}
+/**
+ * launchRequestFromBody parses the launch and stop POST body: the engine,
+ * config, and platform override the plan renders from, falling back to the
+ * stored config per key. The stop route ignores the platform key.
+ * `providerId` names the saved provider entry the launch record (or its
+ * stop's clear) targets, and `autoRebuild` carries the card's Auto Rebuild
+ * checkbox.
+ */
+export function launchRequestFromBody(body) {
+    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;
+    }
+    if (typeof body.providerId === 'string' && body.providerId.trim() !== '') {
+        request.providerId = body.providerId;
+    }
+    if (typeof body.autoRebuild === 'boolean') {
+        request.autoRebuild = body.autoRebuild;
+    }
+    return request;
+}
+/**
+ * registerRequestFromBody parses the register and unregister POST body: the
+ * engine and config the plan renders from, plus agentDefault for the register
+ * route, falling back to the stored config per key.
+ */
+export function registerRequestFromBody(body) {
+    const request = {};
+    if (typeof body.engine === 'string') {
+        request.engine = body.engine;
+    }
+    if (body.config && typeof body.config === 'object') {
+        request.config = body.config;
+    }
+    if (typeof body.agentDefault === 'boolean') {
+        request.agentDefault = body.agentDefault;
+    }
+    return request;
+}
+//# sourceMappingURL=request.js.map