@aliou/pi-neuralwatt 0.16.2 → 0.17.0

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.
@@ -116,6 +116,62 @@ const KIMI_K2_7_CODE: NeuralwattModelFamily = {
   },
 };
 
+// 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`.
+const MIMO_V2_6_PRO: NeuralwattModelFamily = {
+  cost: { input: 0.87, output: 1.74, cacheRead: 0.036 },
+  vision: true,
+  reasoningMetadata: {
+    supported_efforts: ["high", "none"],
+    mandatory: false,
+    effort_aliases: {
+      max: "high",
+      xhigh: "high",
+      medium: "high",
+      low: "high",
+      minimal: "none",
+    },
+  },
+};
+
+// Neuralwatt tracking alias: the current large model, today Kimi K3. The
+// alias moves to newer models over time, so it snapshots K3's contract
+// instead of sharing the KIMI_K3 family.
+const NW_LARGE: NeuralwattModelFamily = {
+  cost: { input: 3, output: 15, cacheRead: 0.3 },
+  vision: true,
+  reasoningMetadata: {
+    supported_efforts: ["max", "high", "low", "none"],
+    mandatory: false,
+    effort_aliases: { xhigh: "max", medium: "high", minimal: "low" },
+  },
+};
+
+// Neuralwatt tracking alias: the current cheap, fast model, today DeepSeek
+// V4.1 Flash. Same moving-alias caveat as NW_LARGE.
+const NW_FLASH: NeuralwattModelFamily = {
+  cost: { input: 0.15, output: 0.6, cacheRead: 0.015 },
+  vision: true,
+  reasoningMetadata: {
+    supported_efforts: ["max", "xhigh", "high", "low", "none"],
+    mandatory: false,
+    effort_aliases: { medium: "high", minimal: "low" },
+  },
+};
+
+// Neuralwatt tracking alias: the current small model, today Qwen3.8-27B.
+// Same moving-alias caveat as NW_LARGE.
+const NW_SMALL: NeuralwattModelFamily = {
+  cost: { input: 0.45, output: 3.2, cacheRead: 0.25 },
+  vision: true,
+  reasoningMetadata: {
+    supported_efforts: ["xhigh", "medium", "low", "none"],
+    mandatory: false,
+    effort_aliases: { max: "xhigh", high: "xhigh", minimal: "low" },
+  },
+};
+
 // Qwen. Qwen3.6 35B only advertises `high` and `none`.
 const QWEN_3_6_35B: NeuralwattModelFamily = {
   cost: { input: 0.29, output: 1.15, cacheRead: 0.029 },
@@ -192,6 +248,13 @@ const FAMILIES: [NeuralwattModelFamily, NeuralwattVariantSpec[]][] = [
         reasoning: true,
         costMultiplier: 0.65,
       },
+      {
+        id: "deepseek-v4.1-flash-speed",
+        name: "DeepSeek V4.1 Flash (Speed)",
+        contextWindow: 1048560,
+        maxOutputTokens: 393216,
+        reasoning: true,
+      },
     ],
   ],
   [
@@ -302,6 +365,86 @@ const FAMILIES: [NeuralwattModelFamily, NeuralwattVariantSpec[]][] = [
       },
     ],
   ],
+  [
+    MIMO_V2_6_PRO,
+    [
+      {
+        id: "mimo-v2.6-pro",
+        name: "MiMo-V2.6-Pro",
+        contextWindow: 1048560,
+        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,
+      },
+    ],
+  ],
+  [
+    NW_LARGE,
+    [
+      {
+        id: "nw-large",
+        name: "Neuralwatt Large",
+        contextWindow: 1048560,
+        maxOutputTokens: null,
+        reasoning: true,
+      },
+      {
+        id: "nw-large-flex",
+        name: "Neuralwatt Large (flex)",
+        contextWindow: 1048560,
+        maxOutputTokens: null,
+        reasoning: true,
+        costMultiplier: 0.65,
+      },
+    ],
+  ],
+  [
+    NW_FLASH,
+    [
+      {
+        id: "nw-flash",
+        name: "Neuralwatt Flash",
+        contextWindow: 1048560,
+        maxOutputTokens: 393216,
+        reasoning: true,
+      },
+      {
+        id: "nw-flash-flex",
+        name: "Neuralwatt Flash (flex)",
+        contextWindow: 1048560,
+        maxOutputTokens: 393216,
+        reasoning: true,
+        costMultiplier: 0.65,
+      },
+    ],
+  ],
+  [
+    NW_SMALL,
+    [
+      {
+        id: "nw-small",
+        name: "Neuralwatt Small",
+        contextWindow: 262128,
+        maxOutputTokens: 131072,
+        reasoning: true,
+      },
+      {
+        id: "nw-small-flex",
+        name: "Neuralwatt Small (flex)",
+        contextWindow: 262128,
+        maxOutputTokens: 131072,
+        reasoning: true,
+        costMultiplier: 0.65,
+      },
+    ],
+  ],
   [
     QWEN_3_6_35B,
     [
@@ -357,6 +500,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.2",
+  "version": "0.17.0",
   "license": "MIT",
   "type": "module",
   "private": false,
@@ -38,21 +38,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"
   },

package/schema.json

@@ -76,6 +76,10 @@
         "api": {
           "$ref": "#/definitions/NeuralwattApi",
           "description": "Which API serves model requests."
+        },
+        "apiBaseUrl": {
+          "type": "string",
+          "description": "Fallback base URL for Neuralwatt API calls, used only by models that carry no baseUrl of their own (models.json, custom providers, and proxy routing all take precedence) and by the extension's own catalog and quota fetches. Defaults to the direct upstream."
         }
       },
       "additionalProperties": false

package/src/config/defaults.ts

@@ -1,5 +1,7 @@
 import type { ResolvedNeuralwattConfig } from "./types";
 
+export const NEURALWATT_API_BASE_URL = "https://api.neuralwatt.com/v1";
+
 export const DEFAULT_CONFIG: ResolvedNeuralwattConfig = {
   quotaCommand: {
     enabled: true,
@@ -12,5 +14,6 @@ export const DEFAULT_CONFIG: ResolvedNeuralwattConfig = {
   },
   provider: {
     api: "openai-completions",
+    apiBaseUrl: NEURALWATT_API_BASE_URL,
   },
 };