pi-lilac-provider 1.2.0 → 1.3.0

package/README.md

@@ -77,7 +77,7 @@ pi
 | GLM 5.2 | 524K | ❌ | ✅ | $0.90 | $0.27 | $3.00 |
 | Kimi K2.6 | 262K | ✅ | ✅ | $0.70 | $0.20 | $3.50 |
 | MiniMax M2.7 | 205K | ❌ | ✅ | $0.30 | $0.06 | $1.20 |
-| MiniMax M3 | 1.0M | ❌ | ✅ | $0.28 | $0.05 | $1.10 |
+| MiniMax M3 | 1.0M | ✅ | ✅ | $0.28 | $0.05 | $1.10 |
 
 *Costs are per million tokens. Prices subject to change — check [getlilac.com](https://getlilac.com/) for current pricing.*
 

package/index.ts

@@ -479,6 +479,41 @@ function dimStatus(ctx: any, text: string): string {
   }
 }
 
+/**
+ * Paint the footer status from the LIVE session model — the single source of
+ * truth for the display. ctx.model is a lazy getter (not a snapshot), so this
+ * reflects the currently-selected model even when called from a deferred
+ * post-await callback that captured a different (stale) model at hook start.
+ *
+ * Set for lilac models, cleared for everything else. Every status paint site
+ * calls this, so whichever handler runs last wins — including after a switch
+ * to a non-lilac model, fixing a race where deferred post-await setStatus()
+ * calls re-painted a stale captured lilac model's discount over the clear
+ * that model_select had just issued.
+ *
+ * Only the DISPLAY follows the live model. Cost mutation (applyDiscountInPlace)
+ * and registerProvider() in before_provider_request still target the turn's
+ * captured in-flight model — that's the object pi bound and whose .cost
+ * calculateCost() reads, and it may legitimately differ from the live model
+ * after a mid-turn /model switch.
+ *
+ * Wrapped in try/catch: ctx.model / ctx.ui assert the extension runner is
+ * still active and throw if the session ended mid-fetch, so a late deferred
+ * callback after session_shutdown no-ops instead of throwing.
+ */
+function syncStatus(ctx: any): void {
+  try {
+    const model = ctx.model;
+    if (model?.provider === "lilac") {
+      ctx.ui.setStatus("lilac", dimStatus(ctx, formatDiscountStatus(model.id)));
+    } else {
+      ctx.ui.setStatus("lilac", undefined);
+    }
+  } catch {
+    // Runner stale (session ended mid-fetch) — nothing to paint.
+  }
+}
+
 function discountsChanged(
   a: Map<string, JsonDiscount> | null,
   b: Map<string, JsonDiscount> | null,
@@ -503,7 +538,19 @@ let cachedApiKey: string | undefined;
 let revalidateAbort: AbortController | null = null;
 let latestDiscounts: Map<string, JsonDiscount> | null = null;
 let lastDiscountFetchTime = 0;
-const STATUS_CACHE_TTL_MS = 30000;
+// Turn-initiated /status fetches are throttled to once per TTL window so a burst
+// of messages doesn't hammer the endpoint. Background polling (see
+// STATUS_POLL_INTERVAL_MS) and turn fetches both stamp lastDiscountFetchTime, so
+// they cooperate: a poll that just ran lets the next turn skip its own fetch
+// within the TTL.
+const STATUS_CACHE_TTL_MS = 60000;
+// Lilac refreshes discounts ~every 10 minutes (per their docs: "Discounts refresh
+// approximately every 10 minutes and are locked in when a request starts"). Poll
+// on that cadence during idle so a long-idle session still catches supply/sub
+// changes without waiting for the user to send a message — turn fetches alone
+// only refresh on a user message and are TTL-throttled to 1/min.
+const STATUS_POLL_INTERVAL_MS = 10 * 60 * 1000;
+let pollInterval: ReturnType<typeof setInterval> | null = null;
 // List-price (patch-applied, pre-discount) models, cached until the base set
 // changes. Reset in cacheModels() so the next getListModels() rebuilds from the
 // refreshed disk cache / embedded set.
@@ -564,19 +611,56 @@ export default function (pi: ExtensionAPI) {
     }
   }
 
