anyformer 0.0.0-stage → 0.1.0

package/src/models.js

@@ -0,0 +1,50 @@
+// Models that pass a browser test through anyformer, grouped by what they do. Pass an entry to load() in place of a
+// repo id; it carries the task and, where the back end needs one, the budget. DEFAULT is the smallest download that
+// passed. `test` names the page under test/browser/ that proves the entry; test/models.test.js checks it exists.
+
+const M = (repo, backend, task, test, extra = {}) => ({ repo, backend, task, test, ...extra });
+
+const QWEN2_5_0_5B = M('onnx-community/Qwen2.5-0.5B-Instruct', 'transformers', 'text-generation', 'transformers', { downloadBytes: 786e6 });
+const TERNARY_BONSAI_4B = M('onnx-community/Ternary-Bonsai-4B-ONNX', 'transformers', 'text-generation', 'transformers', { downloadBytes: 1.16e9 });
+const LFM2_5_230M = M('LiquidAI/LFM2.5-230M-GGUF', 'localmind', 'text-generation', 'chat', { downloadBytes: 149e6 });
+const LFM2_5_1_2B = M('LiquidAI/LFM2.5-1.2B-Instruct-GGUF', 'localmind', 'text-generation', 'chat', { downloadBytes: 696e6 });
+const GEMMA4_E2B = M('google/gemma-4-E2B-it-qat-mobile-transformers', 'localmind', 'text-generation', 'chat', { downloadBytes: 2.46e9 });
+const GEMMA4_E4B = M('google/gemma-4-E4B-it-qat-mobile-transformers', 'localmind', 'text-generation', 'chat', { budget: 4e9, downloadBytes: 3.53e9 });
+const TERNARY_BONSAI_2_27B = M('prism-ml/Ternary-Bonsai-2-27B-gguf', 'localmind', 'text-generation', 'chat', { budget: 7e9, downloadBytes: 5.94e9 });
+const QWEN3_5_4B = M('onnx-community/Qwen3.5-4B-ONNX-OPT', 'transformers', 'text-generation', 'vision', { budget: 3.1e9, downloadBytes: 3.0e9 });
+const GEMMA4_E2B_ONNX = M('onnx-community/gemma-4-E2B-it-ONNX', 'transformers', 'text-generation', 'vision', { budget: 3.5e9, downloadBytes: 3.38e9 });
+const GEMMA4_E4B_ONNX = M('onnx-community/gemma-4-E4B-it-ONNX', 'transformers', 'text-generation', 'transformers', { budget: 5.3e9, downloadBytes: 5.18e9 });
+const MINICPM5_2B = M('openbmb/MiniCPM5-2B-GGUF', 'wllama', 'text-generation', 'chat', { downloadBytes: 1.56e9 });
+const QWEN3_0_6B_MDLM = M('naklitechie/Qwen3-0.6B-diffusion-mdlm-ONNX', 'kohra', 'text-generation', 'kohra', { downloadBytes: 1.54e9 });
+const GEMMA4_26B_A4B = M('google/gemma-4-26B-A4B-it-qat-q4_0-gguf', 'diskformer', 'text-generation', 'diskformer-chat', { budget: 2.5e9, downloadBytes: 14.44e9 });
+const MINILM_L6 = M('Xenova/all-MiniLM-L6-v2', 'transformers', 'feature-extraction', 'embed', { downloadBytes: 90e6 });
+const DETR_RESNET_50 = M('Xenova/detr-resnet-50', 'transformers', 'object-detection', 'detect', { downloadBytes: 167e6 });
+
+export const MODELS = {
+  chat: {
+    DEFAULT: QWEN2_5_0_5B,
+    QWEN2_5_0_5B,
+    /** Ternary weights (q2 graph), 4B parameters in 1.16 GB. */
+    TERNARY_BONSAI_4B,
+    /** LocalMind's hand-written LFM2 kernels: 149 MB, the fastest chat here. */
+    LFM2_5_230M,
+    /** The same LFM2 engine on the 1.2B GGUF. */
+    LFM2_5_1_2B,
+    /** Gemma 4 E2B, Google's QAT-mobile export, on LocalMind's Gemma kernels. */
+    GEMMA4_E2B,
+    /** Gemma 4 E4B on the same kernels; the whole 3.5 GB stays on the GPU. */
+    GEMMA4_E4B,
+    /** 27B parameters at 1.6 bits (Prism ternary), 5.9 GB on the GPU. */
+    TERNARY_BONSAI_2_27B,
+    /** llama.cpp in WebAssembly (wllama): WebGPU when the budget holds it, the CPU otherwise. */
+    MINICPM5_2B,
+    /** Text diffusion: the whole reply denoises at once (kohra). */
+    QWEN3_0_6B_MDLM,
+    /** 26B parameters in 2.5 GB of GPU memory; 14.4 GB on disk (diskformer). */
+    GEMMA4_26B_A4B,
+  },
+  /** Chat with images in the messages: content [{ type: 'image', image }, { type: 'text', text }]. Gemma 4 takes audio too. */
+  vision: { DEFAULT: QWEN3_5_4B, QWEN3_5_4B, GEMMA4_E2B_ONNX, GEMMA4_E4B_ONNX },
+  embedding: { DEFAULT: MINILM_L6, MINILM_L6 },
+  objectDetection: { DEFAULT: DETR_RESNET_50, DETR_RESNET_50 },
+};

