dsh-plugin-local-infer 0.1.3 → 0.1.4

package/packages/ui/lib/route.js

@@ -31,6 +31,7 @@ import { downloadRoute } from "./routes/download.js";
 import { getRoute } from "./routes/get.js";
 import { installRoute } from "./routes/install.js";
 import { launchRoute } from "./routes/launch.js";
+import { logsRoute } from "./routes/logs.js";
 import { providerDeleteRoute } from "./routes/provider-delete.js";
 import { registerRoute } from "./routes/register.js";
 import { saveRoute } from "./routes/save.js";
@@ -104,6 +105,15 @@ export class RouteResponder {
             this.res.write(chunk);
         }
     }
+    /**
+     * 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) {
+        this.res.on?.('close', listener);
+    }
     /** End the response, optionally with a final body chunk. */
     end(body) {
         this.res.end(body);
@@ -143,16 +153,18 @@ export function defineRoute(spec) {
 }
 /**
  * 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 function registerLocalInferRoute(scope, localInfer, getHost) {
+export function registerLocalInferRoute(scope, localInfer, getHost, launchHost) {
+    const logsStreamRoute = logsRoute(localInfer);
     const routes = [
         summaryRoute(localInfer),
         saveRoute(localInfer),
@@ -162,8 +174,9 @@ export function registerLocalInferRoute(scope, localInfer, getHost) {
         downloadRoute(localInfer),
         chatTemplateRoute(localInfer),
         getRoute(localInfer, getHost),
-        launchRoute(localInfer),
+        launchRoute(localInfer, launchHost),
         stopRoute(localInfer),
+        logsStreamRoute,
         registerRoute(localInfer),
         unregisterRoute(localInfer),
     ];
@@ -175,8 +188,13 @@ export function registerLocalInferRoute(scope, localInfer, getHost) {
         // The engine death observer: a crash, a pkill, or the poll-detected exit
         // of an adopted process clears the provider entry's launch record and
         // notes the exit in the last-run logs the moment it happens, so the card
-        // and a later restart read the provider stopped rather than stale.
-        localInfer.setEngineDeathObserver(handleEngineDeath);
+        // and a later restart read the provider stopped rather than stale. The
+        // closure captures the service so the same note reaches the dead entry's
+        // live run-log buffer (handleEngineDeath closes a run its late append
+        // reopened, so the note never strands the key as running).
+        localInfer.setEngineDeathObserver((event) => {
+            handleEngineDeath(event, localInfer);
+        });
         // The mount re-link: re-adopt a surviving engine from a stored launch
         // record and start its liveness watcher without waiting for the card to
         // open the summary route, so a DSH that restarts re-attaches its engines
@@ -185,10 +203,15 @@ export function registerLocalInferRoute(scope, localInfer, getHost) {
         const disposers = routes.map((route) => scope.webServer.register(route));
         return () => {
             localInfer.setEngineDeathObserver(undefined);
+            // Browser panes still streaming hold hub subscriptions that
+            // unregistering the route does not touch: close every open stream
+            // first, so a bundle switch off leaves no listener forwarding into a
+            // response no route owns any more.
+            logsStreamRoute.closeOpenStreams();
             for (const dispose of disposers) {
                 dispose();
             }
         };
     }, 'local-infer: settings routes');
 }
-//# sourceMappingURL=route.js.map
+//# sourceMappingURL=route.js.map

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

@@ -1,14 +1 @@
-/**
- * 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

@@ -1,37 +1 @@
-/**
- * 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

@@ -1,16 +1 @@
-/**
- * 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

@@ -1,27 +1 @@
-/**
- * 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

@@ -1,16 +1 @@
-/**
- * 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

@@ -1,48 +1 @@
-/**
- * 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

@@ -1,18 +1 @@
-/**
- * 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

@@ -1,14 +1,20 @@
 /**
- * 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.
+ * The POST /local-infer/get route: the Get step. Its answer streams as
+ * NDJSON progress events only (a structured download state folded from the
+ * hf download's tqdm stderr): the run's log text reaches the card through
+ * the per-provider run-log stream (the GET /local-infer/logs route fed by the
+ * hub), so one line never arrives twice. The full run still collects,
+ * persists as the last-run logs in plain text, and feeds the live hub, so
+ * the log file, the Logs section, and the streamed run read the run the same
+ * way.
  * @module dsh-plugin-local-infer/ui/routes/get
  */
+import { runLogKey } from '../../../service/lib/index.js';
 import { parseStoredPlatformConfig } from "../config.js";
-import { getEngine } from "../ops/engine.js";
-import { persistGetLogs } from "../ops/logs.js";
+import { CANCELED_LINE, GET_EVENT_PREFIX, getEngine, resolveStoredRequest } from "../ops/engine.js";
+import { captureRunBaseline, finishRunSection, GET_RUN_SEED } from "../ops/logs.js";
 import { defineRoute } from "../route.js";
+import { abortOnResponseClose, ndjsonLine, throttledProgressSink } from "./stream.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
@@ -34,24 +40,67 @@ export function getRoute(localInfer, getHost) {
             if (platform !== undefined) {
                 request.platform = platform;
             }
-            res.textStream();
+            res.ndjsonStream();
+            // The run key the live hub buffers this Get under, the shared runLogKey
+            // rule (the request names no provider, so the stored entry matching the
+            // engine and model wins, and a draft falls back to the engine id).
+            const { stored, engineId, config } = resolveStoredRequest(request);
+            const runKey = runLogKey(stored.providers, engineId, undefined, config);
+            localInfer.beginRun(runKey, GET_RUN_SEED);
+            // 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.
+            const baseline = captureRunBaseline();
             let collected = '';
+            // The log sink collects the plain-text run (the persisted log) and
+            // appends the same chunk to the live hub, whose run-log stream carries
+            // the text to the card's Logs pane (Q2: one streamed display path).
+            // The route's own answer no longer mirrors the text as log events, so
+            // a line never lands twice.
             const log = (text) => {
                 collected += text;
-                res.write(text);
+                localInfer.appendRunLog(runKey, text);
             };
+            // The hf download's raw stderr sink: the core chunk folder turns the
+            // tqdm lines into a structured state, and the sink emits a progress
+            // event when a fold yields one (throttled to the half-second cadence).
+            const onChunk = throttledProgressSink((progress) => ndjsonLine(res, { progress }));
+            // The card's provider-form Cancel aborts the fetch, which closes the
+            // response: the abort interrupts the in-flight hf child (SIGINT, then
+            // SIGTERM). Resume is within-invocation only; a killed run re-downloads
+            // from zero on the re-run (the orphaned .incomplete blob lingers until
+            // `hf cache prune`). A close after the run settled is the normal end,
+            // not a cancel.
+            const { signal, markFinished } = abortOnResponseClose(res);
             try {
-                await getEngine(localInfer, request, log, getHost);
+                try {
+                    await getEngine(localInfer, request, log, getHost, signal, onChunk);
+                }
+                catch (error) {
+                    log(`${GET_EVENT_PREFIX}get failed: ${String(error?.message ?? error)}\n`);
+                }
+                // A cancel that closed the stream appends the "Canceled" line, so the
+                // persisted run (and the log file) read the run as canceled, the same
+                // line the card writes to its Logs buffer on the Cancel.
+                if (signal.aborted) {
+                    log(`${CANCELED_LINE}`);
+                }
+                markFinished();
+                // The "Getting engine and model..." separator leads the persisted
+                // run and the live run's seed, so the Logs section, the log file, and
+                // the streamed run read the run as one fresh process section.
+                // finishRunSection closes the run over the baseline captured before
+                // it started, not a second append over its own provisional notes.
+                finishRunSection(baseline, `${GET_RUN_SEED}${collected}`);
+                res.end();
             }
-            catch (error) {
-                log(`!! get failed: ${String(error?.message ?? error)}\n`);
+            finally {
+                // The bracket closes on every settle path, cancel and failure
+                // included: the key's running flag clears after finishRunSection.
+                localInfer.endRun(runKey);
             }
-            // 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
+//# sourceMappingURL=get.js.map

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

@@ -13,4 +13,4 @@ import type { LocalInferRoute } from '../route.ts';
  * register step holds by an effect.
  */
 export declare function installRoute(localInfer: LocalInferService): LocalInferRoute;
-//# sourceMappingURL=install.d.ts.map
+//# sourceMappingURL=install.d.ts.map

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

@@ -33,4 +33,4 @@ export function installRoute(localInfer) {
         },
     });
 }