+  /**
+   * Background /status poll, fired every STATUS_POLL_INTERVAL_MS (10 min) from
+   * session_start to cover idle sessions. Mirrors the discount half of
+   * before_provider_request, but without an in-flight turn model to mutate: it
+   * only refreshes latestDiscounts, re-registers (so the next turn's models carry
+   * the new price), and re-paints the footer from the LIVE model. Passes the
+   * session AbortSignal so the fetch dies on session_shutdown or a subsequent
+   * session_start; bails on a missing API key or an aborted signal.
+   */
+  function pollStatusDiscounts(ctx: any, signal: AbortSignal): void {
+    if (signal.aborted || !cachedApiKey) return;
+    fetchStatusDiscounts(cachedApiKey, signal).then(discounts => {
+      if (signal.aborted || !discounts) return;
+      lastDiscountFetchTime = Date.now();
+      if (!discountsChanged(latestDiscounts, discounts)) {
+        syncStatus(ctx);
+        return;
+      }
+      cacheDiscounts(discounts);
+      latestDiscounts = discounts;
+      const freshList = getListModels();
+      pi.registerProvider("lilac", {
+        baseUrl: BASE_URL,
+        apiKey: "$LILAC_API_KEY",
+        api: "openai-completions",
+        models: applyDiscounts(freshList, discounts),
+      });
+      syncStatus(ctx);
+    }).catch(() => { /* network errors are non-fatal */ });
+  }
+
   pi.on("session_start", async (_event, ctx) => {
     revalidateAbort?.abort();
     revalidateAbort = new AbortController();
     const signal = revalidateAbort.signal;
 
+    // Tear down any poll interval left from a prior session before starting a
+    // fresh one (defensive; session_shutdown normally handles this).
+    if (pollInterval) {
+      clearInterval(pollInterval);
+      pollInterval = null;
+    }
+
     // Replay persisted discount state from session JSONL (synchronous, zero-latency)
     replayDiscountEvents(ctx);
 
-    // Show status immediately with replayed/cached data — don't block pi startup
-    const model = ctx.model;
-    if (model?.provider === "lilac") {
-      ctx.ui.setStatus("lilac", dimStatus(ctx, formatDiscountStatus(model.id)));
-    }
+    // Show status immediately with replayed/cached data — don't block pi startup.
+    // syncStatus reads the LIVE ctx.model so a switch away from lilac before the
+    // background fetch resolves never leaves a stale discount painted.
+    syncStatus(ctx);
 
     // Fire-and-forget: resolve API key, then fetch live data in background.
     // Provider and status are hot-swapped when results arrive.
@@ -613,11 +697,21 @@ export default function (pi: ExtensionAPI) {
           });
         }
 
-        if (model?.provider === "lilac") {
-          ctx.ui.setStatus("lilac", dimStatus(ctx, formatDiscountStatus(model.id)));
-        }
+        // Re-paint from the LIVE model: if the user switched to a non-lilac
+        // model (or a different lilac model) during the fetch, this reflects
+        // the new selection instead of re-showing the stale captured model.
+        syncStatus(ctx);
       }).catch(() => { /* network errors are non-fatal */ });
     });
