anyformer 0.4.19 → 0.4.21

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # Changelog
 
+## 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.
+
+### Not yet verified
+- No browser run of an adapter on Gemma 4 or Qwen3.6 through anyformer: no adapter GGUF for either is in the catalog.
+
+## 0.4.20 — 2026-10-31
+
+### Added
+- Tool calls on every back end: `generate(messages, { tools })` takes OpenAI-style tools. A back end whose chat template
+  renders them (`diskformer-onnx`) gets them as they are; for the others anyformer writes the tool list, assistant
+  `tool_calls` turns and `tool` results into the conversation in the model family's format (`src/tool-calls.js`: LFM2's
+  `<|tool_list_start|>` / `<|tool_call_start|>[name(k=v)]<|tool_call_end|>`; Qwen's hermes `<tools>` /
+  `<tool_call>{json}</tool_call>` for the rest). A chunk whose text holds complete calls carries them as `toolCalls`
+  (OpenAI `tool_calls`, ids `call_<n>`) and its text without them. Qwen3-Coder XML calls (LFM3) parse too, and for LFM2
+  a bare call list ending the reply, since LocalMind's LFM2 engine decodes without special tokens. An assistant turn
+  with only `tool_calls` and no content is valid input.
+- Run-time LoRA on diskformer's LFM2.5 engine (v0.6.19): the `diskformer` back end applies `adapter` with
+  `engine.loadAdapter` / `setAdapter`; `session.setAdapter(false / true)` switches it off and on with no reload.
+  `backend.adapters` may be a function of the model.
+- Browser test `tools`: one get_weather call and its result, then a text answer with the temperature.
+
+### Changed
+- `MODELS.chat.LFM2_5_24B_PI` moves to the `diskformer` back end (the base QAD-Q4_0 GGUF plus the 37 MB adapter at run
+  time; diskformer's gate 9/9 against llama-server --lora). diskformer-llama still applies it where the hand engine
+  cannot run.
+- With thinking off, a diskformer engine that always reasons with the block opened by its prompt (LFM2.5-24B:
+  `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/README.md

@@ -78,6 +78,7 @@ and `threw`. Every other failure is an `AnyformerError` too, with a code from `E
 ```js
 plan(repo, { budget, task })      // what would run it (adapter: a LoRA GGUF; only diskformer-llama applies one), and why the others would not; loads nothing
 load(repo, { budget, task, file, adapter, maxCtx, poolBytes, localFile, fetch, ple, speculative, onProgress, signal })  // → { backend, task, plan, run(input), generate?, think?, prime?, reset?, speculative?, dispose() }
+generate(messages, { tools })     // OpenAI-style tools in; chunks carry parsed toolCalls (LFM2, Qwen/hermes, Qwen3-Coder XML)
 pipeline(task, repo, { budget })  // transformers.js's call shape: gen(messages) → [{ generated_text }]
 probe()                           // WebGPU, shader-f16, subgroups, limits, OPFS quota, memory64
 describe(repo)                    // Hub repo → formats, architecture, task, tags, files

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anyformer",
-  "version": "0.4.19",
+  "version": "0.4.21",
   "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-onnx.js

@@ -81,6 +81,8 @@ export const diskformerOnnxBackend = {
       // chunk, and `sampleRate`; maxNewTokens then counts text tokens and speech frames (80 ms each) together. Speech is
       // sampled (generation_config.json: temperature 0.4, repetition penalty 1.2 over 64 frames); audioTemperature,
       // audioRepetitionPenalty, audioRepetitionWindow and seed override it.
+      // The chat template renders the tool list itself; anyformer only parses the calls.
+      templateTools: true,
       async *generate(messages, { maxNewTokens = 512, signal, thinking = false, tools, repetitionPenalty, speech = false, seed,
         audioTemperature, audioRepetitionPenalty, audioRepetitionWindow } = {}) {
         const queue = [];

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).
@@ -51,6 +55,8 @@ export const DISKFORMER_MODELS = [
   {
     repo: 'LiquidAI/LFM2.5-24B-A2B-GGUF', file: 'LFM2.5-24B-A2B-QAD-Q4_0.gguf', size: 13578190880,
     engine: 'lfm2_moe_ssd.js', Engine: 'Lfm2MoeSsd', minBudget: 4e9,
+    // LoRA at run time (v0.6.19+: engine.loadAdapter / setAdapter; adapters on the routed experts are refused).
+    adapters: true,
     speeds: [],
   },
   // Two parts, ingested as one file by the engine's splitFetch (engines/ling_moe_ssd.js LING_FLASH, rev 29edce5).
@@ -91,6 +97,10 @@ export const diskformerBackend = {
   source: SOURCES.diskformer,
   // Where the engine downloads its GGUF from; null is Hugging Face. A test points it at a local server.
   url: null,
+  // Where an adapter GGUF downloads from.
+  adapterUrl: (a) => `https://huggingface.co/${a.repo}/resolve/${a.revision || 'main'}/${a.file.split('/').map(encodeURIComponent).join('/')}`,
+  // The engines that apply a LoRA at run time.
+  adapters: (model) => !!match(model)?.adapters,
 
   canRun(model, caps, { budget, task }) {
     if (!model.formats.includes('gguf')) return { ok: false, code: 'format', reason: 'no GGUF in the repo' };
@@ -111,7 +121,9 @@ 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.
-  async load(model, { budget, maxCtx = 1024, poolBytes, localFile, onProgress, signal }) {
+  // adapter: { repo, file, revision, scale } loads onto the GPU beside the model and is on for every reply;
+  //   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);
     const mod = await import(`${diskformerBackend.source}/${m.engine}`);
     let engine;
@@ -124,6 +136,14 @@ export const diskformerBackend = {
         onProgress: onProgress && ((e) => onProgress({ backend: 'diskformer', ...e })),
       });
     } catch (e) { throw budgetError(e) || e; }
+    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 });
+        await engine.setAdapter(lora);
+      } catch (e) { await engine.dispose?.(); throw e; }
+    }
     // Where the model's reasoning starts and ends, as token ids, so a caller can split it out without parsing text.
     const open = engine.thinkOpenTokenId ?? null;
     return {
@@ -136,14 +156,23 @@ export const diskformerBackend = {
       // thinking: false (the default, as on every back end here) answers directly; true lets a model that reasons
       // (Gemma 4, Qwen3.6, Ling) think first. Image blocks ({ type: 'image', rgb, width, height }) pass through to
       // an engine that reads them.
+      // A model that always reasons with the block opened by its prompt (LFM2.5-24B: engine.alwaysThinks and
+      // thinkInPrompt) cannot answer directly, so with thinking off its reasoning moves to `reasoning` and `text` holds
+      // only what follows </think> (empty until then).
       async *generate(messages, { maxNewTokens = 512, signal, thinking = false } = {}) {
-        for await (const r of engine.generate(messages, { maxNewTokens, signal, enableThinking: thinking === true }))
-          yield { text: r.text, token: r.token, tokens: r.tokens };
+        const split = thinking !== true && engine.alwaysThinks === true && engine.thinkInPrompt === true;
+        for await (const r of engine.generate(messages, { maxNewTokens, signal, enableThinking: thinking === true })) {
+          if (!split) { yield { text: r.text, token: r.token, tokens: r.tokens }; continue; }
+          const at = r.text.indexOf('</think>');
+          yield at < 0 ? { text: '', reasoning: r.text, token: r.token, tokens: r.tokens }
+            : { text: r.text.slice(at + 8).replace(/^\s+/, ''), reasoning: r.text.slice(0, at), token: r.token, tokens: r.tokens };
+        }
       },
       // Checkpoints a system prompt after load, so the first question does not wait for it (Qwen3.6, MiniCPM-V).
       ...(typeof engine.prime === 'function' && { prime: (system) => engine.prime(system) }),
       // Loads the vision tower, for an engine that reads images (MiniCPM-V).
       ...(typeof engine.ensureVision === 'function' && { ensureVision: (o) => engine.ensureVision(o) }),
+      ...(lora && { setAdapter: (on) => engine.setAdapter(on ? lora : null) }),
       dispose: () => engine.dispose(),
     };
   },