package/src/pipeline.js

@@ -0,0 +1,27 @@
+// transformers.js's pipeline() call shape over anyformer's resolver, so `import { pipeline } from 'anyformer'` replaces
+// `from '@huggingface/transformers'` for the calls below. Any repo anyformer can plan works: GGUF on diskformer,
+// text diffusion on kohra, ONNX on transformers.js.
+//
+//   const gen = await pipeline('text-generation', 'google/gemma-4-26B-A4B-it-qat-q4_0-gguf', { budget: 2.5e9 });
+//   const [{ generated_text }] = await gen(messages, { max_new_tokens: 128 });   // messages in → messages + reply out
+//   const [{ generated_text: text }] = await gen('Once upon a time');            // a string in → the reply string out
+//
+// Other tasks return what the session's run() returns (feature-extraction: plain arrays, not a Tensor).
+// Options: budget, maxCtx, backends, progress_callback (transformers.js's name) or onProgress, signal.
+
+import { load } from './load.js';
+import { AnyformerError } from './errors.js';
+
+export async function pipeline(task, repo, options = {}) {
+  if (!repo) throw new AnyformerError('INVALID_ARGUMENT', 'pipeline(task, repo): anyformer needs a repo id or a MODELS entry');
+  const { progress_callback, ...opts } = options;
+  const session = await load(repo, { ...opts, task, onProgress: opts.onProgress || progress_callback });
+  const call = task === 'text-generation'
+    ? async (input, o = {}) => {
+      const messages = typeof input === 'string' ? [{ role: 'user', content: input }] : input;
+      const reply = await session.run(messages, { maxNewTokens: o.max_new_tokens ?? o.maxNewTokens ?? 256, signal: o.signal });
+      return [{ generated_text: typeof input === 'string' ? reply.text : [...messages, { role: 'assistant', content: reply.text }] }];
+    }
+    : (input, o) => session.run(input, o);
+  return Object.assign(call, { task, backend: session.backend, plan: session.plan, session, dispose: () => session.dispose() });
+}

package/src/probe.js

@@ -0,0 +1,35 @@
+// What this browser can do, read once per page. Every field has a safe value when an API is missing (Node, Firefox,
+// a page without WebGPU), so a back end's canRun() reads caps without guarding.
+
+// A wasm module with one memory whose flags byte is 0x04 (memory64). It validates only where memory64 is supported.
+const MEMORY64_PROBE = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 4, 0]);
+
+export function memory64() {
+  try { return WebAssembly.validate(MEMORY64_PROBE); } catch { return false; }
+}
+
+export async function probe({ gpu = globalThis.navigator?.gpu, storage = globalThis.navigator?.storage } = {}) {
+  const caps = {
+    webgpu: false, f16: false, subgroups: false,
+    maxBufferSize: 0, maxStorageBufferBindingSize: 0, adapter: null,
+    opfs: false, quotaBytes: 0, usageBytes: 0,
+    memory64: memory64(),
+  };
+  const adapter = gpu ? await gpu.requestAdapter({ powerPreference: 'high-performance' }).catch(() => null) : null;
+  if (adapter) {
+    caps.webgpu = true;
+    caps.f16 = adapter.features.has('shader-f16');
+    caps.subgroups = adapter.features.has('subgroups');
+    caps.maxBufferSize = adapter.limits.maxBufferSize;
+    caps.maxStorageBufferBindingSize = adapter.limits.maxStorageBufferBindingSize;
+    const info = adapter.info || {};
+    caps.adapter = { vendor: info.vendor || '', architecture: info.architecture || '', description: info.description || '' };
+  }
+  if (storage?.getDirectory) {
+    caps.opfs = true;
+    const est = storage.estimate ? await storage.estimate().catch(() => null) : null;
+    caps.quotaBytes = est?.quota || 0;
+    caps.usageBytes = est?.usage || 0;
+  }
+  return caps;
+}

