dsh-plugin-local-infer 0.1.3 → 0.1.4

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

@@ -1,22 +1,53 @@
 /**
  * The hf CLI download operations: downloadFor runs the download for a default
  * model, and chatTemplateDownloadFor pulls a selected chat template into the
- * model directory. Both resolve the directory against the request, the
- * stored config, and the plugin's default model directory in that order.
+ * model directory. Both resolve the directory through resolveDownloadTarget
+ * (the request, the stored config, and the hub cache root in that order,
+ * through the shared override rule), so the hub-cache layout rule has one
+ * home across the download routes and the card.
  * @module dsh-plugin-local-infer/ui/ops/hf
  */
+import { isModelDirectoryOverridden, modelDownloadTarget } from '../../../core/lib/index.js';
+import { runLogKey } from '../../../service/lib/index.js';
 import { defaultModelFor } from '../../../providers/lib/index.js';
 import { readConfig } from "../config.js";
+import { CANCELED_LINE, DOWNLOAD_RUN_SEED, persistProcessLog } from "./logs.js";
 import { RouteError } from "../route.js";
 import { isHfRepoReference } from "../viewmodels/summaryHelpers.js";
+/**
+ * resolveDownloadTarget resolves the directory a download route targets: the
+ * request's directory, the stored config's model directory, and the hub
+ * cache root, in that order. The first named directory wins (the shared
+ * override predicate), then the shared modelDownloadTarget rule decides the
+ * layout: a named directory keeps the flat --local-dir target; only when
+ * neither names one does the hub-cache layout apply, based on the hub cache
+ * root (the service seam: the hf CLI's own download home, which resolves its
+ * own snapshot destination and creates the directory when absent), so a
+ * download never materializes a snapshot-directory or hub-root override into
+ * the config.
+ */
+function resolveDownloadTarget(localInfer, requestDirectory, stored) {
+    const named = isModelDirectoryOverridden(requestDirectory)
+        ? requestDirectory
+        : stored.config.modelDirectory;
+    return modelDownloadTarget(named, localInfer.defaultModelDirectory());
+}
 /**
  * downloadFor runs the hf CLI download for the request's default model: it
  * resolves the entry through the providers' default list (a 404 when no
- * entry names the pair), resolves the directory against the request, the
- * stored config, and the plugin's default model directory in that order, and
- * runs the download through the service.
+ * entry names the pair), resolves the directory through
+ * resolveDownloadTarget, and runs the download through the service. The run
+ * brackets one live hub run under the runLogKey rule keyed on the entry's
+ * engine and model (a draft falls back to the engine id): the seed is the
+ * "Downloading..." separator, the hf CLI's streamed chunks append as they
+ * land, and the settled completion or failure line reaches the hub and the
+ * persisted run from one text before the run ends. The optional signal is
+ * the card's cancel (the download route's response-close abort, the Get and
+ * launch routes' rule): an abort interrupts the in-flight hf child (SIGINT,
+ * then SIGTERM) and the run carries the shared "Canceled" line, live and
+ * persisted.
  */
