@aliou/pi-neuralwatt 0.16.3 → 0.18.0

package/extensions/provider/index.ts

@@ -30,7 +30,10 @@ import {
   parseRateLimitHeaders,
 } from "./rate-limit-error";
 import { updateQuotasFromSseComment } from "./sse-quotas";
-import { wrapNeuralwattStreamSimple } from "./stream-simple";
+import {
+  type NeuralwattStreamCallbacks,
+  wrapNeuralwattStreamSimple,
+} from "./stream-simple";
 
 const HEADER_EMIT_THROTTLE_MS = 5_000;
 
@@ -42,7 +45,7 @@ function emitConfigUpdated(pi: ExtensionAPI): void {
 
 function registerNeuralwattProvider(
   pi: ExtensionAPI,
-  onSseQuota: (line: string) => void,
+  streamCallbacks: NeuralwattStreamCallbacks,
 ): void {
   const staticModels = buildNeuralwattProviderModels();
 
@@ -51,7 +54,7 @@ function registerNeuralwattProvider(
   const streamSimple = baseStreamSimple
     ? (wrapNeuralwattStreamSimple(
         baseStreamSimple as never,
-        onSseQuota,
+        streamCallbacks,
       ) as never)
     : undefined;
 
@@ -60,7 +63,7 @@ function registerNeuralwattProvider(
   const messagesStreamSimple = messagesBaseStreamSimple
     ? (wrapNeuralwattStreamSimple(
         messagesBaseStreamSimple as never,
-        onSseQuota,
+        streamCallbacks,
       ) as never)
     : undefined;
 
@@ -101,7 +104,17 @@ export default async function (pi: ExtensionAPI) {
     emitQuotas(quotas, "sse");
   };
 
-  registerNeuralwattProvider(pi, handleSseQuota);
+  // Rate-limit info captured by the per-request fetch wrapper 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;
+
+  registerNeuralwattProvider(pi, {
+    onSseQuota: handleSseQuota,
+    onRateLimit: (info) => {
+      pendingRateLimitInfo = info;
+    },
+  });
 
   const loadedFeatures = new Set<NeuralwattFeatureId>();
 
@@ -125,10 +138,6 @@ export default async function (pi: ExtensionAPI) {
     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;
   let currentModelRegistry: ModelRegistry | undefined;
 
   pi.on("message_end", (event, ctx) => {
@@ -148,14 +157,14 @@ export default async function (pi: ExtensionAPI) {
       return { message };
     }
 
-    // Fallback for 429s where no layer-specific headers were captured. The
-    // streamSimple wrap (wrapNeuralwattStreamSimple) already formats a
-    // detailed message via formatRateLimitError when it captures headers;
-    // detect that case by the `"429 rate limit:"` prefix it emits and leave
-    // it untouched. This branch only fires for genuinely headerless 429s
-    // (e.g. anonymous playground limits, or a 429 from infra in front of
-    // Neuralwatt), since after_provider_response cannot observe 429s — the
-    // OpenAI SDK throws before Pi's onResponse hook runs.
+    // Fallback for 429s where no layer-specific headers were captured (the
+    // fetch wrapper reported `undefined` via onRateLimit, or the 429 came
+    // from infra in front of Neuralwatt). The `"429 rate limit:"` prefix
+    // guard skips messages the first branch already rewrote. On the
+    // openai-completions surface after_provider_response cannot observe
+    // 429s — the OpenAI SDK throws before Pi's onResponse hook runs — so
+    // this is the only repair path there; on anthropic-messages
+    // after_provider_response also feeds pendingRateLimitInfo directly.
     if (
       event.message.role === "assistant" &&
       event.message.stopReason === "error" &&

package/extensions/provider/models/build.ts

@@ -4,8 +4,24 @@ import type {
   NeuralwattReasoningEffort,
 } from "../../../src/types/models-api";
 
+export type ProviderChatModelConfig = Extract<
+  ProviderModelConfig,
+  { type?: "chat" }
+>;
+
+export type ProviderClassifierModelConfig = Extract<
+  ProviderModelConfig,
+  { type: "classifier" }
+>;
+
+export const NEURALWATT_SYSTEM_ONE_API = "typesafe-system-one" as const;
+
+export type NeuralwattClassifierModel = ProviderClassifierModelConfig & {
+  api: typeof NEURALWATT_SYSTEM_ONE_API;
+};
+
 export type ThinkingLevelMap = NonNullable<
-  ProviderModelConfig["thinkingLevelMap"]
+  ProviderChatModelConfig["thinkingLevelMap"]
 >;
 
 /**
@@ -13,7 +29,7 @@ export type ThinkingLevelMap = NonNullable<
  * retained for anthropic-messages map derivation. Rides the models store
  * (JSON passthrough); stripped from stamped runtime models.
  */
-export type NeuralwattCompiledModel = ProviderModelConfig & {
+export type NeuralwattCompiledModel = ProviderChatModelConfig & {
   reasoningContract?: NeuralwattReasoningMapSource;
 };
 
@@ -157,7 +173,7 @@ export function buildNeuralwattModel(
 ): NeuralwattCompiledModel {
   const vision = variant.vision ?? family.vision;
 
-  const compat: NonNullable<ProviderModelConfig["compat"]> = {
+  const compat: NonNullable<ProviderChatModelConfig["compat"]> = {
     supportsDeveloperRole: false,
     maxTokensField: "max_tokens",
   };

package/extensions/provider/models/catalog.ts

@@ -1,19 +1,45 @@
-import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
 import type { NeuralwattApiModel } from "../../../src/types/models-api";
 import {
   buildThinkingLevelMap,
+  NEURALWATT_SYSTEM_ONE_API,
+  type NeuralwattClassifierModel,
   type NeuralwattCompiledModel,
+  type ProviderChatModelConfig,
   resolveMaxTokens,
   type ThinkingLevelMap,
 } from "./build";
 import { NEURALWATT_MODELS } from "./public-models";
 
-export type NeuralwattModel = NeuralwattCompiledModel;
+export type NeuralwattChatModel = NeuralwattCompiledModel;
+
+export type NeuralwattModel = NeuralwattChatModel | NeuralwattClassifierModel;
+
+export function isNeuralwattClassifierModel(
+  model: NeuralwattModel,
+): model is NeuralwattClassifierModel {
+  return model.type === "classifier";
+}
+
+export function partitionNeuralwattModels(models: readonly NeuralwattModel[]): {
+  chat: NeuralwattChatModel[];
+  classifiers: NeuralwattClassifierModel[];
+} {
+  const chat: NeuralwattChatModel[] = [];
+  const classifiers: NeuralwattClassifierModel[] = [];
+  for (const model of models) {
+    if (isNeuralwattClassifierModel(model)) {
+      classifiers.push(model);
+    } else {
+      chat.push(model);
+    }
+  }
+  return { chat, classifiers };
+}
 
 // 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<
-  Record<string, Partial<NonNullable<ProviderModelConfig["compat"]>>>
+  Record<string, Partial<NonNullable<ProviderChatModelConfig["compat"]>>>
 > = {
   "Qwen/Qwen3.8-27B-FP8": {
     thinkingFormat: "chat-template",
@@ -23,7 +49,36 @@ const COMPAT_OVERRIDES: Partial<
   },
 };
 
-function apiModelToProviderModel(model: NeuralwattApiModel): NeuralwattModel {
+function apiModelToClassifierModel(
+  model: NeuralwattApiModel,
+): NeuralwattClassifierModel {
+  const meta = model.metadata;
+  if (!meta)
+    throw new Error(
+      `Neuralwatt API returned model "${model.id}" without metadata`,
+    );
+
+  return {
+    type: "classifier",
+    api: NEURALWATT_SYSTEM_ONE_API,
+    id: model.id,
+    name: meta.display_name ?? model.id,
+    input: meta.capabilities.vision
+      ? (["text", "image"] as const)
+      : (["text"] as const),
+    cost: {
+      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: model.max_model_len,
+  };
+}
+
+function apiModelToProviderModel(
+  model: NeuralwattApiModel,
+): NeuralwattChatModel {
   const meta = model.metadata;
   if (!meta)
     throw new Error(
@@ -32,7 +87,7 @@ function apiModelToProviderModel(model: NeuralwattApiModel): NeuralwattModel {
 
   const reasoning = meta.capabilities.reasoning;
 
-  const compat: NonNullable<ProviderModelConfig["compat"]> = {
+  const compat: NonNullable<ProviderChatModelConfig["compat"]> = {
     supportsDeveloperRole: meta.capabilities.developer_role,
     maxTokensField: "max_tokens",
     ...COMPAT_OVERRIDES[model.id],
@@ -83,13 +138,18 @@ export function buildNeuralwattProviderModelsFromApi(
         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)
+          !["chat", "completions", "decision"].includes(
+            m.metadata.capabilities.task,
+          )
         ),
     )
-    .map(apiModelToProviderModel);
+    .map((m) =>
+      m.metadata?.capabilities.task === "decision"
+        ? apiModelToClassifierModel(m)
+        : apiModelToProviderModel(m),
+    );
   return models;
 }
 

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

@@ -1,8 +1,8 @@
-import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
 import {
   buildNeuralwattFamily,
   type NeuralwattModelFamily,
   type NeuralwattVariantSpec,
+  type ProviderChatModelConfig,
 } from "./build";
 
 // Public models returned by https://api.neuralwatt.com/v1/models.
@@ -105,17 +105,6 @@ const KIMI_K3: NeuralwattModelFamily = {
   },
 };
 
-// MoonshotAI. K2.7 Code has mandatory reasoning with no selectable efforts
-// (`supported_efforts: []`), so `buildThinkingLevelMap` nulls out every level.
-const KIMI_K2_7_CODE: NeuralwattModelFamily = {
-  cost: { input: 0.95, output: 4.0, cacheRead: 0.095 },
-  vision: true,
-  reasoningMetadata: {
-    supported_efforts: [],
-    mandatory: true,
-  },
-};
-
 // Xiaomi. MiMo-V2.6-Pro only has two reasoning behaviors: `high` (default)
 // and `none`; the API aliases every other effort onto those, with `minimal`
 // landing on `none`.
@@ -336,35 +325,6 @@ const FAMILIES: [NeuralwattModelFamily, NeuralwattVariantSpec[]][] = [
       },
     ],
   ],
-  [
-    KIMI_K2_7_CODE,
-    [
-      {
-        id: "kimi-k2.7-code",
-        name: "Kimi K2.7 Code",
-        contextWindow: 262128,
-        maxOutputTokens: null,
-        reasoning: true,
-      },
-      {
-        // K2.7 Code cannot disable thinking; the -fast variant caps the
-        // reasoning budget (~64 tokens) rather than turning it off.
-        id: "kimi-k2.7-code-fast",
-        name: "Kimi K2.7 Code Fast",
-        contextWindow: 262128,
-        maxOutputTokens: null,
-        reasoning: true,
-      },
-      {
-        id: "kimi-k2.7-code-flex",
-        name: "Kimi K2.7 Code (flex)",
-        contextWindow: 262128,
-        maxOutputTokens: null,
-        reasoning: true,
-        costMultiplier: 0.65,
-      },
-    ],
-  ],
   [
     MIMO_V2_6_PRO,
     [
@@ -375,6 +335,14 @@ const FAMILIES: [NeuralwattModelFamily, NeuralwattVariantSpec[]][] = [
         maxOutputTokens: 393216,
         reasoning: true,
       },
+      {
+        id: "mimo-v2.6-pro-flex",
+        name: "MiMo-V2.6-Pro (flex)",
+        contextWindow: 1048560,
+        maxOutputTokens: 393216,
+        reasoning: true,
+        costMultiplier: 0.65,
+      },
     ],
   ],
   [
@@ -492,6 +460,6 @@ const FAMILIES: [NeuralwattModelFamily, NeuralwattVariantSpec[]][] = [
 // `costMultiplier: 0.65` per variant.
 // https://docs.neuralwatt.com/guides/flex-tier.md
 
-export const NEURALWATT_MODELS: ProviderModelConfig[] = FAMILIES.flatMap(
+export const NEURALWATT_MODELS: ProviderChatModelConfig[] = FAMILIES.flatMap(
   ([family, variants]) => buildNeuralwattFamily(family, variants),
 );

package/extensions/provider/models/refresh.ts

@@ -1,7 +1,9 @@
 import type {
+  AnyModel,
   ModelsStoreEntry,
   RefreshModelsContext,
 } from "@earendil-works/pi-ai";
+import { configuredApiBaseUrl } from "../../../src/config/loader";
 import type { NeuralwattApiModel } from "../../../src/types/models-api";
 import type {
   buildNeuralwattProviderModels,
@@ -17,7 +19,8 @@ export const MODEL_STORE_TTL_MS = 4 * 60 * 60 * 1000;
  * 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).
+ * convention in src/lib/neuralwatt-api.ts (authHeaders). The base URL is part
+ * of the key because a gateway can serve a different catalog than upstream.
  */
 const CATALOG_SCOPE_VERSION = "v2";
 type CatalogScope = "public" | "key";
@@ -30,18 +33,15 @@ function catalogScope(apiKey: string | undefined): CatalogScope {
     : "public";
 }
 
-function storedCatalogKey(entry: ScopedModelsStoreEntry): string | undefined {
-  return entry.catalogKey;
+function catalogKey(scope: CatalogScope): string {
+  return `${scope} ${CATALOG_SCOPE_VERSION} ${configuredApiBaseUrl()}`;
 }
 
 function catalogKeyMatches(
   entry: ScopedModelsStoreEntry | undefined,
   scope: CatalogScope,
 ): boolean {
-  return (
-    entry !== undefined &&
-    storedCatalogKey(entry) === `${scope} ${CATALOG_SCOPE_VERSION}`
-  );
+  return entry !== undefined && entry.catalogKey === catalogKey(scope);
 }
 
 export type FetchNeuralwattApiModels = (
@@ -49,6 +49,10 @@ export type FetchNeuralwattApiModels = (
   signal?: AbortSignal,
 ) => Promise<readonly NeuralwattApiModel[]>;
 
+function asStoredChatModels(models: readonly AnyModel[]): NeuralwattModel[] {
+  return models as unknown as NeuralwattModel[];
+}
+
 function isFreshStoreEntry(
   entry: Readonly<ModelsStoreEntry> | undefined,
 ): entry is ModelsStoreEntry {
@@ -82,11 +86,11 @@ export function createNeuralwattRefreshModels(
       const stored = context.stored as ScopedModelsStoreEntry | undefined;
       if (!context.allowNetwork) {
         return stored !== undefined && catalogKeyMatches(stored, scope)
-          ? buildFromStore(stored.models)
+          ? buildFromStore(asStoredChatModels(stored.models))
           : fallback;
       }
       if (!context.force && isUsableStoreEntry(stored, scope)) {
-        return buildFromStore(stored.models);
+        return buildFromStore(asStoredChatModels(stored.models));
       }
       const apiModels = await fetchApiModels(apiKey, context.signal);
       context.signal.throwIfAborted();
@@ -94,7 +98,7 @@ export function createNeuralwattRefreshModels(
       const entry: ScopedModelsStoreEntry = {
         models: models as unknown as ModelsStoreEntry["models"],
         checkedAt: Date.now(),
-        catalogKey: `${scope} ${CATALOG_SCOPE_VERSION}`,
+        catalogKey: catalogKey(scope),
       };
       await context.publish({ persist: entry }).catch(() => undefined);
       context.signal.throwIfAborted();

package/extensions/provider/provider.ts

@@ -2,6 +2,7 @@ import type { Provider } from "@earendil-works/pi-ai";
 import type { NeuralwattApi } from "../../src/config";
 import { createAnthropicMessagesApi } from "./api/anthropic-messages";
 import { createOpenAiCompletionsApi } from "./api/openai-completions";
+import { classify, stampClassifierModels } from "./api/system-one";
 import type { NeuralwattApiHandler } from "./api/types";
 import {
   NEURALWATT_API_KEY_ENV,
@@ -13,6 +14,7 @@ import type { NeuralwattModel } from "./models/catalog";
 import {
   buildNeuralwattProviderModelsFromApi,
   buildNeuralwattProviderModelsFromStore,
+  partitionNeuralwattModels,
 } from "./models/catalog";
 import {
   createNeuralwattRefreshModels,
@@ -98,11 +100,22 @@ export function createNeuralwattProvider(
           if (envKey) {
             return { auth: { apiKey: envKey }, source: NEURALWATT_API_KEY_ENV };
           }
-          return { auth: { apiKey: "" }, source: "anonymous" };
+          // pi-ai rejects empty keys before dispatch; "-" is the neutral
+          // placeholder that gateways strip or replace server-side.
+          return { auth: { apiKey: "-" }, source: "anonymous" };
         },
       },
     },
-    getModels: () => handler.stampModels(canonicalModels),
+    getModels: () =>
+      handler.stampModels(partitionNeuralwattModels(canonicalModels).chat),
+    getAllModels: () => {
+      const { chat, classifiers } = partitionNeuralwattModels(canonicalModels);
+      return [
+        ...handler.stampModels(chat),
+        ...stampClassifierModels(classifiers),
+      ];
+    },
+    classify: (model, context, options) => classify(model, context, options),
     refreshModels: async (context) => {
       const models = await refreshCatalog(context);
       await context.publish({

package/extensions/provider/stream-simple.ts

@@ -1,32 +1,39 @@
 // 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.
+// We inject a per-request `options.fetch` wrapper so 429
+// rate-limit headers can be captured before the SDK turns them into a generic
+// error, and tee successful SSE bodies for live quota comments, while still
+// delegating normal streaming behavior to Pi's provider implementation.
+// `globalThis.fetch` is never touched.
 //
 // 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,
+import type {
+  AssistantMessageEventStream,
+  FetchFunction,
+  Model,
+  SimpleStreamOptions,
+  TranscriptContext,
 } from "@earendil-works/pi-ai";
+import { configuredApiBaseUrl } from "../../src/config/loader";
 import {
   type NeuralwattRateLimitInfo,
-  normalizeNeuralwattRateLimitError,
   parseRateLimitHeaders,
 } from "./rate-limit-error";
 import { readQuotaCommentsFromTee } from "./sse-quotas";
 
 export type AnyStreamSimple = (
   model: Model<string>,
-  context: Context,
+  context: TranscriptContext,
   options?: SimpleStreamOptions,
 ) => AssistantMessageEventStream;
 
+export interface NeuralwattStreamCallbacks {
+  onSseQuota: (line: string) => void;
+  onRateLimit: (info: NeuralwattRateLimitInfo | undefined) => void;
+}
+
 function headersToRecord(headers: Headers): Record<string, string> {
   const record: Record<string, string> = {};
   headers.forEach((value, key) => {
@@ -58,56 +65,34 @@ function isProviderStreamUrl(
   }
 }
 
-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,
+  callbacks: NeuralwattStreamCallbacks,
 ): 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);
+    const providerOrigin = new URL(model.baseUrl ?? configuredApiBaseUrl())
+      .origin;
+    const callerFetch = options.fetch;
+
+    const neuralwattFetch: FetchFunction = async (input, init) => {
+      // Chain onto a caller-provided fetch when present; otherwise resolve
+      // the global at request time so late host/test overrides still apply.
+      const response = await (callerFetch ?? globalThis.fetch)(input, init);
 
       if (!isProviderStreamUrl(input, providerOrigin)) return response;
 
-      const headers = headersToRecord(response.headers);
       if (response.status === 429) {
-        rateLimitInfo = parseRateLimitHeaders(headers);
+        callbacks.onRateLimit(
+          parseRateLimitHeaders(headersToRecord(response.headers)),
+        );
         return response;
       }
 
       if (response.ok && response.body) {
         const [sdkBody, quotaBody] = response.body.tee();
-        sseQuotaTask = readQuotaCommentsFromTee(quotaBody, onSseQuota);
+        // Best-effort side channel; failures inside are swallowed by the
+        // reader so quota comments can never break the SDK stream.
+        void readQuotaCommentsFromTee(quotaBody, callbacks.onSseQuota);
         return new Response(sdkBody, {
           headers: response.headers,
           status: response.status,
@@ -118,22 +103,6 @@ export function wrapNeuralwattStreamSimple(
       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;
+    return base(model, context, { ...options, fetch: neuralwattFetch });
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-neuralwatt",
-  "version": "0.16.3",
+  "version": "0.18.0",
   "license": "MIT",
   "type": "module",
   "private": false,
@@ -17,8 +17,7 @@
     "extensions": [
       "./extensions/provider/index.ts",
       "./extensions/command-quotas/index.ts",
-      "./extensions/quota-warnings/index.ts",
-      "./extensions/sub-bar-integration/index.ts"
+      "./extensions/quota-warnings/index.ts"
     ],
     "video": "https://assets.aliou.me/github/aliou/pi-neuralwatt/demo.mp4"
   },
@@ -38,21 +37,22 @@
     "@aliou/pi-utils-ui": "^0.5.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": ">=0.84.0",
-    "@earendil-works/pi-coding-agent": ">=0.84.0",
+    "@earendil-works/pi-ai": ">=1.0.0",
+    "@earendil-works/pi-coding-agent": ">=1.0.0",
     "@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.84.0",
-    "@earendil-works/pi-coding-agent": "0.84.0",
-    "@earendil-works/pi-tui": "0.84.0",
+    "@earendil-works/pi-ai": "1.1.0",
+    "@earendil-works/pi-coding-agent": "1.1.0",
+    "@earendil-works/pi-tui": "1.1.0",
     "@types/node": "^25.0.10",
     "husky": "^9.1.7",
     "ts-json-schema-generator": "^2.4.0",
     "tsx": "4.23.12",
+    "typebox": "1.3.27",
     "typescript": "^5.9.3",
     "vitest": "^4.0.18"
   },
@@ -70,8 +70,8 @@
     "test:watch": "vitest",
     "check:models": "tsx scripts/check-models.ts",
     "check:changesets": "tsx scripts/check-changesets.ts",
-    "gen:schema": "pi-settings-schema -p src/config/types.ts -t NeuralwattConfig -o schema.json --version 0.12.0",
-    "check:schema": "pi-settings-schema -p src/config/types.ts -t NeuralwattConfig -o schema.json --version 0.12.0 --check",
+    "gen:schema": "pi-settings-schema -p src/config/types.ts -t NeuralwattConfig -o schema.json",
+    "check:schema": "pi-settings-schema -p src/config/types.ts -t NeuralwattConfig -o schema.json --check",
     "check:lockfile": "pnpm install --frozen-lockfile --ignore-scripts",
     "prepare": "[ -d .git ] && husky || true",
     "changeset": "changeset",