Simplify ToolCallbackResolver auto-configuration.

- In febf86c, we broke a dependency cycle ChatClient -> McpClient
- With the introduction of ClientMcpSyncHandlersRegistry and the async
  variant, there is no dependency McpClient -> MCP handlers anymore,
  breaking the cycle in a simpler way.
- Here, we revert most of the changes of febf86c, but keep the tests.

Signed-off-by: Daniel Garnier-Moiroux <[email protected]>

Author: Kehrlann

auto-configurations/mcp/spring-ai-autoconfigure-mcp-client-webflux/src/test/java/org/springframework/ai/mcp/client/webflux/autoconfigure/McpToolsConfigurationTests.java

@@ -120,26 +120,7 @@ void toolCallbacksRegistered() {
 			assertThat(resolver.resolve("customToolCallbackProvider")).isNotNull();
 
 			// MCP toolcallback providers are never added to the resolver
-
-			// Bean graph setup
-			var injectedProviders = (List<ToolCallbackProvider>) ctx.getBean(
-					"org.springframework.ai.model.tool.autoconfigure.ToolCallingAutoConfiguration.toolcallbackprovider.mcp-excluded");
-			// Beans exposed as non-MCP
-			var toolCallbackProvider = (ToolCallbackProvider) ctx.getBean("toolCallbackProvider");
-			var customToolCallbackProvider = (ToolCallbackProvider) ctx.getBean("customToolCallbackProvider");
-			// This is injected in the resolver bean, because it's exposed as a
-			// ToolCallbackProvider, but it's not added to the resolver
-			var genericMcpToolCallbackProvider = (ToolCallbackProvider) ctx.getBean("genericMcpToolCallbackProvider");
-
-			// beans exposed as MCP
-			var mcpToolCallbackProvider = (ToolCallbackProvider) ctx.getBean("mcpToolCallbackProvider");
-			var customMcpToolCallbackProvider = (ToolCallbackProvider) ctx.getBean("customMcpToolCallbackProvider");
-
-			assertThat(injectedProviders)
-				.containsExactlyInAnyOrder(toolCallbackProvider, customToolCallbackProvider,
-						genericMcpToolCallbackProvider)
-				.doesNotContain(mcpToolCallbackProvider, customMcpToolCallbackProvider);
-
+			// Otherwise, they would throw.
 		});
 	}
 
@@ -192,29 +173,27 @@ ToolCallbackProvider toolCallbackProvider() {
 			return tcp;
 		}
 
-		// This bean depends on the resolver, to ensure there are no cyclic dependencies
 		@Bean
