Threads endpoint remapping

LlmTornado.Demo/AssistantsDemo.cs

@@ -128,10 +128,7 @@ public static async Task<Assistant> CreateWithCodeInterpreter()
     [TornadoTest]
     public static async Task<Assistant?> Retrieve()
     {
-        if (generatedAssistant is null)
-        {
-            await Create();
-        }
+        generatedAssistant ??= await Create();
 
         HttpCallResult<Assistant> response =
             await Program.Connect().Assistants.RetrieveAssistantAsync(generatedAssistant!.Id);
@@ -142,10 +139,7 @@ public static async Task<Assistant> CreateWithCodeInterpreter()
     [TornadoTest]
     public static async Task<Assistant?> Modify()
     {
-        if (generatedAssistant is null)
-        {
-            await Create();
-        }
+        generatedAssistant ??= await Create();
 
         CreateAssistantRequest modifyRequest = new CreateAssistantRequest(generatedAssistant!)
         {
@@ -161,13 +155,11 @@ public static async Task<Assistant> CreateWithCodeInterpreter()
     [TornadoTest]
     public static async Task<bool> Delete()
     {
-        if (generatedAssistant is null)
-        {
-            await Create();
-        }
+        generatedAssistant ??= await Create();
 
         HttpCallResult<bool> response = await Program.Connect().Assistants.DeleteAssistantAsync(generatedAssistant!);
         Console.WriteLine(response.Response);
+        generatedAssistant = null;
         return response.Data;
     }
 
@@ -179,6 +171,7 @@ public static async Task DeleteAllDemoAssistants()
             where assistant.Name.StartsWith("demo_assistant")
             select Program.Connect().Assistants.DeleteAssistantAsync(assistant.Id)).ToList();
         Console.WriteLine($"Deleting {tasks.Count} assistants...");
+        generatedAssistant = null;
         await Task.WhenAll(tasks);
     }
 }

LlmTornado.Demo/ThreadsDemo.cs

@@ -1,64 +1,264 @@
+using LlmTornado.Assistants;
+using LlmTornado.Chat;
+using LlmTornado.Chat.Models;
 using LlmTornado.Common;
 using LlmTornado.Threads;
