@otto-code/brain 0.7.5

package/dist/config/schema.js

@@ -0,0 +1,191 @@
+/**
+ * Zod schemas for everything otto-brain persists. Following Otto's config
+ * conventions: a `version` literal, camelCase keys, `.strict()` on config the tool
+ * owns, `.passthrough()` on stores that must survive version skew (profiles carry
+ * measured data we never want a schema bump to silently drop).
+ */
+import { z } from "zod";
+export const DEFAULT_REASONING_MESSAGE = "Enough analysis. Write the complete answer now.";
+// --------------------------------------------------------------- profiles store
+export const ProfileSchema = z
+    .object({
+    modelId: z.string().nullable().default(null),
+    modelPath: z.string().nullable().default(null),
+    mmprojPath: z.string().nullable().default(null),
+    contextSize: z.number(),
+    cacheTypeK: z.string().default("q8_0"),
+    cacheTypeV: z.string().default("q8_0"),
+    flashAttention: z.boolean().default(true),
+    gpuLayers: z.number().default(999),
+    vision: z.boolean().default(false),
+    reasoningBudget: z.number().default(1536),
+    reasoningBudgetMessage: z.string().default(DEFAULT_REASONING_MESSAGE),
+    parallelSlots: z.number().default(1),
+    batchSize: z.number().nullable().default(null),
+    ubatchSize: z.number().nullable().default(null),
+    extraArgs: z.array(z.string()).default([]),
+})
+    .passthrough();
+export const CalibrationSampleSchema = z
+    .object({
+    contextSize: z.number(),
+    deltaBytes: z.number(),
+    loadSeconds: z.number().nullable().optional(),
+})
+    .strip();
+export const CalibrationSchema = z
+    .object({
+    kvBytesPerToken: z.number(),
+    baseOverheadBytes: z.number(),
+    theoreticalKvBytesPerToken: z.number().nullable().optional(),
+    theoreticalRatio: z.number().nullable().optional(),
+    samples: z.array(CalibrationSampleSchema).optional(),
+    cacheTypeK: z.string().optional(),
+    cacheTypeV: z.string().optional(),
+    vision: z.boolean().optional(),
+    measuredAt: z.string().optional(),
+    measuredOn: z.string().optional(),
+    inherited: z.boolean().optional(),
+})
+    .strip();
+export const GeometryCalibrationSchema = z
+    .object({
+    kvBytesPerTokenPerLayer: z.number(),
+    baseOverheadBytes: z.number(),
+    measuredAt: z.string().optional(),
+    measuredOn: z.string().optional(),
+    measuredLayers: z.number().optional(),
+})
+    .passthrough();
+export const ProfilesStoreSchema = z
+    .object({
+    version: z.literal(1).default(1),
+    profiles: z.record(ProfileSchema).default({}),
+    calibrations: z.record(z.record(CalibrationSchema)).default({}),
+    geometryCalibrations: z.record(GeometryCalibrationSchema).default({}),
+    lastModelId: z.string().nullable().default(null),
+})
+    .passthrough();
+// --------------------------------------------------------------- brain config
+export const ListenSchema = z
+    .object({
+    host: z.string().default("127.0.0.1"),
+    port: z.number().default(1234),
+})
+    .strict();
+/**
+ * Remote auth. `none` is only safe on a loopback bind; exposing the brain on a
+ * non-loopback host should carry a token. The service layer enforces this.
+ */
+export const AuthSchema = z
+    .object({
+    mode: z.enum(["none", "token"]).default("none"),
+    token: z.string().nullable().default(null),
+})
+    .strict();
+/**
+ * TLS termination, built into the brain so it can be exposed over HTTPS with no
+ * relay in front. Four modes:
+ *  - `off`      — plain HTTP (the default; loopback-only is the safe posture).
+ *  - `files`    — bring your own cert/key (a real cert, or one you manage).
+ *  - `self-signed` — generate a local keypair on first run, cached under `certDir`.
+ *  - `tailscale` — issue and auto-renew a real Let's Encrypt cert for this
+ *                  machine's MagicDNS name via `tailscaled` (no cert warnings on
+ *                  the tailnet). `hostname` is auto-detected when null.
+ * The service layer enforces that a non-loopback bind still carries auth.
+ */
+export const TlsSchema = z
+    .object({
+    mode: z.enum(["off", "files", "self-signed", "tailscale"]).default("off"),
+    // files mode:
+    certFile: z.string().nullable().default(null),
+    keyFile: z.string().nullable().default(null),
+    // tailscale / self-signed:
+    hostname: z.string().nullable().default(null),
+    // where issued/generated certs are cached; null => $OTTO_HOME/otto-brain/certs.
+    certDir: z.string().nullable().default(null),
+    renewBeforeDays: z.number().default(21),
+    checkIntervalMs: z.number().default(43200000),
+    tailscaleExe: z.string().nullable().default(null),
+})
+    .strict();
+export const RuntimeConfigSchema = z
+    .object({
+    // auto = prefer a managed runtime, fall back to LM Studio discovery.
+    source: z.enum(["auto", "managed", "lmstudio"]).default("auto"),
+    path: z.string().nullable().default(null),
+})
+    .strict();
+export const ProfileDefaultsSchema = z
+    .object({
+    cacheTypeK: z.string().default("q8_0"),
+    cacheTypeV: z.string().default("q8_0"),
+    flashAttention: z.boolean().default(true),
+    reasoningBudget: z.number().default(1536),
+    parallelSlots: z.number().default(1),
+    contextCap: z.number().default(225000),
+})
+    .strict();
+export const BrainConfigSchema = z
+    .object({
+    version: z.literal(1).default(1),
+    // Opt-in: Otto ships with the local brain off and never auto-starts it.
+    enabled: z.boolean().default(false),
+    autoStart: z.boolean().default(false),
+    listen: ListenSchema.default({}),
+    auth: AuthSchema.default({}),
+    tls: TlsSchema.default({}),
+    runtime: RuntimeConfigSchema.default({}),
+    // null => managed default ($OTTO_HOME/otto-brain/models), unioned with LM Studio.
+    modelsDir: z.string().nullable().default(null),
+    // Hugging Face access token for gated/private repo downloads. Env
+    // HF_TOKEN / HUGGING_FACE_HUB_TOKEN take precedence at read time; this is the
+    // persisted fallback so users can set it once (config set hfToken <token>).
+    hfToken: z.string().nullable().default(null),
+    defaultModel: z.string().nullable().default(null),
+    // Pin the host to a single model: serve only the default/resident model and
+    // refuse completion requests that name a different one, instead of queuing a
+    // switch. For hosts that load one model and must not thrash between clients.
+    lockModel: z.boolean().default(false),
+    // Sharing/control gates (off by default — a brain is not remotely
+    // controllable until its owner opts in). `allowRemoteConfig`: a client with
+    // the token may CHANGE config over the network (POST /__host/config), not
+    // just use/read. `allowInsecureBind`: permit a non-loopback bind with no
+    // token (an "open, trusted network" share) — otherwise the service refuses.
+    allowRemoteConfig: z.boolean().default(false),
+    allowInsecureBind: z.boolean().default(false),
+    defaults: ProfileDefaultsSchema.default({}),
+})
+    .strict();
+export const DEFAULT_BRAIN_CONFIG = BrainConfigSchema.parse({});
+// --------------------------------------------------------------- download catalog
+export const CatalogModelSchema = z
+    .object({
+    id: z.string(),
+    name: z.string(),
+    publisher: z.string().optional(),
+    hfRepo: z.string(),
+    quant: z.string(),
+    quantFile: z.string().optional(),
+    approxWeightsBytes: z.number().optional(),
+    params: z.string().optional(),
+    moe: z.boolean().optional(),
+    vision: z.boolean().optional(),
+    thinking: z.boolean().optional(),
+    contextMax: z.number().optional(),
+    useCases: z.array(z.string()).optional(),
+    tier: z.string().optional(),
+    why: z.string().optional(),
+    status: z.string().optional(),
+})
+    .passthrough();
+export const CatalogSchema = z
+    .object({
+    version: z.literal(1).default(1),
+    note: z.string().optional(),
+    vramBudgetBytes: z.number().optional(),
+    systemRamBytes: z.number().optional(),
+    models: z.array(CatalogModelSchema).default([]),
+})
+    .passthrough();
+//# sourceMappingURL=schema.js.map

