Sync from felladrin/MiniSearch@38e67b6

agents.md

@@ -190,7 +190,7 @@ Need to:
 
 1. Check the wasm build can run it: the architecture must exist in `node_modules/@wllama/wllama/esm/wasm/wllama.wasm` (grep the binary for the arch name), and the quant must stay under the ceilings in `docs/ai-integration.md` (shard every file under 2000 MiB; total weights under ~3.7 GB)
 2. Shard the GGUF (`llama-gguf-split --split --size`, or an equivalent) and publish to a `Felladrin/gguf-sharded-<QUANT>-<Name>` repo
-3. Add to `client/modules/wllama.ts`; thinking-by-default templates need nothing extra, their `reasoning_content` channel is streamed into the thinking UI
+3. Add to `client/modules/wllama.ts`; thinking-by-default templates need nothing extra (their `reasoning_content` channel is streamed into the thinking UI) but do need `reasoningBudgetTokens` so they cannot think past the context without answering
 4. Run `node scripts/wllama-catalog-check.cjs` and `npx vitest run client/modules/wllama.test.ts`
 5. Update `docs/ai-integration.md`
 6. Update `docs/configuration.md` defaults

changelog.md

@@ -6,6 +6,7 @@ Notable changes, grouped by date, most recent first.
 ## 2026-11-03
 
 - The five thinking models added on 2026-11-02 (Spark X2.6 1.7B and 4B, Granite 4.2 3B, Qwen 3.5 4B, Gemma 4 E2B) no longer ship with thinking switched off. Their chain of thought arrives on wllama's `reasoning_content` channel and is now wrapped in the configured reasoning markers, so the existing thinking UI shows it while the model reasons and the answer streams in after. The model warmup counts a reasoning token as a working model, so thinking models no longer log a failed warmup.
+- The same five models now cap their chain of thought with `reasoningBudgetTokens` (wllama's `reasoning_budget_tokens`, 256 tokens): when the model has thought that long without answering, the engine closes the reasoning channel and forces the final answer. Without the cap, Spark X2.6 and Granite 4.2 could spend the whole 4096-token context on reasoning and deliver no answer at all.
 
 
 ## 2026-11-02

client/modules/textGenerationWithWllama.ts

@@ -201,6 +201,9 @@ async function initializeWllamaInstance(progressCallback?: ProgressCallback) {
       flash_attn: model.flash_attn,
       embeddings: false,
       n_gpu_layers: isWebGPUAvailable ? 99999 : 0,
+      ...(model.reasoningBudgetTokens
+        ? { reasoning_budget_tokens: model.reasoningBudgetTokens }
+        : {}),
       progressCallback,
     },
   });

client/modules/wllama.test.ts

@@ -46,6 +46,18 @@ describe("wllamaModels catalog", () => {
     }
   });
 
