pi-lilac-provider 1.2.1 → 1.3.0

package/index.ts

@@ -538,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.
@@ -599,11 +611,49 @@ 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);
 
@@ -653,6 +703,15 @@ export default function (pi: ExtensionAPI) {
         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) => {
@@ -776,6 +835,10 @@ export default function (pi: ExtensionAPI) {
 
   pi.on("session_shutdown", () => {
     revalidateAbort?.abort();
+    if (pollInterval) {
+      clearInterval(pollInterval);
+      pollInterval = null;
+    }
   });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-lilac-provider",
-  "version": "1.2.1",
+  "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";
@@ -596,15 +598,16 @@ assert(
 
 console.log("\n--- Test 15: before_provider_request clears status after switch ---");
 
-// Regression: every 30s (when the discount TTL expires) before_provider_request
+// 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 30s TTL to look expired so the fetch path executes.
+// 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) + 60000;
+Date.now = () => realDateNow.call(Date) + 120000;
 try {
   globalThis.fetch = mockFetch({
     "/status": {
@@ -697,6 +700,86 @@ 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 ─
+
+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;