test

dotnet/tests/AnthropicChatCompletion.IntegrationTests/AnthropicChatCompletion.IntegrationTests.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <InjectSharedIntegrationTestCode>True</InjectSharedIntegrationTestCode>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Configuration" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Binder" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.UserSecrets" />
+  </ItemGroup>
+  
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Microsoft.Agents.AI.Anthropic\Microsoft.Agents.AI.Anthropic.csproj" />
+    <ProjectReference Include="..\AgentConformance.IntegrationTests\AgentConformance.IntegrationTests.csproj" />
+  </ItemGroup>
+
+</Project>

dotnet/tests/AnthropicChatCompletion.IntegrationTests/AnthropicChatCompletionChatClientAgentRunStreamingTests.cs

@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Threading.Tasks;
+using AgentConformance.IntegrationTests;
+
+namespace AnthropicChatCompletion.IntegrationTests;
+
+public abstract class SkipAllChatClientRunStreaming(Func<AnthropicChatCompletionFixture> func) : ChatClientAgentRunStreamingTests<AnthropicChatCompletionFixture>(func)
+{
+    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
+    public override Task RunWithFunctionsInvokesFunctionsAndReturnsExpectedResultsAsync()
+        => base.RunWithFunctionsInvokesFunctionsAndReturnsExpectedResultsAsync();
+
+    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
+    public override Task RunWithInstructionsAndNoMessageReturnsExpectedResultAsync()
+        => base.RunWithInstructionsAndNoMessageReturnsExpectedResultAsync();
+}
+
+public class AnthropicBetaChatCompletionChatClientAgentReasoningRunStreamingTests() : SkipAllChatClientRunStreaming(() => new(useReasoningChatModel: true, useBeta: true));
+
+public class AnthropicBetaChatCompletionChatClientAgentRunStreamingTests() : SkipAllChatClientRunStreaming(() => new(useReasoningChatModel: false, useBeta: true));
+
+public class AnthropicChatCompletionChatClientAgentRunStreamingTests() : SkipAllChatClientRunStreaming(() => new(useReasoningChatModel: false, useBeta: false));
+
+public class AnthropicChatCompletionChatClientAgentReasoningRunStreamingTests() : SkipAllChatClientRunStreaming(() => new(useReasoningChatModel: true, useBeta: false));

dotnet/tests/AnthropicChatCompletion.IntegrationTests/AnthropicChatCompletionChatClientAgentRunTests.cs

@@ -0,0 +1,30 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Threading.Tasks;
+using AgentConformance.IntegrationTests;
+
+namespace AnthropicChatCompletion.IntegrationTests;
+
+public abstract class SkipAllChatClientAgentRun(Func<AnthropicChatCompletionFixture> func) : ChatClientAgentRunTests<AnthropicChatCompletionFixture>(func)
+{
+    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
+    public override Task RunWithFunctionsInvokesFunctionsAndReturnsExpectedResultsAsync()
+        => base.RunWithFunctionsInvokesFunctionsAndReturnsExpectedResultsAsync();
+
+    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
+    public override Task RunWithInstructionsAndNoMessageReturnsExpectedResultAsync()
+        => base.RunWithInstructionsAndNoMessageReturnsExpectedResultAsync();
+}
+
+public class AnthropicBetaChatCompletionChatClientAgentRunTests()
+    : SkipAllChatClientAgentRun(() => new(useReasoningChatModel: false, useBeta: true));
+
+public class AnthropicBetaChatCompletionChatClientAgentReasoningRunTests()
+    : SkipAllChatClientAgentRun(() => new(useReasoningChatModel: true, useBeta: true));
+
+public class AnthropicChatCompletionChatClientAgentRunTests()
+    : SkipAllChatClientAgentRun(() => new(useReasoningChatModel: false, useBeta: false));
+
+public class AnthropicChatCompletionChatClientAgentReasoningRunTests()
+    : SkipAllChatClientAgentRun(() => new(useReasoningChatModel: true, useBeta: false));

