@aliou/pi-neuralwatt 0.14.2 → 0.15.0

package/extensions/provider/provider.ts

@@ -5,12 +5,15 @@ import type {
   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,
+import type { NeuralwattModel } from "./models/catalog";
+import {
+  buildNeuralwattProviderModelsFromApi,
+  buildNeuralwattProviderModelsFromStore,
+} from "./models/catalog";
+import {
+  createNeuralwattRefreshModels,
+  type FetchNeuralwattApiModels,
 } from "./models/refresh";
-import { refreshNeuralwattModels } from "./models/refresh";
 import type { AnyStreamSimple } from "./stream-simple";
 
 export const NEURALWATT_PROVIDER_ID = "neuralwatt";
@@ -24,9 +27,7 @@ const NEURALWATT_REQUEST_HEADERS = {
 
 const API = "openai-completions" as const;
 
-function toProviderModels(
-  models: readonly ProviderModelConfig[],
-): Model<Api>[] {
+function toProviderModels(models: NeuralwattModel[]): Model<Api>[] {
   return models.map((model) => ({
     ...model,
     api: model.api ?? API,
@@ -37,11 +38,17 @@ function toProviderModels(
 }
 
 export function createNeuralwattProvider(
-  staticModels: ProviderModelConfig[],
-  refreshOptions: () => RefreshNeuralwattModelsOptions,
+  staticModels: NeuralwattModel[],
+  fetchApiModels: FetchNeuralwattApiModels,
   streamSimpleOverride?: AnyStreamSimple,
 ): Provider {
   let liveModels = toProviderModels(staticModels);
+  const refreshCatalog = createNeuralwattRefreshModels(
+    staticModels,
+    fetchApiModels,
+    buildNeuralwattProviderModelsFromApi,
+    buildNeuralwattProviderModelsFromStore,
+  );
 
   return {
     id: NEURALWATT_PROVIDER_ID,
@@ -65,8 +72,6 @@ export function createNeuralwattProvider(
           if (await ctx.env(NEURALWATT_API_KEY_ENV)) {
             return { type: "api_key", source: NEURALWATT_API_KEY_ENV };
           }
-          // Anonymous availability: requests resolve with an empty key, and
-          // in aperture proxy mode the gateway owns auth.
           return { type: "api_key", source: "anonymous" };
         },
         resolve: async ({ ctx, credential, signal }) => {
@@ -83,28 +88,16 @@ export function createNeuralwattProvider(
           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);
+      const models = await refreshCatalog(context);
       await context.publish({
         update: () => {
-          liveModels = adopted;
+          liveModels = toProviderModels(models);
         },
       });
     },

package/package.json

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

package/schema.json

@@ -8,10 +8,6 @@
         "$schema": {
           "type": "string"
         },
-        "provider": {
-          "$ref": "#/definitions/NeuralwattProviderConfig",
-          "description": "Provider/model behavior."
-        },
         "quotaCommand": {
           "$ref": "#/definitions/NeuralwattQuotaCommandConfig",
           "description": "Quota command feature."
@@ -40,24 +36,6 @@
       },
       "additionalProperties": false
     },
-    "NeuralwattProviderConfig": {
-      "type": "object",
-      "properties": {
-        "includeLegacyModelIds": {
-          "type": "boolean",
-          "description": "Include legacy Neuralwatt model IDs in the model picker."
-        },
-        "includeAliasedModelIds": {
-          "type": "boolean",
-          "description": "Include alternate creator-scoped Neuralwatt model IDs in the model picker."
-        },
-        "includeEarlyAccessModels": {
-          "type": "boolean",
-          "description": "Include early-access Neuralwatt models discovered via the authenticated API."
-        }
-      },
-      "additionalProperties": false
-    },
     "NeuralwattQuotaCommandConfig": {
       "type": "object",
       "properties": {

package/src/config/defaults.ts

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

package/src/config/loader.ts

@@ -14,17 +14,6 @@ function normalizeResolvedConfig(
   const config = resolved as Partial<ResolvedNeuralwattConfig>;
 
   return {
-    provider: {
-      includeLegacyModelIds:
-        config.provider?.includeLegacyModelIds ??
-        DEFAULT_CONFIG.provider.includeLegacyModelIds,
-      includeAliasedModelIds:
-        config.provider?.includeAliasedModelIds ??
-        DEFAULT_CONFIG.provider.includeAliasedModelIds,
-      includeEarlyAccessModels:
-        config.provider?.includeEarlyAccessModels ??
-        DEFAULT_CONFIG.provider.includeEarlyAccessModels,
-    },
     quotaCommand: {
       enabled:
         config.quotaCommand?.enabled ?? DEFAULT_CONFIG.quotaCommand.enabled,

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

@@ -1,43 +1,30 @@
 import type { Migration } from "@aliou/pi-utils-settings";
-import type { NeuralwattConfig } from "../types";
 
-type MutableConfigRecord = Record<string, unknown>;
-
-function hasOwn(record: MutableConfigRecord, key: string): boolean {
-  return Object.hasOwn(record, key);
-}
-
-function hasNestedConfig(config: NeuralwattConfig): boolean {
-  return Boolean(
-    ("provider" in config && config.provider) ||
-      (config.quotaCommand && typeof config.quotaCommand === "object") ||
-      (config.quotaWarnings && typeof config.quotaWarnings === "object") ||
-      (config.subBarIntegration &&
-        typeof config.subBarIntegration === "object"),
-  );
+/** Flat config shape before the 0.8.x nested migration. */
+interface FlatNeuralwattConfig {
+  $schema?: string;
+  quotaCommand?: boolean;
+  quotaWarnings?: boolean;
+  subBarIntegration?: boolean;
+  includeLegacyModelIds?: boolean;
+  includeHiddenModels?: boolean;
 }
 
 function isPreviousConfigWithoutLegacyDefault(
-  config: NeuralwattConfig,
+  config: FlatNeuralwattConfig,
 ): boolean {
-  return (
-    !hasNestedConfig(config) &&
-    !hasOwn(config as MutableConfigRecord, "includeLegacyModelIds")
-  );
+  return config.includeLegacyModelIds === undefined;
 }
 
-export const disableLegacyModelIdsByDefaultMigration: Migration<NeuralwattConfig> =
+export const disableLegacyModelIdsByDefaultMigration: Migration<FlatNeuralwattConfig> =
   {
     name: "disable-legacy-model-ids-by-default",
     version: "0.8.0",
     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.",
-    // Flat config: `includeLegacyModelIds` sits at the top level here. Migration
-    // 02 moves it under `provider`.
-    run: (config) =>
-      ({
-        ...config,
-        includeLegacyModelIds: false,
-      }) as unknown as NeuralwattConfig,
+    run: (config) => ({
+      ...config,
+      includeLegacyModelIds: false,
+    }),
   };

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

@@ -3,22 +3,14 @@ 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 } from "../types";
 
 /** The original flat config, replaced by per-feature sections. */
 interface FlatNeuralwattConfig {
-  /** Show the quota command (/neuralwatt:quota). */
+  $schema?: string;
   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;
-
   /** Renamed to `provider.includeEarlyAccessModels` by migration 03. */
   includeHiddenModels?: boolean;
 }
@@ -50,7 +42,7 @@ function isObject(value: unknown): value is Record<string, unknown> {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
-function isPreviousConfig(config: NeuralwattConfig): boolean {
+function isPreviousConfig(config: FlatNeuralwattConfig): boolean {
   const record = config as MutableConfigRecord;
   return FLAT_CONFIG_KEYS.some((key) => typeof record[key] === "boolean");
 }
@@ -78,7 +70,7 @@ export async function backupConfig(filePath: string): Promise<void> {
   }
 }
 
-export const flatToNestedConfigMigration: Migration<NeuralwattConfig> = {
+export const flatToNestedConfigMigration: Migration<FlatNeuralwattConfig> = {
   name: "flat-to-nested-config",
   version: "0.8.1",
   shouldRun: isPreviousConfig,
@@ -86,82 +78,54 @@ export const flatToNestedConfigMigration: Migration<NeuralwattConfig> = {
   run: async (config, filePath) => {
     await backupConfig(filePath);
 
-    const nestedConfig = config;
     const record = config as unknown as MutableConfigRecord;
-    const nested: NeuralwattConfig = {
-      provider: {
-        ...(isObject(nestedConfig.provider) ? nestedConfig.provider : {}),
-      },
-      quotaCommand: isObject(nestedConfig.quotaCommand)
-        ? { ...nestedConfig.quotaCommand }
-        : {},
-      quotaWarnings: isObject(nestedConfig.quotaWarnings)
-        ? { ...nestedConfig.quotaWarnings }
-        : {},
-      subBarIntegration: isObject(nestedConfig.subBarIntegration)
-        ? { ...nestedConfig.subBarIntegration }
-        : {},
+
+    // Preserve existing nested values from a partially-migrated config.
+    const existingProvider = isObject(record.provider)
+      ? { ...record.provider }
+      : {};
+    const existingQuotaCommand = isObject(record.quotaCommand)
+      ? { ...record.quotaCommand }
+      : {};
+    const existingQuotaWarnings = isObject(record.quotaWarnings)
+      ? { ...record.quotaWarnings }
+      : {};
+    const existingSubBarIntegration = isObject(record.subBarIntegration)
+      ? { ...record.subBarIntegration }
+      : {};
+
+    const nested = {
+      provider: existingProvider as Record<string, unknown>,
+      quotaCommand: existingQuotaCommand as Record<string, unknown>,
+      quotaWarnings: existingQuotaWarnings as Record<string, unknown>,
+      subBarIntegration: existingSubBarIntegration as Record<string, unknown>,
     };
 
     const includeLegacyModelIds = booleanValue(record, "includeLegacyModelIds");
-    if (
-      nested.provider?.includeLegacyModelIds === undefined &&
-      includeLegacyModelIds !== undefined
-    ) {
-      nested.provider = {
-        ...nested.provider,
-        includeLegacyModelIds,
-      };
+    if (includeLegacyModelIds !== undefined) {
+      nested.provider = { ...nested.provider, includeLegacyModelIds };
     }
 
-    // Flat configs predate the rename, so they still use `includeHiddenModels`.
-    const includeEarlyAccessModels = booleanValue(
-      record,
-      "includeHiddenModels",
-    );
-    if (
-      nested.provider?.includeEarlyAccessModels === undefined &&
-      includeEarlyAccessModels !== undefined
-    ) {
-      nested.provider = {
-        ...nested.provider,
-        includeEarlyAccessModels,
-      };
+    const includeHiddenModels = booleanValue(record, "includeHiddenModels");
+    if (includeHiddenModels !== undefined) {
+      nested.provider = { ...nested.provider, includeHiddenModels };
     }
 
     const quotaCommand = booleanValue(record, "quotaCommand");
-    if (
-      nested.quotaCommand?.enabled === undefined &&
-      quotaCommand !== undefined
-    ) {
-      nested.quotaCommand = {
-        ...nested.quotaCommand,
-        enabled: quotaCommand,
-      };
+    if (quotaCommand !== undefined) {
+      nested.quotaCommand = { enabled: quotaCommand };
     }
 
     const quotaWarnings = booleanValue(record, "quotaWarnings");
-    if (
-      nested.quotaWarnings?.enabled === undefined &&
-      quotaWarnings !== undefined
-    ) {
-      nested.quotaWarnings = {
-        ...nested.quotaWarnings,
-        enabled: quotaWarnings,
-      };
+    if (quotaWarnings !== undefined) {
+      nested.quotaWarnings = { enabled: quotaWarnings };
     }
 
     const subBarIntegration = booleanValue(record, "subBarIntegration");
-    if (
-      nested.subBarIntegration?.enabled === undefined &&
-      subBarIntegration !== undefined
-    ) {
-      nested.subBarIntegration = {
-        ...nested.subBarIntegration,
-        enabled: subBarIntegration,
-      };
+    if (subBarIntegration !== undefined) {
+      nested.subBarIntegration = { enabled: subBarIntegration };
     }
 
-    return nested;
+    return nested as unknown as FlatNeuralwattConfig;
   },
 };

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

@@ -1,48 +1,43 @@
 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;
+/** Nested config shape with `includeHiddenModels` (pre-0.10.6). */
+interface PreRenameNeuralwattConfig {
+  $schema?: string;
+  provider?: {
+    includeLegacyModelIds?: boolean;
+    includeEarlyAccessModels?: boolean;
+    /** Renamed to `includeEarlyAccessModels`. */
+    includeHiddenModels?: boolean;
+  };
+  quotaCommand?: { enabled?: boolean };
+  quotaWarnings?: { enabled?: boolean };
+  subBarIntegration?: { enabled?: boolean };
 }
 
 /**
  * `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",
-  version: "0.10.6",
-  shouldRun: (config) =>
-    previousProvider(config)?.includeHiddenModels !== undefined,
-  message:
-    "[neuralwatt] `provider.includeHiddenModels` is now `provider.includeEarlyAccessModels`.",
-  run: (config) => {
-    const provider = previousProvider(config);
-    if (!provider) return config;
+export const renameHiddenToEarlyAccessMigration: Migration<PreRenameNeuralwattConfig> =
+  {
+    name: "rename-hidden-models-to-early-access",
+    version: "0.10.6",
+    shouldRun: (config) => config.provider?.includeHiddenModels !== undefined,
+    message:
+      "[neuralwatt] `provider.includeHiddenModels` is now `provider.includeEarlyAccessModels`.",
+    run: (config) => {
+      const provider = config.provider;
+      if (!provider) return config;
 
-    const { includeHiddenModels, ...rest } = provider;
+      const { includeHiddenModels, ...rest } = provider;
 
-    return {
-      ...config,
-      provider: {
-        ...rest,
-        includeEarlyAccessModels:
-          rest.includeEarlyAccessModels ?? includeHiddenModels,
-      },
-    };
-  },
-};
+      return {
+        ...config,
+        provider: {
+          ...rest,
+          includeEarlyAccessModels:
+            rest.includeEarlyAccessModels ?? includeHiddenModels,
+        },
+      };
+    },
+  };

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

@@ -1,42 +1,33 @@
 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;
+/** Nested config shape before aliases were split out (pre-0.11.0). */
+interface PreAliasNeuralwattConfig {
+  $schema?: string;
+  provider?: {
+    includeLegacyModelIds?: boolean;
+    includeAliasedModelIds?: boolean;
+    includeEarlyAccessModels?: boolean;
+  };
+  quotaCommand?: { enabled?: boolean };
+  quotaWarnings?: { enabled?: boolean };
+  subBarIntegration?: { enabled?: boolean };
 }
 
 /**
  * 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> =
+export const enableAliasesForLegacyUsersMigration: Migration<PreAliasNeuralwattConfig> =
   {
     name: "enable-alias-model-ids-for-legacy-users",
     version: "0.11.0",
-    shouldRun: (config) => {
-      const provider = previousProvider(config);
-      return (
-        provider?.includeLegacyModelIds === true &&
-        provider.includeAliasedModelIds === undefined
-      );
-    },
+    shouldRun: (config) =>
+      config.provider?.includeLegacyModelIds === true &&
+      config.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);
+      const provider = config.provider;
       if (!provider) return config;
 
       return {

package/src/config/migration/index.ts

@@ -14,9 +14,12 @@ 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>[] = [
+// Each migration is typed against its own historical input shape. The loader
+// applies them in sequence on the raw config record, so they are cast to the
+// current config type for the array.
+export const migrations = [
   disableLegacyModelIdsByDefaultMigration,
   flatToNestedConfigMigration,
   renameHiddenToEarlyAccessMigration,
   enableAliasesForLegacyUsersMigration,
-];
+] as unknown as Migration<NeuralwattConfig>[];

package/src/config/types.ts

@@ -1,14 +1,3 @@
-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;
-}
-
 export interface NeuralwattQuotaCommandConfig {
   /** Show the quota command (/neuralwatt:quota). */
   enabled?: boolean;
@@ -28,9 +17,6 @@ export interface NeuralwattConfig {
   /** $schema URL for editor autocomplete. */
   $schema?: string;
 
-  /** Provider/model behavior. */
-  provider?: NeuralwattProviderConfig;
-
   /** Quota command feature. */
   quotaCommand?: NeuralwattQuotaCommandConfig;
 
@@ -42,11 +28,6 @@ export interface NeuralwattConfig {
 }
 
 export interface ResolvedNeuralwattConfig {
-  provider: {
-    includeLegacyModelIds: boolean;
-    includeAliasedModelIds: boolean;
-    includeEarlyAccessModels: boolean;
-  };
   quotaCommand: {
     enabled: boolean;
   };

package/src/lib/neuralwatt-api.ts

@@ -8,6 +8,10 @@ import type { QuotasResult } from "../types/quota-result";
 const BASE_URL = "https://api.neuralwatt.com/v1";
 const FETCH_TIMEOUT_MS = 15_000;
 
+function authHeaders(apiKey: string | undefined): Record<string, string> {
+  return apiKey && apiKey !== "-" ? { Authorization: `Bearer ${apiKey}` } : {};
+}
+
 function isTimeoutReason(reason: unknown): boolean {
   return (
     (reason instanceof DOMException && reason.name === "TimeoutError") ||
@@ -23,12 +27,12 @@ function combineSignals(signal?: AbortSignal): AbortSignal {
 
 async function neuralwattFetch(
   path: string,
-  apiKey: string,
+  apiKey: string | undefined,
   signal?: AbortSignal,
   headers?: Record<string, string>,
 ): Promise<Response> {
   return fetch(`${BASE_URL}${path}`, {
-    headers: { Authorization: `Bearer ${apiKey}`, ...headers },
+    headers: { ...authHeaders(apiKey), ...headers },
     signal: combineSignals(signal),
   });
 }
@@ -38,13 +42,9 @@ export type NeuralwattModelsResult =
   | { success: false };
 
 export async function fetchNeuralwattModels(
-  apiKey: string,
+  apiKey: string | undefined,
   signal?: AbortSignal,
 ): Promise<NeuralwattModelsResult> {
-  if (!apiKey) {
-    return { success: false };
-  }
-
   const combined = combineSignals(signal);
 
   try {

package/extensions/provider/models/aliases.ts

@@ -1,35 +0,0 @@
-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)`,
-      },
-    ];
-  });
-}