package/src/resolve.js

@@ -0,0 +1,48 @@
+// Ask every back end whether it can run the model under the budget, then rank the ones that can.
+//
+// Back-end contract (each back end is a plain object):
+//   id        string, stable, e.g. 'diskformer'
+//   tasks     the Hugging Face pipeline tasks it runs, e.g. ['text-generation']
+//   canRun(model, caps, { budget, task }) → { ok: true, estimate } | { ok: false, code, reason, need? }
+//             estimate = { gpuBytes, diskBytes, tokPerSec | null }. No network, no GPU allocation: it reads the
+//             descriptor and caps only. code is one of REFUSALS below; need is the budget that would pass, with
+//             code 'budget'. A throw counts as code 'threw' with the message as the reason.
+//   load(model, { budget, caps, maxCtx, dtype, onProgress, signal }) → session   (maxCtx: tokens; dtype: a precision
+//             the back end offers, e.g. 'q4f16' for transformers.js; undefined = the back end's default)
+//             session = { run(input, opts) → result, dispose() }; a text-generation session also has
+//             generate(messages, opts) → async iterable of { text, tokens }, and run(messages) is its last chunk.
+//   task is the requested pipeline task, or null for the repo's own (model.task).
+//             The back end applies the model's own chat template.
+
+// Why a back end said no: a closed set, each with the move that changes the answer.
+export const REFUSALS = {
+  format: 'the repo has no weights in a format this back end reads; pick a repo in another format',
+  model: 'this back end reads the format but not this model (architecture or file); pick another model',
+  task: 'this back end does not run the requested task; another back end or another repo does',
+  webgpu: 'no WebGPU adapter; use Chrome or Edge 121+ on a GPU with WebGPU',
+  f16: 'the GPU lacks shader-f16; use a GPU that has it',
+  opfs: 'no OPFS; use a browser with navigator.storage.getDirectory, outside private mode',
+  budget: 'the GPU budget is too small; pass { budget } at least `need` bytes',
+  threw: 'the back end crashed deciding; a bug in that back end, report it with the reason',
+};
+
+export async function resolve(model, caps, backends, { budget, task = null } = {}) {
+  const candidates = [];
+  for (const [order, b] of backends.entries()) {
+    let r;
+    try { r = await b.canRun(model, caps, { budget, task }); } catch (e) { r = { ok: false, code: 'threw', reason: `canRun threw: ${e.message}` }; }
+    candidates.push(r.ok ? { backend: b.id, order, ok: true, estimate: r.estimate } : { backend: b.id, order, ok: false, code: r.code || 'model', reason: r.reason, ...(r.need && { need: r.need }) });
+  }
+  const ranked = candidates.filter((c) => c.ok).sort(rank);
+  return { chosen: ranked[0]?.backend ?? null, ranked: ranked.map((c) => c.backend), candidates };
+}
+
+// A back end with a speed estimate ranks above one without; two estimates rank by tok/s; otherwise the order the
+// caller listed them in, which is the default preference.
+function rank(a, b) {
+  const ta = a.estimate?.tokPerSec ?? null;
+  const tb = b.estimate?.tokPerSec ?? null;
+  if (ta !== null && tb !== null && ta !== tb) return tb - ta;
+  if ((ta === null) !== (tb === null)) return ta === null ? 1 : -1;
+  return a.order - b.order;
+}

package/src/sources.js

