@otto-code/brain 0.8.9 → 0.8.12

package/dist/commands/calibrate.js

@@ -35,12 +35,19 @@ export async function runCalibrateCommand(options, _command) {
     const catalog = scanModels(config);
     const model = pickModel(catalog, options.model ?? store.lastModelId ?? undefined);
     const profile = forModel(store, model, config.defaults);
+    // A measurement from the previous run is the best prior on bytes/token for
+    // this exact profile shape. The sample cap uses it so the high sample never
+    // lands at a context that would spill the KV cache to CPU and bias the new
+    // slope low. Inherited family calibrations are excluded: they were measured
+    // on another file and are not a trustworthy budget input here.
+    const prior = getCalibration(store, model, profile);
     // Announced so the Brain rail can show the host as busy: a calibrate loads the
     // model at several context sizes and will make anything else queue behind it.
     const measurement = await withActivity("calibrate", { target: model.displayName }, () => calibrate({
         runtime,
         model,
         profile,
+        priorCalibration: prior && !prior.inherited ? prior : null,
         onProgress: (p) => {
             if (p.phase === "loading")
                 process.stderr.write(`  loading at ${p.contextSize?.toLocaleString()} ctx…\n`);
@@ -48,6 +55,8 @@ export async function runCalibrateCommand(options, _command) {
                 process.stderr.write(`    used ${vram.formatGiB(p.deltaBytes ?? 0)}\n`);
             if (p.phase === "skip")
                 process.stderr.write(`  skipped ${p.contextSize}: ${p.reason}\n`);
+            if (p.phase === "failed")
+                process.stderr.write(`  failed at ${p.contextSize?.toLocaleString()}: ${p.error ?? p.reason}\n`);
         },
     }));
     putCalibration(store, model, profile, measurement);

package/dist/commands/catalog.d.ts

@@ -14,6 +14,7 @@ export interface CatalogRow {
     id: string;
     name: string;
     family: string | null;
+    favorite: boolean;
     installed: boolean;
     publisher: string;
     repo: string;

package/dist/commands/catalog.js

@@ -30,6 +30,7 @@ export async function runCatalogCommand(_options, _command) {
         id: model.id,
         name: model.name,
         family: model.family ?? null,
+        favorite: model.favorite,
         installed: installedCatalogIds.has(model.id),
         publisher: model.publisher ?? "",
         repo: model.hfRepo,

package/dist/commands/pull.d.ts

@@ -18,6 +18,7 @@ export interface PullOptionsInput {
     quant?: string;
     listQuants?: boolean;
     component?: string[];
+    componentsOnly?: boolean;
 }
 export declare function runPullCommand(modelArg: string, options: PullOptionsInput, _command: Command): Promise<AnyCommandResult<PullRow>>;
 //# sourceMappingURL=pull.d.ts.map

package/dist/commands/pull.js

@@ -40,13 +40,16 @@ function findCatalogModel(models, needle) {
     return matches[0];
 }
 export function addPullOptions(cmd) {
-    return cmd
+    return (cmd
         .description("Download a model from the catalog")
         .argument("<model>", "catalog id or name fragment")
         .option("--file <name.gguf>", "explicit GGUF file name in the repo")
         .option("--quant <label>", "download a specific quantization (e.g. Q5_K_M)")
         .option("--component <id...>", "download optional bundle component ids")
-        .option("--list-quants", "list the quantizations the repo offers and exit");
+        // The daemon uses this for a bundle job that gained companions after its
+        // primary transfer began. It is deliberately not a normal user action.
+        .option("--components-only", "download selected bundle components without the primary quant")
+        .option("--list-quants", "list the quantizations the repo offers and exit"));
 }
 export async function runPullCommand(modelArg, options, _command) {
     const config = loadBrainConfig();
@@ -67,7 +70,13 @@ export async function runPullCommand(modelArg, options, _command) {
                 message: `${model.hfRepo} has no ${options.quant}`,
             });
         }
-        const plan = bundleDownloadPlan(model, options.component ?? [], choice?.files, choice?.sizeBytes);
+        if (options.componentsOnly && (options.component?.length ?? 0) === 0) {
+            throw new CommandError({
+                code: "NO_COMPONENT",
+                message: "--components-only requires at least one bundle component",
+            });
+        }
+        const plan = bundleDownloadPlan(model, options.component ?? [], options.componentsOnly ? [] : choice?.files, options.componentsOnly ? 0 : choice?.sizeBytes, !options.componentsOnly);
         const progressLabel = `${model.name}${choice ? ` ${choice.quant}` : ""}`;
         const written = await downloadRepoFilesWithProgress({
             activityTarget: model.name,

package/dist/commands/search.d.ts

@@ -30,5 +30,6 @@ export declare function runAddCommand(repo: string, options: {
     listQuants?: boolean;
     component?: string[];
     primaryOnly?: boolean;
+    componentsOnly?: boolean;
 }, _command: Command): Promise<AnyCommandResult<AddRow>>;
 //# sourceMappingURL=search.d.ts.map

package/dist/commands/search.js

@@ -80,6 +80,7 @@ export function addAddOptions(cmd) {
         .option("--quant <label>", "quantization to download (e.g. Q5_K_M)")
         .option("--component <id...>", "download optional discovered component ids")
         .option("--primary-only", "download only the selected primary quant")
+        .option("--components-only", "download selected bundle components without the primary quant")
         .option("--list-quants", "list the quantizations the repo offers and exit");
 }
 export async function runAddCommand(repo, options, _command) {
@@ -131,8 +132,17 @@ export async function runAddCommand(repo, options, _command) {
     const includeProjector = Boolean(mmproj) &&
         (requested.has("vision-projector") ||
             (!options.primaryOnly && options.component === undefined));
-    const files = [...choice.files, ...(includeProjector ? mmproj.files : [])];
-    const total = choice.sizeBytes + (includeProjector ? mmproj.sizeBytes : 0);
+    if (options.componentsOnly && !includeProjector) {
+        throw new CommandError({
+            code: "NO_COMPONENT",
+            message: "--components-only requires a selected bundle component",
+        });
+    }
+    const files = [
+        ...(options.componentsOnly ? [] : choice.files),
+        ...(includeProjector ? mmproj.files : []),
+    ];
+    const total = (options.componentsOnly ? 0 : choice.sizeBytes) + (includeProjector ? mmproj.sizeBytes : 0);
     const written = await downloadRepoFilesWithProgress({
         activityTarget: `${repo} (${choice.quant})`,
         progressLabel: `${repo} ${choice.quant}`,

package/dist/config/index.d.ts

@@ -6,6 +6,6 @@ export { parseBooleanEnv, applyEnvOverrides } from "./env.js";
 export { loadBrainConfig, loadPersistedConfig, saveBrainConfig, loadProfilesStore, saveProfilesStore, loadCatalog, } from "./store.js";
 export { defaultProfile, forModel, put, calibrationKey, geometryKey, getCalibration, putCalibration, hasStaleCalibration, } from "./profiles.js";
 export { effectiveHostingProfile, resolveHostingProfileForLaunch } from "./hosting-profiles.js";
-export { calibrationInfo, nativeContextLimit, profileFieldDescriptors, profileWarnings, sanitizeProfilePatch, formatReasoningBudget, CACHE_TYPE_CYCLE, REASONING_BUDGET_CYCLE, UNRESTRICTED_REASONING_BUDGET, type CalibrationInfo, type CalibrationState, type ProfileFieldDescriptor, type ProfileWarning, } from "./profile-edit.js";
+export { calibrationInfo, nativeContextLimit, profileFieldDescriptors, profileWarnings, sanitizeProfilePatch, formatReasoningBudget, CACHE_TYPE_CYCLE, REASONING_BUDGET_CYCLE, UNRESTRICTED_REASONING_BUDGET, PRESERVE_REASONING_CYCLE, SAMPLING_RANGES, preserveReasoningFromOption, preserveReasoningOption, type CalibrationInfo, type CalibrationState, type ProfileFieldDescriptor, type ProfileWarning, } from "./profile-edit.js";
 export * from "./schema.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/config/index.js

@@ -6,6 +6,6 @@ export { parseBooleanEnv, applyEnvOverrides } from "./env.js";
 export { loadBrainConfig, loadPersistedConfig, saveBrainConfig, loadProfilesStore, saveProfilesStore, loadCatalog, } from "./store.js";
 export { defaultProfile, forModel, put, calibrationKey, geometryKey, getCalibration, putCalibration, hasStaleCalibration, } from "./profiles.js";
 export { effectiveHostingProfile, resolveHostingProfileForLaunch } from "./hosting-profiles.js";
-export { calibrationInfo, nativeContextLimit, profileFieldDescriptors, profileWarnings, sanitizeProfilePatch, formatReasoningBudget, CACHE_TYPE_CYCLE, REASONING_BUDGET_CYCLE, UNRESTRICTED_REASONING_BUDGET, } from "./profile-edit.js";
+export { calibrationInfo, nativeContextLimit, profileFieldDescriptors, profileWarnings, sanitizeProfilePatch, formatReasoningBudget, CACHE_TYPE_CYCLE, REASONING_BUDGET_CYCLE, UNRESTRICTED_REASONING_BUDGET, PRESERVE_REASONING_CYCLE, SAMPLING_RANGES, preserveReasoningFromOption, preserveReasoningOption, } from "./profile-edit.js";
 export * from "./schema.js";
 //# sourceMappingURL=index.js.map

package/dist/config/profile-edit.d.ts

@@ -6,19 +6,88 @@ export interface ProfileFieldDescriptor {
     key: string;
     label: string;
     kind: ProfileFieldKind;
+    /**
+     * One sentence on what the field does, for the client's tooltip. It lives
+     * here rather than in the UI for the same reason the ranges do: a client that
+     * wrote its own copy would describe a setting the brain had since changed.
+     */
+    description?: string;
     /** For `number`: the increment a stepper should use. */
     step?: number;
     min?: number;
     max?: number;
+    /**
+     * For `number`: decimal places the value carries. Absent means an integer.
+     * A stepper MUST round to this after adding `step`, or repeated presses walk
+     * a sampler into 0.30000000000000004 and the profile stores that.
+     */
+    precision?: number;
     /** For `cycle`: the values to offer, in order. */
     options?: (string | number)[];
     /** Labels for `options`, index-aligned, when the raw value is not presentable. */
     optionLabels?: string[];
+    /**
+     * For `cycle`: what each option actually stores, index-aligned. Absent means
+     * the option IS the stored value, which is true of every cycle but the
+     * tri-states: `options` is limited to strings and numbers on the wire, so a
+     * field storing `true`/`false`/`null` needs somewhere to say so. A client
+     * matches the current value here first, then falls back to `options`.
+     */
+    optionValues?: (string | number | boolean | null)[];
     /** False when this model cannot use the field at all (vision with no projector). */
     available: boolean;
     /** Why it is unavailable, for the disabled-state hint. */
     unavailableReason?: string;
 }
+/**
+ * Sampler ranges. llama.cpp itself bounds almost none of these - it will take a
+ * temperature of 50 - so the bounds are the useful range rather than the legal
+ * one, which is what a stepper wants. The write path clamps to exactly these,
+ * so a value the editor cannot reach is a value the brain will not store.
+ */
+export declare const SAMPLING_RANGES: {
+    readonly temperature: {
+        readonly min: 0;
+        readonly max: 2;
+        readonly step: 0.05;
+        readonly precision: 2;
+    };
+    readonly topP: {
+        readonly min: 0;
+        readonly max: 1;
+        readonly step: 0.05;
+        readonly precision: 2;
+    };
+    readonly topK: {
+        readonly min: 0;
+        readonly max: 200;
+        readonly step: 1;
+    };
+    readonly minP: {
+        readonly min: 0;
+        readonly max: 1;
+        readonly step: 0.01;
+        readonly precision: 2;
+    };
+    readonly presencePenalty: {
+        readonly min: -2;
+        readonly max: 2;
+        readonly step: 0.05;
+        readonly precision: 2;
+    };
+    readonly repeatPenalty: {
+        readonly min: 0.5;
+        readonly max: 2;
+        readonly step: 0.01;
+        readonly precision: 2;
+    };
+};
+/** Tri-state preservation, in the order a cycle should offer it. */
+export declare const PRESERVE_REASONING_CYCLE: readonly ["default", "on", "off"];
+/** The stored value a cycle option maps to. */
+export declare function preserveReasoningFromOption(option: string): boolean | null;
+/** The cycle option a stored value maps to. */
+export declare function preserveReasoningOption(value: boolean | null | undefined): string;
 /**
  * The cache types the editor cycles through. `CACHE_TYPE_BYTES` knows more
  * (f32, bf16, q5_0, q4_1) and a write naming one of those is accepted; these
@@ -42,6 +111,19 @@ export declare const UNRESTRICTED_REASONING_BUDGET = -1;
  */
 export declare function formatReasoningBudget(budget: number): string;
 export declare const MAX_PARALLEL_SLOTS = 16;
+/**
+ * Ceiling on `cachedChats`. Generous on purpose: entries are small for a small
+ * model and huge for a large one, so the honest guard is the RAM figure the
+ * warning shows, not an arbitrary count.
+ */
+export declare const MAX_CACHED_CHATS = 64;
+/**
+ * What llama.cpp allows by default when no `--cache-ram` is emitted, in bytes.
+ * `cachedChats` of 0 emits no flag, so the estimate for the Default option is
+ * this fixed figure against the installed RAM - not the model's measured KV
+ * cost, which is irrelevant here because the size does not depend on the model.
+ */
+export declare const ENGINE_DEFAULT_CACHE_RAM_BYTES: number;
 export declare const MAX_GPU_LAYERS = 999;
 export declare const MIN_CONTEXT_SIZE = 1024;
 export declare const CONTEXT_STEP = 8192;
@@ -54,7 +136,12 @@ export declare function profileFieldDescriptors(model: Model | null, profile?: P
 /** A note attached to a field, or to the profile as a whole when `field` is null. */
 export interface ProfileWarning {
     field: string | null;
-    severity: "info" | "warn";
+    /**
+     * `info` renders as muted text, `warn` as yellow. `error` is red: the
+     * Cached KVs estimate earns it when the parked state would use at least the
+     * machine's whole RAM.
+     */
+    severity: "info" | "warn" | "error";
     message: string;
     /** True when this combination cannot start, as opposed to merely being unwise. */
     blocksStart: boolean;