Add support for MCP prompts

- Add prompt registry class and methods.
- Add prompt message, prompt parameter and roles classes.
- Extract common methods to RegistryBase class.
- Adjust McpToolRegistry accordingly.
- Add tests for simple prompts.
- Update MCP client test to list available prompts.

Author: josesimoes

nanoFramework.WebServer.Mcp/McpPromptMessage.cs

@@ -0,0 +1,55 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace nanoFramework.WebServer.Mcp
+{
+    /// <summary>
+    /// Represents a message within the Model Context Protocol (MCP) system, used for communication between clients and AI models.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// A <see cref="PromptMessage"/> encapsulates content sent to or received from AI models in the Model Context Protocol.
+    /// Each message has a specific role (<see cref="Role.User"/> or <see cref="Role.Assistant"/>) and contains content which can be text.
+    /// </para>
+    /// <para>
+    /// It serves as a core data structure in the MCP message exchange flow, particularly in prompt formation and model responses.
+    /// </para>
+    /// </remarks>
+    public sealed class PromptMessage
+    {
+        /// <summary>
+        /// Gets or sets the text content of the message.
+        /// </summary>
+        public string Text { get; set; }
+
+        /// <summary>
+        /// Gets or sets the role of the message sender, specifying whether it's from a "user" or an "assistant".
+        /// </summary>
+        /// <remarks>
+        /// In the Model Context Protocol, each message must have a clear role assignment to maintain
+        /// the conversation flow. User messages represent queries or inputs from users, while assistant
+        /// messages represent responses generated by AI models.
+        /// </remarks>
+        public Role Role { get; set; } = Role.User;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PromptMessage"/> class with this prompt text.
+        /// </summary>
+        /// <param name="text">The text content of the message.</param>
+        public PromptMessage(string text)
+        {
+            Text = text;
+        }
+
+        /// <inheritdoc/>
+        public override string ToString()
+        {
+            return $"{{\"role\":\"{RoleToString(Role)}\",\"content\":{{\"type\": \"text\",\"text\":\"{Text}\"}}}}";
+        }
+
+        private static string RoleToString(Role role)
+        {
+            return role == Role.User ? "user" : "assistant";
+        }
+    }
+}

nanoFramework.WebServer.Mcp/McpPromptParameter.cs

