Fix thread-safety race in CustomChainedCredential credential initialization

The ??= compound assignment is not atomic in C#. Under concurrent
GetToken / GetTokenAsync calls before the credential chain was
initialized (e.g. parallel tool calls on server startup in HTTP mode),
two threads could both observe _credential == null, construct separate
ChainedTokenCredential instances, and have one silently discarded. The
two chains may hold diverged MSAL token cache handles, causing
intermittent authentication failures.

Fix: replace the nullable field + ??= pattern with Lazy<TokenCredential>
using LazyThreadSafetyMode.ExecutionAndPublication, which provides
guaranteed single initialization under concurrent access with no
manual locking required.

Also adds GetToken_ConcurrentCalls_InitializesCredentialExactlyOnce
test to verify the Lazy<T>.IsValueCreated post-concurrent access.

Closes #398

Author: g2vinay

core/Azure.Mcp.Core/tests/Azure.Mcp.Core.Tests/Services/Azure/Authentication/CustomChainedCredentialTests.cs

@@ -469,6 +469,38 @@ public void UnknownCredentialValue_LogsWarning_AndFallsBackToDefaultChain()
         Assert.Contains("AZURE_TOKEN_CREDENTIALS", warning);
     }
 
+    /// <summary>
+    /// Tests that concurrent calls to GetToken initialize the credential chain exactly once.
+    /// Validates that the Lazy&lt;T&gt; (ExecutionAndPublication) fix for the ??= race condition
+    /// ensures a single shared credential instance under concurrent access.
+    /// </summary>
+    [Fact]
+    public async Task GetToken_ConcurrentCalls_InitializesCredentialExactlyOnce()
+    {
+        // Arrange
+        var credential = CreateCustomChainedCredential();
+        var credentialType = GetCustomChainedCredentialType();
+        var lazyField = credentialType.GetField("_credential",
+            BindingFlags.Instance | BindingFlags.NonPublic);
+        Assert.NotNull(lazyField);
+
+        // Act — fire 20 concurrent GetToken calls before the chain is initialized
+        var tasks = Enumerable.Range(0, 20).Select(_ => Task.Run(() =>
+        {
+            try { credential.GetToken(new TokenRequestContext(["https://management.azure.com/.default"]), CancellationToken.None); }
+            catch { /* auth failure expected in test environment */ }
+        })).ToArray();
+
+        await Task.WhenAll(tasks);
+
+        // Assert — the Lazy<T> value was created and is a single shared instance
+        var lazyValue = lazyField.GetValue(credential);
+        Assert.NotNull(lazyValue);
+        var isValueCreated = (bool)lazyValue.GetType()
+            .GetProperty("IsValueCreated")!.GetValue(lazyValue)!;
+        Assert.True(isValueCreated);
+    }
+
     /// <summary>
     /// Helper method to create CustomChainedCredential using reflection since it's an internal class.
     /// </summary>

core/Microsoft.Mcp.Core/src/Services/Azure/Authentication/CustomChainedCredential.cs

@@ -84,10 +84,18 @@ namespace Microsoft.Mcp.Core.Services.Azure.Authentication;
 /// If not set, System-Assigned Managed Identity will be used.
 /// </para>
 /// </remarks>
-internal class CustomChainedCredential(string? tenantId = null, ILogger<CustomChainedCredential>? logger = null, bool forceBrowserFallback = false) : TokenCredential
+internal class CustomChainedCredential : TokenCredential
 {
-    private TokenCredential? _credential;
-    private readonly ILogger<CustomChainedCredential>? _logger = logger;
+    private readonly Lazy<TokenCredential> _credential;
+    private readonly ILogger<CustomChainedCredential>? _logger;
+
+    internal CustomChainedCredential(string? tenantId = null, ILogger<CustomChainedCredential>? logger = null, bool forceBrowserFallback = false)
+    {
+        _logger = logger;
+        _credential = new Lazy<TokenCredential>(
+            () => CreateCredential(tenantId, logger, forceBrowserFallback),
+            LazyThreadSafetyMode.ExecutionAndPublication);
+    }
 
     /// <summary>
     /// Cloud configuration for authority host. Set by DI container during service registration.
@@ -102,14 +110,12 @@ internal class CustomChainedCredential(string? tenantId = null, ILogger<CustomCh
 
     public override AccessToken GetToken(TokenRequestContext requestContext, CancellationToken cancellationToken)
     {
-        _credential ??= CreateCredential(tenantId, _logger, forceBrowserFallback);
-        return _credential.GetToken(requestContext, cancellationToken);
+        return _credential.Value.GetToken(requestContext, cancellationToken);
     }
 
     public override ValueTask<AccessToken> GetTokenAsync(TokenRequestContext requestContext, CancellationToken cancellationToken)
     {
-        _credential ??= CreateCredential(tenantId, _logger, forceBrowserFallback);
-        return _credential.GetTokenAsync(requestContext, cancellationToken);
+        return _credential.Value.GetTokenAsync(requestContext, cancellationToken);
     }
 
     private const string AuthenticationRecordEnvVarName = "AZURE_MCP_AUTHENTICATION_RECORD";

servers/Azure.Mcp.Server/changelog-entries/1783400773627.yaml

@@ -0,0 +1,3 @@
+changes:
+  - section: "Bugs Fixed"
+    description: "Fixed a thread-safety issue in CustomChainedCredential where concurrent calls to GetToken/GetTokenAsync before initialization could construct duplicate credential chains. The credential is now initialized via Lazy<T> (ExecutionAndPublication) to guarantee single initialization under concurrent access."