@aliou/pi-neuralwatt 0.10.4 → 0.10.6

package/extensions/provider/models/refresh.ts

@@ -5,7 +5,10 @@ import type {
   RefreshModelsContext,
 } from "@earendil-works/pi-ai";
 import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
-import { HIDDEN_NEURALWATT_MODELS, loadHiddenModels } from "./hidden";
+import {
+  EARLY_ACCESS_NEURALWATT_MODELS,
+  loadEarlyAccessModels,
+} from "./early-access";
 import { buildLegacyNeuralwattModels } from "./legacy";
 import { NEURALWATT_MODELS } from "./public-models";
 
@@ -15,8 +18,8 @@ const API = "openai-completions" as const;
 
 export interface RefreshNeuralwattModelsOptions {
   includeLegacyModelIds: boolean;
-  includeHiddenModels: boolean;
-  loadHidden?: typeof loadHiddenModels;
+  includeEarlyAccessModels: boolean;
+  loadEarlyAccess?: typeof loadEarlyAccessModels;
 }
 
 function configuredModels(
@@ -59,31 +62,31 @@ function toProviderModel(model: Model<Api>): ProviderModelConfig {
   };
 }
 
-function dedupeHiddenModels(
-  hiddenModels: ProviderModelConfig[],
+function dedupeEarlyAccessModels(
+  earlyAccessModels: ProviderModelConfig[],
   baselineModels: ProviderModelConfig[],
 ): ProviderModelConfig[] {
   const baselineIds = new Set(baselineModels.map((model) => model.id));
-  return hiddenModels.filter((model) => !baselineIds.has(model.id));
+  return earlyAccessModels.filter((model) => !baselineIds.has(model.id));
 }
 
-function configuredHiddenModels(
+function configuredEarlyAccessModels(
   discoveredModels: ProviderModelConfig[],
   baselineModels: ProviderModelConfig[],
 ): ProviderModelConfig[] {
   const hardcodedIds = new Set(
-    HIDDEN_NEURALWATT_MODELS.map((model) => model.id),
+    EARLY_ACCESS_NEURALWATT_MODELS.map((model) => model.id),
   );
-  return dedupeHiddenModels(
+  return dedupeEarlyAccessModels(
     [
-      ...HIDDEN_NEURALWATT_MODELS,
+      ...EARLY_ACCESS_NEURALWATT_MODELS,
       ...discoveredModels.filter((model) => !hardcodedIds.has(model.id)),
     ],
     baselineModels,
   );
 }
 
-function cachedHiddenModels(
+function cachedEarlyAccessModels(
   stored: ModelsStoreEntry | undefined,
 ): ProviderModelConfig[] {
   if (!stored) return [];
@@ -115,16 +118,16 @@ export async function refreshNeuralwattModels(
   const baseline = configuredModels(options.includeLegacyModelIds);
   const stored = await context.store.read();
 
-  if (!options.includeHiddenModels) {
+  if (!options.includeEarlyAccessModels) {
     await persistModels(context, baseline);
     return baseline;
   }
 
-  const cachedHidden = configuredHiddenModels(
-    cachedHiddenModels(stored),
+  const cachedEarlyAccess = configuredEarlyAccessModels(
+    cachedEarlyAccessModels(stored),
     baseline,
   );
-  const cachedCatalog = [...baseline, ...cachedHidden];
+  const cachedCatalog = [...baseline, ...cachedEarlyAccess];
 
   if (!context.allowNetwork || context.signal?.aborted) {
     return cachedCatalog;
@@ -134,16 +137,19 @@ export async function refreshNeuralwattModels(
     context.credential?.type === "api_key" ? context.credential.key : undefined;
   if (!apiKey) return cachedCatalog;
 
-  const hidden = await (options.loadHidden ?? loadHiddenModels)(
+  const earlyAccess = await (options.loadEarlyAccess ?? loadEarlyAccessModels)(
     apiKey,
     context.signal,
   );
   if (context.signal?.aborted) return cachedCatalog;
-  if (!hidden) {
+  if (!earlyAccess) {
     throw new Error("Neuralwatt model catalog refresh failed");
   }
 
-  const catalog = [...baseline, ...configuredHiddenModels(hidden, baseline)];
+  const catalog = [
+    ...baseline,
+    ...configuredEarlyAccessModels(earlyAccess, baseline),
+  ];
   await persistModels(context, catalog);
   return catalog;
 }

package/package.json

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

package/schema.json

@@ -31,8 +31,8 @@
     "NeuralwattProviderConfig": {
       "additionalProperties": false,
       "properties": {
-        "includeHiddenModels": {
-          "description": "Include hidden Neuralwatt models discovered via the authenticated API.",
+        "includeEarlyAccessModels": {
+          "description": "Include early-access Neuralwatt models discovered via the authenticated API.",
           "type": "boolean"
         },
         "includeLegacyModelIds": {

package/src/config/defaults.ts

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

package/src/config/index.ts

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

package/src/config/loader.ts

@@ -2,70 +2,44 @@ import { buildSchemaUrl, ConfigLoader } from "@aliou/pi-utils-settings";
 import packageJson from "../../package.json";
 import { DEFAULT_CONFIG } from "./defaults";
 import { migrations } from "./migration";
-import type { NeuralwattRawConfig, ResolvedNeuralwattConfig } from "./types";
-
-type ConfigRecord = Record<string, unknown>;
-
-type MaybeEnabled = { enabled?: boolean };
-type MaybeProvider = {
-  includeLegacyModelIds?: boolean;
-  includeHiddenModels?: boolean;
-};
-
-function featureEnabled(value: unknown, fallback: boolean): boolean {
-  if (typeof value === "boolean") return value;
-  if (value && typeof value === "object") {
-    const { enabled } = value as MaybeEnabled;
-    if (typeof enabled === "boolean") return enabled;
-  }
-  return fallback;
-}
+import type { NeuralwattConfig, ResolvedNeuralwattConfig } from "./types";
 
+/**
+ * Fill in every field the rest of the code reads. Migrations already normalized
+ * the on-disk shape, so this only merges partial sections with the defaults.
+ */
 function normalizeResolvedConfig(
   resolved: ResolvedNeuralwattConfig,
 ): ResolvedNeuralwattConfig {
-  const record = resolved as unknown as ConfigRecord;
-  const provider =
-    record.provider && typeof record.provider === "object"
-      ? (record.provider as MaybeProvider)
-      : {};
+  const config = resolved as Partial<ResolvedNeuralwattConfig>;
 
   return {
     provider: {
       includeLegacyModelIds:
-        provider.includeLegacyModelIds ??
-        (typeof record.includeLegacyModelIds === "boolean"
-          ? record.includeLegacyModelIds
-          : DEFAULT_CONFIG.provider.includeLegacyModelIds),
-      includeHiddenModels:
-        provider.includeHiddenModels ??
-        (typeof record.includeHiddenModels === "boolean"
-          ? record.includeHiddenModels
-          : DEFAULT_CONFIG.provider.includeHiddenModels),
+        config.provider?.includeLegacyModelIds ??
+        DEFAULT_CONFIG.provider.includeLegacyModelIds,
+      includeEarlyAccessModels:
+        config.provider?.includeEarlyAccessModels ??
+        DEFAULT_CONFIG.provider.includeEarlyAccessModels,
     },
     quotaCommand: {
-      enabled: featureEnabled(
-        record.quotaCommand,
-        DEFAULT_CONFIG.quotaCommand.enabled,
-      ),
+      enabled:
+        config.quotaCommand?.enabled ?? DEFAULT_CONFIG.quotaCommand.enabled,
     },
     quotaWarnings: {
-      enabled: featureEnabled(
-        record.quotaWarnings,
-        DEFAULT_CONFIG.quotaWarnings.enabled,
-      ),
+      enabled:
+        config.quotaWarnings?.enabled ?? DEFAULT_CONFIG.quotaWarnings.enabled,
     },
     subBarIntegration: {
-      enabled: featureEnabled(
-        record.subBarIntegration,
+      enabled:
+        config.subBarIntegration?.enabled ??
         DEFAULT_CONFIG.subBarIntegration.enabled,
-      ),
     },
   };
 }
 
 export const configLoader = new ConfigLoader<
-  NeuralwattRawConfig,
+  NeuralwattConfig,
   ResolvedNeuralwattConfig
 >("neuralwatt", DEFAULT_CONFIG, {
   migrations,

package/src/config/migration/01-disable-legacy-model-ids-by-default.ts

@@ -1,7 +1,5 @@
 import type { Migration } from "@aliou/pi-utils-settings";
-import type { NeuralwattConfig, PreviousNeuralwattConfig } from "../types";
-
-type MigrationConfig = PreviousNeuralwattConfig | NeuralwattConfig;
+import type { NeuralwattConfig } from "../types";
 
 type MutableConfigRecord = Record<string, unknown>;
 
@@ -9,7 +7,7 @@ function hasOwn(record: MutableConfigRecord, key: string): boolean {
   return Object.hasOwn(record, key);
 }
 
-function hasNestedConfig(config: MigrationConfig): boolean {
+function hasNestedConfig(config: NeuralwattConfig): boolean {
   return Boolean(
     ("provider" in config && config.provider) ||
       (config.quotaCommand && typeof config.quotaCommand === "object") ||
@@ -20,25 +18,25 @@ function hasNestedConfig(config: MigrationConfig): boolean {
 }
 
 function isPreviousConfigWithoutLegacyDefault(
-  config: MigrationConfig,
-): config is PreviousNeuralwattConfig {
+  config: NeuralwattConfig,
+): boolean {
   return (
     !hasNestedConfig(config) &&
     !hasOwn(config as MutableConfigRecord, "includeLegacyModelIds")
   );
 }
 
-export const disableLegacyModelIdsByDefaultMigration: Migration<MigrationConfig> =
+export const disableLegacyModelIdsByDefaultMigration: Migration<NeuralwattConfig> =
   {
     name: "disable-legacy-model-ids-by-default",
     shouldRun: isPreviousConfigWithoutLegacyDefault,
     message:
       "[neuralwatt] legacy model IDs (ids including the provider and the quantization) are disabled by default. You can enable them with /neuralwatt:settings.",
-    run: (config) => {
-      const previous = config as PreviousNeuralwattConfig;
-      return {
-        ...previous,
+    // Flat config: `includeLegacyModelIds` sits at the top level here. Migration
+    // 02 moves it under `provider`.
+    run: (config) =>
+      ({
+        ...config,
         includeLegacyModelIds: false,
-      };
-    },
+      }) as unknown as NeuralwattConfig,
   };

package/src/config/migration/02-flat-to-nested-config.ts

@@ -3,11 +3,27 @@ import { copyFile } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
 import type { Migration } from "@aliou/pi-utils-settings";
 import packageJson from "../../../package.json";
-import type { NeuralwattConfig, PreviousNeuralwattConfig } from "../types";
+import type { NeuralwattConfig } from "../types";
 
-type MigrationConfig = PreviousNeuralwattConfig | NeuralwattConfig;
+/** The original flat config, replaced by per-feature sections. */
+interface FlatNeuralwattConfig {
+  /** Show the quota command (/neuralwatt:quota). */
+  quotaCommand?: boolean;
 
-type FlatConfigKey = keyof Omit<PreviousNeuralwattConfig, "$schema">;
+  /** Show quota warnings when credits or energy are low. */
+  quotaWarnings?: boolean;
+
+  /** Show usage in the sub-bar / status bar. */
+  subBarIntegration?: boolean;
+
+  /** Include legacy Neuralwatt model IDs in the model picker. */
+  includeLegacyModelIds?: boolean;
+
+  /** Renamed to `provider.includeEarlyAccessModels` by migration 03. */
+  includeHiddenModels?: boolean;
+}
+
+type FlatConfigKey = keyof FlatNeuralwattConfig;
 type MutableConfigRecord = Record<string, unknown>;
 
 const FLAT_CONFIG_KEYS = [
@@ -34,9 +50,7 @@ function isObject(value: unknown): value is Record<string, unknown> {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
-function isPreviousConfig(
-  config: MigrationConfig,
-): config is PreviousNeuralwattConfig {
+function isPreviousConfig(config: NeuralwattConfig): boolean {
   const record = config as MutableConfigRecord;
   return FLAT_CONFIG_KEYS.some((key) => typeof record[key] === "boolean");
 }
@@ -64,16 +78,15 @@ export async function backupConfig(filePath: string): Promise<void> {
   }
 }
 
-export const flatToNestedConfigMigration: Migration<MigrationConfig> = {
+export const flatToNestedConfigMigration: Migration<NeuralwattConfig> = {
   name: "flat-to-nested-config",
   shouldRun: isPreviousConfig,
   message: FLAT_CONFIG_MIGRATION_MESSAGE,
   run: async (config, filePath) => {
     await backupConfig(filePath);
 
-    const previous = config as PreviousNeuralwattConfig;
-    const nestedConfig = config as NeuralwattConfig;
-    const record = previous as MutableConfigRecord;
+    const nestedConfig = config;
+    const record = config as unknown as MutableConfigRecord;
     const nested: NeuralwattConfig = {
       provider: {
         ...(isObject(nestedConfig.provider) ? nestedConfig.provider : {}),
@@ -100,14 +113,18 @@ export const flatToNestedConfigMigration: Migration<MigrationConfig> = {
       };
     }
 
-    const includeHiddenModels = booleanValue(record, "includeHiddenModels");
+    // Flat configs predate the rename, so they still use `includeHiddenModels`.
+    const includeEarlyAccessModels = booleanValue(
+      record,
+      "includeHiddenModels",
+    );
     if (
-      nested.provider?.includeHiddenModels === undefined &&
-      includeHiddenModels !== undefined
+      nested.provider?.includeEarlyAccessModels === undefined &&
+      includeEarlyAccessModels !== undefined
     ) {
       nested.provider = {
         ...nested.provider,
-        includeHiddenModels,
+        includeEarlyAccessModels,
       };
     }
 

package/src/config/migration/03-rename-hidden-to-early-access.ts

@@ -0,0 +1,47 @@
+import type { Migration } from "@aliou/pi-utils-settings";
+import type { NeuralwattConfig } from "../types";
+
+/** The provider section before `includeHiddenModels` was renamed. */
+interface PreviousProviderConfig {
+  includeLegacyModelIds?: boolean;
+  includeEarlyAccessModels?: boolean;
+  /** Renamed to `includeEarlyAccessModels`. */
+  includeHiddenModels?: 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;
+}
+
+/**
+ * `provider.includeHiddenModels` was renamed to `provider.includeEarlyAccessModels`.
+ * The models were never hidden, only released to authorized accounts first.
+ */
+export const renameHiddenToEarlyAccessMigration: Migration<NeuralwattConfig> = {
+  name: "rename-hidden-models-to-early-access",
+  shouldRun: (config) =>
+    previousProvider(config)?.includeHiddenModels !== undefined,
+  message:
+    "[neuralwatt] `provider.includeHiddenModels` is now `provider.includeEarlyAccessModels`.",
+  run: (config) => {
+    const provider = previousProvider(config);
+    if (!provider) return config;
+
+    const { includeHiddenModels, ...rest } = provider;
+
+    return {
+      ...config,
+      provider: {
+        ...rest,
+        includeEarlyAccessModels:
+          rest.includeEarlyAccessModels ?? includeHiddenModels,
+      },
+    };
+  },
+};

package/src/config/migration/index.ts

@@ -1,16 +1,19 @@
 import type { Migration } from "@aliou/pi-utils-settings";
-import type { NeuralwattRawConfig } from "../types";
+import type { NeuralwattConfig } from "../types";
 
 export { disableLegacyModelIdsByDefaultMigration } from "./01-disable-legacy-model-ids-by-default";
 export {
   backupConfig,
   flatToNestedConfigMigration,
 } from "./02-flat-to-nested-config";
+export { renameHiddenToEarlyAccessMigration } from "./03-rename-hidden-to-early-access";
 
 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";
 
-export const migrations: Migration<NeuralwattRawConfig>[] = [
+export const migrations: Migration<NeuralwattConfig>[] = [
   disableLegacyModelIdsByDefaultMigration,
   flatToNestedConfigMigration,
+  renameHiddenToEarlyAccessMigration,
 ];

package/src/config/types.ts

@@ -1,29 +1,9 @@
-export interface PreviousNeuralwattConfig {
-  /** $schema URL for editor autocomplete. */
-  $schema?: string;
-
-  /** Show the quota command (/neuralwatt:quota). */
-  quotaCommand?: boolean;
-
-  /** Show quota warnings when credits or energy are low. */
-  quotaWarnings?: boolean;
-
-  /** Show usage in the sub-bar / status bar. */
-  subBarIntegration?: boolean;
-
-  /** Include legacy Neuralwatt model IDs in the model picker. */
-  includeLegacyModelIds?: boolean;
-
-  /** Include hidden Neuralwatt models discovered via the authenticated API. */
-  includeHiddenModels?: boolean;
-}
-
 export interface NeuralwattProviderConfig {
   /** Include legacy Neuralwatt model IDs in the model picker. */
   includeLegacyModelIds?: boolean;
 
-  /** Include hidden Neuralwatt models discovered via the authenticated API. */
-  includeHiddenModels?: boolean;
+  /** Include early-access Neuralwatt models discovered via the authenticated API. */
+  includeEarlyAccessModels?: boolean;
 }
 
 export interface NeuralwattQuotaCommandConfig {
@@ -58,12 +38,10 @@ export interface NeuralwattConfig {
   subBarIntegration?: NeuralwattSubBarIntegrationConfig;
 }
 
-export type NeuralwattRawConfig = PreviousNeuralwattConfig | NeuralwattConfig;
-
 export interface ResolvedNeuralwattConfig {
   provider: {
     includeLegacyModelIds: boolean;
-    includeHiddenModels: boolean;
+    includeEarlyAccessModels: boolean;
   };
   quotaCommand: {
     enabled: boolean;