anyformer 0.0.1 → 0.3.1

package/src/store.js

@@ -0,0 +1,145 @@
+// 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);
+//                   'gguf/<name>' (diskformer-llama: llama.cpp's GGUFs, with <name>.part and .part.json while downloading;
+//                   anyformer-llama.json maps each name to its repo).
+
+import { DISKFORMER_MODELS } from './backends/diskformer.js';
+import { SPLIT_ROOT } from './gguf-split.js';
+import { readLlamaIndex, LLAMA_INDEX } from './backends/diskformer-llama.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 }));
+  }
+  const llama = await opfsDir(['gguf']);
+  if (llama) {
+    const index = await readLlamaIndex();
+    for await (const [name, h] of llama.entries()) {
+      if (h.kind !== 'file' || name.endsWith('.part.json') || name.endsWith('.crswap')) continue;
+      const base = name.replace(/\.part$/, '');
+      add('diskformer-llama', index[base], (await h.getFile()).size, async () => {
+        for (const n of [base, `${base}.part`, `${base}.part.json`]) await llama.removeEntry(n).catch(() => {});
+        const rest = await readLlamaIndex();
+        delete rest[base];
+        const w = await (await (await navigator.storage.getDirectory()).getFileHandle(LLAMA_INDEX, { create: true })).createWritable();
+        await w.write(JSON.stringify(rest));
+        await w.close();
+      });
+    }
+  }
+  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);
+}