@@ -0,0 +1,52 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+
+namespace nanoFramework.WebServer.Mcp
+{
+    /// <summary>
+    /// Represents a parameter for a Model Context Protocol (MCP) prompt, providing metadata about the parameter such as its name and description.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// These have to be added to the methods implementing the MCP prompts in the same order as the parameters.
+    /// </para>
+    /// <para>
+    /// By design, if a prompt parameter is specified, it is considered required. .NET nanoFramework does not support optional parameters in MCP prompts.
+    /// </para>
+    /// </remarks>
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
+    public sealed class McpPromptParameterAttribute : Attribute
+    {
+        /// <summary>
+        /// Gets or sets the name of the prompt parameter.
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// Gets or sets the description of the prompt parameter.
+        /// </summary>
+        /// <remarks>
+        /// The description is optional.
+        /// </remarks>
+        public string Description { get; set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="McpPromptParameterAttribute"/> class with the specified name and description.
+        /// </summary>
+        /// <param name="name">The name of the prompt parameter.</param>
+        /// <param name="description">The description of the prompt parameter.</param>
+        public McpPromptParameterAttribute(string name, string description)
+        {
+            Name = name;
+            Description = description;
+        }
+
+        /// <inheritdoc/>
+        public override string ToString()
+        {
+            return $"{{\"name\":\"{Name}\",\"description\":\"{Description}\",\"required\":\"true\"}}";
+        }
+    }
+}

nanoFramework.WebServer.Mcp/McpPromptRegistry.cs

@@ -0,0 +1,203 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections;
+using System.Diagnostics;
+using System.Reflection;
+using System.Text;
+
+namespace nanoFramework.WebServer.Mcp
+{
+    /// <summary>
+    /// Registry for Model Context Protocol (MCP) prompts, allowing discovery and invocation of prompts defined with the <see cref="McpServerPromptAttribute"/>.
+    /// </summary>
+    public class McpPromptRegistry : RegistryBase
+    {
+        private static readonly Hashtable promtps = new Hashtable();
+        private static bool isInitialized = false;
+
+        /// <summary>
+        /// Discovers MCP prompts by scanning the provided types for methods decorated with the <see cref="McpServerPromptAttribute"/>.
+        /// This method should be called once to populate the tool registry.
+        /// </summary>
+        /// <param name="typesWithPrompts">An array of types to scan for MCP prompts.</param>
+        public static void DiscoverPrompts(Type[] typesWithPrompts)
+        {
+            if (isInitialized)
+            {
+                // prompts already discovered
+                return;
+            }
+
+            foreach (Type mcpPrompt in typesWithPrompts)
+            {
+                MethodInfo[] methods = mcpPrompt.GetMethods();
+
+                foreach (MethodInfo method in methods)
+                {
+                    try
+                    {
+                        object[] allAttribute = method.GetCustomAttributes(false);
+
+                        foreach (object attrib in allAttribute)
+                        {
+                            if (attrib.GetType() != typeof(McpServerPromptAttribute))
+                            {
+                                continue;
+                            }
+
+                            McpServerPromptAttribute attribute = (McpServerPromptAttribute)attrib;
+                            if (attribute != null)
+                            {
+                                // validate if the method returns an array of PromptMessage
+                                if (method.ReturnType != typeof(PromptMessage[]) && !method.ReturnType.IsArray)
+                                {
+                                    throw new Exception($"Method {method.Name} does not return an array of PromptMessage.");
+                                }
+
+                                promtps.Add(attribute.Name, new PromptMetadata
+                                {
+                                    Name = attribute.Name,
+                                    Description = attribute.Description,
+                                    Arguments = ComposeArgumentsAsJson(allAttribute),
+                                    Method = method
+                                });
+                            }
+                        }
+                    }
+                    catch (Exception)
+                    {
+                        continue;
+                    }
+                }
+            }
+
+            isInitialized = true;
+        }
+
+        private static string ComposeArgumentsAsJson(object[] attributes)
+        {
+            StringBuilder sb = new StringBuilder();
+            bool isFirst = true;
+
+            foreach (object attrib in attributes)
+            {
+                if (attrib is not McpPromptParameterAttribute)
+                {
+                    continue;
+                }
+
+                McpPromptParameterAttribute parameterNameAttribute = (McpPromptParameterAttribute)attrib;
+                if (parameterNameAttribute != null)
+                {
+                    sb.Append(isFirst ? "" : ",");
+
+                    sb.Append($"{{{parameterNameAttribute}}}");
+
+                    isFirst = false;
+                }
+            }
+
+            return sb.Length > 0 ? sb.ToString() : string.Empty;
+        }
+
+        /// <summary>
+        /// Gets the metadata of all registered MCP prompts in JSON format.
+        /// This method should be called after <see cref="DiscoverPrompts"/> to retrieve the prompt metadata.
+        /// </summary>
+        /// <returns>A JSON string containing the metadata of all registered prompts.</returns>
+        /// <exception cref="Exception">Thrown if there is an error building the prompts list.</exception>
+        public static string GetPromptMetadataJson()
+        {
+            try
+            {
+                StringBuilder sb = new StringBuilder();
+                sb.Append("\"prompts\":[");
+
+                foreach (PromptMetadata prompt in promtps.Values)
+                {
+                    sb.Append(prompt.ToString());
+                    sb.Append(",");
+                }
+
+                sb.Remove(sb.Length - 1, 1);
+                sb.Append("],\"nextCursor\":null");
+                return sb.ToString();
+            }
+            catch (Exception)
+            {
+                throw new Exception("Impossible to build prompts list.");
+            }
+        }
+
+        /// <summary>
+        /// Gets the description of a registered MCP prompt by its name.
+        /// </summary>
+        /// <param name="promptName">The name of the prompt to invoke.</param>
+        /// <returns>A string containing the description of the prompt.</returns>
+        /// <exception cref="Exception">Thrown when the specified prompt is not found in the registry.</exception>
+        public static string GetPromptDescription(string promptName)
+        {
+            if (promtps.Contains(promptName))
+            {
+                PromptMetadata promptMetadata = (PromptMetadata)promtps[promptName];
+                return promptMetadata.Description;
+            }
+
+            throw new Exception("Prompt not found");
+        }
+
+        /// <summary>
+        /// Invokes a registered MCP prompt by name and returns the serialized result.
+        /// </summary>
+        /// <param name="promptName">The name of the prompt to invoke.</param>
+        /// <param name="arguments">The arguments to pass to the tool.</param>
+        /// <returns>A JSON string containing the serialized result of the prompt invocation.</returns>
+        /// <exception cref="Exception">Thrown when the specified prompt is not found in the registry.</exception>
+        public static string InvokePrompt(string promptName, Hashtable arguments)
+        {
+            if (promtps.Contains(promptName))
+            {
+                PromptMetadata promptMetadata = (PromptMetadata)promtps[promptName];
+                MethodInfo method = promptMetadata.Method;
+                Debug.WriteLine($"Prompt name: {promptName}, method: {method.Name}");
+
+                object[] methodParams = null;
+
+                if (arguments is not null && arguments.Count > 0)
+                {
+                    methodParams = new object[arguments.Count];
+
+                    arguments.Values.CopyTo(methodParams, 0);
+                }
+
+                PromptMessage[] result = (PromptMessage[])method.Invoke(null, methodParams);
+
+                // serialize the result to JSON using a speedy approach with a StringBuilder
+                StringBuilder sb = new StringBuilder();
+
+                // start building the JSON response
+                sb.Append($"{{\"description\":\"{GetPromptDescription(promptName)}\",\"messages\":[");
+
+                // iterate through the result array and append each message
+                for (int i = 0; i < result.Length; i++)
+                {
+                    sb.Append(result[i]);
+                    if (i < result.Length - 1)
+                    {
+                        sb.Append(",");
+                    }
+                }
+
+                // close the messages array and the main object
+                sb.Append("]}");
+
+                // done here, return the JSON string
+                return sb.ToString();
+            }
+
+            throw new Exception("Prompt not found");
+        }
+    }
+}

nanoFramework.WebServer.Mcp/McpServerController.cs

@@ -120,11 +120,28 @@ public void HandleMcpRequest(WebServerEventArgs e)
 
                         sb.Append($",\"result\":{{\"content\":[{{\"type\":\"text\",\"text\":{result}}}]}}}}");
                     }
