Update for consistency

Author: localden

samples/ProtectedMCPClient/Program.cs

@@ -1,55 +1,36 @@
 using ModelContextProtocol.Authentication;
 using ModelContextProtocol.Client;
 using ModelContextProtocol.Protocol.Transport;
-using System.Diagnostics;
 
 namespace ProtectedMCPClient;
 
 class Program
 {
     static async Task Main(string[] args)
     {
-        Console.WriteLine("MCP Secure Weather Client with Authentication");
-        Console.WriteLine("==============================================");
+        Console.WriteLine("Protected MCP Weather Server");
         Console.WriteLine();
 
-        // Create a standard HttpClient with authentication configured
-        var serverUrl = "http://localhost:7071/sse"; // Default server URL
+        var serverUrl = "http://localhost:7071/sse";
 
-        // Allow the user to specify a different server URL
-        Console.WriteLine($"Server URL (press Enter for default: {serverUrl}):");
-        var userInput = Console.ReadLine();
-        if (!string.IsNullOrWhiteSpace(userInput))
-        {
-            serverUrl = userInput;
-        }
-
-        // Create a single HttpClient with authentication configured
         var tokenProvider = new SimpleAccessTokenProvider(new Uri(serverUrl));
-        var httpClient = new HttpClient().UseAuthenticationProvider(tokenProvider);
+        var httpClient = new HttpClient().UseMcpAuthorizationProvider(tokenProvider);
 
         Console.WriteLine();
         Console.WriteLine($"Connecting to weather server at {serverUrl}...");
-        Console.WriteLine("When prompted for authorization, the challenge will be verified automatically.");
-        Console.WriteLine("If required, you'll be guided through any necessary authentication steps.");
-        Console.WriteLine();
 
         try
         {
-            // Create SseClientTransportOptions with the server URL
             var transportOptions = new SseClientTransportOptions
             {
                 Endpoint = new Uri(serverUrl),
                 Name = "Secure Weather Client"
             };
 
-            // Create SseClientTransport with our authenticated HTTP client
             var transport = new SseClientTransport(transportOptions, httpClient);
 
-            // Create an MCP client using the factory method with our transport
             var client = await McpClientFactory.CreateAsync(transport);
 
-            // Get the list of available tools
             var tools = await client.ListToolsAsync();
             if (tools.Count == 0)
             {
@@ -60,7 +41,6 @@ static async Task Main(string[] args)
             Console.WriteLine($"Found {tools.Count} tools on the server.");
             Console.WriteLine();
 
-            // Call the protected-data tool which requires authentication
             if (tools.Any(t => t.Name == "protected-data"))
             {
                 Console.WriteLine("Calling protected-data tool...");

samples/ProtectedMCPClient/SimpleAccessTokenProvider.cs

@@ -15,7 +15,7 @@ namespace ProtectedMCPClient;
 /// A simple implementation of IAccessTokenProvider that uses a fixed API key.
 /// This is just for demonstration purposes.
 /// </summary>
-public partial class SimpleAccessTokenProvider : ITokenProvider
+public partial class SimpleAccessTokenProvider : IMcpAuthorizationProvider
 {
     private readonly ConcurrentDictionary<string, TokenContainer> _tokenCache = new();
     private readonly Uri _serverUrl;
@@ -32,7 +32,7 @@ public SimpleAccessTokenProvider(Uri serverUrl, string clientId = "demo-client",
     }
 
     /// <inheritdoc />
-    public async Task<string?> GetTokenAsync(Uri resourceUri, CancellationToken cancellationToken = default)
+    public async Task<string?> GetCredentialAsync(Uri resourceUri, CancellationToken cancellationToken = default)
     {
         Console.WriteLine($"Getting authentication token for {resourceUri}");
 

src/ModelContextProtocol/Authentication/AuthorizationDelegatingHandler.cs

@@ -7,15 +7,15 @@ namespace ModelContextProtocol.Authentication;
 /// </summary>
 internal class AuthorizationDelegatingHandler : DelegatingHandler
 {
-    private readonly ITokenProvider _tokenProvider;
+    private readonly IMcpAuthorizationProvider _tokenProvider;
     private readonly string _scheme;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="AuthorizationDelegatingHandler"/> class.
     /// </summary>
     /// <param name="tokenProvider">The provider that supplies authentication tokens.</param>
     /// <param name="scheme">The authentication scheme to use, e.g., "Bearer".</param>
-    public AuthorizationDelegatingHandler(ITokenProvider tokenProvider, string scheme)
+    public AuthorizationDelegatingHandler(IMcpAuthorizationProvider tokenProvider, string scheme)
     {
         _tokenProvider = tokenProvider ?? throw new ArgumentNullException(nameof(tokenProvider));
         _scheme = scheme ?? throw new ArgumentNullException(nameof(scheme));
@@ -66,7 +66,7 @@ private async Task AddAuthorizationHeaderAsync(HttpRequestMessage request, Cance
     {
         if (request.RequestUri != null)
         {
-            var token = await _tokenProvider.GetTokenAsync(request.RequestUri, cancellationToken);
+            var token = await _tokenProvider.GetCredentialAsync(request.RequestUri, cancellationToken);
             if (!string.IsNullOrEmpty(token))
             {
                 request.Headers.Authorization = new AuthenticationHeaderValue(_scheme, token);

src/ModelContextProtocol/Authentication/HttpClientExtensions.cs

@@ -20,7 +20,7 @@ public static class HttpClientExtensions
     /// <item>Retries the request with the new token if token refresh is successful</item>
     /// </list>
     /// </remarks>
-    public static HttpClient UseAuthenticationProvider(this HttpClient httpClient, ITokenProvider tokenProvider, string scheme = "Bearer")
+    public static HttpClient UseMcpAuthorizationProvider(this HttpClient httpClient, IMcpAuthorizationProvider tokenProvider, string scheme = "Bearer")
     {
         if (httpClient == null)
             throw new ArgumentNullException(nameof(httpClient));

src/ModelContextProtocol/Authentication/ITokenProvider.cs

@@ -4,15 +4,15 @@ namespace ModelContextProtocol.Authentication;
 /// Defines an interface for providing authentication for requests.
 /// This is the main extensibility point for authentication in MCP clients.
 /// </summary>
-public interface ITokenProvider
+public interface IMcpAuthorizationProvider
 {
     /// <summary>
     /// Gets an authentication token or credential for authenticating requests to a resource.
     /// </summary>
     /// <param name="resourceUri">The URI of the resource requiring authentication.</param>
     /// <param name="cancellationToken">A token to cancel the operation.</param>
     /// <returns>An authentication token string or null if no token could be obtained.</returns>
-    Task<string?> GetTokenAsync(Uri resourceUri, CancellationToken cancellationToken = default);
+    Task<string?> GetCredentialAsync(Uri resourceUri, CancellationToken cancellationToken = default);
 
     /// <summary>
     /// Handles a 401 Unauthorized response from a resource.