Use fully-qualified type names in generated partial method signatures

Changes XmlToDescriptionGenerator to use FullyQualifiedFormat with
global:: prefix instead of MinimallyQualifiedFormat when emitting
parameter and return types in generated partial declarations.

This fixes build failures when MCP tool methods have parameters with
types defined in different namespaces (e.g., enums from separate
namespace modules).

Also includes nullability annotation support via
SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier.

Co-authored-by: stephentoub <2642209+stephentoub@users.noreply.github.com>

Author: Copilot

src/ModelContextProtocol.Analyzers/XmlToDescriptionGenerator.cs

@@ -19,6 +19,14 @@ public sealed class XmlToDescriptionGenerator : IIncrementalGenerator
 {
     private const string GeneratedFileName = "ModelContextProtocol.Descriptions.g.cs";
 
+    /// <summary>
+    /// A display format that produces fully-qualified type names with "global::" prefix
+    /// and includes nullability annotations.
+    /// </summary>
+    private static readonly SymbolDisplayFormat FullyQualifiedFormatWithNullability =
+        SymbolDisplayFormat.FullyQualifiedFormat.AddMiscellaneousOptions(
+            SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier);
+
     public void Initialize(IncrementalGeneratorInitializationContext context)
     {
         // Extract method information for all MCP tools, prompts, and resources.
@@ -125,7 +133,7 @@ private static MethodToGenerate ExtractMethodInfo(
             .Where(m => !m.IsKind(SyntaxKind.AsyncKeyword))
             .Select(m => m.Text);
         string modifiersStr = string.Join(" ", modifiers);
-        string returnType = methodSymbol.ReturnType.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat);
+        string returnType = methodSymbol.ReturnType.ToDisplayString(FullyQualifiedFormatWithNullability);
         string methodName = methodSymbol.Name;
 
         // Extract parameters
@@ -137,7 +145,7 @@ private static MethodToGenerate ExtractMethodInfo(
             var paramSyntax = i < parameterSyntaxList.Count ? parameterSyntaxList[i] : null;
 
             parameters[i] = new ParameterInfo(
-                ParameterType: param.Type.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat),
+                ParameterType: param.Type.ToDisplayString(FullyQualifiedFormatWithNullability),
                 Name: param.Name,
                 HasDescriptionAttribute: descriptionAttribute is not null && HasAttribute(param, descriptionAttribute),
                 XmlDescription: xmlDocs?.Parameters.TryGetValue(param.Name, out var pd) == true && !string.IsNullOrWhiteSpace(pd) ? pd : null,

tests/ModelContextProtocol.Analyzers.Tests/XmlToDescriptionGeneratorTests.cs

@@ -1561,7 +1561,7 @@ namespace Test
                 partial class TestTools
                 {
                     [Description("Async tool")]
-                    public partial Task<string> DoWorkAsync(string input);
+                    public partial global::System.Threading.Tasks.Task<string> DoWorkAsync(string input);
                 }
             }
             """;
@@ -1611,7 +1611,7 @@ namespace Test
                 partial class TestTools
                 {
                     [Description("Static async tool")]
-                    public static partial Task<string> StaticAsyncMethod(string input);
+                    public static partial global::System.Threading.Tasks.Task<string> StaticAsyncMethod(string input);
                 }
             }
             """;
@@ -1663,7 +1663,7 @@ namespace Test
                 partial class TestTools
                 {
                     [Description("Async tool with defaults")]
-                    public static partial Task<string> AsyncWithDefaults([Description("The input")] string input, [Description("Timeout in ms")] int timeout = 1000);
+                    public static partial global::System.Threading.Tasks.Task<string> AsyncWithDefaults([Description("The input")] string input, [Description("Timeout in ms")] int timeout = 1000);
                 }
             }
             """;
@@ -1719,6 +1719,64 @@ partial class TestTools
         AssertGeneratedSourceEquals(expected, result.GeneratedSources[0].SourceText.ToString());
     }
 
+    [Fact]
+    public void Generator_WithEnumFromDifferentNamespace_GeneratesFullyQualifiedTypeName()
+    {
+        // This test validates the fix for the issue where parameter types from different namespaces
+        // caused build failures because the generator was emitting unqualified type names.
+        var result = RunGenerator("""
+            using ModelContextProtocol.Server;
+            using System.ComponentModel;
+            using System.Threading.Tasks;
+
+            namespace MyApp.Actions
+            {
+                public enum MyAction
+                {
+                    One,
+                    Two
+                }
+            }
+
+            namespace MyApp
+            {
+                [McpServerToolType]
+                public sealed partial class Tools
+                {
+                    /// <summary>Do a thing based on an action.</summary>
+                    /// <param name="action">The action to perform.</param>
+                    [McpServerTool]
+                    public async partial Task<string> DoThing(MyApp.Actions.MyAction action)
+                        => await Task.FromResult("ok");
+                }
+            }
+            """);
+
+        Assert.True(result.Success);
+        Assert.Single(result.GeneratedSources);
+
+        var expected = $$"""
+            // <auto-generated/>
+            // ModelContextProtocol.Analyzers {{typeof(XmlToDescriptionGenerator).Assembly.GetName().Version}}
+
+            #pragma warning disable
+
+            using System.ComponentModel;
+            using ModelContextProtocol.Server;
+
+            namespace MyApp
+            {
+                partial class Tools
+                {
+                    [Description("Do a thing based on an action.")]
+                    public partial global::System.Threading.Tasks.Task<string> DoThing([Description("The action to perform.")] global::MyApp.Actions.MyAction action);
+                }
+            }
+            """;
+
+        AssertGeneratedSourceEquals(expected, result.GeneratedSources[0].SourceText.ToString());
+    }
+
     private GeneratorRunResult RunGenerator([StringSyntax("C#-test")] string source, params string[] expectedDiagnosticIds)
     {
         var syntaxTree = CSharpSyntaxTree.ParseText(source);