anyformer 0.4.20 → 0.4.22

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## 0.4.22 — 2026-10-31
+
+### Changed
+- The `diskformer` back end downloads an `adapter` GGUF itself and keeps it in Cache Storage (`anyformer-adapters-v1`,
+  keyed by its URL, so by repo, revision and file). A later load reads it from disk; a cached copy whose size
+  differs from `adapter.size` downloads again. The download reports progress (`status: 'adapter'`, `loaded`,
+  `total`; `cached: true` on a cache hit), and the engine gets the bytes as a Blob. Before, every load fetched the
+  37 MB Pi adapter again with no progress (NakliOS: about 3 minutes per load at 200 KB/s).
+- `stored()` and `remove(repo)` cover the adapter cache, listed under the adapter's repo.
+
+### Verified
+- `npm test` 108/108: the first load downloads the adapter once with progress from 0 to 37,437,888 bytes and caches
+  it; a second load downloads nothing and reports `cached: true`.
+
+### Not yet verified
+- No browser run of the cache in Chrome; NakliOS's live check covers it.
+
+## 0.4.21 — 2026-10-31
+
+### Changed
+- diskformer pin cefebc7 → 7962912 (v0.6.20: run-time LoRA in every native MoE engine through `engines/lora.js`).
+  The `diskformer` back end now takes `adapter` on Gemma 4 26B and Qwen3.6 35B too. diskformer's gates (plain /
+  adapter / plain again, against llama-server --lora on the same file): Gemma 4 26B 9/9, 8/9, 9/9; Qwen3.6 35B 6/9,
+  9/9, 6/9. Adapters on routed experts are refused with an error. MiniCPM-V, Clover, Flint and Ling take no adapter,
+  so an `adapter` drops `diskformer` from their plans.
+
+### Verified (after the tag, on the pinned code)
+- Browser test `diskformer-chat --query "local=1&adapter=gemma4-26b-random-lora.gguf"` (new adapter mode; Gemma 4 26B
+  at a 2.5 GB budget, diskformer's seeded random rank-32 test adapter on 205 matrices, thinking on, 15:28 to 15:35
+  IST): plain 9/9 against llama-server, adapter on 8/9 against `llama-server --lora` on the same file, plain again 9/9
+  with the same text as the first phase; the adapter changed 3 of 9 replies. The one miss (word-problem) is the one
+  diskformer's own gate reports: the reply where the adapter first changes the text keeps the plain branch.
+- Not run: Qwen3.6 35B with its test adapter (36.9 GB GGUF).
+
 ## 0.4.20 — 2026-10-31
 
 ### Added
@@ -24,6 +58,16 @@
   `alwaysThinks` and `thinkInPrompt`) returns only the answer in `text`, and the reasoning in `reasoning`.
 - diskformer pin 317d2a0 → cefebc7 (v0.6.19: run-time LoRA in `lfm2_moe_ssd.js`).
 
+### Verified (after the npm publish, on the published code)
+- `tools` on LFM2.5 230M (`localmind`, local file): `get_weather` {"city":"Paris"} parsed from the bare call list;
+  after the tool result, an answer with 18°C and clear sky.
+- `tools` on `LFM2_5_24B_PI` (`diskformer`, run-time adapter, base GGUF and adapter from local files, 13:31 IST): the
+  first turn's text is empty (reasoning in `reasoning`) with `get_weather` {"city":"Paris"} as `toolCalls`; then
+  "The current weather in Paris is **clear skies** with a temperature of **18°C**."
+- `chat?entry=chat.LFM2_5_24B_PI&turns=4` on the same engine (by 13:41 IST): PASS, 4/4 turns on topic with no
+  reasoning in `text`; load 50 s from OPFS. The page's tok/s (about 2.5) counts only answer tokens after the hidden
+  reasoning, so it is not a decode speed.
+
 ## 0.4.19 — 2026-10-31
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anyformer",
-  "version": "0.4.20",
+  "version": "0.4.22",
   "description": "One call to run a model in a browser tab: anyformer reads the Hub repo, probes the browser, and picks the back end (transformers.js, LocalMind's WebGPU kernels, diskformer, kohra) that fits the model's format, architecture and your GPU budget.",
   "type": "module",
   "main": "./index.js",

