@aliou/pi-neuralwatt 0.8.0 → 0.9.0

package/README.md

@@ -77,14 +77,22 @@ Configure features with `/neuralwatt:settings`:
 - **Quota command** — Show/hide `/neuralwatt:quota`
 - **Quota warnings** — Enable/disable low quota notifications
 - **Sub-bar integration** — Show/hide usage in status bar
+- **Legacy model IDs** — Include deprecated model aliases
+- **Hidden models** — Include models available only to the configured API key
 
 The provider itself cannot be disabled — it is always loaded.
 
 Configuration uses nested per-feature sections. Existing flat config files are migrated automatically, with a backup written next to the migrated config.
 
+### Model Refresh
+
+Neuralwatt registers its public models without network access. When hidden models are enabled, opening `/model` refreshes the authenticated catalog in the background. `pi update --models` forces an immediate refresh.
+
+Pi stores the complete effective Neuralwatt catalog in `~/.pi/agent/models-store.json` for offline startup. Current hardcoded public and legacy definitions remain authoritative when cached models are restored.
+
 ## Adding or Updating Models
 
-Models are hardcoded in `extensions/provider/models/public-models.ts` and validated against the live API. To update:
+Public models are hardcoded in `extensions/provider/models/public-models.ts` and validated against the live API. To update:
 
 1. Run `pnpm test` — it fetches `/v1/models` and compares against hardcoded definitions
 2. Fix any discrepancies (missing models, changed context windows)
