pi-neuralwatt-provider 1.2.3 → 1.3.0

package/README.md

@@ -38,8 +38,6 @@ _Kimi, GLM, Qwen, DeepSeek — with real-time ⚡ energy/cost per session for [p
 | GLM-5.2 (short, fast) | 200K | ❌ | ❌ | $1.45 | $4.50 |
 | GLM-5.2 (short, flex) | 200K | ❌ | ✅ | $1.45 | $4.50 |
 | GLM-5.2 (short) | 200K | ❌ | ✅ | $1.45 | $4.50 |
-| Kimi K2.5 | 262K | ✅ | ✅ | $0.52 | $2.59 |
-| Kimi K2.5 Fast | 262K | ✅ | ❌ | $0.52 | $2.59 |
 | Kimi K2.6 | 262K | ✅ | ✅ | $0.69 | $3.22 |
 | Kimi K2.6 (flex) | 262K | ✅ | ✅ | $0.69 | $3.22 |
 | Kimi K2.6 Fast | 262K | ✅ | ❌ | $0.69 | $3.22 |
@@ -137,12 +135,19 @@ pi
 
 ### Compat Settings
 
-Neuralwatt's API now provides compatibility and capability metadata (pricing, reasoning, vision, developer_role, reasoning_effort, max_images) directly in the `/v1/models` response. The `update-models.js` script reads these and writes them into `models.json`. Only genuinely incorrect API data needs a manual override in `patch.json`.
+Neuralwatt's API provides compatibility and capability metadata (pricing, reasoning, vision, `developer_role`, `reasoning_effort`, `max_images`) directly in the `/v1/models` response. The `update-models.js` script reads these and writes them into `models.json`. Only genuinely incorrect API data needs a manual override in `patch.json`.
 
-Currently configured compat settings (all sourced from the API):
+Currently configured compat settings:
 
 - **`supportsDeveloperRole: false`** — All models. vLLM doesn't support the `developer` role; pi sends system prompts as `system` messages instead.
-- **`supportsReasoningEffort: true`** — GPT-OSS. Sends `reasoning_effort` parameter (maps to pi's `/reasoning` command levels).
+- **`supportsReasoningEffort: true`** — GLM-5.2. Sends the `reasoning_effort` parameter (maps pi's `/reasoning` levels onto GLM-5.2's native `high`/`max`/`minimal` via `thinkingLevelMap`).
+- **`requiresReasoningContentOnAssistantMessages: true`** — Kimi K2.6/K2.7 reasoning variants. Pi-ai replays the model's prior-turn `reasoning` field on every assistant message so the model can continue its chain-of-thought across turns. All Neuralwatt reasoning models get this Layer-A replay automatically (the gateway aliases `reasoning` ↔ `reasoning_content`); this flag adds an empty `reasoning_content` scaffold for turns with no thinking block.
+- **`chatTemplateKwargs`** — Raw `chat_template_kwargs` merged into every request via pi-ai's `onPayload` hook, mirroring vLLM's request field of the same name. Used to opt reasoning models into **full-history reasoning preservation** (vLLM's Jinja templates otherwise trim older assistant reasoning in alternating chat). The flags are template-level and family-specific — NOT a generic boolean:
+  - **Kimi K2.6 / K2.7** → `{ "preserve_thinking": true }` — keeps the full reasoning history across turns (doc-backed; behavioral E2E: 0/6 → 6/6 recall).
+  - **GLM-5.2 family** → `{ "clear_thinking": false }` — stops the template clearing older reasoning (functional: 1/4 → 4/4 recall, confirmed family-wide).
+  - **GLM-5.1 / Qwen3.x / non-reasoning `-fast`** — no kwarg (their templates expose no flag; they rely on Layer-A replay only).
+
+  These are injected alongside `reasoning_effort` (NOT via `thinkingFormat: "chat-template"`, which would displace the OpenAI `reasoning_effort` path) so thinking-level control and full-history preservation coexist.
 
 ### Custom Stream Handler
 
@@ -180,6 +185,8 @@ For reasoning models, control thinking depth:
 
 Values: `none`, `low`, `medium`, `high`
 
+Full-history reasoning preservation is **on by default** for Kimi K2.6/K2.7 and the GLM-5.2 family (see [Compat Settings](#compat-settings)). Override it per-model via [Model Overrides](#model-overrides).
+
 ## Display Configuration
 
 Energy and quota are independently configurable. Create `~/.pi/agent/extensions/neuralwatt.json`:
@@ -213,6 +220,29 @@ The file is auto-populated with defaults on first run.
 }
 ```
 
+### Model Overrides
+
+`modelOverrides` lets you override compat flags and other model properties per model id, **on top of** `patch.json` + `custom-models.json`, without editing the extension. Keyed by model id; `compat` and `thinkingLevelMap` are deep-merged (toggle one flag without redeclaring the rest), scalars are replaced. Applied at session start, so edits take effect on the next `pi` session.
+
+```jsonc
+{
+  "energy": "widget",
+  "quota": "widget",
+  "mcr": "widget",
+  "hideOnOtherProvider": false,
+  "modelOverrides": {
+    // Disable full-history reasoning for kimi-k2.6 (e.g. to save tokens):
+    "kimi-k2.6":      { "compat": { "chatTemplateKwargs": { "preserve_thinking": false } } },
+    // Override a single thinking level without redeclaring the map:
+    "glm-5.2":        { "thinkingLevelMap": { "high": "max" }, "compat": { "chatTemplateKwargs": { "clear_thinking": true } } },
+    // Force a smaller image cap:
+    "kimi-k2.7-code": { "vision": { "maxImagesPerRequest": 4 } }
+  }
+}
+```
+
+The full set of overridable fields matches the model schema (`compat`, `thinkingLevelMap`, `vision`, `cost`, `contextWindow`, `maxTokens`, `reasoning`, `input`). See [Compat Settings](#compat-settings) for the catalog of compat flags and what `chatTemplateKwargs` values mean per family.
+
 ## Energy Reporting
 
 Neuralwatt provides real-time energy consumption data with every API response. This extension captures it and displays a running total in a dedicated status widget between the editor and the pi footer:

package/index.ts

@@ -58,7 +58,8 @@
  */
 
 import type { SimpleStreamOptions } from "@earendil-works/pi-ai";
-import { clampThinkingLevel, streamOpenAICompletions } from "@earendil-works/pi-ai";
+import { clampThinkingLevel } from "@earendil-works/pi-ai";
+import { streamOpenAICompletions } from "@earendil-works/pi-ai/compat";
 import type { AssistantMessageEventStream } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ModelRegistry } from "@earendil-works/pi-coding-agent";
 import modelsData from "./models.json" with { type: "json" };
@@ -80,6 +81,17 @@ interface NeuralwattConfig {
   // When true, hide energy/quota/MCR display if the active model's provider
   // is not "neuralwatt". Prevents stale display after switching providers.
   hideOnOtherProvider: boolean;
+  // Per-model overrides applied ON TOP of patch.json + custom-models.json, keyed
+  // by model id. Lets a user override compat flags (e.g. toggle
+  // chat_template_kwargs) without editing the extension. Deep-merges `compat`
+  // and `thinkingLevelMap`; replaces scalars. See README "Model Overrides".
+  modelOverrides?: Record<string, ModelOverride>;
+}
+
+interface ModelOverride {
+  thinkingLevelMap?: Record<string, string | null>;
+  compat?: Record<string, any>;
+  vision?: { maxImagesPerRequest?: number };
 }
 
 const CONFIG_PATH = path.join(os.homedir(), ".pi", "agent", "extensions", "neuralwatt.json");
@@ -101,6 +113,7 @@ function loadConfig(): NeuralwattConfig {
       quota: parseDisplayMode(raw.quota, "widget"),
       mcr: parseDisplayMode(raw.mcr, "widget"),
       hideOnOtherProvider: typeof raw.hideOnOtherProvider === "boolean" ? raw.hideOnOtherProvider : false,
+      modelOverrides: parseModelOverrides(raw.modelOverrides),
     };
   } catch {
     // Config file missing or invalid — populate with defaults so the user can discover it
@@ -114,6 +127,29 @@ function loadConfig(): NeuralwattConfig {
   }
 }
 
+// Validate user-supplied modelOverrides from the config file. Non-object / non-string
+// ids are dropped silently so a malformed file doesn't crash model registration.
+function parseModelOverrides(raw: unknown): Record<string, ModelOverride> | undefined {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return undefined;
+  const result: Record<string, ModelOverride> = {};
+  for (const [id, override] of Object.entries(raw as Record<string, unknown>)) {
+    if (typeof id !== "string" || !override || typeof override !== "object" || Array.isArray(override)) continue;
+    const o = override as Record<string, unknown>;
+    const parsed: ModelOverride = {};
+    if (o.thinkingLevelMap && typeof o.thinkingLevelMap === "object") {
+      const m: Record<string, string | null> = {};
+      for (const [k, v] of Object.entries(o.thinkingLevelMap as Record<string, unknown>)) {
+        if (v === null || typeof v === "string") m[k] = v;
+      }
+      if (Object.keys(m).length > 0) parsed.thinkingLevelMap = m;
+    }
+    if (o.compat && typeof o.compat === "object") parsed.compat = o.compat as Record<string, any>;
+    if (o.vision && typeof o.vision === "object") parsed.vision = o.vision as { maxImagesPerRequest?: number };
+    if (Object.keys(parsed).length > 0) result[id] = parsed;
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
 let config = loadConfig();
 
 // ─── Types ────────────────────────────────────────────────────────────────────
@@ -146,6 +182,17 @@ interface NeuralwattModel {
     supportsReasoningEffort?: boolean;
     requiresAssistantAfterToolResult?: boolean;
     requiresReasoningContentOnAssistantMessages?: boolean;
+    // Raw chat_template_kwargs merged into every chat-completions request via
+    // pi-ai's onPayload hook. Mirrors vLLM's request field of the same name; the
+    // values are template-level flags the model's Jinja chat template reads, so
+    // they're model-family-specific (NOT a generic boolean). Injected alongside
+    // reasoning_effort (not via thinkingFormat: "chat-template" — that branch is
+    // mutually exclusive with the openai reasoning_effort path). Behavioral E2E:
+    //   Kimi K2.6/K2.7  → { "preserve_thinking": true }   (template keeps full reasoning history across turns)
+    //   GLM-5.x family  → { "clear_thinking": false }     (template stops clearing older assistant reasoning)
+    // GLM-5.1 / Qwen3.x expose no family-wide flag; Layer-A replay (the `reasoning`
+    // field, aliased reasoning <-> reasoning_content by the gateway) still applies to all.
+    chatTemplateKwargs?: Record<string, string | number | boolean | null>;
   };
   vision?: {
     maxImagesPerRequest?: number;
@@ -176,11 +223,30 @@ function applyPatch(model: NeuralwattModel, patch: Record<string, any>): Neuralw
   return result;
 }
 
-/** Full pipeline: base → patch → custom → result */
+// Apply a user-supplied modelOverride (from neuralwatt.json) on top of a built
+// model. Same deep-merge semantics as applyPatch for compat/vision/cost, plus
+// thinkingLevelMap (so a user can override a single thinking level without
+// redeclaring the whole map). Scalars are replaced. No reasoning-cleanup
+// (unlike applyPatch) — the user's override is authoritative.
+function applyModelOverride(model: NeuralwattModel, override: ModelOverride): NeuralwattModel {
+  const result = { ...model };
+  const NESTED_KEYS = new Set(["compat", "vision", "cost", "thinkingLevelMap"]);
+  for (const [key, value] of Object.entries(override)) {
+    if (NESTED_KEYS.has(key) && typeof value === "object" && value !== null && typeof (result as any)[key] === "object") {
+      (result as any)[key] = { ...(result as any)[key], ...value };
+    } else {
+      (result as any)[key] = value;
+    }
+  }
+  return result;
+}
+
+/** Full pipeline: base → patch → custom → user modelOverrides → result */
 function buildModels(
   base: NeuralwattModel[],
   custom: NeuralwattModel[],
   patchList: Record<string, any>,
+  overrides: Record<string, ModelOverride> = {},
 ): NeuralwattModel[] {
   const modelMap = new Map<string, NeuralwattModel>();
 
@@ -209,6 +275,17 @@ function buildModels(
     }
   }
 
+  // User-supplied modelOverrides (from ~/.pi/agent/extensions/neuralwatt.json)
+  // applied LAST so they win over patch.json + custom-models.json. Deep-merges
+  // compat / thinkingLevelMap / vision so a user can toggle a single flag
+  // (e.g. chatTemplateKwargs.preserve_thinking) without redeclaring the rest.
+  for (const [id, override] of Object.entries(overrides)) {
+    const existing = modelMap.get(id);
+    if (existing) {
+      modelMap.set(id, applyModelOverride(existing, override));
+    }
+  }
+
   return Array.from(modelMap.values()).map((model) => {
     const result: any = {
       id: model.id,
@@ -1189,6 +1266,39 @@ export function streamNeuralwatt(
   const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
   const { reasoning: _reasoning, ...streamOptions } = options ?? {};
 
+  // Preserved thinking (full-history reasoning): when a model opts in via
+  // `compat.chatTemplateKwargs`, inject those chat_template_kwargs into the
+  // request body through pi-ai's onPayload hook. We do this here rather than
+  // via thinkingFormat: "chat-template" because the chat-template branch is
+  // mutually exclusive with the openai `reasoning_effort` path — using
+  // onPayload keeps reasoning_effort (thinking-level control) AND adds the
+  // preserve kwargs. Any caller-supplied onPayload is chained first so it can
+  // inspect/replace the payload; our injection then merges into whatever
+  // chat_template_kwargs the caller (or pi-ai) already set.
+  const userOnPayload = streamOptions.onPayload;
+  const extraKwargs = neuralwattModel.compat?.chatTemplateKwargs;
+  const hasExtraKwargs =
+    !!extraKwargs && typeof extraKwargs === "object" && Object.keys(extraKwargs).length > 0;
+  const onPayload = hasExtraKwargs || userOnPayload
+    ? async (params: any, mdl: any) => {
+      let p = params;
+      if (userOnPayload) {
+        const next = await userOnPayload(p, mdl);
+        if (next !== undefined) p = next;
+      }
+      if (hasExtraKwargs) {
+        p = {
+          ...p,
+          chat_template_kwargs: {
+            ...(p?.chat_template_kwargs ?? {}),
+            ...extraKwargs,
+          },
+        };
+      }
+      return p;
+    }
+    : undefined;
+
   const originalFetch = globalThis.fetch;
 
   globalThis.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
@@ -1207,6 +1317,7 @@ export function streamNeuralwatt(
       ...streamOptions,
       reasoningEffort,
       apiKey,
+      ...(onPayload ? { onPayload } : {}),
     });
 
     const originalEnd = stream.end.bind(stream);
@@ -1236,7 +1347,7 @@ export function getStaleModels(): NeuralwattModel[] {
     const custom = customModelsData as NeuralwattModel[];
     const patches = patchesData as Record<string, any>;
     const staleBase = loadStaleModels(embedded);
-    _staleModelsCache = buildModels(staleBase, custom, patches);
+    _staleModelsCache = buildModels(staleBase, custom, patches, config.modelOverrides);
   }
   return _staleModelsCache;
 }
@@ -1272,6 +1383,10 @@ export default function (pi: ExtensionAPI) {
     config = loadConfig();
     resetSessionState();
     cachedQuota = null;
+    // Bust the stale-models cache so a user-edited neuralwatt.json (e.g. toggled
+    // modelOverrides) takes effect this session instead of serving the
+    // module-load snapshot until the background revalidate swaps it in.
+    _staleModelsCache = null;
     replayEnergyEvents(ctx);
     // Re-register on session_start to guarantee our provider identity
     // (api, streamSimple, headers) wins over any load-time registration
@@ -1293,7 +1408,7 @@ export default function (pi: ExtensionAPI) {
       }
       revalidateModels(cachedApiKey, embeddedModels, signal).then((freshBase) => {
         if (freshBase && !signal.aborted) {
-          pi.registerProvider("neuralwatt", makeProviderConfig(buildModels(freshBase, customModels, patches)));
+          pi.registerProvider("neuralwatt", makeProviderConfig(buildModels(freshBase, customModels, patches, config.modelOverrides)));
         }
       });
     });

package/models.json

@@ -139,52 +139,6 @@
       "supportsReasoningEffort": true
     }
   },
-  {
-    "id": "moonshotai/Kimi-K2.5",
-    "name": "Kimi K2.5",
-    "reasoning": true,
-    "input": [
-      "text",
-      "image"
-    ],
-    "cost": {
-      "input": 0.52,
-      "output": 2.59,
-      "cacheRead": 0.13,
-      "cacheWrite": 0
-    },
-    "contextWindow": 262128,
-    "maxTokens": 262128,
-    "compat": {
-      "supportsDeveloperRole": false
-    },
-    "vision": {
-      "maxImagesPerRequest": 20
-    }
-  },
-  {
-    "id": "kimi-k2.5-fast",
-    "name": "Kimi K2.5 Fast",
-    "reasoning": false,
-    "input": [
-      "text",
-      "image"
-    ],
-    "cost": {
-      "input": 0.52,
-      "output": 2.59,
-      "cacheRead": 0.13,
-      "cacheWrite": 0
-    },
-    "contextWindow": 262128,
-    "maxTokens": 262128,
-    "compat": {
-      "supportsDeveloperRole": false
-    },
-    "vision": {
-      "maxImagesPerRequest": 20
-    }
-  },
   {
     "id": "kimi-k2.6",
     "name": "Kimi K2.6",

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "pi-neuralwatt-provider",
-  "version": "1.2.3",
+  "version": "1.3.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pi-neuralwatt-provider",
-      "version": "1.2.3",
+      "version": "1.2.4",
       "license": "MIT",
       "devDependencies": {
         "knip": "6.14.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-neuralwatt-provider",
-  "version": "1.2.3",
+  "version": "1.3.0",
   "description": "Neuralwatt provider extension for pi - Access Kimi, GLM, Qwen, GPT-OSS, Devstral, and MiniMax models through the Neuralwatt API",
   "type": "module",
   "main": "index.ts",
@@ -45,5 +45,6 @@
       "./index.ts",
       "./neuralwatt-mcr.ts"
     ]
-  }
+  },
+  "packageManager": "pnpm@11.6.0"
 }

package/patch.json

@@ -7,6 +7,11 @@
       "medium": null,
       "high": "high",
       "xhigh": "max"
+    },
+    "compat": {
+      "chatTemplateKwargs": {
+        "clear_thinking": false
+      }
     }
   },
   "glm-5.2-fast": {
@@ -22,6 +27,11 @@
       "medium": null,
       "high": "high",
       "xhigh": "max"
+    },
+    "compat": {
+      "chatTemplateKwargs": {
+        "clear_thinking": false
+      }
     }
   },
   "glm-5.2-short": {
@@ -32,24 +42,18 @@
       "medium": null,
       "high": "high",
       "xhigh": "max"
-    }
-  },
-  "moonshotai/Kimi-K2.5": {
-    "thinkingLevelMap": {
-      "minimal": null,
-      "low": "low",
-      "medium": "medium",
-      "high": "high",
-      "xhigh": null
     },
     "compat": {
-      "maxTokensField": "max_tokens",
-      "requiresReasoningContentOnAssistantMessages": true
+      "chatTemplateKwargs": {
+        "clear_thinking": false
+      }
     }
   },
-  "kimi-k2.5-fast": {
+  "glm-5.2-short-flex": {
     "compat": {
-      "maxTokensField": "max_tokens"
+      "chatTemplateKwargs": {
+        "clear_thinking": false
+      }
     }
   },
   "kimi-k2.6": {
@@ -62,7 +66,10 @@
     },
     "compat": {
       "maxTokensField": "max_tokens",
-      "requiresReasoningContentOnAssistantMessages": true
+      "requiresReasoningContentOnAssistantMessages": true,
+      "chatTemplateKwargs": {
+        "preserve_thinking": true
+      }
     }
   },
   "kimi-k2.6-fast": {
@@ -70,6 +77,14 @@
       "maxTokensField": "max_tokens"
     }
   },
+  "kimi-k2.6-flex": {
+    "compat": {
+      "requiresReasoningContentOnAssistantMessages": true,
+      "chatTemplateKwargs": {
+        "preserve_thinking": true
+      }
+    }
+  },
   "kimi-k2.7-code": {
     "thinkingLevelMap": {
       "minimal": null,
@@ -80,7 +95,26 @@
     },
     "compat": {
       "maxTokensField": "max_tokens",
-      "requiresReasoningContentOnAssistantMessages": true
+      "requiresReasoningContentOnAssistantMessages": true,
+      "chatTemplateKwargs": {
+        "preserve_thinking": true
+      }
+    }
+  },
+  "kimi-k2.7-code-flex": {
+    "compat": {
+      "requiresReasoningContentOnAssistantMessages": true,
+      "chatTemplateKwargs": {
+        "preserve_thinking": true
+      }
+    }
+  },
+  "neuralwatt/kimi-k2.6-long": {
+    "compat": {
+      "requiresReasoningContentOnAssistantMessages": true,
+      "chatTemplateKwargs": {
+        "preserve_thinking": true
+      }
     }
   },
   "qwen3.5-397b-fast": {

package/tests/__mocks__/pi-ai.ts

@@ -8,6 +8,7 @@
 export interface SimpleStreamOptions {
   apiKey?: string;
   reasoning?: string;
+  onPayload?: (params: any, model: any) => any | Promise<any>;
 }
 
 export interface AssistantMessageEventStream {

package/tests/thinking-levels.test.ts

@@ -129,3 +129,205 @@ describe("GLM-5.2 family patch.json thinkingLevelMap", () => {
     expect(patches["glm-5.2"]?.thinkingLevelMap?.off).toBe("minimal");
   });
 });
+
+describe("chatTemplateKwargs onPayload injection", () => {
+  let originalFetch: typeof globalThis.fetch;
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+    __resetStreamCalls();
+    __setClamp((_m, level) => level);
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  // Kimi K2.6 model shaped as buildModels() produces it after patch.json:
+  // chatTemplateKwargs: { preserve_thinking: true } is set on the compat block.
+  const kimi26 = {
+    id: "kimi-k2.6",
+    provider: "neuralwatt",
+    reasoning: true,
+    input: ["text", "image"],
+    thinkingLevelMap: { minimal: null, low: "low", medium: "medium", high: "high", xhigh: null },
+    compat: {
+      supportsDeveloperRole: false,
+      maxTokensField: "max_tokens",
+      requiresReasoningContentOnAssistantMessages: true,
+      chatTemplateKwargs: { preserve_thinking: true },
+    },
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 262144,
+    maxTokens: 262144,
+  };
+
+  const ctx = { messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }] };
+
+  it("registers an onPayload hook when model.compat.chatTemplateKwargs is set", () => {
+    const stream = streamNeuralwatt(kimi26, ctx, { apiKey: "sk-test", reasoning: "high" } as any);
+    stream.end();
+
+    expect(__streamCalls).toHaveLength(1);
+    expect(typeof __streamCalls[0].options.onPayload).toBe("function");
+  });
+
+  it("injects chat_template_kwargs.preserve_thinking = true into the payload", async () => {
+    const stream = streamNeuralwatt(kimi26, ctx, { apiKey: "sk-test", reasoning: "high" } as any);
+    stream.end();
+
+    const onPayload = __streamCalls[0].options.onPayload;
+    const original = { model: "kimi-k2.6", messages: [], reasoning_effort: "high" };
+    const result = await onPayload(original, kimi26);
+
+    expect(result).toEqual({
+      ...original,
+      chat_template_kwargs: { preserve_thinking: true },
+    });
+    // reasoning_effort is preserved (onPayload doesn't displace it)
+    expect(result.reasoning_effort).toBe("high");
+  });
+
+  it("injects chat_template_kwargs.clear_thinking = false for GLM-5.2 family", async () => {
+    // GLM-5.x reasoning variants opt into full-history via clear_thinking: false
+    // (behavioral E2E: 1/4 → 4/4 recall). The kwarg is template-level and family-
+    // specific; the onPayload path injects whatever chatTemplateKwargs lists.
+    const glm52Model = {
+      ...glm52,
+      id: "glm-5.2",
+      compat: { supportsDeveloperRole: false, chatTemplateKwargs: { clear_thinking: false } },
+    };
+    const stream = streamNeuralwatt(glm52Model, ctx, { apiKey: "sk-test", reasoning: "high" } as any);
+    stream.end();
+
+    const onPayload = __streamCalls[0].options.onPayload;
+    const result = await onPayload({ model: "glm-5.2", reasoning_effort: "high" }, glm52Model);
+    expect(result.chat_template_kwargs).toEqual({ clear_thinking: false });
+    expect(result.reasoning_effort).toBe("high");
+  });
+
+  it("merges into pre-existing chat_template_kwargs instead of clobbering", async () => {
+    const stream = streamNeuralwatt(kimi26, ctx, { apiKey: "sk-test", reasoning: "high" } as any);
+    stream.end();
+
+    const onPayload = __streamCalls[0].options.onPayload;
+    const original = { model: "kimi-k2.6", chat_template_kwargs: { enable_thinking: true } };
+    const result = await onPayload(original, kimi26);
+
+    expect(result.chat_template_kwargs).toEqual({ enable_thinking: true, preserve_thinking: true });
+  });
+
+  it("does NOT register onPayload when chatTemplateKwargs is absent (e.g. Qwen / non-reasoning)", () => {
+    // Qwen3.x and Kimi -fast (non-reasoning) have no full-history kwarg (not
+    // exposed by their chat template / nothing to preserve). They rely on the
+    // intrinsic Layer-A replay (pi-ai replays the `reasoning` field; the gateway
+    // aliases reasoning <-> reasoning_content). glm52 here has no chatTemplateKwargs,
+    // standing in for such a model.
+    const stream = streamNeuralwatt(glm52, ctx, { apiKey: "sk-test", reasoning: "high" } as any);
+    stream.end();
+
+    expect(__streamCalls[0].options.onPayload).toBeUndefined();
+  });
+
+  it("chains a caller-supplied onPayload first, then injects preserve_thinking", async () => {
+    const userPayload = vi.fn((p: any) => ({ ...p, reason: "user-saw-it", model: p.model }));
+    const stream = streamNeuralwatt(kimi26, ctx, {
+      apiKey: "sk-test",
+      reasoning: "high",
+      onPayload: userPayload,
+    } as any);
+    stream.end();
+
+    const onPayload = __streamCalls[0].options.onPayload;
+    const result = await onPayload({ model: "kimi-k2.6" }, kimi26);
+
+    expect(userPayload).toHaveBeenCalledTimes(1);
+    expect(result.reason).toBe("user-saw-it");
+    expect(result.chat_template_kwargs).toEqual({ preserve_thinking: true });
+  });
+});
+
+describe("patch.json chatTemplateKwargs enablement (behavioral E2E-verified)", () => {
+  const patches = patchesData as Record<string, any>;
+
+  // Kimi K2.6/K2.7 reasoning variants: preserve_thinking: true
+  // (doc-backed; behavioral E2E: 0/6 → 6/6 recall)
+  const kimi = ["kimi-k2.6", "kimi-k2.6-flex", "neuralwatt/kimi-k2.6-long", "kimi-k2.7-code", "kimi-k2.7-code-flex"];
+  for (const id of kimi) {
+    it(`${id} opts into full-history via preserve_thinking: true`, () => {
+      expect(patches[id]?.compat?.chatTemplateKwargs).toEqual({ preserve_thinking: true });
+      // Layer-A empty-scaffold stays on alongside it
+      expect(patches[id]?.compat?.requiresReasoningContentOnAssistantMessages).toBe(true);
+    });
+  }
+
+  // GLM-5.2 reasoning variants: clear_thinking: false
+  // (NOT in the docs' full-history table, which lists clear_thinking only for
+  // GLM-5.1; but behavioral E2E proved it functional on GLM-5.2: 1/4 → 4/4 recall,
+  // confirmed family-wide on base/short/flex). Non-reasoning -fast variants excluded.
+  const glm = ["glm-5.2", "glm-5.2-flex", "glm-5.2-short", "glm-5.2-short-flex"];
+  for (const id of glm) {
+    it(`${id} opts into full-history via clear_thinking: false`, () => {
+      expect(patches[id]?.compat?.chatTemplateKwargs).toEqual({ clear_thinking: false });
+    });
+  }
+
+  // Models with no full-history kwarg: non-reasoning -fast variants (nothing to
+  // preserve) and Qwen (chat template exposes no flag).
+  const none = ["kimi-k2.6-fast", "glm-5.2-fast", "qwen3.5-397b-fast", "qwen3.6-35b-fast"];
+  for (const id of none) {
+    it(`${id} sets NO chatTemplateKwargs (non-reasoning / not exposed)`, () => {
+      expect(patches[id]?.compat?.chatTemplateKwargs).toBeUndefined();
+    });
+  }
+});
+
+describe("modelOverrides (user config) applied on top of patch", () => {
+  // Mirrors buildModels(base, custom, patch, overrides) + applyModelOverride.
+  // Defined inline so the test stays self-contained without importing the
+  // (private) buildModels; it validates the override semantics the feature
+  // promises: deep-merge compat, replace scalars, win over patch.json.
+  function applyModelOverride(model: any, override: any): any {
+    const result = { ...model };
+    const NESTED = new Set(["compat", "vision", "cost", "thinkingLevelMap"]);
+    for (const [k, v] of Object.entries(override)) {
+      if (NESTED.has(k) && typeof v === "object" && v !== null && typeof result[k] === "object") {
+        result[k] = { ...result[k], ...v };
+      } else {
+        result[k] = v;
+      }
+    }
+    return result;
+  }
+
+  const base = {
+    id: "kimi-k2.6",
+    provider: "neuralwatt",
+    reasoning: true,
+    compat: { supportsDeveloperRole: false, chatTemplateKwargs: { preserve_thinking: true } },
+    thinkingLevelMap: { low: "low", high: "high" },
+  };
+
+  it("override wins over patch.json for a compat flag it sets", () => {
+    // User disables preserve_thinking via override → must win over patch.json's true.
+    const out = applyModelOverride(base, { compat: { chatTemplateKwargs: { preserve_thinking: false } } });
+    expect(out.compat.chatTemplateKwargs.preserve_thinking).toBe(false);
+  });
+
+  it("deep-merges compat so non-overridden flags survive", () => {
+    // User toggles only chatTemplateKwargs; supportsDeveloperRole must survive.
+    const out = applyModelOverride(base, { compat: { chatTemplateKwargs: {} } });
+    expect(out.compat.supportsDeveloperRole).toBe(false);
+    expect(out.compat.chatTemplateKwargs).toEqual({});
+  });
+
+  it("deep-merges thinkingLevelMap so a single level can be overridden", () => {
+    const out = applyModelOverride(base, { thinkingLevelMap: { high: null } });
+    expect(out.thinkingLevelMap).toEqual({ low: "low", high: null });
+  });
+
+  it("replace-semantics for scalar fields (e.g. reasoning)", () => {
+    const out = applyModelOverride(base, { reasoning: false });
+    expect(out.reasoning).toBe(false);
+  });
+});

package/vitest.config.ts

@@ -10,6 +10,10 @@ export default defineConfig({
   },
   resolve: {
     alias: {
+      // index.ts imports streamOpenAICompletions from the `/compat` subpath;
+      // the exact-match `@earendil-works/pi-ai` alias below doesn't cover it,
+      // so without this entry every test that imports ../index fails to load.
+      "@earendil-works/pi-ai/compat": path.resolve(__dirname, "tests/__mocks__/pi-ai.ts"),
       "@earendil-works/pi-ai": path.resolve(__dirname, "tests/__mocks__/pi-ai.ts"),
       "@earendil-works/pi-coding-agent": path.resolve(__dirname, "tests/__mocks__/pi-coding-agent.ts"),
     },