OpenAI-DotNet 7.3.0

.github/workflows/Publish-Nuget.yml

@@ -34,7 +34,7 @@ jobs:
     runs-on: windows-latest
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
       with:
         fetch-depth: 0
     - uses: actions/setup-dotnet@v3

OpenAI-DotNet-Tests/TestFixture_00_Authentication.cs → OpenAI-DotNet-Tests/TestFixture_00_00_Authentication.cs

@@ -6,7 +6,7 @@
 
 namespace OpenAI.Tests
 {
-    internal class TestFixture_00_Authentication
+    internal class TestFixture_00_00_Authentication
     {
         [SetUp]
         public void Setup()

OpenAI-DotNet-Tests/TextFixture_11_Proxy.cs → OpenAI-DotNet-Tests/TestFixture_00_01_Proxy.cs

@@ -6,7 +6,7 @@
 
 namespace OpenAI.Tests
 {
-    internal class TextFixture_11_Proxy : AbstractTestFixture
+    internal class TestFixture_00_01_Proxy : AbstractTestFixture
     {
         [Test]
         public async Task Test_01_Health()

OpenAI-DotNet-Tests/TestFixture_03_Chat.cs

@@ -451,8 +451,9 @@ public async Task Test_07_GetChatToolCompletion()
                 Assert.IsTrue(result.Choices.Count == 1);
             }
 
-            var usedTool = result.FirstChoice.Message.ToolCalls[0];
             Assert.IsTrue(result.FirstChoice.FinishReason == "tool_calls");
+            var usedTool = result.FirstChoice.Message.ToolCalls[0];
+            Assert.IsNotNull(usedTool);
             Assert.IsTrue(usedTool.Function.Name == nameof(WeatherService.GetCurrentWeather));
             Console.WriteLine($"{result.FirstChoice.Message.Role}: {usedTool.Function.Name} | Finish Reason: {result.FirstChoice.FinishReason}");
             Console.WriteLine($"{usedTool.Function.Arguments}");
@@ -553,6 +554,7 @@ public async Task Test_08_GetChatToolCompletion_Streaming()
 
             Assert.IsTrue(result.FirstChoice.FinishReason == "tool_calls");
             var usedTool = result.FirstChoice.Message.ToolCalls[0];
+            Assert.IsNotNull(usedTool);
             Assert.IsTrue(usedTool.Function.Name == nameof(WeatherService.GetCurrentWeather));
             Console.WriteLine($"{result.FirstChoice.Message.Role}: {usedTool.Function.Name} | Finish Reason: {result.FirstChoice.FinishReason}");
             Console.WriteLine($"{usedTool.Function.Arguments}");
@@ -627,12 +629,13 @@ public async Task Test_09_GetChatToolForceCompletion()
             Assert.IsTrue(result.Choices.Count == 1);
             messages.Add(result.FirstChoice.Message);
 
-            var usedTool = result.FirstChoice.Message.ToolCalls[0];
             Assert.IsTrue(result.FirstChoice.FinishReason == "stop");
+            var usedTool = result.FirstChoice.Message.ToolCalls[0];
+            Assert.IsNotNull(usedTool);
             Assert.IsTrue(usedTool.Function.Name == nameof(WeatherService.GetCurrentWeather));
             Console.WriteLine($"{result.FirstChoice.Message.Role}: {usedTool.Function.Name} | Finish Reason: {result.FirstChoice.FinishReason}");
             Console.WriteLine($"{usedTool.Function.Arguments}");
-            var functionArgs = JsonSerializer.Deserialize<WeatherArgs>(result.FirstChoice.Message.ToolCalls[0].Function.Arguments.ToString());
+            var functionArgs = JsonSerializer.Deserialize<WeatherArgs>(usedTool.Function.Arguments.ToString());
             var functionResult = WeatherService.GetCurrentWeather(functionArgs);
             Assert.IsNotNull(functionResult);
             messages.Add(new Message(usedTool, functionResult));

OpenAI-DotNet-Tests/TestFixture_05_Images.cs

@@ -18,10 +18,10 @@ public async Task Test_1_GenerateImages()
 
             Assert.IsNotNull(results);
             Assert.NotZero(results.Count);
-            Assert.IsNotEmpty(results[0]);
 
             foreach (var result in results)
             {
+                Assert.IsNotNull(result);
                 Console.WriteLine(result);
             }
         }
@@ -36,10 +36,10 @@ public async Task Test_2_GenerateImages_B64_Json()
 
             Assert.IsNotNull(results);
             Assert.NotZero(results.Count);
-            Assert.IsNotEmpty(results[0]);
 
             foreach (var result in results)
             {
+                Assert.IsNotNull(result);
                 Console.WriteLine(result);
             }
         }
@@ -60,6 +60,7 @@ public async Task Test_3_GenerateImageEdits()
 
             foreach (var result in results)
             {
+                Assert.IsNotNull(result);
                 Console.WriteLine(result);
             }
         }
