Fix trimming warnings by using generic type registration methods

Author: yotsuda

PowerShell.MCP.Proxy/Extensions/LocalizedMcpServerBuilderExtensions.cs

@@ -1,3 +1,4 @@
+using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
 using System.Text.Json;
 using System.Text.Json.Nodes;
@@ -16,6 +17,7 @@ public static class LocalizedMcpServerBuilderExtensions
     /// Adds types marked with McpServerPromptTypeAttribute from the given assembly as prompts to the server,
     /// with support for localized prompt names via LocalizedNameAttribute.
     /// </summary>
+    [RequiresUnreferencedCode("This method uses reflection to discover prompt types and methods.")]
     public static IMcpServerBuilder WithLocalizedPromptsFromAssembly(
         this IMcpServerBuilder builder,
         Assembly? promptAssembly = null,
@@ -131,7 +133,119 @@ paramNode is JsonObject paramObject &&
         }
     }
 
-    private static object CreateTarget(IServiceProvider? services, Type targetType)
+    /// <summary>
+    /// Adds the specified prompt type with support for localized prompt names via LocalizedNameAttribute.
+    /// This generic version is trimming-safe.
+    /// </summary>
+    public static IMcpServerBuilder WithLocalizedPrompts<[DynamicallyAccessedMembers(
+        DynamicallyAccessedMemberTypes.PublicMethods | 
+        DynamicallyAccessedMemberTypes.NonPublicMethods |
+        DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] TPromptType>(
+        this IMcpServerBuilder builder,
+        JsonSerializerOptions? serializerOptions = null)
+        where TPromptType : class
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+
+        try
+        {
+            var promptType = typeof(TPromptType);
+            var promptMethods = promptType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance)
+                .Where(m => m.GetCustomAttribute<McpServerPromptAttribute>() is not null);
+
+            foreach (var promptMethod in promptMethods)
+            {
+                // Get localized name from LocalizedNameAttribute if present
+                string? localizedName = null;
+                try
+                {
+                    if (promptMethod.GetCustomAttribute<LocalizedNameAttribute>() is { } localizedNameAttr)
+                    {
+                        localizedName = localizedNameAttr.Name;
+                    }
+                }
+                catch
+                {
+                    // Ignore localization errors
+                }
+
+                // Build parameter name mappings for localized descriptions
+                var parameterNameMappings = new Dictionary<string, string>();
+                foreach (var param in promptMethod.GetParameters())
+                {
+                    var resourceDescAttr = param.GetCustomAttribute<ResourceDescriptionAttribute>();
+                    if (resourceDescAttr is not null)
+                    {
+                        parameterNameMappings[param.Name!] = resourceDescAttr.Description;
+                    }
+                }
+
+                // Create schema options to inject localized titles for parameters
+                var schemaCreateOptions = new AIJsonSchemaCreateOptions
+                {
+                    TransformSchemaNode = (context, node) =>
+                    {
+                        if (node.GetValueKind() == JsonValueKind.Object && node is JsonObject jsonObject)
+                        {
+                            foreach (var kvp in parameterNameMappings)
+                            {
+                                var paramName = kvp.Key;
+                                var localizedTitle = kvp.Value;
+                                
+                                if (jsonObject.TryGetPropertyValue(paramName, out var paramNode) &&
+                                    paramNode is JsonObject paramObject &&
+                                    !paramObject.ContainsKey("title"))
+                                {
+                                    paramObject["title"] = localizedTitle;
+                                }
+                            }
+                        }
+                        return node;
+                    }
+                };
+
+                var options = new McpServerPromptCreateOptions
+                {
+                    Services = null,
+                    SerializerOptions = serializerOptions,
+                    Name = localizedName,
+                    SchemaCreateOptions = schemaCreateOptions
+                };
+
+                if (promptMethod.IsStatic)
+                {
+                    builder.Services.AddSingleton<McpServerPrompt>(services =>
+                    {
+                        options.Services = services;
+                        return McpServerPrompt.Create(promptMethod, options: options);
+                    });
+                }
+                else
+                {
+                    builder.Services.AddSingleton<McpServerPrompt>(services =>
+                    {
+                        options.Services = services;
+                        return McpServerPrompt.Create(
+                            promptMethod,
+                            r => CreateTarget(r.Services, promptType),
+                            options);
+                    });
+                }
+            }
+
+            return builder;
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"[ERROR] WithLocalizedPrompts<{typeof(TPromptType).Name}> failed: {ex.Message}");
+            Console.Error.WriteLine($"[ERROR] Stack trace: {ex.StackTrace}");
+            throw;
+        }
+    }
+
+    private static object CreateTarget(
+        IServiceProvider? services,
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type targetType)
     {
         if (services is not null && services.GetService(targetType) is { } instance)
         {

PowerShell.MCP.Proxy/PowerShell.MCP.Proxy.csproj

@@ -6,7 +6,7 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <Version>1.3.9.0</Version>
-    <NoWarn>$(NoWarn);IL2026;IL2067;IL2075;NETSDK1206</NoWarn>
+    <NoWarn>$(NoWarn);NETSDK1206</NoWarn>
 
     <!-- Single File デプロイ設定 -->
     <PublishSingleFile>true</PublishSingleFile>

PowerShell.MCP.Proxy/Program.cs

@@ -2,6 +2,8 @@
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using PowerShell.MCP.Proxy.Services;
+using PowerShell.MCP.Proxy.Tools;
+using PowerShell.MCP.Proxy.Prompts;
 using System.Reflection;
 
 namespace PowerShell.MCP.Proxy
@@ -30,8 +32,8 @@ public static async Task Main(string[] args)
             builder.Services
                 .AddMcpServer()
                 .WithStdioServerTransport()
-                .WithToolsFromAssembly()
-                .WithLocalizedPromptsFromAssembly(Assembly.GetExecutingAssembly()); // Use localized prompts
+                .WithTools<PowerShellTools>()
+                .WithLocalizedPrompts<PowerShellPrompts>();
 
             await builder.Build().RunAsync();
         }

PowerShell.MCP.Proxy/Prompts/PowerShellPrompts.cs

@@ -5,7 +5,7 @@
 namespace PowerShell.MCP.Proxy.Prompts;
 
 [McpServerPromptType]
-public static class PowerShellPrompts
+public class PowerShellPrompts
 {
     [McpServerPrompt]
     [LocalizedName("Prompt_AnalyzeContent_Name")]

PowerShell.MCP.Proxy/Tools/PowerShellTools.cs

@@ -6,7 +6,7 @@
 namespace PowerShell.MCP.Proxy.Tools;
 
 [McpServerToolType]
-public static class PowerShellTools
+public class PowerShellTools
 {
     // Error message constant definitions
     private const string ERROR_CONSOLE_NOT_RUNNING = "The PowerShell 7 console is not running.";