@aliou/pi-neuralwatt 0.10.5 → 0.11.0

package/README.md

@@ -78,7 +78,8 @@ Configure features with `/neuralwatt:settings`:
 - **Quota warnings** — Enable/disable low quota notifications
 - **Sub-bar integration** — Show/hide usage in status bar
 - **Legacy model IDs** — Include deprecated model aliases
-- **Hidden models** — Include models available only to the configured API key
+- **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.
 
@@ -86,7 +87,7 @@ Configuration uses nested per-feature sections. Existing flat config files are m
 
 ### Model Refresh
 
-Neuralwatt registers its public models without network access. When hidden 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. When early-access models are enabled, opening `/model` refreshes the authenticated catalog in the background. `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.
 

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

@@ -7,7 +7,6 @@ import type { SettingItem } from "@earendil-works/pi-tui";
 import {
   configLoader,
   type NeuralwattConfig,
-  type NeuralwattRawConfig,
   type ResolvedNeuralwattConfig,
 } from "../../../../src/config";
 import {
@@ -50,51 +49,11 @@ function featureRow(
   };
 }
 
-function optionalFeatureValue(value: unknown): boolean | undefined {
-  if (typeof value === "boolean") return value;
-  if (value && typeof value === "object") {
-    const enabled = (value as { enabled?: boolean }).enabled;
-    if (typeof enabled === "boolean") return enabled;
-  }
-  return undefined;
-}
-
-function featureValue(value: unknown, fallback: boolean): boolean {
-  return optionalFeatureValue(value) ?? fallback;
-}
-
-function toNestedConfig(config: NeuralwattRawConfig): NeuralwattConfig {
-  const provider = "provider" in config ? config.provider : undefined;
-
-  return {
-    provider: {
-      ...(provider ?? {}),
-      includeLegacyModelIds:
-        provider?.includeLegacyModelIds ??
-        ("includeLegacyModelIds" in config
-          ? config.includeLegacyModelIds
-          : undefined),
-      includeHiddenModels:
-        provider?.includeHiddenModels ??
-        ("includeHiddenModels" in config
-          ? config.includeHiddenModels
-          : undefined),
-    },
-    quotaCommand: {
-      ...(typeof config.quotaCommand === "object" ? config.quotaCommand : {}),
-      enabled: optionalFeatureValue(config.quotaCommand),
-    },
-    quotaWarnings: {
-      ...(typeof config.quotaWarnings === "object" ? config.quotaWarnings : {}),
-      enabled: optionalFeatureValue(config.quotaWarnings),
-    },
-    subBarIntegration: {
-      ...(typeof config.subBarIntegration === "object"
-        ? config.subBarIntegration
-        : {}),
-      enabled: optionalFeatureValue(config.subBarIntegration),
-    },
-  };
+function featureValue(
+  section: { enabled?: boolean } | undefined,
+  fallback: boolean,
+): boolean {
+  return section?.enabled ?? fallback;
 }
 
 export function registerNeuralwattSettings(
@@ -103,7 +62,7 @@ export function registerNeuralwattSettings(
 ): void {
   const { getLoadedFeatures } = options;
 
-  registerSettingsCommand<NeuralwattRawConfig, ResolvedNeuralwattConfig>(pi, {
+  registerSettingsCommand<NeuralwattConfig, ResolvedNeuralwattConfig>(pi, {
     commandName: "neuralwatt:settings",
     title: "Neuralwatt Settings",
     configStore: configLoader,
@@ -154,30 +113,32 @@ export function registerNeuralwattSettings(
               description:
                 "Include deprecated Neuralwatt model IDs as aliases in the model picker",
               currentValue:
-                ((tabConfig &&
-                  "provider" in tabConfig &&
-                  tabConfig.provider?.includeLegacyModelIds) ??
-                (tabConfig &&
-                  "includeLegacyModelIds" in tabConfig &&
-                  tabConfig.includeLegacyModelIds) ??
+                (tabConfig?.provider?.includeLegacyModelIds ??
                 resolved.provider.includeLegacyModelIds)
                   ? "include"
                   : "ignore",
               values: ["include", "ignore"],
             },
             {
-              id: "includeHiddenModels",
-              label: "Hidden models",
+              id: "includeAliasedModelIds",
+              label: "Alias model IDs",
+              description:
+                "Include active creator-scoped model IDs as aliases in the model picker",
+              currentValue:
+                (tabConfig?.provider?.includeAliasedModelIds ??
+                resolved.provider.includeAliasedModelIds)
+                  ? "include"
+                  : "ignore",
+              values: ["include", "ignore"],
+            },
+            {
+              id: "includeEarlyAccessModels",
+              label: "Early access models",
               description:
-                "Include Neuralwatt models that are accessible via API key but not advertised in the public model list",
+                "Include pre-release Neuralwatt models that your API key can reach but that are not yet in the public model list",
               currentValue:
-                ((tabConfig &&
-                  "provider" in tabConfig &&
-                  tabConfig.provider?.includeHiddenModels) ??
-                (tabConfig &&
-                  "includeHiddenModels" in tabConfig &&
-                  tabConfig.includeHiddenModels) ??
-                resolved.provider.includeHiddenModels)
+                (tabConfig?.provider?.includeEarlyAccessModels ??
+                resolved.provider.includeEarlyAccessModels)
                   ? "include"
                   : "ignore",
               values: ["include", "ignore"],
@@ -190,23 +151,31 @@ export function registerNeuralwattSettings(
       // Non-feature toggles are handled first so they are not blocked by the
       // loaded-features guard (they are managed directly by the provider).
       if (id === "includeLegacyModelIds") {
-        const nestedConfig = toNestedConfig(config);
         return {
-          ...nestedConfig,
+          ...config,
           provider: {
-            ...nestedConfig.provider,
+            ...config.provider,
             includeLegacyModelIds: newValue === "include",
           },
         };
       }
 
-      if (id === "includeHiddenModels") {
-        const nestedConfig = toNestedConfig(config);
+      if (id === "includeAliasedModelIds") {
         return {
-          ...nestedConfig,
+          ...config,
           provider: {
-            ...nestedConfig.provider,
-            includeHiddenModels: newValue === "include",
+            ...config.provider,
+            includeAliasedModelIds: newValue === "include",
+          },
+        };
+      }
+
+      if (id === "includeEarlyAccessModels") {
+        return {
+          ...config,
+          provider: {
+            ...config.provider,
+            includeEarlyAccessModels: newValue === "include",
           },
         };
       }
@@ -219,21 +188,18 @@ export function registerNeuralwattSettings(
       switch (id) {
         case "quotaCommand":
           return {
-            ...toNestedConfig(config),
-            quotaCommand: { ...toNestedConfig(config).quotaCommand, enabled },
+            ...config,
+            quotaCommand: { ...config.quotaCommand, enabled },
           };
         case "quotaWarnings":
           return {
-            ...toNestedConfig(config),
-            quotaWarnings: { ...toNestedConfig(config).quotaWarnings, enabled },
+            ...config,
+            quotaWarnings: { ...config.quotaWarnings, enabled },
           };
         case "subBarIntegration":
           return {
-            ...toNestedConfig(config),
-            subBarIntegration: {
-              ...toNestedConfig(config).subBarIntegration,
-              enabled,
-            },
+            ...config,
+            subBarIntegration: { ...config.subBarIntegration, enabled },
           };
         default:
           return null;

package/extensions/provider/index.ts

@@ -44,6 +44,7 @@ function registerNeuralwattProvider(
 
   const models = getNeuralwattModels({
     includeLegacyModelIds: providerConfig.includeLegacyModelIds,
+    includeAliasedModelIds: providerConfig.includeAliasedModelIds,
   });
 
   const config: Parameters<ExtensionAPI["registerProvider"]>[1] = {
@@ -61,8 +62,10 @@ function registerNeuralwattProvider(
       refreshNeuralwattModels(context, {
         includeLegacyModelIds:
           configLoader.getConfig().provider.includeLegacyModelIds,
-        includeHiddenModels:
-          configLoader.getConfig().provider.includeHiddenModels,
+        includeAliasedModelIds:
+          configLoader.getConfig().provider.includeAliasedModelIds,
+        includeEarlyAccessModels:
+          configLoader.getConfig().provider.includeEarlyAccessModels,
       }),
   };
 
@@ -113,8 +116,10 @@ export default async function (pi: ExtensionAPI) {
     if (
       next.includeLegacyModelIds ===
         registeredProviderSettings.includeLegacyModelIds &&
-      next.includeHiddenModels ===
-        registeredProviderSettings.includeHiddenModels
+      next.includeAliasedModelIds ===
+        registeredProviderSettings.includeAliasedModelIds &&
+      next.includeEarlyAccessModels ===
+        registeredProviderSettings.includeEarlyAccessModels
     ) {
       return;
     }

package/extensions/provider/models/aliases.ts

@@ -0,0 +1,36 @@
+import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
+import { NEURALWATT_MODELS } from "./public-models";
+
+// Alternate creator-scoped model IDs that Neuralwatt accepts for active models.
+// These are only included when `includeAliasedModelIds` is enabled.
+export const ALIAS_MODEL_MAP = {
+  "deepseek-ai/DeepSeek-V4-Flash": "deepseek-v4-flash",
+  "zai-org/GLM-5.2-FP8": "glm-5.2",
+  "moonshotai/Kimi-K2.6": "kimi-k2.6",
+  "moonshotai/Kimi-K2.7-Code": "kimi-k2.7-code",
+  "Qwen/Qwen3.5-397B-A17B-FP8": "qwen3.5-397b",
+  "Qwen/Qwen3.6-35B-A3B": "qwen3.6-35b",
+  "nvidia/Gemma-4-31B-IT-NVFP4": "gemma-4-31b",
+} as const;
+
+export const ALIAS_NEURALWATT_MODEL_IDS = new Set<string>(
+  Object.keys(ALIAS_MODEL_MAP),
+);
+
+export function buildAliasNeuralwattModels(
+  canonicalModels: ProviderModelConfig[] = NEURALWATT_MODELS,
+): ProviderModelConfig[] {
+  return Object.entries(ALIAS_MODEL_MAP).flatMap(([aliasId, canonicalId]) => {
+    const canonical = canonicalModels.find((model) => model.id === canonicalId);
+
+    if (!canonical) return [];
+
+    return [
+      {
+        ...canonical,
+        id: aliasId,
+        name: `${canonical.name} (alias ID)`,
+      },
+    ];
+  });
+}

package/extensions/provider/models/build.ts

@@ -0,0 +1,119 @@
+import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
+
+export type ThinkingLevelMap = NonNullable<
+  ProviderModelConfig["thinkingLevelMap"]
+>;
+
+/**
+ * Flex tier is billed at 65% of standard pricing (35% off) when the request
+ * streams. A non-streaming request to a `-flex` model silently falls back to
+ * the standard tier and the standard price.
+ *
+ * https://portal.neuralwatt.com/docs/guides/flex-tier
+ */
+export const FLEX_COST_MULTIPLIER = 0.65;
+
+export interface NeuralwattCost {
+  input: number;
+  output: number;
+  cacheRead: number;
+}
+
+/**
+ * Shared metadata for every variant of a Neuralwatt model (base, `-fast`,
+ * `-flex`, `-short`, ...). Variants only declare what differs.
+ */
+export interface NeuralwattModelFamily {
+  cost: NeuralwattCost;
+  vision: boolean;
+  /** Thinking levels used by reasoning variants of this family. */
+  thinkingLevelMap?: ThinkingLevelMap;
+}
+
+export interface NeuralwattVariantSpec {
+  id: string;
+  name: string;
+  /** `max_model_len` from /v1/models. */
+  contextWindow: number;
+  /**
+   * `metadata.limits.max_output_tokens` from /v1/models. `null` means the API
+   * imposes no separate output cap, so output is bounded by the context window.
+   */
+  maxOutputTokens: number | null;
+  reasoning: boolean;
+  cost?: Partial<NeuralwattCost>;
+  /**
+   * Multiplier applied to the family cost, e.g. the Flex tier discount.
+   * Applied after any per-variant `cost` override.
+   */
+  costMultiplier?: number;
+  vision?: boolean;
+  thinkingLevelMap?: ThinkingLevelMap;
+}
+
+/**
+ * Neuralwatt reports `max_output_tokens: null` for models whose output is only
+ * bounded by the context window. Mirror the API instead of inventing a cap.
+ */
+export function resolveMaxTokens(
+  maxOutputTokens: number | null | undefined,
+  contextWindow: number,
+): number {
+  return maxOutputTokens ?? contextWindow;
+}
+
+export function buildNeuralwattModel(
+  family: NeuralwattModelFamily,
+  variant: NeuralwattVariantSpec,
+): ProviderModelConfig {
+  const vision = variant.vision ?? family.vision;
+
+  const compat: NonNullable<ProviderModelConfig["compat"]> = {
+    supportsDeveloperRole: false,
+    maxTokensField: "max_tokens",
+  };
+  if (variant.reasoning) {
+    compat.requiresReasoningContentOnAssistantMessages = true;
+  }
+
+  const multiplier = variant.costMultiplier ?? 1;
+  const scale = (value: number): number =>
+    multiplier === 1 ? value : Number((value * multiplier).toFixed(6));
+
+  const model: ProviderModelConfig = {
+    id: variant.id,
+    name: variant.name,
+    reasoning: variant.reasoning,
+    input: vision ? ["text", "image"] : ["text"],
+    cost: {
+      input: scale(variant.cost?.input ?? family.cost.input),
+      output: scale(variant.cost?.output ?? family.cost.output),
+      cacheRead: scale(variant.cost?.cacheRead ?? family.cost.cacheRead),
+      cacheWrite: 0,
+    },
+    contextWindow: variant.contextWindow,
+    maxTokens: resolveMaxTokens(variant.maxOutputTokens, variant.contextWindow),
+    compat,
+  };
+
+  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 };
+  }
+
+  return model;
+}
+
+export function buildNeuralwattFamily(
+  family: NeuralwattModelFamily,
+  variants: NeuralwattVariantSpec[],
+): ProviderModelConfig[] {
+  return variants.map((variant) => buildNeuralwattModel(family, variant));
+}

package/extensions/provider/models/{hidden.ts → early-access.ts}

@@ -1,55 +1,53 @@
 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 { buildNeuralwattModel, resolveMaxTokens } from "./build";
 import { NEURALWATT_MODELS } from "./public-models";
 
-// Hidden models available to authorized accounts but omitted from the public
-// /v1/models response. Keep these gated by includeHiddenModels and hardcode
-// early-access entries so they remain available from the offline catalog.
+// Pre-release models. Neuralwatt ships these to authorized accounts before they
+// reach the public /v1/models response; most go public eventually. Keep them
+// gated by includeEarlyAccessModels and hardcode entries so they remain
+// available from the offline catalog.
 // Move an entry to public-models.ts once Neuralwatt advertises it publicly.
-export const HIDDEN_NEURALWATT_MODELS: ProviderModelConfig[] = [
+export const EARLY_ACCESS_NEURALWATT_MODELS: ProviderModelConfig[] = [
   // Kimi K3 - early-access MoonshotAI multimodal MoE.
   // Metadata is sourced from Neuralwatt's authenticated model catalog.
-  {
-    id: "kimi-k3",
-    name: "Kimi K3",
-    reasoning: true,
-    input: ["text", "image"],
-    cost: {
-      input: 3,
-      output: 15,
-      cacheRead: 0.3,
-      cacheWrite: 0,
-    },
-    contextWindow: 1048560,
-    maxTokens: 65536,
-    thinkingLevelMap: {
-      minimal: null,
-      low: null,
-      medium: "medium",
-      high: null,
-      xhigh: null,
+  buildNeuralwattModel(
+    {
+      cost: { input: 3, output: 15, cacheRead: 0.3 },
+      vision: true,
+      thinkingLevelMap: {
+        minimal: null,
+        low: null,
+        medium: "medium",
+        high: null,
+        xhigh: null,
+      },
     },
-    compat: {
-      supportsDeveloperRole: false,
-      maxTokensField: "max_tokens",
-      requiresReasoningContentOnAssistantMessages: true,
+    {
+      id: "kimi-k3",
+      name: "Kimi K3",
+      contextWindow: 1048560,
+      maxOutputTokens: null,
+      reasoning: true,
     },
-  },
+  ),
 ];
 
-// Per-ID overrides for known hidden 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.
-// Previously hidden models that have since gone public now live in public-models.ts.
-const HIDDEN_MODEL_OVERRIDES: Partial<
+// 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.
+// Models that have since gone public now live in public-models.ts.
+const EARLY_ACCESS_MODEL_OVERRIDES: Partial<
   Record<string, Partial<ProviderModelConfig>>
 > = {};
 
-function buildHiddenModel(apiModel: NeuralwattApiModel): ProviderModelConfig {
+function buildEarlyAccessModel(
+  apiModel: NeuralwattApiModel,
+): ProviderModelConfig {
   const meta = apiModel.metadata;
   const reasoning = meta?.capabilities.reasoning ?? false;
-  const override = HIDDEN_MODEL_OVERRIDES[apiModel.id];
+  const override = EARLY_ACCESS_MODEL_OVERRIDES[apiModel.id];
 
   const compat: NonNullable<ProviderModelConfig["compat"]> = {
     supportsDeveloperRole: false,
@@ -74,7 +72,10 @@ function buildHiddenModel(apiModel: NeuralwattApiModel): ProviderModelConfig {
       cacheWrite: meta?.pricing.cached_output_per_million ?? 0,
     },
     contextWindow: apiModel.max_model_len,
-    maxTokens: meta?.limits.max_output_tokens ?? 65536,
+    maxTokens: resolveMaxTokens(
+      meta?.limits.max_output_tokens,
+      apiModel.max_model_len,
+    ),
     compat,
   };
 
@@ -89,13 +90,13 @@ function buildHiddenModel(apiModel: NeuralwattApiModel): ProviderModelConfig {
   }
 
   if (override) {
-    return applyHiddenOverride(model, override);
+    return applyEarlyAccessOverride(model, override);
   }
 
   return model;
 }
 
-function applyHiddenOverride(
+function applyEarlyAccessOverride(
   model: ProviderModelConfig,
   override: Partial<ProviderModelConfig>,
 ): ProviderModelConfig {
@@ -122,14 +123,14 @@ function applyHiddenOverride(
 }
 
 /**
- * Load hidden models from the authenticated /v1/models endpoint.
+ * Load early-access models from the authenticated /v1/models endpoint.
  *
- * Hidden models are any models returned by the API that are not already part of
- * the public hardcoded list. If the API key is missing or the request fails, an
- * `undefined` distinguishes an unavailable/failed request from a successful
- * empty hidden-model list, allowing refresh callers to preserve stale cache.
+ * Early-access models are any models returned by the API that are not already
+ * part of the public hardcoded list. If the API key is missing or the request
+ * fails, an `undefined` distinguishes an unavailable/failed request from a
+ * successful empty list, allowing refresh callers to preserve stale cache.
  */
-export async function loadHiddenModels(
+export async function loadEarlyAccessModels(
   apiKey: string,
   signal?: AbortSignal,
 ): Promise<ProviderModelConfig[] | undefined> {
@@ -146,5 +147,5 @@ export async function loadHiddenModels(
         !model.metadata?.deprecated && !model.metadata?.pricing.pricing_tbd,
     )
     .filter((model) => !publicIds.has(model.id))
-    .map(buildHiddenModel);
+    .map(buildEarlyAccessModel);
 }

package/extensions/provider/models/index.ts

@@ -1,8 +1,18 @@
 import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
+import { buildAliasNeuralwattModels } from "./aliases";
 import { buildLegacyNeuralwattModels } from "./legacy";
 import { NEURALWATT_MODELS } from "./public-models";
 
-export { HIDDEN_NEURALWATT_MODELS, loadHiddenModels } from "./hidden";
+export {
+  ALIAS_MODEL_MAP,
+  ALIAS_NEURALWATT_MODEL_IDS,
+  buildAliasNeuralwattModels,
+} from "./aliases";
+
+export {
+  EARLY_ACCESS_NEURALWATT_MODELS,
+  loadEarlyAccessModels,
+} from "./early-access";
 export {
   buildLegacyNeuralwattModels,
   LEGACY_MODEL_ALIAS_MAP,
@@ -13,6 +23,7 @@ export { refreshNeuralwattModels } from "./refresh";
 
 export function getNeuralwattModels(options?: {
   includeLegacyModelIds?: boolean;
+  includeAliasedModelIds?: boolean;
 }): ProviderModelConfig[] {
   const models: ProviderModelConfig[] = [...NEURALWATT_MODELS];
 
@@ -20,5 +31,9 @@ export function getNeuralwattModels(options?: {
     models.push(...buildLegacyNeuralwattModels());
   }
 
+  if (options?.includeAliasedModelIds) {
+    models.push(...buildAliasNeuralwattModels());
+  }
+
   return models;
 }

package/extensions/provider/models/legacy.ts

@@ -9,10 +9,6 @@ export const LEGACY_MODEL_ALIAS_MAP = {
   "zai-org/GLM-5.1-FP8": "glm-5.2",
   "moonshotai/Kimi-K2.5": "kimi-k2.6",
   "kimi-k2.5-fast": "kimi-k2.6-fast",
-  "moonshotai/Kimi-K2.6": "kimi-k2.6",
-  "Qwen/Qwen3.5-397B-A17B-FP8": "qwen3.5-397b",
-  "Qwen/Qwen3.6-35B-A3B": "qwen3.6-35b",
-  "nvidia/Gemma-4-31B-IT-NVFP4": "gemma-4-31b",
 } as const;
 
 export const LEGACY_NEURALWATT_MODEL_IDS = new Set<string>(