@aliou/pi-neuralwatt 0.15.4 → 0.16.0

package/README.md

@@ -47,6 +47,15 @@ Once installed, select `neuralwatt` as your provider and choose from available m
 /model neuralwatt meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8
 ```
 
+### API surface
+
+Neuralwatt serves every model on two APIs. Pick one via `/neuralwatt:settings` → **API** (or set `provider.api` in the extension config):
+
+- `openai-completions` (default) — the OpenAI-compatible `chat/completions` endpoint;
+- `anthropic-messages` — the Anthropic-compatible `POST /v1/messages` endpoint (vLLM-backed), which streams native tool use and thinking blocks.
+
+The setting swaps the whole provider (same model ids on both sides) and applies on `/reload`. Usage/cost accounting and quota tracking work on both surfaces: per-request quota headers only exist on chat-completions responses, while `/v1/messages` streams carry the same data as `: energy` / `: cost` SSE comments.
+
 ### Quota Command
 
 Check your API usage at a glance:
@@ -74,12 +83,10 @@ When a Neuralwatt model is active, the footer status bar shows live quota usage
 
 Configure features with `/neuralwatt:settings`:
 
+- **API** — Choose between `openai-completions` (default) and `anthropic-messages`; applies on `/reload`
 - **Quota command** — Show/hide `/neuralwatt:quota`
 - **Quota warnings** — Enable/disable low quota notifications
 - **Sub-bar integration** — Show/hide usage in status bar
-- **Legacy model IDs** — Include deprecated model aliases
-- **Alias model IDs** — Include active creator-scoped model aliases
-- **Early access models** — Include pre-release models available only to the configured API key
 
 The provider itself cannot be disabled — it is always loaded.
 
@@ -87,9 +94,9 @@ Configuration uses nested per-feature sections. Existing flat config files are m
 
 ### Model Refresh
 
-Neuralwatt registers its public models without network access. When early-access models are enabled, opening `/model` refreshes the authenticated catalog in the background. `pi update --models` forces an immediate refresh.
+Neuralwatt registers its public models without network access. Opening `/model` refreshes the catalog from the API in the background (authenticated when an API key is configured). `pi update --models` forces an immediate refresh.
 
-Pi stores the complete effective Neuralwatt catalog in `~/.pi/agent/models-store.json` for offline startup. Current hardcoded public and legacy definitions remain authoritative when cached models are restored.
+Pi stores the complete effective Neuralwatt catalog in `~/.pi/agent/models-store.json` for offline startup. Current hardcoded public definitions remain authoritative when cached models are restored.
 
 ## Adding or Updating Models
 

package/extensions/provider/api/anthropic-messages.ts

@@ -0,0 +1,114 @@
+import type { StreamOptions } from "@earendil-works/pi-ai";
+import { stream, streamSimple } from "@earendil-works/pi-ai/compat";
+import {
+  NEURALWATT_BASE_URL,
+  NEURALWATT_PROVIDER_ID,
+  NEURALWATT_REQUEST_HEADERS,
+} from "../constants";
+import { buildAnthropicThinkingLevelMap } from "../models/build";
+import type { NeuralwattModel } from "../models/catalog";
+import type { AnyStreamSimple } from "../stream-simple";
+import type { NeuralwattApiHandler } from "./types";
+
+type AnthropicMessagesBody = {
+  thinking?: { type?: string };
+  output_config?: { effort?: string };
+  chat_template_kwargs?: Record<string, unknown>;
+  [key: string]: unknown;
+};
+
+// Outside vLLM's effort enum (HTTP 400); both mean "reasoning off".
+const EFFORT_OFF_VALUES = new Set(["none", "minimal"]);
+
+function applyReasoningOff(body: AnthropicMessagesBody): AnthropicMessagesBody {
+  delete body.thinking;
+  delete body.output_config;
+  body.chat_template_kwargs = {
+    ...(body.chat_template_kwargs ?? {}),
+    enable_thinking: false,
+  };
+  return body;
+}
+
+/**
+ * vLLM's reasoning controls differ from first-party Anthropic: positive levels
+ * go through `output_config.effort` (adaptive path, forced via compat) while
+ * `thinking:{type:"disabled"}` is accepted but ignored, so off is expressed
+ * through the chat-template kwarg instead.
+ */
+function makeReasoningInjector(
+  upstream?: StreamOptions["onPayload"],
+): NonNullable<StreamOptions["onPayload"]> {
+  return async (payload, model) => {
+    const next = await upstream?.(payload, model);
+    const body = (next !== undefined ? next : payload) as AnthropicMessagesBody;
+
+    if (body.thinking?.type === "disabled") {
+      return applyReasoningOff(body);
+    }
+
+    const effort = body.output_config?.effort;
+    if (effort && EFFORT_OFF_VALUES.has(effort)) {
+      return applyReasoningOff(body);
+    }
+
+    return body;
+  };
+}
+
+// The Anthropic SDK appends `/v1/messages` to the client base URL.
+function toMessagesBaseUrl(baseUrl: string): string {
+  return baseUrl.replace(/\/v1\/?$/, "");
+}
+
+function stampAnthropicModels(models: NeuralwattModel[]) {
+  return models.map((model) => {
+    const { reasoningContract, ...compiled } = model;
+    // No retained contract: the identity map is the alias-free special case.
+    const thinkingLevelMap = model.reasoning
+      ? reasoningContract
+        ? buildAnthropicThinkingLevelMap(reasoningContract)
+        : model.thinkingLevelMap
+          ? { ...model.thinkingLevelMap }
+          : undefined
+      : undefined;
+
+    return {
+      ...compiled,
+      api: "anthropic-messages" as const,
+      provider: NEURALWATT_PROVIDER_ID,
+      baseUrl: toMessagesBaseUrl(model.baseUrl ?? NEURALWATT_BASE_URL),
+      headers: NEURALWATT_REQUEST_HEADERS,
+      compat: {
+        forceAdaptiveThinking: true,
+        supportsTemperature: true,
+        supportsStrictTools: false,
+        supportsCacheControlOnTools: false,
+      },
+      ...(thinkingLevelMap ? { thinkingLevelMap } : {}),
+    };
+  });
+}
+
+export function createAnthropicMessagesApi(options?: {
+  streamSimple?: AnyStreamSimple;
+}): NeuralwattApiHandler {
+  const withReasoning = (options?: {
+    onPayload?: StreamOptions["onPayload"];
+  }) => ({
+    ...options,
+    onPayload: makeReasoningInjector(options?.onPayload),
+  });
+
+  return {
+    stampModels: stampAnthropicModels,
+    stream: (model, context, streamOptions) =>
+      stream(model, context, withReasoning(streamOptions) as never),
+    streamSimple: (model, context, simpleOptions) =>
+      (options?.streamSimple ?? streamSimple)(
+        model,
+        context,
+        withReasoning(simpleOptions) as never,
+      ),
+  };
+}

package/extensions/provider/api/openai-completions.ts

@@ -0,0 +1,30 @@
+import { stream, streamSimple } from "@earendil-works/pi-ai/compat";
+import {
+  NEURALWATT_BASE_URL,
+  NEURALWATT_PROVIDER_ID,
+  NEURALWATT_REQUEST_HEADERS,
+} from "../constants";
+import type { NeuralwattModel } from "../models/catalog";
+import type { AnyStreamSimple } from "../stream-simple";
+import type { NeuralwattApiHandler } from "./types";
+
+export function createOpenAiCompletionsApi(options?: {
+  streamSimple?: AnyStreamSimple;
+}): NeuralwattApiHandler {
+  return {
+    stampModels: (models: NeuralwattModel[]) =>
+      models.map((model) => {
+        const { reasoningContract: _reasoningContract, ...compiled } = model;
+        return {
+          ...compiled,
+          api: "openai-completions" as const,
+          provider: NEURALWATT_PROVIDER_ID,
+          baseUrl: model.baseUrl ?? NEURALWATT_BASE_URL,
+          headers: NEURALWATT_REQUEST_HEADERS,
+        };
+      }),
+    stream: (model, context, streamOptions) =>
+      stream(model, context, streamOptions as never),
+    streamSimple: options?.streamSimple ?? streamSimple,
+  };
+}

package/extensions/provider/api/types.ts

@@ -0,0 +1,24 @@
+import type {
+  Api,
+  AssistantMessageEventStream,
+  Context,
+  Model,
+  SimpleStreamOptions,
+  StreamOptions,
+} from "@earendil-works/pi-ai";
+import type { NeuralwattModel } from "../models/catalog";
+
+/** One Neuralwatt API surface: model stamping plus submission plumbing. */
+export interface NeuralwattApiHandler {
+  stampModels(models: NeuralwattModel[]): Model<Api>[];
+  stream(
+    model: Model<Api>,
+    context: Context,
+    options?: StreamOptions,
+  ): AssistantMessageEventStream;
+  streamSimple(
+    model: Model<Api>,
+    context: Context,
+    options?: SimpleStreamOptions,
+  ): AssistantMessageEventStream;
+}

package/extensions/provider/commands/settings/index.ts

@@ -6,6 +6,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { SettingItem } from "@earendil-works/pi-tui";
 import {
   configLoader,
+  type NeuralwattApi,
   type NeuralwattConfig,
   type ResolvedNeuralwattConfig,
 } from "../../../../src/config";
@@ -61,6 +62,9 @@ export function registerNeuralwattSettings(
   options: RegisterNeuralwattSettingsOptions,
 ): void {
   const { getLoadedFeatures } = options;
+  // The provider stamps `provider.api` at extension load; a saved change only
+  // reaches it after `/reload`.
+  let pendingApi: NeuralwattApi | undefined;
 
   registerSettingsCommand<NeuralwattConfig, ResolvedNeuralwattConfig>(pi, {
     commandName: "neuralwatt:settings",
@@ -69,6 +73,19 @@ export function registerNeuralwattSettings(
     buildSections: (tabConfig, resolved): SettingsSection[] => {
       const loaded = getLoadedFeatures();
       return [
+        {
+          label: "Provider",
+          items: [
+            {
+              id: "api",
+              label: "API",
+              description:
+                "Serve models via the OpenAI-compatible chat/completions endpoint or the Anthropic-compatible /v1/messages endpoint",
+              currentValue: tabConfig?.provider?.api ?? resolved.provider.api,
+              values: ["openai-completions", "anthropic-messages"],
+            },
+          ],
+        },
         {
           label: "Features",
           items: [
@@ -107,6 +124,20 @@ export function registerNeuralwattSettings(
       ];
     },
     onSettingChange: (id, newValue, config) => {
+      if (id === "api") {
+        if (
+          newValue !== "openai-completions" &&
+          newValue !== "anthropic-messages"
+        ) {
+          return null;
+        }
+        pendingApi = newValue;
+        return {
+          ...config,
+          provider: { ...config.provider, api: newValue },
+        };
+      }
+
       if (!getLoadedFeatures().has(id as NeuralwattFeatureId)) {
         return null;
       }
@@ -132,8 +163,11 @@ export function registerNeuralwattSettings(
           return null;
       }
     },
-    onSave: async () => {
+    onSave: async (ctx) => {
       emitConfigUpdated(pi);
+      if (pendingApi === undefined) return;
+      pendingApi = undefined;
+      ctx.ui.notify("Run /reload to apply the new API", "info");
     },
   });
 }

package/extensions/provider/constants.ts

@@ -0,0 +1,7 @@
+export const NEURALWATT_PROVIDER_ID = "neuralwatt";
+export const NEURALWATT_BASE_URL = "https://api.neuralwatt.com/v1";
+export const NEURALWATT_API_KEY_ENV = "NEURALWATT_API_KEY";
+export const NEURALWATT_REQUEST_HEADERS = {
+  Referer: "https://pi.dev",
+  "X-Title": "npm:@aliou/pi-neuralwatt",
+};

package/extensions/provider/index.ts

@@ -55,6 +55,15 @@ function registerNeuralwattProvider(
       ) as never)
     : undefined;
 
+  const messagesApiProvider = getApiProvider("anthropic-messages");
+  const messagesBaseStreamSimple = messagesApiProvider?.streamSimple;
+  const messagesStreamSimple = messagesBaseStreamSimple
+    ? (wrapNeuralwattStreamSimple(
+        messagesBaseStreamSimple as never,
+        onSseQuota,
+      ) as never)
+    : undefined;
+
   pi.registerProvider(
     createNeuralwattProvider(
       staticModels,
@@ -65,7 +74,11 @@ function registerNeuralwattProvider(
         }
         return result.data;
       },
-      streamSimple,
+      {
+        api: configLoader.getConfig().provider.api,
+        openAiStreamSimple: streamSimple,
+        messagesStreamSimple,
+      },
     ),
   );
 }

package/extensions/provider/models/build.ts

@@ -8,6 +8,15 @@ export type ThinkingLevelMap = NonNullable<
   ProviderModelConfig["thinkingLevelMap"]
 >;
 
+/**
+ * A compiled provider model plus the reasoning contract it was compiled from,
+ * retained for anthropic-messages map derivation. Rides the models store
+ * (JSON passthrough); stripped from stamped runtime models.
+ */
+export type NeuralwattCompiledModel = ProviderModelConfig & {
+  reasoningContract?: NeuralwattReasoningMapSource;
+};
+
 export interface NeuralwattCost {
   input: number;
   output: number;
@@ -56,7 +65,7 @@ export interface NeuralwattVariantSpec {
  */
 export type NeuralwattReasoningMapSource = Pick<
   NeuralwattApiModelReasoning,
-  "supported_efforts" | "mandatory"
+  "supported_efforts" | "mandatory" | "effort_aliases"
 >;
 
 /**
@@ -71,9 +80,9 @@ export type NeuralwattReasoningMapSource = Pick<
  * exposes none), falls back to a conservative `high`-only map with `off: null`,
  * matching the upstream binary thinking toggle.
  *
- * `default_effort` and `effort_aliases` are deliberately ignored: Pi has no
- * default-reasoning field, and we expose native supported efforts rather than
- * aliasing unsupported ones.
+ * `effort_aliases` is deliberately ignored here (the openai-completions
+ * gateway aliases unsupported efforts server-side); it is consumed by the
+ * anthropic-messages map below.
  */
 export function buildThinkingLevelMap(
   reasoning: NeuralwattReasoningMapSource | undefined,
@@ -96,6 +105,39 @@ export function buildThinkingLevelMap(
   };
 }
 
+/**
+ * Thinking level map for the anthropic-messages surface. vLLM's
+ * `output_config.effort` accepts only the model's native efforts, so
+ * unsupported Pi levels resolve through `effort_aliases` (or `null`). A level
+ * may resolve to `"none"` — off on this surface, handled by the payload
+ * injector in `api/anthropic-messages.ts`.
+ */
+export function buildAnthropicThinkingLevelMap(
+  reasoning: NeuralwattReasoningMapSource | undefined,
+): ThinkingLevelMap {
+  const supported = new Set<string>(reasoning?.supported_efforts ?? ["high"]);
+  const mandatory = reasoning?.mandatory ?? true;
+  const aliases = reasoning?.effort_aliases ?? {};
+
+  const resolve = (level: string): string | null => {
+    if (supported.has(level)) return level;
+    const alias = aliases[level as keyof typeof aliases];
+    return alias && supported.has(alias) ? alias : null;
+  };
+
+  return {
+    // "none" is a marker so pi-ai enables the off path (off !== null);
+    // vLLM rejects it on the wire, so the injector never sends it verbatim.
+    off: !mandatory && supported.has("none") ? "none" : null,
+    minimal: resolve("minimal"),
+    low: resolve("low"),
+    medium: resolve("medium"),
+    high: resolve("high"),
+    xhigh: resolve("xhigh"),
+    max: resolve("max"),
+  };
+}
+
 /**
  * Neuralwatt reports `max_output_tokens: null` for models whose output is only
  * bounded by the context window. Some models incorrectly report 0; treat 0
@@ -112,7 +154,7 @@ export function resolveMaxTokens(
 export function buildNeuralwattModel(
   family: NeuralwattModelFamily,
   variant: NeuralwattVariantSpec,
-): ProviderModelConfig {
+): NeuralwattCompiledModel {
   const vision = variant.vision ?? family.vision;
 
   const compat: NonNullable<ProviderModelConfig["compat"]> = {
@@ -127,7 +169,7 @@ export function buildNeuralwattModel(
   const scale = (value: number): number =>
     multiplier === 1 ? value : Number((value * multiplier).toFixed(6));
 
-  const model: ProviderModelConfig = {
+  const model: NeuralwattCompiledModel = {
     id: variant.id,
     name: variant.name,
     reasoning: variant.reasoning,
@@ -144,14 +186,14 @@ export function buildNeuralwattModel(
   };
 
   if (variant.reasoning) {
+    const contract = variant.reasoningMetadata ?? family.reasoningMetadata;
     // Clone so variants never share a family map instance. The map is derived
     // from the API reasoning contract; missing metadata falls back to a
     // high-only map rather than throwing.
     model.thinkingLevelMap = {
-      ...buildThinkingLevelMap(
-        variant.reasoningMetadata ?? family.reasoningMetadata,
-      ),
+      ...buildThinkingLevelMap(contract),
     };
+    model.reasoningContract = contract;
   }
 
   return model;
@@ -160,6 +202,6 @@ export function buildNeuralwattModel(
 export function buildNeuralwattFamily(
   family: NeuralwattModelFamily,
   variants: NeuralwattVariantSpec[],
-): ProviderModelConfig[] {
+): NeuralwattCompiledModel[] {
   return variants.map((variant) => buildNeuralwattModel(family, variant));
 }

package/extensions/provider/models/catalog.ts

@@ -2,12 +2,13 @@ import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
 import type { NeuralwattApiModel } from "../../../src/types/models-api";
 import {
   buildThinkingLevelMap,
+  type NeuralwattCompiledModel,
   resolveMaxTokens,
   type ThinkingLevelMap,
 } from "./build";
 import { NEURALWATT_MODELS } from "./public-models";
 
-export type NeuralwattModel = ProviderModelConfig;
+export type NeuralwattModel = NeuralwattCompiledModel;
 
 // Chat-template thinking: the API exposes a `reasoning` block, but the
 // underlying mechanism is chat_template_kwargs, so Pi needs the mapping.
@@ -22,16 +23,6 @@ const COMPAT_OVERRIDES: Partial<
   },
 };
 
-const HARDCODED_ALIASES: Record<string, string> = {
-  "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 isVariantId(id: string): boolean {
-  return id.includes("-fast") || id.includes("-flex") || id.includes("-short");
-}
-
 function apiModelToProviderModel(model: NeuralwattApiModel): NeuralwattModel {
   const meta = model.metadata;
   if (!meta)
@@ -72,44 +63,14 @@ function apiModelToProviderModel(model: NeuralwattApiModel): NeuralwattModel {
     result.thinkingLevelMap = buildThinkingLevelMap(
       meta.reasoning,
     ) as ThinkingLevelMap;
+    // Kept for anthropic-messages stamping, which resolves levels through
+    // `effort_aliases`.
+    result.reasoningContract = meta.reasoning;
   }
 
   return result;
 }
 
-function buildAliases(
-  models: NeuralwattModel[],
-  apiModels: readonly NeuralwattApiModel[],
-): NeuralwattModel[] {
-  const existingIds = new Set(models.map((m) => m.id));
-  const aliases: NeuralwattModel[] = [];
-  const seen = new Set<string>();
-
-  const addAlias = (aliasId: string, canonicalId: string): void => {
-    if (seen.has(aliasId) || existingIds.has(aliasId)) return;
-    const canonical = models.find((m) => m.id === canonicalId);
-    if (!canonical) return;
-    seen.add(aliasId);
-    aliases.push({
-      ...canonical,
-      id: aliasId,
-      name: `${canonical.name} (alias ID)`,
-    });
-  };
-
-  for (const [aliasId, canonicalId] of Object.entries(HARDCODED_ALIASES)) {
-    addAlias(aliasId, canonicalId);
-  }
-
-  for (const apiModel of apiModels) {
-    const hfId = apiModel.metadata?.huggingface_id;
-    if (!hfId || hfId === apiModel.id || isVariantId(apiModel.id)) continue;
-    addAlias(hfId, apiModel.id);
-  }
-
-  return aliases;
-}
-
 export function buildNeuralwattProviderModels(): NeuralwattModel[] {
   return NEURALWATT_MODELS.map((model) => ({ ...model }));
 }
@@ -130,7 +91,7 @@ export function buildNeuralwattProviderModelsFromApi(
         ),
     )
     .map(apiModelToProviderModel);
-  return [...models, ...buildAliases(models, apiModels)];
+  return models;
 }
 
 export function buildNeuralwattProviderModelsFromStore(

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

@@ -127,6 +127,13 @@ const FAMILIES: [NeuralwattModelFamily, NeuralwattVariantSpec[]][] = [
         reasoning: true,
         costMultiplier: 0.65,
       },
+      {
+        id: "deepseek-v4-flash-speed",
+        name: "DeepSeek V4 Flash (Speed)",
+        contextWindow: 1048560,
+        maxOutputTokens: 65536,
+        reasoning: true,
+      },
     ],
   ],
   [

package/extensions/provider/provider.ts

@@ -1,10 +1,14 @@
-import type {
-  Api,
-  Model,
-  Provider,
-  ProviderStreamOptions,
-} from "@earendil-works/pi-ai";
-import { stream, streamSimple } from "@earendil-works/pi-ai/compat";
+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 type { NeuralwattApiHandler } from "./api/types";
+import {
+  NEURALWATT_API_KEY_ENV,
+  NEURALWATT_BASE_URL,
+  NEURALWATT_PROVIDER_ID,
+  NEURALWATT_REQUEST_HEADERS,
+} from "./constants";
 import type { NeuralwattModel } from "./models/catalog";
 import {
   buildNeuralwattProviderModelsFromApi,
@@ -16,33 +20,39 @@ import {
 } from "./models/refresh";
 import type { AnyStreamSimple } from "./stream-simple";
 
-export const NEURALWATT_PROVIDER_ID = "neuralwatt";
-export const NEURALWATT_BASE_URL = "https://api.neuralwatt.com/v1";
-export const NEURALWATT_API_KEY_ENV = "NEURALWATT_API_KEY";
-
-const NEURALWATT_REQUEST_HEADERS = {
-  Referer: "https://pi.dev",
-  "X-Title": "npm:@aliou/pi-neuralwatt",
-};
+export { NEURALWATT_API_KEY_ENV, NEURALWATT_BASE_URL, NEURALWATT_PROVIDER_ID };
 
-const API = "openai-completions" as const;
+export interface NeuralwattProviderOptions {
+  /** Active API surface; resolved once. Changes need a `/reload`. */
+  api?: NeuralwattApi;
+  openAiStreamSimple?: AnyStreamSimple;
+  messagesStreamSimple?: AnyStreamSimple;
+}
 
-function toProviderModels(models: NeuralwattModel[]): Model<Api>[] {
-  return models.map((model) => ({
-    ...model,
-    api: model.api ?? API,
-    provider: NEURALWATT_PROVIDER_ID,
-    baseUrl: model.baseUrl ?? NEURALWATT_BASE_URL,
-    headers: NEURALWATT_REQUEST_HEADERS,
-  }));
+function createApiHandler(
+  api: NeuralwattApi,
+  options?: NeuralwattProviderOptions,
+): NeuralwattApiHandler {
+  if (api === "anthropic-messages") {
+    return createAnthropicMessagesApi({
+      streamSimple: options?.messagesStreamSimple,
+    });
+  }
+  return createOpenAiCompletionsApi({
+    streamSimple: options?.openAiStreamSimple,
+  });
 }
 
 export function createNeuralwattProvider(
   staticModels: NeuralwattModel[],
   fetchApiModels: FetchNeuralwattApiModels,
-  streamSimpleOverride?: AnyStreamSimple,
+  options?: NeuralwattProviderOptions,
 ): Provider {
-  let liveModels = toProviderModels(staticModels);
+  const handler = createApiHandler(
+    options?.api ?? "openai-completions",
+    options,
+  );
+  let canonicalModels = staticModels;
   const refreshCatalog = createNeuralwattRefreshModels(
     staticModels,
     fetchApiModels,
@@ -92,17 +102,18 @@ export function createNeuralwattProvider(
         },
       },
     },
-    getModels: () => liveModels,
+    getModels: () => handler.stampModels(canonicalModels),
     refreshModels: async (context) => {
       const models = await refreshCatalog(context);
       await context.publish({
         update: () => {
-          liveModels = toProviderModels(models);
+          canonicalModels = models;
         },
       });
     },
-    stream: (model, context, options) =>
-      stream(model, context, options as ProviderStreamOptions | undefined),
-    streamSimple: streamSimpleOverride ?? streamSimple,
+    stream: (model, context, streamOptions) =>
+      handler.stream(model, context, streamOptions as never),
+    streamSimple: (model, context, simpleOptions) =>
+      handler.streamSimple(model, context, simpleOptions),
   };
 }

package/extensions/provider/sse-quotas.ts

@@ -31,13 +31,26 @@ export function updateQuotasFromSseComment(
     if (trimmed.startsWith(": cost ")) {
       const cost = JSON.parse(trimmed.slice(7)) as {
         request_cost_usd?: number;
+        allowance_remaining_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,
-      );
+      // The absolute allowance in the comment is fresher than the locally
+      // tracked total.
+      if (
+        typeof cost.allowance_remaining_usd === "number" &&
+        Number.isFinite(cost.allowance_remaining_usd)
+      ) {
+        next.balance.credits_remaining_usd = Math.max(
+          0,
+          cost.allowance_remaining_usd,
+        );
+      } else {
+        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;

package/extensions/provider/stream-simple.ts

@@ -35,7 +35,7 @@ function headersToRecord(headers: Headers): Record<string, string> {
   return record;
 }
 
-function isProviderChatCompletionsUrl(
+function isProviderStreamUrl(
   input: RequestInfo | URL,
   providerOrigin: string,
 ): boolean {
@@ -50,7 +50,8 @@ function isProviderChatCompletionsUrl(
     const url = new URL(rawUrl);
     return (
       url.origin === providerOrigin &&
-      url.pathname.endsWith("/chat/completions")
+      (url.pathname.endsWith("/chat/completions") ||
+        url.pathname.endsWith("/messages"))
     );
   } catch {
     return false;
@@ -96,7 +97,7 @@ export function wrapNeuralwattStreamSimple(
     const wrappedFetch: typeof fetch = async (input, init) => {
       const response = await originalFetch(input, init);
 
-      if (!isProviderChatCompletionsUrl(input, providerOrigin)) return response;
+      if (!isProviderStreamUrl(input, providerOrigin)) return response;
 
       const headers = headersToRecord(response.headers);
       if (response.status === 429) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-neuralwatt",
-  "version": "0.15.4",
+  "version": "0.16.0",
   "license": "MIT",
   "type": "module",
   "private": false,
@@ -69,6 +69,7 @@
     "test": "vitest run",
     "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",
     "check:lockfile": "pnpm install --frozen-lockfile --ignore-scripts",

package/schema.json

@@ -20,6 +20,10 @@
           "$ref": "#/definitions/NeuralwattSubBarIntegrationConfig",
           "description": "Sub-bar/status-bar integration feature."
         },
+        "provider": {
+          "$ref": "#/definitions/NeuralwattProviderConfig",
+          "description": "Provider behavior (API surface)."
+        },
         "version": {
           "anyOf": [
             {
@@ -65,6 +69,24 @@
         }
       },
       "additionalProperties": false
+    },
+    "NeuralwattProviderConfig": {
+      "type": "object",
+      "properties": {
+        "api": {
+          "$ref": "#/definitions/NeuralwattApi",
+          "description": "Which API serves model requests."
+        }
+      },
+      "additionalProperties": false
+    },
+    "NeuralwattApi": {
+      "type": "string",
+      "enum": [
+        "openai-completions",
+        "anthropic-messages"
+      ],
+      "description": "Neuralwatt serves every chat model twice: on an OpenAI-compatible `chat/completions` endpoint and on a vLLM-backed Anthropic-compatible `POST /v1/messages` endpoint. Exactly one serves the provider at a time."
     }
   }
 }

package/src/config/defaults.ts

@@ -10,4 +10,7 @@ export const DEFAULT_CONFIG: ResolvedNeuralwattConfig = {
   subBarIntegration: {
     enabled: true,
   },
+  provider: {
+    api: "openai-completions",
+  },
 };

package/src/config/index.ts

@@ -1,4 +1,8 @@
 export { DEFAULT_CONFIG } from "./defaults";
-export { configLoader } from "./loader";
+export { configLoader, resolveApi } from "./loader";
 export { migrations } from "./migration";
-export type { NeuralwattConfig, ResolvedNeuralwattConfig } from "./types";
+export type {
+  NeuralwattApi,
+  NeuralwattConfig,
+  ResolvedNeuralwattConfig,
+} from "./types";

package/src/config/loader.ts

@@ -2,7 +2,11 @@ import { buildSchemaUrl, ConfigLoader } from "@aliou/pi-utils-settings";
 import packageJson from "../../package.json";
 import { DEFAULT_CONFIG } from "./defaults";
 import { migrations } from "./migration";
-import type { NeuralwattConfig, ResolvedNeuralwattConfig } from "./types";
+import type {
+  NeuralwattApi,
+  NeuralwattConfig,
+  ResolvedNeuralwattConfig,
+} from "./types";
 
 /**
  * Fill in every field the rest of the code reads. Migrations already normalized
@@ -27,9 +31,19 @@ function normalizeResolvedConfig(
         config.subBarIntegration?.enabled ??
         DEFAULT_CONFIG.subBarIntegration.enabled,
     },
+    provider: {
+      api: resolveApi(config.provider?.api),
+    },
   };
 }
 
+export function resolveApi(value: string | undefined): NeuralwattApi {
+  if (value === "anthropic-messages" || value === "openai-completions") {
+    return value;
+  }
+  return DEFAULT_CONFIG.provider.api;
+}
+
 export const configLoader = new ConfigLoader<
   NeuralwattConfig,
   ResolvedNeuralwattConfig

package/src/config/migration/index.ts

@@ -6,11 +6,9 @@ export {
   flatToNestedConfigMigration,
 } from "./02-flat-to-nested-config";
 export { renameHiddenToEarlyAccessMigration } from "./03-rename-hidden-to-early-access";
-export { enableAliasesForLegacyUsersMigration } from "./04-enable-aliases-for-legacy-users";
 
 import { flatToNestedConfigMigration } from "./02-flat-to-nested-config";
 import { renameHiddenToEarlyAccessMigration } from "./03-rename-hidden-to-early-access";
-import { enableAliasesForLegacyUsersMigration } from "./04-enable-aliases-for-legacy-users";
 
 // Each migration is typed against its own historical input shape. The loader
 // applies them in sequence on the raw config record, so they are cast to the
@@ -18,5 +16,4 @@ import { enableAliasesForLegacyUsersMigration } from "./04-enable-aliases-for-le
 export const migrations = [
   flatToNestedConfigMigration,
   renameHiddenToEarlyAccessMigration,
-  enableAliasesForLegacyUsersMigration,
 ] as unknown as Migration<NeuralwattConfig>[];

package/src/config/types.ts

@@ -13,6 +13,18 @@ export interface NeuralwattSubBarIntegrationConfig {
   enabled?: boolean;
 }
 
+/**
+ * Neuralwatt serves every chat model twice: on an OpenAI-compatible
+ * `chat/completions` endpoint and on a vLLM-backed Anthropic-compatible
+ * `POST /v1/messages` endpoint. Exactly one serves the provider at a time.
+ */
+export type NeuralwattApi = "openai-completions" | "anthropic-messages";
+
+export interface NeuralwattProviderConfig {
+  /** Which API serves model requests. */
+  api?: NeuralwattApi;
+}
+
 export interface NeuralwattConfig {
   /** $schema URL for editor autocomplete. */
   $schema?: string;
@@ -25,6 +37,9 @@ export interface NeuralwattConfig {
 
   /** Sub-bar/status-bar integration feature. */
   subBarIntegration?: NeuralwattSubBarIntegrationConfig;
+
+  /** Provider behavior (API surface). */
+  provider?: NeuralwattProviderConfig;
 }
 
 export interface ResolvedNeuralwattConfig {
@@ -37,4 +52,7 @@ export interface ResolvedNeuralwattConfig {
   subBarIntegration: {
     enabled: boolean;
   };
+  provider: {
+    api: NeuralwattApi;
+  };
 }

package/src/types/models-api.ts

@@ -38,14 +38,11 @@ export type NeuralwattReasoningEffort =
   | "max";
 
 /**
- * Per-model reasoning contract from `/v1/models`.
- *
- * `supported_efforts` is authoritative for which Pi thinking levels to expose:
- * the Pi map is built by identity (a level is enabled iff it appears here),
- * see `buildThinkingLevelMap` in `extensions/provider/models/build.ts`.
- * `default_effort` and `effort_aliases` are typed for fidelity but are not
- * consumed — Pi has no default-reasoning field and we expose native efforts
- * rather than aliasing unsupported ones.
+ * Per-model reasoning contract from `/v1/models`. The openai-completions
+ * thinking map uses `supported_efforts` by identity; the anthropic-messages
+ * map additionally resolves through `effort_aliases` (vLLM's effort enum
+ * accepts only native values). `default_enabled`/`default_effort` are typed
+ * for fidelity but not consumed.
  */
 export interface NeuralwattApiModelReasoning {
   /** Whether the model reasons by default. */
@@ -58,7 +55,10 @@ export interface NeuralwattApiModelReasoning {
   accepted_efforts?: NeuralwattReasoningEffort[];
   /** Server-side default. Not consumed; Pi has no default-reasoning field. */
   default_effort: NeuralwattReasoningEffort;
-  /** Wire-level aliases from accepted to supported efforts. Not consumed. */
+  /**
+   * Wire-level aliases from accepted to supported efforts. Consumed by the
+   * anthropic-messages thinking level map; ignored by openai-completions.
+   */
   effort_aliases?: Partial<
     Record<NeuralwattReasoningEffort, NeuralwattReasoningEffort>
   >;

package/src/config/migration/04-enable-aliases-for-legacy-users.ts

@@ -1,41 +0,0 @@
-import type { Migration } from "@aliou/pi-utils-settings";
-
-/** Nested config shape before aliases were split out (pre-0.11.0). */
-interface PreAliasNeuralwattConfig {
-  $schema?: string;
-  provider?: {
-    includeLegacyModelIds?: boolean;
-    includeAliasedModelIds?: boolean;
-    includeEarlyAccessModels?: boolean;
-  };
-  quotaCommand?: { enabled?: boolean };
-  quotaWarnings?: { enabled?: boolean };
-  subBarIntegration?: { enabled?: boolean };
-}
-
-/**
- * Creator-scoped active model IDs were split out of the legacy model ID setting.
- * Preserve behavior for users who had explicitly enabled legacy model IDs.
- */
-export const enableAliasesForLegacyUsersMigration: Migration<PreAliasNeuralwattConfig> =
-  {
-    name: "enable-alias-model-ids-for-legacy-users",
-    version: "0.11.0",
-    shouldRun: (config) =>
-      config.provider?.includeLegacyModelIds === true &&
-      config.provider?.includeAliasedModelIds === undefined,
-    message:
-      "[neuralwatt] active model aliases now use `provider.includeAliasedModelIds`; it was enabled because legacy model IDs were enabled.",
-    run: (config) => {
-      const provider = config.provider;
-      if (!provider) return config;
-
-      return {
-        ...config,
-        provider: {
-          ...provider,
-          includeAliasedModelIds: true,
-        },
-      };
-    },
-  };