-//# sourceMappingURL=install.js.map
+//# sourceMappingURL=install.js.map

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

@@ -2,17 +2,23 @@
  * 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.
+ * as each phase (prereqs, download, build, launch) begins, a progress event
+ * when the Get-steps hf download's tqdm stderr folds into a structured
+ * state, a sudo event when a guarded command waits for the user's password
+ * on the launching CLI, 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 { LifecycleHost } from 'dsh-plugin-local-infer/core';
 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.
+ * register step holds by an effect. The optional launchHost is the lifecycle
+ * host the launch's Get steps (git sync, build) 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 launchRoute(localInfer: LocalInferService): LocalInferRoute;
-//# sourceMappingURL=launch.d.ts.map
+export declare function launchRoute(localInfer: LocalInferService, launchHost?: LifecycleHost): LocalInferRoute;
+//# sourceMappingURL=launch.d.ts.map

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

@@ -2,20 +2,27 @@
  * 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.
+ * as each phase (prereqs, download, build, launch) begins, a progress event
+ * when the Get-steps hf download's tqdm stderr folds into a structured
+ * state, a sudo event when a guarded command waits for the user's password
+ * on the launching CLI, 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 { nodeLifecycleHost } from '../../../providers/lib/index.js';
 import { launchEngine } from "../ops/engine.js";
 import { defineRoute, RouteError } from "../route.js";
 import { launchRequestFromBody } from "../request.js";