package/src/backends/diskformer.js

@@ -11,11 +11,15 @@ export const DISKFORMER_MODELS = [
   {
     repo: 'google/gemma-4-26B-A4B-it-qat-q4_0-gguf', file: 'gemma-4-26B_q4_0-it.gguf', size: 14439363584,
     engine: 'gemma4_moe_ssd.js', Engine: 'Gemma4MoeSsd', minBudget: 2.5e9,
+    // LoRA at run time (v0.6.20+, gated against llama-server --lora on the same adapter file).
+    adapters: true,
     speeds: [[2.5e9, 12.4], [4.3e9, 14.2], [7e9, 17.9]],
   },
   {
     repo: 'unsloth/Qwen3.6-35B-A3B-GGUF', file: 'Qwen3.6-35B-A3B-Q8_0.gguf', size: 36903140320,
     engine: 'qwen35_moe_ssd.js', Engine: 'Qwen35MoeSsd', minBudget: 4e9,
+    // LoRA at run time (v0.6.20+, gated against llama-server --lora on the same adapter file).
+    adapters: true,
     speeds: [[4e9, 9.2]],
   },
   // Qwen3.6's language model with a vision encoder (mmproj, ~1.1 GB, loaded on the first image by ensureVision).
@@ -77,6 +81,41 @@ function budgetError(e) {
   return m && new AnyformerError('BUDGET_TOO_SMALL', `diskformer: ${e.message}`, { cause: e, need: Math.ceil((+m[1] + +m[2]) * 1e9) });
 }
 
+// Adapter GGUFs, kept in Cache Storage under their download URL (…/<repo>/resolve/<revision>/<file>), so a later load
+// reads them from disk. src/store.js lists and removes them with the adapter's repo.
+export const ADAPTER_CACHE = 'anyformer-adapters-v1';
+
+// The adapter's bytes as a Blob: from the cache, or downloaded with progress events and then cached. A cached copy
+// whose size differs from adapter.size is downloaded again.
+async function adapterBlob(url, adapter, onProgress, signal) {
+  const cache = typeof caches !== 'undefined' ? await caches.open(ADAPTER_CACHE).catch(() => null) : null;
+  const say = (loaded, total, cached = false) => onProgress?.({ backend: 'diskformer', status: 'adapter', file: adapter.file, loaded, total, ...(cached && { cached }) });
+  const hit = await cache?.match(url);
+  if (hit) {
+    const b = await hit.blob();
+    if (!adapter.size || b.size === adapter.size) { say(b.size, b.size, true); return b; }
+    await cache.delete(url);
+  }
+  const res = await fetch(url, { signal });
+  if (!res.ok) throw new AnyformerError('LOAD_FAILED', `diskformer: adapter ${adapter.file}: HTTP ${res.status}`);
+  const total = Number(res.headers.get('content-length')) || adapter.size || 0;
+  const parts = [], reader = res.body.getReader();
+  let loaded = 0, at = 0;
+  say(0, total);
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    parts.push(value);
+    loaded += value.length;
+    if (Date.now() - at > 250) { at = Date.now(); say(loaded, total); }
+  }
+  const blob = new Blob(parts);
+  if (adapter.size && blob.size !== adapter.size) throw new AnyformerError('LOAD_FAILED', `diskformer: adapter ${adapter.file}: ${blob.size} bytes, expected ${adapter.size}`);
+  say(blob.size, total || blob.size);
+  await cache?.put(url, new Response(blob, { headers: { 'content-length': String(blob.size) } })).catch(() => {});
+  return blob;
+}
+
 const has = (model, file, size) => model.files.gguf.some((f) => f.name === file && f.size === size);
 const match = (model) => DISKFORMER_MODELS.find((m) => m.repo === model.repo &&
   (m.parts ? m.parts.every((p) => has(model, p.file, p.size)) : has(model, m.file, m.size)));