@@ -129,7 +137,7 @@ This repository uses [Changesets](https://github.com/changesets/changesets) for
 
 ## Requirements
 
-- Pi coding agent v0.67.68+
+- Pi coding agent v0.80.8+
 - Neuralwatt API key (configured in `~/.pi/agent/auth.json` or via `NEURALWATT_API_KEY`)
 
 ## Links

package/extensions/_shared/auth.ts

@@ -1,4 +1,4 @@
-import type { AuthStorage } from "@earendil-works/pi-coding-agent";
+import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
 
 const PROVIDER_ID = "neuralwatt";
 
@@ -11,8 +11,7 @@ const PROVIDER_ID = "neuralwatt";
  * 3. Environment variable NEURALWATT_API_KEY
  */
 export async function getNeuralwattApiKey(
-  authStorage: AuthStorage,
+  modelRegistry: ModelRegistry,
 ): Promise<string | undefined> {
-  const key = await authStorage.getApiKey(PROVIDER_ID);
-  return key ?? process.env.NEURALWATT_API_KEY;
+  return modelRegistry.getApiKeyForProvider(PROVIDER_ID);
 }

package/extensions/command-quotas/command.ts

@@ -16,7 +16,7 @@ export function registerQuotasCommand(pi: ExtensionAPI): void {
   pi.registerCommand("neuralwatt:quota", {
     description: "Display Neuralwatt API usage and quota",
     handler: async (_args, ctx) => {
-      const apiKey = await getNeuralwattApiKey(ctx.modelRegistry.authStorage);
+      const apiKey = await getNeuralwattApiKey(ctx.modelRegistry);
       if (!apiKey) {
         ctx.ui.notify(missingAuthMessage(), "warning");
         return;

package/extensions/provider/index.ts

@@ -1,7 +1,7 @@
 import { getApiProvider } from "@earendil-works/pi-ai/compat";
 import type {
   ExtensionAPI,
-  ProviderModelConfig,
+  ModelRegistry,
 } from "@earendil-works/pi-coding-agent";
 import { configLoader } from "../../src/config";
 import {
@@ -18,12 +18,7 @@ import type { NeuralwattQuotas } from "../../src/types/quota-api";
 import { getNeuralwattApiKey } from "../_shared/auth";
 import { registerNeuralwattSettings } from "./commands/settings";
 import { normalizeNeuralwattContextOverflowError } from "./context-overflow";
-import {
-  getNeuralwattModels,
-  loadCachedHiddenModels,
-  loadHiddenModels,
-  writeHiddenModelsCache,
-} from "./models";
+import { getNeuralwattModels, refreshNeuralwattModels } from "./models";
 import { buildQuotasFromHeaders, fetchRequestedQuotas } from "./quota-store";
 import {
   type NeuralwattRateLimitInfo,
@@ -44,18 +39,15 @@ function emitConfigUpdated(pi: ExtensionAPI): void {
 function registerNeuralwattProvider(
   pi: ExtensionAPI,
   onSseQuota: (line: string) => void,
-  hiddenModels: ProviderModelConfig[] = [],
 ): void {
   const { provider: providerConfig } = configLoader.getConfig();
 
-  const publicModels = getNeuralwattModels({
+  const models = getNeuralwattModels({
     includeLegacyModelIds: providerConfig.includeLegacyModelIds,
   });
-  const resolvedHiddenModels = providerConfig.includeHiddenModels
-    ? dedupeHiddenModels(hiddenModels, publicModels)
-    : [];
 
   const config: Parameters<ExtensionAPI["registerProvider"]>[1] = {
+    name: "Neuralwatt",
     baseUrl: "https://api.neuralwatt.com/v1",
     apiKey: "$NEURALWATT_API_KEY",
     api: "openai-completions",
@@ -64,7 +56,14 @@ function registerNeuralwattProvider(
       Referer: "https://pi.dev",
       "X-Title": "npm:@aliou/pi-neuralwatt",
     },
-    models: [...publicModels, ...resolvedHiddenModels],
+    models,
+    refreshModels: (context) =>
+      refreshNeuralwattModels(context, {
+        includeLegacyModelIds:
+          configLoader.getConfig().provider.includeLegacyModelIds,
+        includeHiddenModels:
+          configLoader.getConfig().provider.includeHiddenModels,
+      }),
   };
 
   const provider = getApiProvider("openai-completions");
@@ -79,57 +78,28 @@ function registerNeuralwattProvider(
   pi.registerProvider("neuralwatt", config);
 }
 
-/**
- * Drop any hidden model whose ID collides with a public or legacy model.
- *
- * Models can graduate from hidden (authenticated /v1/models only) to public
- * (unauthenticated list). When that happens, a stale on-disk cache may still
- * list the now-public ID, which would register it twice and make Pi treat the
- * scoped model as ambiguous ("No models match pattern"). Dedupe against the
- * public list so a stale cache can never shadow a public model.
- */
-function dedupeHiddenModels(
-  hiddenModels: ProviderModelConfig[],
-  publicModels: ProviderModelConfig[],
-): ProviderModelConfig[] {
-  const publicIds = new Set(publicModels.map((m) => m.id));
-  return hiddenModels.filter((m) => !publicIds.has(m.id));
-}
-
 export default async function (pi: ExtensionAPI) {
   await configLoader.load();
 
   let latestQuotas: NeuralwattQuotas | undefined;
 
-  // Stale-while-revalidate seed for hidden models.
-  //
-  // Hidden models are only discoverable by hitting the authenticated
-  // `/v1/models` endpoint, which we can do inside `session_start` (Pi does not
-  // expose `authStorage` to extension factories). However, Pi validates scoped
-  // models (e.g. `neuralwatt/glm-5.2-short`) during startup, *before*
-  // `session_start` fires. To avoid "No models match pattern" warnings on saved
-  // scoped models, we synchronously restore the previous session's fetch from
-  // the on-disk cache so the provider is registered with hidden models at
-  // load time. `session_start` then revalidates from the live API and writes
-  // the cache back. First run with no cache still warns once.
-  let hiddenModels: ProviderModelConfig[] = [];
-  if (configLoader.getConfig().provider.includeHiddenModels) {
-    hiddenModels = loadCachedHiddenModels();
-  }
-  let hiddenModelsLoaded = false;
-  let hiddenModelsAbort: AbortController | undefined;
+  let lastSseEmitAt = 0;
 
   const handleSseQuota = (line: string) => {
+    const now = Date.now();
+    if (now - lastSseEmitAt < HEADER_EMIT_THROTTLE_MS) return;
+
     const quotas = updateQuotasFromSseComment(latestQuotas, line);
     if (!quotas || quotas === latestQuotas) return;
-    latestQuotas = quotas;
-    pi.events.emit(NEURALWATT_QUOTAS_UPDATED_EVENT, {
-      quotas,
-      source: "sse",
-    });
+
+    lastSseEmitAt = now;
+    emitQuotas(quotas, "sse");
   };
 
-  registerNeuralwattProvider(pi, handleSseQuota, hiddenModels);
+  registerNeuralwattProvider(pi, handleSseQuota);
+  let registeredProviderSettings = {
+    ...configLoader.getConfig().provider,
+  };
 
   const loadedFeatures = new Set<NeuralwattFeatureId>();
 
@@ -139,22 +109,17 @@ export default async function (pi: ExtensionAPI) {
   });
 
   pi.events.on(NEURALWATT_CONFIG_UPDATED_EVENT, () => {
-    // Toggle may have enabled hidden models since startup. Seed from the disk
-    // cache so previously discovered models are available immediately without
-    // waiting for the next session_start revalidation.
+    const next = configLoader.getConfig().provider;
     if (
-      configLoader.getConfig().provider.includeHiddenModels &&
-      !hiddenModelsLoaded &&
-      hiddenModels.length === 0
+      next.includeLegacyModelIds ===
+        registeredProviderSettings.includeLegacyModelIds &&
+      next.includeHiddenModels ===
+        registeredProviderSettings.includeHiddenModels
     ) {
-      hiddenModels = loadCachedHiddenModels();
+      return;
     }
-    registerNeuralwattProvider(pi, handleSseQuota, hiddenModels);
-  });
-
-  pi.on("session_shutdown", () => {
-    hiddenModelsAbort?.abort();
-    hiddenModelsAbort = undefined;
+    registeredProviderSettings = { ...next };
+    registerNeuralwattProvider(pi, handleSseQuota);
   });
 
   let lastHeaderEmitAt = 0;
@@ -176,6 +141,7 @@ export default async function (pi: ExtensionAPI) {
   // Used in message_end to rewrite the generic error text with
   // actionable details from Neuralwatt's response headers.
   let pendingRateLimitInfo: NeuralwattRateLimitInfo | undefined;
+  let currentModelRegistry: ModelRegistry | undefined;
 
   pi.on("message_end", (event, ctx) => {
     // Rewrite rate-limit errors with layer-specific details
@@ -243,11 +209,14 @@ export default async function (pi: ExtensionAPI) {
     emitQuotas(quotas, "header");
   });
 
-  pi.events.on(NEURALWATT_QUOTAS_REQUEST_EVENT, async (data: unknown) => {
+  pi.events.on(NEURALWATT_QUOTAS_REQUEST_EVENT, async () => {
     if (quotaRequestInFlight) return;
     quotaRequestInFlight = true;
     try {
-      const quotas = await fetchRequestedQuotas(data);
+      const apiKey = currentModelRegistry
+        ? await getNeuralwattApiKey(currentModelRegistry)
+        : undefined;
+      const quotas = await fetchRequestedQuotas(apiKey);
       if (quotas) emitQuotas(quotas, "api");
     } finally {
       quotaRequestInFlight = false;
@@ -260,6 +229,7 @@ export default async function (pi: ExtensionAPI) {
   });
 
   pi.on("session_start", async (_event, ctx) => {
+    currentModelRegistry = ctx.modelRegistry;
     pendingRateLimitInfo = undefined;
     const messages = [...new Set(configLoader.drainMessages())];
     if (messages.length > 0) {
@@ -270,32 +240,14 @@ export default async function (pi: ExtensionAPI) {
     pi.events.emit(NEURALWATT_EXTENSIONS_REQUEST_EVENT, undefined);
     emitConfigUpdated(pi);
 
-    if (
-      !hiddenModelsLoaded &&
-      configLoader.getConfig().provider.includeHiddenModels
-    ) {
-      hiddenModelsLoaded = true;
-      hiddenModelsAbort?.abort();
-      hiddenModelsAbort = new AbortController();
-      const fetched = await loadHiddenModels(
-        ctx.modelRegistry.authStorage,
-        hiddenModelsAbort.signal,
-      );
-      // Persist for the next startup so scoped models resolve without
-      // warnings on Pi's subsequent launches. Always write the cache (even
-      // when empty) and re-register, so graduated or removed hidden models
-      // are purged from both the cache and the provider's model list.
-      hiddenModels = fetched;
-      await writeHiddenModelsCache(hiddenModels);
-      if (!hiddenModelsAbort.signal.aborted) {
-        registerNeuralwattProvider(pi, handleSseQuota, hiddenModels);
-      }
-    }
-
     if (ctx.model?.provider !== "neuralwatt") return;
-    const apiKey = await getNeuralwattApiKey(ctx.modelRegistry.authStorage);
+    const apiKey = await getNeuralwattApiKey(ctx.modelRegistry);
     if (!apiKey) return;
     const quotaResult = await fetchQuotas(apiKey);
     if (quotaResult.success) emitQuotas(quotaResult.data.quotas, "api");
   });
+
+  pi.on("session_shutdown", () => {
+    currentModelRegistry = undefined;
+  });
 }

package/extensions/provider/models/hidden.ts

@@ -1,10 +1,6 @@
-import type {
-  AuthStorage,
-  ProviderModelConfig,
-} from "@earendil-works/pi-coding-agent";
+import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
 import { fetchNeuralwattModels } from "../../../src/lib/neuralwatt-api";
 import type { NeuralwattApiModel } from "../../../src/types/models-api";
-import { getNeuralwattApiKey } from "../../_shared/auth";
 import { NEURALWATT_MODELS } from "./public-models";
 
 // Per-ID overrides for known hidden models. The authenticated /v1/models endpoint
@@ -95,17 +91,17 @@ function applyHiddenOverride(
  *
  * Hidden models are any models returned by the API that are not already part of
  * the public hardcoded list. If the API key is missing or the request fails, an
- * empty array is returned silently.
+ * `undefined` distinguishes an unavailable/failed request from a successful
+ * empty hidden-model list, allowing refresh callers to preserve stale cache.
  */
 export async function loadHiddenModels(
-  authStorage: AuthStorage,
+  apiKey: string,
   signal?: AbortSignal,
-): Promise<ProviderModelConfig[]> {
-  const apiKey = await getNeuralwattApiKey(authStorage);
-  if (!apiKey) return [];
+): Promise<ProviderModelConfig[] | undefined> {
+  if (!apiKey) return undefined;
 
   const result = await fetchNeuralwattModels(apiKey, signal);
-  if (!result.success) return [];
+  if (!result.success) return undefined;
 
   const publicIds = new Set(NEURALWATT_MODELS.map((model) => model.id));
 

package/extensions/provider/models/index.ts

@@ -2,7 +2,6 @@ import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
 import { buildLegacyNeuralwattModels } from "./legacy";
 import { NEURALWATT_MODELS } from "./public-models";
 
-export { loadCachedHiddenModels, writeHiddenModelsCache } from "./cache";
 export { loadHiddenModels } from "./hidden";
 export {
   buildLegacyNeuralwattModels,
@@ -10,6 +9,7 @@ export {
   LEGACY_NEURALWATT_MODEL_IDS,
 } from "./legacy";
 export { NEURALWATT_MODELS } from "./public-models";
+export { refreshNeuralwattModels } from "./refresh";
 
 export function getNeuralwattModels(options?: {
   includeLegacyModelIds?: boolean;

package/extensions/provider/models/refresh.ts

@@ -0,0 +1,130 @@
+import type {
+  Api,
+  Model,
+  ModelsStoreEntry,
+  RefreshModelsContext,
+} from "@earendil-works/pi-ai";
+import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
+import { loadHiddenModels } from "./hidden";
+import { buildLegacyNeuralwattModels } from "./legacy";
+import { NEURALWATT_MODELS } from "./public-models";
+
+const PROVIDER_ID = "neuralwatt";
+const BASE_URL = "https://api.neuralwatt.com/v1";
+const API = "openai-completions" as const;
+
+export interface RefreshNeuralwattModelsOptions {
+  includeLegacyModelIds: boolean;
+  includeHiddenModels: boolean;
+  loadHidden?: typeof loadHiddenModels;
+}
+
+function configuredModels(
+  includeLegacyModelIds: boolean,
+): ProviderModelConfig[] {
+  return includeLegacyModelIds
+    ? [...NEURALWATT_MODELS, ...buildLegacyNeuralwattModels()]
+    : [...NEURALWATT_MODELS];
+}
+
+function toStoredModel(model: ProviderModelConfig): Model<Api> {
+  return {
+    ...model,
+    provider: PROVIDER_ID,
+    api: model.api ?? API,
+    baseUrl: model.baseUrl ?? BASE_URL,
+  };
+}
+
+function toProviderModel(model: Model<Api>): ProviderModelConfig {
+  return {
+    id: model.id,
+    name: model.name,
+    api: model.api,
+    baseUrl: model.baseUrl,
+    reasoning: model.reasoning,
+    thinkingLevelMap: model.thinkingLevelMap,
+    input: [...model.input],
+    cost: structuredClone(model.cost),
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens,
+    headers: model.headers
+      ? Object.fromEntries(
+          Object.entries(model.headers).filter(
+            (entry): entry is [string, string] => entry[1] !== null,
+          ),
+        )
+      : undefined,
+    compat: model.compat ? structuredClone(model.compat) : undefined,
+  };
+}
+
+function dedupeHiddenModels(
+  hiddenModels: ProviderModelConfig[],
+  baselineModels: ProviderModelConfig[],
+): ProviderModelConfig[] {
+  const baselineIds = new Set(baselineModels.map((model) => model.id));
+  return hiddenModels.filter((model) => !baselineIds.has(model.id));
+}
+
+function cachedHiddenModels(
+  stored: ModelsStoreEntry | undefined,
+): ProviderModelConfig[] {
+  if (!stored) return [];
+
+  const allStaticIds = new Set(configuredModels(true).map((model) => model.id));
+
+  return stored.models
+    .filter(
+      (model) => model.provider === PROVIDER_ID && !allStaticIds.has(model.id),
+    )
+    .map(toProviderModel);
+}
+
+async function persistModels(
+  context: RefreshModelsContext,
+  models: ProviderModelConfig[],
+): Promise<void> {
+  await context.store.write({
+    models: models.map(toStoredModel),
+    checkedAt: Date.now(),
+  });
+}
+
+/** Refresh the complete Neuralwatt catalog with Pi-managed persistence. */
+export async function refreshNeuralwattModels(
+  context: RefreshModelsContext,
+  options: RefreshNeuralwattModelsOptions,
+): Promise<ProviderModelConfig[]> {
+  const baseline = configuredModels(options.includeLegacyModelIds);
+  const stored = await context.store.read();
+
+  if (!options.includeHiddenModels) {
+    await persistModels(context, baseline);
+    return baseline;
+  }
+
+  const cachedHidden = dedupeHiddenModels(cachedHiddenModels(stored), baseline);
+  const cachedCatalog = [...baseline, ...cachedHidden];
+
+  if (!context.allowNetwork || context.signal?.aborted) {
+    return cachedCatalog;
+  }
+
+  const apiKey =
+    context.credential?.type === "api_key" ? context.credential.key : undefined;
+  if (!apiKey) return cachedCatalog;
+
+  const hidden = await (options.loadHidden ?? loadHiddenModels)(
+    apiKey,
+    context.signal,
+  );
+  if (context.signal?.aborted) return cachedCatalog;
+  if (!hidden) {
+    throw new Error("Neuralwatt model catalog refresh failed");
+  }
+
+  const catalog = [...baseline, ...dedupeHiddenModels(hidden, baseline)];
+  await persistModels(context, catalog);
+  return catalog;
+}

package/extensions/provider/quota-store.ts

@@ -1,8 +1,6 @@
-import type { AuthStorage } from "@earendil-works/pi-coding-agent";
 import { parseQuotaHeaders } from "../../src/events";
 import { fetchQuotas } from "../../src/lib/neuralwatt-api";
 import type { NeuralwattQuotas } from "../../src/types/quota-api";
-import { getNeuralwattApiKey } from "../_shared/auth";
 
 export function buildQuotasFromHeaders(
   headers: Record<string, string>,
@@ -44,12 +42,8 @@ export function buildQuotasFromHeaders(
 }
 
 export async function fetchRequestedQuotas(
-  data: unknown,
+  apiKey: string | undefined,
 ): Promise<NeuralwattQuotas | undefined> {
-  if (!data || typeof data !== "object") return;
-  const { authStorage } = data as { authStorage?: AuthStorage };
-  if (!authStorage) return;
-  const apiKey = await getNeuralwattApiKey(authStorage);
   if (!apiKey) return;
   const result = await fetchQuotas(apiKey);
   if (!result.success) return;

package/extensions/quota-warnings/index.ts

@@ -17,7 +17,6 @@ export default async function (pi: ExtensionAPI) {
   await configLoader.load();
 
   let enabled = configLoader.getConfig().quotaWarnings.enabled;
-  let currentProvider: string | undefined;
   let currentContext: ExtensionContext | undefined;
 
   // Listen for config changes at runtime
@@ -33,36 +32,29 @@ export default async function (pi: ExtensionAPI) {
   pi.events.on(NEURALWATT_QUOTAS_UPDATED_EVENT, (data: unknown) => {
     if (!enabled) return;
     if (!data || typeof data !== "object") return;
-    if (currentProvider !== "neuralwatt" || !currentContext) return;
-    const { quotas, source } = data as NeuralwattQuotasUpdatedPayload;
-    checkQuotas(currentContext, quotas, source === "header");
+    if (!currentContext) return;
+    if (currentContext.model?.provider !== "neuralwatt") return;
+
+    const { quotas } = data as NeuralwattQuotasUpdatedPayload;
+    checkQuotas(currentContext, quotas);
   });
 
   pi.on("session_start", async (_event, ctx) => {
     currentContext = ctx;
-    currentProvider = ctx.model?.provider;
     if (ctx.model?.provider !== "neuralwatt") return;
     clearAlertState();
   });
 
   pi.on("model_select", (_event, ctx) => {
     currentContext = ctx;
-    currentProvider = ctx.model?.provider;
-    if (ctx.model?.provider !== "neuralwatt") {
-      clearAlertState();
-      return;
-    }
-    clearAlertState();
   });
 
   pi.on("session_before_switch", (_event, ctx) => {
     currentContext = ctx;
-    currentProvider = ctx.model?.provider;
   });
 
   pi.on("session_shutdown", () => {
     currentContext = undefined;
-    currentProvider = undefined;
     clearAlertState();
   });
 

package/extensions/quota-warnings/notifier.ts

@@ -11,6 +11,8 @@ interface AlertState {
   lastNotifiedAt: number;
 }
 
+// Module-level state so cooldowns survive across invocations of checkQuotas()
+// within the same Pi runtime.
 const alerts = new Map<string, AlertState>();
 
 export function clearAlertState(): void {
@@ -22,9 +24,9 @@ function shouldNotify(key: string, severity: WarningSeverity): boolean {
   if (!state) return true;
 
   const order: WarningSeverity[] = ["warning", "critical"];
-  if (order.indexOf(severity) > order.indexOf(state.lastSeverity)) return true;
-
-  if (severity === "critical") return true;
+  const currentIndex = order.indexOf(severity);
+  const lastIndex = order.indexOf(state.lastSeverity);
+  if (currentIndex > lastIndex) return true;
 
   return Date.now() - state.lastNotifiedAt >= COOLDOWN_MS;
 }
@@ -40,7 +42,6 @@ function markNotified(key: string, severity: WarningSeverity): void {
 export function checkQuotas(
   ctx: ExtensionContext,
   quotas: NeuralwattQuotas,
-  skipAlreadyWarned: boolean,
 ): void {
   if (!ctx.hasUI) return;
 
@@ -55,7 +56,7 @@ export function checkQuotas(
       if (pct <= 25) {
         const severity: WarningSeverity = pct <= 10 ? "critical" : "warning";
         const key = "credits";
-        if (!skipAlreadyWarned || shouldNotify(key, severity)) {
+        if (shouldNotify(key, severity)) {
           markNotified(key, severity);
           warnings.push(
             `Credits: ${pct.toFixed(0)}% remaining (${formatUsd(credits_remaining_usd)} of ${formatUsd(total_credits_usd)})`,
@@ -77,7 +78,7 @@ export function checkQuotas(
             ? "critical"
             : "warning";
         const key = "energy";
-        if (!skipAlreadyWarned || shouldNotify(key, severity)) {
+        if (shouldNotify(key, severity)) {
           markNotified(key, severity);
           const tag = in_overage ? " [OVERAGE]" : "";
           warnings.push(

package/extensions/sub-bar-integration/index.ts

@@ -1,5 +1,4 @@
 import type {
-  AuthStorage,
   ExtensionAPI,
   ExtensionContext,
   Theme,
@@ -58,7 +57,6 @@ export default async function (pi: ExtensionAPI) {
   let enabled = configLoader.getConfig().subBarIntegration.enabled;
   let subCoreReady = false;
   let currentProvider: string | undefined;
-  let currentAuthStorage: AuthStorage | undefined;
   let currentContext: ExtensionContext | undefined;
 
   // Listen for config changes at runtime
@@ -81,10 +79,7 @@ export default async function (pi: ExtensionAPI) {
   }
 
   function requestQuotas(): void {
-    if (!currentAuthStorage) return;
-    pi.events.emit(NEURALWATT_QUOTAS_REQUEST_EVENT, {
-      authStorage: currentAuthStorage,
-    });
+    pi.events.emit(NEURALWATT_QUOTAS_REQUEST_EVENT, undefined);
   }
 
   pi.events.on(NEURALWATT_QUOTAS_UPDATED_EVENT, (data: unknown) => {
@@ -93,7 +88,7 @@ export default async function (pi: ExtensionAPI) {
     const { quotas } = data as NeuralwattQuotasUpdatedPayload;
     emitUsage(quotas);
 
-    if (currentContext?.hasUI) {
+    if (currentContext) {
       currentContext.ui.setStatus(
         "neuralwatt-usage",
         formatStatus(quotas, currentContext.ui.theme),
@@ -107,13 +102,11 @@ export default async function (pi: ExtensionAPI) {
 
   pi.on("session_start", async (_event, ctx) => {
     currentProvider = ctx.model?.provider;
-    currentAuthStorage = ctx.modelRegistry.authStorage;
     currentContext = ctx;
   });
 
   pi.on("model_select", async (_event, ctx) => {
     currentProvider = ctx.model?.provider;
-    currentAuthStorage = ctx.modelRegistry.authStorage;
     currentContext = ctx;
 
     if (subCoreReady && isActive() && enabled) {
@@ -121,15 +114,8 @@ export default async function (pi: ExtensionAPI) {
     }
   });
 
-  pi.on("session_before_switch", (_event, ctx) => {
-    currentProvider = ctx.model?.provider;
-    currentAuthStorage = ctx.modelRegistry.authStorage;
-    currentContext = ctx;
-  });
-
   pi.on("session_shutdown", () => {
     currentProvider = undefined;
-    currentAuthStorage = undefined;
     currentContext = undefined;
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-neuralwatt",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "license": "MIT",
   "type": "module",
   "private": false,
@@ -38,17 +38,17 @@
     "@aliou/pi-utils-ui": "^0.5.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-ai": ">=0.80.8",
+    "@earendil-works/pi-coding-agent": ">=0.80.8",
     "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {
     "@aliou/biome-plugins": "^0.11.0",
     "@biomejs/biome": "^2.4.15",
     "@changesets/cli": "^2.27.11",
-    "@earendil-works/pi-ai": "0.80.3",
-    "@earendil-works/pi-coding-agent": "0.80.3",
-    "@earendil-works/pi-tui": "0.80.3",
+    "@earendil-works/pi-ai": "0.80.8",
+    "@earendil-works/pi-coding-agent": "0.80.8",
+    "@earendil-works/pi-tui": "0.80.8",
     "@types/node": "^25.0.10",
     "husky": "^9.1.7",
     "ts-json-schema-generator": "^2.4.0",

package/extensions/provider/models/cache.ts

@@ -1,77 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
-
-/**
- * Stale-while-revalidate disk cache for hidden Neuralwatt models.
- *
- * Hidden models are discovered by hitting the authenticated `/v1/models`
- * endpoint, which only happens inside `session_start` (Pi does not expose
- * `authStorage` to the extension factory). Because Pi validates scoped models
- * during startup — before `session_start` fires — we persist the last fetch to
- * disk so the provider can be registered with cached models instantly on the
- * next launch. The first run with no cache still warns once; subsequent runs
- * resolve cleanly.
- *
- * File shape: `{ version: 1, models: ProviderModelConfig[] }`.
- */
-
-const CACHE_VERSION = 1;
-const CACHE_FILENAME = "neuralwatt-hidden-models.json";
-
-function cachePath(): string {
-  return join(getAgentDir(), "cache", CACHE_FILENAME);
-}
-
-interface HiddenModelsCacheFile {
-  version?: unknown;
-  models?: unknown;
-}
-
-/**
- * Read cached hidden models synchronously.
- *
- * Designed to be called from the provider extension factory body, where Pi
- * has not entered the event loop yet. Returns an empty array if the cache is
- * missing, unreadable, or malformed.
- */
-export function loadCachedHiddenModels(): ProviderModelConfig[] {
-  try {
-    const path = cachePath();
-    if (!existsSync(path)) return [];
-
-    const parsed: HiddenModelsCacheFile = JSON.parse(
-      readFileSync(path, "utf8"),
-    );
-    if (!Array.isArray(parsed?.models)) return [];
-
-    return parsed.models as ProviderModelConfig[];
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Persist hidden models to disk for the next startup.
- *
- * Called after a successful `/v1/models` fetch in `session_start`. Failures are
- * swallowed since a missing cache only degrades to first-run behavior.
- */
-export async function writeHiddenModelsCache(
-  models: ProviderModelConfig[],
-): Promise<void> {
-  try {
-    const path = cachePath();
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(
-      path,
-      `${JSON.stringify({ version: CACHE_VERSION, models }, null, 2)}\n`,
-      "utf8",
-    );
-  } catch {
-    // Cache writes are best-effort. A missing cache only falls back to the
-    // first-run path (next session revalidates and writes again).
-  }
-}