@aliou/pi-neuralwatt 0.10.2 → 0.10.4

package/extensions/provider/models/hidden.ts

@@ -6,7 +6,40 @@ import { NEURALWATT_MODELS } from "./public-models";
 // Hidden aliases that work for authorized accounts but are omitted from the
 // authenticated /v1/models response. Keep these gated by includeHiddenModels.
 // Move an entry to public-models.ts once Neuralwatt advertises it publicly.
-export const HIDDEN_NEURALWATT_MODELS: ProviderModelConfig[] = [];
+export const HIDDEN_NEURALWATT_MODELS: ProviderModelConfig[] = [
+  // DeepSeek V4 Flash Canary - early-access 284B/13B-active MoE served on B200s.
+  // Neuralwatt omits it from the authenticated catalog. Context and runtime
+  // capabilities were verified directly; pricing follows DeepSeek's upstream
+  // rates until Neuralwatt publishes model metadata.
+  {
+    id: "deepseek-v4-flash",
+    name: "DeepSeek V4 Flash (Canary)",
+    reasoning: true,
+    input: ["text", "image"],
+    cost: {
+      input: 0.14,
+      output: 0.28,
+      cacheRead: 0.0028,
+      cacheWrite: 0,
+    },
+    contextWindow: 1_000_000,
+    maxTokens: 384_000,
+    thinkingLevelMap: {
+      off: "none",
+      minimal: "low",
+      low: "low",
+      medium: "medium",
+      high: "high",
+      xhigh: null,
+      max: "max",
+    },
+    compat: {
+      supportsDeveloperRole: false,
+      maxTokensField: "max_tokens",
+      requiresReasoningContentOnAssistantMessages: true,
+    },
+  },
+];
 
 // Per-ID overrides for known hidden models. The authenticated /v1/models endpoint
 // exposes pricing and capabilities, but some Pi-specific behavior (thinking levels,

package/extensions/provider/models/public-models.ts

