pi-lilac-provider 1.4.1 → 1.6.0

package/README.md

@@ -128,6 +128,23 @@ for M3's adaptive "model decides" mode. (The selector/footer show pi's level
 names — `minimal`/`high` — not the `thinking_mode` values; pi has no per-model
 level-relabel hook.)
 
+**Preserved thinking (full-history reasoning).** By default these templates
+trim older assistant reasoning between turns (each vendor's default), which
+degrades multi-turn recall. Three models opt into full-history preservation via
+a template flag sent alongside the reasoning key:
+
+| Model | Flag | Effect |
+|-------|------|--------|
+| Kimi K2.6 | `preserve_thinking: true` | keeps every assistant turn's reasoning (default: only the last) |
+| GLM 5.1 | `clear_thinking: false` | keeps reasoning for all turns (default: clears before the last user message) |
+| GLM 5.2 | `clear_thinking: false` | keeps reasoning for all turns (default: clears before the last user message) |
+
+Kimi K2.6 and GLM 5.2 are E2E-verified on the sibling neuralwatt provider via a
+3-turn, two-20-digit-number recall test (Kimi 0/6 → 6/6, GLM 5.2 1/4 → 4/4);
+GLM 5.1 uses the same `clear_thinking` mechanism (confirmed in its HuggingFace
+chat template). Gemma 4 and MiniMax M2.7/M3 expose no family-wide preserve flag,
+so their older assistant reasoning is trimmed per the template default.
+
 In pi, reasoning models automatically use the appropriate thinking format. Use
 Shift+Tab to control thinking level.
 
@@ -173,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.
+- **`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.
@@ -193,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.4.1",
+  "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,7 +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/patch.json

@@ -10,7 +10,8 @@
       "thinkingFormat": "chat-template",
       "chatTemplateKwargs": {
         "thinking": { "$var": "thinking.enabled" },
-        "enable_thinking": { "$var": "thinking.enabled" }
+        "enable_thinking": { "$var": "thinking.enabled" },
+        "preserve_thinking": true
       },
       "maxTokensField": "max_completion_tokens",
       "supportsDeveloperRole": false,
@@ -29,7 +30,8 @@
       "thinkingFormat": "chat-template",
       "chatTemplateKwargs": {
         "thinking": { "$var": "thinking.enabled" },
-        "enable_thinking": { "$var": "thinking.enabled" }
+        "enable_thinking": { "$var": "thinking.enabled" },
+        "clear_thinking": false
       },
       "maxTokensField": "max_completion_tokens",
       "supportsDeveloperRole": false,
@@ -42,7 +44,8 @@
       "thinkingFormat": "chat-template",
       "chatTemplateKwargs": {
         "enable_thinking": { "$var": "thinking.enabled" },
-        "reasoning_effort": { "$var": "thinking.effort", "omitWhenOff": true }
+        "reasoning_effort": { "$var": "thinking.effort", "omitWhenOff": true },
+        "clear_thinking": false
       }
     },
     "thinkingLevelMap": {

package/scripts/test-discounts.ts

@@ -17,7 +17,7 @@
  *     recomputed from list price so re-applied discounts never compound.
  * 11. before_provider_request mutates the bound (in-flight) model object so the
  *     current turn's cost calc sees the discount in real time.
- * 12. session_start schedules a 10-minute background /status poll to cover idle
+ * 12. session_start schedules a 5-minute background /status poll to cover idle
  *     sessions; session_shutdown clears it.
  */
 
@@ -700,12 +700,12 @@ assert(
   "deferred session_start paints the NEW lilac model's discount (glm), not the stale kimi capture",
 );
 
-// ─── Test 17: session_start schedules a 10-min idle poll; shutdown clears it ─
+// ─── Test 17: session_start schedules a 5-min idle poll; shutdown clears it ─
 
 console.log("\n--- Test 17: session_start schedules idle poll; session_shutdown clears it ---");
 
-// Lilac refreshes discounts ~every 10 minutes. session_start must schedule a
-// background /status poll at that cadence to cover idle sessions (turn fetches
+// Lilac refreshes discounts ~every 10 minutes, so session_start polls /status
+// every 5 min (half the refresh window) to cover idle sessions (turn fetches
 // only run when the user sends a message), and session_shutdown must clear it so
 // it neither leaks nor keeps the process alive. Wrap the global timer APIs to
 // capture the scheduled delay + handle, then confirm shutdown clears it.
@@ -729,7 +729,7 @@ globalThis.clearInterval = ((handle: ReturnType<typeof setInterval>) => {
 
 try {
   // Benign fetch mock so the session_start fire-and-forget /models + /status
-  // fetch doesn't hit the network. (The poll itself never fires — 10 min — so
+  // fetch doesn't hit the network. (The poll itself never fires — 5 min — so
   // only the startup fetch needs mocking here.)
   globalThis.fetch = mockFetch({
     "/models": { body: { data: [] } },
@@ -759,8 +759,8 @@ try {
   }
 
   assert(
-    scheduledDelay === 10 * 60 * 1000,
-    "session_start schedules a 10-minute (600000ms) /status poll for idle sessions",
+    scheduledDelay === 5 * 60 * 1000,
+    "session_start schedules a 5-minute (300000ms) /status poll for idle sessions",
   );
   assert(scheduledHandle !== null, "poll interval handle was captured");
   const capturedHandle = scheduledHandle;

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);

package/scripts/test-preserved-thinking.ts

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+/**
+ * Wire-level test for preserved-thinking (full-history reasoning) flags.
+ *
+ * Verifies, against the REAL pi-ai streamSimple + a stubbed fetch, that the
+ * `chat_template_kwargs` each Lilac reasoning model puts on the wire include the
+ * preservation flags configured in patch.json — and that those static flags
+ * coexist with the { $var }-resolved thinking keys at every thinking level.
+ *
+ * Background: reasoning models trim older assistant reasoning across turns by
+ * default (each vendor's template default). Two template-level flags opt into
+ * full-history preservation (confirmed in each model's HuggingFace chat
+ * template; Kimi K2.6 and GLM 5.2 additionally E2E-verified on the sibling
+ * neuralwatt provider's 3-turn / two-20-digit-number recall test):
+ *
+ *   Kimi K2.6    → preserve_thinking: true   (template: "if preserve_thinking, keep -1 ... retain reasoning")
+ *   GLM 5.1      → clear_thinking: false      (same clear_thinking mechanism as GLM 5.2)
+ *   GLM 5.2      → clear_thinking: false      (template: keep reasoning when "clear_thinking is defined and not clear_thinking")
+ *
+ * Lilac uses pi-ai's `chat-template` thinkingFormat, which calls
+ * buildChatTemplateKwargs → resolveChatTemplateKwargValue. Static primitive
+ * kwargs pass through verbatim; only { $var } objects are resolved against the
+ * turn's thinking state. So the preserve flags ride onto the wire as plain
+ * booleans next to the { $var } thinking/enable_thinking keys — no onPayload
+ * hook needed (unlike neuralwatt, which drives the openai reasoning_effort path
+ * and must inject via onPayload because the two paths are mutually exclusive).
+ *
+ * Gemma 4 and MiniMax M2.7/M3 expose NO family-wide preserve flag (their HF
+ * templates read only enable_thinking / thinking_mode + reasoning_content), so
+ * no flag is added for them here — asserted as a regression guard.
+ *
+ * Run: node scripts/test-preserved-thinking.ts
+ */
+import fs from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+
+const HERE = path.dirname(new URL(import.meta.url).pathname);
+
+// ─── Faithful replica of index.ts applyPatch / buildModels ────────────────────
+// Mirrors the provider's model pipeline so the test exercises the same objects
+// the runtime registers. (Kept inline so the test has no TS-import dependency
+// on index.ts, which pulls in pi-coding-agent types.)
+
+function applyPatch(model, patch) {
+  const result = { ...model };
+  if (patch.name !== undefined) result.name = patch.name;
+  if (patch.reasoning !== undefined) result.reasoning = patch.reasoning;
+  if (patch.input !== undefined) result.input = patch.input;
+  if (patch.contextWindow !== undefined) result.contextWindow = patch.contextWindow;
+  if (patch.maxTokens !== undefined) result.maxTokens = patch.maxTokens;
+  if (patch.cost) {
+    result.cost = {
+      input: patch.cost.input ?? result.cost.input,
+      output: patch.cost.output ?? result.cost.output,
+      cacheRead: patch.cost.cacheRead ?? result.cost.cacheRead,
+      cacheWrite: patch.cost.cacheWrite ?? result.cost.cacheWrite,
+    };
+  }
+  if (patch.compat) result.compat = { ...(result.compat || {}), ...patch.compat };
+  if (patch.thinkingLevelMap !== undefined) result.thinkingLevelMap = patch.thinkingLevelMap;
+  if (!result.reasoning && result.compat?.thinkingFormat) delete result.compat.thinkingFormat;
+  if (!result.reasoning && result.thinkingLevelMap) delete result.thinkingLevelMap;
+  if (result.compat && Object.keys(result.compat).length === 0) delete result.compat;
+  return result;
+}
+
+function buildModels(base, custom, patch) {
+  const map = new Map();
+  for (const m of base) map.set(m.id, m);
+  for (const [id, p] of Object.entries(patch)) {
+    const ex = map.get(id);
+    if (ex) map.set(id, applyPatch(ex, p));
+  }
+  for (const m of custom) {
+    const ex = map.get(m.id);
+    const p = patch[m.id];
+    if (ex && p) map.set(m.id, applyPatch(m, p));
+    else if (ex) map.set(m.id, m);
+    else if (p) map.set(m.id, applyPatch(m, p));
+    else map.set(m.id, m);
+  }
+  return Array.from(map.values());
+}
+
+// ─── Load REAL pi-ai streamSimple from the global pi install ──────────────────
+// Imported by absolute path so its relative deps (openai, ../models.js, ...) and
+// the `openai` SDK resolve from the global pi node_modules tree.
+const PI_AI_API = path.join(
+  os_home_pi_ai(),
+  "dist/api/openai-completions.js",
+);
+function os_home_pi_ai() {
+  // Resolve the pi-ai package shipped inside the globally-installed pi agent.
+  const candidates = [
+    "/Users/monotykamary/.npm-global/lib/node_modules/@earendil-works/pi-coding-agent/node_modules/@earendil-works/pi-ai",
+  ];
+  for (const c of candidates) if (fs.existsSync(c)) return c;
+  throw new Error("Could not locate pi-ai package in the global pi install.");
+}
+
+const { streamSimple } = await import(pathToFileURL(PI_AI_API).href);
+
+// ─── Build the exact model objects the provider registers ────────────────────
+const embedded = JSON.parse(fs.readFileSync(path.join(HERE, "..", "models.json"), "utf8"));
+const custom = JSON.parse(fs.readFileSync(path.join(HERE, "..", "custom-models.json"), "utf8"));
+const patch = JSON.parse(fs.readFileSync(path.join(HERE, "..", "patch.json"), "utf8"));
+const models = new Map(buildModels(embedded, custom, patch).map((m) => [m.id, m]));
+
+// ─── Stub fetch to capture the request body (fires before response parsing) ──
+const captured = [];
+const originalFetch = globalThis.fetch;
+globalThis.fetch = async (url, init) => {
+  captured.push({ url: String(url), body: init?.body ?? null });
+  // Minimal SSE response that ends immediately — enough for the OpenAI SDK to
+  // construct the stream; we only need the request body, captured above.
+  return new Response(new ReadableStream({ start(c) { c.close(); } }), {
+    headers: { "content-type": "text/event-stream" },
+  });
+};
+
+async function wire(modelId, reasoning) {
+  const model = models.get(modelId);
+  if (!model) throw new Error(`unknown model: ${modelId}`);
+  captured.length = 0;
+  const ctx = { messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }] };
+  const s = streamSimple(
+    { ...model, provider: "lilac", api: "openai-completions", baseUrl: "https://api.getlilac.com/v1" },
+    ctx,
+    { apiKey: "sk-test", reasoning },
+  );
+  // The fetch fires inside stream()'s async IIFE; poll for it.
+  const deadline = Date.now() + 2000;
+  while (captured.length === 0 && Date.now() < deadline) await new Promise((r) => setTimeout(r, 20));
+  try { s.end?.(); } catch {}
+  const hit = captured.find((c) => c.url.includes("/chat/completions"));
+  if (!hit) throw new Error(`no /chat/completions request captured for ${modelId} (${reasoning})`);
+  return JSON.parse(hit.body);
+}
+
+// ─── Assertions ───────────────────────────────────────────────────────────────
+let failures = 0;
+function eq(actual, expected, msg) {
+  const a = JSON.stringify(actual);
+  const e = JSON.stringify(expected);
+  const ok = a === e;
+  console.log(`${ok ? "✓" : "✗"} ${msg}`);
+  if (!ok) {
+    failures++;
+    console.log(`    expected ${e}`);
+    console.log(`    actual   ${a}`);
+  }
+}
+function truthy(actual, msg) {
+  const ok = !!actual;
+  console.log(`${ok ? "✓" : "✗"} ${msg}`);
+  if (!ok) {
+    failures++;
+    console.log(`    expected truthy, got ${JSON.stringify(actual)}`);
+  }
+}
+function falsy(actual, msg) {
+  const ok = !actual;
+  console.log(`${ok ? "✓" : "✗"} ${msg}`);
+  if (!ok) {
+    failures++;
+    console.log(`    expected falsy/undefined, got ${JSON.stringify(actual)}`);
+  }
+}
+
+console.log("\n=== patch.json data ===");
+const kimiPatch = patch["moonshotai/kimi-k2.6"]?.compat?.chatTemplateKwargs;
+eq(kimiPatch?.preserve_thinking, true, "kimi-k2.6 patch sets preserve_thinking: true");
+const glm51Patch = patch["zai-org/glm-5.1"]?.compat?.chatTemplateKwargs;
+eq(glm51Patch?.clear_thinking, false, "glm-5.1 patch sets clear_thinking: false");
+const glm52Patch = patch["zai-org/glm-5.2"]?.compat?.chatTemplateKwargs;
+eq(glm52Patch?.clear_thinking, false, "glm-5.2 patch sets clear_thinking: false");
+
+console.log("\n=== Kimi K2.6 on the wire (real pi-ai) ===");
+{
+  const high = await wire("moonshotai/kimi-k2.6", "high");
+  eq(high.chat_template_kwargs, { thinking: true, enable_thinking: true, preserve_thinking: true },
+    "kimi @ high → thinking+enable_thinking true AND preserve_thinking true");
+  const off = await wire("moonshotai/kimi-k2.6", "off");
+  eq(off.chat_template_kwargs, { thinking: false, enable_thinking: false, preserve_thinking: true },
+    "kimi @ off → thinking false but preserve_thinking still true (level-independent)");
+  const minimal = await wire("moonshotai/kimi-k2.6", "minimal");
+  eq(minimal.chat_template_kwargs, { thinking: true, enable_thinking: true, preserve_thinking: true },
+    "kimi @ minimal → preserve_thinking present at every level");
+}
+
+console.log("\n=== GLM 5.2 on the wire (real pi-ai) ===");
+{
+  const high = await wire("zai-org/glm-5.2", "high");
+  eq(high.chat_template_kwargs, { enable_thinking: true, reasoning_effort: "high", clear_thinking: false },
+    "glm-5.2 @ high → enable_thinking+reasoning_effort AND clear_thinking false");
+  const xhigh = await wire("zai-org/glm-5.2", "xhigh");
+  eq(xhigh.chat_template_kwargs, { enable_thinking: true, reasoning_effort: "max", clear_thinking: false },
+    "glm-5.2 @ xhigh → reasoning_effort max, clear_thinking false");
+  const off = await wire("zai-org/glm-5.2", "off");
+  eq(off.chat_template_kwargs, { enable_thinking: false, clear_thinking: false },
+    "glm-5.2 @ off → reasoning_effort omitted (omitWhenOff), clear_thinking false persists");
+}
+
+console.log("\n=== GLM 5.1 on the wire (real pi-ai) ===");
+{
+  const high = await wire("zai-org/glm-5.1", "high");
+  eq(high.chat_template_kwargs, { thinking: true, enable_thinking: true, clear_thinking: false },
+    "glm-5.1 @ high → thinking+enable_thinking true AND clear_thinking false");
+  const off = await wire("zai-org/glm-5.1", "off");
+  eq(off.chat_template_kwargs, { thinking: false, enable_thinking: false, clear_thinking: false },
+    "glm-5.1 @ off → thinking false but clear_thinking false persists");
+}
+
+console.log("\n=== Gemma 4 / MiniMax (no family-wide preserve flag — regression guard) ===");
+{
+  const gemma = await wire("google/gemma-4-31b-it", "high");
+  eq(gemma.chat_template_kwargs, { thinking: true, enable_thinking: true },
+    "gemma-4 @ high → only thinking/enable_thinking (no preserve/clear flag)");
+  falsy(gemma.chat_template_kwargs?.preserve_thinking, "gemma-4 has no preserve_thinking");
+  falsy(gemma.chat_template_kwargs?.clear_thinking, "gemma-4 has no clear_thinking");
+
+  const m3 = await wire("minimaxai/minimax-m3", "high");
+  eq(m3.chat_template_kwargs, { thinking_mode: "enabled" },
+    "minimax-m3 @ high → only thinking_mode (no preserve/clear flag)");
+  falsy(m3.chat_template_kwargs?.preserve_thinking, "minimax-m3 has no preserve_thinking");
+
+  const m27 = await wire("minimaxai/minimax-m2.7", "high");
+  eq(m27.chat_template_kwargs, { thinking: true, enable_thinking: true },
+    "minimax-m2.7 @ high → only thinking/enable_thinking (no preserve/clear flag)");
+  falsy(m27.chat_template_kwargs?.clear_thinking, "minimax-m2.7 has no clear_thinking");
+}
+
+globalThis.fetch = originalFetch;
+
+console.log(`\n${failures === 0 ? "ALL PASS" : `${failures} FAILURE(S)`}`);
+if (failures > 0) process.exit(1);