package/src/load.js

@@ -9,6 +9,7 @@ import { localmindBackend } from './backends/localmind.js';
 import { wllamaBackend } from './backends/wllama.js';
 import { diskformerOnnxBackend } from './backends/diskformer-onnx.js';
 import { AnyformerError, wrap } from './errors.js';
+import { toolFormat, withTools, parseToolCalls } from './tool-calls.js';
 
 // Back ends land here as each one passes its browser test (test/browser/). The list order breaks ties: a
 // diskformer hand engine carries a measured speed and outranks diskformer-llama for the same model; diskformer-llama
@@ -30,8 +31,9 @@ function noBackend(plan) {
 // task: a Hugging Face pipeline task ('text-generation', 'feature-extraction', …); null runs the repo's own.
 // file: a weights file in the repo to load (a GGUF name); null lets each back end pick.
 // repo: a Hub id, or an entry from MODELS (its task, budget and adapter apply unless opts set them).
-// adapter: a LoRA GGUF applied over the model, { repo, file, revision, size, scale }; only a back end with
-// `adapters: true` (diskformer-llama) can apply one, so the others drop out of the plan.
+// adapter: a LoRA GGUF applied over the model, { repo, file, revision, size, scale }; only a back end whose
+// `adapters` is true, or a function that says yes for the model, can apply one (diskformer's LFM2.5 engine at run time,
+// diskformer-llama), so the others drop out of the plan.
 const entry = (repo, opts) => (typeof repo === 'object' && repo?.repo
   ? [repo.repo, { ...(repo.task && { task: repo.task }), ...(repo.budget && { budget: repo.budget }), ...(repo.adapter && { adapter: repo.adapter }), ...opts }]
   : [repo, opts]);
@@ -40,7 +42,7 @@ export async function plan(repoOrEntry, opts = {}) {
   let [repo, { budget = DEFAULT_BUDGET, task = null, file = null, backends = BACKENDS, caps, model, fetch, adapter = null }] = entry(repoOrEntry, opts);
   caps ??= await probe();
   model ??= await describe(repo, fetch ? { fetch } : {});
-  if (adapter) backends = backends.filter((b) => b.adapters);
+  if (adapter) backends = backends.filter((b) => (typeof b.adapters === 'function' ? b.adapters(model) : b.adapters));
   return { model, caps, budget, task, file, ...(adapter && { adapter }), ...(await resolve(model, caps, backends, { budget, task, file })) };
 }
 
@@ -56,17 +58,22 @@ export async function load(repoOrEntry, options = {}) {
     session = await backend.load(p.model, { budget: p.budget, task: p.task, file: p.file, adapter: p.adapter, caps: p.caps, maxCtx, dtype, poolBytes, localFile, fetch: engineFetch, ple, speculative, speech, onProgress, signal });
   } catch (e) { throw wrap(e, 'LOAD_FAILED', signal, `${backend.id}: `); }
   // Added onto serialize()'s object, not spread: a spread would read its getters once and freeze them.
-  return Object.assign(serialize(session), { backend: backend.id, task: session.task || p.task || p.model.task || null, ...(session.device && { device: session.device }), plan: p });
+  return Object.assign(serialize(session, p.model.architecture), { backend: backend.id, task: session.task || p.task || p.model.task || null, ...(session.device && { device: session.device }), plan: p });
 }
 
 // content: a string, or an array of { type, … } blocks (text, image, audio) for multimodal models.
 const validContent = (c) => typeof c === 'string' || (Array.isArray(c) && c.every((b) => typeof b?.type === 'string'));
