refactor: use source plan for models list

src/commands/models/list.list-command.ts

@@ -1,6 +1,5 @@
 import type { ModelRegistry } from "@mariozechner/pi-coding-agent";
 import { parseModelRef } from "../../agents/model-selection.js";
-import type { NormalizedModelCatalogRow } from "../../model-catalog/index.js";
 import type { RuntimeEnv } from "../../runtime.js";
 import { normalizeLowercaseStringOrEmpty } from "../../shared/string-coerce.js";
 import { resolveConfiguredEntries } from "./list.configured.js";
@@ -14,11 +13,11 @@ const DISPLAY_MODEL_PARSE_OPTIONS = { allowPluginNormalization: false } as const
 
 type RegistryLoadModule = typeof import("./list.registry-load.js");
 type RowSourcesModule = typeof import("./list.row-sources.js");
-type ProviderCatalogModule = typeof import("./list.provider-catalog.js");
+type SourcePlanModule = typeof import("./list.source-plan.js");
 
 let registryLoadModulePromise: Promise<RegistryLoadModule> | undefined;
 let rowSourcesModulePromise: Promise<RowSourcesModule> | undefined;
-let providerCatalogModulePromise: Promise<ProviderCatalogModule> | undefined;
+let sourcePlanModulePromise: Promise<SourcePlanModule> | undefined;
 
 function loadRegistryLoadModule(): Promise<RegistryLoadModule> {
   registryLoadModulePromise ??= import("./list.registry-load.js");
@@ -30,25 +29,9 @@ function loadRowSourcesModule(): Promise<RowSourcesModule> {
   return rowSourcesModulePromise;
 }
 
-function loadProviderCatalogModule(): Promise<ProviderCatalogModule> {
-  providerCatalogModulePromise ??= import("./list.provider-catalog.js");
-  return providerCatalogModulePromise;
-}
-
-function modelRowSourcesRequireRegistry(params: {
-  all?: boolean;
-  providerFilter?: string;
-  useManifestCatalogFastPath: boolean;
-  useProviderCatalogFastPath: boolean;
-  useProviderIndexCatalogFastPath: boolean;
-}): boolean {
-  if (!params.all) {
-    return false;
-  }
-  if (params.providerFilter) {
-    return false;
-  }
-  return true;
+function loadSourcePlanModule(): Promise<SourcePlanModule> {
+  sourcePlanModulePromise ??= import("./list.source-plan.js");
+  return sourcePlanModulePromise;
 }
 
 export async function modelsListCommand(
@@ -98,38 +81,15 @@ export async function modelsListCommand(
   let availabilityErrorMessage: string | undefined;
   const { entries } = resolveConfiguredEntries(cfg);
   const configuredByKey = new Map(entries.map((entry) => [entry.key, entry]));
-  let manifestCatalogRows: readonly NormalizedModelCatalogRow[] = [];
-  let providerIndexCatalogRows: readonly NormalizedModelCatalogRow[] = [];
-  if (opts.all && providerFilter) {
-    const { loadStaticManifestCatalogRowsForList } = await import("./list.manifest-catalog.js");
-    manifestCatalogRows = loadStaticManifestCatalogRowsForList({ cfg, providerFilter });
-  }
-  const useManifestCatalogFastPath = manifestCatalogRows.length > 0;
-  if (!useManifestCatalogFastPath && opts.all && providerFilter) {
-    const { loadProviderIndexCatalogRowsForList } =
-      await import("./list.provider-index-catalog.js");
-    providerIndexCatalogRows = loadProviderIndexCatalogRowsForList({ cfg, providerFilter });
-  }
-  const useProviderIndexCatalogFastPath = providerIndexCatalogRows.length > 0;
-  const useProviderCatalogFastPath = await (async () => {
-    if (
-      useManifestCatalogFastPath ||
-      useProviderIndexCatalogFastPath ||
-      !opts.all ||
-      !providerFilter
-    ) {
-      return false;
-    }
-    const { hasProviderStaticCatalogForFilter } = await loadProviderCatalogModule();
-    return hasProviderStaticCatalogForFilter({ cfg, providerFilter });
-  })();
-  const shouldLoadRegistry = modelRowSourcesRequireRegistry({
-    all: opts.all,
-    providerFilter,
-    useManifestCatalogFastPath,
-    useProviderCatalogFastPath,
-    useProviderIndexCatalogFastPath,
-  });
+  const sourcePlanModule = opts.all ? await loadSourcePlanModule() : undefined;
+  const sourcePlan = sourcePlanModule
+    ? await sourcePlanModule.planAllModelListSources({
+        all: opts.all,
+        providerFilter,
+        cfg,
+      })
+    : undefined;
+  const shouldLoadRegistry = sourcePlan?.requiresInitialRegistry ?? false;
   const loadRegistryState = async () => {
     const { loadListModelRegistry } = await loadRegistryLoadModule();
     const loaded = await loadListModelRegistry(cfg, { providerFilter });
@@ -170,18 +130,15 @@ export async function modelsListCommand(
 
   if (opts.all) {
     const { appendAllModelRowSources } = await loadRowSourcesModule();
-    let rowContext = buildRowContext(
-      useManifestCatalogFastPath || useProviderCatalogFastPath || useProviderIndexCatalogFastPath,
-    );
+    if (!sourcePlan || !sourcePlanModule) {
+      throw new Error("models list source plan was not initialized");
+    }
+    let rowContext = buildRowContext(sourcePlan.skipRuntimeModelSuppression);
     const initialAppend = await appendAllModelRowSources({
       rows,
       context: rowContext,
       modelRegistry,
-      manifestCatalogRows,
-      providerIndexCatalogRows,
-      useManifestCatalogFastPath,
-      useProviderCatalogFastPath,
-      useProviderIndexCatalogFastPath,
+      sourcePlan,
     });
     if (initialAppend.requiresRegistryFallback) {
       try {
@@ -197,11 +154,7 @@ export async function modelsListCommand(
         rows,
         context: rowContext,
         modelRegistry,
-        manifestCatalogRows: [],
-        providerIndexCatalogRows: [],
-        useManifestCatalogFastPath: false,
-        useProviderCatalogFastPath: false,
-        useProviderIndexCatalogFastPath: false,
+        sourcePlan: sourcePlanModule.createRegistryModelListSourcePlan(),
       });
     }
   } else {

src/commands/models/list.row-sources.ts

@@ -1,5 +1,4 @@
 import type { ModelRegistry } from "@mariozechner/pi-coding-agent";
-import type { NormalizedModelCatalogRow } from "../../model-catalog/index.js";
 import {
   appendCatalogSupplementRows,
   appendConfiguredProviderRows,
@@ -10,48 +9,24 @@ import {
   appendProviderCatalogRows,
   type RowBuilderContext,
 } from "./list.rows.js";
+import type { ModelListSourcePlan } from "./list.source-plan.js";
 import type { ConfiguredEntry, ModelRow } from "./list.types.js";
 
 type AllModelRowSources = {
   rows: ModelRow[];
   context: RowBuilderContext;
   modelRegistry?: ModelRegistry;
-  manifestCatalogRows?: readonly NormalizedModelCatalogRow[];
-  providerIndexCatalogRows?: readonly NormalizedModelCatalogRow[];
-  useManifestCatalogFastPath: boolean;
-  useProviderCatalogFastPath: boolean;
-  useProviderIndexCatalogFastPath: boolean;
+  sourcePlan: ModelListSourcePlan;
 };
 
 type AppendAllModelRowSourcesResult = {
   requiresRegistryFallback: boolean;
 };
 
-export function modelRowSourcesRequireRegistry(params: {
-  all?: boolean;
-  providerFilter?: string;
-  useManifestCatalogFastPath: boolean;
-  useProviderCatalogFastPath: boolean;
-  useProviderIndexCatalogFastPath: boolean;
-}): boolean {
-  if (!params.all) {
-    return false;
-  }
-  if (params.providerFilter) {
-    return false;
-  }
-  return true;
-}
-
 export async function appendAllModelRowSources(
   params: AllModelRowSources,
 ): Promise<AppendAllModelRowSourcesResult> {
-  if (
-    params.context.filter.provider &&
-    (params.useManifestCatalogFastPath ||
-      params.useProviderCatalogFastPath ||
-      params.useProviderIndexCatalogFastPath)
-  ) {
+  if (params.context.filter.provider && params.sourcePlan.kind !== "registry") {
     let seenKeys = new Set<string>();
     await appendConfiguredProviderRows({
       rows: params.rows,
@@ -59,31 +34,35 @@ export async function appendAllModelRowSources(
       seenKeys,
     });
     let catalogRows = 0;
-    if (params.useManifestCatalogFastPath) {
+    if (params.sourcePlan.kind === "manifest") {
       catalogRows = await appendManifestCatalogRows({
         rows: params.rows,
         context: params.context,
         seenKeys,
-        manifestRows: params.manifestCatalogRows ?? [],
+        manifestRows: params.sourcePlan.manifestCatalogRows,
       });
     }
-    if (catalogRows === 0 && params.useProviderCatalogFastPath) {
-      catalogRows = await appendProviderCatalogRows({
-        rows: params.rows,
-        context: params.context,
-        seenKeys,
-        staticOnly: true,
-      });
-    }
-    if (catalogRows === 0 && params.useProviderIndexCatalogFastPath) {
+    if (catalogRows === 0 && params.sourcePlan.kind === "provider-index") {
       catalogRows = await appendModelCatalogRows({
         rows: params.rows,
         context: params.context,
         seenKeys,
-        catalogRows: params.providerIndexCatalogRows ?? [],
+        catalogRows: params.sourcePlan.providerIndexCatalogRows,
       });
     }
-    if (catalogRows === 0) {
+    if (
+      catalogRows === 0 &&
+      (params.sourcePlan.kind === "provider-runtime-static" ||
+        params.sourcePlan.kind === "provider-runtime-scoped")
+    ) {
+      catalogRows = await appendProviderCatalogRows({
+        rows: params.rows,
+        context: params.context,
+        seenKeys,
+        staticOnly: params.sourcePlan.kind === "provider-runtime-static",
+      });
+    }
+    if (catalogRows === 0 && params.sourcePlan.fallbackToRegistryWhenEmpty) {
       if (!params.modelRegistry) {
         return { requiresRegistryFallback: true };
       }