@@ -80,6 +81,7 @@ public async Task Test_4_GenerateImageEdits_B64_Json()
 
             foreach (var result in results)
             {
+                Assert.IsNotNull(result);
                 Console.WriteLine(result);
             }
         }
@@ -98,6 +100,7 @@ public async Task Test_5_GenerateImageVariations()
 
             foreach (var result in results)
             {
+                Assert.IsNotNull(result);
                 Console.WriteLine(result);
             }
         }
@@ -116,6 +119,7 @@ public async Task Test_6_GenerateImageVariations_B64_Json()
 
             foreach (var result in results)
             {
+                Assert.IsNotNull(result);
                 Console.WriteLine(result);
             }
         }

OpenAI-DotNet-Tests/TestFixture_09_FineTuning.cs

@@ -106,9 +106,9 @@ public async Task Test_02_ListFineTuneJobs()
             Assert.IsNotNull(OpenAIClient.FineTuningEndpoint);
             var list = await OpenAIClient.FineTuningEndpoint.ListJobsAsync();
             Assert.IsNotNull(list);
-            Assert.IsNotEmpty(list.Jobs);
+            Assert.IsNotEmpty(list.Items);
 
-            foreach (var job in list.Jobs.OrderByDescending(job => job.CreatedAt))
+            foreach (var job in list.Items.OrderByDescending(job => job.CreatedAt))
             {
                 Console.WriteLine($"{job.Id} -> {job.CreatedAt} | {job.Status}");
             }
@@ -120,9 +120,9 @@ public async Task Test_03_RetrieveFineTuneJobInfo()
             Assert.IsNotNull(OpenAIClient.FineTuningEndpoint);
             var list = await OpenAIClient.FineTuningEndpoint.ListJobsAsync();
             Assert.IsNotNull(list);
-            Assert.IsNotEmpty(list.Jobs);
+            Assert.IsNotEmpty(list.Items);
 