@@ -117,7 +156,8 @@ export const diskformerBackend = {
   //   its pool from gpuBudgetBytes when given one, so it gets one or the other).
   // localFile: the GGUF as a File the user picked; the engine ingests it instead of downloading, and refuses a file
   //   whose size differs from the one it is pinned to.
-  // adapter: { repo, file, revision, scale } loads onto the GPU beside the model and is on for every reply;
+  // adapter: { repo, file, revision, size, scale } loads onto the GPU beside the model and is on for every reply; its
+  //   GGUF downloads once (progress events with status 'adapter') and stays in Cache Storage (ADAPTER_CACHE);
   //   session.setAdapter(false / true) switches it off and on again with no reload.
   async load(model, { budget, maxCtx = 1024, poolBytes, localFile, adapter = null, onProgress, signal }) {
     const m = match(model);
@@ -135,8 +175,8 @@ export const diskformerBackend = {
     let lora = null;
     if (adapter) {
       try {
-        onProgress?.({ backend: 'diskformer', status: 'adapter', file: adapter.file });
-        lora = await engine.loadAdapter(diskformerBackend.adapterUrl(adapter), { scale: adapter.scale ?? 1 });
+        const bytes = await adapterBlob(diskformerBackend.adapterUrl(adapter), adapter, onProgress, signal);
+        lora = await engine.loadAdapter(bytes, { scale: adapter.scale ?? 1 });
         await engine.setAdapter(lora);
       } catch (e) { await engine.dispose?.(); throw e; }
     }

package/src/sources.js

@@ -9,6 +9,8 @@ export const PINS = {
   // v0.3.1: seeded block-KV graphs (Nemotron-Labs-Diffusion-3B), chatFormat, split external data; download progress
   // (progress_callback) and the graph files cached in Cache Storage 'kohra-models'.
   kohra: 'bf95d44c3e3cfc001201baa03fa121c2bf9c7d73',
+  // v0.6.20 (7962912): run-time LoRA in every native MoE engine (engines/lora.js): Gemma 4 26B, Qwen3.6 35B, LFM2.5
+  // 24B and Qwen3 (untested); adapters on routed experts are refused. Engines expose addBos from the GGUF.
   // v0.6.19 (cefebc7): run-time LoRA in lfm2_moe_ssd.js (engine.loadAdapter / setAdapter, no reload to switch).
   // v0.6.18 (317d2a0): with thinking off, the llama.cpp chat closes a template's always-open <think> (LFM2.5-24B) and
   // bans the <think> token for the reply.
@@ -31,7 +33,7 @@ export const PINS = {
   // Gemma 4 E2B/E4B and Ternary Bonsai 2) under engines/, and the llama.cpp path under ggml/, which loads split GGUFs
   // and drafters, and reads past 2 GiB (Nemotron 3.5 Bolt E4B needs v0.6.8 or later). The hand engines' ingest
   // streams the GGUF header with progress and resumes a dropped range.
-  diskformer: 'cefebc7c18bf106f82378925bd5650cae4320193',
+  diskformer: '79629125d7a39b13ddcaf74df58262458d8d470e',
 };
 
 const gh = (repo, sha, path) => `https://cdn.jsdelivr.net/gh/NakliTechie/${repo}@${sha}/${path}`;

package/src/store.js

@@ -4,7 +4,8 @@
 //   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), 'kohra-models' (kohra v0.3.1+: its ONNX graph and data files), 'diskformer-models' (diskformer's
-//                   ONNX engines, LFM3-Omni): one entry per file URL
+//                   ONNX engines, LFM3-Omni), 'anyformer-adapters-v1' (LoRA adapters for diskformer's engines, listed
+//                   under the adapter's repo): one entry per file URL
 //                   (…/<repo>/resolve/<rev>/<file>). Older kohra left its graph in the 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
@@ -15,11 +16,11 @@
 //                   '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 { DISKFORMER_MODELS, ADAPTER_CACHE } 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', 'kohra-models': 'kohra', 'diskformer-models': 'diskformer-onnx' };
+const CACHE_BACKEND = { [ADAPTER_CACHE]: 'diskformer', 'transformers-cache': 'transformers', 'gguf-v1': 'localmind', 'gguf-v1-headers': 'localmind', 'bonsai-pipeline-v1': 'localmind', 'kohra-models': 'kohra', 'diskformer-models': 'diskformer-onnx' };
 const IDB_STORES = ['gguf-cache-v1', 'safetensors-cache-v1'];
 const BONSAI2 = 'prism-ml/Ternary-Bonsai-2-27B-gguf';