chore: import upstream snapshot with attribution

dotnet/tests/CopilotStudio.IntegrationTests/CopilotStudio.IntegrationTests.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <NoWarn>$(NoWarn);CS8793</NoWarn>
+    <InjectSharedIntegrationTestCode>True</InjectSharedIntegrationTestCode>
+    <InjectSharedThrow>true</InjectSharedThrow>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Microsoft.Agents.AI.CopilotStudio\Microsoft.Agents.AI.CopilotStudio.csproj" />
+    <ProjectReference Include="..\AgentConformance.IntegrationTests\AgentConformance.IntegrationTests.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Identity.Client.Extensions.Msal" />
+  </ItemGroup>
+
+</Project>

dotnet/tests/CopilotStudio.IntegrationTests/CopilotStudioFixture.cs

@@ -0,0 +1,75 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Threading.Tasks;
+using AgentConformance.IntegrationTests;
+using AgentConformance.IntegrationTests.Support;
+using CopilotStudio.IntegrationTests.Support;
+using Microsoft.Agents.AI;
+using Microsoft.Agents.AI.CopilotStudio;
+using Microsoft.Agents.CopilotStudio.Client;
+using Microsoft.Extensions.AI;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging.Abstractions;
+using Shared.IntegrationTests;
+
+namespace CopilotStudio.IntegrationTests;
+
+public class CopilotStudioFixture : IAgentFixture
+{
+    public AIAgent Agent { get; private set; } = null!;
+
+    public Task<List<ChatMessage>> GetChatHistoryAsync(AIAgent agent, AgentSession session) =>
+        throw new NotSupportedException("CopilotStudio doesn't allow retrieval of chat history.");
+
+    public Task DeleteSessionAsync(AgentSession session) =>
+        // Chat Completion does not require/support deleting threads, so this is a no-op.
+        Task.CompletedTask;
+
+    public ValueTask InitializeAsync()
+    {
+        const string CopilotStudioHttpClientName = nameof(CopilotStudioAgent);
+
+        CopilotStudioConnectionSettings? settings = null;
+        try
+        {
+            settings = new CopilotStudioConnectionSettings(
+                TestConfiguration.GetRequiredValue(TestSettings.CopilotStudioTenantId),
+                TestConfiguration.GetRequiredValue(TestSettings.CopilotStudioAgentAppId))
+            {
+                DirectConnectUrl = TestConfiguration.GetRequiredValue(TestSettings.CopilotStudioDirectConnectUrl),
+            };
+        }
+        catch (InvalidOperationException ex)
+        {
+            Assert.Skip("CopilotStudio configuration could not be loaded. Error:" + ex.Message);
+        }
+
+        ServiceCollection services = new();
+
+        services
+            .AddSingleton(settings)
+            .AddSingleton<CopilotStudioTokenHandler>()
+            .AddHttpClient(CopilotStudioHttpClientName)
+            .ConfigurePrimaryHttpMessageHandler<CopilotStudioTokenHandler>();
+
+        IHttpClientFactory httpClientFactory =
+            services
+                .BuildServiceProvider()
+                .GetRequiredService<IHttpClientFactory>();
+
+        CopilotClient client = new(settings, httpClientFactory, NullLogger.Instance, CopilotStudioHttpClientName);
+
+        this.Agent = new CopilotStudioAgent(client);
+
+        return default;
+    }
+
+    public ValueTask DisposeAsync()
+    {
+        GC.SuppressFinalize(this);
+        return default;
+    }
+}

dotnet/tests/CopilotStudio.IntegrationTests/CopilotStudioRunStreamingTests.cs

@@ -0,0 +1,42 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Threading.Tasks;
+using AgentConformance.IntegrationTests;
+
+namespace CopilotStudio.IntegrationTests;
+
+public class CopilotStudioRunStreamingTests() : RunStreamingTests<CopilotStudioFixture>(() => new())
+{
+    // Set to null to run the tests.
+    private const string ManualVerification = "For manual verification";
+
+    public override Task SessionMaintainsHistoryAsync()
+    {
+        Assert.Skip("Copilot Studio does not support session history retrieval, so this test is not applicable.");
+        return base.SessionMaintainsHistoryAsync();
+    }
+
+    public override Task RunWithChatMessageReturnsExpectedResultAsync()
+    {
+        Assert.SkipWhen(ManualVerification is not null, ManualVerification ?? string.Empty);
+        return base.RunWithChatMessageReturnsExpectedResultAsync();
+    }
+
+    public override Task RunWithChatMessagesReturnsExpectedResultAsync()
+    {
+        Assert.SkipWhen(ManualVerification is not null, ManualVerification ?? string.Empty);
+        return base.RunWithChatMessagesReturnsExpectedResultAsync();
+    }
+
+    public override Task RunWithNoMessageDoesNotFailAsync()
+    {
+        Assert.SkipWhen(ManualVerification is not null, ManualVerification ?? string.Empty);
+        return base.RunWithNoMessageDoesNotFailAsync();
+    }
+
+    public override Task RunWithStringReturnsExpectedResultAsync()
+    {
+        Assert.SkipWhen(ManualVerification is not null, ManualVerification ?? string.Empty);
+        return base.RunWithStringReturnsExpectedResultAsync();
+    }
+}

