@aliou/pi-neuralwatt 0.12.1 → 0.14.0

package/extensions/provider/index.ts

@@ -18,7 +18,8 @@ import type { NeuralwattQuotas } from "../../src/types/quota-api";
 import { getNeuralwattApiKey } from "../_shared/auth";
 import { registerNeuralwattSettings } from "./commands/settings";
 import { normalizeNeuralwattContextOverflowError } from "./context-overflow";
-import { getNeuralwattModels, refreshNeuralwattModels } from "./models";
+import { getNeuralwattModels } from "./models";
+import { createNeuralwattProvider } from "./provider";
 import { buildQuotasFromHeaders, fetchRequestedQuotas } from "./quota-store";
 import {
   type NeuralwattRateLimitInfo,
@@ -42,24 +43,24 @@ function registerNeuralwattProvider(
 ): void {
   const { provider: providerConfig } = configLoader.getConfig();
 
-  const models = getNeuralwattModels({
+  const staticModels = getNeuralwattModels({
     includeLegacyModelIds: providerConfig.includeLegacyModelIds,
     includeAliasedModelIds: providerConfig.includeAliasedModelIds,
   });
 
-  const config: Parameters<ExtensionAPI["registerProvider"]>[1] = {
-    name: "Neuralwatt",
-    baseUrl: "https://api.neuralwatt.com/v1",
-    apiKey: "$NEURALWATT_API_KEY",
-    api: "openai-completions",
-    authHeader: true,
-    headers: {
-      Referer: "https://pi.dev",
-      "X-Title": "npm:@aliou/pi-neuralwatt",
-    },
-    models,
-    refreshModels: (context) =>
-      refreshNeuralwattModels(context, {
+  const apiProvider = getApiProvider("openai-completions");
+  const baseStreamSimple = apiProvider?.streamSimple;
+  const streamSimple = baseStreamSimple
+    ? (wrapNeuralwattStreamSimple(
+        baseStreamSimple as never,
+        onSseQuota,
+      ) as never)
+    : undefined;
+
+  pi.registerProvider(
+    createNeuralwattProvider(
+      staticModels,
+      () => ({
         includeLegacyModelIds:
           configLoader.getConfig().provider.includeLegacyModelIds,
         includeAliasedModelIds:
@@ -67,18 +68,9 @@ function registerNeuralwattProvider(
         includeEarlyAccessModels:
           configLoader.getConfig().provider.includeEarlyAccessModels,
       }),
-  };
-
-  const provider = getApiProvider("openai-completions");
-  const baseStreamSimple = provider?.streamSimple;
-  if (baseStreamSimple) {
-    config.streamSimple = wrapNeuralwattStreamSimple(
-      baseStreamSimple as never,
-      onSseQuota,
-    ) as never;
-  }
-
-  pi.registerProvider("neuralwatt", config);
+      streamSimple,
+    ),
+  );
 }
 
 export default async function (pi: ExtensionAPI) {

package/extensions/provider/models/build.ts

@@ -1,4 +1,8 @@
 import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
+import type {
+  NeuralwattApiModelReasoning,
+  NeuralwattReasoningEffort,
+} from "../../../src/types/models-api";
 
 export type ThinkingLevelMap = NonNullable<
   ProviderModelConfig["thinkingLevelMap"]
@@ -26,8 +30,11 @@ export interface NeuralwattCost {
 export interface NeuralwattModelFamily {
   cost: NeuralwattCost;
   vision: boolean;
-  /** Thinking levels used by reasoning variants of this family. */
-  thinkingLevelMap?: ThinkingLevelMap;
+  /**
+   * Reasoning contract snapshot from `/v1/models` for reasoning variants.
+   * `buildThinkingLevelMap` turns it into the Pi thinking level map.
+   */
+  reasoningMetadata?: NeuralwattReasoningMapSource;
 }
 
 export interface NeuralwattVariantSpec {
@@ -48,7 +55,54 @@ export interface NeuralwattVariantSpec {
    */
   costMultiplier?: number;
   vision?: boolean;
-  thinkingLevelMap?: ThinkingLevelMap;
+  /** Override the family reasoning contract for this variant. */
+  reasoningMetadata?: NeuralwattReasoningMapSource;
+}
+
+/**
+ * Subset of the API reasoning block needed to build the Pi thinking level map.
+ * Kept narrow so public snapshots stay small and offline-friendly.
+ */
+export type NeuralwattReasoningMapSource = Pick<
+  NeuralwattApiModelReasoning,
+  "supported_efforts" | "mandatory"
+>;
+
+/**
+ * Build the Pi thinking level map from the Neuralwatt reasoning contract.
+ *
+ * Pure identity mapping: a Pi level is enabled iff it appears in
+ * `supported_efforts` (mapped to its own name), `null` otherwise. `off` maps to
+ * `"none"` when the model permits disabling reasoning (`!mandatory` and
+ * `"none"` is supported).
+ *
+ * When the reasoning block is missing (e.g. Kimi K2.7 Code, whose API metadata
+ * 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.
+ */
+export function buildThinkingLevelMap(
+  reasoning: NeuralwattReasoningMapSource | undefined,
+): ThinkingLevelMap {
+  // Conservative fallback for models whose API metadata has no reasoning
+  // block. Expose one known-good level and forbid disabling reasoning.
+  const supported = new Set<NeuralwattReasoningEffort>(
+    reasoning?.supported_efforts ?? ["high"],
+  );
+  const mandatory = reasoning?.mandatory ?? true;
+
+  return {
+    off: !mandatory && supported.has("none") ? "none" : null,
+    minimal: supported.has("minimal") ? "minimal" : null,
+    low: supported.has("low") ? "low" : null,
+    medium: supported.has("medium") ? "medium" : null,
+    high: supported.has("high") ? "high" : null,
+    xhigh: supported.has("xhigh") ? "xhigh" : null,
+    max: supported.has("max") ? "max" : null,
+  };
 }
 
 /**
@@ -97,15 +151,14 @@ export function buildNeuralwattModel(
   };
 
   if (variant.reasoning) {
-    const thinkingLevelMap =
-      variant.thinkingLevelMap ?? family.thinkingLevelMap;
-    if (!thinkingLevelMap) {
-      throw new Error(
-        `Missing thinkingLevelMap for reasoning model ${variant.id}`,
-      );
-    }
-    // Clone so variants never share a family map instance.
-    model.thinkingLevelMap = { ...thinkingLevelMap };
+    // 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,
+      ),
+    };
   }
 
   return model;

package/extensions/provider/models/early-access.ts

@@ -1,7 +1,7 @@
 import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
 import { fetchNeuralwattModels } from "../../../src/lib/neuralwatt-api";
 import type { NeuralwattApiModel } from "../../../src/types/models-api";
-import { resolveMaxTokens } from "./build";
+import { buildThinkingLevelMap, resolveMaxTokens } from "./build";
 import { NEURALWATT_MODELS } from "./public-models";
 
 // Pre-release models. Neuralwatt ships these to authorized accounts before they
@@ -13,10 +13,16 @@ export const EARLY_ACCESS_NEURALWATT_MODELS: ProviderModelConfig[] = [];
 
 // Per-ID overrides for known early-access models. The authenticated /v1/models
 // endpoint exposes pricing and capabilities, but some Pi-specific behavior
-// (thinking levels, compat flags) has to be supplied by hand.
+// (compat flags, context window, max tokens) has to be supplied by hand.
+// Reasoning config is always derived from the endpoint's `reasoning` block via
+// `buildThinkingLevelMap`, so `reasoning` and `thinkingLevelMap` are not part
+// of the override shape.
 // Models that have since gone public now live in public-models.ts.
 const EARLY_ACCESS_MODEL_OVERRIDES: Partial<
-  Record<string, Partial<ProviderModelConfig>>
+  Record<
+    string,
+    Omit<Partial<ProviderModelConfig>, "reasoning" | "thinkingLevelMap">
+  >
 > = {};
 
 function buildEarlyAccessModel(
@@ -57,13 +63,10 @@ function buildEarlyAccessModel(
   };
 
   if (reasoning) {
-    model.thinkingLevelMap = override?.thinkingLevelMap ?? {
-      minimal: null,
-      low: null,
-      medium: "medium",
-      high: null,
-      xhigh: null,
-    };
+    // Reasoning levels come straight from the endpoint's `reasoning` block:
+    // `supported_efforts` (identity) and `mandatory` (gates `off`). A missing
+    // block falls back to a high-only map inside `buildThinkingLevelMap`.
+    model.thinkingLevelMap = buildThinkingLevelMap(meta?.reasoning);
   }
 
   if (override) {
@@ -80,11 +83,7 @@ function applyEarlyAccessOverride(
   const result: ProviderModelConfig = { ...model };
 
   if (override.name !== undefined) result.name = override.name;
-  if (override.reasoning !== undefined) result.reasoning = override.reasoning;
   if (override.input !== undefined) result.input = override.input;
-  if (override.thinkingLevelMap !== undefined) {
-    result.thinkingLevelMap = override.thinkingLevelMap;
-  }
   if (override.contextWindow !== undefined) {
     result.contextWindow = override.contextWindow;
   }
@@ -96,6 +95,9 @@ function applyEarlyAccessOverride(
     result.compat = { ...model.compat, ...override.compat };
   }
 
+  // `reasoning` and `thinkingLevelMap` are intentionally not overridable:
+  // reasoning config is derived from the endpoint's `reasoning` block.
+
   return result;
 }
 

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

@@ -4,119 +4,83 @@ import {
   FLEX_COST_MULTIPLIER,
   type NeuralwattModelFamily,
   type NeuralwattVariantSpec,
-  type ThinkingLevelMap,
 } from "./build";
 
 // Public models returned by https://api.neuralwatt.com/v1/models.
 // Pricing, capabilities, and limits are sourced from the API metadata fields;
 // `maxTokens` is `metadata.limits.max_output_tokens ?? max_model_len`.
 //
-// Models are declared per family so every variant (`-fast`, `-flex`, `-short`)
-// inherits the family's pricing, modalities, and thinking levels. See
-// `models.test.ts` for the drift check against the live catalog.
-
-// GLM natively supports `high` and `max` reasoning efforts. `xhigh` is an
-// unsupported hole between them. Pi added the `max` level in 0.80.6.
-const GLM_THINKING: ThinkingLevelMap = {
-  off: "none",
-  minimal: null,
-  low: null,
-  medium: null,
-  high: "high",
-  xhigh: null,
-  max: "max",
-};
-
-// Binary thinking control (Kimi K2.x, Qwen3.x): no graded `reasoning_effort`
-// upstream, only a thinking on/off toggle. Expose a single known-good Pi
-// level; "high" stands in for standard full thinking.
-const BINARY_THINKING: ThinkingLevelMap = {
-  minimal: null,
-  low: null,
-  medium: null,
-  high: "high",
-  xhigh: null,
-};
+// Each reasoning family snapshots its `reasoning.supported_efforts` +
+// `reasoning.mandatory` from the API; `buildThinkingLevelMap` turns that into
+// the Pi thinking level map by identity (no aliasing). See `models.test.ts`
+// for the drift check against the live catalog.
 
+// DeepSeek V4 Flash: efforts max/high/none, not mandatory.
+// https://api-docs.deepseek.com/guides/thinking_mode/
 const DEEPSEEK_V4_FLASH: NeuralwattModelFamily = {
   cost: { input: 0.14, output: 0.28, cacheRead: 0.028 },
   vision: false,
-  // DeepSeek V4 Flash accepts reasoning_effort low/high/max (default high);
-  // there is no "medium" tier, so Pi's low/high/max map directly and
-  // minimal/medium/xhigh are unsupported holes.
-  // https://api-docs.deepseek.com/guides/thinking_mode/
-  thinkingLevelMap: {
-    off: "none",
-    minimal: null,
-    low: "low",
-    medium: null,
-    high: "high",
-    xhigh: null,
-    max: "max",
+  reasoningMetadata: {
+    supported_efforts: ["max", "high", "none"],
+    mandatory: false,
   },
 };
 
 // Google, served from NVIDIA's NVFP4 checkpoint. Gemma 4's chat template
-// takes a boolean rather than an effort level, so it has a single reasoning
-// depth (`max`) plus thinking-off; every non-`none` value resolves to `max`.
+// takes a boolean rather than an effort level, so the API only advertises
+// `max` and `none`; every non-`none` request resolves to `max` upstream.
 // It does not reason by default (`default_enabled: false`), but the model
 // can produce reasoning traces when asked. See
 // https://portal.neuralwatt.com/docs/api/chat-completions#reasoning-effort
-const GEMMA_4_THINKING: ThinkingLevelMap = {
-  off: "none",
-  minimal: null,
-  low: null,
-  medium: null,
-  high: null,
-  xhigh: null,
-  max: "max",
-};
-
 const GEMMA_4: NeuralwattModelFamily = {
   cost: { input: 0.144, output: 0.42, cacheRead: 0.0144 },
   vision: true,
-  thinkingLevelMap: GEMMA_4_THINKING,
+  reasoningMetadata: {
+    supported_efforts: ["max", "none"],
+    mandatory: false,
+  },
 };
 
-// ZhipuAI.
+// ZhipuAI. GLM-5.2 natively supports `high` and `max` reasoning efforts;
+// `xhigh` is an unsupported hole between them. Pi's `max` level (0.80.6) maps
+// to GLM's top tier.
 const GLM_5_2: NeuralwattModelFamily = {
   cost: { input: 1.45, output: 4.5, cacheRead: 0.145 },
   vision: false,
-  thinkingLevelMap: GLM_THINKING,
+  reasoningMetadata: {
+    supported_efforts: ["max", "high", "none"],
+    mandatory: false,
+  },
 };
 
-// MoonshotAI. K3 is the largest open-weight model ever released, served in
-// preview with limited concurrency. K3 always reasons (thinking cannot be
-// disabled) and supports `reasoning_effort` values "low", "high", and "max"
-// (default "max"). There is no "medium" tier upstream, so Pi's low/high/max
-// map directly and `off`, `minimal`, `medium`, and `xhigh` are unsupported
-// holes. The `-fast` endpoint is a shorthand to set thinking to off.
+// MoonshotAI. K3 supports reasoning efforts low/high/max (default max) and
+// can be turned off (`mandatory: false`). The `-fast` endpoint is a shorthand
+// to set thinking to off.
 const KIMI_K3: NeuralwattModelFamily = {
   cost: { input: 3, output: 15, cacheRead: 0.3 },
   vision: true,
-  thinkingLevelMap: {
-    off: null,
-    minimal: null,
-    low: "low",
-    medium: null,
-    high: "high",
-    xhigh: null,
-    max: "max",
+  reasoningMetadata: {
+    supported_efforts: ["max", "high", "low", "none"],
+    mandatory: false,
   },
 };
 
-// MoonshotAI.
+// MoonshotAI. The K2.7 Code API exposes no `reasoning` block, so this family
+// omits `reasoningMetadata`; `buildThinkingLevelMap` falls back to a high-only
+// map with `off: null`, matching the upstream binary thinking toggle.
 const KIMI_K2_7_CODE: NeuralwattModelFamily = {
   cost: { input: 0.95, output: 4.0, cacheRead: 0.095 },
   vision: true,
-  thinkingLevelMap: { off: null, ...BINARY_THINKING },
 };
 
-// Qwen.
+// 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 },
   vision: true,
-  thinkingLevelMap: BINARY_THINKING,
+  reasoningMetadata: {
+    supported_efforts: ["high", "none"],
+    mandatory: false,
+  },
 };
 
 const FAMILIES: [NeuralwattModelFamily, NeuralwattVariantSpec[]][] = [
@@ -216,28 +180,37 @@ const FAMILIES: [NeuralwattModelFamily, NeuralwattVariantSpec[]][] = [
       },
     ],
   ],
+  // The kimi-k3 endpoint rejects anything above 327,680 total tokens with
+  // `400: max_completion_tokens is too large … supports at most 327680
+  // completion tokens` (verified at runtime), even though the API advertises
+  // `max_model_len: 1048560` with a null output cap for the whole family.
+  // The -fast/-flex endpoints don't enforce any cap server-side yet (they
+  // accept max_completion_tokens beyond the advertised window), but they are
+  // the same K3 deployment and are expected to share the 327,680 limit, so
+  // all three variants are pinned to it. The drift check in models.test.ts
+  // whitelists this divergence via CONTEXT_WINDOW_OVERRIDES.
   [
     KIMI_K3,
     [
       {
         id: "kimi-k3",
         name: "Kimi K3",
-        contextWindow: 1048560,
-        maxOutputTokens: null,
+        contextWindow: 327680,
+        maxOutputTokens: 327680,
         reasoning: true,
       },
       {
         id: "kimi-k3-fast",
         name: "Kimi K3 Fast",
-        contextWindow: 1048560,
-        maxOutputTokens: null,
+        contextWindow: 327680,
+        maxOutputTokens: 327680,
         reasoning: false,
       },
       {
         id: "kimi-k3-flex",
         name: "Kimi K3 (flex)",
-        contextWindow: 1048560,
-        maxOutputTokens: null,
+        contextWindow: 327680,
+        maxOutputTokens: 327680,
         reasoning: true,
         costMultiplier: FLEX_COST_MULTIPLIER,
       },

package/extensions/provider/models/refresh.ts

@@ -5,10 +5,6 @@ import type {
   RefreshModelsContext,
 } from "@earendil-works/pi-ai";
 import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
-import {
-  persistModels,
-  readStoredModels,
-} from "../../../src/refresh-store-compat";
 import {
   ALIAS_NEURALWATT_MODEL_IDS,
   buildAliasNeuralwattModels,
@@ -24,6 +20,8 @@ const PROVIDER_ID = "neuralwatt";
 const BASE_URL = "https://api.neuralwatt.com/v1";
 const API = "openai-completions" as const;
 
+export type StoredProviderModels = readonly Model<Api>[];
+
 export interface RefreshNeuralwattModelsOptions {
   includeLegacyModelIds: boolean;
   includeAliasedModelIds: boolean;
@@ -129,25 +127,27 @@ function persistCatalog(
   context: RefreshModelsContext,
   models: ProviderModelConfig[],
 ): Promise<boolean> {
-  return persistModels(context, {
-    models: models.map(toStoredModel),
-    checkedAt: Date.now(),
+  return context.publish({
+    persist: {
+      models: models.map(toStoredModel),
+      checkedAt: Date.now(),
+    },
   });
 }
 
-/** Refresh the complete Neuralwatt catalog with Pi-managed persistence. */
+/** Refresh the complete Neuralwatt catalog; undefined = failed (stale store kept). */
 export async function refreshNeuralwattModels(
   context: RefreshModelsContext,
   options: RefreshNeuralwattModelsOptions,
-): Promise<ProviderModelConfig[]> {
+): Promise<ProviderModelConfig[] | undefined> {
   const baseline = configuredModels(
     options.includeLegacyModelIds,
     options.includeAliasedModelIds,
   );
-  const stored = await readStoredModels(context);
+  const stored = context.stored;
 
   if (!options.includeEarlyAccessModels) {
-    await persistCatalog(context, baseline);
+    await persistCatalog(context, baseline).catch(() => false);
     return baseline;
   }
 
@@ -161,29 +161,31 @@ export async function refreshNeuralwattModels(
     cachedEarlyAccess,
   );
 
-  if (!context.allowNetwork || context.signal?.aborted) {
+  if (!context.allowNetwork || context.signal.aborted) {
     return cachedCatalog;
   }
 
+  // Anonymous credential (empty or missing key): keep the public catalog and
+  // skip discovery, which requires a real key.
   const apiKey =
-    context.credential?.type === "api_key" ? context.credential.key : undefined;
+    context.credential?.type === "api_key" && context.credential.key
+      ? context.credential.key
+      : undefined;
   if (!apiKey) return cachedCatalog;
 
   const earlyAccess = await (options.loadEarlyAccess ?? loadEarlyAccessModels)(
     apiKey,
     context.signal,
   );
-  if (context.signal?.aborted) return cachedCatalog;
-  if (!earlyAccess) {
-    throw new Error("Neuralwatt model catalog refresh failed");
-  }
+  if (context.signal.aborted) return cachedCatalog;
+  if (!earlyAccess) return undefined;
 
   const catalog = configuredModels(
     options.includeLegacyModelIds,
     options.includeAliasedModelIds,
     configuredEarlyAccessModels(earlyAccess, baseline),
   );
-  context.signal?.throwIfAborted();
-  await persistCatalog(context, catalog);
+  context.signal.throwIfAborted();
+  await persistCatalog(context, catalog).catch(() => false);
   return catalog;
 }

package/extensions/provider/provider.ts

@@ -0,0 +1,113 @@
+import type {
+  Api,
+  Model,
+  Provider,
+  ProviderStreamOptions,
+} from "@earendil-works/pi-ai";
+import { stream, streamSimple } from "@earendil-works/pi-ai/compat";
+import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
+import type {
+  RefreshNeuralwattModelsOptions,
+  StoredProviderModels,
+} from "./models/refresh";
+import { refreshNeuralwattModels } 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",
+};
+
+const API = "openai-completions" as const;
+
+function toProviderModels(
+  models: readonly ProviderModelConfig[],
+): 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,
+  }));
+}
+
+export function createNeuralwattProvider(
+  staticModels: ProviderModelConfig[],
+  refreshOptions: () => RefreshNeuralwattModelsOptions,
+  streamSimpleOverride?: AnyStreamSimple,
+): Provider {
+  let liveModels = toProviderModels(staticModels);
+
+  return {
+    id: NEURALWATT_PROVIDER_ID,
+    name: "Neuralwatt",
+    baseUrl: NEURALWATT_BASE_URL,
+    headers: NEURALWATT_REQUEST_HEADERS,
+    auth: {
+      apiKey: {
+        name: "Neuralwatt API key",
+        login: async (interaction) => ({
+          type: "api_key",
+          key: await interaction.prompt({
+            type: "secret",
+            message: "Enter Neuralwatt API key",
+          }),
+        }),
+        check: async ({ ctx, credential }) => {
+          if (credential?.type === "api_key" && credential.key) {
+            return { type: "api_key", source: "stored credential" };
+          }
+          if (await ctx.env(NEURALWATT_API_KEY_ENV)) {
+            return { type: "api_key", source: NEURALWATT_API_KEY_ENV };
+          }
+          return undefined;
+        },
+        resolve: async ({ ctx, credential, signal }) => {
+          signal.throwIfAborted();
+          if (credential?.type === "api_key" && credential.key) {
+            return {
+              auth: { apiKey: credential.key },
+              env: credential.env,
+              source: "stored credential",
+            };
+          }
+          const envKey = await ctx.env(NEURALWATT_API_KEY_ENV);
+          signal.throwIfAborted();
+          if (envKey) {
+            return { auth: { apiKey: envKey }, source: NEURALWATT_API_KEY_ENV };
+          }
+          // Resolve never fails: without a key the catalog is the hardcoded
+          // one and early-access discovery is skipped (anonymous playground
+          // traffic authenticates at stream time).
+          return { auth: { apiKey: "" }, source: "anonymous" };
+        },
+      },
+    },
+    getModels: () => liveModels,
+    refreshModels: async (context) => {
+      const refreshed = await refreshNeuralwattModels(
+        context,
+        refreshOptions(),
+      );
+      // Fresh or offline store: the refresh intentionally skipped the
+      // network; adopt the persisted catalog anyway so getModels reflects it
+      // (statics otherwise).
+      const next = refreshed ?? context.stored?.models;
+      if (!next || next.length === 0) return;
+      const adopted = toProviderModels(next as StoredProviderModels);
+      await context.publish({
+        update: () => {
+          liveModels = adopted;
+        },
+      });
+    },
+    stream: (model, context, options) =>
+      stream(model, context, options as ProviderStreamOptions | undefined),
+    streamSimple: streamSimpleOverride ?? streamSimple,
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-neuralwatt",
-  "version": "0.12.1",
+  "version": "0.14.0",
   "license": "MIT",
   "type": "module",
   "private": false,
@@ -38,8 +38,8 @@
     "@aliou/pi-utils-ui": "^0.5.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": ">=0.80.8",
-    "@earendil-works/pi-coding-agent": ">=0.80.8",
+    "@earendil-works/pi-ai": ">=0.84.0",
+    "@earendil-works/pi-coding-agent": ">=0.84.0",
     "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {

package/src/types/models-api.ts

@@ -18,6 +18,46 @@ export interface NeuralwattApiModelCapabilities {
   developer_role: boolean;
 }
 
+/**
+ * Reasoning effort values Neuralwatt accepts on the wire. Mirrors Pi's
+ * `ModelThinkingLevel` (minus `off`, which the API spells `"none"`).
+ */
+export type NeuralwattReasoningEffort =
+  | "none"
+  | "minimal"
+  | "low"
+  | "medium"
+  | "high"
+  | "xhigh"
+  | "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.
+ */
+export interface NeuralwattApiModelReasoning {
+  /** Whether the model reasons by default. */
+  default_enabled: boolean;
+  /** Whether reasoning cannot be turned off. Forces `off: null` in the map. */
+  mandatory: boolean;
+  /** Efforts the model truly supports; drives the Pi thinking level map. */
+  supported_efforts: NeuralwattReasoningEffort[];
+  /** Efforts the API accepts but aliases onto a supported one. Not consumed. */
+  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. */
+  effort_aliases?: Partial<
+    Record<NeuralwattReasoningEffort, NeuralwattReasoningEffort>
+  >;
+}
+
 export interface NeuralwattApiModelLimits {
   max_context_length: number;
   max_output_tokens: number | null;
@@ -31,6 +71,7 @@ export interface NeuralwattApiModelMetadata {
   huggingface_id: string | null;
   pricing: NeuralwattApiModelPricing;
   capabilities: NeuralwattApiModelCapabilities;
+  reasoning?: NeuralwattApiModelReasoning;
   limits: NeuralwattApiModelLimits;
   deprecated: boolean;
   deprecated_message: string | null;

package/src/refresh-store-compat.ts

@@ -1,69 +0,0 @@
-// ---------------------------------------------------------------------------
-// Backward-compat shim for the Pi coding-agent provider refresh context.
-//
-// Pi 0.84 replaced dynamic `context.store` read/write access with the
-// read-only `context.stored` snapshot and the generation-checked
-// `context.publish({ persist })` transaction. This module detects the
-// available API shape at runtime so the extension works on both <0.84 (store)
-// and >=0.84 (publish) hosts.
-//
-// Once the minimum supported @earendil-works/pi-coding-agent version is
-// >=0.84, delete this file and:
-//   - replace `readStoredModels(context)` with `context.stored`
-//   - replace `persistModels(context, entry)` with
-//     `await context.publish({ persist: entry })` (skip when aborted)
-// ---------------------------------------------------------------------------
-
-import type {
-  ModelsStoreEntry,
-  RefreshModelsContext,
-} from "@earendil-works/pi-ai";
-
-type LegacyRefreshModelsContext = RefreshModelsContext & {
-  store?: {
-    read(): Promise<ModelsStoreEntry | undefined>;
-    write(entry: ModelsStoreEntry): Promise<unknown>;
-  };
-};
-
-/**
- * Returns the persisted catalog entry for the current provider, reading from
- * the 0.84+ `context.stored` snapshot when available and falling back to the
- * legacy `context.store.read()` on older hosts.
- */
-export async function readStoredModels(
-  context: RefreshModelsContext,
-): Promise<ModelsStoreEntry | undefined> {
-  if (context.stored !== undefined) return context.stored;
-  return readLegacyStore(context);
-}
-
-function readLegacyStore(
-  context: RefreshModelsContext,
-): Promise<ModelsStoreEntry | undefined> {
-  const legacy = context as LegacyRefreshModelsContext;
-  return legacy.store ? legacy.store.read() : Promise.resolve(undefined);
-}
-
-/**
- * Persists the catalog entry, publishing through
- * `context.publish({ persist: entry })` on 0.84+ hosts and writing through
- * the legacy `context.store.write(entry)` on older hosts.
- *
- * Returns true when the entry was persisted. On 0.84+ hosts a return value of
- * false means a newer refresh superseded this publication (generation check).
- */
-export async function persistModels(
-  context: RefreshModelsContext,
-  entry: ModelsStoreEntry,
-): Promise<boolean> {
-  if (typeof context.publish === "function") {
-    return context.publish({ persist: entry });
-  }
-  const legacy = context as LegacyRefreshModelsContext;
-  if (legacy.store) {
-    await legacy.store.write(entry);
-    return true;
-  }
-  return false;
-}