package/dist/config/store.d.ts

@@ -0,0 +1,11 @@
+import { type BrainPaths } from "./paths.js";
+import { type BrainConfig, type Catalog, type ProfilesStore } from "./schema.js";
+export declare function loadProfilesStore(paths?: BrainPaths): ProfilesStore;
+export declare function saveProfilesStore(store: ProfilesStore, paths?: BrainPaths): void;
+export declare function loadCatalog(paths?: BrainPaths): Catalog;
+/** Persisted config only — no env overrides. Used by writers. */
+export declare function loadPersistedConfig(paths?: BrainPaths): BrainConfig;
+/** Effective config: persisted file with env overrides layered on top. */
+export declare function loadBrainConfig(env?: NodeJS.ProcessEnv, paths?: BrainPaths): BrainConfig;
+export declare function saveBrainConfig(config: BrainConfig, paths?: BrainPaths): void;
+//# sourceMappingURL=store.d.ts.map

package/dist/config/store.js

@@ -0,0 +1,73 @@
+/**
+ * Load/save for otto-brain's persisted state under `$OTTO_HOME/otto-brain/`.
+ * Reads are validated through the zod schemas; writes are atomic + private. On
+ * first run, profiles and the download catalog are migrated once from the legacy
+ * repo-local `config/` seed data so an existing calibrated setup is not lost.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { writePrivateFileAtomicSync } from "./private-files.js";
+import { packageRoot, resolveBrainPaths } from "./paths.js";
+import { BrainConfigSchema, CatalogSchema, ProfilesStoreSchema, } from "./schema.js";
+import { applyEnvOverrides } from "./env.js";
+function readJson(file, schema) {
+    if (!existsSync(file))
+        return null;
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    const result = schema.safeParse(parsed);
+    if (!result.success) {
+        throw new Error(`invalid ${path.basename(file)}: ${result.error.issues[0]?.message ?? "schema error"}`);
+    }
+    return result.data;
+}
+function writeJson(file, data) {
+    writePrivateFileAtomicSync(file, `${JSON.stringify(data, null, 2)}\n`);
+}
+// ------------------------------------------------------------------- profiles
+export function loadProfilesStore(paths = resolveBrainPaths()) {
+    const current = readJson(paths.profilesFile, ProfilesStoreSchema);
+    if (current)
+        return current;
+    const legacy = path.join(packageRoot(), "config", "profiles.json");
+    const migrated = readJson(legacy, ProfilesStoreSchema);
+    if (migrated) {
+        writeJson(paths.profilesFile, migrated);
+        return migrated;
+    }
+    return ProfilesStoreSchema.parse({});
+}
+export function saveProfilesStore(store, paths = resolveBrainPaths()) {
+    writeJson(paths.profilesFile, store);
+}
+// -------------------------------------------------------------------- catalog
+export function loadCatalog(paths = resolveBrainPaths()) {
+    const current = readJson(paths.catalogFile, CatalogSchema);
+    if (current)
+        return current;
+    const legacy = path.join(packageRoot(), "config", "downloads.json");
+    const migrated = readJson(legacy, CatalogSchema);
+    if (migrated) {
+        writeJson(paths.catalogFile, migrated);
+        return migrated;
+    }
+    return CatalogSchema.parse({ models: [] });
+}
+// --------------------------------------------------------------------- config
+/** Persisted config only — no env overrides. Used by writers. */
+export function loadPersistedConfig(paths = resolveBrainPaths()) {
+    const current = readJson(paths.configFile, BrainConfigSchema);
+    if (current)
+        return current;
+    const seeded = BrainConfigSchema.parse({});
+    writeJson(paths.configFile, seeded);
+    return seeded;
+}
+/** Effective config: persisted file with env overrides layered on top. */
+export function loadBrainConfig(env = process.env, paths = resolveBrainPaths(env)) {
+    return applyEnvOverrides(loadPersistedConfig(paths), env);
+}
+export function saveBrainConfig(config, paths = resolveBrainPaths()) {
+    const validated = BrainConfigSchema.parse(config);
+    writeJson(paths.configFile, validated);
+}
+//# sourceMappingURL=store.js.map