dotnet/tests/CopilotStudio.IntegrationTests/CopilotStudioRunTests.cs

@@ -0,0 +1,42 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Threading.Tasks;
+using AgentConformance.IntegrationTests;
+
+namespace CopilotStudio.IntegrationTests;
+
+public class CopilotStudioRunTests() : RunTests<CopilotStudioFixture>(() => new())
+{
+    // Set to null to run the tests.
+    private const string ManualVerification = "For manual verification";
+
+    public override Task SessionMaintainsHistoryAsync()
+    {
+        Assert.Skip("Copilot Studio does not support session history retrieval, so this test is not applicable.");
+        return base.SessionMaintainsHistoryAsync();
+    }
+
+    public override Task RunWithChatMessageReturnsExpectedResultAsync()
+    {
+        Assert.SkipWhen(ManualVerification is not null, ManualVerification ?? string.Empty);
+        return base.RunWithChatMessageReturnsExpectedResultAsync();
+    }
+
+    public override Task RunWithChatMessagesReturnsExpectedResultAsync()
+    {
+        Assert.SkipWhen(ManualVerification is not null, ManualVerification ?? string.Empty);
+        return base.RunWithChatMessagesReturnsExpectedResultAsync();
+    }
+
+    public override Task RunWithNoMessageDoesNotFailAsync()
+    {
+        Assert.SkipWhen(ManualVerification is not null, ManualVerification ?? string.Empty);
+        return base.RunWithNoMessageDoesNotFailAsync();
+    }
+
+    public override Task RunWithStringReturnsExpectedResultAsync()
+    {
+        Assert.SkipWhen(ManualVerification is not null, ManualVerification ?? string.Empty);
+        return base.RunWithStringReturnsExpectedResultAsync();
+    }
+}

dotnet/tests/CopilotStudio.IntegrationTests/Support/CopilotStudioConnectionSettings.cs

@@ -0,0 +1,61 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using Microsoft.Agents.CopilotStudio.Client;
+using Microsoft.Agents.CopilotStudio.Client.Discovery;
+using Microsoft.Extensions.Configuration;
+
+namespace CopilotStudio.IntegrationTests.Support;
+
+/// <summary>
+/// <see cref="ConnectionSettings"/> with additional properties to specify Application (Client) Id,
+/// Tenant Id, and optionally the Application Client secret.
+/// </summary>
+internal sealed class CopilotStudioConnectionSettings : ConnectionSettings
+{
+    /// <summary>
+    /// Application ID for creating the authentication for the connection
+    /// </summary>
+    public string AppClientId { get; }
+
+    /// <summary>
+    /// Application secret for creating the authentication for the connection
+    /// </summary>
+    public string? AppClientSecret { get; }
+
+    /// <summary>
+    /// Tenant ID for creating the authentication for the connection
+    /// </summary>
+    public string TenantId { get; }
+
+    /// <summary>
+    /// Use interactive or service connection for authentication.
+    /// Defaults to true, meaning interactive authentication will be used.
+    /// </summary>
+    public bool UseInteractiveAuthentication { get; set; } = true;
+
+    /// <summary>
+    /// Instantiate a new instance of the <see cref="CopilotStudioConnectionSettings"/> from provided settings.
+    /// </summary>
+    public CopilotStudioConnectionSettings(string tenantId, string appClientId, string? appClientSecret = null)
+    {
+        this.TenantId = tenantId;
+        this.AppClientId = appClientId;
+        this.AppClientSecret = appClientSecret;
+        this.Cloud = PowerPlatformCloud.Prod;
+        this.CopilotAgentType = AgentType.Published;
+    }
+
+    /// <summary>
+    /// Instantiate a new instance of the <see cref="CopilotStudioConnectionSettings"/> from a configuration section.
+    /// </summary>
+    /// <param name="config"></param>
+    /// <exception cref="ArgumentException"></exception>
+    public CopilotStudioConnectionSettings(IConfigurationSection config)
+        : base(config)
+    {
+        this.AppClientId = config[nameof(this.AppClientId)] ?? throw new ArgumentException($"{nameof(this.AppClientId)} not found in config");
+        this.TenantId = config[nameof(this.TenantId)] ?? throw new ArgumentException($"{nameof(this.TenantId)} not found in config");
+        this.AppClientSecret = config[nameof(this.AppClientSecret)];
+    }
+}

dotnet/tests/CopilotStudio.IntegrationTests/Support/CopilotStudioTokenHandler.cs

