import { resolveVisibleModelCatalog } from "../agents/model-catalog-visibility.js";

import { loadModelCatalog } from "../agents/model-catalog.js";

import type { ModelCatalogEntry } from "../agents/model-catalog.js";

import {

isModelPickerVisibleModelRef,

isModelPickerVisibleProvider,

} from "../agents/model-picker-visibility.js";

import { createModelPickerVisibleProviderPredicate } from "../agents/model-picker-visibility.js";

import { createProviderAuthChecker } from "../agents/model-provider-auth.js";

import { formatLiteralProviderPrefixedModelRef } from "../agents/model-ref-shared.js";

import {

aliasIndex: ReturnType<typeof buildModelAliasIndex>;

hasAuth: (provider: string) => Promise<boolean>;

literalPrefixProviders: Set<string>;

isVisibleProvider: (provider: string) => boolean;

}) {

const normalizedRef = normalizeModelRef(params.entry.provider, params.entry.id);

const key = modelKey(normalizedRef.provider, normalizedRef.model);

if (

params.seen.has(key) ||

HIDDEN_ROUTER_MODELS.has(key) ||

!isModelPickerVisibleProvider(normalizedRef.provider)

!params.isVisibleProvider(normalizedRef.provider)

) {

return;

}

aliasIndex: ReturnType<typeof buildModelAliasIndex>;

hasAuth: (provider: string) => Promise<boolean>;

literalPrefixProviders?: Set<string>;

isVisibleProvider: (provider: string) => boolean;

fallbackHint: string;

}) {

const entry = splitModelKey(params.key);

aliasIndex: params.aliasIndex,

hasAuth: params.hasAuth,

literalPrefixProviders: params.literalPrefixProviders ?? EMPTY_LITERAL_PREFIX_PROVIDERS,

isVisibleProvider: params.isVisibleProvider,

});

if (params.seen.size > before) {

const option = params.options.at(-1);

cfg: OpenClawConfig;

workspaceDir?: string;

env?: NodeJS.ProcessEnv;

isVisibleProvider: (provider: string) => boolean;

}): Promise<typeof params.models> {

let next = params.models.filter((entry) => isModelPickerVisibleProvider(entry.provider));

let next = params.models.filter((entry) => params.isVisibleProvider(entry.provider));

const providerIds = sortUniqueStrings(next.map((entry) => entry.provider));

const hasPreferredProvider = !!params.preferredProvider;

const shouldPromptProvider =

});

}

const isVisibleProvider = createModelPickerVisibleProviderPredicate({

config: cfg,

env: params.env,

includeSetupRegistry: true,

});

const filteredModels = await maybeFilterModelsByProvider({

models,

preferredProvider,

prompter: params.prompter,

cfg,

workspaceDir: params.workspaceDir,

env: params.env,

isVisibleProvider,

});

if (filteredModels.length === 0) {

return promptManualModel({

aliasIndex,

hasAuth,

literalPrefixProviders,

isVisibleProvider,

});

}

if (configuredKey && !seen.has(configuredKey)) {

})

: [];

if (scopedFastKeys.length > 0) {

const isVisibleProvider = createModelPickerVisibleProviderPredicate({

config: cfg,

env: params.env,

includeSetupRegistry: true,

});

const scopeKeys = allowedKeys.length > 0 ? allowedKeys : scopedFastKeys;

const scopeKeySet = new Set(scopeKeys);

const initialKeys = normalizeModelKeys(initialSeeds.filter((key) => scopeKeySet.has(key)));

seen,

aliasIndex,

hasAuth,

isVisibleProvider,

fallbackHint:

allowedKeys.length > 0 ? t("wizard.model.allowed") : t("wizard.model.configured"),

});

workspaceDir: params.workspaceDir,

env: params.env,

});

const isVisibleProvider = createModelPickerVisibleProviderPredicate({

config: cfg,

env: params.env,

includeSetupRegistry: true,

});

const isVisibleModelRef = (ref: string): boolean => {

const separatorIndex = ref.indexOf("/");

return separatorIndex <= 0 || isVisibleProvider(ref.slice(0, separatorIndex));

};

const options: WizardSelectOption[] = [];

const seen = new Set<string>();

const allowedCatalog = (

allowedKeySet

? catalog.filter((entry) => allowedKeySet.has(modelKey(entry.provider, entry.id)))

: catalog

).filter((entry) => isModelPickerVisibleProvider(entry.provider));

).filter((entry) => isVisibleProvider(entry.provider));

const filteredCatalog =

preferredProvider && allowedCatalog.some((entry) => matchesPreferredProvider?.(entry.provider))

? allowedCatalog.filter((entry) => matchesPreferredProvider?.(entry.provider))

: initialSeeds;

const initialKeys = allowedKeySet

? initialSeeds.filter((key) => allowedKeySet.has(key))

: selectableInitialSeeds.filter(isModelPickerVisibleModelRef);

: selectableInitialSeeds.filter(isVisibleModelRef);

for (const entry of filteredCatalog) {

await addModelSelectOption({

aliasIndex,

hasAuth,

literalPrefixProviders,

isVisibleProvider,

});

}

const supplementalKeys = (allowedKeySet ? allowedKeys : selectableInitialSeeds).filter(

isModelPickerVisibleModelRef,

isVisibleModelRef,

);

for (const key of supplementalKeys) {

if (seen.has(key)) {

scopeKeySet && !includesResolvedPrimary

? rawSelectedFallbacks.filter((key) => existingFallbackSet.has(key))

: rawSelectedFallbacks;

const isVisibleProvider = createModelPickerVisibleProviderPredicate({

config: cfg,

includeSetupRegistry: true,

});

const isVisibleModelRef = (ref: string): boolean => {

const separatorIndex = ref.indexOf("/");

return separatorIndex <= 0 || isVisibleProvider(ref.slice(0, separatorIndex));

};

const preserveExistingFallback = scopeKeySet

? (fallback: string) => !scopeKeySet.has(fallback)

: (fallback: string) => !isModelPickerVisibleModelRef(fallback);

: (fallback: string) => !isVisibleModelRef(fallback);

const fallbacks = mergeFallbackSelection({

existingFallbacks,

selectedFallbacks,