@otto-code/brain 0.8.2 → 0.8.3

package/dist/commands/lifecycle.js

@@ -5,7 +5,7 @@
  * they are always explicit user actions, never auto-started.
  */
 import { spawn } from "node:child_process";
-import { openSync } from "node:fs";
+import { existsSync, openSync } from "node:fs";
 import http from "node:http";
 import https from "node:https";
 import { loadBrainConfig } from "../config/index.js";
@@ -30,7 +30,9 @@ export async function runServeCommand(options, _command) {
     });
     const scheme = handle.secure ? "https" : "http";
     process.stdout.write(`router listening on ${scheme}://${handle.displayHost}:${handle.port}\n`);
-    process.stdout.write(`ready: ${handle.model.displayName}, ${vram.formatGiB(handle.supervisor.vramAtReadyBytes ?? 0)} VRAM in use\n`);
+    process.stdout.write(handle.model
+        ? `ready: ${handle.model.displayName}, ${vram.formatGiB(handle.supervisor.vramAtReadyBytes ?? 0)} VRAM in use\n`
+        : "ready: no model loaded; use the Library tab or `otto brain pull` to download one\n");
     process.stdout.write("press Ctrl+C to stop\n");
     const shutdown = async () => {
         process.stdout.write("\nstopping…\n");
@@ -83,7 +85,19 @@ export async function runStartCommand(options, command) {
         });
     }
     const { logFile } = resolveBrainPaths();
+    // process.argv[1] is the entry script of whatever host is running us (the npm
+    // CLI's bin, the desktop bundle's dist/index.js, bin/otto-brain). If it is not
+    // a file, we are running somewhere that does not lay argv out like Node - the
+    // detached child would silently get a verb where the script belongs and parse
+    // as garbage, so say so instead.
     const entry = process.argv[1];
+    if (!entry || !existsSync(entry)) {
+        throw new CommandError({
+            code: "NO_ENTRYPOINT",
+            message: "cannot start the brain detached: this host does not expose a CLI entry script",
+            details: "run `otto brain serve` in the foreground, or use the npm CLI (npm i -g @otto-code/cli)",
+        });
+    }
     const args = [...invocationVerbPrefix(command), "serve"];
     if (options.model)
         args.push("--model", options.model);

package/dist/models/download.js

@@ -4,7 +4,7 @@
  * `<managedModelsDir>/<publisher>/<repo>/<file>` to mirror the LM Studio layout
  * the scanner already understands.
  */
-import { createWriteStream, existsSync, mkdirSync } from "node:fs";
+import { createWriteStream, existsSync, mkdirSync, rmSync } from "node:fs";
 import path from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
@@ -41,6 +41,10 @@ function authHeaders(token) {
  * killed download never leaves a truncated file that looks complete.
  */
 async function streamRepoFile(url, destPath, label, token, onProgress, received) {
+    const tmp = `${destPath}.part`;
+    // Remove leftovers from an earlier interrupted attempt before starting a
+    // fresh request, including when this request fails before opening a stream.
+    rmSync(tmp, { force: true });
     mkdirSync(path.dirname(destPath), { recursive: true });
     if (existsSync(destPath))
         return false;
@@ -54,10 +58,16 @@ async function streamRepoFile(url, destPath, label, token, onProgress, received)
         received.bytes += chunk.length;
         onProgress?.({ file: label, receivedBytes: received.bytes, totalBytes });
     });
-    const tmp = `${destPath}.part`;
-    await pipeline(body, createWriteStream(tmp));
-    const { renameSync } = await import("node:fs");
-    renameSync(tmp, destPath);
+    try {
+        await pipeline(body, createWriteStream(tmp));
+        const { renameSync } = await import("node:fs");
+        renameSync(tmp, destPath);
+    }
+    finally {
+        // Cancellation kills the CLI child while the stream is still writing. Do
+        // not leave a truncated `.part` behind for the next quant attempt.
+        rmSync(tmp, { force: true });
+    }
     return true;
 }
 /** Download the model file; returns the local path it was written to. */

package/dist/service/activity.d.ts

