@otto-code/brain 0.8.1 → 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/config/paths.d.ts

@@ -4,11 +4,13 @@ export interface BrainPaths {
     configFile: string;
     profilesFile: string;
     catalogFile: string;
+    renameMapFile: string;
     modelsDir: string;
     runtimesDir: string;
     pidFile: string;
     activityFile: string;
     logFile: string;
+    logsDir: string;
     resultsDir: string;
 }
 export declare function resolveBrainPaths(env?: NodeJS.ProcessEnv): BrainPaths;

package/dist/config/paths.js

@@ -15,6 +15,7 @@ export function resolveBrainPaths(env = process.env) {
         configFile: path.join(root, "config.json"),
         profilesFile: path.join(root, "profiles.json"),
         catalogFile: path.join(root, "catalog.json"),
+        renameMapFile: path.join(root, "rename-map.json"),
         modelsDir: path.join(root, "models"),
         runtimesDir: path.join(root, "runtimes"),
         pidFile: path.join(root, "otto-brain.pid"),
@@ -23,6 +24,7 @@ export function resolveBrainPaths(env = process.env) {
         // service - which is what answers /__host/status - never sees them otherwise.
         activityFile: path.join(root, "otto-brain.activity"),
         logFile: path.join(root, "otto-brain.log"),
+        logsDir: path.join(root, "logs"),
         resultsDir: path.join(root, "results"),
     };
 }

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/models/index.js

@@ -4,6 +4,7 @@ import { CatalogSchema } from "../config/schema.js";
 import { loadCatalog } from "../config/store.js";
 import { resolveModelsDirs } from "./dirs.js";
 import { enrichWithCatalog } from "./enrich.js";
+import { loadRenameMap } from "./rename-map.js";
 import { scan } from "./scan.js";
 export * from "./scan.js";
 export { pickModel, pickAutoModel } from "./pick.js";
@@ -30,6 +31,12 @@ export function scanModels(config, env = process.env, options = {}) {
         }
     }
     const enriched = enrichWithCatalog(all, loadCatalogSafe(env));
+    const renameMap = loadRenameMap(resolveBrainPaths(env));
+    for (const model of enriched) {
+        if (renameMap[model.id]) {
+            model.displayName = renameMap[model.id];
+        }
+    }
     enriched.sort((a, b) => a.displayName.localeCompare(b.displayName));
     return enriched;
 }

package/dist/models/rename-map.d.ts

@@ -0,0 +1,12 @@
+import { type BrainPaths } from "../config/paths.js";
+/** Every function here only ever touches renameMapFile; narrowed to that one
+ * field (rather than the full BrainPaths) so a test's fake paths object is
+ * actually type-checked instead of passing only because tsconfig excludes
+ * *.test.ts from the build. */
+type RenameMapPaths = Pick<BrainPaths, "renameMapFile">;
+export declare function loadRenameMap(paths?: RenameMapPaths): Record<string, string>;
+export declare function saveRenameMap(map: Record<string, string>, paths?: RenameMapPaths): void;
+export declare function updateDisplayName(modelId: string, displayName: string, paths?: RenameMapPaths): Record<string, string>;
+export declare function deleteDisplayName(modelId: string, paths?: RenameMapPaths): Record<string, string>;
+export {};
+//# sourceMappingURL=rename-map.d.ts.map

package/dist/models/rename-map.js

@@ -0,0 +1,39 @@
+/**
+ * User-defined model display-name overrides, keyed by model id, persisted at
+ * `$OTTO_HOME/otto-brain/rename-map.json`. Kept as its own file (rather than a
+ * field on the profiles store) so renaming a model never touches the
+ * calibration/profile data profiles.json carries.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { z } from "zod";
+import { resolveBrainPaths } from "../config/paths.js";
+import { writePrivateFileAtomicSync } from "../config/private-files.js";
+const RenameMapSchema = z.record(z.string());
+export function loadRenameMap(paths = resolveBrainPaths()) {
+    if (!existsSync(paths.renameMapFile))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(paths.renameMapFile, "utf8"));
+        const result = RenameMapSchema.safeParse(parsed);
+        return result.success ? result.data : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function saveRenameMap(map, paths = resolveBrainPaths()) {
+    writePrivateFileAtomicSync(paths.renameMapFile, `${JSON.stringify(map, null, 2)}\n`);
+}
+export function updateDisplayName(modelId, displayName, paths = resolveBrainPaths()) {
+    const map = loadRenameMap(paths);
+    map[modelId] = displayName;
+    saveRenameMap(map, paths);
+    return map;
+}
+export function deleteDisplayName(modelId, paths = resolveBrainPaths()) {
+    const map = loadRenameMap(paths);
+    delete map[modelId];
+    saveRenameMap(map, paths);
+    return map;
+}
+//# sourceMappingURL=rename-map.js.map

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
@@ -48,6 +57,21 @@ export interface HostCapabilities {
     resources: boolean;
     /** GET /__host/models */
     inventory: boolean;
+    /** POST /__host/model/rename */
+    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;
 }
@@ -68,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 {