@otto-code/brain 0.8.7 → 0.8.9

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;
@@ -26,6 +28,22 @@ export interface ModelFeatures {
     imatrix: boolean;
     distilled: boolean;
 }
+export type ModelComponentRole = "vision_projector" | "speculative_drafter";
+/** A catalog-declared companion artifact resolved against local disk. */
+export interface ModelComponent {
+    id: string;
+    label: string;
+    description: string;
+    role: ModelComponentRole;
+    path: string | null;
+    bytes: number;
+    required: boolean;
+    defaultDownload: boolean;
+    defaultLoad: boolean;
+    available: boolean;
+    unavailableReason?: string;
+    minRuntimeBuild?: number;
+}
 /** A GGUF model discovered on disk (or resolvable from the download catalog). */
 export interface Model {
     id: string;
@@ -57,10 +75,16 @@ 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[];
 }
 /** A resolved llama.cpp runtime: an executable paired with its vendor DLL dir. */
 export interface Runtime {
     label: string;
+    /** Human-readable runtime identity, separate from the filesystem-safe label. */
+    displayName?: string;
     version: string;
     dir: string;
     exe: string;

package/dist/vram.d.ts

@@ -21,6 +21,9 @@ export type BudgetSource = "measured" | "theoretical" | "unknown";
 export interface Budget {
     weightsBytes: number;
     mmprojBytes: number;
+    componentBytes: number;
+    drafterKvBytes: number;
+    imageProcessingBytes: number;
     kvBytes: number;
     overheadBytes: number;
     totalBytes: number;

package/dist/vram.js

@@ -35,7 +35,17 @@ export function theoreticalKvBytesPerToken(metadata, cacheTypeK, cacheTypeV) {
 /** Compute a VRAM budget for a profile. */
 export function budget({ model, profile, calibration = null, totalVramBytes, reserveBytes = 1.5 * GIB, }) {
     const weights = model.sizeBytes;
-    const mmproj = profile.vision && model.mmprojPath ? model.mmprojBytes : 0;
+    const enabled = new Set(profile.enabledComponents ?? []);
+    const components = model.components ?? [];
+    const projector = components.filter((component) => component.role === "vision_projector" && enabled.has(component.id) && component.available);
+    const drafters = components.filter((component) => component.role === "speculative_drafter" && enabled.has(component.id) && component.available);
+    const componentBytes = components.length
+        ? [...projector, ...drafters].reduce((total, component) => total + component.bytes, 0)
+        : profile.vision && model.mmprojPath
+            ? model.mmprojBytes
+            : 0;
+    const mmproj = projector.reduce((total, component) => total + component.bytes, 0) ||
+        (components.length ? 0 : componentBytes);
     const theoretical = theoreticalKvBytesPerToken(model.metadata, profile.cacheTypeK, profile.cacheTypeV);
     let kvBytesPerToken;
     let source;
@@ -52,14 +62,22 @@ export function budget({ model, profile, calibration = null, totalVramBytes, res
         source = "unknown";
     }
     const kv = kvBytesPerToken * profile.contextSize;
+    // The speculative decoder keeps its own KV cache. Until component-specific
+    // calibration exists, reserve the same conservative per-token cost.
+    const drafterKv = drafters.length * kv;
+    // Vision preprocessing needs transient GPU buffers in addition to weights.
+    const imageProcessing = projector.length * 256 * 1024 * 1024;
     // Compute buffers and the CUDA context; measured at ~0.6 GB for a 27B and
     // superseded by the calibrated value when available.
     const overhead = calibration && calibration.baseOverheadBytes > 0 ? calibration.baseOverheadBytes : 0.6 * GIB;
-    const total = weights + mmproj + kv + overhead;
+    const total = weights + componentBytes + kv + drafterKv + imageProcessing + overhead;
     const usable = totalVramBytes - reserveBytes;
     return {
         weightsBytes: weights,
         mmprojBytes: mmproj,
+        componentBytes,
+        drafterKvBytes: drafterKv,
+        imageProcessingBytes: imageProcessing,
         kvBytes: kv,
         overheadBytes: overhead,
         totalBytes: total,
@@ -85,14 +103,14 @@ export function maxContextThatFits({ model, profile, calibration, totalVramBytes
     });
     if (probe.kvBytesPerToken <= 0)
         return null;
-    const fixed = probe.weightsBytes + probe.mmprojBytes + probe.overheadBytes;
+    const fixed = probe.weightsBytes + probe.componentBytes + probe.imageProcessingBytes + probe.overheadBytes;
     const room = probe.usableBytes - fixed;
     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.7",
+  "version": "0.8.9",
   "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": {