@aliou/pi-neuralwatt 0.6.2 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-neuralwatt",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "license": "MIT",
   "type": "module",
   "private": false,
@@ -33,7 +33,8 @@
   ],
   "dependencies": {
     "@aliou/pi-utils-settings": "^0.17.0",
-    "@aliou/pi-utils-ui": "^0.4.0"
+    "@aliou/pi-utils-ui": "^0.4.0",
+    "@earendil-works/pi-ai": "$@earendil-works/pi-coding-agent"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",

package/src/extensions/provider/index.ts

@@ -1,3 +1,4 @@
+import { getApiProvider } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import {
   configLoader,
@@ -19,13 +20,23 @@ import { fetchQuotas } from "../../utils/quotas";
 import { normalizeNeuralwattContextOverflowError } from "./context-overflow";
 import { getNeuralwattModels } from "./models";
 import { buildQuotasFromHeaders, fetchRequestedQuotas } from "./quota-store";
+import {
+  type NeuralwattRateLimitInfo,
+  normalizeNeuralwattRateLimitError,
+  parseRateLimitHeaders,
+} from "./rate-limit-error";
+import { updateQuotasFromSseComment } from "./sse-quotas";
+import { wrapNeuralwattStreamSimple } from "./stream-simple";
 
 const HEADER_EMIT_THROTTLE_MS = 5_000;
 
-function registerNeuralwattProvider(pi: ExtensionAPI): void {
+function registerNeuralwattProvider(
+  pi: ExtensionAPI,
+  onSseQuota: (line: string) => void,
+): void {
   const { includeLegacyModelIds } = configLoader.getConfig();
 
-  pi.registerProvider("neuralwatt", {
+  const config: Parameters<ExtensionAPI["registerProvider"]>[1] = {
     baseUrl: "https://api.neuralwatt.com/v1",
     apiKey: "$NEURALWATT_API_KEY",
     api: "openai-completions",
@@ -37,13 +48,36 @@ function registerNeuralwattProvider(pi: ExtensionAPI): void {
     models: getNeuralwattModels({
       includeLegacyModelIds,
     }),
-  });
+  };
+
+  const provider = getApiProvider("openai-completions");
+  const baseStreamSimple = provider?.streamSimple;
+  if (baseStreamSimple) {
+    config.streamSimple = wrapNeuralwattStreamSimple(
+      baseStreamSimple as never,
+      onSseQuota,
+    ) as never;
+  }
+
+  pi.registerProvider("neuralwatt", config);
 }
 
 export default async function (pi: ExtensionAPI) {
   await configLoader.load();
 
-  registerNeuralwattProvider(pi);
+  let latestQuotas: NeuralwattQuotas | undefined;
+
+  const handleSseQuota = (line: string) => {
+    const quotas = updateQuotasFromSseComment(latestQuotas, line);
+    if (!quotas || quotas === latestQuotas) return;
+    latestQuotas = quotas;
+    pi.events.emit(NEURALWATT_QUOTAS_UPDATED_EVENT, {
+      quotas,
+      source: "sse",
+    });
+  };
+
+  registerNeuralwattProvider(pi, handleSseQuota);
 
   const loadedFeatures = new Set<NeuralwattFeatureId>();
 
@@ -53,7 +87,7 @@ export default async function (pi: ExtensionAPI) {
   });
 
   pi.events.on(NEURALWATT_CONFIG_UPDATED_EVENT, () => {
-    registerNeuralwattProvider(pi);
+    registerNeuralwattProvider(pi, handleSseQuota);
   });
 
   let lastHeaderEmitAt = 0;
@@ -67,20 +101,67 @@ export default async function (pi: ExtensionAPI) {
     if (source === "header" && now - lastHeaderEmitAt < HEADER_EMIT_THROTTLE_MS)
       return;
     if (source === "header") lastHeaderEmitAt = now;
+    latestQuotas = quotas;
     pi.events.emit(NEURALWATT_QUOTAS_UPDATED_EVENT, { quotas, source });
   }
 
+  // Stored rate-limit info from the most recent 429 response.
+  // Used in message_end to rewrite the generic error text with
+  // actionable details from Neuralwatt's response headers.
+  let pendingRateLimitInfo: NeuralwattRateLimitInfo | undefined;
+
   pi.on("message_end", (event, ctx) => {
-    const message = normalizeNeuralwattContextOverflowError(
+    // Rewrite rate-limit errors with layer-specific details
+    if (
+      pendingRateLimitInfo &&
+      event.message.role === "assistant" &&
+      event.message.stopReason === "error" &&
+      (event.message.provider === "neuralwatt" ||
+        ctx.model?.provider === "neuralwatt")
+    ) {
+      const message = normalizeNeuralwattRateLimitError(
+        event.message,
+        pendingRateLimitInfo,
+      );
+      pendingRateLimitInfo = undefined;
+      return { message };
+    }
+
+    if (
+      event.message.role === "assistant" &&
+      event.message.stopReason === "error" &&
+      (event.message.provider === "neuralwatt" ||
+        ctx.model?.provider === "neuralwatt") &&
+      event.message.errorMessage?.includes("429")
+    ) {
+      return {
+        message: normalizeNeuralwattRateLimitError(event.message, {
+          layer: "unknown",
+          detail:
+            "Neuralwatt rate limit reached, but Pi did not receive layer-specific rate-limit headers. Retry shortly.",
+        }),
+      };
+    }
+
+    // Rewrite context overflow errors for Pi's native compaction
+    const overflowMessage = normalizeNeuralwattContextOverflowError(
       event.message,
       ctx.model?.provider,
     );
-    if (!message) return;
-    return { message };
+    if (!overflowMessage) return;
+    return { message: overflowMessage };
   });
 
   pi.on("after_provider_response", (event, ctx) => {
     if (ctx.model?.provider !== "neuralwatt") return;
+
+    // Capture rate-limit headers from 429 responses for message_end rewriting
+    if (event.status === 429) {
+      pendingRateLimitInfo = parseRateLimitHeaders(event.headers);
+    } else {
+      pendingRateLimitInfo = undefined;
+    }
+
     const quotas = buildQuotasFromHeaders(event.headers);
     if (!quotas) return;
     emitQuotas(quotas, "header");
@@ -91,11 +172,7 @@ export default async function (pi: ExtensionAPI) {
     quotaRequestInFlight = true;
     try {
       const quotas = await fetchRequestedQuotas(data);
-      if (quotas)
-        pi.events.emit(NEURALWATT_QUOTAS_UPDATED_EVENT, {
-          quotas,
-          source: "api",
-        });
+      if (quotas) emitQuotas(quotas, "api");
     } finally {
       quotaRequestInFlight = false;
     }
@@ -107,6 +184,7 @@ export default async function (pi: ExtensionAPI) {
   });
 
   pi.on("session_start", async (_event, ctx) => {
+    pendingRateLimitInfo = undefined;
     for (const message of configLoader.drainMessages()) {
       ctx.ui.notify(message, "warning");
     }

package/src/extensions/provider/models.ts

@@ -5,11 +5,12 @@
 import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
 
 export const NEURALWATT_MODELS: ProviderModelConfig[] = [
-  // GLM-5 Fast - ZhipuAI
+  // GLM-5.1 (200K vLLM deployment) - ZhipuAI
+  // Legacy id previously aliased to glm-5.1; now serving a GLM-5.2 test build.
   {
-    id: "glm-5-fast",
-    name: "GLM-5 Fast",
-    reasoning: false,
+    id: "zai-org/GLM-5.1-FP8",
+    name: "GLM-5.2 (test)",
+    reasoning: true,
     input: ["text"],
     cost: {
       input: 1.1,
@@ -17,14 +18,23 @@ export const NEURALWATT_MODELS: ProviderModelConfig[] = [
       cacheRead: 0,
       cacheWrite: 0,
     },
-    contextWindow: 202736,
+    contextWindow: 1048560,
     maxTokens: 65536,
+    thinkingLevelMap: {
+      minimal: null,
+      low: null,
+      medium: "medium",
+      high: null,
+      xhigh: null,
+    },
     compat: {
       supportsDeveloperRole: false,
       maxTokensField: "max_tokens",
+      requiresReasoningContentOnAssistantMessages: true,
     },
   },
   // GLM-5.1 - ZhipuAI
+  // Backed by the 1048K GLM-5.2 deployment (GLM-5.1 redirect in effect). Deprecated.
   {
     id: "glm-5.1",
     name: "GLM-5.1",
@@ -36,7 +46,7 @@ export const NEURALWATT_MODELS: ProviderModelConfig[] = [
       cacheRead: 0,
       cacheWrite: 0,
     },
-    contextWindow: 202736,
+    contextWindow: 1048560,
     maxTokens: 65536,
     thinkingLevelMap: {
       minimal: null,
@@ -63,7 +73,7 @@ export const NEURALWATT_MODELS: ProviderModelConfig[] = [
       cacheRead: 0,
       cacheWrite: 0,
     },
-    contextWindow: 202736,
+    contextWindow: 1048560,
     maxTokens: 65536,
     compat: {
       supportsDeveloperRole: false,
@@ -84,12 +94,15 @@ export const NEURALWATT_MODELS: ProviderModelConfig[] = [
     },
     contextWindow: 1048560,
     maxTokens: 65536,
+    // GLM-5.2 has two native reasoning depths (high, max) plus thinking-off.
+    // Pi levels below high disable thinking; high -> high, xhigh -> max.
+    // See https://portal.neuralwatt.com/docs/api/chat-completions#reasoning-effort
     thinkingLevelMap: {
-      minimal: "low",
-      low: "low",
-      medium: "medium",
+      minimal: null,
+      low: null,
+      medium: null,
       high: "high",
-      xhigh: null,
+      xhigh: "max",
     },
     compat: {
       supportsDeveloperRole: false,
@@ -97,6 +110,25 @@ export const NEURALWATT_MODELS: ProviderModelConfig[] = [
       requiresReasoningContentOnAssistantMessages: true,
     },
   },
+  // GLM-5.2 Fast - ZhipuAI
+  {
+    id: "glm-5.2-fast",
+    name: "GLM-5.2 Fast",
+    reasoning: false,
+    input: ["text"],
+    cost: {
+      input: 1.45,
+      output: 4.5,
+      cacheRead: 0,
+      cacheWrite: 0,
+    },
+    contextWindow: 1048560,
+    maxTokens: 65536,
+    compat: {
+      supportsDeveloperRole: false,
+      maxTokensField: "max_tokens",
+    },
+  },
   // Kimi K2.5 - MoonshotAI
   {
     id: "moonshotai/Kimi-K2.5",
@@ -264,7 +296,7 @@ export const NEURALWATT_MODELS: ProviderModelConfig[] = [
   },
   // Kimi K2.7 Code - MoonshotAI
   {
-    id: "moonshotai/Kimi-K2.7-Code",
+    id: "kimi-k2.7-code",
     name: "Kimi K2.7 Code",
     reasoning: true,
     input: ["text", "image"],
@@ -312,7 +344,6 @@ export const NEURALWATT_MODELS: ProviderModelConfig[] = [
 ];
 
 const LEGACY_MODEL_ALIAS_MAP = {
-  "zai-org/GLM-5.1-FP8": "glm-5.1",
   "moonshotai/Kimi-K2.6": "kimi-k2.6",
   "Qwen/Qwen3.5-397B-A17B-FP8": "qwen3.5-397b",
   "Qwen/Qwen3.6-35B-A3B": "qwen3.6-35b",

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

@@ -0,0 +1,150 @@
+interface AssistantErrorLike {
+  role: string;
+  stopReason?: string;
+  provider?: string;
+  errorMessage?: string;
+}
+
+/**
+ * Parsed rate-limit info from Neuralwatt 429 response headers.
+ *
+ * Neuralwatt applies three independent rate-limit layers plus a legacy RPM
+ * layer. Each sets unique headers so the client can tell which layer
+ * triggered the rejection.
+ *
+ * @see https://portal.neuralwatt.com/docs/guides/rate-limits
+ */
+export interface NeuralwattRateLimitInfo {
+  /** Which rate-limit layer triggered the 429 */
+  layer: "concurrent" | "tpm" | "admission" | "rpm" | "unknown";
+  /** Seconds the server recommends waiting before retrying */
+  retryAfter?: number;
+  /** Human-readable details (varies per layer) */
+  detail: string;
+}
+
+/** Case-insensitive header lookup */
+function getHeader(
+  headers: Record<string, string>,
+  name: string,
+): string | undefined {
+  const entry = Object.entries(headers).find(
+    ([key]) => key.toLowerCase() === name.toLowerCase(),
+  );
+  return entry?.[1];
+}
+
+/**
+ * Parse Neuralwatt rate-limit headers from a 429 response.
+ *
+ * Returns `undefined` if no rate-limit-specific headers are found (e.g. the
+ * 429 came from a different proxy or middleware that doesn't set these
+ * headers).
+ */
+export function parseRateLimitHeaders(
+  headers: Record<string, string>,
+): NeuralwattRateLimitInfo | undefined {
+  const retryAfterRaw = getHeader(headers, "Retry-After");
+  const retryAfter = retryAfterRaw
+    ? Number.parseInt(retryAfterRaw, 10)
+    : undefined;
+
+  // 1. Concurrent-request limit
+  const concurrentDimension = getHeader(
+    headers,
+    "X-Concurrent-Limit-Dimension",
+  );
+  if (concurrentDimension) {
+    const active = getHeader(headers, "X-Concurrent-Limit-Active") ?? "?";
+    const max = getHeader(headers, "X-Concurrent-Limit-Max") ?? "?";
+    return {
+      layer: "concurrent",
+      retryAfter,
+      detail: `Concurrent request limit reached (${active}/${max} active, ${concurrentDimension}-scoped). Wait for an in-flight request to complete before retrying.`,
+    };
+  }
+
+  // 2. Input TPM limit
+  const tpmDimension = getHeader(headers, "X-TPM-Limit-Dimension");
+  if (tpmDimension) {
+    const tokens = getHeader(headers, "X-TPM-Limit-Tokens") ?? "?";
+    const max = getHeader(headers, "X-TPM-Limit-Max") ?? "?";
+    return {
+      layer: "tpm",
+      retryAfter,
+      detail: `Input token rate exceeded (${tokens}/${max} tokens/min, ${tpmDimension}-scoped). Wait before sending more requests.`,
+    };
+  }
+
+  // 3. Admission control
+  const admissionDimension = getHeader(headers, "X-Admission-Dimension");
+  if (admissionDimension) {
+    const inFlight = getHeader(headers, "X-Admission-InFlight") ?? "?";
+    const threshold = getHeader(headers, "X-Admission-Threshold") ?? "?";
+    return {
+      layer: "admission",
+      retryAfter,
+      detail: `Backend at capacity (${inFlight}/${threshold} in-flight tokens, ${admissionDimension}-scoped). The server is busy — retry shortly.`,
+    };
+  }
+
+  // 4. Legacy RPM limit
+  const rpmLimit = getHeader(headers, "X-RateLimit-Limit");
+  if (rpmLimit) {
+    const remaining = getHeader(headers, "X-RateLimit-Remaining") ?? "?";
+    return {
+      layer: "rpm",
+      retryAfter,
+      detail: `Requests per minute exceeded (${remaining}/${rpmLimit} remaining). Wait before sending more requests.`,
+    };
+  }
+
+  // Generic 429 with Retry-After but no layer-specific headers
+  if (retryAfter !== undefined) {
+    return {
+      layer: "unknown",
+      retryAfter,
+      detail: "Rate limited by the server. Wait before retrying.",
+    };
+  }
+
+  return undefined;
+}
+
+/**
+ * Build a user-facing error message from a NeuralwattRateLimitInfo.
+ */
+function formatRateLimitError(info: NeuralwattRateLimitInfo): string {
+  const parts = [info.detail];
+
+  if (info.retryAfter !== undefined && info.retryAfter > 0) {
+    if (info.retryAfter < 60) {
+      parts.push(`Retry-After: ${info.retryAfter}s.`);
+    } else {
+      const mins = Math.ceil(info.retryAfter / 60);
+      parts.push(`Retry-After: ~${mins} min.`);
+    }
+  } else if (info.retryAfter === 0 && info.layer === "concurrent") {
+    // Retry-After: 0 means: retry as soon as a slot frees
+    parts.push("Retry immediately after an in-flight request completes.");
+  }
+
+  return `429 rate limit: ${parts.join(" ")}`;
+}
+
+/**
+ * Normalize Neuralwatt rate-limit errors so the user sees which layer
+ * triggered the 429 and what to do about it.
+ *
+ * Without this, Pi shows a generic "Too Many Requests" because the
+ * Neuralwatt 429 response body is empty — all diagnostics are in the
+ * response headers.
+ */
+export function normalizeNeuralwattRateLimitError<
+  TMessage extends AssistantErrorLike,
+>(message: TMessage, rateLimitInfo: NeuralwattRateLimitInfo): TMessage {
+  return {
+    ...message,
+    errorMessage: formatRateLimitError(rateLimitInfo),
+  };
+}

package/src/extensions/provider/sse-quotas.ts

@@ -0,0 +1,84 @@
+import type { NeuralwattQuotas } from "../../types/quota-api";
+
+const JOULES_PER_KWH = 3_600_000;
+
+export function updateQuotasFromSseComment(
+  quotas: NeuralwattQuotas | undefined,
+  line: string,
+): NeuralwattQuotas | undefined {
+  if (!quotas) return;
+  const trimmed = line.trim();
+  const next = structuredClone(quotas);
+
+  try {
+    if (trimmed.startsWith(": energy ")) {
+      const energy = JSON.parse(trimmed.slice(9)) as { energy_joules?: number };
+      const energyKwh = (energy.energy_joules ?? 0) / JOULES_PER_KWH;
+      if (energyKwh <= 0) return quotas;
+      next.usage.current_month.energy_kwh += energyKwh;
+      next.usage.lifetime.energy_kwh += energyKwh;
+      if (next.subscription) {
+        next.subscription.kwh_used += energyKwh;
+        next.subscription.kwh_remaining = Math.max(
+          0,
+          next.subscription.kwh_remaining - energyKwh,
+        );
+      }
+      next.snapshot_at = new Date().toISOString();
+      return next;
+    }
+
+    if (trimmed.startsWith(": cost ")) {
+      const cost = JSON.parse(trimmed.slice(7)) as {
+        request_cost_usd?: number;
+      };
+      const requestCostUsd = cost.request_cost_usd ?? 0;
+      if (requestCostUsd <= 0) return quotas;
+      next.balance.credits_remaining_usd = Math.max(
+        0,
+        next.balance.credits_remaining_usd - requestCostUsd,
+      );
+      next.balance.credits_used_usd += requestCostUsd;
+      next.usage.current_month.cost_usd += requestCostUsd;
+      next.usage.lifetime.cost_usd += requestCostUsd;
+      next.snapshot_at = new Date().toISOString();
+      return next;
+    }
+  } catch {
+    return quotas;
+  }
+
+  return quotas;
+}
+
+export async function readQuotaCommentsFromTee(
+  body: ReadableStream<Uint8Array>,
+  onComment: (line: string) => void,
+): Promise<void> {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) onComment(line);
+    }
+
+    const final = decoder.decode(new Uint8Array(0), { stream: false });
+    const remaining = (buffer + final).trim();
+    if (remaining) onComment(remaining);
+  } catch {
+    // The SDK side may abort the tee; quota comments are best-effort.
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+      // ignore
+    }
+  }
+}

package/src/extensions/provider/stream-simple.ts

@@ -0,0 +1,138 @@
+// Neuralwatt is OpenAI-compatible, but the OpenAI SDK throws on non-2xx
+// responses before Pi's after_provider_response hook can see the raw headers.
+// We wrap the built-in openai-completions streamSimple so 429 rate-limit
+// headers can be captured before the SDK turns them into a generic error, while
+// still delegating normal streaming behavior to Pi's provider implementation.
+//
+// The SSE tee used for live quota comments is inspired by:
+// https://github.com/monotykamary/pi-neuralwatt-provider
+
+import {
+  type AssistantMessageEventStream,
+  type Context,
+  createAssistantMessageEventStream,
+  type Model,
+  type SimpleStreamOptions,
+} from "@earendil-works/pi-ai";
+import {
+  type NeuralwattRateLimitInfo,
+  normalizeNeuralwattRateLimitError,
+  parseRateLimitHeaders,
+} from "./rate-limit-error";
+import { readQuotaCommentsFromTee } from "./sse-quotas";
+
+export type AnyStreamSimple = (
+  model: Model<string>,
+  context: Context,
+  options?: SimpleStreamOptions,
+) => AssistantMessageEventStream;
+
+function headersToRecord(headers: Headers): Record<string, string> {
+  const record: Record<string, string> = {};
+  headers.forEach((value, key) => {
+    record[key] = value;
+  });
+  return record;
+}
+
+function isProviderChatCompletionsUrl(
+  input: RequestInfo | URL,
+  providerOrigin: string,
+): boolean {
+  const rawUrl =
+    typeof input === "string"
+      ? input
+      : input instanceof URL
+        ? input.toString()
+        : input.url;
+
+  try {
+    const url = new URL(rawUrl);
+    return (
+      url.origin === providerOrigin &&
+      url.pathname.endsWith("/chat/completions")
+    );
+  } catch {
+    return false;
+  }
+}
+
+async function forwardStream(
+  stream: AssistantMessageEventStream,
+  outer: AssistantMessageEventStream,
+  getRateLimitInfo: () => NeuralwattRateLimitInfo | undefined,
+  restoreFetch: () => void,
+): Promise<void> {
+  try {
+    for await (const event of stream) {
+      const rateLimitInfo = getRateLimitInfo();
+      if (event.type === "error" && rateLimitInfo) {
+        outer.push({
+          ...event,
+          error: normalizeNeuralwattRateLimitError(event.error, rateLimitInfo),
+        });
+      } else {
+        outer.push(event);
+      }
+    }
+  } finally {
+    restoreFetch();
+    outer.end();
+  }
+}
+
+export function wrapNeuralwattStreamSimple(
+  base: AnyStreamSimple,
+  onSseQuota: (line: string) => void,
+): AnyStreamSimple {
+  return (model, context, options = {}) => {
+    let rateLimitInfo: NeuralwattRateLimitInfo | undefined;
+    let sseQuotaTask: Promise<void> | undefined;
+    const outer = createAssistantMessageEventStream();
+    const providerOrigin = new URL(
+      model.baseUrl ?? "https://api.neuralwatt.com/v1",
+    ).origin;
+    const originalFetch = globalThis.fetch;
+    const wrappedFetch: typeof fetch = async (input, init) => {
+      const response = await originalFetch(input, init);
+
+      if (!isProviderChatCompletionsUrl(input, providerOrigin)) return response;
+
+      const headers = headersToRecord(response.headers);
+      if (response.status === 429) {
+        rateLimitInfo = parseRateLimitHeaders(headers);
+        return response;
+      }
+
+      if (response.ok && response.body) {
+        const [sdkBody, quotaBody] = response.body.tee();
+        sseQuotaTask = readQuotaCommentsFromTee(quotaBody, onSseQuota);
+        return new Response(sdkBody, {
+          headers: response.headers,
+          status: response.status,
+          statusText: response.statusText,
+        });
+      }
+
+      return response;
+    };
+
+    globalThis.fetch = wrappedFetch;
+
+    const restoreFetch = () => {
+      if (globalThis.fetch === wrappedFetch) globalThis.fetch = originalFetch;
+      sseQuotaTask?.catch(() => {});
+    };
+
+    const stream = base(model, context, options);
+    const originalOuterEnd = outer.end.bind(outer);
+    outer.end = (result?: Parameters<typeof originalOuterEnd>[0]) => {
+      restoreFetch();
+      originalOuterEnd(result);
+    };
+
+    void forwardStream(stream, outer, () => rateLimitInfo, restoreFetch);
+
+    return outer;
+  };
+}

package/src/types/quota-events.ts

@@ -1,6 +1,6 @@
 import type { NeuralwattQuotas } from "./quota-api";
 
-export type QuotaSource = "header" | "api";
+export type QuotaSource = "header" | "api" | "sse";
 
 export const NEURALWATT_QUOTAS_UPDATED_EVENT =
   "neuralwatt:quotas:updated" as const;