@@ -3,6 +3,25 @@ import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
 // Public models returned by https://api.neuralwatt.com/v1/models (unauthenticated view).
 // Pricing, capabilities, and limits are sourced from the API metadata fields.
 export const NEURALWATT_MODELS: ProviderModelConfig[] = [
+  // Gemma 4 31B - NVIDIA NVFP4 checkpoint
+  {
+    id: "nvidia/Gemma-4-31B-IT-NVFP4",
+    name: "Gemma 4 31B (NVFP4)",
+    reasoning: false,
+    input: ["text", "image"],
+    cost: {
+      input: 0.144,
+      output: 0.42,
+      cacheRead: 0.036,
+      cacheWrite: 0,
+    },
+    contextWindow: 262128,
+    maxTokens: 16384,
+    compat: {
+      supportsDeveloperRole: false,
+      maxTokensField: "max_tokens",
+    },
+  },
   // Gemma 4 31B - Google, served from NVIDIA's NVFP4 checkpoint
   {
     id: "gemma-4-31b",
@@ -86,7 +105,7 @@ export const NEURALWATT_MODELS: ProviderModelConfig[] = [
       cacheWrite: 0,
     },
     contextWindow: 199984,
-    maxTokens: 65536,
+    maxTokens: 32000,
     thinkingLevelMap: {
       off: "none",
       minimal: null,
@@ -115,7 +134,7 @@ export const NEURALWATT_MODELS: ProviderModelConfig[] = [
       cacheWrite: 0,
     },
     contextWindow: 199984,
-    maxTokens: 65536,
+    maxTokens: 32000,
     compat: {
       supportsDeveloperRole: false,
       maxTokensField: "max_tokens",

package/extensions/quota-warnings/notifier.ts

@@ -5,6 +5,13 @@ import { formatKwh, formatUsd } from "../../src/utils/quota-format";
 export type WarningSeverity = "warning" | "critical";
 
 const COOLDOWN_MS = 60 * 60 * 1000; // 60 minutes
+const LOW_PCT = 25;
+const CRITICAL_PCT = 10;
+
+/** Per-kWh price once a subscription's included kWh are exhausted. */
+const OVERAGE_RATE_PER_KWH_SUBSCRIBED = 5;
+/** Per-kWh price when there is no active subscription (no included kWh). */
+const OVERAGE_RATE_PER_KWH_UNSUBSCRIBED = 10;
 
 interface AlertState {
   lastSeverity: WarningSeverity;
@@ -19,14 +26,16 @@ export function clearAlertState(): void {
   alerts.clear();
 }
 
+function severityForPct(pct: number): WarningSeverity {
+  return pct <= CRITICAL_PCT ? "critical" : "warning";
+}
+
 function shouldNotify(key: string, severity: WarningSeverity): boolean {
   const state = alerts.get(key);
   if (!state) return true;
 
   const order: WarningSeverity[] = ["warning", "critical"];
-  const currentIndex = order.indexOf(severity);
-  const lastIndex = order.indexOf(state.lastSeverity);
-  if (currentIndex > lastIndex) return true;
+  if (order.indexOf(severity) > order.indexOf(state.lastSeverity)) return true;
 
   return Date.now() - state.lastNotifiedAt >= COOLDOWN_MS;
 }
@@ -35,9 +44,121 @@ function markNotified(key: string, severity: WarningSeverity): void {
   alerts.set(key, { lastSeverity: severity, lastNotifiedAt: Date.now() });
 }
 
+interface PendingWarning {
+  key: string;
+  severity: WarningSeverity;
+  message: string;
+}
+
+/** Subscription energy (kWh) — the primary billing pool while subscribed. */
+function energyWarning(
+  sub: NonNullable<NeuralwattQuotas["subscription"]>,
+): PendingWarning | undefined {
+  if (sub.kwh_included <= 0) return;
+  const pct = (sub.kwh_remaining / sub.kwh_included) * 100;
+  if (pct > LOW_PCT) return;
+  return {
+    key: "energy",
+    severity: severityForPct(pct),
+    message: `Energy: ${pct.toFixed(0)}% remaining (${formatKwh(sub.kwh_remaining)} of ${formatKwh(sub.kwh_included)})`,
+  };
+}
+
+/** Balance credits (USD) — on-demand top-up pool. */
+function creditsWarning(quotas: NeuralwattQuotas): PendingWarning | undefined {
+  const { credits_remaining_usd, total_credits_usd } = quotas.balance;
+  if (total_credits_usd <= 0) return;
+  const pct = (credits_remaining_usd / total_credits_usd) * 100;
+  if (pct > LOW_PCT) return;
+  return {
+    key: "credits",
+    severity: severityForPct(pct),
+    message: `Credits: ${pct.toFixed(0)}% remaining (${formatUsd(credits_remaining_usd)} of ${formatUsd(total_credits_usd)})`,
+  };
+}
+
+/** Overage usage billed against the overage cap, derived from kWh usage. */
+interface OverageProgress {
+  /** kWh billed at the overage rate. */
+  overageKwh: number;
+  /** Per-kWh rate applied (USD). */
+  rate: number;
+  /** Cost of the overage kWh so far (USD). */
+  costUsd: number;
+  /** Configured overage cap (USD), or 0 when none. */
+  capUsd: number;
+  /** Remaining cap headroom (USD), clamped at 0. */
+  remainingUsd: number;
+  /** Remaining cap as a percentage of the cap (0-100). 0 when no cap. */
+  pctRemaining: number;
+  /** Cap exhausted (overage cost has reached or passed the cap). */
+  exhausted: boolean;
+}
+
+export function computeOverageProgress(
+  quotas: NeuralwattQuotas,
+): OverageProgress {
+  const capUsd = quotas.limits.overage_limit_usd ?? 0;
+  const hasSub = quotas.subscription !== null;
+
+  // Subscribed: only kWh beyond the included quota are billed at the overage
+  // rate. Unsubscribed: every kWh is billable — the monthly usage total is the
+  // overage pool (there is no included quota to subtract from).
+  const overageKwh = hasSub
+    ? Math.max(
+        0,
+        (quotas.subscription?.kwh_used ?? 0) -
+          (quotas.subscription?.kwh_included ?? 0),
+      )
+    : quotas.usage.current_month.energy_kwh;
+
+  const rate = hasSub
+    ? OVERAGE_RATE_PER_KWH_SUBSCRIBED
+    : OVERAGE_RATE_PER_KWH_UNSUBSCRIBED;
+  const costUsd = overageKwh * rate;
+  const remainingUsd = Math.max(0, capUsd - costUsd);
+  const pctRemaining = capUsd > 0 ? (remainingUsd / capUsd) * 100 : 0;
+
+  return {
+    overageKwh,
+    rate,
+    costUsd,
+    capUsd,
+    remainingUsd,
+    pctRemaining,
+    exhausted: capUsd > 0 && remainingUsd <= 0,
+  };
+}
+
+function overageWarning(progress: OverageProgress): PendingWarning {
+  const pct = Math.max(0, Math.min(100, progress.pctRemaining));
+  return {
+    key: "overage",
+    // Entering overage is itself worth a critical alert; the % controls the
+    // message, not whether we notify.
+    severity: "critical",
+    message: `Overage cap: ${pct.toFixed(0)}% remaining (${formatUsd(progress.remainingUsd)} of ${formatUsd(progress.capUsd)}, ${formatKwh(progress.overageKwh)} over @ ${formatUsd(progress.rate)}/kWh)`,
+  };
+}
+
 /**
- * When a subscription is active, energy is the primary billing method.
- * Credits are on-demand/top-up only — don't warn for credits when subscribed.
+ * Warning progression mirrors Neuralwatt's billing order. Each stage uses its
+ * own alert key, so once a later stage starts the earlier one stops — the
+ * warning "moves on" instead of re-reporting a depleted pool forever.
+ *
+ *   subscribed, not in overage          → energy (kWh remaining of quota)
+ *   subscribed, in overage, cap set      → overage cap progress (credits unreachable)
+ *   subscribed, in overage, cap exhausted→ balance credits
+ *   subscribed, in overage, no cap      → balance credits (overage draws them down)
+ *   no subscription, cap set            → overage cap progress (all kWh billable)
+ *   no subscription, no cap             → balance credits
+ *
+ * Overage cost is derived from kWh usage: subscribed pays $5/kWh for kWh
+ * beyond the included quota; unsubscribed pays $10/kWh for all usage. There is
+ * no overage-spent counter in the API, so progress is computed.
+ *
+ * Usage totals (monthly/lifetime cost in USD) are deliberately not used as a
+ * threshold basis — they are not directly tied to the subscription's kWh quota.
  */
 export function checkQuotas(
   ctx: ExtensionContext,
@@ -45,55 +166,59 @@ export function checkQuotas(
 ): void {
   if (!ctx.hasUI) return;
 
-  const warnings: string[] = [];
-  const hasSub = quotas.subscription !== null;
+  const pending: PendingWarning[] = [];
+  const sub = quotas.subscription;
 
-  // Credits warning — only when no active subscription
-  if (!hasSub) {
-    const { credits_remaining_usd, total_credits_usd } = quotas.balance;
-    if (total_credits_usd > 0) {
-      const pct = (credits_remaining_usd / total_credits_usd) * 100;
-      if (pct <= 25) {
-        const severity: WarningSeverity = pct <= 10 ? "critical" : "warning";
-        const key = "credits";
-        if (shouldNotify(key, severity)) {
-          markNotified(key, severity);
-          warnings.push(
-            `Credits: ${pct.toFixed(0)}% remaining (${formatUsd(credits_remaining_usd)} of ${formatUsd(total_credits_usd)})`,
-          );
-        }
+  if (sub?.in_overage) {
+    const cap = quotas.limits.overage_limit_usd;
+    if (cap !== null && cap > 0) {
+      const progress = computeOverageProgress(quotas);
+      if (progress.exhausted) {
+        // Cap spent — fall through to the balance credits.
+        const cw = creditsWarning(quotas);
+        if (cw) pending.push(cw);
+      } else {
+        pending.push(overageWarning(progress));
       }
+    } else {
+      // No cap: overage spends down the balance credits directly.
+      const cw = creditsWarning(quotas);
+      if (cw) pending.push(cw);
     }
-  }
-
-  // Subscription energy check
-  if (quotas.subscription) {
-    const { kwh_included, kwh_remaining, in_overage } = quotas.subscription;
-    if (kwh_included > 0) {
-      const pct = (kwh_remaining / kwh_included) * 100;
-      if (in_overage || pct <= 25) {
-        const severity: WarningSeverity = in_overage
-          ? "critical"
-          : pct <= 10
-            ? "critical"
-            : "warning";
-        const key = "energy";
-        if (shouldNotify(key, severity)) {
-          markNotified(key, severity);
-          const tag = in_overage ? " [OVERAGE]" : "";
-          warnings.push(
-            `Energy${tag}: ${pct.toFixed(0)}% remaining (${formatKwh(kwh_remaining)} of ${formatKwh(kwh_included)})`,
-          );
-        }
+  } else if (sub) {
+    const ew = energyWarning(sub);
+    if (ew) pending.push(ew);
+  } else {
+    // No subscription. All kWh bill at the unsubscribed rate; warn on the
+    // overage cap when one is set, otherwise on the balance credits.
+    const cap = quotas.limits.overage_limit_usd;
+    if (cap !== null && cap > 0) {
+      const progress = computeOverageProgress(quotas);
+      if (progress.exhausted) {
+        const cw = creditsWarning(quotas);
+        if (cw) pending.push(cw);
+      } else if (progress.pctRemaining <= LOW_PCT) {
+        pending.push(overageWarning(progress));
       }
+    } else {
+      const cw = creditsWarning(quotas);
+      if (cw) pending.push(cw);
     }
   }
 
-  if (warnings.length === 0) return;
+  const fired = pending.filter((w) => {
+    if (shouldNotify(w.key, w.severity)) {
+      markNotified(w.key, w.severity);
+      return true;
+    }
+    return false;
+  });
+
+  if (fired.length === 0) return;
 
-  const hasCritical = warnings.some((w) => w.includes("[OVERAGE]"));
+  const hasCritical = fired.some((w) => w.severity === "critical");
   ctx.ui.notify(
-    `Neuralwatt quota warning:\n${warnings.map((w) => `  - ${w}`).join("\n")}`,
+    `Neuralwatt quota warning:\n${fired.map((w) => `  - ${w.message}`).join("\n")}`,
     hasCritical ? "error" : "warning",
   );
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-neuralwatt",
-  "version": "0.10.2",
+  "version": "0.10.4",
   "license": "MIT",
   "type": "module",
   "private": false,