chore: import upstream snapshot with attribution

dotnet/tests/OpenAIAssistant.IntegrationTests/OpenAIAssistant.IntegrationTests.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <InjectSharedIntegrationTestCode>True</InjectSharedIntegrationTestCode>
+    <NoWarn>$(NoWarn);OPENAI001;</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.AI.OpenAI" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\AgentConformance.IntegrationTests\AgentConformance.IntegrationTests.csproj" />
+    <ProjectReference Include="..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+
+</Project>

dotnet/tests/OpenAIAssistant.IntegrationTests/OpenAIAssistantChatClientAgentRunStreamingTests.cs

@@ -0,0 +1,9 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using AgentConformance.IntegrationTests;
+
+namespace OpenAIAssistant.IntegrationTests;
+
+public class OpenAIAssistantChatClientAgentRunStreamingTests() : ChatClientAgentRunStreamingTests<OpenAIAssistantFixture>(() => new())
+{
+}

dotnet/tests/OpenAIAssistant.IntegrationTests/OpenAIAssistantChatClientAgentRunTests.cs

@@ -0,0 +1,9 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using AgentConformance.IntegrationTests;
+
+namespace OpenAIAssistant.IntegrationTests;
+
+public class OpenAIAssistantChatClientAgentRunTests() : ChatClientAgentRunTests<OpenAIAssistantFixture>(() => new())
+{
+}

dotnet/tests/OpenAIAssistant.IntegrationTests/OpenAIAssistantFixture.cs

@@ -0,0 +1,100 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using AgentConformance.IntegrationTests;
+using AgentConformance.IntegrationTests.Support;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+using OpenAI;
+using OpenAI.Assistants;
+using Shared.IntegrationTests;
+
+namespace OpenAIAssistant.IntegrationTests;
+
+public class OpenAIAssistantFixture : IChatClientAgentFixture
+{
+    private AssistantClient? _assistantClient;
+    private ChatClientAgent _agent = null!;
+
+    public AIAgent Agent => this._agent;
+
+    public IChatClient ChatClient => this._agent.ChatClient;
+
+    public async Task<List<ChatMessage>> GetChatHistoryAsync(AIAgent agent, AgentSession session)
+    {
+        var typedSession = (ChatClientAgentSession)session;
+        List<ChatMessage> messages = [];
+        await foreach (var agentMessage in this._assistantClient!.GetMessagesAsync(typedSession.ConversationId, new() { Order = MessageCollectionOrder.Ascending }))
+        {
+            messages.Add(new()
+            {
+                Role = agentMessage.Role == MessageRole.User ? ChatRole.User : ChatRole.Assistant,
+                Contents =
+                [
+                    new TextContent(agentMessage.Content[0].Text ?? string.Empty)
+                ],
+            });
+        }
+
+        return messages;
+    }
+
+    public async Task<ChatClientAgent> CreateChatClientAgentAsync(
+        string name = "HelpfulAssistant",
+        string instructions = "You are a helpful assistant.",
+        IList<AITool>? aiTools = null)
+    {
+        var assistant =
+            await this._assistantClient!.CreateAssistantAsync(
+                TestConfiguration.GetRequiredValue(TestSettings.OpenAIChatModelName),
+                new AssistantCreationOptions()
+                {
+                    Name = name,
+                    Instructions = instructions
+                });
+
+        return new ChatClientAgent(
+            this._assistantClient.AsIChatClient(assistant.Value.Id),
+            options: new()
+            {
+                Id = assistant.Value.Id,
+                ChatOptions = new() { Tools = aiTools }
+            });
+    }
+
+    public Task DeleteAgentAsync(ChatClientAgent agent) =>
+        this._assistantClient!.DeleteAssistantAsync(agent.Id);
+
+    public Task DeleteSessionAsync(AgentSession session)
+    {
+        var typedSession = (ChatClientAgentSession)session;
+        if (typedSession?.ConversationId is not null)
+        {
+            return this._assistantClient!.DeleteThreadAsync(typedSession.ConversationId);
+        }
+
+        return Task.CompletedTask;
+    }
+
+    public async ValueTask InitializeAsync()
+    {
+        var client = new OpenAIClient(TestConfiguration.GetRequiredValue(TestSettings.OpenAIApiKey));
+        this._assistantClient = client.GetAssistantClient();
+
+        this._agent = await this.CreateChatClientAgentAsync();
+    }
+
+    public ValueTask DisposeAsync()
+    {
+        GC.SuppressFinalize(this);
+
+        if (this._assistantClient is not null && this._agent is not null)
+        {
+            return new ValueTask(this._assistantClient.DeleteAssistantAsync(this._agent.Id));
+        }
+
+        return default;
+    }
+}

dotnet/tests/OpenAIAssistant.IntegrationTests/OpenAIAssistantIRunTests.cs

@@ -0,0 +1,9 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using AgentConformance.IntegrationTests;
+
+namespace OpenAIAssistant.IntegrationTests;
+
+public class OpenAIAssistantIRunTests() : RunTests<OpenAIAssistantFixture>(() => new())
+{
+}

dotnet/tests/OpenAIAssistant.IntegrationTests/OpenAIAssistantRunStreamingTests.cs

@@ -0,0 +1,9 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using AgentConformance.IntegrationTests;
+
+namespace OpenAIAssistant.IntegrationTests;
+
+public class OpenAIAssistantRunStreamingTests() : RunStreamingTests<OpenAIAssistantFixture>(() => new())
+{
+}

dotnet/tests/OpenAIAssistant.IntegrationTests/OpenAIAssistantStructuredOutputRunTests.cs

@@ -0,0 +1,23 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Threading.Tasks;
+using AgentConformance.IntegrationTests;
+
+namespace OpenAIAssistant.IntegrationTests;
+
+public class OpenAIAssistantStructuredOutputRunTests() : StructuredOutputRunTests<OpenAIAssistantFixture>(() => new())
+{
+    private const string SkipReason = "Fails intermittently on the build agent/CI";
+
+    [Fact(Skip = SkipReason)]
+    public override Task RunWithResponseFormatReturnsExpectedResultAsync() =>
+        base.RunWithResponseFormatReturnsExpectedResultAsync();
+
+    [Fact(Skip = SkipReason)]
+    public override Task RunWithGenericTypeReturnsExpectedResultAsync() =>
+        base.RunWithGenericTypeReturnsExpectedResultAsync();
+
+    [Fact(Skip = SkipReason)]
+    public override Task RunWithPrimitiveTypeReturnsExpectedResultAsync() =>
+        base.RunWithPrimitiveTypeReturnsExpectedResultAsync();
+}