@otto-code/brain 0.8.8 → 0.8.10

package/dist/service/serve.js

@@ -13,7 +13,7 @@ import { execFile, spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import http from "node:http";
 import https from "node:https";
-import { getCalibration, forModel, loadPersistedConfig, loadProfilesStore, saveBrainConfig, saveProfilesStore, } from "../config/index.js";
+import { getCalibration, forModel, loadPersistedConfig, loadProfilesStore, put, putCalibration, saveBrainConfig, saveProfilesStore, } from "../config/index.js";
 import { resolveBrainPaths } from "../config/paths.js";
 import { query as queryGpu } from "../gpu.js";
 import { managedModelsDir, pickAutoModel, pickModel, scanModels } from "../models/index.js";
@@ -22,6 +22,10 @@ import { resolveRuntime } from "../runtime/index.js";
 import * as vram from "../vram.js";
 import { resolveVersion } from "../version.js";
 import * as results from "../ops/results.js";
+import * as archive from "../ops/archive.js";
+import { calibrate } from "../ops/calibrate.js";
+import { sweep } from "../ops/sweep.js";
+import * as bench from "../bench/index.js";
 import { createCpuSampler, sample as sampleSystem } from "../sysmon.js";
 import { createHostApi } from "./host-api.js";
 import { errorMessage } from "./http-util.js";
@@ -58,14 +62,10 @@ function collectEvals() {
     }
 }
 const REMOTE_JOB_RETENTION_MS = 5 * 60000;
