test

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/OpenAIAssistantClientExtensionsTests.cs

@@ -0,0 +1,267 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+#pragma warning disable CS0618 // Type or member is obsolete - Testing deprecated OpenAI Assistants API extension methods
+
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Threading.Tasks;
+using AgentConformance.IntegrationTests.Support;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+using OpenAI;
+using OpenAI.Assistants;
+using OpenAI.Files;
+using OpenAI.VectorStores;
+using Shared.IntegrationTests;
+
+namespace OpenAIAssistant.IntegrationTests;
+
+public class OpenAIAssistantClientExtensionsTests
+{
+    private static readonly OpenAIConfiguration s_config = TestConfiguration.LoadSection<OpenAIConfiguration>();
+    private readonly AssistantClient _assistantClient = new OpenAIClient(s_config.ApiKey).GetAssistantClient();
+    private readonly OpenAIFileClient _fileClient = new OpenAIClient(s_config.ApiKey).GetOpenAIFileClient();
+
+    [Theory]
+    [InlineData("CreateWithChatClientAgentOptionsAsync")]
+    [InlineData("CreateWithChatClientAgentOptionsSync")]
+    [InlineData("CreateWithParamsAsync")]
+    public async Task CreateAIAgentAsync_WithAIFunctionTool_InvokesFunctionAsync(string createMechanism)
+    {
+        // Arrange
+        const string AgentInstructions = "You are a helpful weather assistant. Always call the GetWeather function to answer questions about weather.";
+
+        static string GetWeather(string location) => $"The weather in {location} is sunny with a high of 23C.";
+        var weatherFunction = AIFunctionFactory.Create(GetWeather, nameof(GetWeather));
+
+        // Act
+        var agent = createMechanism switch
+        {
+            "CreateWithChatClientAgentOptionsAsync" => await this._assistantClient.CreateAIAgentAsync(
+                model: s_config.ChatModelId!,
+                options: new ChatClientAgentOptions()
+                {
+                    ChatOptions = new()
+                    {
+                        Instructions = AgentInstructions,
+                        Tools = [weatherFunction]
+                    }
+                }),
+            "CreateWithChatClientAgentOptionsSync" => await this._assistantClient.CreateAIAgentAsync(
+                model: s_config.ChatModelId!,
+                options: new ChatClientAgentOptions()
+                {
+                    ChatOptions = new()
+                    {
+                        Instructions = AgentInstructions,
+                        Tools = [weatherFunction]
+                    }
+                }),
+            "CreateWithParamsAsync" => await this._assistantClient.CreateAIAgentAsync(
+                model: s_config.ChatModelId!,
+                instructions: AgentInstructions,
+                tools: [weatherFunction]),
+            _ => throw new InvalidOperationException($"Unknown create mechanism: {createMechanism}")
+        };
+
+        try
+        {
+            // Trigger function call.
+            var response = await agent.RunAsync("What is the weather like in Amsterdam?");
+            var text = response.Text;
+
+            // Assert
+            Assert.Contains("Amsterdam", text, StringComparison.OrdinalIgnoreCase);
+            Assert.Contains("sunny", text, StringComparison.OrdinalIgnoreCase);
+            Assert.Contains("23", text, StringComparison.OrdinalIgnoreCase);
+        }
+        finally
+        {
+            await this._assistantClient.DeleteAssistantAsync(agent.Id);
+        }
+    }
+
+    [Theory]
+    [InlineData("CreateWithChatClientAgentOptionsAsync")]
+    [InlineData("CreateWithChatClientAgentOptionsSync")]
+    [InlineData("CreateWithParamsAsync")]
+    public async Task CreateAIAgentAsync_WithHostedCodeInterpreter_RunsCodeAsync(string createMechanism)
+    {
+        // Arrange
+        const string Instructions = "Use the Code Interpreter Tool to run the uploaded python file and respond only with the secret number.";
+
+        // Create a python file that prints a known value.
+        var codeFilePath = Path.GetTempFileName() + "openai_secret_number.py";
+        File.WriteAllText(
+            path: codeFilePath,
+            contents: "print(\"OPENAI_SECRET=13579\")" // Deterministic output we will look for.
+        );
+
+        // Upload file to OpenAI Assistants file store for use with the Code Interpreter.
+        var uploadResult = await this._fileClient.UploadFileAsync(codeFilePath, FileUploadPurpose.Assistants);
+        string uploadedFileId = uploadResult.Value.Id;
+        var codeInterpreterTool = new HostedCodeInterpreterTool() { Inputs = [new HostedFileContent(uploadedFileId)] };
+
+        var agent = createMechanism switch
+        {
+            "CreateWithChatClientAgentOptionsAsync" => await this._assistantClient.CreateAIAgentAsync(
+                model: s_config.ChatModelId!,
+                options: new ChatClientAgentOptions()
+                {
+                    ChatOptions = new()
+                    {
+                        Instructions = Instructions,
+                        Tools = [codeInterpreterTool]
+                    }
+                }),
+            "CreateWithChatClientAgentOptionsSync" => await this._assistantClient.CreateAIAgentAsync(
+                model: s_config.ChatModelId!,
+                options: new ChatClientAgentOptions()
+                {
+                    ChatOptions = new()
+                    {
+                        Instructions = Instructions,
+                        Tools = [codeInterpreterTool]
+                    }
+                }),
+            "CreateWithParamsAsync" => await this._assistantClient.CreateAIAgentAsync(
+                model: s_config.ChatModelId!,
+                instructions: Instructions,
+                tools: [codeInterpreterTool]),
+            _ => throw new InvalidOperationException($"Unknown create mechanism: {createMechanism}")
+        };
+
+        try
+        {
+            var response = await agent.RunAsync("What is the OPENAI_SECRET number?");
+            var text = response.ToString();
+            Assert.Contains("13579", text);
+        }
+        finally
+        {
+            await this._assistantClient.DeleteAssistantAsync(agent.Id);
+            await this._fileClient.DeleteFileAsync(uploadedFileId);
+            File.Delete(codeFilePath);
+        }
+    }
+
+    [Theory(Skip = "For manual testing only")]
+    [InlineData("CreateWithChatClientAgentOptionsAsync")]
+    [InlineData("CreateWithChatClientAgentOptionsSync")]
+    [InlineData("CreateWithParamsAsync")]
+    public async Task CreateAIAgentAsync_WithHostedFileSearchTool_SearchesFilesAsync(string createMechanism)
+    {
+        // Arrange.
+        const string Instructions = """
+            You are a helpful agent that can help fetch data from files you know about.
+            Use the File Search Tool to look up codes for words.
+            Do not answer a question unless you can find the answer using the File Search Tool.
+            """;
+
+        // Create a local file with deterministic content and upload it.
+        var searchFilePath = Path.GetTempFileName() + "wordcodelookup.txt";
+        File.WriteAllText(
+            path: searchFilePath,
+            contents: "The word 'apple' uses the code 442345, while the word 'banana' uses the code 673457.");
+        var uploadResult = await this._fileClient.UploadFileAsync(searchFilePath, FileUploadPurpose.Assistants);
+        string uploadedFileId = uploadResult.Value.Id;
+
+        // Create a vector store backing the file search (HostedFileSearchTool requires a vector store id).
+        var vectorStoreClient = new OpenAIClient(s_config.ApiKey).GetVectorStoreClient();
+        var vectorStoreCreate = await vectorStoreClient.CreateVectorStoreAsync(options: new VectorStoreCreationOptions()
+        {
+            Name = "WordCodeLookup_VectorStore",
+            FileIds = { uploadedFileId }
+        });
+        string vectorStoreId = vectorStoreCreate.Value.Id;
+
+        // Wait for vector store indexing to complete before using it
+        await WaitForVectorStoreReadyAsync(vectorStoreClient, vectorStoreId);
+
+        var fileSearchTool = new HostedFileSearchTool() { Inputs = [new HostedVectorStoreContent(vectorStoreId)] };
+
+        var agent = createMechanism switch
+        {
+            "CreateWithChatClientAgentOptionsAsync" => await this._assistantClient.CreateAIAgentAsync(
+                model: s_config.ChatModelId!,
+                options: new ChatClientAgentOptions()
+                {
+                    ChatOptions = new()
+                    {
+                        Instructions = Instructions,
+                        Tools = [fileSearchTool]
+                    }
+                }),
+            "CreateWithChatClientAgentOptionsSync" => await this._assistantClient.CreateAIAgentAsync(
+                model: s_config.ChatModelId!,
+                options: new ChatClientAgentOptions()
+                {
+                    ChatOptions = new()
+                    {
+                        Instructions = Instructions,
+                        Tools = [fileSearchTool]
+                    }
+                }),
+            "CreateWithParamsAsync" => await this._assistantClient.CreateAIAgentAsync(
+                model: s_config.ChatModelId!,
+                instructions: Instructions,
+                tools: [fileSearchTool]),
+            _ => throw new InvalidOperationException($"Unknown create mechanism: {createMechanism}")
+        };
+
+        try
+        {
+            // Act - ask about banana code which must be retrieved via file search.
+            var response = await agent.RunAsync("Can you give me the documented code for 'banana'?");
+            var text = response.ToString();
+            Assert.Contains("673457", text);
+        }
+        finally
+        {
+            await this._assistantClient.DeleteAssistantAsync(agent.Id);
+            await vectorStoreClient.DeleteVectorStoreAsync(vectorStoreId);
+            await this._fileClient.DeleteFileAsync(uploadedFileId);
+            File.Delete(searchFilePath);
+        }
+    }
+
+    /// <summary>
+    /// Waits for a vector store to complete indexing by polling its status.
+    /// </summary>
+    /// <param name="client">The vector store client.</param>
+    /// <param name="vectorStoreId">The ID of the vector store.</param>
+    /// <param name="maxWaitSeconds">Maximum time to wait in seconds (default: 30).</param>
+    /// <returns>A task that completes when the vector store is ready or throws on timeout/failure.</returns>
+    private static async Task WaitForVectorStoreReadyAsync(
+        VectorStoreClient client,
+        string vectorStoreId,
+        int maxWaitSeconds = 30)
+    {
+        Stopwatch sw = Stopwatch.StartNew();
+        while (sw.Elapsed.TotalSeconds < maxWaitSeconds)
+        {
+            VectorStore vectorStore = await client.GetVectorStoreAsync(vectorStoreId);
+            VectorStoreStatus status = vectorStore.Status;
+
+            if (status == VectorStoreStatus.Completed)
+            {
+                if (vectorStore.FileCounts.Failed > 0)
+                {
+                    throw new InvalidOperationException("Vector store indexing failed for some files");
+                }
+
+                return;
+            }
+
+            if (status == VectorStoreStatus.Expired)
+            {
+                throw new InvalidOperationException("Vector store has expired");
+            }
+
+            await Task.Delay(1000);
+        }
+
+        throw new TimeoutException($"Vector store did not complete indexing within {maxWaitSeconds}s");
+    }
+}

