@otto-code/brain 0.8.8 → 0.8.10

package/dist/config/schema.js

@@ -25,11 +25,54 @@ export const ProfileSchema = z
     reasoningBudget: z.number().default(1536),
     reasoningBudgetMessage: z.string().default(DEFAULT_REASONING_MESSAGE),
     parallelSlots: z.number().default(1),
+    /** RoPE extension factor; 1 keeps the GGUF-native context window. */
+    contextMultiplier: z.number().default(1),
+    /** Cleared only by a successful calibration of this saved model profile. */
+    calibrationRequired: z.boolean().default(true),
     batchSize: z.number().nullable().default(null),
     ubatchSize: z.number().nullable().default(null),
     extraArgs: z.array(z.string()).default([]),
+    /** The selected profile id when `hostingProfileMode` is `custom`. */
+    hostingProfileId: z.string().nullable().default(null),
+    /**
+     * Whether this model inherits its family's profile, disables profiles, or
+     * selects one itself. `inherit` is the default because it is what a profile
+     * stored before this field existed meant: the family default applied to
+     * every model in the family that had not overridden it. Defaulting to `off`
+     * would silently drop that default on every profile written by an older
+     * Brain. With no family default set, `inherit` resolves to nothing, which
+     * is exactly what `off` does, so the safe default costs nothing.
+     */
+    hostingProfileMode: z.enum(["inherit", "off", "custom"]).default("inherit"),
+    /** Derived at load time from the selected Brain-owned hosting profile. */
+    chatTemplateFile: z.string().nullable().default(null),
+    /** Derived at load time; passed directly to llama-server's Jinja engine. */
+    chatTemplateKwargs: z.record(z.unknown()).default({}),
+    /**
+     * Derived at load time from the selected hosting profile's system-prompt
+     * addendum. The router injects it per request rather than the launcher
+     * baking it into a CLI flag; see `hosting-profiles.ts` for why.
+     */
+    chatSystemAddendum: z.string().nullable().default(null),
 })
     .passthrough();
+/**
+ * A named, Brain-owned inference composition. The template is intentionally
+ * text, rather than a user-owned path: remote Brains must be able to apply the
+ * same profile and no client is allowed to make llama-server read arbitrary
+ * files from its host.
+ */
+export const HostingProfileSchema = z
+    .object({
+    id: z.string(),
+    name: z.string(),
+    family: z.string(),
+    description: z.string().default(""),
+    template: z.string().nullable().default(null),
+    systemPromptAddendum: z.string().nullable().default(null),
+    templateKwargs: z.record(z.unknown()).default({}),
+})
+    .strict();
 export const CalibrationSampleSchema = z
     .object({
     contextSize: z.number(),
@@ -67,6 +110,16 @@ export const ProfilesStoreSchema = z
     profiles: z.record(ProfileSchema).default({}),
     calibrations: z.record(z.record(CalibrationSchema)).default({}),
     geometryCalibrations: z.record(GeometryCalibrationSchema).default({}),
+    /** Named reusable profiles, scoped to this Brain rather than any client. */
+    hostingProfiles: z.record(HostingProfileSchema).default({}),
+    /** Optional family default; individual model profiles may override it. */
+    familyHostingProfileIds: z.record(z.string().nullable()).default({}),
+    /**
+     * A saved edit made while that model was resident. It stays visible when
+     * the user leaves and revisits the model settings, and clears only after a
+     * successful fresh llama-server load of that model.
+     */
+    pendingReloadModelIds: z.record(z.boolean()).default({}),
     lastModelId: z.string().nullable().default(null),
 })
     .passthrough();
@@ -169,6 +222,8 @@ export const CatalogModelSchema = z
     /** Retired Otto-curated ids this canonical catalog entry replaces. */
     replaces: z.array(z.string()).optional(),
     name: z.string(),
+    /** Stable UI family identity. Otto clients resolve this to a monochrome glyph. */
+    family: z.string().optional(),
     publisher: z.string().optional(),
     hfRepo: z.string(),
     quant: z.string(),

package/dist/config/store.js

@@ -10,6 +10,7 @@ import { writePrivateFileAtomicSync } from "./private-files.js";
 import { packageRoot, resolveBrainPaths } from "./paths.js";
 import { BrainConfigSchema, CatalogSchema, ProfilesStoreSchema, } from "./schema.js";
 import { applyEnvOverrides } from "./env.js";