@@ -58,6 +58,13 @@ export declare function withActivity<T>(kind: BrainActivityKind, options: {
  */
 export declare function chunkHasReasoning(text: string): boolean;
 export declare function chunkHasContent(text: string): boolean;
+export type InferenceStage = "processing" | "thinking" | "generating";
+export interface InferenceActivitySnapshot {
+    activeRequests: number;
+    processing: number;
+    thinking: number;
+    generating: number;
+}
 /**
  * Which in-flight completions are currently mid-thought.
  *
@@ -68,16 +75,29 @@ export declare function chunkHasContent(text: string): boolean;
  * if more reasoning follows - a stream that is producing readable output should
  * not report as though it were still silent.
  *
- * A set rather than a boolean because llama-server runs several slots at once,
- * and one request finishing its thought must not clear the flag for another.
+ * A map rather than one global phase because llama-server runs several slots at
+ * once. One request can be processing a prompt while another thinks and a third
+ * generates content; the aggregate counts must preserve all three.
  */
 export declare class ReasoningTracker {
     #private;
+    /**
+     * Watch stage counts, not the per-chunk traffic behind them.
+     *
+     * The status event stream needs to publish request start, the moment a model
+     * goes silent to think and the moment it starts answering. Repeated chunks in
+     * one stage do not notify; slot sampling owns bounded token-rate updates.
+     */
+    onChange(listener: () => void): () => void;
+    /** A completion was dispatched to llama-server and awaits its first output delta. */
+    begin(requestId: string): void;
     /** Note a chunk of `requestId`'s stream. Cheap enough to call per chunk. */
     observe(requestId: string, text: string): void;
     /** Forget the request. Must be called on end *and* on error, or the flag sticks. */
     end(requestId: string): void;
     get active(): boolean;
     get count(): number;
+    /** Aggregate request stages. Counts stay exact even with several parallel slots. */
+    get snapshot(): InferenceActivitySnapshot;
 }
 //# sourceMappingURL=activity.d.ts.map

package/dist/service/activity.js

@@ -3,10 +3,16 @@ 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 _ReasoningTracker_reasoning, _ReasoningTracker_content;
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _ReasoningTracker_instances, _ReasoningTracker_requests, _ReasoningTracker_tails, _ReasoningTracker_inlineReasoning, _ReasoningTracker_listeners, _ReasoningTracker_lastSnapshot, _ReasoningTracker_announce;
 /**
- * What long-running work currently owns the brain, and whether the loaded model
- * is mid-reasoning.
+ * What long-running work currently owns the brain, and which stage each live
+ * inference request has reached.
  *
  * Two trackers with deliberately different lifetimes:
  *
@@ -18,11 +24,11 @@ var _ReasoningTracker_reasoning, _ReasoningTracker_content;
  *   was killed with Ctrl-C never gets to clean up after itself, and a status
  *   that stays stuck on "calibrating" forever is worse than no status at all.
  *
- * - **Reasoning** is per-request and lives only as long as the stream does, so
+ * - **Inference** is per-request and lives only as long as the stream does, so
  *   it is plain in-process state on the router. It never touches disk.
  *
- * Both feed the one `activity` field on the host status, which the client turns
- * into the Brain rail's icon.
+ * Both ride on host status: ops under `activity`, inference under `inference`.
+ * The client uses those independent signals to drive the Overview and rail.
  */
 import { existsSync, readFileSync, rmSync } from "node:fs";
 import { resolveBrainPaths } from "../config/paths.js";
@@ -164,10 +170,14 @@ function clampProgress(progress) {
  * would cost more than the signal is worth.
  */
 export function chunkHasReasoning(text) {
-    return text.includes("thinking") || text.includes("reasoning");
+    return (/"type"\s*:\s*"(?:thinking|reasoning)_delta"/u.test(text) ||
+        /"(?:thinking|reasoning_content)"\s*:\s*"[^"]/u.test(text));
 }
 export function chunkHasContent(text) {
-    return text.includes('"text_delta"') || /"content"\s*:\s*"[^"]/.test(text);
+    return (/"type"\s*:\s*"text_delta"/u.test(text) ||
+        /"content"\s*:\s*"[^"]/u.test(text) ||
+        /"tool_calls"\s*:\s*\[\s*\{/u.test(text) ||
+        /"type"\s*:\s*"(?:tool_use|input_json_delta)"/u.test(text));
 }
 /**
  * Which in-flight completions are currently mid-thought.
@@ -179,38 +189,114 @@ export function chunkHasContent(text) {
  * if more reasoning follows - a stream that is producing readable output should
  * not report as though it were still silent.
  *
- * A set rather than a boolean because llama-server runs several slots at once,
- * and one request finishing its thought must not clear the flag for another.
+ * A map rather than one global phase because llama-server runs several slots at
+ * once. One request can be processing a prompt while another thinks and a third
+ * generates content; the aggregate counts must preserve all three.
  */
 export class ReasoningTracker {
     constructor() {
-        _ReasoningTracker_reasoning.set(this, new Set());
-        _ReasoningTracker_content.set(this, new Set());
+        _ReasoningTracker_instances.add(this);
+        _ReasoningTracker_requests.set(this, new Map());
+        /** Tail of the last transport chunk, so a field name split by TCP is still detected. */
+        _ReasoningTracker_tails.set(this, new Map());
+        /** Models/runtimes that leave reasoning inline as `<think>…</think>`. */
+        _ReasoningTracker_inlineReasoning.set(this, new Set());
+        _ReasoningTracker_listeners.set(this, new Set());
+        _ReasoningTracker_lastSnapshot.set(this, "0:0:0:0");
+    }
+    /**
+     * Watch stage counts, not the per-chunk traffic behind them.
+     *
+     * The status event stream needs to publish request start, the moment a model
+     * goes silent to think and the moment it starts answering. Repeated chunks in
+     * one stage do not notify; slot sampling owns bounded token-rate updates.
+     */
+    onChange(listener) {
+        __classPrivateFieldGet(this, _ReasoningTracker_listeners, "f").add(listener);
+        return () => __classPrivateFieldGet(this, _ReasoningTracker_listeners, "f").delete(listener);
+    }
+    /** A completion was dispatched to llama-server and awaits its first output delta. */
+    begin(requestId) {
+        if (__classPrivateFieldGet(this, _ReasoningTracker_requests, "f").has(requestId))
+            return;
+        __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").set(requestId, "processing");
+        __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_announce).call(this);
     }
     /** Note a chunk of `requestId`'s stream. Cheap enough to call per chunk. */
     observe(requestId, text) {
-        if (__classPrivateFieldGet(this, _ReasoningTracker_content, "f").has(requestId))
+        const current = __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").get(requestId);
+        if (current === "generating")
             return;
-        if (chunkHasContent(text)) {
-            __classPrivateFieldGet(this, _ReasoningTracker_content, "f").add(requestId);
-            __classPrivateFieldGet(this, _ReasoningTracker_reasoning, "f").delete(requestId);
+        if (!current)
+            __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").set(requestId, "processing");
+        // Node can split an SSE JSON field name at any byte. Keeping a small tail
+        // makes stage recognition independent of transport chunk boundaries without
+        // parsing or retaining the generated content itself.
+        const combined = `${__classPrivateFieldGet(this, _ReasoningTracker_tails, "f").get(requestId) ?? ""}${text}`;
+        __classPrivateFieldGet(this, _ReasoningTracker_tails, "f").set(requestId, combined.slice(-128));
+        if (__classPrivateFieldGet(this, _ReasoningTracker_inlineReasoning, "f").has(requestId)) {
+            if (combined.includes("</think>")) {
+                __classPrivateFieldGet(this, _ReasoningTracker_inlineReasoning, "f").delete(requestId);
+                __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").set(requestId, "generating");
+                __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_announce).call(this);
+            }
+            return;
+        }
+        if (combined.includes("<think>")) {
+            __classPrivateFieldGet(this, _ReasoningTracker_inlineReasoning, "f").add(requestId);
+            __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").set(requestId, "thinking");
+            __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_announce).call(this);
+            return;
+        }
+        if (chunkHasContent(combined)) {
+            __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").set(requestId, "generating");
+            __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_announce).call(this);
             return;
         }
-        if (chunkHasReasoning(text)) {
-            __classPrivateFieldGet(this, _ReasoningTracker_reasoning, "f").add(requestId);
+        if (chunkHasReasoning(combined) && current !== "thinking") {
+            __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").set(requestId, "thinking");
+            __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_announce).call(this);
         }
     }
     /** Forget the request. Must be called on end *and* on error, or the flag sticks. */
     end(requestId) {
-        __classPrivateFieldGet(this, _ReasoningTracker_reasoning, "f").delete(requestId);
-        __classPrivateFieldGet(this, _ReasoningTracker_content, "f").delete(requestId);
+        __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").delete(requestId);
+        __classPrivateFieldGet(this, _ReasoningTracker_tails, "f").delete(requestId);
+        __classPrivateFieldGet(this, _ReasoningTracker_inlineReasoning, "f").delete(requestId);
+        __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_announce).call(this);
     }
     get active() {
-        return __classPrivateFieldGet(this, _ReasoningTracker_reasoning, "f").size > 0;
+        return this.snapshot.thinking > 0;
     }
     get count() {
-        return __classPrivateFieldGet(this, _ReasoningTracker_reasoning, "f").size;
+        return this.snapshot.thinking;
+    }
+    /** Aggregate request stages. Counts stay exact even with several parallel slots. */
+    get snapshot() {
+        const result = {
+            activeRequests: __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").size,
+            processing: 0,
+            thinking: 0,
+            generating: 0,
+        };
+        for (const stage of __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").values())
+            result[stage] += 1;
+        return result;
     }
 }