dotnet/tests/OpenAIAssistant.IntegrationTests/OpenAIAssistantFixture.cs

@@ -0,0 +1,99 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+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 static readonly OpenAIConfiguration s_config = TestConfiguration.LoadSection<OpenAIConfiguration>();
+
+    private AssistantClient? _assistantClient;
+    private ChatClientAgent _agent = null!;
+
+    public AIAgent Agent => this._agent;
+
+    public IChatClient ChatClient => this._agent.ChatClient;
+
+    public async Task<List<ChatMessage>> GetChatHistoryAsync(AgentThread thread)
+    {
+        var typedThread = (ChatClientAgentThread)thread;
+        List<ChatMessage> messages = [];
+        await foreach (var agentMessage in this._assistantClient!.GetMessagesAsync(typedThread.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(
+                s_config.ChatModelId!,
+                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 DeleteThreadAsync(AgentThread thread)
+    {
+        var typedThread = (ChatClientAgentThread)thread;
+        if (typedThread?.ConversationId is not null)
+        {
+            return this._assistantClient!.DeleteThreadAsync(typedThread.ConversationId);
+        }
+
+        return Task.CompletedTask;
+    }
+
+    public async Task InitializeAsync()
+    {
+        var client = new OpenAIClient(s_config.ApiKey);
+        this._assistantClient = client.GetAssistantClient();
+
+        this._agent = await this.CreateChatClientAgentAsync();
+    }
+
+    public Task DisposeAsync()
+    {
+        if (this._assistantClient is not null && this._agent is not null)
+        {
+            return this._assistantClient.DeleteAssistantAsync(this._agent.Id);
+        }
+
+        return Task.CompletedTask;
+    }
+}

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())
+{
+}