import { normalizeLowercaseStringOrEmpty } from "../../shared/string-coerce.js";

import { resolveConfiguredEntries } from "./list.configured.js";

import { formatErrorWithStack } from "./list.errors.js";

import { hasProviderStaticCatalogForFilter } from "./list.provider-catalog.js";

import { loadConfiguredListModelRegistry, loadListModelRegistry } from "./list.registry-load.js";

import {

appendAllModelRowSources,

appendConfiguredModelRowSources,

modelRowSourcesRequireRegistry,

} from "./list.row-sources.js";

import { printModelTable } from "./list.table.js";

import type { ModelRow } from "./list.types.js";

import { loadModelsConfigWithSource } from "./load-config.js";

import { DEFAULT_PROVIDER, ensureFlagCompatibility } from "./shared.js";

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");

let registryLoadModulePromise: Promise<RegistryLoadModule> | undefined;

let rowSourcesModulePromise: Promise<RowSourcesModule> | undefined;

let providerCatalogModulePromise: Promise<ProviderCatalogModule> | undefined;

function loadRegistryLoadModule(): Promise<RegistryLoadModule> {

registryLoadModulePromise ??= import("./list.registry-load.js");

return registryLoadModulePromise;

}

function loadRowSourcesModule(): Promise<RowSourcesModule> {

rowSourcesModulePromise ??= import("./list.row-sources.js");

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;

}

export async function modelsListCommand(

opts: {

all?: boolean;

if (providerFilter === null) {

return;

}

const { ensureAuthProfileStore, resolveOpenClawAgentDir } = await import("./list.runtime.js");

const [{ loadAuthProfileStoreWithoutExternalProfiles }, { resolveOpenClawAgentDir }] =

await Promise.all([

import("../../agents/auth-profiles/store.js"),

import("../../agents/agent-paths.js"),

]);

const { resolvedConfig: cfg } = await loadModelsConfigWithSource({

commandName: "models list",

runtime,

});

const authStore = ensureAuthProfileStore();

const authStore = loadAuthProfileStoreWithoutExternalProfiles();

const agentDir = resolveOpenClawAgentDir();

let modelRegistry: ModelRegistry | undefined;

manifestCatalogRows = loadStaticManifestCatalogRowsForList({ cfg, providerFilter });

}

const useManifestCatalogFastPath = manifestCatalogRows.length > 0;

const useProviderCatalogFastPath =

!useManifestCatalogFastPath && opts.all && providerFilter

? await hasProviderStaticCatalogForFilter({ cfg, providerFilter })

: false;

if (!useManifestCatalogFastPath && !useProviderCatalogFastPath && opts.all && providerFilter) {

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,

useProviderIndexCatalogFastPath,

});

const loadRegistryState = async () => {

const { loadListModelRegistry } = await loadRegistryLoadModule();

const loaded = await loadListModelRegistry(cfg, { providerFilter });

modelRegistry = loaded.registry;

discoveredKeys = loaded.discoveredKeys;

try {

if (shouldLoadRegistry) {

await loadRegistryState();

} else if (!opts.all) {

} else if (!opts.all && opts.local) {

const { loadConfiguredListModelRegistry } = await loadRegistryLoadModule();

const loaded = loadConfiguredListModelRegistry(cfg, entries, { providerFilter });

modelRegistry = loaded.registry;

discoveredKeys = loaded.discoveredKeys;

const rows: ModelRow[] = [];

if (opts.all) {

const { appendAllModelRowSources } = await loadRowSourcesModule();

let rowContext = buildRowContext(

useManifestCatalogFastPath || useProviderCatalogFastPath || useProviderIndexCatalogFastPath,

);

});

}

} else {

const registry = modelRegistry;

if (!registry) {

runtime.error("Model registry unavailable.");

process.exitCode = 1;

return;

}

appendConfiguredModelRowSources({

const { appendConfiguredModelRowSources } = await loadRowSourcesModule();

await appendConfiguredModelRowSources({

rows,

entries,

modelRegistry: registry,

context: buildRowContext(false),

modelRegistry,

context: buildRowContext(!modelRegistry),

});

}