+import { abortOnResponseClose, ndjsonLine, throttledProgressSink } from "./stream.js";
 /**
  * launchRoute builds the POST /local-infer/launch route definition the
- * register step holds by an effect.
+ * register step holds by an effect. The optional launchHost is the lifecycle
+ * host the launch's Get steps (git sync, build) 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 launchRoute(localInfer) {
+export function launchRoute(localInfer, launchHost = nodeLifecycleHost) {
     return defineRoute({
         name: 'local-infer-launch',
         path: '/local-infer/launch',
@@ -25,13 +32,29 @@ export function launchRoute(localInfer) {
         run: async ({ body }, res) => {
             res.ndjsonStream();
             const writeLine = (line) => {
-                res.write(JSON.stringify(line) + '\n');
+                ndjsonLine(res, line);
             };
             const onProgress = (step) => {
                 writeLine({ step });
             };
+            // The Get-steps hf download's raw stderr sink: the core chunk folder
+            // turns the tqdm lines into a structured state, and the sink emits a
+            // progress event when a fold yields one (throttled to the half-second
+            // cadence), between the step and result events.
+            const onChunk = throttledProgressSink((progress) => writeLine({ progress }));
+            // The run's sudo observer calls this when a guarded command waits for
+            // the password on the launching CLI (see launchEngine): the card reads
+            // the line as "Sudo needed" on its Launch control.
+            const onSudo = () => {
+                writeLine({ sudo: true });
+            };
+            // The card's provider-form Cancel aborts the fetch, which closes the
+            // response: the abort interrupts the in-flight Get-step hf child
+            // (SIGINT, then SIGTERM), and the persisted run carries the "Canceled"
+            // line. A close after the run settled is the normal end, not a cancel.
+            const { signal, markFinished } = abortOnResponseClose(res);
             try {
-                const result = await launchEngine(localInfer, launchRequestFromBody(body), onProgress);
+                const result = await launchEngine(localInfer, launchRequestFromBody(body), onProgress, launchHost, signal, onChunk, onSudo);
                 writeLine({ result });
             }
             catch (error) {
@@ -43,8 +66,9 @@ export function launchRoute(localInfer) {
                     : String(error?.message ?? error);
                 writeLine({ result: { healthy: false, detail } });
             }
+            markFinished();
             res.end();
         },
     });
 }
-//# sourceMappingURL=launch.js.map
+//# sourceMappingURL=launch.js.map

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

@@ -0,0 +1,57 @@
+/**
+ * The GET /local-infer/logs route: the per-provider live run-log stream the
+ * card's Logs pane holds open (Q2: all live log display streams, nothing
+ * polls). The handler subscribes to the run-log hub before reading the
+ * catch-up snapshot, so an append that lands between the two is deduped by
+ * seq against the snapshot instead of doubling or being lost. One attached
+ * connection sees, in order: one `{ snapshot, seq, running }` catch-up line,
+ * then one `{ log, seq }` line per append, a `{ runBegin, seq }` line when a
+ * new run resets the buffer (the pane replaces, never appends), and a
+ * `{ runEnd, seq }` line when the run settles. The connection stays attached
+ * across runs. An unknown or blank provider key streams the empty snapshot
+ * and stays attached, so a client racing a run start never sees a 404; the
+ * client disconnect disposes the hub subscription.
+ * @module dsh-plugin-local-infer/ui/routes/logs
+ */
+import type { LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { LocalInferRoute } from '../route.ts';
+/**
+ * LogsStreamEvent is one NDJSON line the logs route streams: the catch-up
+ * snapshot (the bounded buffer text, the seq it reached, the running flag),
+ * one appended chunk, a run begin (the new run's seed line, seq back at 0,
+ * so the pane replaces its display), or the run end (the seq it settled at).
+ * Every line carries the seq the next append continues, so the card can drop
+ * any line whose seq the text it holds already covers.
+ */
+export type LogsStreamEvent = {
+    snapshot: string;
+    seq: number;
+    running: boolean;
+} | {
+    log: string;
+    seq: number;
+} | {
+    runBegin: string;
+    seq: number;
+} | {
+    runEnd: true;
+    seq: number;
+};
+/**
+ * LogsStreamRoute is the logs route's definition plus the open-stream
+ * registry the route effect's disposer drains. A bundle switch off
+ * unregisters the route, but browser panes that still hold a stream open
+ * leave their hub subscriptions behind unless something closes them; the
+ * effect disposer calls closeOpenStreams for that.
+ */
+export interface LogsStreamRoute extends LocalInferRoute {
+    closeOpenStreams(): void;
+}
+/**
+ * logsRoute builds the GET /local-infer/logs?provider=<key> route definition
+ * the register step holds by an effect. The `provider` query is the run key
+ * every run path shares (the runLogKey rule the card's requests mirror); a
+ * missing or unknown key is a live stream of nothing until someone runs it.
+ */
+export declare function logsRoute(localInfer: LocalInferService): LogsStreamRoute;
+//# sourceMappingURL=logs.d.ts.map