openclaw/dist/model-selection-da0gMxcZ.js

Multi-channel AI gateway with extensible messaging integrations

import { l as normalizeOptionalString } from "./string-coerce-CIXf7egm.js";
import { t as createLazyImportLoader } from "./lazy-promise-DGqyc4Y4.js";
import { c as resolveAgentConfig, u as resolveAgentDir } from "./agent-scope-config-DcbEhP0R.js";
import { t as isDiagnosticFlagEnabled } from "./diagnostic-flags-qVPAqdVk.js";
import { a as legacyModelKey, c as normalizeProviderId, s as normalizeModelRef } from "./model-ref-shared-Dz7QU0Lx.js";
import { t as modelKey } from "./model-key-CMdQNkZf.js";
import { r as buildConfiguredModelCatalog, v as resolveModelAliasFromPair } from "./model-selection-shared-BlLyx1r2.js";
import { E as hasSessionAutoModelFallbackProvenance, r as hasLegacyAutoFallbackWithoutOrigin } from "./agent-scope-DbtJyKUL.js";
import { s as normalizeThinkLevel } from "./thinking.shared-bHYuuc1L.js";
import { a as listOpenAIAuthProfileProvidersForAgentRuntime } from "./openai-routing-Ex_3E9TF.js";
import { i as isUserModelAuthProfileId } from "./profile-usage-stats-dkZh2v8y.js";
import { t as resolveAgentHarnessPolicy } from "./policy-D9i1QMuw.js";
import { n as isStoredCredentialCompatibleWithAuthProvider } from "./order-CC2RBzI5.js";
import { a as applyModelOverrideToSessionEntry } from "./model-overrides-Bm7jo7Di.js";
import { a as resolveCliRuntimeCanonicalProvider } from "./cli-backends-Bs_a4MW0.js";
import { a as resolveReasoningDefault, l as normalizeStoredOverrideModel, u as resolvePersistedOverrideModelRef } from "./model-selection-di2kjKCB.js";
import { n as resolveThinkingDefault } from "./model-thinking-default-1g_x1V4J.js";
import { a as SessionWorkStartInvalidatedError } from "./lifecycle-BaroCBMc.js";
import { n as createModelVisibilityPolicy, t as RUNTIME_MODEL_VISIBILITY_NORMALIZATION } from "./model-visibility-policy-mYoB7nkk.js";
import { n as resolveStoredModelOverride, t as resolveDirectStoredModelOverride } from "./stored-model-overrides-j_gQYbkA.js";
import { i as normalizeRuntimeRef, o as resolveRuntimeNormalization, r as mergePreparedConfiguredCatalog, t as findSelectedCatalogEntry } from "./model-runtime-normalization-CVjCcJkR.js";
import { t as clearSessionAuthProfileOverride } from "./session-override-ClC-ppNe.js";
import { a as sessionModelOverrideChangesApplied, n as adoptPersistedSessionSnapshot } from "./session-snapshot-merge-Cf1TdJBp.js";
import "./model-selection-directive-B3DZzVk6.js";
import "./model-selection-context-BUKuYlr-.js";
//#region src/auto-reply/reply/stored-model-override.ts
/** Normalizes a stored model ref, resolving runtime aliases only for CLI-bound sessions. */
function normalizeStoredRuntimeModelRef(provider, model, cfg, sessionEntry, normalization = RUNTIME_MODEL_VISIBILITY_NORMALIZATION) {
	const normalized = normalizeModelRef(provider, model, normalization);
	const hasCliSessionBinding = sessionEntry?.cliSessionBindings?.[normalized.provider] !== void 0;
	const canonicalProvider = cfg && hasCliSessionBinding ? resolveCliRuntimeCanonicalProvider({
		runtime: normalized.provider,
		config: cfg,
		includeSetupRegistry: true
	}) : void 0;
	return canonicalProvider ? {
		...normalized,
		provider: canonicalProvider
	} : normalized;
}
function resolveModelRefKey(params) {
	const normalizedOverride = normalizeStoredOverrideModel({
		providerOverride: params.overrideProvider,
		modelOverride: params.overrideModel
	});
	const ref = resolvePersistedOverrideModelRef({
		defaultProvider: params.defaultProvider,
		overrideProvider: normalizedOverride.providerOverride,
		overrideModel: normalizedOverride.modelOverride
	});
	if (!ref) return null;
	const normalizedRef = normalizeModelRef(ref.provider, ref.model);
	return modelKey(normalizedRef.provider, normalizedRef.model);
}
/** Detects heartbeat auto-fallback overrides that no longer match the primary model. */
function isStaleHeartbeatAutoFallbackOverride(params) {
	if (params.isHeartbeat !== true || params.hasResolvedHeartbeatModelOverride === true) return false;
	if (params.storedOverride?.source !== "session") return false;
	const entry = params.sessionEntry;
	const recoveredAutoFallbackOverride = entry !== void 0 && entry.modelOverrideSource === void 0 && hasSessionAutoModelFallbackProvenance(entry);
	if (entry?.modelOverrideSource !== "auto" && !recoveredAutoFallbackOverride) return false;
	if (!entry) return false;
	const primaryKey = resolveModelRefKey({
		defaultProvider: params.defaultProvider,
		overrideProvider: params.primaryProvider ?? params.defaultProvider,
		overrideModel: params.primaryModel ?? params.defaultModel
	});
	if (!primaryKey) return false;
	const originKey = resolveModelRefKey({
		defaultProvider: params.defaultProvider,
		overrideProvider: entry.modelOverrideFallbackOriginProvider,
		overrideModel: entry.modelOverrideFallbackOriginModel
	});
	if (originKey) return originKey !== primaryKey;
	const noticeSelectedKey = resolveModelRefKey({
		defaultProvider: params.defaultProvider,
		overrideModel: normalizeOptionalString(entry.fallbackNotice?.selectedModel)
	});
	if (noticeSelectedKey) return noticeSelectedKey !== primaryKey;
	const storedOverrideKey = resolveModelRefKey({
		defaultProvider: params.defaultProvider,
		overrideProvider: params.storedOverride.provider,
		overrideModel: params.storedOverride.model
	});
	return storedOverrideKey !== null && storedOverrideKey !== primaryKey;
}
//#endregion
//#region src/auto-reply/reply/model-selection.ts
/** Model selection state for reply runs, including catalog and override handling. */
function resolveConfiguredModelThinkingDefault(raw) {
	if (raw === false || raw === "disabled" || raw === "none") return "off";
	return typeof raw === "string" ? normalizeThinkLevel(raw) : void 0;
}
/** Creates minimal model-selection state for fast test mode. */
function createFastTestModelSelectionState(params) {
	return {
		provider: params.provider,
		model: params.model,
		requestedRouteResolution: "resolved",
		modelPolicy: createModelVisibilityPolicy({
			cfg: { agents: { defaults: params.agentCfg } },
			catalog: [],
			defaultProvider: params.provider,
			defaultModel: params.model
		}),
		allowedModelKeys: /* @__PURE__ */ new Set(),
		allowedModelCatalog: [],
		policyAliasIndex: {
			byAlias: /* @__PURE__ */ new Map(),
			byKey: /* @__PURE__ */ new Map()
		},
		resetModelOverride: false,
		resetModelOverrideRef: void 0,
		resetModelOverrideReason: void 0,
		modelPolicyConfigPath: void 0,
		modelPolicyRepairConfigPath: void 0,
		resolveThinkingCatalog: async () => [],
		resolveDefaultThinkingLevel: async () => params.agentCfg?.thinkingDefault,
		hasConfiguredThinkingDefault: params.agentCfg?.thinkingDefault !== void 0,
		resolveDefaultReasoningLevel: async () => "off",
		needsModelCatalog: false,
		modelContextWindow: void 0,
		modelContextTokens: void 0
	};
}
const modelCatalogRuntimeLoader = createLazyImportLoader(() => import("./agents/model-catalog.runtime.js"));
const sessionPersistenceRuntimeLoader = createLazyImportLoader(() => import("./session-entry-persistence-DLekbNEV.js"));
function loadPreparedModelCatalogRuntime() {
	return modelCatalogRuntimeLoader.load();
}
function loadSessionPersistenceRuntime() {
	return sessionPersistenceRuntimeLoader.load();
}
/** Resolves provider/model, allowlist, catalog, and thinking defaults for a reply run. */
async function createModelSelectionState(params) {
	const timingEnabled = isDiagnosticFlagEnabled("ingress.timing", params.cfg);
	const startMs = timingEnabled ? Date.now() : 0;
	const logStage = (stage, extra) => {
		if (!timingEnabled) return;
		const suffix = extra ? ` ${extra}` : "";
		console.log(`[model-selection] session=${params.sessionKey ?? "(no-session)"} stage=${stage} elapsedMs=${Date.now() - startMs}${suffix}`);
	};
	const { cfg, agentCfg, sessionEntry, sessionStore, sessionKey, parentSessionKey, storePath, defaultProvider, defaultModel } = params;
	const loadRuntimeCatalogSnapshot = async () => params.preparedModelCatalog ?? await (await loadPreparedModelCatalogRuntime()).loadPreparedModelCatalogSnapshot({
		config: cfg,
		...params.agentId ? { agentId: params.agentId } : {}
	});
	const runtimeModelNormalization = resolveRuntimeNormalization(cfg);
	const { manifestPlugins } = runtimeModelNormalization;
	let provider = params.provider;
	let model = params.model;
	let requestedRouteResolution = "resolved";
	const primaryProvider = params.primaryProvider ?? defaultProvider;
	const primaryModel = params.primaryModel ?? defaultModel;
	const hasOneTurnModelOverride = params.hasOneTurnModelOverride === true;
	const modelSelectionLocked = sessionEntry?.modelSelectionLocked === true;
	const agentEntry = params.agentId ? resolveAgentConfig(cfg, params.agentId) : void 0;
	let visibilityPolicy = createModelVisibilityPolicy({
		cfg,
		catalog: [],
		defaultProvider,
		defaultModel,
		agentId: params.agentId,
		...runtimeModelNormalization
	});
	const hasAllowlist = !visibilityPolicy.allowAny;
	const hasConfiguredModels = Object.keys(agentCfg?.models ?? {}).length > 0 || Object.keys(agentEntry?.models ?? {}).length > 0;
	const defaultModelVisibleByWildcard = visibilityPolicy.allowsByWildcard({
		provider: defaultProvider,
		model: defaultModel
	});
	const configuredModelCatalog = mergePreparedConfiguredCatalog({
		configured: buildConfiguredModelCatalog({
			cfg,
			manifestPlugins
		}),
		prepared: params.preparedModelCatalog?.entries
	});
	const needsModelCatalog = params.hasModelDirective || hasAllowlist && visibilityPolicy.hasProviderWildcards && !defaultModelVisibleByWildcard;
	let allowedModelKeys = /* @__PURE__ */ new Set();
	let allowedModelCatalog = configuredModelCatalog;
	let modelCatalog = null;
	let catalogAuthoritative = true;
	let resetModelOverride = false;
	let resetModelOverrideRef;
	let resetModelOverrideReason;
	const directStoredModelOverride = resolveDirectStoredModelOverride({
		sessionEntry,
		defaultProvider
	});
	const staleHeartbeatAutoFallbackOverride = isStaleHeartbeatAutoFallbackOverride({
		isHeartbeat: params.isHeartbeat,
		hasResolvedHeartbeatModelOverride: params.hasResolvedHeartbeatModelOverride,
		sessionEntry,
		storedOverride: directStoredModelOverride,
		defaultProvider,
		defaultModel,
		primaryProvider: params.primaryProvider,
		primaryModel: params.primaryModel
	});
	const primaryHarnessPolicy = resolveAgentHarnessPolicy({
		provider: primaryProvider,
		modelId: primaryModel,
		config: cfg,
		agentId: params.agentId,
		sessionKey
	});
	const staleLegacyOpenAICodexAutoOverride = directStoredModelOverride?.source === "session" && sessionEntry?.modelOverrideSource === "auto" && normalizeProviderId(directStoredModelOverride.provider ?? "") === "openai" && normalizeProviderId(primaryProvider) === "openai" && primaryHarnessPolicy.runtime === "codex" && normalizeRuntimeRef("openai", directStoredModelOverride.model, runtimeModelNormalization).model === normalizeRuntimeRef("openai", primaryModel, runtimeModelNormalization).model;
	const normalizedCurrentSelection = normalizeRuntimeRef(provider, model, runtimeModelNormalization);
	const normalizedDirectOverride = directStoredModelOverride ? normalizeRuntimeRef(directStoredModelOverride.provider ?? defaultProvider, directStoredModelOverride.model, runtimeModelNormalization) : null;
	const staleLegacyAutoFallbackWithoutOrigin = directStoredModelOverride?.source === "session" && hasLegacyAutoFallbackWithoutOrigin(sessionEntry) && normalizedDirectOverride !== null && modelKey(normalizedCurrentSelection.provider, normalizedCurrentSelection.model) !== modelKey(normalizedDirectOverride.provider, normalizedDirectOverride.model);
	const staleDirectStoredOverride = staleHeartbeatAutoFallbackOverride || staleLegacyOpenAICodexAutoOverride || staleLegacyAutoFallbackWithoutOrigin;
	if (needsModelCatalog) {
		const catalogSnapshot = await loadRuntimeCatalogSnapshot();
		modelCatalog = catalogSnapshot.entries;
		catalogAuthoritative = catalogSnapshot.authoritative !== false;
		logStage("catalog-loaded", `entries=${modelCatalog.length} authoritative=${catalogAuthoritative}`);
		visibilityPolicy = createModelVisibilityPolicy({
			cfg,
			catalog: modelCatalog,
			defaultProvider,
			defaultModel,
			agentId: params.agentId,
			...runtimeModelNormalization
		});
		allowedModelCatalog = visibilityPolicy.allowedCatalog;
		allowedModelKeys = visibilityPolicy.allowedKeys;
		logStage("allowlist-built", `allowed=${allowedModelCatalog.length} keys=${allowedModelKeys.size}`);
	} else if (hasAllowlist || hasConfiguredModels) {
		visibilityPolicy = createModelVisibilityPolicy({
			cfg,
			catalog: configuredModelCatalog,
			defaultProvider,
			defaultModel,
			agentId: params.agentId,
			...runtimeModelNormalization
		});
		allowedModelCatalog = visibilityPolicy.allowedCatalog;
		allowedModelKeys = visibilityPolicy.allowedKeys;
		logStage("configured-allowlist-built", `allowed=${allowedModelCatalog.length} keys=${allowedModelKeys.size}`);
	} else if (configuredModelCatalog.length > 0) logStage("configured-catalog-ready", `entries=${configuredModelCatalog.length}`);
	if (sessionEntry && sessionStore && sessionKey && directStoredModelOverride && !hasOneTurnModelOverride) {
		const normalizedOverride = normalizeStoredRuntimeModelRef(directStoredModelOverride.provider ?? defaultProvider, directStoredModelOverride.model, cfg, sessionEntry, runtimeModelNormalization);
		const key = modelKey(normalizedOverride.provider, normalizedOverride.model);
		const overrideAllowed = visibilityPolicy.allowsKey(key);
		const shouldResetOverride = (staleDirectStoredOverride || !overrideAllowed) && !modelSelectionLocked;
		if (shouldResetOverride && !staleDirectStoredOverride && !catalogAuthoritative) {
			resetModelOverrideRef = key;
			resetModelOverrideReason = "temporarily-unavailable";
		} else if (shouldResetOverride) {
			const initialSessionEntry = { ...sessionEntry };
			const nextSessionEntry = { ...sessionEntry };
			const { updated } = applyModelOverrideToSessionEntry({
				entry: nextSessionEntry,
				selection: {
					provider: primaryProvider,
					model: primaryModel,
					isDefault: true
				},
				preserveAuthProfileOverride: staleDirectStoredOverride
			});
			let resetApplied = updated;
			if (updated) {
				if (storePath) {
					const { persistReplySessionEntry } = await loadSessionPersistenceRuntime();
					const persistence = await persistReplySessionEntry({
						storePath,
						sessionKey,
						initialEntry: initialSessionEntry,
						entry: nextSessionEntry
					});
					if (persistence.status === "lifecycle-invalidated") throw new SessionWorkStartInvalidatedError(persistence.error);
					const persistedEntry = persistence.entry;
					resetApplied = sessionModelOverrideChangesApplied({
						initial: initialSessionEntry,
						next: nextSessionEntry,
						current: persistedEntry
					});
					adoptPersistedSessionSnapshot(sessionEntry, persistedEntry);
				} else adoptPersistedSessionSnapshot(sessionEntry, nextSessionEntry);
				sessionStore[sessionKey] = sessionEntry;
			}
			resetModelOverride = resetApplied;
			if (resetApplied) {
				resetModelOverrideRef = key;
				resetModelOverrideReason = staleDirectStoredOverride ? "stale" : "disallowed";
			}
		}
	}
	if (staleDirectStoredOverride) {
		if (modelKey(normalizedCurrentSelection.provider, normalizedCurrentSelection.model) === (normalizedDirectOverride ? modelKey(normalizedDirectOverride.provider, normalizedDirectOverride.model) : void 0)) {
			provider = primaryProvider;
			model = primaryModel;
			requestedRouteResolution = "resolved";
		}
	}
	const storedOverride = resolveStoredModelOverride({
		sessionEntry,
		sessionStore,
		sessionKey,
		parentSessionKey,
		defaultProvider
	});
	const skipStoredOverride = params.skipStoredModelOverride === true || hasOneTurnModelOverride || params.hasResolvedHeartbeatModelOverride === true || resetModelOverride && staleDirectStoredOverride && storedOverride?.source === "session";
	if (storedOverride?.model && !skipStoredOverride) {
		const storedProvider = storedOverride.provider || defaultProvider;
		const storedRouteCataloged = Boolean(findSelectedCatalogEntry({
			catalog: modelCatalog ?? allowedModelCatalog,
			provider: storedProvider,
			model: storedOverride.model
		}));
		const storedAlias = storedOverride.routeResolution === "raw" && !storedRouteCataloged ? resolveModelAliasFromPair({
			cfg,
			provider: storedProvider,
			model: storedOverride.model,
			defaultProvider,
			aliasIndex: visibilityPolicy.selectionAliasIndex,
			...runtimeModelNormalization
		}) : null;
		const normalizedStoredOverride = normalizeStoredRuntimeModelRef(storedAlias?.provider ?? storedProvider, storedAlias?.model ?? storedOverride.model, cfg, sessionEntry, runtimeModelNormalization);
		const key = modelKey(normalizedStoredOverride.provider, normalizedStoredOverride.model);
		if (modelSelectionLocked || visibilityPolicy.allowsKey(key)) {
			provider = normalizedStoredOverride.provider;
			model = normalizedStoredOverride.model;
			requestedRouteResolution = storedAlias || storedRouteCataloged ? "resolved" : storedOverride.routeResolution;
		}
	}
	if (!(params.hasModelDirective || hasOneTurnModelOverride || modelSelectionLocked)) {
		const unresolvedSelectionKey = modelKey(provider, model);
		const allowedInitialSelection = visibilityPolicy.resolveSelection({
			provider,
			model
		});
		if (!allowedInitialSelection) {
			const policyPath = visibilityPolicy.allowConfigPath ?? "modelPolicy.allow";
			throw new Error(`Configured default model "${modelKey(provider, model)}" is not allowed by ${policyPath}, and no allowed model is available.`);
		}
		provider = allowedInitialSelection.provider;
		model = allowedInitialSelection.model;
		if (modelKey(provider, model) !== unresolvedSelectionKey) requestedRouteResolution = "resolved";
	}
	if (!params.skipStoredModelOverride && sessionEntry && sessionStore && sessionKey && sessionEntry.authProfileOverride) {
		const { ensureAuthProfileStore } = await import("./agents/auth-profiles.runtime.js");
		const store = ensureAuthProfileStore(params.agentId ? resolveAgentDir(cfg, params.agentId) : void 0, {
			allowKeychainPrompt: false,
			profileId: sessionEntry.authProfileOverride
		});
		logStage("auth-profile-store-loaded", `profiles=${Object.keys(store.profiles).length}`);
		const profile = store.profiles[sessionEntry.authProfileOverride];
		const harnessPolicy = resolveAgentHarnessPolicy({
			provider,
			modelId: model,
			config: cfg,
			agentId: params.agentId,
			sessionKey
		});
		const acceptedAuthProviders = listOpenAIAuthProfileProvidersForAgentRuntime({
			provider,
			harnessRuntime: harnessPolicy.runtime,
			config: cfg
		}).map(normalizeProviderId);
		const overrideStillEligible = profile != null && acceptedAuthProviders.some((accepted) => isStoredCredentialCompatibleWithAuthProvider({
			cfg,
			provider: accepted,
			credential: profile
		}));
		const missingPersonalProfile = !profile && isUserModelAuthProfileId(sessionEntry.authProfileOverride);
		if (!overrideStillEligible && !missingPersonalProfile) await clearSessionAuthProfileOverride({
			sessionEntry,
			sessionStore,
			sessionKey,
			storePath
		});
	}
	let manifestModelCatalog = null;
	const buildThinkingCatalog = (catalog) => createModelVisibilityPolicy({
		cfg,
		catalog,
		defaultProvider,
		defaultModel,
		agentId: params.agentId,
		...runtimeModelNormalization
	}).allowedCatalog;
	const loadManifestCatalog = async () => {
		if (manifestModelCatalog) return manifestModelCatalog;
		const { loadManifestModelCatalog } = await loadPreparedModelCatalogRuntime();
		manifestModelCatalog = loadManifestModelCatalog({
			config: cfg,
			fallbackToMetadataScan: false
		});
		logStage("manifest-catalog-loaded", `entries=${manifestModelCatalog.length}`);
		return manifestModelCatalog;
	};
	const thinkingCatalogs = /* @__PURE__ */ new Map();
	const resolveThinkingCatalog = async (selection = {
		provider,
		model
	}) => {
		const key = modelKey(selection.provider, selection.model);
		const cached = thinkingCatalogs.get(key);
		if (cached) return cached.length > 0 ? cached : void 0;
		let catalog = allowedModelCatalog;
		const hasReasoning = (entries) => findSelectedCatalogEntry({
			catalog: entries,
			provider: selection.provider,
			model: selection.model
		})?.reasoning !== void 0;
		if (!hasReasoning(catalog)) {
			const manifestCatalog = buildThinkingCatalog(await loadManifestCatalog());
			if (hasReasoning(manifestCatalog)) catalog = manifestCatalog;
			else {
				const { loadProviderScopedThinkingCatalog } = await loadPreparedModelCatalogRuntime();
				const scopedCatalog = buildThinkingCatalog(await loadProviderScopedThinkingCatalog({
					config: cfg,
					agentId: params.agentId,
					provider: selection.provider,
					model: selection.model
				}));
				if (findSelectedCatalogEntry({
					catalog: scopedCatalog,
					...selection
				})) catalog = scopedCatalog;
			}
		}
		thinkingCatalogs.set(key, catalog);
		return catalog.length > 0 ? catalog : void 0;
	};
	const defaultThinkingLevels = /* @__PURE__ */ new Map();
	const resolveDefaultThinkingLevel = async (selection) => {
		const selectedProvider = selection?.provider ?? provider;
		const selectedModel = selection?.model ?? model;
		const cacheKey = `${modelKey(selectedProvider, selectedModel)}\0${selection?.agentRuntime ?? ""}`;
		const cached = defaultThinkingLevels.get(cacheKey);
		if (cached) return cached;
		const agentThinkingDefault = agentEntry?.thinkingDefault;
		if (agentThinkingDefault) {
			defaultThinkingLevels.set(cacheKey, agentThinkingDefault);
			return agentThinkingDefault;
		}
		const configuredModels = cfg.agents?.defaults?.models;
		const canonicalKey = modelKey(selectedProvider, selectedModel);
		const legacyKey = legacyModelKey(selectedProvider, selectedModel);
		const resolvedConfiguredModelThinkingDefault = resolveConfiguredModelThinkingDefault(configuredModels?.[canonicalKey]?.params?.thinking ?? (legacyKey ? configuredModels?.[legacyKey]?.params?.thinking : void 0));
		if (resolvedConfiguredModelThinkingDefault) {
			defaultThinkingLevels.set(cacheKey, resolvedConfiguredModelThinkingDefault);
			return resolvedConfiguredModelThinkingDefault;
		}
		const configuredThinkingDefault = agentCfg?.thinkingDefault;
		if (configuredThinkingDefault) {
			defaultThinkingLevels.set(cacheKey, configuredThinkingDefault);
			return configuredThinkingDefault;
		}
		const catalogForThinking = await resolveThinkingCatalog(selection);
		const defaultThinkingLevel = resolveThinkingDefault({
			cfg,
			provider: selectedProvider,
			model: selectedModel,
			catalog: catalogForThinking,
			agentRuntime: selection?.agentRuntime
		}) ?? "off";
		defaultThinkingLevels.set(cacheKey, defaultThinkingLevel);
		return defaultThinkingLevel;
	};
	const resolveDefaultReasoningLevel = async (selection = {
		provider,
		model
	}) => resolveReasoningDefault({
		provider: selection.provider,
		model: selection.model,
		catalog: await resolveThinkingCatalog(selection)
	});
	const selectedCatalogEntry = findSelectedCatalogEntry({
		catalog: modelCatalog ?? allowedModelCatalog,
		provider,
		model
	});
	const configuredModels = cfg.agents?.defaults?.models;
	const canonicalKey = modelKey(provider, model);
	const legacyKey = legacyModelKey(provider, model);
	const configuredModelThinkingDefault = configuredModels?.[canonicalKey]?.params?.thinking ?? (legacyKey ? configuredModels?.[legacyKey]?.params?.thinking : void 0);
	const hasConfiguredThinkingDefault = agentEntry?.thinkingDefault !== void 0 || resolveConfiguredModelThinkingDefault(configuredModelThinkingDefault) !== void 0 || agentCfg?.thinkingDefault !== void 0;
	return {
		provider,
		model,
		requestedRouteResolution,
		modelPolicy: visibilityPolicy,
		allowedModelKeys,
		allowedModelCatalog,
		policyAliasIndex: visibilityPolicy.policyAliasIndex,
		resetModelOverride,
		resetModelOverrideRef,
		resetModelOverrideReason,
		modelPolicyConfigPath: visibilityPolicy.allowConfigPath ?? void 0,
		modelPolicyRepairConfigPath: visibilityPolicy.allowRepairConfigPath,
		resolveThinkingCatalog,
		resolveDefaultThinkingLevel,
		hasConfiguredThinkingDefault,
		resolveDefaultReasoningLevel,
		needsModelCatalog,
		modelContextWindow: selectedCatalogEntry?.contextWindow,
		modelContextTokens: selectedCatalogEntry?.contextTokens
	};
}
//#endregion
export { createModelSelectionState as n, isStaleHeartbeatAutoFallbackOverride as r, createFastTestModelSelectionState as t };