Merge branch 'modelcontextprotocol:main' into logging_capability_raw

Author: PederHP

.github/workflows/markdown-link-check.yml

@@ -0,0 +1,16 @@
+name: Check Markdown links
+
+on:
+    push:
+      branches: [ "main" ]
+    pull_request:
+      branches: [ "main" ]
+
+jobs:
+  markdown-link-check:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@main
+      - name: Markup Link Checker (mlc)
+        uses: becheran/[email protected]

.github/workflows/release.yml

@@ -0,0 +1,91 @@
+# This workflow is triggered by new releases
+# It builds, tests, and publishes to the GitHub NuGet package registry
+name: Release package
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  build:
+
+    runs-on: windows-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # Shallow clones should be disabled for a better relevancy of analysis
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v2
+        with:
+          dotnet-version: |
+            9.0.x
+            8.0.x
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: '20'
+
+      - name: Install dependencies for tests
+        run: npm install @modelcontextprotocol/server-everything
+
+      - name: Install dependencies for tests
+        run: npm install @modelcontextprotocol/server-memory
+
+      - name: Build
+        run: dotnet build --configuration Release
+
+      - name: Test
+        run: dotnet test --configuration Release --no-build --filter '(Execution!=Manual)'
+
+      - name: Pack
+        run: dotnet pack --configuration Release --output "${{ github.workspace }}/artifacts/packages"
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        if: ${{ !cancelled() }}
+        with:
+          name: build-artifacts
+          path: ${{ github.workspace }}/artifacts
+
+  publish:
+    name: Publish Package
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v2
+        with:
+          dotnet-version: |
+            9.0.x
+            8.0.x
+
+      - name: Download build artifacts
+        uses: actions/download-artifact@v4
+
+      - name: Upload release asset
+        if: github.event_name == 'release'
+        run: gh release upload ${{ github.event.release.tag_name }}
+          ${{ github.workspace }}/build-artifacts/packages/*.*nupkg
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: NuGet authentication for GitHub
+        run: dotnet nuget add source
+          "https://nuget.pkg.github.com/${{ github.repository_owner }}/index.json"
+          --name "github"
+          --username ${{ github.actor }}
+          --password ${{ secrets.GITHUB_TOKEN }}
+          --store-password-in-clear-text
+
+      - name: Publish to GitHub NuGet package registry
+        run: dotnet nuget push
+            ${{github.workspace}}/build-artifacts/packages/*.nupkg
+            --source "github"
+            --api-key ${{ secrets.GITHUB_TOKEN }}
+            --skip-duplicate

Open.snk

@@ -10,6 +10,7 @@ The official C# SDK for the [Model Context Protocol](https://modelcontextprotoco
 The Model Context Protocol (MCP) is an open protocol that standardizes how applications provide context to Large Language Models (LLMs). It enables secure integration between LLMs and various data sources and tools.
 
 For more information about MCP:
+
 - [Official Documentation](https://modelcontextprotocol.io/)
 - [Protocol Specification](https://spec.modelcontextprotocol.io/)
 - [GitHub Organization](https://github.com/modelcontextprotocol)
@@ -19,12 +20,13 @@ For more information about MCP:
 To get started writing a client, the `McpClientFactory.CreateAsync` method is used to instantiate and connect an `IMcpClient`
 to a server, with details about the client and server specified in `McpClientOptions` and `McpServerConfig` objects.
 Once you have an `IMcpClient`, you can interact with it, such as to enumerate all available tools and invoke tools.
+
 ```csharp
 McpClientOptions options = new()
 {
     ClientInfo = new() { Name = "TestClient", Version = "1.0.0" }
 };
-	
+
 McpServerConfig config = new()
 {
     Id = "everything",
@@ -36,7 +38,7 @@ McpServerConfig config = new()
         ["arguments"] = "-y @modelcontextprotocol/server-everything",
     }
 };
-		
+
 var client = await McpClientFactory.CreateAsync(config, options);
 
 // Print the list of tools available from the server.
@@ -55,11 +57,12 @@ var result = await client.CallToolAsync(
 Console.WriteLine(result.Content.First(c => c.Type == "text").Text);
 ```
 
-You can find samples demonstrating how to use ModelContextProtocol with an LLM SDK in the [samples](samples) directory, and also refer to the [IntegrationTests](test/ModelContextProtocol.IntegrationTests) project for more examples. Additional examples and documentation will be added as in the near future.
+You can find samples demonstrating how to use ModelContextProtocol with an LLM SDK in the [samples](samples) directory, and also refer to the [tests](tests/ModelContextProtocol.Tests) project for more examples. Additional examples and documentation will be added as in the near future.
 
 Clients can connect to any MCP server, not just ones created using this library. The protocol is designed to be server-agnostic, so you can use this library to connect to any compliant server.
 
 Tools can be exposed easily as `AIFunction` instances so that they are immediately usable with `IChatClient`s.
+
 ```csharp
 // Get available functions.
 IList<AIFunction> tools = await client.GetAIFunctionsAsync();
@@ -103,6 +106,7 @@ public static class EchoTool
 ```
 
 More control is also available, with fine-grained control over configuring the server and how it should handle client requests. For example:
+
 ```csharp
 using ModelContextProtocol.Protocol.Transport;
 using ModelContextProtocol.Protocol.Types;

README.MD

@@ -12,6 +12,8 @@
     <SymbolPackageFormat>snupkg</SymbolPackageFormat>
     <PackageOutputPath>$(RepoRoot)artifacts/</PackageOutputPath>
     <EmbedUntrackedSources>true</EmbedUntrackedSources>
+    <AssemblyOriginatorKeyFile>$(RepoRoot)\Open.snk</AssemblyOriginatorKeyFile>
+    <SignAssembly>true</SignAssembly>
   </PropertyGroup>
 
   <ItemGroup>

src/Directory.Build.props

@@ -139,6 +139,44 @@ public static Task<GetPromptResult> GetPromptAsync(this IMcpClient client, strin
             cancellationToken);
     }
 
+    /// <summary>
+    /// Retrieves a sequence of available resource templates from the server.
+    /// </summary>
+    /// <param name="client">The client.</param>
+    /// <param name="cancellationToken">A token to cancel the operation.</param>
+    /// <returns>An asynchronous sequence of resource template information.</returns>
+    public static async IAsyncEnumerable<ResourceTemplate> ListResourceTemplatesAsync(
+        this IMcpClient client, [EnumeratorCancellation] CancellationToken cancellationToken = default)
+    {
+        string? cursor = null;
+        do
+        {
+            var resources = await ListResourceTemplatesAsync(client, cursor, cancellationToken).ConfigureAwait(false);
+            foreach (var resource in resources.ResourceTemplates)
+            {
+                yield return resource;
+            }
+
+            cursor = resources.NextCursor;
+        }
+        while (cursor is not null);
+    }
+
+    /// <summary>
+    /// Retrieves a list of available resources from the server.
+    /// </summary>
+    /// <param name="client">The client.</param>
+    /// <param name="cursor">A  cursor to paginate the results.</param>
+    /// <param name="cancellationToken">A token to cancel the operation.</param>
+    public static Task<ListResourceTemplatesResult> ListResourceTemplatesAsync(this IMcpClient client, string? cursor, CancellationToken cancellationToken = default)
+    {
+        Throw.IfNull(client);
+
+        return client.SendRequestAsync<ListResourceTemplatesResult>(
+            CreateRequest("resources/templates/list", CreateCursorDictionary(cursor)),
+            cancellationToken);
+    }
+
     /// <summary>
     /// Retrieves a sequence of available resources from the server.
     /// </summary>

src/ModelContextProtocol/Client/McpClientExtensions.cs

@@ -11,6 +11,19 @@ namespace ModelContextProtocol;
 /// </summary>
 public static partial class McpServerBuilderExtensions
 {
+    /// <summary>
+    /// Sets the handler for list resource templates requests.
+    /// </summary>
+    /// <param name="builder">The builder instance.</param>
+    /// <param name="handler">The handler.</param>
+    public static IMcpServerBuilder WithListResourceTemplatesHandler(this IMcpServerBuilder builder, Func<RequestContext<ListResourceTemplatesRequestParams>, CancellationToken, Task<ListResourceTemplatesResult>> handler)
+    {
+        Throw.IfNull(builder);
+
+        builder.Services.Configure<McpServerHandlers>(s => s.ListResourceTemplatesHandler = handler);
+        return builder;
+    }
+
     /// <summary>
     /// Sets the handler for list tools requests.
     /// </summary>

src/ModelContextProtocol/Configuration/McpServerBuilderExtensions.Handler.cs

@@ -13,10 +13,6 @@
     <IsAotCompatible>true</IsAotCompatible>
   </PropertyGroup>
 
-  <ItemGroup>
-    <InternalsVisibleTo Include="ModelContextProtocol.Tests" />
-  </ItemGroup>
-
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.AI.Abstractions"/>
     <PackageReference Include="Microsoft.Extensions.AI" />

src/ModelContextProtocol/ModelContextProtocol.csproj

@@ -0,0 +1,16 @@
+using System.Text.Json.Serialization;
+
+namespace ModelContextProtocol.Protocol.Types;
+
+/// <summary>
+/// Base for objects that include optional annotations for the client. The client can use annotations to inform how objects are used or displayed.
+/// <see href="https://github.com/modelcontextprotocol/specification/blob/main/schema/2024-11-05/schema.json">See the schema for details</see>
+/// </summary>
+public abstract record Annotated
+{
+    /// <summary>
+    /// Optional annotations for the resource.
+    /// </summary>
+    [JsonPropertyName("annotations")]
+    public Annotations? Annotations { get; init; }
+}

src/ModelContextProtocol/Protocol/Types/Annotated.cs

@@ -117,6 +117,12 @@ public record ResourcesCapability
     [JsonPropertyName("listChanged")]
     public bool? ListChanged { get; init; }
 
+    /// <summary>
+    /// Gets or sets the handler for list resource templates requests.
+    /// </summary>
+    [JsonIgnore]
+    public Func<RequestContext<ListResourceTemplatesRequestParams>, CancellationToken, Task<ListResourceTemplatesResult>>? ListResourceTemplatesHandler { get; init; }
+
     /// <summary>
     /// Gets or sets the handler for list resources requests.
     /// </summary>