dotnet/tests/AnthropicChatCompletion.IntegrationTests/AnthropicChatCompletionFixture.cs

@@ -0,0 +1,109 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using AgentConformance.IntegrationTests;
+using AgentConformance.IntegrationTests.Support;
+using Anthropic;
+using Anthropic.Models.Beta.Messages;
+using Anthropic.Models.Messages;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+using Shared.IntegrationTests;
+
+namespace AnthropicChatCompletion.IntegrationTests;
+
+public class AnthropicChatCompletionFixture : IChatClientAgentFixture
+{
+    // All tests for Anthropic are intended to be ran locally as the CI pipeline for Anthropic is not setup.
+    internal const string SkipReason = "Integrations tests for local execution only";
+
+    private static readonly AnthropicConfiguration s_config = TestConfiguration.LoadSection<AnthropicConfiguration>();
+    private readonly bool _useReasoningModel;
+    private readonly bool _useBeta;
+
+    private ChatClientAgent _agent = null!;
+
+    public AnthropicChatCompletionFixture(bool useReasoningChatModel, bool useBeta)
+    {
+        this._useReasoningModel = useReasoningChatModel;
+        this._useBeta = useBeta;
+    }
+
+    public AIAgent Agent => this._agent;
+
+    public IChatClient ChatClient => this._agent.ChatClient;
+
+    public async Task<List<ChatMessage>> GetChatHistoryAsync(AgentThread thread)
+    {
+        var typedThread = (ChatClientAgentThread)thread;
+
+        if (typedThread.MessageStore is null)
+        {
+            return [];
+        }
+
+        return (await typedThread.MessageStore.InvokingAsync(new([]))).ToList();
+    }
+
+    public Task<ChatClientAgent> CreateChatClientAgentAsync(
+        string name = "HelpfulAssistant",
+        string instructions = "You are a helpful assistant.",
+        IList<AITool>? aiTools = null)
+    {
+        var anthropicClient = new AnthropicClient() { APIKey = s_config.ApiKey };
+
+        IChatClient? chatClient = this._useBeta
+            ? anthropicClient
+                .Beta
+                .AsIChatClient()
+                .AsBuilder()
+                .ConfigureOptions(options
+                     => options.RawRepresentationFactory = _
+                     => new Anthropic.Models.Beta.Messages.MessageCreateParams()
+                     {
+                         Model = options.ModelId ?? (this._useReasoningModel ? s_config.ChatReasoningModelId : s_config.ChatModelId),
+                         MaxTokens = options.MaxOutputTokens ?? 4096,
+                         Messages = [],
+                         Thinking = this._useReasoningModel
+                            ? new BetaThinkingConfigParam(new BetaThinkingConfigEnabled(2048))
+                            : new BetaThinkingConfigParam(new BetaThinkingConfigDisabled())
+                     }).Build()
+
+            : anthropicClient
+                .AsIChatClient()
+                .AsBuilder()
+                .ConfigureOptions(options
+                     => options.RawRepresentationFactory = _
+                     => new Anthropic.Models.Messages.MessageCreateParams()
+                     {
+                         Model = options.ModelId ?? (this._useReasoningModel ? s_config.ChatReasoningModelId : s_config.ChatModelId),
+                         MaxTokens = options.MaxOutputTokens ?? 4096,
+                         Messages = [],
+                         Thinking = this._useReasoningModel
+                            ? new ThinkingConfigParam(new ThinkingConfigEnabled(2048))
+                            : new ThinkingConfigParam(new ThinkingConfigDisabled())
+                     }).Build();
+
+        return Task.FromResult(new ChatClientAgent(chatClient, options: new()
+        {
+            Name = name,
+            ChatOptions = new() { Instructions = instructions, Tools = aiTools }
+        }));
+    }
+
+    public Task DeleteAgentAsync(ChatClientAgent agent) =>
+        // Chat Completion does not require/support deleting agents, so this is a no-op.
+        Task.CompletedTask;
+
+    public Task DeleteThreadAsync(AgentThread thread) =>
+        // Chat Completion does not require/support deleting threads, so this is a no-op.
+        Task.CompletedTask;
+
+    public async Task InitializeAsync() =>
+        this._agent = await this.CreateChatClientAgentAsync();
+
+    public Task DisposeAsync() =>
+        Task.CompletedTask;
+}