@@ -0,0 +1,22 @@
+// Where each back end's runtime loads from: exact versions and commits, so a given anyformer behaves the same tomorrow.
+// kohra, diskformer and LocalMind move fast on their main branches; `node scripts/pin-sources.mjs` moves these pins
+// to each repo's current main, and the browser tests then prove the new pins (test/browser/README.md).
+// transformers.js and wllama move only by hand, in step with LocalMind's pins (plan/history.md, 2026-10-08).
+
+export const PINS = {
+  transformers: '4.3.1',
+  wllama: '3.4.1',      // LocalMind's pin; its stream-drain workaround (src/backends/wllama.js) is for this version
+  kohra: 'f678fac7342c79b58b640540b8b3a7d078b7ab1a',
+  diskformer: '524bc50e2edd186403403090dd83d13f66a8f73f',
+  localmind: '203288a0f0e23919b43c76bff8dc5d49f48ed300',
+};
+
+const gh = (repo, sha, path) => `https://cdn.jsdelivr.net/gh/NakliTechie/${repo}@${sha}/${path}`;
+
+export const SOURCES = {
+  transformers: `https://cdn.jsdelivr.net/npm/@huggingface/transformers@${PINS.transformers}/+esm`,
+  wllama: `https://cdn.jsdelivr.net/npm/@wllama/wllama@${PINS.wllama}/esm`,
+  kohra: gh('kohra', PINS.kohra, 'kohra.js'),
+  diskformer: gh('diskformer.js', PINS.diskformer, 'engines'),
+  localmind: gh('LocalMind', PINS.localmind, 'src'),
+};

package/src/store.js

