@otto-code/brain 0.8.1 → 0.8.3

package/dist/service/host-api.js

@@ -1,10 +1,29 @@
 import { calibrationInfo, profileFieldDescriptors, profileWarnings, sanitizeProfilePatch, } from "../config/profile-edit.js";
 import { forModel, getCalibration, put } from "../config/profiles.js";
 import { deleteModelFiles, diskUsage, planDelete, totalModelBytes } from "../models/manage.js";
+import { deleteDisplayName, updateDisplayName } from "../models/rename-map.js";
 import * as vram from "../vram.js";
 import { errorMessage, readJsonBody, sendError, sendJson } from "./http-util.js";
 const MAX_PATCH_BYTES = 256 * 1024;
+const MAX_DISPLAY_NAME = 200;
 const DEFAULT_LOG_LINES = 200;
+/**
+ * The management API's own version, additive to the capability flags.
+ *
+ * Capabilities answer "can this brain do X"; this answers "which generation of
+ * the API is this" for the rare change that no single flag describes. A daemon
+ * reads both and never requires an exact package-version match.
+ */
+export const HOST_API_VERSION = 2;
+/**
+ * How often the SSE stream writes a comment line when nothing has changed.
+ *
+ * This is transport keepalive, not a status event: a proxy or a NAT table with
+ * an idle timeout would otherwise silently drop a stream from a brain that is
+ * simply sitting still, and the daemon would report an unreachable brain that is
+ * fine. Comments are ignored by every SSE parser, so no reader sees them.
+ */
+const SSE_KEEPALIVE_MS = 20000;
 function stateOf(supervisor, model) {
     if (!supervisor.model || supervisor.model.id !== model.id)
         return "not-loaded";
@@ -101,6 +120,13 @@ export function createHostApi(deps) {
         load: true,
         resources: true,
         inventory: true,
+        rename: true,
+        reset: true,
+        // Read live rather than captured: the publisher is inert until the router
+        // installs its snapshot source, and advertising a stream we cannot serve
+        // would make a daemon stop polling and see nothing.
+        events: Boolean(deps.statusEvents?.ready),
+        liveInference: Boolean(deps.statusEvents?.ready),
         writable: deps.getAllowWrite(),
     });
     /** Refuse a write unless the owner opted into remote configuration. */
@@ -180,6 +206,59 @@ export function createHostApi(deps) {
             })();
         });
     };