@@ -0,0 +1,140 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Agents.CopilotStudio.Client;
+using Microsoft.Identity.Client;
+using Microsoft.Identity.Client.Extensions.Msal;
+using Microsoft.Shared.Diagnostics;
+
+namespace CopilotStudio.IntegrationTests.Support;
+
+#pragma warning disable CA1812 // Internal class that is apparently never instantiated.
+
+/// <summary>
+/// A <see cref="HttpClientHandler"/> that adds an authentication token to the request headers for Copilot Studio API calls.
+/// </summary>
+/// <remarks>
+///  For more information on how to setup various authentication flows, see the Microsoft Identity documentation at https://aka.ms/msal.
+/// </remarks>
+internal sealed class CopilotStudioTokenHandler : HttpClientHandler
+{
+    private const string AuthenticationHeader = "Bearer";
+    private const string CacheFolderName = "mcs_client_console";
+    private const string KeyChainServiceName = "copilot_studio_client_app";
+    private const string KeyChainAccountName = "copilot_studio_client";
+
+    private readonly CopilotStudioConnectionSettings _settings;
+    private readonly string[] _scopes;
+
+    private IConfidentialClientApplication? _clientApplication;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CopilotStudioTokenHandler"/> class with the specified connection settings.
+    /// </summary>
+    /// <param name="settings">The connection settings for Copilot Studio.</param>
+    public CopilotStudioTokenHandler(CopilotStudioConnectionSettings settings)
+    {
+        Throw.IfNull(settings);
+
+        this._settings = settings;
+        this._scopes = [CopilotClient.ScopeFromSettings(this._settings)];
+    }
+
+    /// <inheritdoc/>
+    protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+    {
+        if (request.Headers.Authorization is null)
+        {
+            AuthenticationResult authResponse = await this.AuthenticateAsync(cancellationToken).ConfigureAwait(false);
+
+            request.Headers.Authorization = new AuthenticationHeaderValue(AuthenticationHeader, authResponse.AccessToken);
+        }
+
+        return await base.SendAsync(request, cancellationToken).ConfigureAwait(false);
+    }
+
+    private Task<AuthenticationResult> AuthenticateAsync(CancellationToken cancellationToken) =>
+        this._settings.UseInteractiveAuthentication ?
+                this.AuthenticateInteractiveAsync(cancellationToken) :
+                this.AuthenticateServiceAsync(cancellationToken);
+
+    private async Task<AuthenticationResult> AuthenticateServiceAsync(CancellationToken cancellationToken)
+    {
+        if (this._clientApplication is null)
+        {
+            this._clientApplication = ConfidentialClientApplicationBuilder.Create(this._settings.AppClientId)
+                .WithAuthority(AzureCloudInstance.AzurePublic, this._settings.TenantId)
+                .WithClientSecret(this._settings.AppClientSecret)
+                .Build();
+
+            MsalCacheHelper tokenCacheHelper = await CreateCacheHelperAsync("AppTokenCache").ConfigureAwait(false);
+            tokenCacheHelper.RegisterCache(this._clientApplication.AppTokenCache);
+        }
+
+        AuthenticationResult authResponse;
+
+        authResponse = await this._clientApplication.AcquireTokenForClient(this._scopes).ExecuteAsync(cancellationToken).ConfigureAwait(false);
+
+        return authResponse;
+    }
+
+    private async Task<AuthenticationResult> AuthenticateInteractiveAsync(CancellationToken cancellationToken = default!)
+    {
+        IPublicClientApplication app =
+            PublicClientApplicationBuilder.Create(this._settings.AppClientId)
+             .WithAuthority(AadAuthorityAudience.AzureAdMyOrg)
+             .WithTenantId(this._settings.TenantId)
+             .WithRedirectUri("http://localhost")
+             .Build();
+
+        MsalCacheHelper tokenCacheHelper = await CreateCacheHelperAsync("TokenCache").ConfigureAwait(false);
+        tokenCacheHelper.RegisterCache(app.UserTokenCache);
+
+        IEnumerable<IAccount> accounts = await app.GetAccountsAsync().ConfigureAwait(false);
+        IAccount? account = accounts.FirstOrDefault();
+
+        AuthenticationResult authResponse;
+
+        try
+        {
+            authResponse = await app.AcquireTokenSilent(this._scopes, account).ExecuteAsync(cancellationToken).ConfigureAwait(false);
+        }
+        catch (MsalUiRequiredException)
+        {
+            authResponse = await app.AcquireTokenInteractive(this._scopes).ExecuteAsync(cancellationToken).ConfigureAwait(false);
+        }
+
+        return authResponse;
+    }
+
+    private static async Task<MsalCacheHelper> CreateCacheHelperAsync(string cacheFileName)
+    {
+        string currentDir = Path.Combine(AppContext.BaseDirectory, CacheFolderName);
+
+        if (!Directory.Exists(currentDir))
+        {
+            Directory.CreateDirectory(currentDir);
+        }
+
+        StorageCreationPropertiesBuilder storageProperties = new(cacheFileName, currentDir);
+
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+        {
+            storageProperties.WithLinuxUnprotectedFile();
+        }
+        else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+        {
+            storageProperties.WithMacKeyChain(KeyChainServiceName, KeyChainAccountName);
+        }
+
+        return await MsalCacheHelper.CreateAsync(storageProperties.Build()).ConfigureAwait(false);
+    }
+}