-const validMessages = (messages) => Array.isArray(messages) && messages.every((m) => typeof m?.role === 'string' && validContent(m?.content));
+// An assistant turn that only calls tools may have no content.
+const validMessages = (messages) => Array.isArray(messages) && messages.every((m) => typeof m?.role === 'string' &&
+  (validContent(m?.content) || (m.role === 'assistant' && Array.isArray(m.tool_calls) && (m.content == null || m.content === ''))));
 
 // One call at a time per session: two overlapping generates would share one KV cache. A call waits for the previous
 // one to finish (or for its caller to stop iterating). dispose() waits for the running call, then frees the GPU;
 // calls after it throw DISPOSED.
-function serialize(session) {
+// tools: OpenAI-style tool definitions. A back end whose chat template takes them (templateTools) gets them as they are;
+// for the others the conversation carries them as text in the model family's format (src/tool-calls.js). Either way a
+// chunk whose text holds complete tool calls carries them as `toolCalls` (OpenAI tool_calls) and its text without them.
+function serialize(session, architecture) {
   let tail = Promise.resolve(), disposed = false;
   const gone = () => new AnyformerError('DISPOSED', 'this session was disposed; load the model again');
   const turn = async () => {
@@ -83,7 +90,15 @@ function serialize(session) {
     const release = await turn();
     try {
       if (disposed) throw gone();
-      for await (const chunk of session.generate(messages, o)) yield chunk;
+      const tools = o.tools?.length ? o.tools : null;
+      const traffic = messages.some((m) => m.role === 'tool' || m.tool_calls?.length);
+      const asText = (tools || traffic) && !session.templateTools;
+      const msgs = asText ? withTools(messages, tools, toolFormat(architecture)) : messages;
+      const { tools: _, ...rest } = o;
+      for await (const chunk of session.generate(msgs, asText ? rest : o)) {
+        const found = tools && typeof chunk.text === 'string' ? parseToolCalls(chunk.text, toolFormat(architecture)) : null;
+        yield found?.toolCalls.length ? { ...chunk, text: found.content, toolCalls: found.toolCalls } : chunk;
+      }
     } catch (e) {
       throw wrap(e, 'EXECUTION_FAILED', o.signal);
     } finally {
@@ -110,6 +125,8 @@ function serialize(session) {
     ...(session.prime && { prime: queued(session.prime) }),
     ...(session.ensureVision && { ensureVision: queued(session.ensureVision) }),
     ...(session.reset && { reset: queued(session.reset) }),
+    // Switches a loaded adapter on (true) or off (false) for the next reply, with no reload (diskformer's LFM2.5 engine).
+    ...(session.setAdapter && { setAdapter: queued(session.setAdapter) }),
     // The one call every task has. For text generation it is the last chunk of generate().
     async run(input, o = {}) {
       if (generate) { let last; for await (const c of generate(input, o)) last = c; return last; }

package/src/models.js

@@ -3,7 +3,7 @@
 // passed. `test` names the page under test/browser/ that proves the entry; test/models.test.js checks it exists.
 // `diffusion: true` marks a text-diffusion model (the reply denoises in blocks, so generate() chunks arrive a block at a time); `experimental: true` marks an entry its
 // app shows as opt-in until that app's own checks pass; `audioOut: true` marks a model that can also answer in speech
-// (generate({ speech: true })); `adapter` names a LoRA GGUF applied over the model (diskformer-llama only).
+// (generate({ speech: true })); `adapter` names a LoRA GGUF applied over the model (diskformer's LFM2.5 engine, diskformer-llama).
 
 const M = (repo, backend, task, test, extra = {}) => ({ repo, backend, task, test, ...extra });
 
@@ -32,13 +32,15 @@ const NEMOTRON_3_5_BOLT_E4B = M('danyalmalik/NVIDIA-Nemotron-3.5-Bolt-E4B-ONNX-W
 // diskformer checked one hand-written prompt through complete(); generate() renders the GGUF's chat template, which no
 // browser run has checked.
 const DEEPSEEK_V4_1_FLASH = M('ISTA-DASLab/DeepSeek-V4.1-Flash-1017-GSQ-RCO-GGUF', 'diskformer-llama', 'text-generation', 'llama-gate', { budget: 8e9, downloadBytes: 231316411072, experimental: true });
-// LFM2.5-24B-A2B with harness-hub's Pi LoRA (rank 32, alpha 64; asynchronous GRPO inside the Pi coding agent), on
-// diskformer's llama.cpp path, the only back end that applies an adapter. The adapter touches the conv, attention and
-// two dense FFN layers only, so expert paging is unchanged. diskformer v0.6.17's gate: 8/9 replies identical to
-// llama-server --lora (the path's own baseline without the adapter is 7/9). Authors' numbers on 100 data-analysis tasks:
-// 39% fewer tool calls on tasks both solve, pass@1 −4.2 points (noise about ±5); expect base-model behaviour or worse in
-// other agents. Licence lfm1.0 (model and adapter): royalty-free commercial use only below US$10M annual revenue.
-const LFM2_5_24B_PI = M('LiquidAI/LFM2.5-24B-A2B-GGUF', 'diskformer-llama', 'text-generation', 'chat', {
+// LFM2.5-24B-A2B with harness-hub's Pi LoRA (rank 32, alpha 64; asynchronous GRPO inside the Pi coding agent), applied
+// at run time by diskformer's LFM2.5 engine (v0.6.19: one base download, the 37 MB adapter beside it on the GPU,
+// session.setAdapter(false) for the plain model with no reload). The adapter touches the conv, attention and two dense
+// FFN layers only. diskformer's gate: 9/9 replies identical to llama-server --lora (plain 8/9 against llama.cpp, the
+// engine's baseline). diskformer-llama applies it too (8/9) when the hand engine cannot run. Authors' numbers on 100
+// data-analysis tasks: 39% fewer tool calls on tasks both solve, pass@1 −4.2 points (noise about ±5); expect base-model
+// behaviour or worse in other agents. Licence lfm1.0 (model and adapter): royalty-free commercial use only below
+// US$10M annual revenue. The model always reasons first on the hand engine (no thinking-off form).
+const LFM2_5_24B_PI = M('LiquidAI/LFM2.5-24B-A2B-GGUF', 'diskformer', 'text-generation', 'chat', {
   budget: 4e9, downloadBytes: 13578190880 + 37437888, experimental: true, license: 'lfm1.0',
   adapter: { repo: 'harness-hub/LFM2.5-24B-A2B-pi-GGUF', file: 'LFM2.5-24B-A2B-harbor-pi-lora-F16.gguf',
     revision: 'a994cf7f03ab0e572832d5829f42cbe2ef28d472', size: 37437888, scale: 1, trainedFor: 'pi' },
@@ -80,7 +82,7 @@ export const MODELS = {
     LFM3_OMNI_2B,
     /** DeepSeek V4.1 Flash (763B MoE), a tech demo on diskformer's llama.cpp path: 231 GB on disk, very slow. */
     DEEPSEEK_V4_1_FLASH,
-    /** LFM2.5-24B-A2B with harness-hub's Pi coding-agent LoRA (diskformer's llama.cpp path); tuned for the Pi agent; licence lfm1.0. */
+    /** LFM2.5-24B-A2B with harness-hub's Pi coding-agent LoRA, applied at run time by diskformer's engine; tuned for the Pi agent; licence lfm1.0. */
     LFM2_5_24B_PI,
   },
   /** Chat with images in the messages: content [{ type: 'image', image }, { type: 'text', text }]. Gemma 4 takes audio too. */

package/src/sources.js

@@ -9,6 +9,9 @@ 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.
   // v0.6.17 (314362e): LoRA adapters on the llama.cpp path (llama.load({ lora, loraScale })), and lfm2_moe_ssd.js runs
@@ -30,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: '317d2a002d95278e504ed84fab2d0f71dabaa884',
+  diskformer: '79629125d7a39b13ddcaf74df58262458d8d470e',
 };
 
 const gh = (repo, sha, path) => `https://cdn.jsdelivr.net/gh/NakliTechie/${repo}@${sha}/${path}`;

package/src/tool-calls.js

@@ -0,0 +1,186 @@
+// Tool calls for every back end: generate(messages, { tools }) takes OpenAI-style tools ({ type: 'function', function:
+// { name, description, parameters } }), writes them into the conversation in the model family's own format, and reads
+// the calls back out of the reply as OpenAI `tool_calls`. Assistant turns that carry `tool_calls` and `tool` turns that
+// carry results are written back in the same format, so a multi-step tool loop needs no model-specific code.
+//
+// Formats:
+//   lfm2    LFM2 / LFM2.5 (architectures lfm2, lfm2moe): the system turn gets "List of tools: <|tool_list_start|>[…]
+//           <|tool_list_end|>"; the model answers <|tool_call_start|>[name(arg="v", n=1)]<|tool_call_end|> (Python call
+//           syntax); results go back as a `tool` turn. As in LiquidAI's chat template.
+//   hermes  Qwen and the rest: "# Tools … <tools>{json per line}</tools> …" in the system turn; the model answers
+//           <tool_call>{"name": …, "arguments": {…}}</tool_call>; results go back in <tool_response> in a user turn. As
+//           in Qwen3's chat template.
+// The parser also reads Qwen3-Coder's XML calls (<tool_call><function=name><parameter=k>v</parameter></function>), which
+// LFM3 writes, whatever the format of the prompt.
+
+const LFM2 = new Set(['lfm2', 'lfm2moe']);
+export const toolFormat = (architecture) => (LFM2.has(architecture) ? 'lfm2' : 'hermes');
+
+const fn = (t) => t.function || t;
+const text = (c) => (typeof c === 'string' ? c : (c || []).filter((b) => b.type === 'text').map((b) => b.text).join('\n'));
+const args = (a) => (typeof a === 'string' ? (a ? JSON.parse(a) : {}) : a || {});
+
+// A Python literal for the lfm2 call syntax.
+function py(v) {
+  if (v === null || v === undefined) return 'None';
+  if (v === true) return 'True';
+  if (v === false) return 'False';
+  if (Array.isArray(v)) return `[${v.map(py).join(', ')}]`;
+  if (typeof v === 'object') return `{${Object.entries(v).map(([k, x]) => `${JSON.stringify(k)}: ${py(x)}`).join(', ')}}`;
+  return JSON.stringify(v);
+}
+
+function callText(calls, format) {
+  if (format === 'lfm2') {
+    const list = calls.map((c) => `${fn(c).name}(${Object.entries(args(fn(c).arguments)).map(([k, v]) => `${k}=${py(v)}`).join(', ')})`);
+    return `<|tool_call_start|>[${list.join(', ')}]<|tool_call_end|>`;
+  }
+  return calls.map((c) => `<tool_call>\n${JSON.stringify({ name: fn(c).name, arguments: args(fn(c).arguments) })}\n</tool_call>`).join('\n');
+}
+
+function systemText(tools, format) {
+  const defs = tools.map(fn);
+  if (format === 'lfm2') return `List of tools: <|tool_list_start|>${JSON.stringify(defs)}<|tool_list_end|>`;
+  return '# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function ' +
+    `signatures within <tools></tools> XML tags:\n<tools>\n${defs.map((d) => JSON.stringify({ type: 'function', function: d })).join('\n')}\n</tools>\n\n` +
+    'For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n' +
+    '<tool_call>\n{"name": <function-name>, "arguments": <args-json-object>}\n</tool_call>';
+}
+
+// The conversation with the tool list in its system turn and tool traffic as text, for a back end whose chat template
+// is not given the tools itself.
+export function withTools(messages, tools, format) {
+  const out = [];
+  const list = tools?.length ? systemText(tools, format) : null;
+  const first = messages[0]?.role === 'system' ? messages[0] : null;
+  if (list) out.push({ role: 'system', content: first ? `${text(first.content)}\n${list}` : list });
+  else if (first) out.push(first);
+  for (const m of messages.slice(first ? 1 : 0)) {
+    if (m.role === 'assistant' && m.tool_calls?.length) {
+      const before = text(m.content);
+      out.push({ role: 'assistant', content: `${before ? `${before}\n` : ''}${callText(m.tool_calls, format)}` });
+    } else if (m.role === 'tool') {
+      const body = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
+      if (format === 'lfm2') out.push({ role: 'tool', content: body });
+      else {
+        const prev = out.at(-1);
+        const wrapped = `<tool_response>\n${body}\n</tool_response>`;
+        // Consecutive results share one user turn, as Qwen3's template writes them.
+        if (prev?.role === 'user' && prev.toolResults) prev.content += `\n${wrapped}`;
+        else out.push(Object.defineProperty({ role: 'user', content: wrapped }, 'toolResults', { value: true }));
+      }
+    } else out.push(m);
+  }
+  return out.map(({ role, content }) => ({ role, content }));
+}
+
+// A Python literal (strings, numbers, True/False/None, lists, dicts) at s[i]: [value, next index].
+function literal(s, i) {
+  const ws = () => { while (/\s/.test(s[i])) i++; };
+  ws();
+  const c = s[i];
+  if (c === '"' || c === "'") {
+    let out = '';
+    for (i++; i < s.length && s[i] !== c; i++) {
+      if (s[i] === '\\') { i++; out += ({ n: '\n', t: '\t', r: '\r' })[s[i]] ?? s[i]; } else out += s[i];
+    }
+    if (s[i] !== c) throw new Error('unterminated string');
+    return [out, i + 1];
+  }
+  if (c === '[' || c === '(') {
+    const close = c === '[' ? ']' : ')', arr = [];
+    for (i++; ;) {
+      ws();
+      if (s[i] === close) return [arr, i + 1];
+      let v; [v, i] = literal(s, i); arr.push(v); ws();
+      if (s[i] === ',') i++;
+      else if (s[i] !== close) throw new Error('bad list');
+    }
+  }
+  if (c === '{') {
+    const obj = {};
+    for (i++; ;) {
+      ws();
+      if (s[i] === '}') return [obj, i + 1];
+      let k, v; [k, i] = literal(s, i); ws();
+      if (s[i++] !== ':') throw new Error('bad dict');
+      [v, i] = literal(s, i); obj[k] = v; ws();
+      if (s[i] === ',') i++;
+      else if (s[i] !== '}') throw new Error('bad dict');
+    }
+  }
+  const m = /^(True|False|None|true|false|null|-?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?)/.exec(s.slice(i));
+  if (!m) throw new Error(`bad value at ${i}`);
+  const t = m[1];
+  return [t === 'True' || t === 'true' ? true : t === 'False' || t === 'false' ? false : t === 'None' || t === 'null' ? null : Number(t), i + t.length];
+}
+
+// [name(k=v, …), …] in Python call syntax.
+function pythonCalls(body) {
+  const s = body.trim().replace(/^\[/, '').replace(/\]$/, ''), calls = [];
+  let i = 0;
+  while (i < s.length) {
+    const m = /^\s*,?\s*([A-Za-z_][\w.-]*)\s*\(/.exec(s.slice(i));
+    if (!m) break;
+    i += m[0].length;
+    const a = {};
+    for (;;) {
+      while (/[\s,]/.test(s[i])) i++;
+      if (s[i] === ')') { i++; break; }
+      const k = /^([A-Za-z_]\w*)\s*=/.exec(s.slice(i));
+      if (!k) throw new Error('bad argument');
+      i += k[0].length;
+      let v; [v, i] = literal(s, i); a[k[1]] = v;
+    }
+    calls.push({ name: m[1], arguments: a });
+  }
+  return calls;
+}
+
+function xmlCall(body) {
+  const f = /<function=([^>\s]+)>([\s\S]*?)(?:<\/function>|$)/.exec(body);
+  if (!f) return null;
+  const a = {};
+  for (const p of f[2].matchAll(/<parameter=([^>\s]+)>([\s\S]*?)<\/parameter>/g)) {
+    const v = p[2].replace(/^\n/, '').replace(/\n$/, '');
+    try { a[p[1]] = JSON.parse(v); } catch { a[p[1]] = v; }
+  }
+  return { name: f[1], arguments: a };
+}
+
+const PATTERNS = [
+  [/<\|tool_call_start\|>([\s\S]*?)<\|tool_call_end\|>/g, (b) => pythonCalls(b)],
+  [/<tool_call>([\s\S]*?)<\/tool_call>/g, (b) => {
+    const x = xmlCall(b);
+    if (x) return [x];
+    const j = JSON.parse(b.trim());
+    return [{ name: j.name, arguments: args(j.arguments ?? j.parameters) }];
+  }],
+];
+
+// A bare LFM2 call list ending the reply, for an engine that decodes without special tokens (LocalMind's LFM2 engine
+// drops <|tool_call_start|> and <|tool_call_end|>): "[name(k=v), …]" that parses whole as calls.
+const BARE_LFM2 = /\[\s*[A-Za-z_][\w.-]*\s*\([\s\S]*\)\s*\]\s*$/;
+
+// The reply's tool calls as OpenAI tool_calls, and its text without them. A call that does not parse stays in the
+// text. ids are call_<n> in reply order. format 'lfm2' also reads a bare call list that ends the reply.
+export function parseToolCalls(reply, format = null) {
+  const calls = [];
+  let content = reply;
+  for (const [re, read] of PATTERNS) {
+    content = content.replace(re, (whole, body) => {
+      try { calls.push(...read(body)); return ''; } catch { return whole; }
+    });
+  }
+  const bare = format === 'lfm2' && !calls.length && BARE_LFM2.exec(content);
+  if (bare) {
+    try {
+      const found = pythonCalls(bare[0]);
+      if (found.length) { calls.push(...found); content = content.slice(0, bare.index); }
+    } catch { /* not a call list: leave the text */ }
+  }
+  return {
+    content: calls.length ? content.trim() : reply,
+    toolCalls: calls.map((c, n) => ({ id: `call_${n}`, type: 'function', function: { name: c.name, arguments: JSON.stringify(c.arguments) } })),
+  };
+}