-/**
- * Runs a benchmark as a child of the brain service. This is intentionally here
- * rather than in the connecting daemon: its process, model store, results
- * directory and GPU all belong to the host that is being benchmarked.
- */
 class ServiceJobRunner {
-    constructor(onPullCompleted) {
+    constructor(onPullCompleted, runResidentJob) {
         this.onPullCompleted = onPullCompleted;
+        this.runResidentJob = runResidentJob;
         this.jobs = new Map();
     }
     start(kind, target, args) {
@@ -88,7 +88,26 @@ class ServiceJobRunner {
             startedAt: new Date().toISOString(),
             finishedAt: null,
             child: null,
+            controller: null,
         };
+        this.jobs.set(job.id, job);
+        if (kind === "calibrate" || kind === "sweep" || kind === "bench") {
+            const controller = new AbortController();
+            job.controller = controller;
+            void this.runResidentJob(kind, target, {
+                message: (value) => {
+                    if (job.status === "running")
+                        job.message = value.slice(-1000);
+                },
+                percent: (value) => {
+                    if (job.status === "running")
+                        job.percent = value;
+                },
+            }, controller.signal)
+                .then(() => this.finish(job, "succeeded", null))
+                .catch((error) => this.finish(job, controller.signal.aborted ? "canceled" : "failed", errorMessage(error)));
+            return this.publicJob(job);
+        }
         // The service is launched by the same CLI entry point as `otto-brain bench`.
         // Reusing that entry point keeps its config/path resolution on this host.
         const entry = process.argv[1];
@@ -101,7 +120,6 @@ class ServiceJobRunner {
             windowsHide: true,
         });
         job.child = child;
-        this.jobs.set(job.id, job);
         child.stderr?.setEncoding("utf8");
         child.stderr?.on("data", (chunk) => this.ingestOutput(job, chunk));
         child.once("error", (error) => this.finish(job, "failed", error.message));
@@ -166,8 +184,13 @@ class ServiceJobRunner {
     }
     async cancel(jobId) {
         const job = this.jobs.get(jobId);
-        if (!job || job.status !== "running" || !job.child)
+        if (!job || job.status !== "running")
+            return this.list();
+        if (!job.child) {
+            job.controller?.abort();
+            this.finish(job, "canceled", "Canceled.");
             return this.list();
+        }
         const child = job.child;
         if (process.platform === "win32" && child.pid) {
             await new Promise((resolve) => execFile("taskkill", ["/pid", String(child.pid), "/t", "/f"], () => resolve()));
@@ -196,13 +219,14 @@ class ServiceJobRunner {
         if (job.status !== "running")
             return;
         job.child = null;
+        job.controller = null;
         job.status = status;
         job.error = error;
         job.finishedAt = new Date().toISOString();
         if (status === "succeeded")
             job.percent = 100;
     }
-    publicJob({ child: _child, ...job }) {
+    publicJob({ child: _child, controller: _controller, ...job }) {
         return job;
     }
 }
@@ -334,7 +358,7 @@ export async function startService({ config, modelNeedle, env = process.env, onL
         }
     }
     const telemetry = new Telemetry();
-    const supervisor = new Supervisor({ runtime });
+    const supervisor = new Supervisor({ runtime, paths, getProfilesStore: () => store });
     supervisor.on("log", (line) => {
         runLog.write(line);
         if (/error|failed|warn/i.test(line))
@@ -367,6 +391,7 @@ export async function startService({ config, modelNeedle, env = process.env, onL
             fitProfile = fit.profile;
         }
         await supervisor.start(target, fitProfile);
+        delete store.pendingReloadModelIds[target.id];
         store.lastModelId = target.id;
         saveProfilesStore(store, paths);
     };
@@ -419,7 +444,153 @@ export async function startService({ config, modelNeedle, env = process.env, onL
     // /__host/events. One instance, so `capabilities.events` and the stream can
     // never disagree about whether this brain publishes.
     const statusEvents = new BrainStatusPublisher();
-    const jobs = new ServiceJobRunner(rescanCatalog);
+    const runResidentJob = async (kind, target, update, signal) => {
+        const ensureActive = () => {
+            if (signal.aborted)
+                throw new Error("Operation canceled.");
+        };
+        const modelId = target ?? supervisor.model?.id ?? store.lastModelId ?? null;
+        const targetModel = modelId
+            ? catalog.find((candidate) => candidate.id === modelId || candidate.displayName === modelId)
+            : null;
+        if (!targetModel)
+            throw new Error("No installed model is available for this operation.");
+        const restoreModel = supervisor.model;
+        const restoreProfile = supervisor.profile;
+        const restore = async () => {
+            if (restoreModel && restoreProfile && !signal.aborted) {
+                await supervisor.start(restoreModel, restoreProfile, { preserveLogs: true });
+            }
+        };
+        if (kind === "calibrate") {
+            const runtime = supervisor.runtime ?? resolveRuntime(config, env);
+            if (!runtime)
+                throw new Error("no llama.cpp runtime available; install one from the Library tab");
+            const profile = forModel(store, targetModel, config.defaults);
+            update.message(`Calibrating ${targetModel.displayName}`);
+            supervisor.recordLog(`operation calibrate: ${targetModel.displayName}`);
+            try {
+                const measurement = await calibrate({
+                    runtime,
+                    model: targetModel,
+                    profile,
+                    supervisor,
+                    onProgress: (event) => {
+                        ensureActive();
+                        const message = event.phase === "loading"
+                            ? `Calibrating ${event.contextSize.toLocaleString()} context`
+                            : event.phase === "measured"
+                                ? `Measured ${event.contextSize.toLocaleString()} context`
+                                : (event.reason ??
+                                    event.error ??
+                                    `Skipped ${event.contextSize.toLocaleString()} context`);
+                        update.message(message);
+                        supervisor.recordLog(`operation calibrate: ${message}`);
+                    },
+                });
+                ensureActive();
+                putCalibration(store, targetModel, profile, measurement);
+                saveProfilesStore(store, paths);
+                update.percent(100);
+                supervisor.recordLog(`operation calibrate: saved measurement for ${targetModel.displayName}`);
+            }
+            finally {
+                await restore();
+            }
+            return;
+        }
+        if (kind === "sweep") {
+            const runtime = supervisor.runtime ?? resolveRuntime(config, env);
+            if (!runtime)
+                throw new Error("no llama.cpp runtime available; install one from the Library tab");
+            const profile = forModel(store, targetModel, config.defaults);
+            update.message(`Sweeping ${targetModel.displayName}`);
+            supervisor.recordLog(`operation sweep: ${targetModel.displayName}`);
+            try {
+                const report = await sweep({
+                    runtime,
+                    model: targetModel,
+                    profile,
+                    supervisor,
+                    onProgress: (event) => {
+                        ensureActive();
+                        const message = event.phase === "loading"
+                            ? `Budget ${event.budget}: loading`
+                            : event.phase === "generating"
+                                ? `Budget ${event.budget}: generating`
+                                : event.phase === "done"
+                                    ? `Budget ${event.budget}: complete`
+                                    : `Budget ${event.budget}: ${event.error ?? "failed"}`;
+                        update.message(message);
+                        supervisor.recordLog(`operation sweep: ${message}`);
+                    },
+                });
+                ensureActive();
+                if (report.recommended !== null) {
+                    profile.reasoningBudget = report.recommended;
+                    put(store, targetModel, profile);
+                    saveProfilesStore(store, paths);
+                    supervisor.recordLog(`operation sweep: saved budget ${report.recommended}`);
+                }
+                update.percent(100);
+            }
+            finally {
+                await restore();
+            }
+            return;
+        }
+        update.message(`Benchmarking ${targetModel.displayName}`);
+        supervisor.recordLog(`operation benchmark: ${targetModel.displayName}`);
+        await loadModel(targetModel);
+        ensureActive();
+        supervisor.recordLog(`operation benchmark: resident model ready`);
+        const profile = supervisor.profile ?? forModel(store, targetModel, config.defaults);
+        const gpuInfo = await queryGpu();
+        const calibration = getCalibration(store, targetModel, profile);
+        const fit = gpuInfo
+            ? vram.fitToBudget({
+                model: targetModel,
+                profile,
+                calibration,
+                totalVramBytes: gpuInfo.totalBytes,
+            })
+            : null;
+        const archiveId = archive.runId(targetModel);
+        const report = await bench.runSuite({
+            host: supervisor.host,
+            port: supervisor.internalPort,
+            concurrency: 3,
+            reasoningBudget: profile.reasoningBudget ?? null,
+            contextWindow: profile.contextSize ?? null,
+            archiveId,
+            onProgress: (event) => {
+                ensureActive();
+                const message = event.title
+                    ? `${event.title}: ${event.phase}`
+                    : (event.summary ?? event.phase);
+                update.message(message);
+                supervisor.recordLog(`operation benchmark: ${message}`);
+            },
+        });
+        ensureActive();
+        results.save({
+            model: targetModel,
+            profile,
+            report,
+            gpu: gpuInfo,
+            runtime: supervisor.runtime
+                ? `${supervisor.runtime.label} v${supervisor.runtime.version}`
+                : "unknown runtime",
+            archiveId,
+            args: supervisor.args,
+            fit,
+            calibration,
+            suite: { execute: true, concurrency: 3, depths: null, only: null, mined: false },
+        });
+        update.percent(100);
+        supervisor.recordLog(`operation benchmark: saved result for ${targetModel.displayName}`);
+    };
+    const jobs = new ServiceJobRunner(rescanCatalog, runResidentJob);
     // Assigned once `stop` exists below. This indirection lets the management API
     // answer a remote restart request before closing its own socket.
     let requestRestart = () => { };
@@ -496,6 +667,7 @@ export async function startService({ config, modelNeedle, env = process.env, onL
     certManager?.start();
     if (model && profile && runtime) {
         await supervisor.start(model, profile);
+        delete store.pendingReloadModelIds[model.id];
         store.lastModelId = model.id;
         saveProfilesStore(store, paths);
     }

package/dist/service/supervisor.d.ts

@@ -1,7 +1,8 @@
 import { type ChildProcess } from "node:child_process";
 import { EventEmitter } from "node:events";
+import { type BrainPaths } from "../config/paths.js";
 import type { Model, Runtime } from "../types.js";
-import type { Profile } from "../config/schema.js";
+import type { Profile, ProfilesStore } from "../config/schema.js";
 /**
  * Default loopback port for the private llama-server child. Deliberately clear
  * of Otto's space: 8081 (the old default) is the Expo/Metro dev port, so a brain
@@ -19,6 +20,14 @@ export interface SupervisorOptions {
     internalPort?: number;
     host?: string;
     readyTimeoutMs?: number;
+    /**
+     * Long-lived hosts provide their live store so profile edits applied just
+     * before a model switch are visible without a second disk read. Standalone
+     * operations use the current persisted store, which still preserves the
+     * launch-resolution invariant.
+     */
+    paths?: BrainPaths;
+    getProfilesStore?: () => ProfilesStore;
 }
 export interface SupervisorStatus {
     state: SupervisorState;
@@ -44,6 +53,8 @@ export declare class Supervisor extends EventEmitter {
     internalPort: number;
     host: string;
     readyTimeoutMs: number;
+    paths: BrainPaths;
+    getProfilesStore: () => ProfilesStore;
     state: SupervisorState;
     child: ChildProcess | null;
     model: Model | null;
@@ -61,10 +72,27 @@ export declare class Supervisor extends EventEmitter {
      * shell line is for reading, not for re-parsing.
      */
     args: string[] | null;
-    constructor({ runtime, internalPort, host, readyTimeoutMs, }: SupervisorOptions);
+    constructor({ runtime, internalPort, host, readyTimeoutMs, paths, getProfilesStore, }: SupervisorOptions);
     get upstreamBase(): string;
-    /** Start (or restart) the server for a model + profile. */
-    start(model: Model, profile: Profile): Promise<this>;
+    /**
+     * Add a host-operation event to the same bounded tail as llama-server output.
+     *
+     * Calibrate, sweep, and benchmark deliberately reuse this supervisor rather
+     * than creating invisible sidecar servers. Their lifecycle markers belong in
+     * the same log stream as the child they exercise.
+     */
+    recordLog(line: string): void;
+    /**
+     * Start (or restart) the server for a model + profile.
+     *
+     * This is the sole llama-server launch boundary, so it materializes the
+     * selected hosting profile here. Keeping it beside `buildArgs()` makes the
+     * Jinja template and router-visible system addendum mandatory for every
+     * caller, including future maintenance operations that start a sidecar.
+     */
+    start(model: Model, profile: Profile, options?: {
+        preserveLogs?: boolean;
+    }): Promise<this>;
     /** Fetch /props from the running server (modalities, template caps, defaults). */
     props(): Promise<unknown>;
     stop(): Promise<void>;

package/dist/service/supervisor.js

@@ -8,6 +8,9 @@ import http from "node:http";
 import { spawn } from "node:child_process";
 import { EventEmitter } from "node:events";
 import { buildArgs, buildEnv, formatCommand } from "../runtime/index.js";
+import { resolveHostingProfileForLaunch } from "../config/hosting-profiles.js";
+import { resolveBrainPaths } from "../config/paths.js";
+import { loadProfilesStore } from "../config/store.js";
 import { usedBytes } from "../gpu.js";
 const LOG_LINES_KEPT = 300;
 /**
@@ -28,13 +31,15 @@ export const DEFAULT_INTERNAL_PORT = 20800;
  * stable one so switching models never asks a client to reconnect elsewhere.
  */
 export class Supervisor extends EventEmitter {
-    constructor({ runtime, internalPort = DEFAULT_INTERNAL_PORT, host = "127.0.0.1", readyTimeoutMs = 300000, }) {
+    constructor({ runtime, internalPort = DEFAULT_INTERNAL_PORT, host = "127.0.0.1", readyTimeoutMs = 300000, paths = resolveBrainPaths(), getProfilesStore = loadProfilesStore, }) {
         super();
         _Supervisor_instances.add(this);
         this.runtime = runtime;
         this.internalPort = internalPort;
         this.host = host;
         this.readyTimeoutMs = readyTimeoutMs;
+        this.paths = paths;
+        this.getProfilesStore = getProfilesStore;
         this.state = "stopped"; // stopped | starting | ready | failed
         this.child = null;
         this.model = null;
@@ -51,8 +56,25 @@ export class Supervisor extends EventEmitter {
     get upstreamBase() {
         return `http://${this.host}:${this.internalPort}`;
     }
-    /** Start (or restart) the server for a model + profile. */
-    async start(model, profile) {
+    /**
+     * Add a host-operation event to the same bounded tail as llama-server output.
+     *
+     * Calibrate, sweep, and benchmark deliberately reuse this supervisor rather
+     * than creating invisible sidecar servers. Their lifecycle markers belong in
+     * the same log stream as the child they exercise.
+     */
+    recordLog(line) {
+        __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_log).call(this, line);
+    }
+    /**
+     * Start (or restart) the server for a model + profile.
+     *
+     * This is the sole llama-server launch boundary, so it materializes the
+     * selected hosting profile here. Keeping it beside `buildArgs()` makes the
+     * Jinja template and router-visible system addendum mandatory for every
+     * caller, including future maintenance operations that start a sidecar.
+     */
+    async start(model, profile, options = {}) {
         await this.stop();
         if (!this.runtime) {
             this.lastError = "no llama.cpp runtime available";
@@ -60,13 +82,15 @@ export class Supervisor extends EventEmitter {
             throw new Error(this.lastError);
         }
         const runtime = this.runtime;
+        const launchProfile = resolveHostingProfileForLaunch(this.paths, this.getProfilesStore(), profile, model.family);
         this.model = model;
-        this.profile = profile;
+        this.profile = launchProfile;
         this.lastError = null;
-        this.logLines = [];
+        if (!options.preserveLogs)
+            this.logLines = [];
         this.vramBaselineBytes = await usedBytes();
         __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_setState).call(this, "starting");
-        const args = buildArgs({ ...profile, modelPath: model.modelPath, mmprojPath: model.mmprojPath }, { port: this.internalPort, host: this.host });
+        const args = buildArgs({ ...launchProfile, modelPath: model.modelPath, mmprojPath: model.mmprojPath }, { port: this.internalPort, host: this.host }, model);
         this.args = args;
         this.command = formatCommand(runtime, args);
         __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_log).call(this, `launching: ${this.command}`);

package/dist/tui/app.js

@@ -162,7 +162,7 @@ export class App {
         this.rankings = new Map(); // model id/name -> averaged benchmark rank + score
         this.rankedModels = []; // ranked list (mean of runs), best first | help
         this.telemetry = new Telemetry();
-        this.supervisor = new Supervisor({ runtime });
+        this.supervisor = new Supervisor({ runtime, getProfilesStore: () => this.store });
         this.routerServer = null;
         this.supervisor.on("state", () => this.draw());
         this.supervisor.on("log", () => {

package/dist/types.d.ts

@@ -5,6 +5,8 @@
  */
 export interface ModelMetadata {
     arch?: string | null;
+    name?: string | null;
+    basename?: string | null;
     contextLength?: number | null;
     blockCount?: number | null;
     headCount?: number | null;
@@ -73,6 +75,8 @@ export interface Model {
     catalogId?: string;
     /** Back-reference: the hfRepo of the reconciled catalog entry, if matched. */
     catalogHfRepo?: string;
+    /** Hosting-profile family from the catalog or normalized GGUF metadata. */
+    family?: string;
     /** Present only when this catalog entry declares a component manifest. */
     components?: ModelComponent[];
 }

package/dist/vram.js

@@ -108,9 +108,9 @@ export function maxContextThatFits({ model, profile, calibration, totalVramBytes
     if (room <= 0)
         return null;
     const tokens = Math.floor(room / probe.kvBytesPerToken);
-    const capped = model.metadata?.contextLength
-        ? Math.min(tokens, model.metadata.contextLength)
-        : tokens;
+    const native = model.metadata?.contextLength;
+    const contextLimit = typeof native === "number" && native > 0 ? native * profile.contextMultiplier : tokens;
+    const capped = Math.min(tokens, contextLimit);
     return Math.max(0, Math.floor(capped / step) * step);
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@otto-code/brain",
-  "version": "0.8.8",
+  "version": "0.8.10",
   "description": "Otto Brain - self-contained host for local GGUF models, with measured VRAM budgeting and reasoning-budget control",
   "license": "AGPL-3.0-or-later",
   "bin": {