pi-lilac-provider 1.5.0 → 1.6.0

package/README.md

@@ -190,7 +190,7 @@ Add to your pi configuration for automatic loading:
 
 Lilac's API is OpenAI-compatible with these specifics:
 
-- **`thinkingFormat: "chat-template"`** — All reasoning models. Lilac's vLLM backend toggles reasoning via `chat_template_kwargs`, but the honored key differs per model family. Per-model `chatTemplateKwargs` in `patch.json` send the right key(s): `thinking`+`enable_thinking` (bool) for Kimi K2.6, GLM 5.1, Gemma 4, and MiniMax M2.7; `enable_thinking` + `reasoning_effort` for GLM 5.2; `thinking_mode` (adaptive|enabled|disabled) for MiniMax M3. Kimi K2.6, GLM 5.1, and GLM 5.2 additionally send a preservation flag (`preserve_thinking: true` / `clear_thinking: false`) to retain full reasoning history across turns — see [Preserved thinking](#thinking-mode) above.
+- **`thinkingFormat: "chat-template"`** — All reasoning models. Lilac's vLLM backend toggles reasoning via `chat_template_kwargs`, but the honored key differs per model family. Per-model `chatTemplateKwargs` in `patch.json` send the right key(s): `thinking`+`enable_thinking` (bool) for Kimi K2.6, GLM 5.1, Gemma 4, and MiniMax M2.7; `enable_thinking` + `reasoning_effort` for GLM 5.2; `thinking_mode` (adaptive|enabled|disabled) for MiniMax M3. Kimi K2.6, GLM 5.1, and GLM 5.2 additionally send a preservation flag (`preserve_thinking: true` / `clear_thinking: false`) to retain full reasoning history across turns — see [Preserved thinking](#thinking-mode) above. Override these per-model via [Model Overrides](#model-overrides).
 - **`maxTokensField: "max_completion_tokens"`** — All models. Lilac supports `max_completion_tokens` (preferred for reasoning models as it includes reasoning tokens).
 - **`supportsDeveloperRole: true`** — All models. Lilac's vLLM backend maps the developer role to system.
 - **`supportsStore: false`** — All models. Lilac doesn't support the `store` parameter.