-export async function downloadFor(localInfer, request) {
+export async function downloadFor(localInfer, request, signal) {
     const stored = readConfig();
     const engineId = request.engine ?? stored.engine;
     const modelId = request.model ?? (typeof stored.config.model === 'string' ? stored.config.model : '');
@@ -24,23 +55,62 @@ export async function downloadFor(localInfer, request) {
     if (entry === undefined) {
         throw new RouteError(404, `no default model is registered for "${engineId}/${modelId}"`);
     }
-    const storedDir = stored.config.modelDirectory;
-    const directory = typeof request.directory === 'string' && request.directory.trim() !== ''
-        ? request.directory
-        : typeof storedDir === 'string' && storedDir.trim() !== ''
-            ? storedDir
-            : localInfer.defaultModelDirectory();
-    return localInfer.downloadModel(entry, directory);
+    const { baseDir, useHubCache } = resolveDownloadTarget(localInfer, request.directory, stored);
+    // The key rule prices the model this download fetches, so the run lands on
+    // the stored entry for that engine and model, not the draft's.
+    const runKey = runLogKey(stored.providers, engineId, undefined, {
+        ...stored.config,
+        ...(modelId === '' ? {} : { model: modelId }),
+    });
+    localInfer.beginRun(runKey, DOWNLOAD_RUN_SEED);
+    // The service writes the rendered hf command's `$ <command>` line through
+    // onLog before it spawns the child: it streams into the live hub right away
+    // and rides the persisted section below, so the command line reads exactly
+    // once per run in both readers, ahead of the CLI's output.
+    let commandLine = '';
+    try {
+        const result = await localInfer.downloadModel(entry, baseDir, {
+            useHubCache,
+            ...(signal !== undefined ? { signal } : {}),
+            onChunk: (chunk) => {
+                localInfer.appendRunLog(runKey, chunk);
+            },
+            onLog: (line) => {
+                commandLine += line;
+                localInfer.appendRunLog(runKey, line);
+            },
+        });
+        // The settle line reads the same in the live run and the persisted one:
+        // the "Downloading..." separator leads the stored run so the Logs
+        // section and the log file read the download as a fresh process section.
+        // A cancel appends the shared "Canceled" line, the Get and launch
+        // routes' mark, so the run reads as canceled wherever it is read.
+        const line = result.ok
+            ? 'download complete\n'
+            : `!! download failed${result.detail !== undefined ? `: ${result.detail}` : ''}\n`;
+        const settled = signal?.aborted === true ? `${line}${CANCELED_LINE}` : line;
+        localInfer.appendRunLog(runKey, settled);
+        persistProcessLog(`${DOWNLOAD_RUN_SEED}${commandLine}${settled}`);
+        return result;
+    }
+    finally {
+        localInfer.endRun(runKey);
+    }
 }
 /**
  * chatTemplateDownloadFor runs the hf CLI download for the request's chat
  * template: it resolves the template repo reference from the request or the
  * stored config's chatTemplate (a 400 when neither names an HF repo
- * reference), resolves the directory against the request, the stored config,
- * and the plugin's default model directory in that order, and runs the
- * download through the service.
+ * reference), resolves the directory through resolveDownloadTarget, and
+ * runs the download through the service. The run brackets one live hub run
+ * under the "Downloading..." seed and the runLogKey rule (the stored entry
+ * matching the engine and model, else the engine id): the hf CLI's streamed
+ * chunks append as they land, and the run ends at settle. The optional
+ * signal is the card's cancel (the chat-template route's response-close
+ * abort, the Get and launch routes' rule): an abort interrupts the in-flight
+ * hf child and the live run carries the shared "Canceled" line.
  */
-export async function chatTemplateDownloadFor(localInfer, request) {
+export async function chatTemplateDownloadFor(localInfer, request, signal) {
     const stored = readConfig();
     let template = typeof request.template === 'string' ? request.template : '';
     if (template.trim() === '') {
@@ -49,12 +119,32 @@ export async function chatTemplateDownloadFor(localInfer, request) {
     if (!isHfRepoReference(template)) {
         throw new RouteError(400, `the chat template must be an HF repo reference, got "${template || '(none)'}"`);
     }
-    const storedDir = stored.config.modelDirectory;
-    const directory = typeof request.directory === 'string' && request.directory.trim() !== ''
-        ? request.directory
-        : typeof storedDir === 'string' && storedDir.trim() !== ''
-            ? storedDir
-            : localInfer.defaultModelDirectory();
-    return localInfer.downloadChatTemplate(template, directory);
+    const { baseDir, useHubCache } = resolveDownloadTarget(localInfer, request.directory, stored);
+    const runKey = runLogKey(stored.providers, request.engine ?? stored.engine, undefined, stored.config);
+    localInfer.beginRun(runKey, DOWNLOAD_RUN_SEED);
+    try {
+        const result = await localInfer.downloadChatTemplate(template, baseDir, {
+            useHubCache,
+            ...(signal !== undefined ? { signal } : {}),
+            onChunk: (chunk) => {
+                localInfer.appendRunLog(runKey, chunk);
+            },
+            // The service writes the rendered chat-template pull's `$ <command>`
+            // line through onLog before it spawns the child, so the live run reads
+            // the command ahead of the CLI's output, exactly once.
+            onLog: (line) => {
+                localInfer.appendRunLog(runKey, line);
+            },
+        });
+        // A cancel marks the live run canceled; the template pull's outcome
+        // rides the card's template cell, not the persisted run, so no persist.
+        if (signal?.aborted === true) {
+            localInfer.appendRunLog(runKey, CANCELED_LINE);
+        }
+        return result;
+    }
+    finally {
+        localInfer.endRun(runKey);
+    }
 }
-//# sourceMappingURL=hf.js.map
+//# sourceMappingURL=hf.js.map

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

@@ -1,23 +1,78 @@
 /**
- * The last-run log persistence the card's process steps use: appendProcessLog
+ * 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) 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. persistGetLogs and persistDownloadLog are the
- * step-specific wrappers.
+ * 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';
 /**
- * persistGetLogs appends one Get run's streamed output (the commands and their
- * output) to the stored last-run logs and writes the run to the configured log
- * file, the same per-run file rule the launch step applies.
+ * 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 function persistGetLogs(output: string): void;
+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";
 /**
- * persistDownloadLog appends one model or chat-template download's result to the
- * stored last-run logs and writes the run to the configured log file, so the
- * card's Logs section and the log file show the download beside the Get and
- * launch runs.
+ * 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 function persistDownloadLog(output: string): void;
-//# sourceMappingURL=logs.d.ts.map
+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

@@ -1,34 +1,112 @@
 /**
- * The last-run log persistence the card's process steps use: appendProcessLog
+ * 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) 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. persistGetLogs and persistDownloadLog are the
- * step-specific wrappers.
+ * 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 { resolveLogPath } from '../../../core/lib/index.js';
-import { readConfig, writeConfig } from "../config.js";
+import { LOG_TAIL_BYTES, resolveLogPath } from '../../../core/lib/index.js';
+import { readConfig, writeStored } from "../config.js";
 /**
- * appendProcessLog 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.
+ * 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.
  */
-function appendProcessLog(output) {
+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();
-    const joined = `${stored.lastLogs}${stored.lastLogs === '' ? '' : '\n'}${output}`;
-    writeConfig(stored.engine, stored.config, stored.allowRunDeps, stored.platform, stored.showHelp, stored.providers, stored.logPath, joined.slice(-65536));
+    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 modelId = typeof stored.config.model === 'string' ? stored.config.model : undefined;
-    const logPath = resolveLogPath(stored.logPath, stored.engine, modelId, new Date(), homedir());
+    const logPath = resolveLogPath(stored.logPath, engineId, modelId, new Date(), homedir());
     try {
         mkdirSync(dirname(logPath), { recursive: true });
         writeFileSync(logPath, output);
@@ -38,21 +116,4 @@ function appendProcessLog(output) {
         // fail the run; the in-memory last-run logs still reach the card.
     }
 }
-/**
- * persistGetLogs appends one Get run's streamed output (the commands and their
- * output) to the stored last-run logs and writes the run to the configured log
- * file, the same per-run file rule the launch step applies.
- */
-export function persistGetLogs(output) {
-    appendProcessLog(output);
-}
-/**
- * persistDownloadLog appends one model or chat-template download's result to the
- * stored last-run logs and writes the run to the configured log file, so the
- * card's Logs section and the log file show the download beside the Get and
- * launch runs.
- */
-export function persistDownloadLog(output) {
-    appendProcessLog(output);
-}
-//# sourceMappingURL=logs.js.map
+//# sourceMappingURL=logs.js.map

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

@@ -4,8 +4,7 @@
  * 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; resolveModelDirectory picks the model directory a
- * Get run downloads into.
+ * the registrar publishes.
  * @module dsh-plugin-local-infer/ui/ops/model
  */
 import type { Config, ModelRow, RegisterResult, VramModel } from 'dsh-plugin-local-infer/core';
@@ -69,11 +68,4 @@ export declare function syncRegisteredModel(localInfer: LocalInferService, engin
 export declare function unregisterFor(localInfer: LocalInferService, request?: RegisterRequest): Promise<{
     removed: boolean;
 }>;
-/**
- * resolveModelDirectory picks the model directory a Get run downloads into:
- * the config's modelDirectory override when it names a path, else the
- * plugin's default model directory. The same rule the summary and deps routes
- * apply, so a Get and the card's Model Directory field agree on the target.
- */
-export declare function resolveModelDirectory(localInfer: LocalInferService, config: Config): string;
-//# sourceMappingURL=model.d.ts.map
+//# sourceMappingURL=model.d.ts.map

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

@@ -4,11 +4,16 @@
  * 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; resolveModelDirectory picks the model directory a
- * Get run downloads into.
+ * 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";
 /**
@@ -31,7 +36,7 @@ export function resolveContextWindow(config, models) {
     else if (models.length === 1) {
         model = models[0];
     }
-    return model?.nativeMaxContext ?? 32768;
+    return model?.nativeMaxContext ?? DEFAULT_CONTEXT_WINDOW;
 }
 /**
  * resolveModelRow picks the model row the registrar publishes for an engine
@@ -115,16 +120,4 @@ export async function unregisterFor(localInfer, request) {
     await localInfer.removeModel(entry.providerId, row.id);
     return { removed: true };
 }
-/**
- * resolveModelDirectory picks the model directory a Get run downloads into:
- * the config's modelDirectory override when it names a path, else the
- * plugin's default model directory. The same rule the summary and deps routes
- * apply, so a Get and the card's Model Directory field agree on the target.
- */
-export function resolveModelDirectory(localInfer, config) {
-    const rawModelDir = config.modelDirectory;
-    return typeof rawModelDir === 'string' && rawModelDir.trim() !== ''
-        ? rawModelDir
-        : localInfer.defaultModelDirectory();
-}
-//# sourceMappingURL=model.js.map
+//# sourceMappingURL=model.js.map

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

@@ -103,4 +103,4 @@ export declare function launchRequestFromBody(body: Record<string, unknown>): La
  * route, falling back to the stored config per key.
  */
 export declare function registerRequestFromBody(body: Record<string, unknown>): RegisterRequest;
-//# sourceMappingURL=request.d.ts.map
+//# sourceMappingURL=request.d.ts.map

package/packages/ui/lib/request.js

@@ -77,4 +77,4 @@ export function registerRequestFromBody(body) {
     }
     return request;
 }
-//# sourceMappingURL=request.js.map
+//# sourceMappingURL=request.js.map

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

@@ -60,6 +60,14 @@ interface OutgoingLike {
      */
     write?(chunk: string): unknown;
     end(body?: string): void;
+    /**
+     * Optional: watch the response for the client disconnecting (the node
+     * ServerResponse's 'close' before the route ends), so a stream route can
+     * abort the in-flight run when the card cancels it. The web server hands
+     * the handler a node ServerResponse; the tests' fake may omit it, and the
+     * route degrades to no abort.
+     */
+    on?(event: string, listener: (...args: unknown[]) => void): unknown;
 }
 /**
  * RouteError is a route failure that carries its own HTTP status, so the
@@ -87,6 +95,13 @@ export declare class RouteResponder {
     ndjsonStream(): void;
     /** Stream one chunk; a fake response without write() collects nothing. */
     write(chunk: string): void;
+    /**
+     * Watch the response's client disconnect (the node 'close' before the
+     * route ends): the listener fires once when the card's Cancel closes the
+     * stream, so the route aborts the in-flight run. A fake response without
+     * on() never fires it, and the run degrades to running to completion.
+     */
+    onClose(listener: () => void): void;
     /** End the response, optionally with a final body chunk. */
     end(body?: string): void;
 }
@@ -129,17 +144,18 @@ export type RouteSpec = {
 export declare function defineRoute(spec: RouteSpec): LocalInferRoute;
 /**
  * registerLocalInferRoute registers the summary, save, provider-delete, deps,
- * install, download, chat-template, get, launch, stop, register, and
+ * install, download, chat-template, get, launch, stop, logs, register, and
  * unregister routes on the web server and holds them by an effect, so a
  * bundle switch off removes them before the next switch on re-registers. The
  * scoped context carries the webServer; the localInfer service is passed in
  * because the scope only injects what it names. The optional getHost is the
- * lifecycle host the Get route's 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.
+ * lifecycle host the Get route's git and build steps run through, and the
+ * optional launchHost the launch route's Get steps run through; both default
+ * to the node host, and a test injects a stub so the routes never clone a
+ * real repo in CI.
  */
 export declare function registerLocalInferRoute(scope: Context & {
     webServer: WebServerService;
-}, localInfer: LocalInferService, getHost?: LifecycleHost): void;
+}, localInfer: LocalInferService, getHost?: LifecycleHost, launchHost?: LifecycleHost): void;
 export {};
-//# sourceMappingURL=route.d.ts.map
+//# sourceMappingURL=route.d.ts.map