+    const handleRename = (req, res, model) => {
+        readJsonBody(req, MAX_DISPLAY_NAME + 64, (result) => {
+            if (!result.ok) {
+                sendError(res, 400, result.error);
+                return;
+            }
+            const body = result.body;
+            const displayName = body.displayName;
+            if (typeof displayName !== "string" || displayName.trim().length === 0) {
+                sendError(res, 400, "displayName must be a non-empty string");
+                return;
+            }
+            if (displayName.length > MAX_DISPLAY_NAME) {
+                sendError(res, 400, `displayName must be at most ${MAX_DISPLAY_NAME} characters`);
+                return;
+            }
+            if (/[^\x20-\x7E]/.test(displayName)) {
+                sendError(res, 400, "displayName must not contain control characters or non-ASCII");
+                return;
+            }
+            // /v1/models keys its `id` on displayName (router.ts) and both the
+            // completion path and defaultModel/switchTo resolve a model by
+            // `displayName === name || id === name` - a collision here would make
+            // one of the two models unreachable by name with no error anywhere.
+            const conflict = deps
+                .getCatalog()
+                .find((m) => m.id !== model.id && (m.displayName === displayName || m.id === displayName));
+            if (conflict) {
+                sendError(res, 409, `another model is already named "${displayName}"`);
+                return;
+            }
+            updateDisplayName(model.id, displayName);
+            // The catalog is kept in memory between requests. Refresh it here so
+            // the next inventory request, and all model lookups, see the persisted
+            // name immediately instead of reverting to the scan-derived name until
+            // the brain is restarted. Reset already follows this pattern below.
+            const catalog = deps.rescan();
+            const updated = resolveModel(catalog, model.id);
+            sendJson(res, { displayName: updated ? updated.displayName : displayName });
+        });
+    };
+    const handleReset = (req, res, model) => {
+        readJsonBody(req, 4096, (result) => {
+            if (!result.ok) {
+                sendError(res, 400, result.error);
+                return;
+            }
+            deleteDisplayName(model.id);
+            const catalog = deps.rescan();
+            const updated = resolveModel(catalog, model.id);
+            sendJson(res, { displayName: updated ? updated.displayName : model.displayName });
+        });
+    };
     const handleBudget = (res, model, params) => {
         void (async () => {
             try {
@@ -282,6 +361,56 @@ export function createHostApi(deps) {
             command: deps.supervisor.command,
         });
     };
+    /**
+     * Stream complete status snapshots as SSE.
+     *
+     * Authentication is the listener's, not this route's: `withAuth` in serve.ts
+     * gates every `/__host/*` path with the same token and TLS policy, so an
+     * unauthenticated caller never reaches this function.
+     *
+     * The stream is unidirectional and outlives the request, which is exactly why
+     * SSE rather than a socket the brain would have to dial back to a daemon: a
+     * remote brain has no idea where its daemon is, and the daemon already knows
+     * how to reach the brain over an authenticated HTTP(S) endpoint.
+     */
+    const handleEvents = (req, res, publisher) => {
+        res.writeHead(200, {
+            "content-type": "text/event-stream",
+            "cache-control": "no-cache, no-transform",
+            connection: "keep-alive",
+            // Tells nginx-shaped intermediaries not to buffer, which would defeat the
+            // whole point by holding each snapshot until the response ended.
+            "x-accel-buffering": "no",
+        });
+        res.flushHeaders?.();
+        const write = (snapshot) => {
+            if (res.writableEnded || res.destroyed)
+                return;
+            res.write(`event: status\ndata: ${JSON.stringify(snapshot)}\n\n`);
+        };
+        let unsubscribe = () => { };
+        const keepalive = setInterval(() => {
+            if (res.writableEnded || res.destroyed)
+                return;
+            res.write(": keepalive\n\n");
+        }, SSE_KEEPALIVE_MS);
+        keepalive.unref?.();
+        const teardown = () => {
+            clearInterval(keepalive);
+            unsubscribe();
+        };
+        // The publisher ends the response on host shutdown: an open SSE response is
+        // an open connection, and `server.close()` waits for those.
+        unsubscribe = publisher.subscribe(write, () => {
+            clearInterval(keepalive);
+            if (!res.writableEnded && !res.destroyed)
+                res.end();
+        });
+        // Both ends matter: `close` on the request covers a client that walked away,
+        // and `close` on the response covers the service shutting the socket down.
+        req.on("close", teardown);
+        res.on("close", teardown);
+    };
     function handleHostApi(req, res) {
         const raw = req.url || "";
         if (!raw.startsWith("/__host/"))
@@ -294,6 +423,15 @@ export function createHostApi(deps) {
             sendJson(res, capabilities());
             return true;
         }
+        if (route === "/__host/events" && method === "GET") {
+            const publisher = deps.statusEvents;
+            if (!publisher?.ready) {
+                sendError(res, 404, "this brain does not serve a status event stream");
+                return true;
+            }
+            handleEvents(req, res, publisher);
+            return true;
+        }
         if (route === "/__host/logs" && method === "GET") {
             handleLogs(res, params);
             return true;
@@ -326,6 +464,8 @@ export function createHostApi(deps) {
             "/__host/model/budget",
             "/__host/model/load",
             "/__host/model/fields",
+            "/__host/model/rename",
+            "/__host/model/rename/reset",
         ]);
         if (!modelRoutes.has(route))
             return false;
@@ -359,6 +499,18 @@ export function createHostApi(deps) {
             handleLoad(res, model);
             return true;
         }
+        if (route === "/__host/model/rename" && method === "POST") {
+            if (!guardWrite(res))
+                return true;
+            handleRename(req, res, model);
+            return true;
+        }
+        if (route === "/__host/model/rename/reset" && method === "POST") {
+            if (!guardWrite(res))
+                return true;
+            handleReset(req, res, model);
+            return true;
+        }
         if (route === "/__host/model" && method === "DELETE") {
             if (!guardWrite(res))
                 return true;

package/dist/service/router.d.ts

@@ -3,7 +3,8 @@ import type { Supervisor } from "./supervisor.js";
 import { type RankedModel } from "../ops/results.js";
 import type { GpuInfo, Model } from "../types.js";
 import type { Profile } from "../config/schema.js";
-import type { HostApi } from "./host-api.js";
+import { type HostApi } from "./host-api.js";
+import type { BrainStatusPublisher } from "./status-events.js";
 type Verdict = "ok" | "reasoning-only" | "truncated" | "failed";
 /** A logger sink; only `warn` is used by the router. */
 export interface Logger {
@@ -70,6 +71,8 @@ interface DescribeOptions {
 /** An LM Studio-style model description, an OpenAI model object enriched. */
 export interface ModelEntry {
     id: string;
+    /** Brain's editable human-facing name; `id` remains the stable model key. */
+    name: string;
     object: "model";
     created: number;
     owned_by: string;
@@ -80,6 +83,10 @@ export interface ModelEntry {
     quantization: string | null;
     state: ModelState;
     max_context_length: number | null;
+    /** Whether the model exposes a chat-template reasoning channel. */
+    reasoning: boolean;
+    /** Optional per-model values accepted by the OpenAI-compatible endpoint. */
+    reasoning_efforts?: string[];
     loaded_context_length?: number;
 }
 /**
@@ -156,13 +163,21 @@ export interface RouterOptions {
      */
     hostApi?: HostApi | null;
     /**
-     * Live system telemetry (CPU, RAM, GPU, slots), folded into `/__host/status`
+     * Live system telemetry (CPU, RAM and GPU), folded into `/__host/status`
      * ONLY when the caller asks with `?resources=1`. The daemon's liveness probe
-     * polls status frequently and must not pay an `nvidia-smi` spawn for it; the
+     * polls status frequently and must not pay an `nvidia-smi` spawn for it. Slot
+     * activity is already part of the cheap status; the
      * Brain page's Overview tab opts in.
      */
     getResources?: (() => Promise<unknown>) | null;
+    /**
+     * The live status source served at `GET /__host/events`. The router installs
+     * its snapshot builder here and notifies it whenever something authoritative
+     * moves, so the same assembly answers both the pull and the push and the two
+     * can never disagree. Absent means this brain does not advertise events.
+     */
+    statusEvents?: BrainStatusPublisher | null;
 }
-export declare function createRouter({ supervisor, telemetry, logger, getCatalog, loadModel, loadRanking, queryGpuInfo, version, getConfig, getEvals, getLockModel, getDefaultModel, applyConfigPatch, getAllowConfigWrite, hostApi, getResources, }: RouterOptions): (req: http.IncomingMessage, res: http.ServerResponse) => void;
+export declare function createRouter({ supervisor, telemetry, logger, getCatalog, loadModel, loadRanking, queryGpuInfo, version, getConfig, getEvals, getLockModel, getDefaultModel, applyConfigPatch, getAllowConfigWrite, hostApi, getResources, statusEvents, }: RouterOptions): (req: http.IncomingMessage, res: http.ServerResponse) => void;
 export {};
 //# sourceMappingURL=router.d.ts.map

package/dist/service/router.js

@@ -5,6 +5,7 @@ import { slots as sampleSlots } from "../sysmon.js";
 import { makeVramFitPredicate, selectCodingModel } from "./model-selector.js";
 import { query as queryGpu } from "../gpu.js";
 import { rankModels } from "../ops/results.js";
+import { HOST_API_VERSION } from "./host-api.js";
 import { errorBody, errorMessage, HOP_BY_HOP, readJsonBody, sendError, sendJson, } from "./http-util.js";
 /**
  * Fronts the supervised llama-server on a stable port.
@@ -144,8 +145,10 @@ export function describeModel(model, options = {}) {
     const { state = "not-loaded", profile = null, createdAt = null } = options;
     const md = model.metadata || {};
     const entry = {
-        // Standard OpenAI fields - id is the friendly name, never the file path.
-        id: model.displayName,
+        // Keep the stable model key separate from Brain's editable display name.
+        // OpenAI-compatible clients send `id`; Otto uses `name` for presentation.
+        id: model.id,
+        name: model.displayName,
         object: "model",
         created: Math.floor((createdAt ? createdAt.getTime() : Date.now()) / 1000),
         owned_by: model.publisher || "local",
@@ -157,7 +160,13 @@ export function describeModel(model, options = {}) {
         quantization: model.quant || null,
         state,
         max_context_length: md.contextLength ?? null,
+        reasoning: Boolean(md.reasoning ?? model.thinking),
     };
+    const reasoningEfforts = md["reasoning_efforts"];
+    if (Array.isArray(reasoningEfforts) &&
+        reasoningEfforts.every((value) => typeof value === "string")) {
+        entry.reasoning_efforts = reasoningEfforts;
+    }
     if (state === "loaded" && profile && profile.contextSize) {
         // llama-server splits -c across --parallel slots, so the window a single
         // request actually gets is the total divided by the concurrency.
@@ -298,6 +307,25 @@ function proxyBuffered({ agent, supervisor, telemetry, logger, req, res, body, r
             }
             res.writeHead(upstreamRes.statusCode ?? 502, outHeaders);
             const isStream = String(upstreamRes.headers["content-type"] || "").includes("event-stream");
+            const upstreamResponseFailed = (error) => {
+                if (settled)
+                    return;
+                const message = `llama-server response ended unexpectedly: ${error.message}`;
+                telemetry.record({
+                    at: new Date().toISOString(),
+                    path: req.url,
+                    verdict: "failed",
+                    error: message,
+                });
+                logger?.warn?.(message);
+                // Headers may already be on the wire for an SSE response. Destroying
+                // it is the only honest result, but `done()` still releases the queue.
+                if (!res.writableEnded && !res.destroyed)
+                    res.destroy(error);
+                done();
+            };
+            upstreamRes.once("aborted", () => upstreamResponseFailed(new Error("upstream response aborted")));
+            upstreamRes.once("error", upstreamResponseFailed);
             if (isStream) {
                 let sawContent = false;
                 let sawReasoning = false;
@@ -368,6 +396,10 @@ function proxyBuffered({ agent, supervisor, telemetry, logger, req, res, body, r
             sendError(res, 502, `Upstream llama-server error: ${error.message}`);
             done();
         });
+        // This is the first authoritative inference-stage signal: the request is
+        // being dispatched to llama-server and is waiting for prompt processing or
+        // its first output delta.
+        reasoning?.begin(streamId);
         upstream.end(body);
     });
 }
@@ -458,10 +490,15 @@ function scheduleCompletion({ req, res, agent, supervisor, telemetry, logger, sc
 // (rare), so the router caches the ranking and re-reads it at most once per
 // window - the cheap time-based trigger.
 const RANKING_TTL_MS = 60000;
-export function createRouter({ supervisor, telemetry, logger, getCatalog = null, loadModel = null, loadRanking = () => rankModels(), queryGpuInfo = queryGpu, version = null, getConfig = null, getEvals = null, getLockModel = () => false, getDefaultModel = () => null, applyConfigPatch = null, getAllowConfigWrite = () => false, hostApi = null, getResources = null, }) {
+export function createRouter({ supervisor, telemetry, logger, getCatalog = null, loadModel = null, loadRanking = () => rankModels(), queryGpuInfo = queryGpu, version = null, getConfig = null, getEvals = null, getLockModel = () => false, getDefaultModel = () => null, applyConfigPatch = null, getAllowConfigWrite = () => false, hostApi = null, getResources = null, statusEvents = null, }) {
     const agent = new http.Agent({ keepAlive: true, maxSockets: 32 });
     const scheduler = loadModel
-        ? new Scheduler({ supervisor, loadModel, logger: (m) => logger?.warn?.(m) })
+        ? new Scheduler({
+            supervisor,
+            loadModel,
+            logger: (m) => logger?.warn?.(m),
+            onChange: statusEvents ? () => statusEvents.notify() : null,
+        })
         : null;
     // A (re)start means whatever produced the current warning no longer applies -
     // either a different model is now resident, or the same one just picked up an
@@ -547,51 +584,79 @@ export function createRouter({ supervisor, telemetry, logger, getCatalog = null,
             resolved: lock ? null : resolveModel(name),
         });
     };
+    /**
+     * The cheap host status: everything `/__host/status` answers except the
+     * opt-in `resources` block.
+     *
+     * One assembly feeds both the pull (`/__host/status`) and the push
+     * (`/__host/events`). Keeping them as one function is the point: a field that
+     * only the polled answer carried would be a field the rail silently lost the
+     * moment a daemon stopped polling.
+     */
+    const buildCheapStatus = async () => {
+        const schedulerStats = scheduler ? scheduler.stats() : null;
+        // Slots come from a loopback GET on the resident llama-server. That is
+        // cheap enough to pay on every sample - unlike GPU sampling, which spawns
+        // `nvidia-smi` and stays opt-in. Skipped entirely unless a model is
+        // resident, since there is nothing listening otherwise.
+        const slots = supervisor.state === "ready"
+            ? await sampleSlots({ host: supervisor.host, port: supervisor.internalPort }).catch(() => null)
+            : null;
+        return {
+            version,
+            // Additive, and separate from `version`: the package version says which
+            // build this is, this says which generation of the management contract it
+            // speaks. A daemon reads this and `capabilities` rather than pinning a
+            // package version.
+            apiVersion: HOST_API_VERSION,
+            ...supervisor.status(),
+            telemetry: { ...telemetry.totals, warning: telemetry.warning },
+            scheduler: schedulerStats,
+            recent: telemetry.records.slice(-10),
+            logLineCount: supervisor.logLines.length,
+            // Carried inline rather than fetched from /__host/capabilities: the
+            // daemon reads status constantly, and a separately cached copy would go
+            // stale the moment the owner toggles allowRemoteConfig.
+            capabilities: hostApi ? hostApi.capabilities() : null,
+            // The three signals the Brain rail's icon is derived from. All are cheap
+            // enough for the liveness path: `activity` is one stat of a file that is
+            // usually absent, `reasoning` is in-process state, and `queued` is
+            // already computed above.
+            activity: readActivity(),
+            reasoning: reasoningTracker.active,
+            // Exact aggregate request stages from the proxy lifecycle. Unlike slot
+            // phase sampling, this distinguishes silent prompt processing, reasoning
+            // deltas and user-visible content even when several requests overlap.
+            inference: reasoningTracker.snapshot,
+            queued: schedulerStats ? schedulerStats.queued : 0,
+            slots,
+        };
+    };
+    // Publish rather than be polled. The publisher decides what counts as a
+    // change (see status-events.ts); everything here just says "look again".
+    if (statusEvents) {
+        statusEvents.setSource(buildCheapStatus);
+        supervisor.on("state", () => statusEvents.notify());
+        supervisor.on("crashed", () => statusEvents.notify());
+        reasoningTracker.onChange(() => statusEvents.notify());
+    }
     return function handler(req, res) {
         // Host-management read surface (`/__host/*`): the single API both the TUI and
         // Otto's GUI consume, so the two never drift. Status is live; config and
         // evals are point-in-time reads the daemon proxies to its settings UI.
         const path = (req.url || "").split("?")[0];
         if (path === "/__host/status") {
-            const schedulerStats = scheduler ? scheduler.stats() : null;
-            const base = {
-                version,
-                ...supervisor.status(),
-                telemetry: { ...telemetry.totals, warning: telemetry.warning },
-                scheduler: schedulerStats,
-                recent: telemetry.records.slice(-10),
-                logLineCount: supervisor.logLines.length,
-                // Carried inline rather than fetched from /__host/capabilities: the
-                // daemon polls status constantly, and a separately cached copy would go
-                // stale the moment the owner toggles allowRemoteConfig.
-                capabilities: hostApi ? hostApi.capabilities() : null,
-                // The three signals the Brain rail's icon is derived from. All are cheap
-                // enough for the liveness poll: `activity` is one stat of a file that is
-                // usually absent, `reasoning` is in-process state, and `queued` is
-                // already computed above. Slot phases are the one that costs a round
-                // trip, and are fetched below.
-                activity: readActivity(),
-                reasoning: reasoningTracker.active,
-                queued: schedulerStats ? schedulerStats.queued : 0,
-            };
-            // Slots come from a loopback GET on the resident llama-server. That is
-            // cheap enough to pay on every poll - unlike the GPU sampling below, which
-            // spawns `nvidia-smi` and stays opt-in. Skipped entirely unless a model is
-            // resident, since there is nothing listening otherwise.
-            const slotsPromise = supervisor.state === "ready"
-                ? sampleSlots({ host: supervisor.host, port: supervisor.internalPort }).catch(() => null)
-                : Promise.resolve(null);
-            // Resources cost an `nvidia-smi` spawn, so they are opt-in: the daemon's
-            // liveness probe polls this route far more often than any UI does, and
-            // must not pay for a panel it is not rendering.
+            // Resources cost an `nvidia-smi` spawn, so they are opt-in: the daemon
+            // reads this route far more often than any UI does, and must not pay for
+            // a panel it is not rendering.
             const wantsResources = /[?&]resources=1(&|$)/.test(req.url || "");
             if (!wantsResources || !getResources) {
-                void slotsPromise.then((slots) => sendJson(res, { ...base, slots }));
+                void buildCheapStatus().then((base) => sendJson(res, base));
                 return;
             }
-            Promise.all([slotsPromise, getResources().catch(() => null)])
-                .then(([slots, resources]) => sendJson(res, { ...base, slots, resources }))
-                .catch(() => sendJson(res, { ...base, slots: null, resources: null }));
+            Promise.all([buildCheapStatus(), getResources().catch(() => null)])
+                .then(([base, resources]) => sendJson(res, { ...base, resources }))
+                .catch((error) => sendError(res, 500, `could not build the host status: ${errorMessage(error)}`));
             return;
         }
         // Config write: apply an editable patch (model/lock live, the rest persisted).

package/dist/service/run-log.d.ts

@@ -0,0 +1,8 @@
+export interface BrainRunLog {
+    path: string;
+    write(line: string): void;
+}
+/** Start a fresh Brain log and prune only expired Brain run logs. */
+export declare function createBrainRunLog(env?: NodeJS.ProcessEnv): BrainRunLog;
+export declare function pruneBrainRunLogs(logsDir: string, now?: number): void;
+//# sourceMappingURL=run-log.d.ts.map

package/dist/service/run-log.js

@@ -0,0 +1,39 @@
+/** Durable, per-service-run diagnostics for Otto Brain. */
+import { appendFileSync, mkdirSync, readdirSync, rmSync, statSync } from "node:fs";
+import path from "node:path";
+import { resolveBrainPaths } from "../config/paths.js";
+const RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+const RUN_LOG_SUFFIX = "-brain.log";
+/** Start a fresh Brain log and prune only expired Brain run logs. */
+export function createBrainRunLog(env = process.env) {
+    const { logsDir } = resolveBrainPaths(env);
+    const startedAt = new Date();
+    const stamp = startedAt
+        .toISOString()
+        .replace(/[-:]/g, "")
+        .replace(/\.\d{3}Z$/, "Z");
+    const filePath = path.join(logsDir, `${stamp}-${process.pid}${RUN_LOG_SUFFIX}`);
+    try {
+        mkdirSync(logsDir, { recursive: true });
+        pruneBrainRunLogs(logsDir, startedAt.getTime());
+    }
+    catch { }
+    const write = (line) => {
+        try {
+            appendFileSync(filePath, `${new Date().toISOString()} ${line}\n`, "utf8");
+        }
+        catch { }
+    };
+    write(`Brain service started (pid ${process.pid})`);
+    return { path: filePath, write };
+}
+export function pruneBrainRunLogs(logsDir, now = Date.now()) {
+    for (const entry of readdirSync(logsDir, { withFileTypes: true })) {
+        if (!entry.isFile() || !entry.name.endsWith(RUN_LOG_SUFFIX))
+            continue;
+        const filePath = path.join(logsDir, entry.name);
+        if (now - statSync(filePath).mtimeMs > RETENTION_MS)
+            rmSync(filePath, { force: true });
+    }
+}
+//# sourceMappingURL=run-log.js.map

package/dist/service/scheduler.d.ts

@@ -33,6 +33,13 @@ export interface SchedulerOptions {
     supervisor: SchedulerSupervisor;
     loadModel: (model: Model) => Promise<void>;
     logger?: ((message: string) => void) | null;
+    /**
+     * Called whenever the queue depth or the turn changes - i.e. whenever
+     * `stats()` would answer differently. The status event stream publishes from
+     * this instead of sampling, so "queued behind a model switch" reaches the UI
+     * the moment it becomes true rather than up to a poll later.
+     */
+    onChange?: (() => void) | null;
 }
 /** A queued completion request bound to a resolved catalog model. */
 export interface QueuedJob {
@@ -55,7 +62,8 @@ export declare class Scheduler {
     queue: QueuedJob[];
     lastTurnId: string | null;
     pumping: boolean;
-    constructor({ supervisor, loadModel, logger }: SchedulerOptions);
+    onChange: (() => void) | null;
+    constructor({ supervisor, loadModel, logger, onChange }: SchedulerOptions);
     /** Id of the model that is actually loaded and ready, or null. */
     get loadedId(): string | null;
     /** How many requests may run at once against the resident model. */

package/dist/service/scheduler.js

@@ -3,10 +3,10 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Scheduler_instances, _Scheduler_take, _Scheduler_serveTurn;
+var _Scheduler_instances, _Scheduler_announce, _Scheduler_take, _Scheduler_serveTurn;
 const MAX_CONCURRENCY = 16;
 export class Scheduler {
-    constructor({ supervisor, loadModel, logger = null }) {
+    constructor({ supervisor, loadModel, logger = null, onChange = null }) {
         _Scheduler_instances.add(this);
         this.supervisor = supervisor;
         this.loadModel = loadModel; // async (model) => resolves once it is ready
@@ -14,6 +14,7 @@ export class Scheduler {
         this.queue = []; // { modelId, model, run, resolve, reject }
         this.lastTurnId = null;
         this.pumping = false;
+        this.onChange = onChange;
     }
     /** Id of the model that is actually loaded and ready, or null. */
     get loadedId() {
@@ -34,6 +35,7 @@ export class Scheduler {
     submit(model, run) {
         return new Promise((resolve, reject) => {
             this.queue.push({ modelId: model.id, model, run, resolve, reject });
+            __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_announce).call(this);
             queueMicrotask(() => this.pump());
         });
     }
@@ -61,6 +63,7 @@ export class Scheduler {
                     }
                 }
                 this.lastTurnId = turnId;
+                __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_announce).call(this);
                 await __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_serveTurn).call(this, turnId);
             }
         }
@@ -78,12 +81,21 @@ export class Scheduler {
         return { queued: this.queue.length, waiting, lastTurn: this.lastTurnId };
     }
 }
-_Scheduler_instances = new WeakSet(), _Scheduler_take = function _Scheduler_take(pred) {
+_Scheduler_instances = new WeakSet(), _Scheduler_announce = function _Scheduler_announce() {
+    try {
+        this.onChange?.();
+    }
+    catch {
+        // Status reporting is not allowed to fail a queued completion.
+    }
+}, _Scheduler_take = function _Scheduler_take(pred) {
     const kept = [];
     const taken = [];
     for (const job of this.queue)
         (pred(job) ? taken : kept).push(job);
     this.queue = kept;
+    if (taken.length > 0)
+        __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_announce).call(this);
     return taken;
 }, _Scheduler_serveTurn = 
 /** Serve one model's snapshot with bounded concurrency. */

package/dist/service/serve.d.ts

@@ -37,7 +37,8 @@ export interface ServiceHandle {
     supervisor: Supervisor;
     host: string;
     port: number;
-    model: Model;
+    /** The model loaded during startup, if one was available. */
+    model: Model | null;
     /** Whether the listener terminates TLS (config.tls.mode !== "off"). */
     secure: boolean;
     /** The address to show a user: the MagicDNS/cert hostname when TLS is on, else the bind host. */