dotnet/tests/AnthropicChatCompletion.IntegrationTests/AnthropicChatCompletionRunStreamingTests.cs

@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Threading.Tasks;
+using AgentConformance.IntegrationTests;
+
+namespace AnthropicChatCompletion.IntegrationTests;
+
+public abstract class SkipAllRunStreaming(Func<AnthropicChatCompletionFixture> func) : RunStreamingTests<AnthropicChatCompletionFixture>(func)
+{
+    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
+    public override Task RunWithChatMessageReturnsExpectedResultAsync() => base.RunWithChatMessageReturnsExpectedResultAsync();
+
+    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
+    public override Task RunWithNoMessageDoesNotFailAsync() => base.RunWithNoMessageDoesNotFailAsync();
+
+    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
+    public override Task RunWithChatMessagesReturnsExpectedResultAsync() => base.RunWithChatMessagesReturnsExpectedResultAsync();
+
+    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
+    public override Task RunWithStringReturnsExpectedResultAsync() => base.RunWithStringReturnsExpectedResultAsync();
+
+    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
+    public override Task ThreadMaintainsHistoryAsync() => base.ThreadMaintainsHistoryAsync();
+}
+
+public class AnthropicBetaChatCompletionRunStreamingTests()
+    : SkipAllRunStreaming(() => new(useReasoningChatModel: false, useBeta: true));
+
+public class AnthropicBetaChatCompletionReasoningRunStreamingTests()
+    : SkipAllRunStreaming(() => new(useReasoningChatModel: true, useBeta: true));
+
+public class AnthropicChatCompletionRunStreamingTests()
+    : SkipAllRunStreaming(() => new(useReasoningChatModel: false, useBeta: false));
+
+public class AnthropicChatCompletionReasoningRunStreamingTests()
+    : SkipAllRunStreaming(() => new(useReasoningChatModel: true, useBeta: false));

dotnet/tests/AnthropicChatCompletion.IntegrationTests/AnthropicChatCompletionRunTests.cs

@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Threading.Tasks;
+using AgentConformance.IntegrationTests;
+
+namespace AnthropicChatCompletion.IntegrationTests;
+
+public abstract class SkipAllRun(Func<AnthropicChatCompletionFixture> func) : RunTests<AnthropicChatCompletionFixture>(func)
+{
+    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
+    public override Task RunWithChatMessageReturnsExpectedResultAsync() => base.RunWithChatMessageReturnsExpectedResultAsync();
+
+    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
+    public override Task RunWithNoMessageDoesNotFailAsync() => base.RunWithNoMessageDoesNotFailAsync();
+
+    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
+    public override Task RunWithChatMessagesReturnsExpectedResultAsync() => base.RunWithChatMessagesReturnsExpectedResultAsync();
+
+    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
+    public override Task RunWithStringReturnsExpectedResultAsync() => base.RunWithStringReturnsExpectedResultAsync();
+
+    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
+    public override Task ThreadMaintainsHistoryAsync() => base.ThreadMaintainsHistoryAsync();
+}
+
+public class AnthropicBetaChatCompletionRunTests()
+    : SkipAllRun(() => new(useReasoningChatModel: false, useBeta: true));
+
+public class AnthropicBetaChatCompletionReasoningRunTests()
+    : SkipAllRun(() => new(useReasoningChatModel: true, useBeta: true));
+
+public class AnthropicChatCompletionRunTests()
+    : SkipAllRun(() => new(useReasoningChatModel: false, useBeta: false));
+
+public class AnthropicChatCompletionReasoningRunTests()
+    : SkipAllRun(() => new(useReasoningChatModel: true, useBeta: false));