Update for consistency

Author: localden

…lient/BasicOAuthAuthorizationProvider.cs …ProtectedMCPClient/BasicOAuthProvider.cssamples/ProtectedMCPClient/BasicOAuthAuthorizationProvider.cs renamed to samples/ProtectedMCPClient/BasicOAuthProvider.cs samples/ProtectedMCPClient/BasicOAuthAuthorizationProvider.cs renamed to samples/ProtectedMCPClient/BasicOAuthProvider.cs

@@ -14,7 +14,7 @@ namespace ProtectedMCPClient;
 /// caching or any advanced token protection - it acquires a token and server metadata and holds it
 /// in memory as-is. This is NOT PRODUCTION READY and MUST NOT BE USED IN PRODUCTION.
 /// </summary>
-public class BasicOAuthAuthorizationProvider : ITokenProvider
+public class BasicOAuthProvider : IMcpCredentialProvider
 {
     /// <summary>
     /// The Bearer authentication scheme.
@@ -38,7 +38,7 @@ public class BasicOAuthAuthorizationProvider : ITokenProvider
     private AuthorizationServerMetadata? _authServerMetadata;
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="BasicOAuthAuthorizationProvider"/> class.
+    /// Initializes a new instance of the <see cref="BasicOAuthProvider"/> class.
     /// </summary>
     /// <param name="serverUrl">The MCP server URL.</param>
     /// <param name="httpClient">The HTTP client to use for OAuth requests. If null, a default HttpClient will be used.</param>
@@ -47,7 +47,7 @@ public class BasicOAuthAuthorizationProvider : ITokenProvider
     /// <param name="clientSecret">OAuth client secret.</param>
     /// <param name="redirectUri">OAuth redirect URI.</param>
     /// <param name="scopes">OAuth scopes.</param>
-    public BasicOAuthAuthorizationProvider(
+    public BasicOAuthProvider(
         Uri serverUrl,
         HttpClient? httpClient,
         AuthorizationHelpers? authorizationHelpers,

samples/ProtectedMCPClient/Program.cs

@@ -25,7 +25,7 @@ static async Task Main(string[] args)
 
         // Create the token provider with our custom HttpClient, 
         // letting the AuthorizationHelpers be created automatically
-        var tokenProvider = new BasicOAuthAuthorizationProvider(
+        var tokenProvider = new BasicOAuthProvider(
             new Uri(serverUrl),
             httpClient,
             null, // AuthorizationHelpers will be created automatically

src/ModelContextProtocol/Authentication/AuthorizationDelegatingHandler.cs

@@ -8,23 +8,23 @@ namespace ModelContextProtocol.Authentication;
 /// </summary>
 public class AuthorizationDelegatingHandler : DelegatingHandler
 {
-    private readonly ITokenProvider _authorizationProvider;
+    private readonly IMcpCredentialProvider _credentialProvider;
     private string _currentScheme;
     private static readonly char[] SchemeSplitDelimiters = { ' ', ',' };
 
     /// <summary>
     /// Initializes a new instance of the <see cref="AuthorizationDelegatingHandler"/> class.
     /// </summary>
-    /// <param name="authorizationProvider">The provider that supplies authentication tokens.</param>
-    public AuthorizationDelegatingHandler(ITokenProvider authorizationProvider)
+    /// <param name="credentialProvider">The provider that supplies authentication tokens.</param>
+    public AuthorizationDelegatingHandler(IMcpCredentialProvider credentialProvider)
     {
-        Throw.IfNull(authorizationProvider);
+        Throw.IfNull(credentialProvider);
 
-        _authorizationProvider = authorizationProvider;
+        _credentialProvider = credentialProvider;
 
         // Select first supported scheme as the default
-        _currentScheme = _authorizationProvider.SupportedSchemes.FirstOrDefault() ??
-            throw new ArgumentException("Authorization provider must support at least one authentication scheme.", nameof(authorizationProvider));
+        _currentScheme = _credentialProvider.SupportedSchemes.FirstOrDefault() ??
+            throw new ArgumentException("Authorization provider must support at least one authentication scheme.", nameof(credentialProvider));
     }
 
     /// <summary>
@@ -65,14 +65,14 @@ private async Task<HttpResponseMessage> HandleUnauthorizedResponseAsync(
         string schemeUsed = originalRequest.Headers.Authorization?.Scheme ?? _currentScheme ?? string.Empty;
         if (!string.IsNullOrEmpty(schemeUsed) && 
             serverSchemes.Contains(schemeUsed) && 
-            _authorizationProvider.SupportedSchemes.Contains(schemeUsed))
+            _credentialProvider.SupportedSchemes.Contains(schemeUsed))
         {
             bestSchemeMatch = schemeUsed;
         }
         else
         {
             // Find the first server scheme that's in our supported set
-            bestSchemeMatch = serverSchemes.Intersect(_authorizationProvider.SupportedSchemes, StringComparer.OrdinalIgnoreCase).FirstOrDefault();
+            bestSchemeMatch = serverSchemes.Intersect(_credentialProvider.SupportedSchemes, StringComparer.OrdinalIgnoreCase).FirstOrDefault();
 
             // If no match was found, either throw an exception or use default
             if (bestSchemeMatch is null)
@@ -81,19 +81,19 @@ private async Task<HttpResponseMessage> HandleUnauthorizedResponseAsync(
                 {
                     throw new InvalidOperationException(
                         $"No matching authentication scheme found. Server supports: [{string.Join(", ", serverSchemes)}], " +
-                        $"Provider supports: [{string.Join(", ", _authorizationProvider.SupportedSchemes)}].");
+                        $"Provider supports: [{string.Join(", ", _credentialProvider.SupportedSchemes)}].");
                 }
 
                 // If the server didn't specify any schemes, use the provider's default
-                bestSchemeMatch = _authorizationProvider.SupportedSchemes.FirstOrDefault();
+                bestSchemeMatch = _credentialProvider.SupportedSchemes.FirstOrDefault();
             }
         }
 
         // If we have a scheme to try, use it
         if (bestSchemeMatch != null)
         {
             // Try to handle the 401 response with the selected scheme
-            var (handled, recommendedScheme) = await _authorizationProvider.HandleUnauthorizedResponseAsync(
+            var (handled, recommendedScheme) = await _credentialProvider.HandleUnauthorizedResponseAsync(
                 response,
                 bestSchemeMatch,
                 cancellationToken).ConfigureAwait(false);
@@ -174,7 +174,7 @@ private async Task AddAuthorizationHeaderAsync(HttpRequestMessage request, strin
     {
         if (request.RequestUri != null)
         {
-            var token = await _authorizationProvider.GetCredentialAsync(scheme, request.RequestUri, cancellationToken).ConfigureAwait(false);
+            var token = await _credentialProvider.GetCredentialAsync(scheme, request.RequestUri, cancellationToken).ConfigureAwait(false);
             if (!string.IsNullOrEmpty(token))
             {
                 request.Headers.Authorization = new AuthenticationHeaderValue(scheme, token);

…rotocol/Authentication/ITokenProvider.cs …Authentication/IMcpCredentialProvider.cssrc/ModelContextProtocol/Authentication/ITokenProvider.cs renamed to src/ModelContextProtocol/Authentication/IMcpCredentialProvider.cs src/ModelContextProtocol/Authentication/ITokenProvider.cs renamed to src/ModelContextProtocol/Authentication/IMcpCredentialProvider.cs

@@ -4,7 +4,7 @@ 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 IMcpCredentialProvider
 {
     /// <summary>
     /// Gets the collection of authentication schemes supported by this provider.

src/ModelContextProtocol/Protocol/Transport/SseClientTransport.cs

@@ -56,21 +56,21 @@ public SseClientTransport(SseClientTransportOptions transportOptions, HttpClient
     /// Initializes a new instance of the <see cref="SseClientTransport"/> class with authentication support.
     /// </summary>
     /// <param name="transportOptions">Configuration options for the transport.</param>
-    /// <param name="authorizationProvider">The authorization provider to use for authentication.</param>
+    /// <param name="credentialProvider">The authorization provider to use for authentication.</param>
     /// <param name="loggerFactory">Logger factory for creating loggers used for diagnostic output during transport operations.</param>
     /// <param name="baseMessageHandler">Optional. The base message handler to use under the authorization handler. 
     /// If null, a new <see cref="HttpClientHandler"/> will be used. This allows for custom HTTP client pipelines (e.g., from HttpClientFactory) 
-    /// to be used in conjunction with the token-based authentication provided by <paramref name="authorizationProvider"/>.</param>
-    public SseClientTransport(SseClientTransportOptions transportOptions, ITokenProvider authorizationProvider, ILoggerFactory? loggerFactory = null, HttpMessageHandler? baseMessageHandler = null)
+    /// to be used in conjunction with the token-based authentication provided by <paramref name="credentialProvider"/>.</param>
+    public SseClientTransport(SseClientTransportOptions transportOptions, IMcpCredentialProvider credentialProvider, ILoggerFactory? loggerFactory = null, HttpMessageHandler? baseMessageHandler = null)
     {
         Throw.IfNull(transportOptions);
-        Throw.IfNull(authorizationProvider);
+        Throw.IfNull(credentialProvider);
 
         _options = transportOptions;
         _loggerFactory = loggerFactory;
         Name = transportOptions.Name ?? transportOptions.Endpoint.ToString();
 
-        var authHandler = new AuthorizationDelegatingHandler(authorizationProvider)
+        var authHandler = new AuthorizationDelegatingHandler(credentialProvider)
         {
             InnerHandler = baseMessageHandler ?? new HttpClientHandler()
         };