-_ReasoningTracker_reasoning = new WeakMap(), _ReasoningTracker_content = new WeakMap();
+_ReasoningTracker_requests = new WeakMap(), _ReasoningTracker_tails = new WeakMap(), _ReasoningTracker_inlineReasoning = new WeakMap(), _ReasoningTracker_listeners = new WeakMap(), _ReasoningTracker_lastSnapshot = new WeakMap(), _ReasoningTracker_instances = new WeakSet(), _ReasoningTracker_announce = function _ReasoningTracker_announce() {
+    const snapshot = this.snapshot;
+    const key = `${snapshot.activeRequests}:${snapshot.processing}:${snapshot.thinking}:${snapshot.generating}`;
+    if (key === __classPrivateFieldGet(this, _ReasoningTracker_lastSnapshot, "f"))
+        return;
+    __classPrivateFieldSet(this, _ReasoningTracker_lastSnapshot, key, "f");
+    for (const listener of __classPrivateFieldGet(this, _ReasoningTracker_listeners, "f")) {
+        try {
+            listener();
+        }
+        catch {
+            // Status reporting must never break a proxied completion.
+        }
+    }
+};
 //# sourceMappingURL=activity.js.map

package/dist/service/host-api.d.ts

@@ -26,7 +26,16 @@ import type { RankedModel } from "../ops/results.js";
 import type { GpuInfo, Model } from "../types.js";
 import * as vram from "../vram.js";
 import type { SystemSample } from "../sysmon.js";
