pi-lilac-provider 1.4.1 → 1.5.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.
 - **`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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-lilac-provider",
-  "version": "1.4.1",
+  "version": "1.5.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",
@@ -35,6 +35,7 @@
     "build": "echo 'nothing to build'",
     "check": "echo 'nothing to check'",
     "test": "node scripts/test-discounts.ts",
+    "test:thinking": "node scripts/test-preserved-thinking.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-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);