pi-lilac-provider 1.2.0 → 1.2.1

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,
@@ -572,11 +607,10 @@ export default function (pi: ExtensionAPI) {
     // 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,9 +647,10 @@ 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 */ });
     });
   });
@@ -652,7 +687,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 +705,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 +725,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

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.2.1",
   "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

@@ -286,7 +286,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 +302,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 +359,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 +373,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 +541,162 @@ 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 30s (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.
+const realDateNow = Date.now;
+Date.now = () => realDateNow.call(Date) + 60000;
+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",
+);
+
 // ─── Cleanup ──────────────────────────────────────────────────────────────────
 
 globalThis.fetch = originalFetch;