@otto-code/brain 0.8.8 → 0.8.10

package/dist/config/profile-edit.js

@@ -47,25 +47,38 @@ export const MAX_PARALLEL_SLOTS = 16;
 export const MAX_GPU_LAYERS = 999;
 export const MIN_CONTEXT_SIZE = 1024;
 export const CONTEXT_STEP = 8192;
+export const CONTEXT_MULTIPLIERS = [1, 2, 4];
 /** The context ceiling: the model's native window, or a generous bound if unknown. */
 export function nativeContextLimit(model) {
     const native = model?.metadata?.contextLength;
     return typeof native === "number" && native > 0 ? native : 1000000;
 }
+export function contextLimit(model, multiplier = 1) {
+    return nativeContextLimit(model) * multiplier;
+}
 /** The editable fields, resolved against one model's capabilities. */
-export function profileFieldDescriptors(model) {
+export function profileFieldDescriptors(model, profile) {
     const projector = model?.components?.find((component) => component.role === "vision_projector");
     const hasProjector = model?.components
         ? Boolean(projector?.available)
         : Boolean(model?.mmprojPath);
     const fields = [
+        {
+            key: "contextMultiplier",
+            label: "Context multiplier",
+            kind: "cycle",
+            options: CONTEXT_MULTIPLIERS,
+            optionLabels: ["Off", "2× (YaRN)", "4× (YaRN)"],
+            available: Boolean(model?.metadata?.contextLength),
+            ...(model?.metadata?.contextLength ? {} : { unavailableReason: "native context unknown" }),
+        },
         {
             key: "contextSize",
             label: "Context",
             kind: "number",
             step: CONTEXT_STEP,
             min: MIN_CONTEXT_SIZE,
-            max: nativeContextLimit(model),
+            max: contextLimit(model, profile?.contextMultiplier ?? 1),
             available: true,
         },
         {
@@ -160,6 +173,17 @@ export function profileWarnings(profile, model, store) {
             blocksStart: false,
         });
     }
+    if (profile.contextMultiplier > 1) {
+        warnings.push({
+            field: "contextMultiplier",
+            severity: "warn",
+            message: `YaRN ×${profile.contextMultiplier} extrapolates beyond the native context. Recalibrate before relying on this profile.`,
+            blocksStart: false,
+        });
+    }
+    // Distinct from `calibrationRequired`, which says this profile has never been
+    // measured in its current shape. This says a measurement exists but was taken
+    // for other cache types, so it names the reason rather than just the verdict.
     if (model && store && hasStaleCalibration(store, model, profile)) {
         warnings.push({
             field: "cacheTypeK",
@@ -176,6 +200,17 @@ export function profileWarnings(profile, model, store) {
  * model's layer count, which the UI must never present as measured on this file.
  */
 export function calibrationInfo(store, model, profile) {
+    // A historical measurement is invalid as soon as any VRAM-affecting setting
+    // changes. Keep the data for comparison, but do not present or use it as the
+    // current model budget until a calibration commits the new profile.
+    if (profile.calibrationRequired) {
+        return {
+            state: "theoretical",
+            kvBytesPerToken: null,
+            measuredAt: null,
+            measuredOn: null,
+        };
+    }
     const calibration = getCalibration(store, model, profile);
     if (!calibration) {
         return {
@@ -195,6 +230,25 @@ export function calibrationInfo(store, model, profile) {
 function clamp(value, min, max) {
     return Math.max(min, Math.min(max, value));
 }
+/** The settings whose value changes what a calibration would measure. */
+const CALIBRATION_INPUTS = [
+    "contextMultiplier",
+    "contextSize",
+    "cacheTypeK",
+    "cacheTypeV",
+    "flashAttention",
+    "gpuLayers",
+    "parallelSlots",
+    "vision",
+    "enabledComponents",
+];
+/** Every calibration input is a scalar except the component id list, which is a set. */
+function sameCalibrationInput(before, after) {
+    if (Array.isArray(before) && Array.isArray(after)) {
+        return [...before].sort().join("\0") === [...after].sort().join("\0");
+    }
+    return before === after;
+}
 /**
  * Apply an editable patch to a profile, clamping every field to its range and
  * dropping anything the model cannot use.
@@ -206,7 +260,7 @@ function clamp(value, min, max) {
  * CLI-only: they have no measured effect worth exposing and `extraArgs` is
  * arbitrary process arguments.
  */
-export function sanitizeProfilePatch(current, patch, model) {
+export function sanitizeProfilePatch(current, patch, model, runtimeBuild = null) {
     const adjustments = [];
     const next = { ...current };
     if (typeof patch !== "object" || patch === null || Array.isArray(patch)) {
@@ -245,7 +299,14 @@ export function sanitizeProfilePatch(current, patch, model) {
         }
         next[key] = value;
     };
-    takeNumber("contextSize", MIN_CONTEXT_SIZE, nativeContextLimit(model));
+    if ("contextMultiplier" in p) {
+        const raw = p.contextMultiplier;
+        if (typeof raw !== "number" || !CONTEXT_MULTIPLIERS.includes(raw)) {
+            throw new Error("contextMultiplier must be one of 1, 2, or 4");
+        }
+        next.contextMultiplier = raw;
+    }
+    takeNumber("contextSize", MIN_CONTEXT_SIZE, contextLimit(model, next.contextMultiplier));
     takeCacheType("cacheTypeK");
     takeCacheType("cacheTypeV");
     takeBoolean("flashAttention");
@@ -283,6 +344,14 @@ export function sanitizeProfilePatch(current, patch, model) {
             throw new Error("enabledComponents must be an array of component ids");
         }
         const requested = [...new Set(p.enabledComponents)];
+        const requiredBuild = requested
+            .map((id) => model?.components?.find((component) => component.id === id))
+            .find((component) => component?.minRuntimeBuild !== undefined &&
+            (runtimeBuild === null || runtimeBuild < component.minRuntimeBuild))?.minRuntimeBuild;
+        if (requiredBuild !== undefined) {
+            const active = runtimeBuild === null ? "unknown" : `b${runtimeBuild}`;
+            throw new Error(`components require llama.cpp build b${requiredBuild} or newer (active build: ${active})`);
+        }
         const available = new Set(model?.components
             ?.filter((component) => component.available)
             .map((component) => component.id) ?? []);
@@ -294,6 +363,27 @@ export function sanitizeProfilePatch(current, patch, model) {
         if (model?.components)
             next.vision = Boolean(projector);
     }
+    // A partial patch may lower the multiplier without naming contextSize. Clamp
+    // the saved value after every field has settled so launch args can never keep
+    // an extended context after YaRN has been turned off.
+    const contextSize = clamp(next.contextSize, MIN_CONTEXT_SIZE, contextLimit(model, next.contextMultiplier));
+    if (contextSize !== next.contextSize) {
+        next.contextSize = contextSize;
+        adjustments.push(`contextSize clamped to ${contextSize}`);
+    }
+    // The saved profile carries the calibration verdict. Do not infer it from
+    // whether an old measurement happens to exist: a person who changes settings,
+    // leaves, and returns must still be told to calibrate this new configuration.
+    //
+    // Compare values, never key presence. The editor autosaves the whole draft on
+    // every edit, so every one of these keys is in `p` every time; keying off
+    // presence threw away a real measurement whenever any unrelated field - or a
+    // hosting-profile choice, which does not touch VRAM at all - was saved.
+    const before = current;
+    const after = next;
+    if (CALIBRATION_INPUTS.some((key) => !sameCalibrationInput(before[key], after[key]))) {
+        next.calibrationRequired = true;
+    }
     return { profile: next, adjustments };
 }
 //# sourceMappingURL=profile-edit.js.map

package/dist/config/profiles.js

@@ -17,6 +17,8 @@ export function defaultProfile(model, defaults) {
         // Long context is the point of this hardware; start at the native limit and
         // let the VRAM budget pull it down.
         contextSize: Math.min(nativeContext, contextCap),
+        contextMultiplier: 1,
+        calibrationRequired: true,
         cacheTypeK: defaults?.cacheTypeK ?? "q8_0",
         cacheTypeV: defaults?.cacheTypeV ?? "q8_0",
         flashAttention: defaults?.flashAttention ?? true, // required for a quantised V cache
@@ -34,6 +36,13 @@ export function defaultProfile(model, defaults) {
         batchSize: null,
         ubatchSize: null,
         extraArgs: [],
+        hostingProfileId: null,
+        // Inherit, not off: a new model in a family that has a default should use
+        // it. With no family default configured this resolves to nothing anyway.
+        hostingProfileMode: "inherit",
+        chatTemplateFile: null,
+        chatTemplateKwargs: {},
+        chatSystemAddendum: null,
     };
 }
 /** Stored profile for a model, falling back to computed defaults. */
@@ -58,6 +67,15 @@ export function forModel(store, model, defaults) {
     return {
         ...base,
         ...stored,
+        // COMPAT(hostingProfileMode): added in v0.8.8, remove after 2027-02-12.
+        // The first hosting-profile store only had an id, and a non-null id there
+        // was an explicit custom choice. Such a profile parses as `inherit` (the
+        // schema default), so promote it. Writers hold the inverse invariant - the
+        // id is nulled whenever the mode is not `custom` - so a stored id can only
+        // mean a legacy record, never a stale leftover of a newer explicit choice.
+        hostingProfileMode: stored.hostingProfileId && stored.hostingProfileMode === "inherit"
+            ? "custom"
+            : stored.hostingProfileMode,
         enabledComponents,
         modelPath: model.modelPath,
         mmprojPath: mmproj?.path ?? (model.components ? null : model.mmprojPath),
@@ -72,12 +90,13 @@ export function put(store, model, profile) {
 /** Calibration is keyed by cache types, since those change bytes/token. */
 export function calibrationKey(profile) {
     const components = [...(profile.enabledComponents ?? [])].sort();
+    const multiplier = profile.contextMultiplier > 1 ? `:contextMultiplier=${profile.contextMultiplier}` : "";
     // COMPAT(bundleCalibrationKey): added in v0.8.7, remove after 2027-02-11.
     // A main-model-only load remains the historical identity; any enabled bundle
     // artifact gets a distinct key and therefore cannot claim that measurement.
     return components.length
-        ? `${profile.cacheTypeK}:${profile.cacheTypeV}:components=${components.join(",")}`
-        : `${profile.cacheTypeK}:${profile.cacheTypeV}`;
+        ? `${profile.cacheTypeK}:${profile.cacheTypeV}${multiplier}:components=${components.join(",")}`
+        : `${profile.cacheTypeK}:${profile.cacheTypeV}${multiplier}`;
 }
 /**
  * True when this model has a stored calibration, but for different cache types
@@ -167,6 +186,10 @@ export function putCalibration(store, model, profile, measurement) {
             writable: true,
         });
     }
+    // Calibration is a durable verdict about the persisted model profile, not a
+    // transient UI hint. Every completion path (CLI, TUI, and host job) shares
+    // this helper, so clearing it here keeps the state consistent everywhere.
+    put(store, model, { ...profile, calibrationRequired: false });
     return store;
 }
 //# sourceMappingURL=profiles.js.map