Refactor ClientOptionsProvider to support singleton pattern for multiple clients (#8864)

- [x] Understand the current ClientOptionsProvider implementation
- [x] Add logic to determine if singleton ClientOptions should be used
(multiple root clients + only standard parameters)
- [x] Make ClientOptionsProvider constructor internal (for testing)
- [x] Create CreateClientOptionsProvider factory method
- [x] Update ClientProvider to use the factory method
- [x] Update ScmOutputLibrary to use HashSet for ClientOptions
- [x] Add tests to verify the new behavior
- [x] Build and test the changes (899 tests passing)
- [x] Verify implementation against existing test projects
- [x] Simplify BuildName and BuildDescription by checking `this ==
_singletonInstance` instead of recalculating conditions
- [x] Remove ResetSingleton API and use reflection in tests instead
- [x] Rename clients variable to types in ScmOutputLibrary for clarity
- [x] Simplify BuildClient by using HashSet<TypeProvider> to
automatically deduplicate client options

<!-- START COPILOT CODING AGENT SUFFIX -->



<details>

<summary>Original prompt</summary>

> 
> ----
> 
> *This section details on the original issue you should resolve*
> 
> <issue_title>Refactor ClientOptionsProvider behavior</issue_title>
> <issue_description>We need to support libraries having multiple
clients and a single client options. The criteria for using this
singleton clientOptionsProvider should be if the following
> - there is more than one top level client InputClient
> - a client has no Client parameters other than ApiVersion and Endpoint
parameters.
> The name of the singleton client options should be based off of the
PrimaryNamespace. Specifically, it should use the last segment of the
namespace and be suffixed with "ClientOptions".
> If the client has parameters or there is only a single client, the
name and namespace should follow the client, i.e. FooClientOptions.
> 
> The singleton can be a private static on ClientOptionsProvider.
> In order to ensure correct usage, we should make
ClientOptionsProvider's constructor private and introduce a factory
method CreateClientOptionsProvider which will either create a new
ClientOptionsProvider instance (if there is only one client or there are
client parameters, or delegate to the static singleton). When iterating
through the client types in ScmOutputLibrary we will need to ensure that
we use a HashSet as multiple clients can use the same instance
now.</issue_description>
> 
> ## Comments on the Issue (you are @copilot in this section)
> 
> <comments>
> </comments>
> 


</details>

- Fixes #8863

<!-- START COPILOT CODING AGENT TIPS -->
---

💡 You can make Copilot smarter by setting up custom instructions,
customizing its development environment and configuring Model Context
Protocol (MCP) servers. Learn more [Copilot coding agent
tips](https://gh.io/copilot-coding-agent-tips) in the docs.

---------

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: JoshLove-msft <[email protected]>

Author: Copilot

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ClientOptionsProvider.cs

@@ -24,8 +24,10 @@ public class ClientOptionsProvider : TypeProvider
         private readonly TypeProvider? _serviceVersionEnum;
         private readonly PropertyProvider? _versionProperty;
         private FieldProvider? _latestVersionField;
+        private static ClientOptionsProvider? _singletonInstance;
 
-        public ClientOptionsProvider(InputClient inputClient, ClientProvider clientProvider)
+        // Internal constructor for testing purposes
+        internal ClientOptionsProvider(InputClient inputClient, ClientProvider clientProvider)
         {
             _inputClient = inputClient;
             _clientProvider = clientProvider;
@@ -46,6 +48,65 @@ public ClientOptionsProvider(InputClient inputClient, ClientProvider clientProvi
             }
         }
 
+        /// <summary>
+        /// Factory method to create a ClientOptionsProvider instance.
+        /// Returns a singleton instance when there are multiple root clients and the client has no custom parameters.
+        /// Otherwise, creates a new instance specific to the client.
+        /// </summary>
+        /// <param name="inputClient">The input client.</param>
+        /// <param name="clientProvider">The client provider.</param>
+        /// <returns>A ClientOptionsProvider instance.</returns>
+        public static ClientOptionsProvider CreateClientOptionsProvider(InputClient inputClient, ClientProvider clientProvider)
+        {
+            var rootClients = ScmCodeModelGenerator.Instance.InputLibrary.InputNamespace.RootClients;
+            var hasMultipleRootClients = rootClients.Count > 1;
+            var hasOnlyStandardParameters = HasOnlyStandardParameters(inputClient);
+
+            if (hasMultipleRootClients && hasOnlyStandardParameters)
+            {
+                // Use singleton instance
+                if (_singletonInstance == null)
+                {
+                    // Create singleton with namespace-based naming
+                    _singletonInstance = new ClientOptionsProvider(inputClient, clientProvider);
+                }
+                return _singletonInstance;
+            }
+
+            // Create client-specific instance
+            return new ClientOptionsProvider(inputClient, clientProvider);
+        }
+
+        /// <summary>
+        /// Determines if a client has only standard parameters (ApiVersion and Endpoint).
+        /// </summary>
+        /// <param name="inputClient">The input client to check.</param>
+        /// <returns>True if the client has only standard parameters, false otherwise.</returns>
+        private static bool HasOnlyStandardParameters(InputClient inputClient)
+        {
+            foreach (var parameter in inputClient.Parameters)
+            {
+                // Check if parameter is NOT an ApiVersion or Endpoint parameter
+                if (!parameter.IsApiVersion)
+                {
+                    if (parameter is InputEndpointParameter endpointParam)
+                    {
+                        // Endpoint parameters are standard
+                        if (!endpointParam.IsEndpoint)
+                        {
+                            return false; // Found a non-standard endpoint parameter
+                        }
+                    }
+                    else
+                    {
+                        // Found a non-ApiVersion, non-Endpoint parameter
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+
         internal PropertyProvider? VersionProperty => _versionProperty;
         private FieldProvider? LatestVersionField => _latestVersionField ??= BuildLatestVersionField();
 
@@ -63,9 +124,43 @@ public ClientOptionsProvider(InputClient inputClient, ClientProvider clientProvi
         }
 
         protected override string BuildRelativeFilePath() => Path.Combine("src", "Generated", $"{Name}.cs");
-        protected override string BuildName() => $"{_clientProvider.Name}Options";
+
+        protected override string BuildName()
+        {
+            if (this == _singletonInstance)
+            {
+                // Use namespace-based naming for singleton
+                var primaryNamespace = ScmCodeModelGenerator.Instance.InputLibrary.InputNamespace.Name;
+                var lastSegment = GetLastNamespaceSegment(primaryNamespace);
+                return $"{lastSegment}ClientOptions";
+            }
+
+            // Use client-specific naming
+            return $"{_clientProvider.Name}Options";
+        }
+
         protected override string BuildNamespace() => _clientProvider.Type.Namespace;
-        protected override FormattableString BuildDescription() => $"Client options for {_clientProvider.Type:C}.";
+
+        protected override FormattableString BuildDescription()
+        {
+            if (this == _singletonInstance)
+            {
+                return $"Client options for clients in this library.";
+            }
+
+            return $"Client options for {_clientProvider.Type:C}.";
+        }
+
+        /// <summary>
+        /// Gets the last segment of a namespace.
+        /// </summary>
+        /// <param name="namespace">The namespace string.</param>
+        /// <returns>The last segment of the namespace.</returns>
+        private static string GetLastNamespaceSegment(string @namespace)
+        {
+            var lastDotIndex = @namespace.LastIndexOf('.');
+            return lastDotIndex >= 0 ? @namespace.Substring(lastDotIndex + 1) : @namespace;
+        }
 
         protected override CSharpType BuildBaseType()
         {

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ClientProvider.cs

@@ -92,7 +92,7 @@ public ClientProvider(InputClient inputClient)
             _inputAuth = ScmCodeModelGenerator.Instance.InputLibrary.InputNamespace.Auth;
             _endpointParameter = BuildClientEndpointParameter();
             _publicCtorDescription = $"Initializes a new instance of {Name}.";
-            ClientOptions = _inputClient.Parent is null ? new ClientOptionsProvider(_inputClient, this) : null;
+            ClientOptions = _inputClient.Parent is null ? ClientOptionsProvider.CreateClientOptionsProvider(_inputClient, this) : null;
             ClientOptionsParameter = ClientOptions != null ? ScmKnownParameters.ClientOptions(ClientOptions.Type) : null;
 
             var apiKey = _inputAuth?.ApiKey;

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/ScmOutputLibrary.cs

@@ -13,40 +13,41 @@ public class ScmOutputLibrary : OutputLibrary
         private static TypeProvider[] BuildClientTypes()
         {
             var inputClients = ScmCodeModelGenerator.Instance.InputLibrary.InputNamespace.RootClients;
-            var clients = new List<TypeProvider>();
+            var types = new HashSet<TypeProvider>();
+
             foreach (var inputClient in inputClients)
             {
-                BuildClient(inputClient, clients);
+                BuildClient(inputClient, types);
             }
 
-            return [.. clients];
+            return [.. types];
         }
 
-        private static void BuildClient(InputClient inputClient, IList<TypeProvider> clients)
+        private static void BuildClient(InputClient inputClient, HashSet<TypeProvider> types)
         {
             foreach (var child in inputClient.Children)
             {
-                BuildClient(child, clients);
+                BuildClient(child, types);
             }
 
             var client = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(inputClient);
             if (client == null)
             {
                 return;
             }
-            clients.Add(client);
-            clients.Add(client.RestClient);
+            types.Add(client);
+            types.Add(client.RestClient);
             var clientOptions = client.ClientOptions;
             if (clientOptions != null)
             {
-                clients.Add(clientOptions);
+                types.Add(clientOptions);
             }
 
             foreach (var method in client.Methods)
             {
                 if (method is ScmMethodProvider scmMethod && scmMethod.CollectionDefinition != null)
                 {
-                    clients.Add(scmMethod.CollectionDefinition);
+                    types.Add(scmMethod.CollectionDefinition);
                 }
             }
         }

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/ClientOptionsProviderTests.cs

@@ -5,6 +5,7 @@
 using System.ClientModel.Primitives;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 using System.Threading.Tasks;
 using Microsoft.TypeSpec.Generator.ClientModel.Providers;
 using Microsoft.TypeSpec.Generator.Expressions;
@@ -25,6 +26,10 @@ public class ClientOptionsProviderTests
         [SetUp]
         public void SetUp()
         {
+            // Reset the singleton instance before each test using reflection
+            var singletonField = typeof(ClientOptionsProvider).GetField("_singletonInstance", BindingFlags.Static | BindingFlags.NonPublic);
+            singletonField?.SetValue(null, null);
+
             var categories = TestContext.CurrentContext.Test?.Properties["Category"];
             bool containsApiVersions = categories?.Contains(ApiVersionsCategory) ?? false;
 
@@ -335,5 +340,109 @@ await MockHelpers.LoadMockGeneratorAsync(
             Assert.IsTrue(body?.Contains("ServiceVersion.V2023_11_01 => \"2023-11-01\""));
             Assert.IsTrue(body?.Contains("ServiceVersion.V2024_01_01 => \"2024-01-01\""));
         }
+
+        [Test]
+        public void SingletonCreatedForMultipleClientsWithStandardParameters()
+        {
+            var client1 = InputFactory.Client("ClientA", clientNamespace: "TestNamespace");
+            var client2 = InputFactory.Client("ClientB", clientNamespace: "TestNamespace");
+
+            MockHelpers.LoadMockGenerator(clients: () => [client1, client2]);
+
+            var clientProvider1 = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(client1);
+            var clientProvider2 = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(client2);
+
+            Assert.IsNotNull(clientProvider1);
+            Assert.IsNotNull(clientProvider2);
+
+            var options1 = clientProvider1!.ClientOptions;
+            var options2 = clientProvider2!.ClientOptions;
+
+            Assert.IsNotNull(options1);
+            Assert.IsNotNull(options2);
+
+            // Both clients should share the same ClientOptions instance
+            Assert.AreSame(options1, options2);
+
+            // The name should be based on the InputNamespace's last segment (which is "Sample" in MockHelpers)
+            Assert.AreEqual("SampleClientOptions", options1!.Name);
+        }
+
+        [Test]
+        public void SingleClientCreatesClientSpecificOptions()
+        {
+            var client = InputFactory.Client("TestClient", clientNamespace: "TestNamespace");
+            
+            MockHelpers.LoadMockGenerator(clients: () => [client]);
+
+            var clientProvider = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(client);
+
+            Assert.IsNotNull(clientProvider);
+            
+            var options = clientProvider!.ClientOptions;
+
+            Assert.IsNotNull(options);
+            
+            // The name should be based on the client name
+            Assert.AreEqual("TestClientOptions", options!.Name);
+        }
+
+        [Test]
+        public void MultipleClientsWithCustomParametersCreateSeparateOptions()
+        {
+            var customParam = InputFactory.MethodParameter(
+                "customParam",
+                InputPrimitiveType.String,
+                isRequired: false,
+                defaultValue: InputFactory.Constant.String("default"),
+                scope: InputParameterScope.Client);
+
+            var client1 = InputFactory.Client("ClientA", clientNamespace: "TestNamespace", parameters: [customParam]);
+            var client2 = InputFactory.Client("ClientB", clientNamespace: "TestNamespace");
+
+            MockHelpers.LoadMockGenerator(clients: () => [client1, client2]);
+
+            var clientProvider1 = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(client1);
+            var clientProvider2 = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(client2);
+
+            Assert.IsNotNull(clientProvider1);
+            Assert.IsNotNull(clientProvider2);
+
+            var options1 = clientProvider1!.ClientOptions;
+            var options2 = clientProvider2!.ClientOptions;
+
+            Assert.IsNotNull(options1);
+            Assert.IsNotNull(options2);
+
+            // ClientA has custom parameters, so it should NOT share options
+            Assert.AreNotSame(options1, options2);
+
+            // ClientA should have client-specific options
+            Assert.AreEqual("ClientAOptions", options1!.Name);
+            // ClientB should have namespace-based options (since it has only standard parameters)
+            // Note: InputNamespace in MockHelpers is set to "Sample" by default
+            Assert.AreEqual("SampleClientOptions", options2!.Name);
+        }
+
+        [Test]
+        public void NamespaceLastSegmentIsUsedForSingletonName()
+        {
+            var client1 = InputFactory.Client("ClientA", clientNamespace: "Company.Service.Api");
+            var client2 = InputFactory.Client("ClientB", clientNamespace: "Company.Service.Api");
+
+            MockHelpers.LoadMockGenerator(clients: () => [client1, client2]);
+
+            var clientProvider1 = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(client1);
+
+            Assert.IsNotNull(clientProvider1);
+
+            var options = clientProvider1!.ClientOptions;
+
+            Assert.IsNotNull(options);
+
+            // The name should be based on the InputNamespace's last segment
+            // Note: InputNamespace in MockHelpers is set to "Sample" by default, not based on client namespace
+            Assert.AreEqual("SampleClientOptions", options!.Name);
+        }
     }
 }