@@ -210,6 +210,27 @@ The `patch.json` file contains overrides that are applied on top of `models.json
 - Adding compat settings that the API doesn't provide
 - Overriding pricing when official rates change
 
+### 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` (including nested `chatTemplateKwargs`), `thinkingLevelMap`, and `cost` are deep-merged **recursively** (toggle one flag without redeclaring the rest), scalars and arrays are replaced. Applied at session start, so edits take effect on the next `pi` session.
+
+Create `~/.pi/agent/extensions/lilac.json` (auto-populated with defaults on first run):
+
+```jsonc
+{
+  "modelOverrides": {
+    // Disable full-history reasoning for kimi-k2.6 (e.g. to save tokens):
+    "moonshotai/kimi-k2.6": { "compat": { "chatTemplateKwargs": { "preserve_thinking": false } } },
+    // Toggle the GLM 5.2 clear_thinking flag without redeclaring the rest of compat:
+    "zai-org/glm-5.2": { "compat": { "chatTemplateKwargs": { "clear_thinking": true } } },
+    // Override a single thinking level without redeclaring the whole map:
+    "zai-org/glm-5.1": { "thinkingLevelMap": { "high": "max" } }
+  }
+}
+```
+
+The full set of overridable fields matches the model schema (`compat`, `thinkingLevelMap`, `cost`, `contextWindow`, `maxTokens`, `reasoning`, `input`). See [Compat Settings](#compat-settings) for the catalog of compat flags and what `chatTemplateKwargs` values mean per family. An invalid JSON file is left untouched (defaults are used) so a typo isn't silently wiped — fix the file and restart pi.
+
 ## Updating Models
 
 Run the update script to fetch the latest models from Lilac's API:

package/index.ts

@@ -178,6 +178,120 @@ interface PatchEntry {
 
 type PatchData = Record<string, PatchEntry>;
 
+// User Configuration: ~/.pi/agent/extensions/lilac.json lets a user override model
+// properties per id ON TOP of patch.json + custom-models.json (so they win).
+// Recursively deep-merges `compat` (incl. nested `chatTemplateKwargs`),
+// `thinkingLevelMap`, and `cost` (toggle one flag without redeclaring the rest),
+// replaces scalars and arrays. Lets a user toggle chat_template_kwargs (e.g.
+// preserve_thinking / clear_thinking) or a single thinking level without editing
+// the extension. See README "Model Overrides".
+interface ModelOverride {
+  thinkingLevelMap?: ThinkingLevelMap;
+  compat?: Record<string, unknown>;
+}
+
+interface LilacConfig {
+  modelOverrides?: Record<string, ModelOverride>;
+}
+
+const CONFIG_PATH = path.join(os.homedir(), ".pi", "agent", "extensions", "lilac.json");
+const DEFAULT_CONFIG: LilacConfig = { modelOverrides: {} };
+
+// Validate user-supplied modelOverrides from the config file. Non-object ids and
+// non-object overrides 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 as ThinkingLevelMap;
+    }
+    if (o.compat && typeof o.compat === "object") parsed.compat = o.compat as Record<string, unknown>;
+    if (Object.keys(parsed).length > 0) result[id] = parsed;
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
+// Reads ~/.pi/agent/extensions/lilac.json. Missing file → populate with defaults
+// so the user can discover it, then return defaults. An existing-but-invalid file
+// is left untouched (defaults returned) so a user's typo isn't silently wiped —
+// they fix the file and restart pi. Loaded lazily on first use (not at import) so
+// importing the module has no filesystem side effects and unit tests can import
+// the pure helpers safely.
+function loadConfig(): LilacConfig {
+  let rawText: string;
+  try {
+    rawText = fs.readFileSync(CONFIG_PATH, "utf8");
+  } catch {
+    try {
+      fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
+      fs.writeFileSync(CONFIG_PATH, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n");
+    } catch {
+      // Write failure is non-fatal — defaults still work in memory
+    }
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const raw = JSON.parse(rawText);
+    return { modelOverrides: parseModelOverrides(raw.modelOverrides) };
+  } catch {
+    // File exists but is invalid JSON — return defaults WITHOUT overwriting.
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+// Recursively deep-merge `override` into `base`. Plain objects are merged
+// key-by-key (so a user can toggle a single chatTemplateKwargs flag without
+// redeclaring the rest, and a single compat flag without redeclaring
+// chatTemplateKwargs); arrays and non-plain-object values replace the base value
+// (so an overridden { $var } schema object, or an `input` array, replaces wholesale).
+function isPlainObject(v: unknown): v is Record<string, unknown> {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+
+function deepMerge<T>(base: T, override: unknown): T {
+  if (!isPlainObject(override) || !isPlainObject(base)) return override as T;
+  const result: Record<string, unknown> = { ...(base as Record<string, unknown>) };
+  for (const [k, v] of Object.entries(override)) {
+    result[k] = isPlainObject(v) && isPlainObject(result[k]) ? deepMerge(result[k], v) : v;
+  }
+  return result as T;
+}
+
+// Apply a user-supplied modelOverride (from lilac.json) on top of a built model.
+// Recursively deep-merges compat (incl. nested chatTemplateKwargs) /
+// thinkingLevelMap / cost so a user can toggle a single flag (e.g.
+// chatTemplateKwargs.preserve_thinking) without redeclaring the rest; replaces
+// scalars and arrays. No reasoning-cleanup (unlike applyPatch) — the override is
+// authoritative.
+function applyModelOverride(model: JsonModel, override: ModelOverride): JsonModel {
+  const result = { ...model };
+  for (const [key, value] of Object.entries(override)) {
+    (result as any)[key] = isPlainObject(value) && isPlainObject((result as any)[key])
+      ? deepMerge((result as any)[key], value)
+      : value;
+  }
+  return result;
+}
+
+let config: LilacConfig | undefined;
+function getConfig(): LilacConfig {
+  if (!config) config = loadConfig();
+  return config;
+}
+
+function activeOverrides(): Record<string, ModelOverride> {
+  return getConfig().modelOverrides ?? {};
+}
+
 // ─── Patch Application ────────────────────────────────────────────────────────
 
 function applyPatch(model: JsonModel, patch: PatchEntry): JsonModel {
@@ -217,8 +331,13 @@ function applyPatch(model: JsonModel, patch: PatchEntry): JsonModel {
   return result;
 }
 
-/** Full pipeline: base models → patch → custom → result */
-function buildModels(base: JsonModel[], custom: JsonModel[], patch: PatchData): JsonModel[] {
+/** Full pipeline: base models → patch → custom → user modelOverrides → result */
+function buildModels(
+  base: JsonModel[],
+  custom: JsonModel[],
+  patch: PatchData,
+  overrides: Record<string, ModelOverride> = {},
+): JsonModel[] {
   const modelMap = new Map<string, JsonModel>();
 
   for (const model of base) {
@@ -246,6 +365,18 @@ function buildModels(base: JsonModel[], custom: JsonModel[], patch: PatchData):
     }
   }
 
+  // User-supplied modelOverrides (from ~/.pi/agent/extensions/lilac.json) applied
+  // LAST so they win over patch.json + custom-models.json. Recursively deep-merges
+  // compat (incl. chatTemplateKwargs) / thinkingLevelMap / cost 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());
 }
 
@@ -617,14 +748,14 @@ export default function (pi: ExtensionAPI) {
   // the in-flight model's cost without compounding an already-applied discount.
   function getListModels(): JsonModel[] {
     if (!listModelsCache) {
-      listModelsCache = buildModels(loadStaleModels(embeddedModels), customModels, patches);
+      listModelsCache = buildModels(loadStaleModels(embeddedModels), customModels, patches, activeOverrides());
     }
     return listModelsCache;
   }
 
   const staleBase = loadStaleModels(embeddedModels);
   latestDiscounts = loadCachedDiscounts();
-  const staleModels = applyDiscounts(buildModels(staleBase, customModels, patches), latestDiscounts);
+  const staleModels = applyDiscounts(buildModels(staleBase, customModels, patches, activeOverrides()), latestDiscounts);
 
   pi.registerProvider("lilac", {
     baseUrl: BASE_URL,
@@ -731,14 +862,14 @@ export default function (pi: ExtensionAPI) {
             baseUrl: BASE_URL,
             apiKey: "$LILAC_API_KEY",
             api: "openai-completions",
-            models: applyDiscounts(buildModels(merged, customModels, patches), latestDiscounts),
+            models: applyDiscounts(buildModels(merged, customModels, patches, activeOverrides()), latestDiscounts),
           });
         } else if (discounts) {
           pi.registerProvider("lilac", {
             baseUrl: BASE_URL,
             apiKey: "$LILAC_API_KEY",
             api: "openai-completions",
-            models: applyDiscounts(buildModels(staleBase, customModels, patches), latestDiscounts),
+            models: applyDiscounts(buildModels(staleBase, customModels, patches, activeOverrides()), latestDiscounts),
           });
         }
 
@@ -887,5 +1018,5 @@ export default function (pi: ExtensionAPI) {
   });
 }
 
-export { fetchStatusDiscounts, applyDiscounts, applyDiscountInPlace, loadCachedDiscounts, cacheDiscounts };
-export type { JsonDiscount, JsonModel, PatchEntry, PatchData };
+export { fetchStatusDiscounts, applyDiscounts, applyDiscountInPlace, loadCachedDiscounts, cacheDiscounts, buildModels, applyModelOverride, parseModelOverrides, loadConfig, getConfig };
+export type { JsonDiscount, JsonModel, PatchEntry, PatchData, ModelOverride, LilacConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-lilac-provider",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Lilac provider extension for pi - Access Kimi K2.6, GLM 5.1, and Gemma 4 models through Lilac's OpenAI-compatible API on idle GPUs",
   "type": "module",
   "main": "index.ts",
@@ -34,8 +34,10 @@
     "clean": "echo 'nothing to clean'",
     "build": "echo 'nothing to build'",
     "check": "echo 'nothing to check'",
-    "test": "node scripts/test-discounts.ts",
+    "test": "node scripts/test-discounts.ts && node scripts/test-preserved-thinking.ts && node scripts/test-model-overrides.ts",
+    "test:discounts": "node scripts/test-discounts.ts",
     "test:thinking": "node scripts/test-preserved-thinking.ts",
+    "test:overrides": "node scripts/test-model-overrides.ts",
     "update-models": "node scripts/update-models.js"
   }
 }

package/scripts/test-model-overrides.ts

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+/**
+ * Test for user model overrides (~/.pi/agent/extensions/lilac.json).
+ *
+ * Verifies, against the REAL exported helpers from index.ts (not a re-implementation):
+ *   - applyModelOverride: override wins over the base value; deep-merge compat /
+ *     cost / thinkingLevelMap preserves non-overridden fields; scalars replaced;
+ *     input model not mutated.
+ *   - parseModelOverrides: drops invalid entries (non-object override, non-string
+ *     thinkingLevelMap values), keeps valid ones.
+ *   - loadConfig: auto-populates a scaffold on a missing file; parses an existing
+ *     file's modelOverrides; returns defaults on invalid JSON WITHOUT overwriting
+ *     the user's file; returns undefined overrides for a file lacking the key.
+ *   - buildModels end-to-end: a user override on a real model id wins over
+ *     patch.json (e.g. disable preserve_thinking on kimi-k2.6) while the rest of
+ *     compat survives; with no overrides the built models are unchanged; an
+ *     override for an unknown id adds no models.
+ *
+ * Config FS is isolated to a temp HOME so nothing touches the real ~/.pi.
+ */
+
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+const root = path.resolve(import.meta.dirname, "..");
+const modelsData = JSON.parse(fs.readFileSync(path.join(root, "models.json"), "utf8"));
+const customModelsData = JSON.parse(fs.readFileSync(path.join(root, "custom-models.json"), "utf8"));
+const patchData = JSON.parse(fs.readFileSync(path.join(root, "patch.json"), "utf8"));
+
+// Isolate config + cache to a temp HOME so loadConfig never touches the real ~/.pi.
+// Must be set before importing index.ts, which computes CONFIG_PATH at module scope.
+const tmpHome = `/tmp/pi-lilac-override-test-${Date.now()}`;
+fs.mkdirSync(tmpHome, { recursive: true });
+process.env.HOME = tmpHome;
+
+const {
+  buildModels,
+  applyModelOverride,
+  parseModelOverrides,
+  loadConfig,
+} = await import("../index.ts");
+
+let passed = 0;
+let failed = 0;
+function assert(condition: boolean, message: string) {
+  if (condition) {
+    console.log(`  ✓ ${message}`);
+    passed++;
+  } else {
+    console.error(`  ✗ ${message}`);
+    failed++;
+  }
+}
+function eq<T>(actual: T, expected: T, message: string) {
+  const ok = JSON.stringify(actual) === JSON.stringify(expected);
+  if (ok) {
+    console.log(`  ✓ ${message}`);
+    passed++;
+  } else {
+    console.error(`  ✗ ${message}\n     expected: ${JSON.stringify(expected)}\n     actual:   ${JSON.stringify(actual)}`);
+    failed++;
+  }
+}
+
+const KIMI = "moonshotai/kimi-k2.6";
+const GLM52 = "zai-org/glm-5.2";
+const GLM51 = "zai-org/glm-5.1";
+
+// ─── applyModelOverride ────────────────────────────────────────────────────────
+
+console.log("\n--- applyModelOverride ---");
+
+{
+  const base = {
+    id: KIMI,
+    reasoning: true,
+    compat: {
+      thinkingFormat: "chat-template",
+      supportsDeveloperRole: false,
+      chatTemplateKwargs: { thinking: { $var: "thinking.enabled" }, preserve_thinking: true },
+    },
+    thinkingLevelMap: { low: "low", high: "high" },
+  } as any;
+
+  const out = applyModelOverride(base, { compat: { chatTemplateKwargs: { preserve_thinking: false } } } as any);
+  assert(out.compat.chatTemplateKwargs.preserve_thinking === false, "override wins over base for a compat flag it sets");
+  assert(out.compat.thinkingFormat === "chat-template", "deep-merge compat preserves non-overridden thinkingFormat");
+  assert(out.compat.supportsDeveloperRole === false, "deep-merge compat preserves non-overridden supportsDeveloperRole");
+  assert((out.compat.chatTemplateKwargs as any).thinking?.$var === "thinking.enabled", "deep-merge chatTemplateKwargs preserves non-overridden thinking key");
+  assert((base.compat.chatTemplateKwargs as any).preserve_thinking === true, "does not mutate the input model");
+}
+
+{
+  const base = { id: GLM52, thinkingLevelMap: { low: "low", high: "high" } } as any;
+  const out = applyModelOverride(base, { thinkingLevelMap: { high: "max" } } as any);
+  eq(out.thinkingLevelMap, { low: "low", high: "max" }, "deep-merge thinkingLevelMap overrides a single level, keeps the rest");
+}
+
+{
+  const base = { id: KIMI, reasoning: true, contextWindow: 131072 } as any;
+  const out = applyModelOverride(base, { reasoning: false, contextWindow: 65536 } as any);
+  assert(out.reasoning === false, "scalar override replaces reasoning");
+  assert(out.contextWindow === 65536, "scalar override replaces contextWindow");
+}
+
+{
+  const base = { id: GLM52, cost: { input: 1, output: 2, cacheRead: 0.2, cacheWrite: 0 } } as any;
+  // cost is a plain object -> recursively deep-merged (not on the ModelOverride
+  // type, so exercise it via a loose cast).
+  const out = applyModelOverride(base, { cost: { input: 5 } } as any);
+  eq(out.cost, { input: 5, output: 2, cacheRead: 0.2, cacheWrite: 0 }, "deep-merge cost overrides one field, keeps the rest");
+}
+
+{
+  // Overriding a { $var } schema object wholesale REPLACES it (no deep-merge into $var)
+  const base = { id: KIMI, compat: { chatTemplateKwargs: { thinking: { $var: "thinking.enabled" }, preserve_thinking: true } } } as any;
+  const out = applyModelOverride(base, { compat: { chatTemplateKwargs: { thinking: { $var: "thinking.effort" } } } } as any);
+  eq(out.compat.chatTemplateKwargs.thinking, { $var: "thinking.effort" }, "overriding a { $var } object replaces it (no merge into $var)");
+  assert(out.compat.chatTemplateKwargs.preserve_thinking === true, "sibling chatTemplateKwargs key survives a $var replacement");
+}
+
+{
+  // Overriding an array (input) replaces it wholesale (no index-wise merge)
+  const base = { id: KIMI, input: ["text", "image"] } as any;
+  const out = applyModelOverride(base, { input: ["text"] } as any);
+  eq(out.input, ["text"], "array override replaces wholesale (no index-wise merge)");
+}
+
+// ─── parseModelOverrides ───────────────────────────────────────────────────────
+
+console.log("\n--- parseModelOverrides ---");
+
+eq(parseModelOverrides(undefined), undefined, "undefined input -> undefined");
+eq(parseModelOverrides("nope"), undefined, "non-object input -> undefined");
+eq(parseModelOverrides({}), undefined, "empty object -> undefined (no valid entries)");
+eq(parseModelOverrides({ badId: "not-an-object" } as any), undefined, "non-object override value dropped -> undefined");
+eq(parseModelOverrides({ id: 123 } as any), undefined, "non-object override (number) dropped -> undefined");
+{
+  const r = parseModelOverrides({
+    [KIMI]: { compat: { chatTemplateKwargs: { preserve_thinking: false } } },
+    bad: 123,
+    alsobad: "string",
+  });
+  assert(r !== undefined && Object.keys(r!).length === 1 && r![KIMI] !== undefined, "keeps valid override, drops invalid ids");
+  assert((r![KIMI] as any).compat.chatTemplateKwargs.preserve_thinking === false, "valid override compat preserved");
+}
+{
+  // thinkingLevelMap: only string/null values kept; non-string values dropped
+  const r = parseModelOverrides({ [GLM52]: { thinkingLevelMap: { high: "max", bad: 42, off: null } } });
+  eq(r, { [GLM52]: { thinkingLevelMap: { high: "max", off: null } } }, "thinkingLevelMap keeps string/null values, drops others");
+}
+{
+  // an override whose fields all parse to nothing is dropped
+  const r = parseModelOverrides({ [KIMI]: { thinkingLevelMap: { bad: 42 } } });
+  eq(r, undefined, "override with no usable fields is dropped -> undefined");
+}
+
+// ─── loadConfig ────────────────────────────────────────────────────────────────
+
+console.log("\n--- loadConfig ---");
+
+const cfgPath = path.join(os.homedir(), ".pi", "agent", "extensions", "lilac.json");
+
+{
+  // Fresh tmpHome: no config file -> loadConfig auto-populates the scaffold and returns defaults
+  assert(!fs.existsSync(cfgPath), "scaffold not present before first loadConfig");
+  const cfg = loadConfig();
+  eq(cfg, { modelOverrides: {} }, "missing file -> defaults (empty modelOverrides)");
+  assert(fs.existsSync(cfgPath), "loadConfig auto-populates the scaffold file on missing file");
+  eq(JSON.parse(fs.readFileSync(cfgPath, "utf8")), { modelOverrides: {} }, "scaffold file contains the default shape");
+}
+
+{
+  // Existing file with valid modelOverrides -> parsed
+  fs.writeFileSync(cfgPath, JSON.stringify({
+    modelOverrides: { [KIMI]: { compat: { chatTemplateKwargs: { preserve_thinking: false } } } },
+  }));
+  const cfg = loadConfig();
+  assert((cfg.modelOverrides as any)?.[KIMI]?.compat?.chatTemplateKwargs?.preserve_thinking === false, "existing file's modelOverrides parsed");
+}
+
+{
+  // Existing file WITHOUT a modelOverrides key -> undefined overrides (not an error)
+  fs.writeFileSync(cfgPath, JSON.stringify({ unrelatedKey: true }));
+  const cfg = loadConfig();
+  assert(cfg.modelOverrides === undefined, "file without modelOverrides key -> undefined overrides");
+  assert(JSON.parse(fs.readFileSync(cfgPath, "utf8")).unrelatedKey === true, "file without modelOverrides key is not rewritten");
+}
+
+{
+  // Existing file with invalid JSON -> defaults returned, file left UNTOUCHED (typo not wiped)
+  fs.writeFileSync(cfgPath, "not json {{{");
+  const cfg = loadConfig();
+  eq(cfg, { modelOverrides: {} }, "invalid JSON -> defaults");
+  assert(fs.readFileSync(cfgPath, "utf8") === "not json {{{", "invalid file is not overwritten (typo preserved)");
+}
+
+// ─── buildModels end-to-end (real models.json + patch.json) ────────────────────
+
+console.log("\n--- buildModels end-to-end ---");
+
+function find(models: any[], id: string): any {
+  const m = models.find((x) => x.id === id);
+  if (!m) throw new Error(`model ${id} not built`);
+  return m;
+}
+
+{
+  // No overrides -> identical to today: kimi preserve_thinking: true survives patch
+  const models = buildModels(modelsData, customModelsData, patchData, {});
+  const kimi = find(models, KIMI);
+  assert(kimi.compat.chatTemplateKwargs.preserve_thinking === true, "no overrides -> kimi preserve_thinking stays true (patch wins)");
+  assert(kimi.compat.thinkingFormat === "chat-template", "no overrides -> kimi thinkingFormat intact");
+  const glm52 = find(models, GLM52);
+  assert(glm52.compat.chatTemplateKwargs.clear_thinking === false, "no overrides -> glm-5.2 clear_thinking stays false (patch wins)");
+}
+
+{
+  // User override wins over patch.json: disable preserve_thinking on kimi
+  const overrides = { [KIMI]: { compat: { chatTemplateKwargs: { preserve_thinking: false } } } } as any;
+  const models = buildModels(modelsData, customModelsData, patchData, overrides);
+  const kimi = find(models, KIMI);
+  assert(kimi.compat.chatTemplateKwargs.preserve_thinking === false, "override wins over patch: kimi preserve_thinking -> false");
+  // deep-merge: the $var thinking keys + thinkingFormat survive
+  assert((kimi.compat.chatTemplateKwargs as any).thinking?.$var === "thinking.enabled", "override deep-merges: thinking $var key survives");
+  assert((kimi.compat.chatTemplateKwargs as any).enable_thinking?.$var === "thinking.enabled", "override deep-merges: enable_thinking $var key survives");
+  assert(kimi.compat.thinkingFormat === "chat-template", "override deep-merges: thinkingFormat survives");
+  assert(kimi.compat.supportsDeveloperRole === false, "override deep-merges: supportsDeveloperRole survives");
+}
+
+{
+  // Override a single thinking level on glm-5.2 without redeclaring the map;
+  // the patch-applied clear_thinking flag survives a thinkingLevelMap-only override
+  const overrides = { [GLM52]: { thinkingLevelMap: { high: "max" } } } as any;
+  const models = buildModels(modelsData, customModelsData, patchData, overrides);
+  const glm = find(models, GLM52);
+  assert((glm.thinkingLevelMap as any)?.high === "max", "override thinkingLevelMap.high wins over patch");
+  assert(glm.compat.chatTemplateKwargs.clear_thinking === false, "non-overridden clear_thinking survives a thinkingLevelMap-only override");
+}
+
+{
+  // Override on glm-5.1 toggles clear_thinking (patch sets false); other compat survives
+  const overrides = { [GLM51]: { compat: { chatTemplateKwargs: { clear_thinking: true } } } } as any;
+  const models = buildModels(modelsData, customModelsData, patchData, overrides);
+  const glm = find(models, GLM51);
+  assert(glm.compat.chatTemplateKwargs.clear_thinking === true, "override wins over patch: glm-5.1 clear_thinking -> true");
+  assert((glm.compat.chatTemplateKwargs as any).thinking?.$var === "thinking.enabled", "override deep-merges: glm-5.1 thinking $var key survives");
+  assert(glm.compat.zaiToolStream === true, "override deep-merges: glm-5.1 zaiToolStream survives");
+}
+
+{
+  // Override for an unknown id is a no-op (adds no models)
+  const before = buildModels(modelsData, customModelsData, patchData, {});
+  const after = buildModels(modelsData, customModelsData, patchData, { "no/such-model": { reasoning: false } } as any);
+  eq(after.length, before.length, "override for an unknown id adds no models");
+}
+
+// ─── Summary ───────────────────────────────────────────────────────────────────
+
+console.log(`\n${failed === 0 ? "ALL PASS" : `${failed} FAILED`}`);
+process.exit(failed === 0 ? 0 : 1);