+
+    // Background poll for idle sessions: Lilac refreshes discounts ~every 10
+    // minutes, so poll on that cadence to catch supply/sub changes while the
+    // user is idle (turn fetches only run when a message is sent). The callback
+    // bails on a missing API key or an aborted/shut-down session. Cleared in
+    // session_shutdown and at the top of the next session_start.
+    pollInterval = setInterval(() => pollStatusDiscounts(ctx, signal), STATUS_POLL_INTERVAL_MS);
+    // Don't keep the process alive solely for discount polling.
+    pollInterval.unref?.();
   });
 
   pi.on("turn_end", async (_event, ctx) => {
@@ -652,7 +746,10 @@ export default function (pi: ExtensionAPI) {
     // returned unchanged) and recomputes from list price so it never compounds
     // a previously-applied factor.
     applyDiscountInPlace(inFlightModel, listModels, latestDiscounts);
-    ctx.ui.setStatus("lilac", dimStatus(ctx, formatDiscountStatus(inFlightModel.id)));
+    // Display follows the LIVE model (clears if the user switched away during
+    // this turn); the cost mutation above still targets the captured in-flight
+    // model pi bound for this turn.
+    syncStatus(ctx);
 
     if (!cachedApiKey) return;
 
@@ -667,7 +764,7 @@ export default function (pi: ExtensionAPI) {
     lastDiscountFetchTime = now;
 
     if (!discountsChanged(latestDiscounts, discounts)) {
-      ctx.ui.setStatus("lilac", dimStatus(ctx, formatDiscountStatus(inFlightModel.id)));
+      syncStatus(ctx);
       return;
     }
 
@@ -687,23 +784,22 @@ export default function (pi: ExtensionAPI) {
       api: "openai-completions",
       models: applyDiscounts(freshList, discounts),
     });
-    ctx.ui.setStatus("lilac", dimStatus(ctx, formatDiscountStatus(inFlightModel.id)));
+    // Display reflects the LIVE model: post-await the user may have switched to
+    // a non-lilac model, so syncStatus clears instead of re-painting the stale
+    // captured in-flight lilac model's discount.
+    syncStatus(ctx);
   });
 
-  pi.on("model_select", async (event, ctx) => {
-    if (event.model.provider === "lilac") {
-      ctx.ui.setStatus("lilac", dimStatus(ctx, formatDiscountStatus(event.model.id)));
-    } else {
-      ctx.ui.setStatus("lilac", undefined);
-    }
+  pi.on("model_select", async (_event, ctx) => {
+    // ctx.model is the live session model (pi sets state.model before emitting
+    // this event), so syncStatus paints/clears consistently with every other
+    // handler — one source of truth for the footer.
+    syncStatus(ctx);
   });
 
   pi.on("session_tree", async (_event, ctx) => {
     replayDiscountEvents(ctx);
-    const model = ctx.model;
-    if (model?.provider === "lilac") {
-      ctx.ui.setStatus("lilac", dimStatus(ctx, formatDiscountStatus(model.id)));
-    }
+    syncStatus(ctx);
   });
 
   // vLLM's streaming parser intermittently emits finish_reason: "tool_calls" without
@@ -739,6 +835,10 @@ export default function (pi: ExtensionAPI) {
 
   pi.on("session_shutdown", () => {
     revalidateAbort?.abort();
+    if (pollInterval) {
+      clearInterval(pollInterval);
+      pollInterval = null;
+    }
   });
 }
 

package/models.json

@@ -119,7 +119,8 @@
     "name": "MiniMax M3",
     "reasoning": true,
     "input": [
-      "text"
+      "text",
+      "image"
     ],
     "cost": {
       "input": 0.28,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-lilac-provider",
-  "version": "1.2.0",
+  "version": "1.3.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",

package/scripts/test-discounts.ts

@@ -11,12 +11,14 @@
  * 5. session_start replays persisted discount events and sets footer status.
  * 6. model_select sets/clears footer status for lilac/non-lilac models.
  * 7. turn_end appends discount entry to session JSONL.
- * 8. before_provider_request refreshes discounts with a 30s cache.
+ * 8. before_provider_request refreshes discounts with a 60s cache.
  * 9. formatDiscountStatus returns fallbacks when data is missing.
  * 10. applyDiscountInPlace mutates the in-flight model's cost in place,
  *     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
+ *     sessions; session_shutdown clears it.
  */
 
 import type { ExtensionAPI, ModelRegistry } from "@earendil-works/pi-coding-agent";
@@ -286,7 +288,7 @@ for (const handler of handlers.get("model_select") || []) {
       previousModel: undefined,
       source: "set",
     },
-    { ui: mockUi }
+    { ui: mockUi, model: { id: "moonshotai/kimi-k2.6", provider: "lilac" } }
   );
 }
 assert(statuses.get("lilac") === "supply: healthy · sub-discount: 25%", "model_select keeps status for lilac model");
@@ -302,7 +304,7 @@ for (const handler of handlers.get("model_select") || []) {
       previousModel: undefined,
       source: "set",
     },
-    { ui: mockUi }
+    { ui: mockUi, model: { id: "claude-sonnet-4", provider: "anthropic" } }
   );
 }
 assert(statuses.get("lilac") === undefined, "model_select clears status for non-lilac model");
@@ -359,7 +361,7 @@ for (const handler of handlers.get("model_select") || []) {
       previousModel: undefined,
       source: "set",
     },
-    { ui: mockUi },
+    { ui: mockUi, model: { id: "some/unknown-model", provider: "lilac" } },
   );
 }
 assert(statuses.get("lilac") === "supply: —", "unknown model shows fallback dash");
@@ -373,7 +375,7 @@ for (const handler of handlers.get("model_select") || []) {
       previousModel: undefined,
       source: "set",
     },