+using Thread = LlmTornado.Threads.Thread;
 
 namespace LlmTornado.Demo;
 
 public static class ThreadsDemo
 {
-    [Flaky]
+    private static Thread? generatedThread;
+    private static Message? generatedMessage;
+    private static TornadoRun? generatedTornadoRun;
+
+    [TornadoTest]
+    public static async Task<Thread> CreateThread()
+    {
+        HttpCallResult<Thread> thread = await Program.Connect().Threads.CreateThreadAsync();
+        Console.WriteLine(thread.Response);
+        generatedThread = thread.Data;
+        return thread.Data!;
+    }
+
+    [TornadoTest]
+    public static async Task<Thread> RetrieveThread()
+    {
+        generatedThread ??= await CreateThread();
+        HttpCallResult<Thread> response = await Program.Connect().Threads.RetrieveThreadAsync(generatedThread!.Id);
+        Console.WriteLine(response.Response);
+        return response.Data!;
+    }
+
     [TornadoTest]
-    public static async Task<ThreadResponse?> Create()
+    public static async Task<Thread> ModifyThread()
     {
-        HttpCallResult<ThreadResponse> thread = await Program.Connect().Threads.CreateThreadAsync();
-        return thread.Data;
+        generatedThread ??= await CreateThread();
+        HttpCallResult<Thread>? response = await Program.Connect().Threads.ModifyThreadAsync(generatedThread.Id,
+            new ModifyThreadRequest()
+            {
+                Metadata = new Dictionary<string, string>
+                {
+                    {"key1", "value1"},
+                    {"key2", "value2"}
+                }
+            });
+        Console.WriteLine(response.Response);
+        return response.Data!;
     }
 
-    [Flaky]
     [TornadoTest]
-    public static async Task<ThreadResponse> Retrieve()
+    public static async Task DeleteThread()
     {
-        ThreadResponse? response = await Create();
-        response = (await Program.Connect().Threads.RetrieveThreadAsync(response.Id)).Data;
+        generatedThread ??= await CreateThread();
+        HttpCallResult<bool> deleted = await Program.Connect().Threads.DeleteThreadAsync(generatedThread.Id);
+        generatedThread = null;
+        generatedMessage = null;
+        generatedTornadoRun = null;
+        Console.WriteLine(deleted.Response);
+    }
+
+    [TornadoTest]
+    public static async Task<Message> CreateMessage()
+    {
+        generatedThread ??= await CreateThread();
+        Message response = await CreateMessage(generatedThread.Id,
+            "I need to think of a magic spell that turns cows into sheep.");
+        Console.WriteLine(response);
+        generatedMessage = response;
         return response;
     }
-
-    [Flaky]
+
+    public static async Task<Message> CreateMessage(string threadId, string content)
+    {
+        HttpCallResult<Message> response = await Program.Connect().Threads.CreateMessageAsync(threadId,
+            new CreateMessageRequest()
+            {
+                Role = ChatMessageRole.User,
+                Content = content
+            });
+        return response.Data!;
+    }
+
+    [TornadoTest]
+    public static async Task<Message> RetrieveMessage()
+    {
+        generatedThread ??= await CreateThread();
+        generatedMessage ??= await CreateMessage();
+
+        HttpCallResult<Message> response =
+            await Program.Connect().Threads.RetrieveMessageAsync(generatedThread.Id, generatedMessage.Id);
+        Console.WriteLine(response.Response);
+        return response.Data!;
+    }
+
+    [TornadoTest]
+    public static async Task<IReadOnlyList<Message>> ListMessages()
+    {
+        generatedThread ??= await CreateThread();
+        generatedMessage ??= await CreateMessage();
+
+        HttpCallResult<ListResponse<Message>> response =
+            await Program.Connect().Threads.ListMessagesAsync(generatedThread.Id);
+        Console.WriteLine(response.Response);
+        return response.Data!.Items;
+    }
+
+    [TornadoTest]
+    public static async Task<Message> ModifyMessage()
+    {
+        generatedThread ??= await CreateThread();
+        generatedMessage ??= await CreateMessage();
+
+        HttpCallResult<Message> response = await Program.Connect().Threads.ModifyMessageAsync(generatedThread.Id,
+            generatedMessage.Id, new ModifyMessageRequest()
+            {
+                Metadata = new Dictionary<string, string>()
+                {
+                    {"key1", "value1"},
+                    {"key2", "value2"}
+                }
+            });
+
+        Console.WriteLine(response.Response);
+        return response.Data!;
+    }
+
+    [TornadoTest]
+    public static async Task<bool> DeleteMessage()
+    {
+        generatedThread ??= await CreateThread();
+        generatedMessage ??= await CreateMessage();
+
+        HttpCallResult<bool> response =
+            await Program.Connect().Threads.DeleteMessageAsync(generatedThread.Id, generatedMessage.Id);
+        generatedMessage = null;
+        Console.WriteLine(response.Response);
+        return response.Data;
+    }
+
     [TornadoTest]
-    public static async Task<ThreadResponse> Modify()
+    public static async Task<TornadoRun> CreateRun(Assistant? assistant = null, string? assistantInstruction = null)
     {
-        ThreadResponse? response = await Create();
-        response = (await Program.Connect().Threads.ModifyThreadAsync(response.Id, new Dictionary<string, string>
+        generatedMessage ??= await CreateMessage();
+        assistant ??= await AssistantsDemo.Create();
+
+        HttpCallResult<TornadoRun> response = await Program.Connect().Threads.CreateRunAsync(generatedThread!.Id,
+            new CreateRunRequest(assistant!.Id)
+            {
+                Model = ChatModel.OpenAi.Gpt4.O241120,
+                Instructions = assistantInstruction ?? "You are a helpful assistant with the ability to create names of magic spells."
+            });
+        Console.WriteLine(response.Response);
+        generatedTornadoRun = response.Data!;
+
+        return response.Data!;
+    }
+
+    [TornadoTest]
+    public static async Task<TornadoRun> RetrieveRun()
+    {
+        generatedTornadoRun ??= await CreateRun();
+
+        HttpCallResult<TornadoRun> response =
+            await Program.Connect().Threads.RetrieveRunAsync(generatedThread!.Id, generatedTornadoRun!.Id);
+        Console.WriteLine(response.Response);
+        return response.Data!;
+    }
+
+    [TornadoTest]
+    public static async Task<TornadoRun> RetrieveRunAndPollForCompletion()
+    {
+        generatedTornadoRun ??= await CreateRun();
+
+        while (true)
         {
-            { "key1", "value1" },
-            { "key2", "value2" }
-        })).Data;
-        response = (await Program.Connect().Threads.RetrieveThreadAsync(response.Id)).Data;
-        return response;
+            HttpCallResult<TornadoRun> response = await Program.Connect().Threads
+                .RetrieveRunAsync(generatedThread!.Id, generatedTornadoRun!.Id);
+            if (response.Data!.Status == RunStatus.Completed)
+            {
+                IReadOnlyList<Message> messages = await ListMessages();
+                Console.WriteLine(response.Response);
+
+                foreach (Message message in messages.Reverse())
+                {
+                    foreach (MessageContent content in message.Content)
+                    {
+                        if (content is MessageContentText text)
+                        {
+                            Console.WriteLine($"{message.Role}: {text.MessageContentTextData?.Value}");
+                        }
+                    }
+                }
+
+                return response.Data!;
+            }
+
+            await Task.Delay(TimeSpan.FromSeconds(1));
+        }
+    }
+
+    public static async Task<TornadoRun> ModifyRun()
+    {
+        generatedTornadoRun ??= await CreateRun();
+
+        HttpCallResult<TornadoRun> response = await Program.Connect().Threads.ModifyRunAsync(generatedThread!.Id,
+            generatedTornadoRun!.Id,
+            new ModifyRunRequest()
+            {
+                Metadata = new Dictionary<string, string>()
+                {
+                    {"key1", "value1"},
+                    {"key2", "value2"}
+                }
+            });
+        Console.WriteLine(response.Response);
+        generatedTornadoRun = response.Data!;
+        return response.Data!;
     }
