Mark samples as AOT compatible

agocke · agocke · commit 49dee53ebc43 · 2025-04-01T14:57:36.000-07:00
There's some follow-up work with Anthropic and Serilog. I also deleted
the AOT-problematic methods from the SDK.
diff --git a/samples/AspNetCoreSseServer/AspNetCoreSseServer.csproj b/samples/AspNetCoreSseServer/AspNetCoreSseServer.csproj
@@ -4,6 +4,7 @@
     <TargetFramework>net9.0</TargetFramework>
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
+    <PublishAot>true</PublishAot>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/samples/AspNetCoreSseServer/Program.cs b/samples/AspNetCoreSseServer/Program.cs
@@ -1,5 +1,10 @@
+using TestServerWithHosting.Tools;
+
 var builder = WebApplication.CreateBuilder(args);
-builder.Services.AddMcpServer().WithToolsFromAssembly();
+builder.Services.AddMcpServer()
+    .WithTools<EchoTool>()
+    .WithTools<SampleLlmTool>();
+
 var app = builder.Build();
 
 app.MapMcp();
diff --git a/samples/AspNetCoreSseServer/Tools/EchoTool.cs b/samples/AspNetCoreSseServer/Tools/EchoTool.cs
@@ -4,7 +4,7 @@
 namespace TestServerWithHosting.Tools;
 
 [McpServerToolType]