+import { seedBuiltinHostingProfiles } from "./builtin-hosting-profiles.js";
 function readJson(file, schema) {
     if (!existsSync(file))
         return null;
@@ -26,15 +27,24 @@ function writeJson(file, data) {
 // ------------------------------------------------------------------- profiles
 export function loadProfilesStore(paths = resolveBrainPaths()) {
     const current = readJson(paths.profilesFile, ProfilesStoreSchema);
-    if (current)
+    if (current) {
+        if (seedBuiltinHostingProfiles(current))
+            writeJson(paths.profilesFile, current);
         return current;
+    }
     const legacy = path.join(packageRoot(), "config", "profiles.json");
     const migrated = readJson(legacy, ProfilesStoreSchema);
     if (migrated) {
+        seedBuiltinHostingProfiles(migrated);
         writeJson(paths.profilesFile, migrated);
         return migrated;
     }
-    return ProfilesStoreSchema.parse({});
+    const seeded = ProfilesStoreSchema.parse({});
+    seedBuiltinHostingProfiles(seeded);
+    // A read-only command must not create profiles.json. In-memory seeding keeps
+    // built-ins available; the first real profile save persists the whole store.
+    // This avoids racing a running service that later writes its startup snapshot.
+    return seeded;
 }
 export function saveProfilesStore(store, paths = resolveBrainPaths()) {
     writeJson(paths.profilesFile, store);

package/dist/gguf.d.ts

@@ -35,6 +35,7 @@ interface GgufSummary {
     tensorCount: number;
     arch: string;
     name: string | null;
+    basename: string | null;
     sizeLabel: string | null;
     fileType: number | null;
     contextLength: number | null;

package/dist/gguf.js

@@ -210,6 +210,7 @@ export function summarize(file) {
         tensorCount,
         arch,
         name: meta["general.name"] || null,
+        basename: meta["general.basename"] || null,
         sizeLabel: meta["general.size_label"] || null,
         fileType: (meta["general.file_type"] ?? null),
         contextLength: (get("context_length") ?? null),

package/dist/models/download.js

@@ -98,6 +98,11 @@ async function streamRepoFile(url, destPath, label, token, onProgress, received)
     mkdirSync(path.dirname(destPath), { recursive: true });
     if (existsSync(destPath)) {
         clearPartial(tmp);
+        // A bundle plan counts every selected artifact. An artifact that is
+        // already present is complete work, not zero work, otherwise the progress
+        // denominator includes it while the numerator never can.
+        received.bytes += statSync(destPath).size;
+        onProgress?.({ file: label, receivedBytes: received.bytes });
         return false;
     }
     let partial = resumablePartial(tmp);

package/dist/models/enrich.d.ts

@@ -1,5 +1,11 @@
 import type { Catalog, CatalogModel } from "../config/schema.js";
 import type { Model } from "../types.js";
+/**
+ * Normalize a GGUF identity into the catalog's hosting-profile vocabulary.
+ * Architecture is a stable structural field; names are only fallbacks for
+ * headers whose architecture is absent or unrecognised.
+ */
+export declare function familyFromGgufMetadata(model: Model): string | undefined;
 /**
  * Find the catalog entry a scanned model belongs to, or null. A model matches
  * when its id path sits directly under the entry's hfRepo directory. When a repo

package/dist/models/enrich.js

@@ -19,6 +19,50 @@
  */
 import fs from "node:fs";
 import path from "node:path";
+/**
+ * Hosting-profile families deliberately use a small, curated vocabulary. It is
+ * a mix of publisher and model-line identities, so GGUF architecture names
+ * must be folded into the existing buckets rather than exposed directly.
+ */
+const FAMILY_BY_GGUF_IDENTIFIER = {
+    chatglm: "chatglm",
+    deepseek: "deepseek",
+    gemma: "gemma",
+    gptoss: "openai",
+    llama: "meta",
+    meta: "meta",
+    microsoft: "microsoft",
+    mistral: "mistral",
+    mixtral: "mistral",
+    nemotron: "nvidia",
+    nvidia: "nvidia",
+    openai: "openai",
+    phi: "microsoft",
+    qwen: "qwen",
+};
+/**
+ * Normalize a GGUF identity into the catalog's hosting-profile vocabulary.
+ * Architecture is a stable structural field; names are only fallbacks for
+ * headers whose architecture is absent or unrecognised.
+ */
+export function familyFromGgufMetadata(model) {
+    const metadata = model.metadata;
+    if (!metadata)
+        return undefined;
+    for (const value of [metadata.arch, metadata.basename, metadata.name]) {
+        if (typeof value !== "string")
+            continue;
+        const identifier = value
+            .trim()
+            .toLowerCase()
+            .replace(/[^a-z0-9]/gu, "");
+        for (const [prefix, family] of Object.entries(FAMILY_BY_GGUF_IDENTIFIER)) {
+            if (identifier.startsWith(prefix))
+                return family;
+        }
+    }
+    return undefined;
+}
 /** Normalize a repo/id path: forward slashes, lowercased, trailing slashes trimmed. */
 function normalizePath(value) {
     const normalized = value.replaceAll("\\", "/");
@@ -76,14 +120,18 @@ export function matchCatalogEntry(model, catalog) {
 export function enrichWithCatalog(models, catalog) {
     return models.map((model) => {
         const entry = matchCatalogEntry(model, catalog);
-        if (!entry)
-            return enrichDiscoveredProjector(model);
+        if (!entry) {
+            const enriched = enrichDiscoveredProjector(model);
+            const family = familyFromGgufMetadata(enriched);
+            return family ? { ...enriched, family } : enriched;
+        }
         const components = resolveComponents(model, entry);
         const projector = components?.find((component) => component.role === "vision_projector");
         return {
             ...model,
             catalogId: entry.id,
             catalogHfRepo: entry.hfRepo,
+            family: entry.family,
             components,
             // A manifest is authoritative. Do not pair a random same-directory
             // projector when the catalog declares the exact companion artifact.

package/dist/ops/calibrate.d.ts

@@ -1,3 +1,4 @@
+import { Supervisor } from "../service/supervisor.js";
 import type { Model, Runtime } from "../types.js";
 import type { Profile } from "../config/schema.js";
 /**
@@ -31,6 +32,8 @@ export interface CalibrateOptions {
     profile: Profile;
     samples?: number[];
     internalPort?: number;
+    /** Reuse the host's resident supervisor instead of creating a sidecar server. */
+    supervisor?: Supervisor;
     onProgress?: (event: CalibrateProgress) => void;
 }
 /** The measured KV-cache profile calibration produces. */
@@ -45,5 +48,5 @@ export interface CalibrationMeasurement {
     vision: boolean;
     measuredAt: string;
 }
-export declare function calibrate({ runtime, model, profile, samples, internalPort, onProgress, }: CalibrateOptions): Promise<CalibrationMeasurement>;
+export declare function calibrate({ runtime, model, profile, samples, internalPort, supervisor: optionsSupervisor, onProgress, }: CalibrateOptions): Promise<CalibrationMeasurement>;
 //# sourceMappingURL=calibrate.d.ts.map

package/dist/ops/calibrate.js

@@ -12,21 +12,24 @@ import { DEFAULT_INTERNAL_PORT, Supervisor } from "../service/supervisor.js";
  * buffers) cancels out of the difference.
  */
 export const DEFAULT_SAMPLES = [8192, 65536];
-export async function calibrate({ runtime, model, profile, samples = DEFAULT_SAMPLES, internalPort = DEFAULT_INTERNAL_PORT + 1, onProgress = () => { }, }) {
-    if (samples.length < 2)
+export async function calibrate({ runtime, model, profile, samples, internalPort = DEFAULT_INTERNAL_PORT + 1, supervisor: optionsSupervisor, onProgress = () => { }, }) {
+    const nativeContext = model.metadata?.contextLength ?? null;
+    const effectiveSamples = samples ??
+        (nativeContext ? [8192, nativeContext * profile.contextMultiplier] : DEFAULT_SAMPLES);
+    if (effectiveSamples.length < 2)
         throw new Error("calibration needs at least two context sizes");
-    const native = model.metadata?.contextLength || Math.max(...samples);
+    const native = (nativeContext || Math.max(...effectiveSamples)) * profile.contextMultiplier;
     const points = [];
-    for (const contextSize of samples) {
+    for (const contextSize of effectiveSamples) {
         if (contextSize > native) {
-            onProgress({ phase: "skip", contextSize, reason: `exceeds native context ${native}` });
+            onProgress({ phase: "skip", contextSize, reason: `exceeds configured context ${native}` });
             continue;
         }
-        const supervisor = new Supervisor({ runtime, internalPort });
+        const supervisor = optionsSupervisor ?? new Supervisor({ runtime, internalPort });
         onProgress({ phase: "loading", contextSize });
         const baseline = await usedBytes();
         try {
-            await supervisor.start(model, { ...profile, contextSize });
+            await supervisor.start(model, { ...profile, contextSize }, { preserveLogs: Boolean(optionsSupervisor) });
             const used = supervisor.vramAtReadyBytes ?? (await usedBytes());
             const delta = Number(used) - Number(supervisor.vramBaselineBytes ?? baseline);
             points.push({ contextSize, deltaBytes: delta, loadSeconds: supervisor.loadSeconds });

package/dist/ops/sweep.d.ts

@@ -70,8 +70,10 @@ export interface SweepOptions {
     maxTokens?: number;
     temperature?: number;
     internalPort?: number;
+    /** Reuse the host's resident supervisor instead of creating a sidecar server. */
+    supervisor?: Supervisor;
     onProgress?: (event: SweepProgress) => void;
 }
-export declare function sweep({ runtime, model, profile, budgets, maxTokens, temperature, internalPort, onProgress, }: SweepOptions): Promise<SweepReport>;
+export declare function sweep({ runtime, model, profile, budgets, maxTokens, temperature, internalPort, supervisor: optionsSupervisor, onProgress, }: SweepOptions): Promise<SweepReport>;
 export {};
 //# sourceMappingURL=sweep.d.ts.map

package/dist/ops/sweep.js

@@ -81,13 +81,13 @@ export async function runTrial({ supervisor, maxTokens, temperature, }) {
         contentPerSecond: elapsedSeconds > 0 ? content.length / elapsedSeconds : 0,
     };
 }
-export async function sweep({ runtime, model, profile, budgets = DEFAULT_BUDGETS, maxTokens = 8192, temperature = 0.7, internalPort = DEFAULT_INTERNAL_PORT + 2, onProgress = () => { }, }) {
+export async function sweep({ runtime, model, profile, budgets = DEFAULT_BUDGETS, maxTokens = 8192, temperature = 0.7, internalPort = DEFAULT_INTERNAL_PORT + 2, supervisor: optionsSupervisor, onProgress = () => { }, }) {
     const results = [];
     for (const budget of budgets) {
-        const supervisor = new Supervisor({ runtime, internalPort });
+        const supervisor = optionsSupervisor ?? new Supervisor({ runtime, internalPort });
         onProgress({ phase: "loading", budget });
         try {
-            await supervisor.start(model, { ...profile, reasoningBudget: budget });
+            await supervisor.start(model, { ...profile, reasoningBudget: budget }, { preserveLogs: Boolean(optionsSupervisor) });
             onProgress({ phase: "generating", budget });
             const trial = await runTrial({ supervisor, maxTokens, temperature });
             results.push({ budget, ...trial, error: null });

package/dist/runtime/args.d.ts

@@ -4,7 +4,7 @@
  * managed one, since both resolve to a `Runtime` (exe + optional vendorDir).
  */
 import type { Profile } from "../config/schema.js";
-import type { Runtime } from "../types.js";
+import type { Model, Runtime } from "../types.js";
 export interface ServeTarget {
     port: number;
     host?: string;
@@ -28,7 +28,7 @@ export declare function buildEnv(runtime: Runtime, baseEnv?: NodeJS.ProcessEnv,
  * Only settings that demonstrably matter for stable local inference are emitted -
  * no experimental sampler knobs.
  */
-export declare function buildArgs(profile: Profile, { port, host }: ServeTarget): string[];
+export declare function buildArgs(profile: Profile, { port, host }: ServeTarget, model?: Model): string[];
 /** The same command as a copy-pasteable shell line, for the TUI to display. */
 export declare function formatCommand(runtime: Runtime, args: string[]): string;
 //# sourceMappingURL=args.d.ts.map

package/dist/runtime/args.js

@@ -29,7 +29,7 @@ export function buildEnv(runtime, baseEnv = process.env, platform = process.plat
  * Only settings that demonstrably matter for stable local inference are emitted -
  * no experimental sampler knobs.
  */
-export function buildArgs(profile, { port, host = "127.0.0.1" }) {
+export function buildArgs(profile, { port, host = "127.0.0.1" }, model) {
     const args = [
         "-m",
         profile.modelPath ?? "",
@@ -66,10 +66,22 @@ export function buildArgs(profile, { port, host = "127.0.0.1" }) {
     }
     if (profile.parallelSlots)
         args.push("--parallel", String(profile.parallelSlots));
+    if (profile.contextMultiplier > 1) {
+        const nativeContext = model?.metadata?.contextLength;
+        args.push("--rope-scaling", "yarn", "--rope-scale", String(profile.contextMultiplier), ...(nativeContext ? ["--yarn-orig-ctx", String(nativeContext)] : []), ...(model?.metadata?.arch
+            ? ["--override-kv", `${model.metadata.arch}.context_length=int:${profile.contextSize}`]
+            : []));
+    }
     if (profile.batchSize)
         args.push("-b", String(profile.batchSize));
     if (profile.ubatchSize)
         args.push("-ub", String(profile.ubatchSize));
+    if (profile.chatTemplateFile) {
+        args.push("--chat-template-file", profile.chatTemplateFile);
+        if (Object.keys(profile.chatTemplateKwargs ?? {}).length > 0) {
+            args.push("--chat-template-kwargs", JSON.stringify(profile.chatTemplateKwargs));
+        }
+    }
     if (profile.extraArgs && profile.extraArgs.length)
         args.push(...profile.extraArgs);
     return args;

package/dist/runtime/index.d.ts

@@ -14,6 +14,13 @@ export declare function listAllRuntimes(env?: NodeJS.ProcessEnv): Runtime[];
 export declare function probeNvidiaGpu(): Promise<boolean>;
 /** The runtime to use given config, or null when none is available. */
 export declare function resolveRuntime(config: BrainConfig, env?: NodeJS.ProcessEnv): Runtime | null;
+/**
+ * The numeric llama.cpp build carried by a resolved runtime, when its source
+ * identifies one. LM Studio and explicit overrides need not expose their
+ * upstream build, so callers must treat null as incompatible with a component
+ * that declares a minimum build rather than guessing compatibility.
+ */
+export declare function runtimeBuild(runtime: Runtime | null | undefined): number | null;
 /** Ensure a runtime exists, downloading the default managed build if none does. */
 export declare function ensureRuntime(config: BrainConfig, env?: NodeJS.ProcessEnv, onProgress?: (progress: InstallProgress) => void, target?: RuntimeTarget): Promise<Runtime>;
 //# sourceMappingURL=index.d.ts.map

package/dist/runtime/index.js

@@ -44,6 +44,16 @@ export function resolveRuntime(config, env = process.env) {
         return lmstudio[0] ?? null;
     return managed[0] ?? lmstudio[0] ?? null; // auto
 }
+/**
+ * The numeric llama.cpp build carried by a resolved runtime, when its source
+ * identifies one. LM Studio and explicit overrides need not expose their
+ * upstream build, so callers must treat null as incompatible with a component
+ * that declares a minimum build rather than guessing compatibility.
+ */
+export function runtimeBuild(runtime) {
+    const match = /^b(\d+)$/iu.exec(runtime?.version ?? "");
+    return match ? Number(match[1]) : null;
+}
 /** Ensure a runtime exists, downloading the default managed build if none does. */
 export async function ensureRuntime(config, env = process.env, onProgress, target = {}) {
     const existing = resolveRuntime(config, env);

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

@@ -20,7 +20,7 @@
  */
 import type http from "node:http";
 import { calibrationInfo, profileWarnings } from "../config/profile-edit.js";
-import type { Profile, ProfileDefaults, ProfilesStore } from "../config/schema.js";
+import { type Profile, type ProfileDefaults, type ProfilesStore } from "../config/schema.js";
 import { planDelete } from "../models/manage.js";
 import type { RankedModel } from "../ops/results.js";
 import type { GpuInfo, Model } from "../types.js";
@@ -130,6 +130,8 @@ export interface HostApiDeps {
 export interface InventoryRow {
     id: string;
     displayName: string;
+    /** Curated model-family identity for the Otto Brain client glyph. */
+    family: string | null;
     publisher: string | null;
     quant: string | null;
     sizeBytes: number;
@@ -155,6 +157,19 @@ export interface InventoryRow {
     warnings: ReturnType<typeof profileWarnings>;
     components: NonNullable<Model["components"]> | null;
 }
+/**
+ * Apply the hosting-profile half of a profile patch, mutating both `profile`
+ * (this model's selection) and `store` (the shared library and family default).
+ *
+ * Separate from `sanitizeProfilePatch` because these keys are not profile
+ * fields: three of the five write to the store rather than the profile.
+ * Exported for testing - the ordering and the cross-profile cleanup are the
+ * parts worth pinning down, and they are unreachable through the HTTP surface
+ * without standing up a service.
+ *
+ * Throws on any invalid input; the caller turns that into a 400.
+ */
+export declare function applyHostingProfilePatch(store: ProfilesStore, model: Model, profile: Profile, patch: Record<string, unknown>, onDelete?: ((id: string) => void) | undefined): void;
 /**
  * Join one model's scan row, GGUF metadata, saved profile, calibration, VRAM
  * budget and benchmark score into the single shape the Models tab renders.
@@ -169,6 +184,7 @@ export declare function buildInventoryRow(params: {
     gpu: GpuInfo | null;
     ranking: RankedModel[];
     supervisor: Supervisor;
+    runtimeBuild?: number | null;
 }): InventoryRow;
 export interface HostApi {
     /** Returns true when it answered the request, false to fall through. */