@aliou/pi-neuralwatt 0.10.6 → 0.11.2

package/README.md

@@ -78,6 +78,7 @@ 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
+- **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.

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

@@ -119,6 +119,18 @@ export function registerNeuralwattSettings(
                   : "ignore",
               values: ["include", "ignore"],
             },
+            {
+              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",
@@ -148,6 +160,16 @@ export function registerNeuralwattSettings(
         };
       }
 
+      if (id === "includeAliasedModelIds") {
+        return {
+          ...config,
+          provider: {
+            ...config.provider,
+            includeAliasedModelIds: newValue === "include",
+          },
+        };
+      }
+
       if (id === "includeEarlyAccessModels") {
         return {
           ...config,

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,6 +62,8 @@ function registerNeuralwattProvider(
       refreshNeuralwattModels(context, {
         includeLegacyModelIds:
           configLoader.getConfig().provider.includeLegacyModelIds,
+        includeAliasedModelIds:
+          configLoader.getConfig().provider.includeAliasedModelIds,
         includeEarlyAccessModels:
           configLoader.getConfig().provider.includeEarlyAccessModels,
       }),
@@ -113,6 +116,8 @@ export default async function (pi: ExtensionAPI) {
     if (
       next.includeLegacyModelIds ===
         registeredProviderSettings.includeLegacyModelIds &&
+      next.includeAliasedModelIds ===
+        registeredProviderSettings.includeAliasedModelIds &&
       next.includeEarlyAccessModels ===
         registeredProviderSettings.includeEarlyAccessModels
     ) {

package/extensions/provider/models/aliases.ts

@@ -0,0 +1,35 @@
+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.7-Code": "kimi-k2.7-code",
+  "moonshotai/Kimi-K3": "kimi-k3",
+  "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/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 { buildNeuralwattModel, resolveMaxTokens } from "./build";
+import { resolveMaxTokens } from "./build";
 import { NEURALWATT_MODELS } from "./public-models";
 
 // Pre-release models. Neuralwatt ships these to authorized accounts before they
@@ -9,30 +9,7 @@ import { NEURALWATT_MODELS } from "./public-models";
 // 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 EARLY_ACCESS_NEURALWATT_MODELS: ProviderModelConfig[] = [
-  // Kimi K3 - early-access MoonshotAI multimodal MoE.
-  // Metadata is sourced from Neuralwatt's authenticated model catalog.
-  buildNeuralwattModel(
-    {
-      cost: { input: 3, output: 15, cacheRead: 0.3 },
-      vision: true,
-      thinkingLevelMap: {
-        minimal: null,
-        low: null,
-        medium: "medium",
-        high: null,
-        xhigh: null,
-      },
-    },
-    {
-      id: "kimi-k3",
-      name: "Kimi K3",
-      contextWindow: 1048560,
-      maxOutputTokens: null,
-      reasoning: true,
-    },
-  ),
-];
+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

package/extensions/provider/models/index.ts

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

package/extensions/provider/models/legacy.ts

@@ -4,15 +4,22 @@ import { NEURALWATT_MODELS } from "./public-models";
 // Legacy model IDs that should resolve to a canonical public model.
 // These are phased out over time and are only included when `includeLegacyModelIds` is enabled.
 export const LEGACY_MODEL_ALIAS_MAP = {
+  // GLM 5.1 → GLM 5.2
   "glm-5.1": "glm-5.2",
   "glm-5.1-fast": "glm-5.2-fast",
   "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",
+  // Kimi K2.5 → Kimi K2.7 Code (K2.6 was retired 8/3, redirected to K2.7)
+  "moonshotai/Kimi-K2.5": "kimi-k2.7-code",
+  "kimi-k2.5-fast": "kimi-k2.7-code-fast",
+  // Kimi K2.6 retired 8/3, redirected to Kimi K2.7 Code
+  "kimi-k2.6": "kimi-k2.7-code",
+  "kimi-k2.6-fast": "kimi-k2.7-code-fast",
+  "kimi-k2.6-flex": "kimi-k2.7-code-flex",
+  "moonshotai/Kimi-K2.6": "kimi-k2.7-code",
+  // Qwen 3.5 retired 8/3, redirected to Qwen 3.6
+  "qwen3.5-397b": "qwen3.6-35b",
+  "qwen3.5-397b-fast": "qwen3.6-35b-fast",
+  "Qwen/Qwen3.5-397B-A17B-FP8": "qwen3.6-35b",
 } as const;
 
 export const LEGACY_NEURALWATT_MODEL_IDS = new Set<string>(

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

@@ -27,23 +27,29 @@ const GLM_THINKING: ThinkingLevelMap = {
   max: "max",
 };
 
-// Binary thinking control: expose a single known-good Pi level.
+// 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: "medium",
-  high: null,
+  medium: null,
+  high: "high",
   xhigh: null,
 };
 
 const DEEPSEEK_V4_FLASH: NeuralwattModelFamily = {
-  cost: { input: 0.104, output: 0.207, cacheRead: 0.026 },
+  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: "low",
+    minimal: null,
     low: "low",
-    medium: "medium",
+    medium: null,
     high: "high",
     xhigh: null,
     max: "max",
@@ -52,41 +58,47 @@ const DEEPSEEK_V4_FLASH: NeuralwattModelFamily = {
 
 // Google, served from NVIDIA's NVFP4 checkpoint.
 const GEMMA_4: NeuralwattModelFamily = {
-  cost: { input: 0.144, output: 0.42, cacheRead: 0.036 },
+  cost: { input: 0.144, output: 0.42, cacheRead: 0.0144 },
   vision: true,
 };
 
 // ZhipuAI.
 const GLM_5_2: NeuralwattModelFamily = {
-  cost: { input: 1.45, output: 4.5, cacheRead: 0.3625 },
+  cost: { input: 1.45, output: 4.5, cacheRead: 0.145 },
   vision: false,
   thinkingLevelMap: GLM_THINKING,
 };
 
-// MoonshotAI.
-const KIMI_K2_6: NeuralwattModelFamily = {
-  cost: { input: 0.69, output: 3.22, cacheRead: 0.1725 },
+// 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.
+const KIMI_K3: NeuralwattModelFamily = {
+  cost: { input: 3, output: 15, cacheRead: 0.3 },
   vision: true,
-  thinkingLevelMap: BINARY_THINKING,
+  thinkingLevelMap: {
+    off: null,
+    minimal: null,
+    low: "low",
+    medium: null,
+    high: "high",
+    xhigh: null,
+    max: "max",
+  },
 };
 
 // MoonshotAI.
 const KIMI_K2_7_CODE: NeuralwattModelFamily = {
-  cost: { input: 0.95, output: 4.0, cacheRead: 0.2375 },
+  cost: { input: 0.95, output: 4.0, cacheRead: 0.095 },
   vision: true,
   thinkingLevelMap: { off: null, ...BINARY_THINKING },
 };
 
-// Qwen.
-const QWEN_3_5_397B: NeuralwattModelFamily = {
-  cost: { input: 0.69, output: 4.14, cacheRead: 0.1725 },
-  vision: false,
-  thinkingLevelMap: BINARY_THINKING,
-};
-
 // Qwen.
 const QWEN_3_6_35B: NeuralwattModelFamily = {
-  cost: { input: 0.29, output: 1.15, cacheRead: 0.0725 },
+  cost: { input: 0.29, output: 1.15, cacheRead: 0.029 },
   vision: true,
   thinkingLevelMap: BINARY_THINKING,
 };
@@ -174,30 +186,22 @@ const FAMILIES: [NeuralwattModelFamily, NeuralwattVariantSpec[]][] = [
     ],
   ],
   [
-    KIMI_K2_6,
+    KIMI_K3,
     [
       {
-        id: "kimi-k2.6",
-        name: "Kimi K2.6",
-        contextWindow: 262128,
+        id: "kimi-k3",
+        name: "Kimi K3",
+        contextWindow: 1048560,
         maxOutputTokens: null,
         reasoning: true,
       },
       {
-        id: "kimi-k2.6-fast",
-        name: "Kimi K2.6 Fast",
-        contextWindow: 262128,
+        id: "kimi-k3-fast",
+        name: "Kimi K3 Fast",
+        contextWindow: 1048560,
         maxOutputTokens: null,
         reasoning: false,
       },
-      {
-        id: "kimi-k2.6-flex",
-        name: "Kimi K2.6 (flex)",
-        contextWindow: 262128,
-        maxOutputTokens: null,
-        reasoning: true,
-        costMultiplier: FLEX_COST_MULTIPLIER,
-      },
     ],
   ],
   [
@@ -227,25 +231,6 @@ const FAMILIES: [NeuralwattModelFamily, NeuralwattVariantSpec[]][] = [
       },
     ],
   ],
-  [
-    QWEN_3_5_397B,
-    [
-      {
-        id: "qwen3.5-397b",
-        name: "Qwen3.5 397B",
-        contextWindow: 262128,
-        maxOutputTokens: null,
-        reasoning: true,
-      },
-      {
-        id: "qwen3.5-397b-fast",
-        name: "Qwen3.5 397B Fast",
-        contextWindow: 262128,
-        maxOutputTokens: null,
-        reasoning: false,
-      },
-    ],
-  ],
   [
     QWEN_3_6_35B,
     [
@@ -269,8 +254,9 @@ const FAMILIES: [NeuralwattModelFamily, NeuralwattVariantSpec[]][] = [
 
 // `-flex` variants are the Flex tier: same model, context window, output cap,
 // and prompt cache as the standard variant, admitted on spare capacity.
-// /v1/models does not advertise them (not even to an authenticated key), so they
-// stay hardcoded here and the drift check in models.test.ts skips them.
+// The API now advertises flex variants but lists them at standard pricing;
+// the 35% Flex discount is a billing-time concept applied here via
+// `costMultiplier` rather than reflected in the catalog metadata.
 // https://portal.neuralwatt.com/docs/guides/flex-tier
 
 export const NEURALWATT_MODELS: ProviderModelConfig[] = FAMILIES.flatMap(

package/extensions/provider/models/refresh.ts

@@ -5,6 +5,10 @@ import type {
   RefreshModelsContext,
 } from "@earendil-works/pi-ai";
 import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
+import {
+  ALIAS_NEURALWATT_MODEL_IDS,
+  buildAliasNeuralwattModels,
+} from "./aliases";
 import {
   EARLY_ACCESS_NEURALWATT_MODELS,
   loadEarlyAccessModels,
@@ -18,16 +22,28 @@ const API = "openai-completions" as const;
 
 export interface RefreshNeuralwattModelsOptions {
   includeLegacyModelIds: boolean;
+  includeAliasedModelIds: boolean;
   includeEarlyAccessModels: boolean;
   loadEarlyAccess?: typeof loadEarlyAccessModels;
 }
 
 function configuredModels(
   includeLegacyModelIds: boolean,
+  includeAliasedModelIds: boolean,
+  extraCanonicalModels: ProviderModelConfig[] = [],
 ): ProviderModelConfig[] {
-  return includeLegacyModelIds
-    ? [...NEURALWATT_MODELS, ...buildLegacyNeuralwattModels()]
-    : [...NEURALWATT_MODELS];
+  const canonicalModels = [...NEURALWATT_MODELS, ...extraCanonicalModels];
+  const models: ProviderModelConfig[] = [...canonicalModels];
+
+  if (includeLegacyModelIds) {
+    models.push(...buildLegacyNeuralwattModels());
+  }
+
+  if (includeAliasedModelIds) {
+    models.push(...buildAliasNeuralwattModels(canonicalModels));
+  }
+
+  return models;
 }
 
 function toStoredModel(model: ProviderModelConfig): Model<Api> {
@@ -91,11 +107,16 @@ function cachedEarlyAccessModels(
 ): ProviderModelConfig[] {
   if (!stored) return [];
 
-  const allStaticIds = new Set(configuredModels(true).map((model) => model.id));
+  const allStaticIds = new Set(
+    configuredModels(true, true).map((model) => model.id),
+  );
 
   return stored.models
     .filter(
-      (model) => model.provider === PROVIDER_ID && !allStaticIds.has(model.id),
+      (model) =>
+        model.provider === PROVIDER_ID &&
+        !allStaticIds.has(model.id) &&
+        !ALIAS_NEURALWATT_MODEL_IDS.has(model.id),
     )
     .map(toProviderModel);
 }
@@ -115,7 +136,10 @@ export async function refreshNeuralwattModels(
   context: RefreshModelsContext,
   options: RefreshNeuralwattModelsOptions,
 ): Promise<ProviderModelConfig[]> {
-  const baseline = configuredModels(options.includeLegacyModelIds);
+  const baseline = configuredModels(
+    options.includeLegacyModelIds,
+    options.includeAliasedModelIds,
+  );
   const stored = await context.store.read();
 
   if (!options.includeEarlyAccessModels) {
@@ -127,7 +151,11 @@ export async function refreshNeuralwattModels(
     cachedEarlyAccessModels(stored),
     baseline,
   );
-  const cachedCatalog = [...baseline, ...cachedEarlyAccess];
+  const cachedCatalog = configuredModels(
+    options.includeLegacyModelIds,
+    options.includeAliasedModelIds,
+    cachedEarlyAccess,
+  );
 
   if (!context.allowNetwork || context.signal?.aborted) {
     return cachedCatalog;
@@ -146,10 +174,11 @@ export async function refreshNeuralwattModels(
     throw new Error("Neuralwatt model catalog refresh failed");
   }
 
-  const catalog = [
-    ...baseline,
-    ...configuredEarlyAccessModels(earlyAccess, baseline),
-  ];
+  const catalog = configuredModels(
+    options.includeLegacyModelIds,
+    options.includeAliasedModelIds,
+    configuredEarlyAccessModels(earlyAccess, baseline),
+  );
   await persistModels(context, catalog);
   return catalog;
 }

package/extensions/quota-warnings/index.ts

@@ -17,7 +17,8 @@ export default async function (pi: ExtensionAPI) {
   await configLoader.load();
 
   let enabled = configLoader.getConfig().quotaWarnings.enabled;
-  let currentContext: ExtensionContext | undefined;
+  let currentProvider: string | undefined;
+  let unsubscribeQuotas: (() => void) | undefined;
 
   // Listen for config changes at runtime
   pi.events.on(NEURALWATT_CONFIG_UPDATED_EVENT, (data: unknown) => {
@@ -29,32 +30,44 @@ export default async function (pi: ExtensionAPI) {
     }
   });
 
-  pi.events.on(NEURALWATT_QUOTAS_UPDATED_EVENT, (data: unknown) => {
+  // The quota handler runs on the shared event bus, so it must only touch a
+  // session ctx captured by a live session-scoped subscription: pi
+  // invalidates session-bound ctx after session replacement (newSession/
+  // fork/switchSession/reload), and dereferencing a stale ctx throws. We
+  // subscribe in session_start (capturing the fresh ctx in the closure) and
+  // unsubscribe in session_shutdown, before the ctx can go stale.
+  function handleQuotas(ctx: ExtensionContext, data: unknown): void {
     if (!enabled) return;
     if (!data || typeof data !== "object") return;
-    if (!currentContext) return;
-    if (currentContext.model?.provider !== "neuralwatt") return;
+    if (currentProvider !== "neuralwatt") return;
 
     const { quotas } = data as NeuralwattQuotasUpdatedPayload;
-    checkQuotas(currentContext, quotas);
-  });
+    checkQuotas(ctx, quotas);
+  }
 
   pi.on("session_start", async (_event, ctx) => {
-    currentContext = ctx;
-    if (ctx.model?.provider !== "neuralwatt") return;
+    unsubscribeQuotas?.();
+    currentProvider = ctx.model?.provider;
+    unsubscribeQuotas = pi.events.on(NEURALWATT_QUOTAS_UPDATED_EVENT, (data) =>
+      handleQuotas(ctx, data),
+    );
+
+    if (currentProvider !== "neuralwatt") return;
     clearAlertState();
   });
 
   pi.on("model_select", (_event, ctx) => {
-    currentContext = ctx;
+    currentProvider = ctx.model?.provider;
   });
 
   pi.on("session_before_switch", (_event, ctx) => {
-    currentContext = ctx;
+    currentProvider = ctx.model?.provider;
   });
 
   pi.on("session_shutdown", () => {
-    currentContext = undefined;
+    unsubscribeQuotas?.();
+    unsubscribeQuotas = undefined;
+    currentProvider = undefined;
     clearAlertState();
   });
 

package/extensions/sub-bar-integration/index.ts

@@ -57,7 +57,7 @@ export default async function (pi: ExtensionAPI) {
   let enabled = configLoader.getConfig().subBarIntegration.enabled;
   let subCoreReady = false;
   let currentProvider: string | undefined;
-  let currentContext: ExtensionContext | undefined;
+  let unsubscribeQuotas: (() => void) | undefined;
 
   // Listen for config changes at runtime
   pi.events.on(NEURALWATT_CONFIG_UPDATED_EVENT, (data: unknown) => {
@@ -82,32 +82,35 @@ export default async function (pi: ExtensionAPI) {
     pi.events.emit(NEURALWATT_QUOTAS_REQUEST_EVENT, undefined);
   }
 
-  pi.events.on(NEURALWATT_QUOTAS_UPDATED_EVENT, (data: unknown) => {
+  // The quota handler runs on the shared event bus, so it must only touch a
+  // session ctx captured by a live session-scoped subscription: pi
+  // invalidates session-bound ctx after session replacement (newSession/
+  // fork/switchSession/reload), and dereferencing a stale ctx throws. We
+  // subscribe in session_start (capturing the fresh ctx in the closure) and
+  // unsubscribe in session_shutdown, before the ctx can go stale.
+  function handleQuotas(ctx: ExtensionContext, data: unknown): void {
     if (!isActive() || !subCoreReady || !enabled) return;
     if (!data || typeof data !== "object") return;
     const { quotas } = data as NeuralwattQuotasUpdatedPayload;
     emitUsage(quotas);
 
-    if (currentContext) {
-      currentContext.ui.setStatus(
-        "neuralwatt-usage",
-        formatStatus(quotas, currentContext.ui.theme),
-      );
-    }
-  });
+    ctx.ui.setStatus("neuralwatt-usage", formatStatus(quotas, ctx.ui.theme));
+  }
 
   pi.events.on("sub-core:ready", () => {
     subCoreReady = true;
   });
 
   pi.on("session_start", async (_event, ctx) => {
+    unsubscribeQuotas?.();
     currentProvider = ctx.model?.provider;
-    currentContext = ctx;
+    unsubscribeQuotas = pi.events.on(NEURALWATT_QUOTAS_UPDATED_EVENT, (data) =>
+      handleQuotas(ctx, data),
+    );
   });
 
   pi.on("model_select", async (_event, ctx) => {
     currentProvider = ctx.model?.provider;
-    currentContext = ctx;
 
     if (subCoreReady && isActive() && enabled) {
       requestQuotas();
@@ -115,8 +118,9 @@ export default async function (pi: ExtensionAPI) {
   });
 
   pi.on("session_shutdown", () => {
+    unsubscribeQuotas?.();
+    unsubscribeQuotas = undefined;
     currentProvider = undefined;
-    currentContext = undefined;
   });
 
   pi.events.on(NEURALWATT_EXTENSIONS_REQUEST_EVENT, () => {

package/package.json

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

package/schema.json

@@ -31,6 +31,10 @@
     "NeuralwattProviderConfig": {
       "additionalProperties": false,
       "properties": {
+        "includeAliasedModelIds": {
+          "description": "Include alternate creator-scoped Neuralwatt model IDs in the model picker.",
+          "type": "boolean"
+        },
         "includeEarlyAccessModels": {
           "description": "Include early-access Neuralwatt models discovered via the authenticated API.",
           "type": "boolean"

package/src/config/defaults.ts

@@ -3,6 +3,7 @@ import type { ResolvedNeuralwattConfig } from "./types";
 export const DEFAULT_CONFIG: ResolvedNeuralwattConfig = {
   provider: {
     includeLegacyModelIds: false,
+    includeAliasedModelIds: false,
     includeEarlyAccessModels: false,
   },
   quotaCommand: {

package/src/config/loader.ts

@@ -18,6 +18,9 @@ function normalizeResolvedConfig(
       includeLegacyModelIds:
         config.provider?.includeLegacyModelIds ??
         DEFAULT_CONFIG.provider.includeLegacyModelIds,
+      includeAliasedModelIds:
+        config.provider?.includeAliasedModelIds ??
+        DEFAULT_CONFIG.provider.includeAliasedModelIds,
       includeEarlyAccessModels:
         config.provider?.includeEarlyAccessModels ??
         DEFAULT_CONFIG.provider.includeEarlyAccessModels,

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

@@ -0,0 +1,49 @@
+import type { Migration } from "@aliou/pi-utils-settings";
+import type { NeuralwattConfig } from "../types";
+
+/** The provider section before alias IDs got a separate setting. */
+interface PreviousProviderConfig {
+  includeLegacyModelIds?: boolean;
+  includeAliasedModelIds?: boolean;
+  includeEarlyAccessModels?: boolean;
+}
+
+function previousProvider(
+  config: NeuralwattConfig,
+): PreviousProviderConfig | undefined {
+  if (!("provider" in config)) return undefined;
+  const { provider } = config;
+  return provider && typeof provider === "object"
+    ? (provider as PreviousProviderConfig)
+    : undefined;
+}
+
+/**
+ * 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<NeuralwattConfig> =
+  {
+    name: "enable-alias-model-ids-for-legacy-users",
+    shouldRun: (config) => {
+      const provider = previousProvider(config);
+      return (
+        provider?.includeLegacyModelIds === true &&
+        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 = previousProvider(config);
+      if (!provider) return config;
+
+      return {
+        ...config,
+        provider: {
+          ...provider,
+          includeAliasedModelIds: true,
+        },
+      };
+    },
+  };

package/src/config/migration/index.ts

@@ -7,13 +7,16 @@ 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 { disableLegacyModelIdsByDefaultMigration } from "./01-disable-legacy-model-ids-by-default";
 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";
 
 export const migrations: Migration<NeuralwattConfig>[] = [
   disableLegacyModelIdsByDefaultMigration,
   flatToNestedConfigMigration,
   renameHiddenToEarlyAccessMigration,
+  enableAliasesForLegacyUsersMigration,
 ];

package/src/config/types.ts

@@ -2,6 +2,9 @@ export interface NeuralwattProviderConfig {
   /** Include legacy Neuralwatt model IDs in the model picker. */
   includeLegacyModelIds?: boolean;
 
+  /** Include alternate creator-scoped Neuralwatt model IDs in the model picker. */
+  includeAliasedModelIds?: boolean;
+
   /** Include early-access Neuralwatt models discovered via the authenticated API. */
   includeEarlyAccessModels?: boolean;
 }
@@ -41,6 +44,7 @@ export interface NeuralwattConfig {
 export interface ResolvedNeuralwattConfig {
   provider: {
     includeLegacyModelIds: boolean;
+    includeAliasedModelIds: boolean;
     includeEarlyAccessModels: boolean;
   };
   quotaCommand: {