-public static class EchoTool
+public sealed class EchoTool
 {
     [McpServerTool, Description("Echoes the input back to the client.")]
     public static string Echo(string message)
diff --git a/samples/AspNetCoreSseServer/Tools/SampleLlmTool.cs b/samples/AspNetCoreSseServer/Tools/SampleLlmTool.cs
@@ -8,7 +8,7 @@ namespace TestServerWithHosting.Tools;
 /// This tool uses dependency injection and async method
 /// </summary>
 [McpServerToolType]
-public static class SampleLlmTool
+public sealed class SampleLlmTool
 {
     [McpServerTool(Name = "sampleLLM"), Description("Samples from an LLM using MCP's sampling feature")]
     public static async Task<string> SampleLLM(
diff --git a/samples/ChatWithTools/ChatWithTools.csproj b/samples/ChatWithTools/ChatWithTools.csproj
@@ -5,6 +5,10 @@
     <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
+    <!--
+    Anthropic SDK isn't AOT compatible yet
+    <PublishAot>true</PublishAot>
+    -->
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/samples/QuickstartClient/QuickstartClient.csproj b/samples/QuickstartClient/QuickstartClient.csproj
@@ -6,6 +6,10 @@
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
         <UserSecretsId>a4e20a70-5009-4b81-b5b6-780b6d43e78e</UserSecretsId>
+        <!--
+        Anthropic SDK isn't AOT compatible yet
+        <PublishAot>true</PublishAot>
+        -->
     </PropertyGroup>
 
     <ItemGroup>
diff --git a/samples/QuickstartWeatherServer/Program.cs b/samples/QuickstartWeatherServer/Program.cs
@@ -1,13 +1,14 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
+using QuickstartWeatherServer.Tools;
 using System.Net.Http.Headers;
 
 var builder = Host.CreateApplicationBuilder(args);
 
 builder.Services.AddMcpServer()
     .WithStdioServerTransport()
-    .WithToolsFromAssembly();
+    .WithTools<WeatherTools>();
 
 builder.Logging.AddConsole(options =>
 {
diff --git a/samples/QuickstartWeatherServer/QuickstartWeatherServer.csproj b/samples/QuickstartWeatherServer/QuickstartWeatherServer.csproj
@@ -5,6 +5,7 @@
         <TargetFramework>net8.0</TargetFramework>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
+        <PublishAot>true</PublishAot>
     </PropertyGroup>
 
     <ItemGroup>
diff --git a/samples/QuickstartWeatherServer/Tools/HttpClientExt.cs b/samples/QuickstartWeatherServer/Tools/HttpClientExt.cs
@@ -0,0 +1,14 @@
+
+using System.Text.Json;
+
+namespace ModelContextProtocol;
+
+internal static class HttpClientExt
+{
+    public static async Task<JsonDocument> ReadJsonDocument(this HttpClient client, string requestUri)
+    {
+        using var response = await client.GetAsync(requestUri);
+        response.EnsureSuccessStatusCode();
+        return await JsonDocument.ParseAsync(await response.Content.ReadAsStreamAsync());
+    }
+}
diff --git a/samples/QuickstartWeatherServer/Tools/WeatherTools.cs b/samples/QuickstartWeatherServer/Tools/WeatherTools.cs
@@ -1,3 +1,4 @@
+using ModelContextProtocol;
 using ModelContextProtocol.Server;
 using System.ComponentModel;
 using System.Net.Http.Json;
@@ -6,14 +7,15 @@
 namespace QuickstartWeatherServer.Tools;
 
 [McpServerToolType]
-public static class WeatherTools
+public sealed class WeatherTools
 {
     [McpServerTool, Description("Get weather alerts for a US state.")]
     public static async Task<string> GetAlerts(
         HttpClient client,
         [Description("The US state to get alerts for.")] string state)
     {
-        var jsonElement = await client.GetFromJsonAsync<JsonElement>($"/alerts/active/area/{state}");
+        using var jsonDocument = await client.ReadJsonDocument($"/alerts/active/area/{state}");
+        var jsonElement = jsonDocument.RootElement;
         var alerts = jsonElement.GetProperty("features").EnumerateArray();
 
         if (!alerts.Any())
@@ -40,7 +42,8 @@ public static async Task<string> GetForecast(
         [Description("Latitude of the location.")] double latitude,
         [Description("Longitude of the location.")] double longitude)
     {
-        var jsonElement = await client.GetFromJsonAsync<JsonElement>($"/points/{latitude},{longitude}");
+        using var jsonDocument = await client.ReadJsonDocument($"/points/{latitude},{longitude}");
+        var jsonElement = jsonDocument.RootElement;
         var periods = jsonElement.GetProperty("properties").GetProperty("periods").EnumerateArray();
 
         return string.Join("\n---\n", periods.Select(period => $"""
diff --git a/samples/TestServerWithHosting/Program.cs b/samples/TestServerWithHosting/Program.cs
@@ -1,6 +1,7 @@
 ﻿using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Serilog;
+using TestServerWithHosting.Tools;
 
 Log.Logger = new LoggerConfiguration()
            .MinimumLevel.Verbose() // Capture all log levels
@@ -19,7 +20,8 @@
     builder.Services.AddSerilog();
     builder.Services.AddMcpServer()
         .WithStdioServerTransport()
-        .WithToolsFromAssembly();
+        .WithTools<EchoTool>()
+        .WithTools<SampleLlmTool>();
 
     var app = builder.Build();
 
diff --git a/samples/TestServerWithHosting/TestServerWithHosting.csproj b/samples/TestServerWithHosting/TestServerWithHosting.csproj
@@ -5,6 +5,10 @@
     <TargetFramework>net9.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
+    <!--
+    Serilog AOT support regressed
+    <PublishAot>true</PublishAot>
+    -->
   </PropertyGroup>
 
   <ItemGroup>
@@ -13,6 +17,9 @@
     <PackageReference Include="Serilog.Sinks.Console" />
     <PackageReference Include="Serilog.Sinks.Debug" />
     <PackageReference Include="Serilog.Sinks.File" />
+    <RuntimeHostConfigurationOption
+      Include="Serilog.IsCompilerGeneratedCodeSupported"
+      Value="false" Trim="true" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/samples/TestServerWithHosting/Tools/EchoTool.cs b/samples/TestServerWithHosting/Tools/EchoTool.cs
@@ -4,7 +4,7 @@
 namespace TestServerWithHosting.Tools;
 
 [McpServerToolType]
-public static class EchoTool
+public sealed class EchoTool
 {
     [McpServerTool, Description("Echoes the input back to the client.")]
     public static string Echo(string message)
diff --git a/samples/TestServerWithHosting/Tools/SampleLlmTool.cs b/samples/TestServerWithHosting/Tools/SampleLlmTool.cs
@@ -8,7 +8,7 @@ namespace TestServerWithHosting.Tools;
 /// This tool uses depenency injection and async method
 /// </summary>
 [McpServerToolType]
-public static class SampleLlmTool
+public sealed class SampleLlmTool
 {
     [McpServerTool(Name = "sampleLLM"), Description("Samples from an LLM using MCP's sampling feature")]
     public static async Task<string> SampleLLM(
diff --git a/src/ModelContextProtocol/Configuration/McpServerBuilderExtensions.cs b/src/ModelContextProtocol/Configuration/McpServerBuilderExtensions.cs
@@ -15,11 +15,6 @@ namespace Microsoft.Extensions.DependencyInjection;
 /// </summary>
 public static partial class McpServerBuilderExtensions
 {
-    #region WithTools
-    private const string WithToolsRequiresUnreferencedCodeMessage =
-        $"The non-generic {nameof(WithTools)} and {nameof(WithToolsFromAssembly)} methods require dynamic lookup of method metadata" +
-        $"and may not work in Native AOT. Use the generic {nameof(WithTools)} method instead.";
-
     /// <summary>Adds <see cref="McpServerTool"/> instances to the service collection backing <paramref name="builder"/>.</summary>
     /// <typeparam name="TToolType">The tool type.</typeparam>
     /// <param name="builder">The builder instance.</param>
@@ -50,66 +45,6 @@ public static partial class McpServerBuilderExtensions
         return builder;
     }
 
-    /// <summary>Adds <see cref="McpServerTool"/> instances to the service collection backing <paramref name="builder"/>.</summary>
-    /// <param name="builder">The builder instance.</param>
-    /// <param name="toolTypes">Types with marked methods to add as tools to the server.</param>
-    /// <exception cref="ArgumentNullException"><paramref name="builder"/> is <see langword="null"/>.</exception>
-    /// <exception cref="ArgumentNullException"><paramref name="toolTypes"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// This method discovers all instance and static methods (public and non-public) on the specified <paramref name="toolTypes"/>
-    /// types, where the methods are attributed as <see cref="McpServerToolAttribute"/>, and adds an <see cref="McpServerTool"/>
-    /// instance for each. For instance methods, an instance will be constructed for each invocation of the tool.
-    /// </remarks>
-    [RequiresUnreferencedCode(WithToolsRequiresUnreferencedCodeMessage)]
-    public static IMcpServerBuilder WithTools(this IMcpServerBuilder builder, params IEnumerable<Type> toolTypes)
-    {
-        Throw.IfNull(builder);
-        Throw.IfNull(toolTypes);
-
-        foreach (var toolType in toolTypes)
-        {
-            if (toolType is not null)
-            {
-                foreach (var toolMethod in toolType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance))
-                {
-                    if (toolMethod.GetCustomAttribute<McpServerToolAttribute>() is not null)
-                    {
-                        builder.Services.AddSingleton((Func<IServiceProvider, McpServerTool>)(toolMethod.IsStatic ?
-                            services => McpServerTool.Create(toolMethod, options: new() { Services = services }) :
-                            services => McpServerTool.Create(toolMethod, toolType, new() { Services = services })));
-                    }
-                }
-            }
-        }
-
-        return builder;
-    }
-
-    /// <summary>
-    /// Adds types marked with the <see cref="McpServerToolTypeAttribute"/> attribute from the given assembly as tools to the server.
-    /// </summary>
-    /// <param name="builder">The builder instance.</param>
-    /// <param name="toolAssembly">The assembly to load the types from. Null to get the current assembly</param>
-    /// <exception cref="ArgumentNullException"><paramref name="builder"/> is <see langword="null"/>.</exception>
-    [RequiresUnreferencedCode(WithToolsRequiresUnreferencedCodeMessage)]
-    public static IMcpServerBuilder WithToolsFromAssembly(this IMcpServerBuilder builder, Assembly? toolAssembly = null)
-    {
-        Throw.IfNull(builder);
-
-        toolAssembly ??= Assembly.GetCallingAssembly();
-
-        return builder.WithTools(
-            from t in toolAssembly.GetTypes()
-            where t.GetCustomAttribute<McpServerToolTypeAttribute>() is not null
-            select t);
-    }
-    #endregion
-
-    #region WithPrompts
-    private const string WithPromptsRequiresUnreferencedCodeMessage =
-        $"The non-generic {nameof(WithPrompts)} and {nameof(WithPromptsFromAssembly)} methods require dynamic lookup of method metadata" +
-        $"and may not work in Native AOT. Use the generic {nameof(WithPrompts)} method instead.";
-
     /// <summary>Adds <see cref="McpServerPrompt"/> instances to the service collection backing <paramref name="builder"/>.</summary>
     /// <typeparam name="TPromptType">The prompt type.</typeparam>
     /// <param name="builder">The builder instance.</param>
@@ -140,61 +75,6 @@ where t.GetCustomAttribute<McpServerToolTypeAttribute>() is not null
         return builder;
     }
 
-    /// <summary>Adds <see cref="McpServerPrompt"/> instances to the service collection backing <paramref name="builder"/>.</summary>
-    /// <param name="builder">The builder instance.</param>
-    /// <param name="promptTypes">Types with marked methods to add as prompts to the server.</param>
-    /// <exception cref="ArgumentNullException"><paramref name="builder"/> is <see langword="null"/>.</exception>
-    /// <exception cref="ArgumentNullException"><paramref name="promptTypes"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// This method discovers all instance and static methods (public and non-public) on the specified <paramref name="promptTypes"/>
-    /// types, where the methods are attributed as <see cref="McpServerPromptAttribute"/>, and adds an <see cref="McpServerPrompt"/>
-    /// instance for each. For instance methods, an instance will be constructed for each invocation of the prompt.
-    /// </remarks>
-    [RequiresUnreferencedCode(WithPromptsRequiresUnreferencedCodeMessage)]
-    public static IMcpServerBuilder WithPrompts(this IMcpServerBuilder builder, params IEnumerable<Type> promptTypes)
-    {
-        Throw.IfNull(builder);
-        Throw.IfNull(promptTypes);
-
-        foreach (var promptType in promptTypes)
-        {
-            if (promptType is not null)
-            {
-                foreach (var promptMethod in promptType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance))
-                {
-                    if (promptMethod.GetCustomAttribute<McpServerPromptAttribute>() is not null)
-                    {
-                        builder.Services.AddSingleton((Func<IServiceProvider, McpServerPrompt>)(promptMethod.IsStatic ?
-                            services => McpServerPrompt.Create(promptMethod, options: new() { Services = services }) :
-                            services => McpServerPrompt.Create(promptMethod, promptType, new() { Services = services })));
-                    }
-                }
-            }
-        }
-
-        return builder;
-    }
-
-    /// <summary>
-    /// Adds types marked with the <see cref="McpServerPromptTypeAttribute"/> attribute from the given assembly as prompts to the server.
-    /// </summary>
-    /// <param name="builder">The builder instance.</param>
-    /// <param name="promptAssembly">The assembly to load the types from. Null to get the current assembly</param>
-    /// <exception cref="ArgumentNullException"><paramref name="builder"/> is <see langword="null"/>.</exception>
-    [RequiresUnreferencedCode(WithPromptsRequiresUnreferencedCodeMessage)]
-    public static IMcpServerBuilder WithPromptsFromAssembly(this IMcpServerBuilder builder, Assembly? promptAssembly = null)
-    {
-        Throw.IfNull(builder);
-
-        promptAssembly ??= Assembly.GetCallingAssembly();
-
-        return builder.WithPrompts(
-            from t in promptAssembly.GetTypes()
-            where t.GetCustomAttribute<McpServerPromptTypeAttribute>() is not null
-            select t);
-    }
-    #endregion
-
     #region Handlers
     /// <summary>
     /// Sets the handler for list resource templates requests.
diff --git a/src/ModelContextProtocol/Server/McpServerPromptTypeAttribute.cs b/src/ModelContextProtocol/Server/McpServerPromptTypeAttribute.cs
@@ -6,9 +6,8 @@ namespace ModelContextProtocol.Server;
 /// Used to attribute a type containing methods that should be exposed as MCP prompts.
 /// </summary>
 /// <remarks>
-/// This is primarily relevant to methods that scan types in an assembly looking for methods
-/// to expose, such as <see cref="McpServerBuilderExtensions.WithPromptsFromAssembly"/>. It is not
-/// necessary to attribute types explicitly provided to a method like <see cref="McpServerBuilderExtensions.WithPrompts{TPrompt}"/>.
+/// It is not necessary to attribute types explicitly provided to a method like <see
+/// cref="McpServerBuilderExtensions.WithPrompts{TPrompt}"/>.
 /// </remarks>
 [AttributeUsage(AttributeTargets.Class)]
 public sealed class McpServerPromptTypeAttribute : Attribute;
diff --git a/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsPromptsTests.cs b/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsPromptsTests.cs
@@ -249,30 +249,15 @@ public async Task Throws_Exception_Missing_Parameter()
     [Fact]
     public void WithPrompts_InvalidArgs_Throws()
     {
-        Assert.Throws<ArgumentNullException>("promptTypes", () => _builder.WithPrompts((IEnumerable<Type>)null!));
 
         IMcpServerBuilder nullBuilder = null!;
         Assert.Throws<ArgumentNullException>("builder", () => nullBuilder.WithPrompts<object>());
-        Assert.Throws<ArgumentNullException>("builder", () => nullBuilder.WithPrompts(Array.Empty<Type>()));
-        Assert.Throws<ArgumentNullException>("builder", () => nullBuilder.WithPromptsFromAssembly());
     }
 
     [Fact]
     public void Empty_Enumerables_Is_Allowed()
     {
-        _builder.WithPrompts(promptTypes: []); // no exception
         _builder.WithPrompts<object>(); // no exception even though no prompts exposed
-        _builder.WithPromptsFromAssembly(typeof(AIFunction).Assembly); // no exception even though no prompts exposed
-    }
-
-    [Fact]
-    public void Register_Prompts_From_Current_Assembly()
-    {
-        ServiceCollection sc = new();
-        sc.AddMcpServer().WithPromptsFromAssembly();
-        IServiceProvider services = sc.BuildServiceProvider();
-
-        Assert.Contains(services.GetServices<McpServerPrompt>(), t => t.ProtocolPrompt.Name == nameof(SimplePrompts.ReturnsChatMessages));
     }
 
     [Fact]
diff --git a/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsToolsTests.cs b/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsToolsTests.cs

Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`	`namespace TestServerWithHosting.Tools;`
`5`	`5`
`6`	`6`	`[McpServerToolType]`
`7`		`-public static class EchoTool`
	`7`	`+public sealed class EchoTool`
`8`	`8`	`{`
`9`	`9`	`[McpServerTool, Description("Echoes the input back to the client.")]`
`10`	`10`	`public static string Echo(string message)`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ namespace TestServerWithHosting.Tools;`
`8`	`8`	`/// This tool uses dependency injection and async method`
`9`	`9`	`/// </summary>`
`10`	`10`	`[McpServerToolType]`
`11`		`-public static class SampleLlmTool`
	`11`	`+public sealed class SampleLlmTool`
`12`	`12`	`{`
`13`	`13`	`[McpServerTool(Name = "sampleLLM"), Description("Samples from an LLM using MCP's sampling feature")]`
`14`	`14`	`public static async Task<string> SampleLLM(`