@@ -0,0 +1,126 @@
+// What anyformer's back ends have downloaded into this browser, and removing it. Each back end keeps its own store;
+// this module reads them all into one shape: { backend, repo, bytes }. Modelled on LocalMind's
+// inventoryModelCaches() (index.html), which covers the same engines' stores.
+//   Cache Storage   'transformers-cache' (transformers.js; kohra's tokenizer too); 'gguf-v1', 'gguf-v1-headers' and
+//                   'bonsai-pipeline-v1' (LocalMind's engines; 'gguf-v1' holds the LFM2
+//                   engine): one entry per file URL (…/<repo>/resolve/<rev>/<file>). kohra's ONNX graph sits in the
+//                   browser's HTTP cache, which a page cannot list.
+//   IndexedDB       'gguf-cache-v1' (Bonsai 2) and 'safetensors-cache-v1' (Gemma 4 QAT-mobile): a store keyed by URL
+//                   with { size } and a chunk store keyed [url, start, end]; 'webgpu-prefix-snapshots' (Bonsai 2's
+//                   system-prompt snapshot).
+//   OPFS            'localmind-ssd/<key>/' (diskformer's MoE stores, Gemma 4's PLE table) with manifest.json naming the
+//                   source; 'cache/' (wllama: '__metadata__<name>' names each file's URL); 'anyformer-gguf/<key>/'
+//                   (GGUFs over 2 GB as shards, meta.json or done.json naming the repo; src/gguf-split.js).
+
+import { DISKFORMER_MODELS } from './backends/diskformer.js';
+import { SPLIT_ROOT } from './gguf-split.js';
+
+const CACHE_BACKEND = { 'transformers-cache': 'transformers', 'gguf-v1': 'localmind', 'gguf-v1-headers': 'localmind', 'bonsai-pipeline-v1': 'localmind' };
+const IDB_STORES = ['gguf-cache-v1', 'safetensors-cache-v1'];
+const BONSAI2 = 'prism-ml/Ternary-Bonsai-2-27B-gguf';
+
+const repoOf = (url) => /^https:\/\/huggingface\.co\/([^/]+\/[^/]+)\/resolve\//.exec(url || '')?.[1] ?? null;
+const req = (r) => new Promise((res, rej) => { r.onsuccess = () => res(r.result); r.onerror = () => rej(r.error); });
+const openDb = (name) => new Promise((res, rej) => {
+  const r = indexedDB.open(name);
+  r.onsuccess = () => res(r.result); r.onerror = () => rej(r.error);
+  r.onupgradeneeded = () => { r.transaction.abort(); rej(new Error(`${name} does not exist`)); };
+});
+
+async function opfsDir(path) {
+  if (!globalThis.navigator?.storage?.getDirectory) return null;
+  let dir = await navigator.storage.getDirectory();
+  for (const name of path) {
+    try { dir = await dir.getDirectoryHandle(name); } catch { return null; }
+  }
+  return dir;
+}
+async function dirBytes(dir) {
+  let n = 0;
+  for await (const [, h] of dir.entries()) n += h.kind === 'file' ? (await h.getFile()).size : await dirBytes(h);
+  return n;
+}
+const readJson = async (dir, name) => { try { return JSON.parse(await (await (await dir.getFileHandle(name)).getFile()).text()); } catch { return null; } };
+
+// Every stored piece: { backend, repo, bytes, remove }.
+async function inventory() {
+  const out = [];
+  const add = (backend, repo, bytes, remove) => { if (repo) out.push({ backend, repo, bytes: bytes || 0, remove }); };
+
+  if (typeof caches !== 'undefined') for (const name of await caches.keys()) {
+    const cache = await caches.open(name);
+    for (const r of await cache.keys()) {
+      // Content-Length is in the stored headers; reading the body to size it would load every file into memory.
+      const res = await cache.match(r);
+      add(CACHE_BACKEND[name] || name, repoOf(r.url), Number(res?.headers.get('content-length')) || 0, () => cache.delete(r));
+    }
+  }
+
+  let dbs = [];
+  try { dbs = (await indexedDB.databases()).map((d) => d.name); } catch { /* no IndexedDB */ }
+  for (const dbName of IDB_STORES.filter((n) => dbs.includes(n))) {
+    const db = await openDb(dbName);
+    let meta = null, chunks = null;
+    for (const s of db.objectStoreNames) {
+      const [k] = await req(db.transaction(s, 'readonly').objectStore(s).getAllKeys(null, 1));
+      if (Array.isArray(k)) chunks = s; else if (typeof k === 'string') meta = s;
+    }
+    if (meta) for (const url of await req(db.transaction(meta, 'readonly').objectStore(meta).getAllKeys())) {
+      const m = await req(db.transaction(meta, 'readonly').objectStore(meta).get(url));
+      add('localmind', repoOf(url), m?.size, async () => {
+        if (chunks) await req(db.transaction(chunks, 'readwrite').objectStore(chunks).delete(IDBKeyRange.bound([url], [url, [], []])));
+        await req(db.transaction(meta, 'readwrite').objectStore(meta).delete(url));
+      });
+    }
+  }
+  if (dbs.includes('webgpu-prefix-snapshots')) {
+    const db = await openDb('webgpu-prefix-snapshots');
+    const stores = [...db.objectStoreNames];
+    const slot = stores.includes('meta') ? await req(db.transaction('meta', 'readonly').objectStore('meta').get('prefix-snapshot-slot')) : null;
+    if (slot) add('localmind', BONSAI2, (slot.sizes || []).reduce((n, s) => n + s, 0), async () => {
+      for (const s of stores) await req(db.transaction(s, 'readwrite').objectStore(s).clear());
+    });
+  }
+
+  const ssd = await opfsDir(['localmind-ssd']);
+  if (ssd) for await (const [key, h] of ssd.entries()) {
+    if (h.kind !== 'directory') continue;
+    const src = (await readJson(h, 'manifest.json'))?.source;
+    const repo = src?.repo || repoOf(src?.url) || DISKFORMER_MODELS.find((m) => m.file.toLowerCase().startsWith(key))?.repo;
+    add(DISKFORMER_MODELS.some((m) => m.repo === repo) ? 'diskformer' : 'localmind', repo, await dirBytes(h), () => ssd.removeEntry(key, { recursive: true }));
+  }
+  const wcache = await opfsDir(['cache']);
+  if (wcache) for await (const [name, h] of wcache.entries()) {
+    if (h.kind !== 'file' || name.startsWith('__metadata__')) continue;
+    add('wllama', repoOf((await readJson(wcache, `__metadata__${name}`))?.originalURL), (await h.getFile()).size, async () => {
+      await wcache.removeEntry(name);
+      await wcache.removeEntry(`__metadata__${name}`).catch(() => {});
+    });
+  }
+  const split = await opfsDir([SPLIT_ROOT]);
+  if (split) for await (const [key, h] of split.entries()) {
+    if (h.kind !== 'directory') continue;
+    const repo = (await readJson(h, 'meta.json'))?.repo || (await readJson(h, 'done.json'))?.repo;
+    add('wllama', repo, await dirBytes(h), () => split.removeEntry(key, { recursive: true }));
+  }
+  return out;
+}
+
+// Every stored model, one row per back end and repo. A store of 0 bytes (an interrupted first write) is left out.
+export async function stored() {
+  const rows = new Map();
+  for (const e of await inventory()) {
+    const k = `${e.backend} ${e.repo}`;
+    const r = rows.get(k) || { backend: e.backend, repo: e.repo, bytes: 0 };
+    r.bytes += e.bytes;
+    rows.set(k, r);
+  }
+  return [...rows.values()].filter((r) => r.bytes > 0);
+}
+
+// Remove a repo from every store that holds it. Returns the bytes freed. The next load downloads it again.
+export async function remove(repo) {
+  let bytes = 0;
+  for (const e of await inventory()) if (e.repo === repo) { bytes += e.bytes; await e.remove(); }
+  return { repo, bytes };
+}