-            foreach (var job in list.Jobs.OrderByDescending(job => job.CreatedAt))
+            foreach (var job in list.Items.OrderByDescending(job => job.CreatedAt))
             {
                 var request = await OpenAIClient.FineTuningEndpoint.GetJobInfoAsync(job);
                 Assert.IsNotNull(request);
@@ -136,22 +136,18 @@ public async Task Test_04_ListFineTuneEvents()
             Assert.IsNotNull(OpenAIClient.FineTuningEndpoint);
             var list = await OpenAIClient.FineTuningEndpoint.ListJobsAsync();
             Assert.IsNotNull(list);
-            Assert.IsNotEmpty(list.Jobs);
+            Assert.IsNotEmpty(list.Items);
 
-            foreach (var job in list.Jobs)
+            foreach (var job in list.Items)
             {
-                if (job.Status == JobStatus.Cancelled)
-                {
-                    continue;
-                }
+                if (job.Status == JobStatus.Cancelled) { continue; }
 
                 var eventList = await OpenAIClient.FineTuningEndpoint.ListJobEventsAsync(job);
                 Assert.IsNotNull(eventList);
-                Assert.IsNotEmpty(eventList.Events);
-
-                Console.WriteLine($"{job.Id} -> status: {job.Status} | event count: {eventList.Events.Count}");
+                Assert.IsNotEmpty(eventList.Items);
+                Console.WriteLine($"{job.Id} -> status: {job.Status} | event count: {eventList.Items.Count}");
 
-                foreach (var @event in eventList.Events.OrderByDescending(@event => @event.CreatedAt))
+                foreach (var @event in eventList.Items.OrderByDescending(@event => @event.CreatedAt))
                 {
                     Console.WriteLine($"  {@event.CreatedAt} [{@event.Level}] {@event.Message}");
                 }
@@ -166,9 +162,9 @@ public async Task Test_05_CancelFineTuneJob()
             Assert.IsNotNull(OpenAIClient.FineTuningEndpoint);
             var list = await OpenAIClient.FineTuningEndpoint.ListJobsAsync();
             Assert.IsNotNull(list);
-            Assert.IsNotEmpty(list.Jobs);
+            Assert.IsNotEmpty(list.Items);
 
-            foreach (var job in list.Jobs)
+            foreach (var job in list.Items)
             {
                 if (job.Status is > JobStatus.NotStarted and < JobStatus.Succeeded)
                 {

OpenAI-DotNet-Tests/TestFixture_11_Assistants.cs

@@ -0,0 +1,134 @@
+using NUnit.Framework;
+using OpenAI.Assistants;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace OpenAI.Tests
+{
+    internal class TestFixture_11_Assistants : AbstractTestFixture
+    {
+        private static string testAssistantId;
+
+        [Test]
+        public async Task Test_01_CreateAssistant()
+        {
+            Assert.IsNotNull(OpenAIClient.AssistantsEndpoint);
+            const string testFilePath = "assistant_test.txt";
+            await File.WriteAllTextAsync(testFilePath, "Knowledge is power!");
+            Assert.IsTrue(File.Exists(testFilePath));
+            var file = await OpenAIClient.FilesEndpoint.UploadFileAsync(testFilePath, "assistants");
+            File.Delete(testFilePath);
+            Assert.IsFalse(File.Exists(testFilePath));
+            var request = new AssistantRequest("gpt-3.5-turbo-1106",
+                name: "test-assistant",
+                description: "Used for unit testing.",
+                instructions: "You are test assistant",
+                metadata: new Dictionary<string, string>
+                {
+                    ["int"] = "1",
+                    ["test"] = Guid.NewGuid().ToString()
+                },
+                tools: new[]
+                {
+                    Tool.Retrieval
+                },
+                fileIds: new[] { file.Id });
+            var assistant = await OpenAIClient.AssistantsEndpoint.CreateAssistantAsync(request);
+            Assert.IsNotNull(assistant);
+            Assert.AreEqual("test-assistant", assistant.Name);
+            Assert.AreEqual("Used for unit testing.", assistant.Description);
+            Assert.AreEqual("You are test assistant", assistant.Instructions);
+            Assert.AreEqual("gpt-3.5-turbo-1106", assistant.Model);
+            Assert.IsNotEmpty(assistant.Metadata);
+            testAssistantId = assistant.Id;
+            Console.WriteLine($"{assistant} -> {assistant.Metadata["test"]}");
+        }
+
+        [Test]
+        public async Task Test_02_ListAssistants()
+        {
+            Assert.IsNotNull(OpenAIClient.AssistantsEndpoint);
+            var assistantsList = await OpenAIClient.AssistantsEndpoint.ListAssistantsAsync();
+            Assert.IsNotNull(assistantsList);
+            Assert.IsNotEmpty(assistantsList.Items);
+
+            foreach (var assistant in assistantsList.Items)
+            {
+                Console.WriteLine($"{assistant} -> {assistant.CreatedAt}");
+            }
+        }
+
+        [Test]
+        public async Task Test_03_ListAssistantFiles()
+        {
+            Assert.IsFalse(string.IsNullOrWhiteSpace(testAssistantId));
+            Assert.IsNotNull(OpenAIClient.AssistantsEndpoint);
+            var filesList = await OpenAIClient.AssistantsEndpoint.ListAssistantFilesAsync(testAssistantId);
+            Assert.IsNotNull(filesList);
+            Assert.IsNotEmpty(filesList.Items);
+
+            foreach (var file in filesList.Items)
+            {
+                Assert.IsNotNull(file);
+                var retrieved = await OpenAIClient.AssistantsEndpoint.RetrieveAssistantFileAsync(file.AssistantId, file.Id);
+                Assert.IsNotNull(retrieved);
+                Console.WriteLine($"{retrieved.AssistantId}'s file -> {retrieved.Id}");
+            }
+        }
+
+        [Test]
+        public async Task Test_04_DeleteAssistantFile()
+        {
+            Assert.IsFalse(string.IsNullOrWhiteSpace(testAssistantId));
+            Assert.IsNotNull(OpenAIClient.AssistantsEndpoint);
+            var filesList = await OpenAIClient.AssistantsEndpoint.ListAssistantFilesAsync(testAssistantId);
+            Assert.IsNotNull(filesList);
+            Assert.IsNotEmpty(filesList.Items);
+
+            foreach (var file in filesList.Items)
+            {
+                Assert.IsNotNull(file);
+                var isRemoved = await OpenAIClient.AssistantsEndpoint.DeleteAssistantFileAsync(file);
+                Assert.IsTrue(isRemoved);
+                var isDeleted = await OpenAIClient.FilesEndpoint.DeleteFileAsync(file);
+                Assert.IsTrue(isDeleted);
+            }
+
+            filesList = await OpenAIClient.AssistantsEndpoint.ListAssistantFilesAsync(testAssistantId);
+            Assert.IsNotNull(filesList);
+            Assert.IsEmpty(filesList.Items);
+        }
+
+        [Test]
+        public async Task Test_05_ModifyAssistants()
+        {
+            Assert.IsFalse(string.IsNullOrWhiteSpace(testAssistantId));
+            Assert.IsNotNull(OpenAIClient.AssistantsEndpoint);
+            var request = new AssistantRequest(
+                model: "gpt-4-1106-preview",
+                name: "Test modified",
+                description: "Modified description",
+                instructions: "You are modified test assistant");
+            var assistant = await OpenAIClient.AssistantsEndpoint.ModifyAssistantAsync(testAssistantId, request);
+            Assert.IsNotNull(assistant);
+            Assert.AreEqual("Test modified", assistant.Name);
+            Assert.AreEqual("Modified description", assistant.Description);
+            Assert.AreEqual("You are modified test assistant", assistant.Instructions);
+            Assert.AreEqual("gpt-4-1106-preview", assistant.Model);
+            Assert.IsTrue(assistant.Metadata.ContainsKey("test"));
+            Console.WriteLine($"{assistant.Id} -> modified");
+        }
+
+        [Test]
+        public async Task Test_06_DeleteAssistant()
+        {
+            Assert.IsFalse(string.IsNullOrWhiteSpace(testAssistantId));
+            Assert.IsNotNull(OpenAIClient.AssistantsEndpoint);
+            var result = await OpenAIClient.AssistantsEndpoint.DeleteAssistantAsync(testAssistantId);
+            Assert.IsTrue(result);
+            Console.WriteLine($"{testAssistantId} -> deleted");
+        }
+    }
+}

OpenAI-DotNet-Tests/TestFixture_12_Threads.cs

@@ -0,0 +1,76 @@
+using NUnit.Framework;
+using OpenAI.Threads;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace OpenAI.Tests
+{
+    internal class TestFixture_12_Threads : AbstractTestFixture
+    {
+        private static CreateThreadRequest TestThread { get; } = new CreateThreadRequest(
+            new List<Message>
+            {
+                new Message("Test message")
+            },
+            new Dictionary<string, string>
+            {
+                ["text"] = "test"
+            }
+        );
+
+        [Test]
+        public async Task Test_01_CreateThread()
+        {
+            Assert.IsNotNull(OpenAIClient.ThreadsEndpoint);
+            var thread = await OpenAIClient.ThreadsEndpoint.CreateThreadAsync(TestThread);
+            Assert.IsNotNull(thread);
+            Assert.IsNotNull(thread.Metadata);
+            Assert.IsNotEmpty(thread.Metadata);
+            Assert.Contains("text", thread.Metadata.Keys.ToList());
+            Assert.AreEqual("test", thread.Metadata["text"]);
+        }
+
+        [Test]
+        public async Task Test_02_RetrieveThread()
+        {
+            Assert.IsNotNull(OpenAIClient.ThreadsEndpoint);
+            var thread = await OpenAIClient.ThreadsEndpoint.CreateThreadAsync(TestThread);
+            Assert.IsNotNull(thread);
+            var retrieved = await OpenAIClient.ThreadsEndpoint.RetrieveThreadAsync(thread);
+            Assert.IsNotNull(retrieved);
+            Assert.AreEqual(thread.Id, retrieved.Id);
+            Assert.IsNotNull(retrieved.Metadata);
+            Assert.Contains("text", retrieved.Metadata.Keys.ToList());
+            Assert.AreEqual("test", retrieved.Metadata["text"]);
+        }
+
+        [Test]
+        public async Task Test_03_ModifyThread()
+        {
+            Assert.IsNotNull(OpenAIClient.ThreadsEndpoint);
+            var thread = await OpenAIClient.ThreadsEndpoint.CreateThreadAsync(TestThread);
+            Assert.IsNotNull(thread);
+            var newMetadata = new Dictionary<string, string>
+            {
+                ["text"] = "test2"
+            };
+            var modified = await OpenAIClient.ThreadsEndpoint.ModifyThreadAsync(thread, newMetadata);
+            Assert.IsNotNull(modified);
+            Assert.AreEqual(thread.Id, modified.Id);
+            Assert.IsNotNull(modified.Metadata);
+            Assert.Contains("text", modified.Metadata.Keys.ToList());
+            Assert.AreEqual("test2", modified.Metadata["text"]);
+        }
+
+        [Test]
+        public async Task Test_04_DeleteThread()
+        {
+            Assert.IsNotNull(OpenAIClient.ThreadsEndpoint);
+            var thread = await OpenAIClient.ThreadsEndpoint.CreateThreadAsync(TestThread);
+            Assert.IsNotNull(thread);
+            var isDeleted = await OpenAIClient.ThreadsEndpoint.DeleteThreadAsync(thread);
+            Assert.IsTrue(isDeleted);
+        }
+    }
+}