@aliou/pi-neuralwatt 0.12.1 → 0.13.0

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[]][] = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-neuralwatt",
-  "version": "0.12.1",
+  "version": "0.13.0",
   "license": "MIT",
   "type": "module",
   "private": false,

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;