Introduce LazilyResolvedToolCallbackProvider

- Some ToolCallbackProviders should not be "resolved" at startup time by
  the auto-configuration, ie we don't want to call #getToolCallback
  eagerly. This is useful for MCP clients, where we don't want to call
  #listTools on startup.
- We also want to break the following dependency cycle:
    - ChatClient
    -> ToolCallingManager
    -> ToolCallbackResolver
    -> ToolCallbackProvider (incl. SyncMcpToolCallbackProvider)
    -> McpSyncClient
    -> ClientMcpAnnotatedBeans
    -> ChatClient (when there is Sampling)
- This PR ensures that the ToolCallbackResolver does not depend on
  SyncMcpToolCallbackProvider, thus breaking the cycle.
- MCP callback providers can still be passed to the chat client, but
  only at runtime, not during the configuration phase.

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

Author: Kehrlann

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

@@ -0,0 +1,124 @@
+/*
+ * Copyright 2025-2025 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.ai.mcp.server.autoconfigure;
+
+import java.util.List;
+
+import io.modelcontextprotocol.client.McpSyncClient;
+import io.modelcontextprotocol.spec.McpSchema;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springaicommunity.mcp.annotation.McpSampling;
+
+import org.springframework.ai.chat.client.ChatClient;
+import org.springframework.ai.chat.model.ChatModel;
+import org.springframework.ai.mcp.client.common.autoconfigure.McpClientAutoConfiguration;
+import org.springframework.ai.mcp.client.common.autoconfigure.McpToolCallbackAutoConfiguration;
+import org.springframework.ai.mcp.client.common.autoconfigure.annotations.McpClientAnnotationScannerAutoConfiguration;
+import org.springframework.ai.mcp.client.common.autoconfigure.annotations.McpClientSpecificationFactoryAutoConfiguration;
+import org.springframework.ai.mcp.client.webflux.autoconfigure.StreamableHttpWebFluxTransportAutoConfiguration;
+import org.springframework.ai.model.chat.client.autoconfigure.ChatClientAutoConfiguration;
+import org.springframework.ai.model.tool.autoconfigure.ToolCallingAutoConfiguration;
+import org.springframework.boot.autoconfigure.AutoConfigurations;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
+import org.springframework.context.annotation.Bean;
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.core.ResolvableType;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+
+/**
+ * Test that MCP tools have handlers configured when they use a chat client. This verifies
+ * that there is no cyclic dependency
+ * {@code McpClient -> @McpHandling -> ChatClient -> McpClient}.
+ *
+ * @author Daniel Garnier-Moiroux
+ */
+class McpToolsConfigurationTests {
+
+	private static final Logger log = LoggerFactory.getLogger(McpToolsConfigurationTests.class);
+
+	private final ApplicationContextRunner clientApplicationContext = new ApplicationContextRunner()
+		.withUserConfiguration(TestMcpClientHandlers.class)
+		// Create a transport
+		.withPropertyValues("spring.ai.mcp.client.streamable-http.connections.server1.url=http://localhost:0",
+				"spring.ai.mcp.client.initialized=false")
+		.withConfiguration(AutoConfigurations.of(McpToolCallbackAutoConfiguration.class,
+				McpClientAutoConfiguration.class, StreamableHttpWebFluxTransportAutoConfiguration.class,
+				McpClientAnnotationScannerAutoConfiguration.class, McpClientSpecificationFactoryAutoConfiguration.class,
+				ChatModelAutoConfiguration.class, ToolCallingAutoConfiguration.class,
+				ChatClientAutoConfiguration.class));
+
+	@Test
+	void mcpClientSupportsSampling() {
+		// 1.
+		this.clientApplicationContext.run(ctx -> {
+			String[] clients = ctx
+				.getBeanNamesForType(ResolvableType.forType(new ParameterizedTypeReference<List<McpSyncClient>>() {
+				}));
+			assertThat(clients).hasSize(1);
+			List<McpSyncClient> syncClients = (List<McpSyncClient>) ctx.getBean(clients[0]);
+			assertThat(syncClients).hasSize(1)
+				.first()
+				.extracting(McpSyncClient::getClientCapabilities)
+				.extracting(McpSchema.ClientCapabilities::sampling)
+				.describedAs("Sampling")
+				.isNotNull();
+		});
+	}
+
+	static class TestMcpClientHandlers {
+
+		private static final Logger logger = LoggerFactory
+			.getLogger(StreamableMcpAnnotationsWithLLMIT.TestMcpClientHandlers.class);
+
+		private final ChatClient chatClient;
+
+		TestMcpClientHandlers(ChatClient.Builder clientBuilder) {
+			this.chatClient = clientBuilder.build();
+		}
+
+		@McpSampling(clients = "server1")
+		McpSchema.CreateMessageResult samplingHandler(McpSchema.CreateMessageRequest llmRequest) {
+			logger.info("MCP SAMPLING: {}", llmRequest);
+
+			String userPrompt = ((McpSchema.TextContent) llmRequest.messages().get(0).content()).text();
+			String modelHint = llmRequest.modelPreferences().hints().get(0).name();
+			// In a real use-case, we would use the chat client to call the LLM again
+			logger.info("MCP SAMPLING: simulating using chat client {}", this.chatClient);
+
+			return McpSchema.CreateMessageResult.builder()
+				.content(new McpSchema.TextContent("Response " + userPrompt + " with model hint " + modelHint))
+				.build();
+		}
+
+	}
+
+	static class ChatModelAutoConfiguration {
+
+		@Bean
+		ChatModel chatModel() {
+			return mock(ChatModel.class);
+		}
+
+	}
+
+	// Theory: server does not suffer from cyclical dependencies
+
+}