+  it("keeps reasoning budgets small enough to leave room for the answer", () => {
+    // The budget forces the final answer once the chain of thought runs
+    // this long. It must stay far below the 4096-token context, or the
+    // model thinks itself out of the window before answering.
+    for (const [id, model] of models) {
+      if (model.reasoningBudgetTokens !== undefined) {
+        expect(model.reasoningBudgetTokens, id).toBeGreaterThanOrEqual(64);
+        expect(model.reasoningBudgetTokens, id).toBeLessThanOrEqual(1024);
+      }
+    }
+  });
+
   it("uses the shared default context size for every model", () => {
     for (const [id, model] of models) {
       expect(model.contextSize, id).toBe(4096);

client/modules/wllama.ts

@@ -141,6 +141,14 @@ export interface WllamaModel {
    * it off.
    */
   readonly chatTemplateKwargs?: Record<string, unknown>;
+  /**
+   * Hard cap on the chain of thought, in tokens (wllama's
+   * `reasoning_budget_tokens`). When the model has thought this long
+   * without answering, the engine closes the reasoning channel and forces
+   * the final answer, so a long-winded model cannot spend the whole
+   * context window thinking and deliver nothing.
+   */
+  readonly reasoningBudgetTokens?: number;
   getSampling: () => Omit<SamplingParams, "logit_bias">;
 }
 
@@ -345,6 +353,7 @@ export const wllamaModels: Readonly<Record<string, WllamaModel>> = {
     hfRepoId: "Felladrin/gguf-sharded-Q4_K_M-Spark-X2.6-1.7B",
     hfFilePath: "Spark-X2.6-1.7B-Q4_K_M-00001-of-00004.gguf",
     fileSizeInMegabytes: 1769,
+    reasoningBudgetTokens: 256,
   },
   "smollm3-3b": {
     ...createDefaultModelConfig(),
@@ -380,6 +389,7 @@ export const wllamaModels: Readonly<Record<string, WllamaModel>> = {
     hfRepoId: "Felladrin/gguf-sharded-Q4_K_S-granite-4.2-3b",
     hfFilePath: "granite-4.2-3b-Q4_K_S-00001-of-00005.gguf",
     fileSizeInMegabytes: 2143,
+    reasoningBudgetTokens: 256,
   },
   "phi-3.5-mini-3.8b": {
     ...createDefaultModelConfig(),
@@ -408,6 +418,7 @@ export const wllamaModels: Readonly<Record<string, WllamaModel>> = {
     hfRepoId: "Felladrin/gguf-sharded-UD-Q3_K_XL-Qwen3.5-4B",
     hfFilePath: "Qwen3.5-4B-UD-Q3_K_XL-00001-of-00005.gguf",
     fileSizeInMegabytes: 2436,
+    reasoningBudgetTokens: 256,
   },
   "gemma-4-e2b": {
     ...createDefaultModelConfig(),
@@ -415,6 +426,7 @@ export const wllamaModels: Readonly<Record<string, WllamaModel>> = {
     hfRepoId: "Felladrin/gguf-sharded-Q3_K_S-gemma-4-e2b-it",
     hfFilePath: "gemma-4-e2b-it-Q3_K_S-00001-of-00005.gguf",
     fileSizeInMegabytes: 2446,
+    reasoningBudgetTokens: 256,
   },
   "phi-4-mini-reasoning": {
     ...createDefaultModelConfig(),
@@ -429,5 +441,6 @@ export const wllamaModels: Readonly<Record<string, WllamaModel>> = {
     hfRepoId: "Felladrin/gguf-sharded-Q4_K_M-Spark-X2.6-4B",
     hfFilePath: "Spark-X2.6-4B-Q4_K_M-00001-of-00007.gguf",
     fileSizeInMegabytes: 3543,
+    reasoningBudgetTokens: 256,
   },
 };

docs/ai-integration.md

@@ -38,7 +38,7 @@ Two constraints decide what can join that list, both measured against the shippe
 - **Every model file must be a shard.** Chromium's OPFS storage silently truncates files past 2000 MiB, so a monolithic GGUF above that size arrives corrupted in the browser. Shards also keep progressive download working.
 - **The wasm linear memory ceiling is 4 GiB.** Models at ~3.5 GB and above OOM during buffer reserve, so the practical catalog ceiling is around 3.7 GB of weights.
 
-Models whose chat template thinks by default (Granite 4.2, Gemma 4, Spark X2.6, Qwen 3.5) keep thinking: wllama splits their chain of thought into a `reasoning_content` channel, and MiniSearch wraps it in the configured reasoning markers so the thinking UI shows it while the answer follows. Thinking spends the same token budget as the answer, so these models are slower and, on a long chain of thought, can use up the context before answering.
+Models whose chat template thinks by default (Granite 4.2, Gemma 4, Spark X2.6, Qwen 3.5) keep thinking: wllama splits their chain of thought into a `reasoning_content` channel, and MiniSearch wraps it in the configured reasoning markers so the thinking UI shows it while the answer follows. Thinking spends the same token budget as the answer, so these models are slower. To keep a long-winded model from thinking its way out of the context window without ever answering, thinking models ship with `reasoningBudgetTokens` (wllama's `reasoning_budget_tokens`, currently 256): once the chain of thought runs that long, the engine closes the reasoning channel and forces the final answer.
 
 `node scripts/wllama-catalog-check.cjs` HEADs every shard of every catalog model on HuggingFace and verifies the claimed sizes; run it after adding or re-sharding a model.
 

package-lock.json

@@ -4659,9 +4659,9 @@
       }
     },
     "node_modules/knip": {
-      "version": "6.44.0",
-      "resolved": "https://registry.npmjs.org/knip/-/knip-6.44.0.tgz",
-      "integrity": "sha512-mT0fl71Mqrko91azUO2Jw/uhYKwldORKT4liRq6yV0ZAtt6G2eYusdnvx8eBSQJDjvhRGKkpKUUx+vUG6syV4w==",
+      "version": "6.44.1",
+      "resolved": "https://registry.npmjs.org/knip/-/knip-6.44.1.tgz",
+      "integrity": "sha512-Hbd8nvkIsNgFfXgC7Jsb5LHv7jj6VwA3tmfHd53XPX2z9Vc9RnAZqV0BIiP4OrtYqKwCoLseFHQZerb1bNlbSw==",
       "dev": true,
       "funding": [
         {