-    { ui: mockUi },
+    { ui: mockUi, model: { id: "moonshotai/kimi-k2.6", provider: "lilac" } },
   );
 }
 assert(
@@ -541,6 +543,243 @@ assert(boundModel.cost.input === 0.525, "bound model cost mutated in place to 0.
 assert(boundModel.cost.output === 2.625, "bound model output mutated to 3.50 * 0.75 = 2.625");
 assert(boundModel.cost.cacheRead === 0.15, "bound model cacheRead mutated to 0.20 * 0.75 = 0.15");
 
+// ─── Test 14: session_start clears status after switch during fetch ─────────
+
+console.log("\n--- Test 14: session_start clears status after switch ---");
+
+// Regression: the session_start background fetch resolves up to ~8s after hook
+// start. If the user switches to a non-lilac model during that window, the
+// deferred callback must NOT re-paint the stale captured lilac model's discount
+// over the clear that model_select issued. syncStatus() reads the LIVE ctx.model
+// (a lazy getter in production), so mutating startCtx.model mid-flight mimics
+// the session model changing and the deferred paint clears instead.
+globalThis.fetch = mockFetch({
+  "/models": { body: { data: [] } }, // no live models → liveModels null
+  "/status": {
+    body: {
+      models: [{
+        id: "moonshotai/kimi-k2.6",
+        current_subscription_supply_state: "healthy",
+        current_subscription_discount_percent: 25,
+        current_subscription_credit_multiplier: "0.75",
+      }],
+    },
+  },
+}) as any;
+
+statuses.clear();
+const startCtx: any = {
+  modelRegistry: mockRegistry,
+  ui: mockUi,
+  model: { id: "moonshotai/kimi-k2.6", provider: "lilac" }, // start on lilac
+  sessionManager: { getBranch: () => [] },
+};
+for (const handler of handlers.get("session_start") || []) {
+  await handler({}, startCtx);
+}
+// Immediate paint reflects the lilac model (still selected at hook start).
+assert(
+  statuses.get("lilac") === "supply: healthy · sub-discount: 25%",
+  "immediate session_start paint shows lilac discount",
+);
+
+// While the background fetch is in flight, the user switches to a non-lilac model.
+startCtx.model = { id: "claude-sonnet-4", provider: "anthropic" };
+
+// Flush the deferred .then() chain (resolveApiKey → fetch → syncStatus).
+await new Promise((r) => setTimeout(r, 100));
+
+assert(
+  statuses.get("lilac") === undefined,
+  "deferred session_start clears status after switch to non-lilac (no stale re-paint)",
+);
+
+// ─── Test 15: before_provider_request clears status after switch ─────────────
+
+console.log("\n--- Test 15: before_provider_request clears status after switch ---");
+
+// Regression: every 60s (when the discount TTL expires) before_provider_request
+// awaits a fresh /status fetch. If the user switches to a non-lilac model during
+// that await, the post-await paint must clear (live model) instead of re-painting
+// the stale captured in-flight lilac model. Cost mutation still targets the
+// captured in-flight model (Tests 12-13); only the DISPLAY follows the live model.
+
+// Force the 60s TTL to look expired so the fetch path executes. Offset 120s for
+// a clear 2x margin over the 60s TTL (the original used 60s over a 30s TTL).
+const realDateNow = Date.now;
+Date.now = () => realDateNow.call(Date) + 120000;
+try {
+  globalThis.fetch = mockFetch({
+    "/status": {
+      body: {
+        // CHANGED discount (low/10%) vs the cached healthy/25% → exercises the
+        // registerProvider + syncStatus path, not just the unchanged early-return.
+        models: [{
+          id: "moonshotai/kimi-k2.6",
+          current_subscription_supply_state: "low",
+          current_subscription_discount_percent: 10,
+          current_subscription_credit_multiplier: "0.90",
+        }],
+      },
+    },
+  }) as any;
+
+  statuses.clear();
+  // Live model holder; reassigning .model mid-await mimics ctx.model being a
+  // lazy getter to the session model.
+  const bprCtx: any = {
+    ui: mockUi,
+    model: { id: "moonshotai/kimi-k2.6", provider: "lilac" },
+  };
+
+  // Kick off before_provider_request; it captures inFlightModel=lilac, mutates
+  // cost, paints, then awaits the fetch (TTL expired).
+  const bprPromise = (async () => {
+    for (const handler of handlers.get("before_provider_request") || []) {
+      await handler({ type: "before_provider_request", payload: {} }, bprCtx);
+    }
+  })();
+
+  // Switch to non-lilac while the fetch is in flight (before the await resumes).
+  bprCtx.model = { id: "claude-sonnet-4", provider: "anthropic" };
+
+  await bprPromise;
+
+  assert(
+    statuses.get("lilac") === undefined,
+    "post-await syncStatus clears after switch to non-lilac (no stale re-paint)",
+  );
+} finally {
+  Date.now = realDateNow;
+}
+
+// ─── Test 16: session_start shows new lilac model after switch ───────────────
+
+console.log("\n--- Test 16: session_start shows new lilac model after switch ---");
+
+// Companion to Test 14: switching to a DIFFERENT lilac model during the fetch
+// must paint the NEW model's discount, proving syncStatus reads the live model
+// (not a stale capture that would show the old model's discount).
+globalThis.fetch = mockFetch({
+  "/models": { body: { data: [] } },
+  "/status": {
+    body: {
+      models: [
+        {
+          id: "moonshotai/kimi-k2.6",
+          current_subscription_supply_state: "healthy",
+          current_subscription_discount_percent: 25,
+          current_subscription_credit_multiplier: "0.75",
+        },
+        {
+          id: "zai-org/glm-5.1",
+          current_subscription_supply_state: "high",
+          current_subscription_discount_percent: 50,
+          current_subscription_credit_multiplier: "0.50",
+        },
+      ],
+    },
+  },
+}) as any;
+
+statuses.clear();
+const startCtx2: any = {
+  modelRegistry: mockRegistry,
+  ui: mockUi,
+  model: { id: "moonshotai/kimi-k2.6", provider: "lilac" }, // start on kimi
+  sessionManager: { getBranch: () => [] },
+};
+for (const handler of handlers.get("session_start") || []) {
+  await handler({}, startCtx2);
+}
+// Switch to a different lilac model (glm) during the in-flight fetch.
+startCtx2.model = { id: "zai-org/glm-5.1", provider: "lilac" };
+await new Promise((r) => setTimeout(r, 100));
+assert(
+  statuses.get("lilac") === "supply: high · sub-discount: 50%",
+  "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 ─
+
+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
+// 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.
+
+const realSetInterval = globalThis.setInterval.bind(globalThis);
+const realClearInterval = globalThis.clearInterval.bind(globalThis);
+let scheduledDelay: number | null = null;
+let scheduledHandle: ReturnType<typeof setInterval> | null = null;
+const clearedHandles = new Set<ReturnType<typeof setInterval>>();
+
+globalThis.setInterval = ((fn: (...args: any[]) => void, delay?: number, ...rest: any[]) => {
+  scheduledDelay = delay ?? null;
+  const h = realSetInterval(fn, delay as any, ...rest);
+  scheduledHandle = h;
+  return h;
+}) as any;
+globalThis.clearInterval = ((handle: ReturnType<typeof setInterval>) => {
+  clearedHandles.add(handle);
+  return realClearInterval(handle);
+}) as any;
+
+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
+  // only the startup fetch needs mocking here.)
+  globalThis.fetch = mockFetch({
+    "/models": { body: { data: [] } },
+    "/status": {
+      body: {
+        models: [
+          {
+            id: "moonshotai/kimi-k2.6",
+            current_subscription_supply_state: "healthy",
+            current_subscription_discount_percent: 25,
+            current_subscription_credit_multiplier: "0.75",
+          },
+        ],
+      },
+    },
+  }) as any;
+
+  const pollCtx: any = {
+    modelRegistry: mockRegistry,
+    ui: mockUi,
+    model: { id: "moonshotai/kimi-k2.6", provider: "lilac" },
+    sessionManager: { getBranch: () => [] },
+  };
+
+  for (const handler of handlers.get("session_start") || []) {
+    await handler({}, pollCtx);
+  }
+
+  assert(
+    scheduledDelay === 10 * 60 * 1000,
+    "session_start schedules a 10-minute (600000ms) /status poll for idle sessions",
+  );
+  assert(scheduledHandle !== null, "poll interval handle was captured");
+  const capturedHandle = scheduledHandle;
+
+  for (const handler of handlers.get("session_shutdown") || []) {
+    await handler({}, pollCtx);
+  }
+
+  assert(
+    capturedHandle !== null && clearedHandles.has(capturedHandle),
+    "session_shutdown clears the scheduled poll interval (no leak / process-hang)",
+  );
+} finally {
+  // Restore globals; clear any interval this test scheduled before it can fire.
+  if (scheduledHandle) realClearInterval(scheduledHandle);
+  globalThis.setInterval = realSetInterval as any;
+  globalThis.clearInterval = realClearInterval as any;
+}
+
 // ─── Cleanup ──────────────────────────────────────────────────────────────────
 
 globalThis.fetch = originalFetch;