-
-    [Flaky]
+
+    [TornadoTest]
+    public static async Task<bool> DeleteRun()
+    {
+        generatedTornadoRun ??= await CreateRun();
+
+        HttpCallResult<bool> response =
+            await Program.Connect().Threads.DeleteRunAsync(generatedThread!.Id, generatedTornadoRun!.Id);
+        Console.WriteLine(response.Response);
+        generatedTornadoRun = null;
+        return response.Data;
+    }
+
     [TornadoTest]
-    public static async Task<bool> Delete(ThreadResponse thread)
+    public static async Task<IReadOnlyList<TornadoRunStep>> ListRunSteps()
     {
-        HttpCallResult<bool> deleted = await Program.Connect().Threads.DeleteThreadAsync(thread.Id);
-        return deleted.Data;
+        generatedTornadoRun ??= await RetrieveRunAndPollForCompletion();
+        HttpCallResult<ListResponse<TornadoRunStep>> response =
+            await Program.Connect().Threads.ListRunStepsAsync(generatedThread!.Id, generatedTornadoRun!.Id);
+        Console.WriteLine(response.Response);
+        return response.Data!.Items;
     }
-
-    [Flaky]
+
     [TornadoTest]
-    public static async Task Delete()
+    public static async Task<TornadoRunStep> RetrieveRunStep()
     {
-        ThreadResponse? response = await Create();
-        HttpCallResult<bool> deleted = await Program.Connect().Threads.DeleteThreadAsync(response.Id);
-        HttpCallResult<ThreadResponse> retrieveResponse = await Program.Connect().Threads.RetrieveThreadAsync(response.Id);
+        IReadOnlyList<TornadoRunStep> runSteps = await ListRunSteps();
+        HttpCallResult<TornadoRunStep> response = await Program.Connect().Threads
+            .RetrieveRunStepAsync(generatedThread!.Id, generatedTornadoRun!.Id, runSteps.FirstOrDefault()!.Id);
+        Console.WriteLine(response.Response);
+        return response.Data!;
     }
-
-    [Flaky]
+
     [TornadoTest]
-    public static async Task CreateMessage()
+    public static async Task<TornadoRun> ExtractInfoFromFile()
     {
-        ThreadResponse? response = await Create();
-        HttpCallResult<MessageResponse> msg = await Program.Connect().Threads.CreateMessageAsync(response.Id, new CreateMessageRequest("my message"));
-        await Delete(response);
+        Assistant assistant = await AssistantsDemo.CreateFileSearchAssistant();
+        generatedThread = await CreateThread();
+        generatedMessage =
+            await CreateMessage(generatedThread.Id, "Please summarize the file in 3 sentences from the file.");
+        generatedTornadoRun = await CreateRun(assistant, "You are assistant that analyzes files in a brief way");
+        TornadoRun completedRun = await RetrieveRunAndPollForCompletion();
+        return completedRun;
     }
 }