+                    else if (request["method"].ToString() == "prompts/list")
+                    {
+                        string promptListJson = McpPromptRegistry.GetPromptMetadataJson();
+                        sb.Append($",\"result\":{{{promptListJson}}}}}");
+                    }
+                    else if (request["method"].ToString() == "prompts/get")
+                    {
+                        string promptName = ((Hashtable)request["params"])["name"].ToString();
+                        Hashtable arguments = ((Hashtable)request["params"])["arguments"] == null ? null : (Hashtable)((Hashtable)request["params"])["arguments"];
+
+                        string result = McpPromptRegistry.InvokePrompt(promptName, arguments);
+                        sb.Append($",\"result\":{result}}}");
+                    }
                     else
                     {
                         sb.Append($",\"error\":{{\"code\":-32601,\"message\":\"Method not found\"}}}}");
                     }
 
+                    Debug.WriteLine();
+                    Debug.WriteLine($"Response: {sb.ToString()}");
+                    Debug.WriteLine();
+
                     WebServer.OutPutStream(e.Context.Response, sb.ToString());
                     return;
                 }

nanoFramework.WebServer.Mcp/McpServerPromptAttribute.cs

@@ -0,0 +1,42 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+
+namespace nanoFramework.WebServer.Mcp
+{
+    /// <summary>
+    /// Used to indicate that a method should be considered an <see cref="McpServerPromptAttribute"/>.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// This attribute is applied to methods that should be exposed as prompts in the Model Context Protocol. When a class 
+    /// containing methods marked with this attribute is registered with McpServerBuilderExtensions,
+    /// these methods become available as prompts that can be called by MCP clients.
+    /// </para>
+    /// </remarks>
+    [AttributeUsage(AttributeTargets.Method)]
+    public class McpServerPromptAttribute : Attribute
+    {
+        /// <summary>
+        /// Gets the name of the prompt.
+        /// </summary>
+        public string Name { get; }
+
+        /// <summary>
+        /// Gets the description of the tool.
+        /// </summary>
+        public string Description { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="McpServerPromptAttribute"/> class with the specified name and description.
+        /// </summary>
+        /// <param name="name">The unique name of the prompt.</param>
+        /// <param name="description">The description of the prompt.</param>
+        public McpServerPromptAttribute(string name, string description = "")
+        {
+            Name = name;
+            Description = description;
+        }
+    }
+}