package/dist/gguf.d.ts

@@ -0,0 +1,61 @@
+import type { ModelMetadata } from "./types.js";
+/**
+ * Minimal GGUF metadata reader.
+ *
+ * We only need the header key/values that govern context length, attention
+ * geometry and rope scaling - never the tensor data - so we read a bounded
+ * prefix of the file rather than mapping gigabytes.
+ */
+export declare const TYPE: {
+    UINT8: number;
+    INT8: number;
+    UINT16: number;
+    INT16: number;
+    UINT32: number;
+    INT32: number;
+    FLOAT32: number;
+    BOOL: number;
+    STRING: number;
+    ARRAY: number;
+    UINT64: number;
+    INT64: number;
+    FLOAT64: number;
+};
+interface GgufHeader {
+    version: number;
+    tensorCount: number;
+    fileSize: number;
+    meta: ModelMetadata;
+}
+export declare function readMetadata(file: string): GgufHeader;
+interface GgufSummary {
+    file: string;
+    fileSize: number;
+    ggufVersion: number;
+    tensorCount: number;
+    arch: string;
+    name: string | null;
+    sizeLabel: string | null;
+    fileType: number | null;
+    contextLength: number | null;
+    blockCount: number | null;
+    embeddingLength: number | null;
+    headCount: number | null;
+    headCountKv: number | null;
+    keyLength: number | null;
+    valueLength: number | null;
+    ropeFreqBase: number | null;
+    ropeScalingType: string | null;
+    ropeScalingFactor: number | null;
+    expertCount: number | null;
+    eosTokenId: number | null;
+    isProjector: boolean;
+    /** Chat template exposes a thinking/reasoning channel. */
+    reasoning: boolean;
+}
+/**
+ * Pull out the fields that matter for hosting decisions.
+ */
+export declare function summarize(file: string): GgufSummary;
+export {};
+//# sourceMappingURL=gguf.d.ts.map