package/src/tools.js

@@ -0,0 +1,148 @@
+// The agent face: every public anyformer call as a tool (name, description, JSON-schema input, handler), published
+// through WebMCP (navigator.modelContext) where the browser has it and as window.anyformer.tools otherwise. Tests drive
+// this manifest, not the functions behind it.
+//
+// Consequence classes: 'read' runs freely; 'stages' lands only when the call accepts the consequence, otherwise it
+// returns what would happen: anyformer_load (downloads weights, fills the GPU) needs acceptDiskBytes, anyformer_remove
+// (deletes a downloaded model; the next load downloads it again) needs confirm.
+// Person-only acts: none. anyformer has no act whose point is the person's own authorship or consent.
+
+import { probe } from './probe.js';
+import { plan, load } from './load.js';
+import { MODELS } from './models.js';
+import { stored, remove } from './store.js';
+
+// Options every tool call passes to plan() and load(): a page sets backends or budget here; tests inject caps and fetch.
+export const toolOptions = {};
+
+const sessions = new Map();
+let nextId = 1;
+// The trajectory: the last 50 calls, with the door each came through. Bounded, so it never grows with use.
+export const journal = [];
+const record = (entry) => { journal.push({ at: new Date().toISOString(), ...entry }); if (journal.length > 50) journal.shift(); };
+
+const repo = { type: 'string', description: 'Hugging Face repo id, e.g. onnx-community/Qwen2.5-0.5B-Instruct' };
+const budget = { type: 'number', description: 'GPU memory budget in bytes; default 2.5e9' };
+
+// A plan without the file list: bounded by the number of back ends, not the size of the repo.
+function brief(p) {
+  return {
+    repo: p.model.repo, formats: p.model.formats, architecture: p.model.architecture, task: p.model.task,
+    budget: p.budget, chosen: p.chosen, ranked: p.ranked,
+    candidates: p.candidates.map(({ order, ...c }) => c),
+    diskBytes: p.candidates.find((c) => c.backend === p.chosen)?.estimate?.diskBytes ?? null,
+  };
+}
+
+export const TOOLS = [
+  {
+    name: 'anyformer_probe', consequence: 'read',
+    description: 'What this browser can run: WebGPU, shader-f16, subgroups, buffer limits, adapter, OPFS quota, memory64.',
+    inputSchema: { type: 'object', properties: {} },
+    handler: () => probe(),
+  },
+  {
+    name: 'anyformer_models', consequence: 'read',
+    description: 'Models that pass a browser test through anyformer, by family (chat, embedding, objectDetection): repo, back end, task, budget, download size. Pass a repo to anyformer_plan or anyformer_load.',
+    inputSchema: { type: 'object', properties: {} },
+    handler: () => MODELS,
+  },
+  {
+    name: 'anyformer_plan', consequence: 'read',
+    description: 'Which back end would run a model under a GPU budget, and why every other back end refused (closed codes: format, model, webgpu, f16, opfs, budget, threw). Loads nothing.',
+    inputSchema: { type: 'object', properties: { repo, budget }, required: ['repo'] },
+    handler: async ({ repo, budget }) => brief(await plan(repo, { ...toolOptions, ...(budget && { budget }) })),
+  },
+  {
+    name: 'anyformer_load', consequence: 'stages',
+    description: 'Load a model. Downloads its weights to browser storage on first use. Pass acceptDiskBytes >= the plan\'s diskBytes to load; without it the call returns the plan and loads nothing.',
+    inputSchema: {
+      type: 'object', required: ['repo'],
+      properties: { repo, budget, acceptDiskBytes: { type: 'number', description: 'disk bytes the caller accepts this load may write' } },
+    },
+    handler: async ({ repo, budget, acceptDiskBytes }) => {
+      const p = brief(await plan(repo, { ...toolOptions, ...(budget && { budget }) }));
+      if (!p.chosen) return { loaded: false, plan: p };
+      if (!(acceptDiskBytes >= (p.diskBytes || 0))) return { loaded: false, staged: true, plan: p };
+      const s = await load(repo, { ...toolOptions, ...(budget && { budget }) });
+      const session = `s${nextId++}`;
+      sessions.set(session, { repo, backend: s.backend, s });
+      return { loaded: true, session, backend: s.backend };
+    },
+  },
+  {
+    name: 'anyformer_generate', consequence: 'read',
+    description: 'Reply to a chat with a loaded model. Greedy decoding; returns the whole reply.',
+    inputSchema: {
+      type: 'object', required: ['session', 'messages'],
+      properties: {
+        session: { type: 'string' },
+        messages: { type: 'array', items: { type: 'object', required: ['role', 'content'], properties: { role: { type: 'string' }, content: { type: 'string' } } } },
+        maxNewTokens: { type: 'number', description: 'default 256' },
+      },
+    },
+    handler: async ({ session, messages, maxNewTokens = 256 }) => {
+      const e = sessions.get(session);
+      if (!e) throw new Error(`no session ${session}; anyformer_sessions lists the open ones, anyformer_load opens one`);
+      let last = { text: '', tokens: 0 };
+      for await (const c of e.s.generate(messages, { maxNewTokens })) last = c;
+      return { text: last.text, tokens: last.tokens };
+    },
+  },
+  {
+    name: 'anyformer_sessions', consequence: 'read',
+    description: 'The loaded models, and the last 50 tool calls with the door each came through.',
+    inputSchema: { type: 'object', properties: {} },
+    handler: () => ({ sessions: [...sessions].map(([id, e]) => ({ session: id, repo: e.repo, backend: e.backend })), journal }),
+  },
+  {
+    name: 'anyformer_stored', consequence: 'read',
+    description: 'Models downloaded into this browser: back end, repo, bytes.',
+    inputSchema: { type: 'object', properties: {} },
+    handler: () => stored(),
+  },
+  {
+    name: 'anyformer_remove', consequence: 'stages',
+    description: 'Delete a downloaded model from this browser. Without confirm: true it returns what it would delete and deletes nothing. The next load downloads it again.',
+    inputSchema: { type: 'object', required: ['repo'], properties: { repo, confirm: { type: 'boolean' } } },
+    handler: async ({ repo, confirm }) => {
+      if (confirm !== true) return { removed: false, staged: true, would: (await stored()).filter((r) => r.repo === repo) };
+      return { removed: true, ...(await remove(repo)) };
+    },
+  },
+  {
+    name: 'anyformer_unload', consequence: 'read',
+    description: 'Free a loaded model\'s GPU memory. Its weights stay in browser storage for the next load.',
+    inputSchema: { type: 'object', required: ['session'], properties: { session: { type: 'string' } } },
+    handler: async ({ session }) => {
+      const e = sessions.get(session);
+      if (!e) return { unloaded: false };
+      sessions.delete(session);
+      await e.s.dispose();
+      return { unloaded: true };
+    },
+  },
+];
+
+// Call a tool by name, as either door does. Errors come back as { error } so a caller branches on data, not a throw.
+export async function call(name, input = {}, door = 'direct') {
+  const t = TOOLS.find((x) => x.name === name);
+  if (!t) return { error: `no tool ${name}; tools: ${TOOLS.map((x) => x.name).join(', ')}` };
+  try {
+    const out = await t.handler(input);
+    record({ tool: name, door, ok: true });
+    return out;
+  } catch (e) {
+    record({ tool: name, door, ok: false, error: e.message });
+    return { error: e.message, ...(e.code && { code: e.code }), ...(e.need && { need: e.need }), ...(e.plan && { plan: brief(e.plan) }) };
+  }
+}
+
+// Publish the manifest: WebMCP when present, window.anyformer.tools always (the same entries).
+export function registerTools({ modelContext = globalThis.navigator?.modelContext, target = globalThis } = {}) {
+  if (modelContext?.registerTool)
+    for (const t of TOOLS)
+      modelContext.registerTool({ name: t.name, description: t.description, inputSchema: t.inputSchema, execute: (input) => call(t.name, input, 'modelContext') });
+  target.anyformer = { ...(target.anyformer || {}), tools: Object.fromEntries(TOOLS.map((t) => [t.name, (input) => call(t.name, input, 'window')])) };
+  return TOOLS.map((t) => t.name);
+}