@aliou/pi-neuralwatt 0.15.2 → 0.15.4

package/README.md

@@ -144,5 +144,5 @@ This repository uses [Changesets](https://github.com/changesets/changesets) for
 ## Links
 
 - [Neuralwatt](https://portal.neuralwatt.com/auth/register?ref=NW-ALIOU-Q7MF)
-- [Neuralwatt API Docs](https://neuralwatt.com/docs)
+- [Neuralwatt API Docs](https://docs.neuralwatt.com/quickstart.md)
 - [Pi Documentation](https://buildwithpi.ai/)

package/extensions/provider/models/build.ts

@@ -8,15 +8,6 @@ export type ThinkingLevelMap = NonNullable<
   ProviderModelConfig["thinkingLevelMap"]
 >;
 
-/**
- * Flex tier is billed at 65% of standard pricing (35% off) when the request
- * streams. A non-streaming request to a `-flex` model silently falls back to
- * the standard tier and the standard price.
- *
- * https://portal.neuralwatt.com/docs/guides/flex-tier
- */
-export const FLEX_COST_MULTIPLIER = 0.65;
-
 export interface NeuralwattCost {
   input: number;
   output: number;
@@ -107,12 +98,14 @@ export function buildThinkingLevelMap(
 
 /**
  * Neuralwatt reports `max_output_tokens: null` for models whose output is only
- * bounded by the context window. Mirror the API instead of inventing a cap.
+ * bounded by the context window. Some models incorrectly report 0; treat 0
+ * like null so we never emit maxTokens: 0.
  */
 export function resolveMaxTokens(
   maxOutputTokens: number | null | undefined,
   contextWindow: number,
 ): number {
+  if (maxOutputTokens === 0) return contextWindow;
   return maxOutputTokens ?? contextWindow;
 }
 

package/extensions/provider/models/catalog.ts

@@ -2,7 +2,6 @@ import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
 import type { NeuralwattApiModel } from "../../../src/types/models-api";
 import {
   buildThinkingLevelMap,
-  FLEX_COST_MULTIPLIER,
   resolveMaxTokens,
   type ThinkingLevelMap,
 } from "./build";
@@ -10,12 +9,6 @@ import { NEURALWATT_MODELS } from "./public-models";
 
 export type NeuralwattModel = ProviderModelConfig;
 
-const CONTEXT_WINDOW_OVERRIDES: ReadonlyMap<string, number> = new Map([
-  ["kimi-k3", 327_680],
-  ["kimi-k3-fast", 327_680],
-  ["kimi-k3-flex", 327_680],
-]);
-
 // Chat-template thinking: the API exposes a `reasoning` block, but the
 // underlying mechanism is chat_template_kwargs, so Pi needs the mapping.
 const COMPAT_OVERRIDES: Partial<
@@ -30,16 +23,11 @@ const COMPAT_OVERRIDES: Partial<
 };
 
 const HARDCODED_ALIASES: Record<string, string> = {
-  "zai-org/GLM-5.2-FP8": "glm-5.2",
   "moonshotai/Kimi-K2.7-Code": "kimi-k2.7-code",
   "Qwen/Qwen3.6-35B-A3B": "qwen3.6-35b",
   "deepseek-ai/DeepSeek-V4-Flash": "deepseek-v4-flash",
 };
 
-function isFlexModelId(id: string): boolean {
-  return id.endsWith("-flex");
-}
-
 function isVariantId(id: string): boolean {
   return id.includes("-fast") || id.includes("-flex") || id.includes("-short");
 }
@@ -52,8 +40,6 @@ function apiModelToProviderModel(model: NeuralwattApiModel): NeuralwattModel {
     );
 
   const reasoning = meta.capabilities.reasoning;
-  // Flex variants are billed at 0.65x when streaming (35% off).
-  const multiplier = isFlexModelId(model.id) ? FLEX_COST_MULTIPLIER : 1;
 
   const compat: NonNullable<ProviderModelConfig["compat"]> = {
     supportsDeveloperRole: meta.capabilities.developer_role,
@@ -62,8 +48,7 @@ function apiModelToProviderModel(model: NeuralwattApiModel): NeuralwattModel {
   if (reasoning) compat.requiresReasoningContentOnAssistantMessages = true;
   Object.assign(compat, COMPAT_OVERRIDES[model.id]);
 
-  const contextWindow =
-    CONTEXT_WINDOW_OVERRIDES.get(model.id) ?? model.max_model_len;
+  const contextWindow = model.max_model_len;
 
   const result: NeuralwattModel = {
     id: model.id,
@@ -73,10 +58,10 @@ function apiModelToProviderModel(model: NeuralwattApiModel): NeuralwattModel {
       ? (["text", "image"] as const)
       : (["text"] as const),
     cost: {
-      input: meta.pricing.input_per_million * multiplier,
-      output: meta.pricing.output_per_million * multiplier,
-      cacheRead: (meta.pricing.cached_input_per_million ?? 0) * multiplier,
-      cacheWrite: (meta.pricing.cached_output_per_million ?? 0) * multiplier,
+      input: meta.pricing.input_per_million,
+      output: meta.pricing.output_per_million,
+      cacheRead: meta.pricing.cached_input_per_million ?? 0,
+      cacheWrite: meta.pricing.cached_output_per_million ?? 0,
     },
     contextWindow,
     maxTokens: resolveMaxTokens(meta.limits.max_output_tokens, contextWindow),
@@ -135,7 +120,14 @@ export function buildNeuralwattProviderModelsFromApi(
   const models = apiModels
     .filter(
       (m) =>
-        m.metadata && !m.metadata.deprecated && !m.metadata.pricing.pricing_tbd,
+        m.metadata &&
+        !m.metadata.deprecated &&
+        !m.metadata.pricing.pricing_tbd &&
+        // Exclude non-chat models (e.g. embeddings) by task
+        !(
+          m.metadata.capabilities.task &&
+          !["chat", "completions"].includes(m.metadata.capabilities.task)
+        ),
     )
     .map(apiModelToProviderModel);
   return [...models, ...buildAliases(models, apiModels)];

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

@@ -1,7 +1,6 @@
 import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
 import {
   buildNeuralwattFamily,
-  FLEX_COST_MULTIPLIER,
   type NeuralwattModelFamily,
   type NeuralwattVariantSpec,
 } from "./build";
@@ -31,7 +30,7 @@ const DEEPSEEK_V4_FLASH: NeuralwattModelFamily = {
 // `max` and `none`; every non-`none` request resolves to `max` upstream.
 // It does not reason by default (`default_enabled: false`), but the model
 // can produce reasoning traces when asked. See
-// https://portal.neuralwatt.com/docs/api/chat-completions#reasoning-effort
+// https://docs.neuralwatt.com/api/chat-completions.md
 const GEMMA_4: NeuralwattModelFamily = {
   cost: { input: 0.144, output: 0.42, cacheRead: 0.0144 },
   vision: true,
@@ -41,25 +40,23 @@ const GEMMA_4: NeuralwattModelFamily = {
   },
 };
 
-// ZhipuAI. GLM-5.2 natively supports `high` and `max` reasoning efforts;
-// `xhigh` is an unsupported hole between them. Pi's `max` level (0.80.6) maps
-// to GLM's top tier.
-const GLM_5_2: NeuralwattModelFamily = {
+// ZhipuAI. GLM-5.3 has mandatory reasoning and `none` is not offered:
+// efforts are max/high/low (default max).
+const GLM_5_3: NeuralwattModelFamily = {
   cost: { input: 1.45, output: 4.5, cacheRead: 0.145 },
   vision: false,
   reasoningMetadata: {
-    supported_efforts: ["max", "high", "none"],
-    mandatory: false,
+    supported_efforts: ["max", "high", "low"],
+    mandatory: true,
   },
 };
 
-// ZhipuAI. GLM-5.3 ships as a GLM-5.2 weight swap in gated preview, with
-// GLM-5.2 pricing parity (per the API metadata; review at launch). Unlike
-// 5.2, reasoning is mandatory and `none` is not offered: efforts are
-// max/high/low (default max).
-const GLM_5_3: NeuralwattModelFamily = {
-  cost: { input: 1.45, output: 4.5, cacheRead: 0.145 },
-  vision: false,
+// ZhipuAI. GLM-5.3 Flash is the small GLM-5.3 tier: vision-capable, much
+// cheaper than the flagship, with the same mandatory max/high/low reasoning
+// contract as GLM-5.3.
+const GLM_5_3_FLASH: NeuralwattModelFamily = {
+  cost: { input: 0.15, output: 0.5, cacheRead: 0.03 },
+  vision: true,
   reasoningMetadata: {
     supported_efforts: ["max", "high", "low"],
     mandatory: true,
@@ -99,6 +96,18 @@ const QWEN_3_6_35B: NeuralwattModelFamily = {
   },
 };
 
+// Qwen. Qwen 3.8 27B tops out at `xhigh` (its default) and also supports
+// `medium`, `low`, and `none`; there is no `max` effort. Reasoning is on by
+// default but can be disabled.
+const QWEN_3_8_27B: NeuralwattModelFamily = {
+  cost: { input: 0.45, output: 3.2, cacheRead: 0.25 },
+  vision: true,
+  reasoningMetadata: {
+    supported_efforts: ["xhigh", "medium", "low", "none"],
+    mandatory: false,
+  },
+};
+
 const FAMILIES: [NeuralwattModelFamily, NeuralwattVariantSpec[]][] = [
   [
     DEEPSEEK_V4_FLASH,
@@ -116,7 +125,7 @@ const FAMILIES: [NeuralwattModelFamily, NeuralwattVariantSpec[]][] = [
         contextWindow: 1048560,
         maxOutputTokens: 65536,
         reasoning: true,
-        costMultiplier: FLEX_COST_MULTIPLIER,
+        costMultiplier: 0.65,
       },
     ],
   ],
@@ -133,114 +142,69 @@ const FAMILIES: [NeuralwattModelFamily, NeuralwattVariantSpec[]][] = [
     ],
   ],
   [
-    GLM_5_2,
+    GLM_5_3,
     [
       {
-        id: "glm-5.2",
-        name: "GLM-5.2",
+        id: "glm-5.3",
+        name: "GLM 5.3",
         contextWindow: 1048560,
         maxOutputTokens: null,
         reasoning: true,
       },
       {
-        // GLM-5.2 Fast pins thinking off by default, but keeps the parent's
-        // full reasoning contract (`high`/`max`/`none`): sending
-        // `reasoning_effort` re-enables thinking for that request.
-        id: "glm-5.2-fast",
-        name: "GLM-5.2 (fast)",
+        id: "glm-5.3-flex",
+        name: "GLM 5.3 (flex)",
         contextWindow: 1048560,
         maxOutputTokens: null,
         reasoning: true,
+        costMultiplier: 0.65,
       },
+    ],
+  ],
+  [
+    GLM_5_3_FLASH,
+    [
       {
-        id: "glm-5.2-flex",
-        name: "GLM-5.2 (flex)",
+        id: "glm-5.3-flash",
+        name: "GLM-5.3 Flash",
         contextWindow: 1048560,
         maxOutputTokens: null,
         reasoning: true,
-        costMultiplier: FLEX_COST_MULTIPLIER,
-      },
-      {
-        id: "glm-5.2-short",
-        name: "GLM-5.2 Short",
-        contextWindow: 199984,
-        maxOutputTokens: 32000,
-        reasoning: true,
-      },
-      {
-        // Short/fast: pins thinking off but keeps the parent reasoning
-        // contract, like glm-5.2-fast.
-        id: "glm-5.2-short-fast",
-        name: "GLM-5.2 (short, fast)",
-        contextWindow: 199984,
-        maxOutputTokens: 32000,
-        reasoning: true,
-      },
-      {
-        id: "glm-5.2-short-flex",
-        name: "GLM-5.2 (short, flex)",
-        contextWindow: 199984,
-        maxOutputTokens: 32000,
-        reasoning: true,
-        costMultiplier: FLEX_COST_MULTIPLIER,
-      },
-      {
-        // Short/fast/flex: pins thinking off but keeps the parent reasoning
-        // contract, like glm-5.2-fast.
-        id: "glm-5.2-short-fast-flex",
-        name: "GLM-5.2 (short, fast, flex)",
-        contextWindow: 199984,
-        maxOutputTokens: 32000,
-        reasoning: true,
-        costMultiplier: FLEX_COST_MULTIPLIER,
       },
-    ],
-  ],
-  [
-    GLM_5_3,
-    [
       {
-        id: "glm-5.3",
-        name: "GLM-5.3",
+        id: "glm-5.3-flash-flex",
+        name: "GLM-5.3 Flash (flex)",
         contextWindow: 1048560,
         maxOutputTokens: null,
         reasoning: true,
+        costMultiplier: 0.65,
       },
     ],
   ],
-  // The kimi-k3 endpoint rejects anything above 327,680 total tokens with
-  // `400: max_completion_tokens is too large … supports at most 327680
-  // completion tokens` (verified at runtime), even though the API advertises
-  // `max_model_len: 1048560` with a null output cap for the whole family.
-  // The -fast/-flex endpoints don't enforce any cap server-side yet (they
-  // accept max_completion_tokens beyond the advertised window), but they are
-  // the same K3 deployment and are expected to share the 327,680 limit, so
-  // all three variants are pinned to it. The drift check in models.test.ts
-  // whitelists this divergence via CONTEXT_WINDOW_OVERRIDES.
   [
     KIMI_K3,
     [
       {
         id: "kimi-k3",
         name: "Kimi K3",
-        contextWindow: 327680,
-        maxOutputTokens: 327680,
+        contextWindow: 1048560,
+        maxOutputTokens: null,
         reasoning: true,
       },
       {
         id: "kimi-k3-fast",
         name: "Kimi K3 Fast",
-        contextWindow: 327680,
-        maxOutputTokens: 327680,
+        contextWindow: 1048560,
+        maxOutputTokens: null,
         reasoning: false,
       },
       {
         id: "kimi-k3-flex",
         name: "Kimi K3 (flex)",
-        contextWindow: 327680,
-        maxOutputTokens: 327680,
+        contextWindow: 1048560,
+        maxOutputTokens: null,
         reasoning: true,
-        costMultiplier: FLEX_COST_MULTIPLIER,
+        costMultiplier: 0.65,
       },
     ],
   ],
@@ -269,7 +233,7 @@ const FAMILIES: [NeuralwattModelFamily, NeuralwattVariantSpec[]][] = [
         contextWindow: 262128,
         maxOutputTokens: null,
         reasoning: true,
-        costMultiplier: FLEX_COST_MULTIPLIER,
+        costMultiplier: 0.65,
       },
     ],
   ],
@@ -290,16 +254,43 @@ const FAMILIES: [NeuralwattModelFamily, NeuralwattVariantSpec[]][] = [
         maxOutputTokens: null,
         reasoning: false,
       },
+      {
+        id: "qwen3.6-35b-flex",
+        name: "Qwen3.6 35B (flex)",
+        contextWindow: 131056,
+        maxOutputTokens: null,
+        reasoning: true,
+        costMultiplier: 0.65,
+      },
+    ],
+  ],
+  [
+    QWEN_3_8_27B,
+    [
+      {
+        id: "qwen-3.8-27b",
+        name: "Qwen 3.8 27B",
+        contextWindow: 262128,
+        maxOutputTokens: 131072,
+        reasoning: true,
+      },
+      {
+        id: "qwen-3.8-27b-flex",
+        name: "Qwen 3.8 27B (flex)",
+        contextWindow: 262128,
+        maxOutputTokens: 131072,
+        reasoning: true,
+        costMultiplier: 0.65,
+      },
     ],
   ],
 ];
 
 // `-flex` variants are the Flex tier: same model, context window, output cap,
-// and prompt cache as the standard variant, admitted on spare capacity.
-// The API now advertises flex variants but lists them at standard pricing;
-// the 35% Flex discount is a billing-time concept applied here via
-// `costMultiplier` rather than reflected in the catalog metadata.
-// https://portal.neuralwatt.com/docs/guides/flex-tier
+// and prompt cache as the standard variant, admitted on spare capacity. The
+// API lists them at discounted prices; the fallback mirrors that with
+// `costMultiplier: 0.65` per variant.
+// https://docs.neuralwatt.com/guides/flex-tier.md
 
 export const NEURALWATT_MODELS: ProviderModelConfig[] = FAMILIES.flatMap(
   ([family, variants]) => buildNeuralwattFamily(family, variants),

package/extensions/provider/models/refresh.ts

@@ -12,6 +12,38 @@ import type {
 
 export const MODEL_STORE_TTL_MS = 4 * 60 * 60 * 1000;
 
+/**
+ * Scope a store entry applies to. The public catalog is a subset of any
+ * key-scoped catalog (preview, grant-gated, private models), so an entry
+ * stamped "public" must not shadow a keyed refresh — and a key-scoped entry
+ * must not be replayed for an anonymous user. Matches the anonymous-key
+ * convention in src/lib/neuralwatt-api.ts (authHeaders).
+ */
+const CATALOG_SCOPE_VERSION = "v1";
+type CatalogScope = "public" | "key";
+
+type ScopedModelsStoreEntry = ModelsStoreEntry & { catalogKey?: string };
+
+function catalogScope(apiKey: string | undefined): CatalogScope {
+  return apiKey !== undefined && apiKey !== "" && apiKey !== "-"
+    ? "key"
+    : "public";
+}
+
+function storedCatalogKey(entry: ScopedModelsStoreEntry): string | undefined {
+  return entry.catalogKey;
+}
+
+function catalogKeyMatches(
+  entry: ScopedModelsStoreEntry | undefined,
+  scope: CatalogScope,
+): boolean {
+  return (
+    entry !== undefined &&
+    storedCatalogKey(entry) === `${scope} ${CATALOG_SCOPE_VERSION}`
+  );
+}
+
 export type FetchNeuralwattApiModels = (
   apiKey: string | undefined,
   signal?: AbortSignal,
@@ -25,6 +57,13 @@ function isFreshStoreEntry(
   return Date.now() - checkedAt < MODEL_STORE_TTL_MS;
 }
 
+function isUsableStoreEntry(
+  entry: Readonly<ModelsStoreEntry> | undefined,
+  scope: CatalogScope,
+): entry is ModelsStoreEntry {
+  return isFreshStoreEntry(entry) && catalogKeyMatches(entry, scope);
+}
+
 export function createNeuralwattRefreshModels(
   staticModels: ReturnType<typeof buildNeuralwattProviderModels>,
   fetchApiModels: FetchNeuralwattApiModels,
@@ -35,29 +74,29 @@ export function createNeuralwattRefreshModels(
     context.signal.throwIfAborted();
     const fallback = buildFromStore(staticModels);
     try {
-      if (!context.allowNetwork) {
-        return context.stored
-          ? buildFromStore(context.stored.models)
-          : fallback;
-      }
-      if (!context.force && isFreshStoreEntry(context.stored)) {
-        return buildFromStore(context.stored.models);
-      }
       const apiKey =
         context.credential?.type === "api_key"
           ? context.credential.key
           : undefined;
+      const scope = catalogScope(apiKey);
+      const stored = context.stored as ScopedModelsStoreEntry | undefined;
+      if (!context.allowNetwork) {
+        return stored !== undefined && catalogKeyMatches(stored, scope)
+          ? buildFromStore(stored.models)
+          : fallback;
+      }
+      if (!context.force && isUsableStoreEntry(stored, scope)) {
+        return buildFromStore(stored.models);
+      }
       const apiModels = await fetchApiModels(apiKey, context.signal);
       context.signal.throwIfAborted();
       const models = buildFromApi(apiModels);
-      await context
-        .publish({
-          persist: {
-            models: models as unknown as ModelsStoreEntry["models"],
-            checkedAt: Date.now(),
-          },
-        })
-        .catch(() => undefined);
+      const entry: ScopedModelsStoreEntry = {
+        models: models as unknown as ModelsStoreEntry["models"],
+        checkedAt: Date.now(),
+        catalogKey: `${scope} ${CATALOG_SCOPE_VERSION}`,
+      };
+      await context.publish({ persist: entry }).catch(() => undefined);
       context.signal.throwIfAborted();
       return models;
     } catch (error) {

package/extensions/provider/rate-limit-error.ts

@@ -12,7 +12,7 @@ interface AssistantErrorLike {
  * layer. Each sets unique headers so the client can tell which layer
  * triggered the rejection.
  *
- * @see https://portal.neuralwatt.com/docs/guides/rate-limits
+ * @see https://docs.neuralwatt.com/guides/rate-limits.md
  */
 export interface NeuralwattRateLimitInfo {
   /** Which rate-limit layer triggered the 429 */

package/extensions/quota-warnings/notifier.ts

@@ -8,10 +8,37 @@ 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). */
+/** $/kWh by plan on a monthly interval. docs.neuralwatt.com/billing/faq */
+const OVERAGE_RATES_MONTHLY = {
+  basic: 8.5,
+  standard: 8.0,
+  pro: 7.5,
+  max: 7.0,
+} as const;
+/** $/kWh by plan on an annual interval. */
+const OVERAGE_RATES_ANNUAL = {
+  basic: 7.08,
+  standard: 6.67,
+  pro: 6.25,
+  max: 5.83,
+} as const;
+/** Pay-as-you-go, verified on portal.neuralwatt.com/pricing. */
 const OVERAGE_RATE_PER_KWH_UNSUBSCRIBED = 10;
+/** Unknown plan on a subscription: fall back to the Standard monthly rate. */
+const OVERAGE_RATE_PER_KWH_UNKNOWN_SUBSCRIBED = 8.0;
+
+function resolveOverageRate(sub: NeuralwattQuotas["subscription"]): number {
+  if (!sub) return OVERAGE_RATE_PER_KWH_UNSUBSCRIBED;
+  const plan = sub.plan.toLowerCase();
+  const table =
+    sub.billing_interval === "year"
+      ? OVERAGE_RATES_ANNUAL
+      : OVERAGE_RATES_MONTHLY;
+  return (
+    (table as Record<string, number>)[plan] ??
+    OVERAGE_RATE_PER_KWH_UNKNOWN_SUBSCRIBED
+  );
+}
 
 interface AlertState {
   lastSeverity: WarningSeverity;
@@ -112,9 +139,7 @@ export function computeOverageProgress(
       )
     : quotas.usage.current_month.energy_kwh;
 
-  const rate = hasSub
-    ? OVERAGE_RATE_PER_KWH_SUBSCRIBED
-    : OVERAGE_RATE_PER_KWH_UNSUBSCRIBED;
+  const rate = resolveOverageRate(quotas.subscription);
   const costUsd = overageKwh * rate;
   const remainingUsd = Math.max(0, capUsd - costUsd);
   const pctRemaining = capUsd > 0 ? (remainingUsd / capUsd) * 100 : 0;
@@ -153,9 +178,12 @@ function overageWarning(progress: OverageProgress): PendingWarning {
  *   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.
+ * Overage cost is derived from kWh usage: subscribed pays a per-plan rate
+ * ($7.00–$8.50/kWh by plan and billing interval) 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. Note `kwh_used` is the
+ * *charged* energy — flex usage bills at 0.65× kWh — so the "kWh over" figure
+ * is billed kWh, not physical consumption.
  *
  * 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.

package/package.json

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

package/src/types/models-api.ts

@@ -5,6 +5,10 @@ export interface NeuralwattApiModelPricing {
   cached_output_per_million: number | null;
   currency: string;
   pricing_tbd: boolean;
+  /** Service tier the pricing applies to (e.g. "standard", "flex"). */
+  service_tier?: string;
+  /** Flex tier cost multiplier (e.g. 0.65); null/absent on standard pricing. */
+  flex_discount_multiplier?: number | null;
 }
 
 export interface NeuralwattApiModelCapabilities {
@@ -16,6 +20,8 @@ export interface NeuralwattApiModelCapabilities {
   streaming: boolean;
   system_role: boolean;
   developer_role: boolean;
+  task?: string;
+  embedding_dimensions?: number;
 }
 
 /**

package/src/types/quota-api.ts

@@ -28,6 +28,10 @@ export interface NeuralwattQuotas {
     total_credits_usd: number;
     credits_used_usd: number;
     accounting_method: string;
+    /** Legacy credit pool split (USD). Typed for fidelity, not consumed yet. */
+    legacy_credits_usd?: number;
+    /** New credit pool split (USD). Typed for fidelity, not consumed yet. */
+    new_credits_usd?: number;
   };
   usage: {
     lifetime: {