package/dist/gguf.js

@@ -0,0 +1,231 @@
+import fs from "node:fs";
+/**
+ * Minimal GGUF metadata reader.
+ *
+ * We only need the header key/values that govern context length, attention
+ * geometry and rope scaling - never the tensor data - so we read a bounded
+ * prefix of the file rather than mapping gigabytes.
+ */
+export const TYPE = {
+    UINT8: 0,
+    INT8: 1,
+    UINT16: 2,
+    INT16: 3,
+    UINT32: 4,
+    INT32: 5,
+    FLOAT32: 6,
+    BOOL: 7,
+    STRING: 8,
+    ARRAY: 9,
+    UINT64: 10,
+    INT64: 11,
+    FLOAT64: 12,
+};
+const FIXED_WIDTH = {
+    [TYPE.UINT8]: 1,
+    [TYPE.INT8]: 1,
+    [TYPE.UINT16]: 2,
+    [TYPE.INT16]: 2,
+    [TYPE.UINT32]: 4,
+    [TYPE.INT32]: 4,
+    [TYPE.FLOAT32]: 4,
+    [TYPE.BOOL]: 1,
+    [TYPE.UINT64]: 8,
+    [TYPE.INT64]: 8,
+    [TYPE.FLOAT64]: 8,
+};
+// Vocabularies can hold hundreds of thousands of strings; never materialize them.
+const MAX_ARRAY_ITEMS = 64;
+class Cursor {
+    constructor(buffer) {
+        this.buf = buffer;
+        this.pos = 0;
+    }
+    get remaining() {
+        return this.buf.length - this.pos;
+    }
+    need(bytes) {
+        if (this.remaining < bytes) {
+            const err = new Error("GGUF header extends beyond the bytes read");
+            err.code = "GGUF_NEED_MORE";
+            throw err;
+        }
+    }
+    take(bytes) {
+        this.need(bytes);
+        const slice = this.buf.subarray(this.pos, this.pos + bytes);
+        this.pos += bytes;
+        return slice;
+    }
+    scalar(type) {
+        const width = FIXED_WIDTH[type];
+        if (width === undefined)
+            throw new Error(`unsupported GGUF scalar type ${type}`);
+        this.need(width);
+        const { buf, pos } = this;
+        let value;
+        switch (type) {
+            case TYPE.UINT8:
+                value = buf.readUInt8(pos);
+                break;
+            case TYPE.INT8:
+                value = buf.readInt8(pos);
+                break;
+            case TYPE.UINT16:
+                value = buf.readUInt16LE(pos);
+                break;
+            case TYPE.INT16:
+                value = buf.readInt16LE(pos);
+                break;
+            case TYPE.UINT32:
+                value = buf.readUInt32LE(pos);
+                break;
+            case TYPE.INT32:
+                value = buf.readInt32LE(pos);
+                break;
+            case TYPE.FLOAT32:
+                value = buf.readFloatLE(pos);
+                break;
+            case TYPE.BOOL:
+                value = buf.readUInt8(pos) !== 0;
+                break;
+            case TYPE.FLOAT64:
+                value = buf.readDoubleLE(pos);
+                break;
+            case TYPE.UINT64:
+                value = Number(buf.readBigUInt64LE(pos));
+                break;
+            case TYPE.INT64:
+                value = Number(buf.readBigInt64LE(pos));
+                break;
+            default:
+                throw new Error(`unsupported GGUF scalar type ${type}`);
+        }
+        this.pos += width;
+        return value;
+    }
+    string() {
+        const length = this.scalar(TYPE.UINT64);
+        return this.take(length).toString("utf8");
+    }
+    value(type) {
+        if (type === TYPE.STRING)
+            return this.string();
+        if (type !== TYPE.ARRAY)
+            return this.scalar(type);
+        const elemType = this.scalar(TYPE.UINT32);
+        const count = this.scalar(TYPE.UINT64);
+        if (count > MAX_ARRAY_ITEMS) {
+            // Skip the payload without decoding it.
+            if (elemType === TYPE.STRING) {
+                for (let i = 0; i < count; i += 1)
+                    this.string();
+            }
+            else {
+                this.take(FIXED_WIDTH[elemType] * count);
+            }
+            return { skipped: true, count, elemType };
+        }
+        const items = [];
+        for (let i = 0; i < count; i += 1)
+            items.push(this.value(elemType));
+        return items;
+    }
+}
+/** Read the first `bytes` of a file (or the whole file if smaller). */
+function readPrefix(file, bytes) {
+    const fd = fs.openSync(file, "r");
+    try {
+        const size = fs.fstatSync(fd).size;
+        const length = Math.min(bytes, size);
+        const buffer = Buffer.allocUnsafe(length);
+        fs.readSync(fd, buffer, 0, length, 0);
+        return { buffer, fileSize: size };
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+export function readMetadata(file) {
+    // Grow the window if a big tokenizer pushes the header past our first read.
+    let windowBytes = 8 * 1024 * 1024;
+    for (let attempt = 0; attempt < 4; attempt += 1) {
+        const { buffer, fileSize } = readPrefix(file, windowBytes);
+        const cursor = new Cursor(buffer);
+        try {
+            const magic = cursor.take(4).toString("ascii");
+            if (magic !== "GGUF")
+                throw new Error(`${file} is not a GGUF file`);
+            const version = cursor.scalar(TYPE.UINT32);
+            const tensorCount = cursor.scalar(TYPE.UINT64);
+            const kvCount = cursor.scalar(TYPE.UINT64);
+            const meta = {};
+            for (let i = 0; i < kvCount; i += 1) {
+                const key = cursor.string();
+                const type = cursor.scalar(TYPE.UINT32);
+                meta[key] = cursor.value(type);
+            }
+            return { version, tensorCount, fileSize, meta };
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== "GGUF_NEED_MORE" || windowBytes >= fileSize)
+                throw error;
+            windowBytes = Math.min(windowBytes * 4, fileSize);
+        }
+    }
+    throw new Error(`could not read GGUF header from ${file}`);
+}
+/**
+ * Pull out the fields that matter for hosting decisions.
+ */
+export function summarize(file) {
+    const { version, tensorCount, fileSize, meta } = readMetadata(file);
+    const arch = meta["general.architecture"] || "unknown";
+    const get = (suffix) => meta[`${arch}.${suffix}`];
+    const heads = get("attention.head_count");
+    const embedding = get("embedding_length");
+    let keyLength = get("attention.key_length");
+    let valueLength = get("attention.value_length");
+    if (keyLength === undefined && typeof embedding === "number" && typeof heads === "number") {
+        keyLength = embedding / heads;
+    }
+    if (valueLength === undefined)
+        valueLength = keyLength;
+    let kvHeads = get("attention.head_count_kv");
+    if (Array.isArray(kvHeads))
+        kvHeads = Math.max(...kvHeads);
+    // A reasoning model advertises its thinking channel in the chat template: a
+    // `<think>` block, a `reasoning_content` field, or an `enable_thinking`
+    // toggle. Detecting it here (rather than from the filename or the catalog)
+    // means any local model is flagged, matching LM Studio's green-brain marker.
+    const chatTemplate = typeof meta["tokenizer.chat_template"] === "string"
+        ? meta["tokenizer.chat_template"]
+        : "";
+    const reasoning = /<think>|<\/think>|reasoning_content|enable_thinking/i.test(chatTemplate);
+    return {
+        file,
+        fileSize,
+        ggufVersion: version,
+        tensorCount,
+        arch,
+        name: meta["general.name"] || null,
+        sizeLabel: meta["general.size_label"] || null,
+        fileType: (meta["general.file_type"] ?? null),
+        contextLength: (get("context_length") ?? null),
+        blockCount: (get("block_count") ?? null),
+        embeddingLength: (embedding ?? null),
+        headCount: (heads ?? null),
+        headCountKv: typeof kvHeads === "number" ? kvHeads : null,
+        keyLength: typeof keyLength === "number" ? keyLength : null,
+        valueLength: typeof valueLength === "number" ? valueLength : null,
+        ropeFreqBase: (get("rope.freq_base") ?? null),
+        ropeScalingType: (get("rope.scaling.type") ?? null),
+        ropeScalingFactor: (get("rope.scaling.factor") ?? null),
+        expertCount: (get("expert_count") ?? null),
+        eosTokenId: (meta["tokenizer.ggml.eos_token_id"] ?? null),
+        isProjector: Boolean(meta["clip.has_vision_encoder"] || arch === "clip"),
+        reasoning,
+    };
+}
+//# sourceMappingURL=gguf.js.map

package/dist/gpu.d.ts

@@ -0,0 +1,12 @@
+import type { GpuInfo } from "./types.js";
+/** Thin wrapper over nvidia-smi. Returns null when there is no NVIDIA GPU. */
+/** GpuInfo plus the live sampling fields nvidia-smi also reports. */
+export interface GpuQuery extends GpuInfo {
+    utilization: number;
+    temperature: number;
+}
+declare function query(): Promise<GpuQuery | null>;
+/** Just the used-VRAM figure, for sampling during a load. */
+declare function usedBytes(): Promise<number | null>;
+export { query, usedBytes };
+//# sourceMappingURL=gpu.d.ts.map

package/dist/gpu.js

@@ -0,0 +1,49 @@
+import { execFile } from "node:child_process";
+function run(args, timeout = 10000) {
+    return new Promise((resolve, reject) => {
+        execFile("nvidia-smi", args, { timeout, windowsHide: true }, (error, stdout) => {
+            if (error)
+                reject(error);
+            else
+                resolve(String(stdout));
+        });
+    });
+}
+const MIB = 1024 * 1024;
+async function query() {
+    try {
+        const out = await run([
+            "--query-gpu=name,memory.total,memory.used,utilization.gpu,temperature.gpu,driver_version,compute_cap",
+            "--format=csv,noheader,nounits",
+        ]);
+        const line = out.trim().split(/\r?\n/)[0];
+        if (!line)
+            return null;
+        const [name, total, used, util, temp, driver, cap] = line.split(",").map((s) => s.trim());
+        return {
+            name,
+            totalBytes: Number(total) * MIB,
+            usedBytes: Number(used) * MIB,
+            freeBytes: (Number(total) - Number(used)) * MIB,
+            utilization: Number(util),
+            temperature: Number(temp),
+            driver,
+            computeCapability: cap,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Just the used-VRAM figure, for sampling during a load. */
+async function usedBytes() {
+    try {
+        const out = await run(["--query-gpu=memory.used", "--format=csv,noheader,nounits"]);
+        return Number(out.trim().split(/\r?\n/)[0]) * MIB;
+    }
+    catch {
+        return null;
+    }
+}
+export { query, usedBytes };
+//# sourceMappingURL=gpu.js.map

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Library entry for @otto-code/brain. Exposes the command group (so the main
+ * `otto` CLI can `program.addCommand(createBrainCommand())`), the service, runtime
+ * resolution, model discovery, config, and shared types. The executable lives in
+ * main.ts.
+ */
+export { createBrainCommand, registerBrainCommands } from "./cli.js";
+export { startService, type ServiceHandle, type StartServiceOptions } from "./service/serve.js";
+export { readRunningService, readPidFile, writePidFile, removePidFile, type PidRecord, } from "./service/pid-lock.js";
+export { resolveRuntime, ensureRuntime, listAllRuntimes, installManagedRuntime, } from "./runtime/index.js";
+export { scanModels, pickModel, pullModel } from "./models/index.js";
+export * from "./config/index.js";
+export type { Model, Runtime, GpuInfo, ModelMetadata, ModelFeatures } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,13 @@
+/**
+ * Library entry for @otto-code/brain. Exposes the command group (so the main
+ * `otto` CLI can `program.addCommand(createBrainCommand())`), the service, runtime
+ * resolution, model discovery, config, and shared types. The executable lives in
+ * main.ts.
+ */
+export { createBrainCommand, registerBrainCommands } from "./cli.js";
+export { startService } from "./service/serve.js";
+export { readRunningService, readPidFile, writePidFile, removePidFile, } from "./service/pid-lock.js";
+export { resolveRuntime, ensureRuntime, listAllRuntimes, installManagedRuntime, } from "./runtime/index.js";
+export { scanModels, pickModel, pullModel } from "./models/index.js";
+export * from "./config/index.js";
+//# sourceMappingURL=index.js.map

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=main.d.ts.map

package/dist/main.js

@@ -0,0 +1,5 @@
+/** Executable entry for bin/otto-brain. Runs the standalone CLI. */
+import { runBrainCli } from "./run.js";
+const code = await runBrainCli(process.argv.slice(2));
+process.exitCode = code;
+//# sourceMappingURL=main.js.map

package/dist/models/dirs.d.ts

@@ -0,0 +1,9 @@
+import type { BrainConfig } from "../config/schema.js";
+export interface ModelsDir {
+    dir: string;
+    origin: "managed" | "lmstudio";
+}
+export declare function resolveModelsDirs(config: BrainConfig, env?: NodeJS.ProcessEnv): ModelsDir[];
+/** The single directory new downloads are written to. */
+export declare function managedModelsDir(config: BrainConfig, env?: NodeJS.ProcessEnv): string;
+//# sourceMappingURL=dirs.d.ts.map