-		SyncMcpToolCallbackProvider mcpToolCallbackProvider(ToolCallbackResolver resolver) {
+		CustomToolCallbackProvider customToolCallbackProvider() {
+			return new CustomToolCallbackProvider("customToolCallbackProvider");
+		}
+
+		// Ignored by the resolver
+		@Bean
+		SyncMcpToolCallbackProvider mcpToolCallbackProvider() {
 			var tcp = mock(SyncMcpToolCallbackProvider.class);
 			when(tcp.getToolCallbacks())
 				.thenThrow(new RuntimeException("mcpToolCallbackProvider#getToolCallbacks should not be called"));
 			return tcp;
 		}
 
+		// Ignored by the resolver
 		@Bean
-		CustomToolCallbackProvider customToolCallbackProvider() {
-			return new CustomToolCallbackProvider("customToolCallbackProvider");
-		}
-
-		// This bean depends on the resolver, to ensure there are no cyclic dependencies
-		@Bean
-		CustomMcpToolCallbackProvider customMcpToolCallbackProvider(ToolCallbackResolver resolver) {
+		CustomMcpToolCallbackProvider customMcpToolCallbackProvider() {
 			return new CustomMcpToolCallbackProvider();
 		}
 
-		// This will be added to the resolver, because the visible type of the bean
-		// is ToolCallbackProvider ; we would need to actually instantiate the bean
-		// to find out that it is MCP-related
+		// Ignored by the resolver
 		@Bean
 		ToolCallbackProvider genericMcpToolCallbackProvider() {
 			return new CustomMcpToolCallbackProvider();

auto-configurations/models/tool/spring-ai-autoconfigure-model-tool/src/main/java/org/springframework/ai/model/tool/autoconfigure/ToolCallingAutoConfiguration.java

@@ -17,7 +17,6 @@
 package org.springframework.ai.model.tool.autoconfigure;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 
 import io.micrometer.observation.ObservationRegistry;
@@ -36,14 +35,7 @@
 import org.springframework.ai.tool.resolution.SpringBeanToolCallbackResolver;
 import org.springframework.ai.tool.resolution.StaticToolCallbackResolver;
 import org.springframework.ai.tool.resolution.ToolCallbackResolver;
-import org.springframework.beans.BeansException;
 import org.springframework.beans.factory.ObjectProvider;
-import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.beans.factory.support.BeanDefinitionBuilder;
-import org.springframework.beans.factory.support.BeanDefinitionRegistry;
-import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
-import org.springframework.beans.factory.support.DefaultListableBeanFactory;
 import org.springframework.boot.autoconfigure.AutoConfiguration;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
@@ -65,26 +57,20 @@
 @AutoConfiguration
 @ConditionalOnClass(ChatModel.class)
 @EnableConfigurationProperties(ToolCallingProperties.class)
-public class ToolCallingAutoConfiguration implements BeanDefinitionRegistryPostProcessor {
+public class ToolCallingAutoConfiguration {
 
 	private static final Logger logger = LoggerFactory.getLogger(ToolCallingAutoConfiguration.class);
 
-	// Marker qualifier to exclude MCP-related ToolCallbackProviders
-	private static final String EXCLUDE_MCP_TOOL_CALLBACK_PROVIDER = "org.springframework.ai.model.tool.autoconfigure.ToolCallingAutoConfiguration.toolcallbackprovider.mcp-excluded";
-
 	/**
 	 * The default {@link ToolCallbackResolver} resolves tools by name for methods,
 	 * functions, and {@link ToolCallbackProvider} beans.
 	 * <p>
-	 * MCP providers should not be injected to avoid cyclic dependencies. If some MCP
-	 * providers are injected, we filter them out to avoid eagerly calling
-	 * #getToolCallbacks.
+	 * MCP providers are excluded, to avoid initializing them early with #listTools().
 	 */
 	@Bean
 	@ConditionalOnMissingBean
 	ToolCallbackResolver toolCallbackResolver(GenericApplicationContext applicationContext,
-			List<ToolCallback> toolCallbacks,
-			@Qualifier(EXCLUDE_MCP_TOOL_CALLBACK_PROVIDER) List<ToolCallbackProvider> tcbProviders) {
+			List<ToolCallback> toolCallbacks, List<ToolCallbackProvider> tcbProviders) {
 		List<ToolCallback> allFunctionAndToolCallbacks = new ArrayList<>(toolCallbacks);
 		tcbProviders.stream()
 			.filter(pr -> !isMcpToolCallbackProvider(ResolvableType.forInstance(pr)))
@@ -100,41 +86,6 @@ ToolCallbackResolver toolCallbackResolver(GenericApplicationContext applicationC
 		return new DelegatingToolCallbackResolver(List.of(staticToolCallbackResolver, springBeanToolCallbackResolver));
 	}
 
-	/**
-	 * Wrap {@link ToolCallbackProvider} beans that are not MCP-related into a named bean,
-	 * which will be picked up by the
-	 * {@link ToolCallingAutoConfiguration#toolCallbackResolver}.
-	 * <p>
-	 * MCP providers must be excluded, because they may depend on a {@code ChatClient} to
-	 * do sampling. The chat client, in turn, depends on a {@link ToolCallbackResolver}.
-	 * To do the detection, we depend on the exposed bean type. If a bean uses a factory
-	 * method which returns a {@link ToolCallbackProvider}, which is an MCP provider under
-	 * the hood, it will be included in the list.
-	 */
-	@Override
-	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
-		if (!(registry instanceof DefaultListableBeanFactory beanFactory)) {
-			return;
-		}
-
-		var excludeMcpToolCallbackProviderBeanDefinition = BeanDefinitionBuilder
-			.genericBeanDefinition(List.class, () -> {
-				var providerNames = beanFactory.getBeanNamesForType(ToolCallbackProvider.class);
-				return Arrays.stream(providerNames)
-					.filter(name -> !isMcpToolCallbackProvider(beanFactory.getBeanDefinition(name).getResolvableType()))
-					.map(beanFactory::getBean)
-					.filter(ToolCallbackProvider.class::isInstance)
-					.map(ToolCallbackProvider.class::cast)
-					.toList();
-			})
-			.setScope(BeanDefinition.SCOPE_SINGLETON)
-			.setLazyInit(true)
-			.getBeanDefinition();
-
-		registry.registerBeanDefinition(EXCLUDE_MCP_TOOL_CALLBACK_PROVIDER,
-				excludeMcpToolCallbackProviderBeanDefinition);
-	}
-
 	private static boolean isMcpToolCallbackProvider(ResolvableType type) {
 		if (type.getType().getTypeName().equals("org.springframework.ai.mcp.SyncMcpToolCallbackProvider")
 				|| type.getType().getTypeName().equals("org.springframework.ai.mcp.AsyncMcpToolCallbackProvider")) {