+import type { BrainStatusPublisher } from "./status-events.js";
 import type { Supervisor } from "./supervisor.js";
+/**
+ * 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 declare const HOST_API_VERSION = 2;
 /**
  * What this brain can serve. The daemon folds this into `brain.host.status` and
  * Otto gates each tab on it, because the daemon and the brain version
@@ -52,6 +61,17 @@ export interface HostCapabilities {
     rename: boolean;
     /** POST /__host/model/rename/reset */
     reset: boolean;
+    /**
+     * GET /__host/events: a live SSE stream of complete status snapshots.
+     *
+     * The one capability a daemon reads *before* deciding how to watch this brain.
+     * False (including on every brain that predates the stream) means the daemon
+     * keeps polling `/__host/status`, which is why nothing about the older
+     * management API had to change for this to ship.
+     */
+    events: boolean;
+    /** Bounded live inference stages, token counts and throughput on status events. */
+    liveInference: boolean;
     /** Whether writes are currently permitted (allowRemoteConfig). */
     writable: boolean;
 }
@@ -72,6 +92,12 @@ export interface HostApiDeps {
     /** The managed models directory, for disk accounting. Null when unresolvable. */
     getModelsDir: () => string | null;
     sampleResources: () => Promise<SystemSample>;
+    /**
+     * The live status source behind `GET /__host/events`. Absent (or not yet
+     * carrying a snapshot source) means this brain does not advertise events and
+     * its daemon keeps polling status.
+     */
+    statusEvents?: BrainStatusPublisher | null;
 }
 /** One row of the model inventory: the scan, metadata, profile and score joined. */
 export interface InventoryRow {

package/dist/service/host-api.js

@@ -7,6 +7,23 @@ 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";
@@ -105,6 +122,11 @@ export function createHostApi(deps) {
         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. */
@@ -216,7 +238,13 @@ export function createHostApi(deps) {
                 return;
             }
             updateDisplayName(model.id, displayName);
-            sendJson(res, { 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) => {
@@ -333,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/"))
@@ -345,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;

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