Merge branch 'main' into Updating-Local-File-Search

Author: e-straight

samples/microsoft/csharp/getting-started-agents/AdditionalMessage.md

@@ -1,44 +1,73 @@
 # Sample for using additional messages while creating agent run in Azure.AI.Agents
 
-1. First get `ProjectEndpoint` and `ModelDeploymentName` from config and create a `PersistentAgentsClient`.
-
-```C# Snippet:Sample_Agent_Multiple_Messages_Create
+1. Set up configuration, create an agent client, and create an agent. This step includes all necessary `using` directives.
+
+```C# Snippet:Sample_PersistentAgent_AdditionalMessages_CommonSetup
+using Azure;
+using Azure.AI.Agents.Persistent;
+using Azure.Identity;
+using Microsoft.Extensions.Configuration;
+
+IConfigurationRoot configuration = new ConfigurationBuilder()
+    .SetBasePath(AppContext.BaseDirectory)
+    .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
+    .Build();
 var projectEndpoint = configuration["ProjectEndpoint"];
 var modelDeploymentName = configuration["ModelDeploymentName"];
-PersistentAgentsClient client = new(new Uri(projectEndpoint), new DefaultAzureCredential());
+PersistentAgentsClient client = new(projectEndpoint, new DefaultAzureCredential());
 ```
 
-2. Next we will need to create an agent.
-
 Synchronous sample:
-```C# Snippet:Sample_Agent_Multiple_Messages_Create
-PersistentAgent agent = client.CreateAgent(
+
+```C# Snippet:Sample_PersistentAgent_AdditionalMessages_CreateAgentSync
+PersistentAgent agent = client.Administration.CreateAgent(
     model: modelDeploymentName,
     name: "Math Tutor",
     instructions: "You are a personal electronics tutor. Write and run code to answer questions.",
     tools: [new CodeInterpreterToolDefinition()]);
 ```
 
 Asynchronous sample:
-```C# Snippet:Sample_Agent_Multiple_Messages_CreateAsync
-PersistentAgent agent = await client.CreateAgentAsync(
+
+```C# Snippet:Sample_PersistentAgent_AdditionalMessages_CreateAgentAsync
+PersistentAgent agent = await client.Administration.CreateAgentAsync(
     model: modelDeploymentName,
     name: "Math Tutor",
     instructions: "You are a personal electronics tutor. Write and run code to answer questions.",
     tools: [new CodeInterpreterToolDefinition()]);
 ```
 
-3. Create the thread and run. In this example we are adding two extra messages to the thread, one with `Agent` and another with `User` role.
+2. Create the thread and add an initial message to it.
 
 Synchronous sample:
-```C# Snippet:Sample_Agent_Multiple_Messages_Run
-PersistentAgentThread thread = client.CreateThread();
-client.CreateMessage(
+
+```C# Snippet:Sample_PersistentAgent_AdditionalMessages_CreateThreadAndMessageSync
+PersistentAgentThread thread = client.Threads.CreateThread();
+
+client.Messages.CreateMessage(
+    thread.Id,
+    MessageRole.User,
+    "What is the impedance formula?");
+```
+
+Asynchronous sample:
+
+```C# Snippet:Sample_PersistentAgent_AdditionalMessages_CreateThreadAndMessageAsync
+PersistentAgentThread thread = await client.Threads.CreateThreadAsync();
+
+await client.Messages.CreateMessageAsync(
     thread.Id,
     MessageRole.User,
     "What is the impedance formula?");
+```
+
+3. Create the run with additional messages and poll for completion.
+   In this example we add two extra messages to the thread when creating the run: one with the `MessageRole.Agent` role and another with the `MessageRole.User` role.
+
+Synchronous sample:
 
-ThreadRun agentRun = client.CreateRun(
+```C# Snippet:Sample_PersistentAgent_AdditionalMessages_CreateAndPollRunSync
+ThreadRun run = client.Runs.CreateRun(
     threadId: thread.Id,
     agent.Id,
     additionalMessages: [
@@ -56,21 +85,17 @@ ThreadRun agentRun = client.CreateRun(
 do
 {
     Thread.Sleep(TimeSpan.FromMilliseconds(500));
-    agentRun = client.GetRun(thread.Id, agentRun.Id);
+    run = client.Runs.GetRun(thread.Id, run.Id);
 }
-while (agentRun.Status == RunStatus.Queued
-    || agentRun.Status == RunStatus.InProgress);
+while (run.Status == RunStatus.Queued
+    || run.Status == RunStatus.InProgress
+    || run.Status == RunStatus.RequiresAction);
 ```
 
 Asynchronous sample:
-```C# Snippet:Sample_Agent_Multiple_Messages_RunAsync
-PersistentAgentThread thread = await client.CreateThreadAsync();
-await client.CreateMessageAsync(
-    thread.Id,
-    MessageRole.User,
-    "What is the impedance formula?");
 
-ThreadRun agentRun = await client.CreateRunAsync(
+```C# Snippet:Sample_PersistentAgent_AdditionalMessages_CreateAndPollRunAsync
+ThreadRun run = await client.Runs.CreateRunAsync(
     threadId: thread.Id,
     agent.Id,
     additionalMessages: [
@@ -88,58 +113,69 @@ ThreadRun agentRun = await client.CreateRunAsync(
 do
 {
     await Task.Delay(TimeSpan.FromMilliseconds(500));
-    agentRun = await client.GetRunAsync(thread.Id, agentRun.Id);
+    run = await client.Runs.GetRunAsync(thread.Id, run.Id);
 }
-while (agentRun.Status == RunStatus.Queued
-    || agentRun.Status == RunStatus.InProgress);
+while (run.Status == RunStatus.Queued
+    || run.Status == RunStatus.InProgress
+    || run.Status == RunStatus.RequiresAction);
 ```
 
-4. Next, we print out all the messages to the console.
+4. Print out all the messages to the console.
 
 Synchronous sample:
-```C# Snippet:Sample_Agent_Multiple_Messages_Print
-PageableList<ThreadMessage> messages = client.GetMessages(thread.Id, order: ListSortOrder.Ascending);
+
+```C# Snippet:Sample_PersistentAgent_AdditionalMessages_PrintMessagesSync
+Pageable<ThreadMessage> messages = client.Messages.GetMessages(
+    threadId: thread.Id,
+    order: ListSortOrder.Ascending);
 
 foreach (ThreadMessage threadMessage in messages)
 {
-    foreach (MessageContent contentItem in threadMessage.ContentItems)
+    foreach (MessageContent content in threadMessage.ContentItems)
     {
-        if (contentItem is MessageTextContent textItem)
+        switch (content)
         {
-            Console.Write($"{threadMessage.Role}: {textItem.Text}");
+            case MessageTextContent textItem:
+                Console.WriteLine($"[{threadMessage.Role}]: {textItem.Text}");
+                break;
         }
-        Console.WriteLine();
     }
 }
 ```
 
 Asynchronous sample:
-```C# Snippet:Sample_Agent_Multiple_Messages_PrintAsync
-PageableList<ThreadMessage> messages = await client.GetMessagesAsync(thread.Id, order:ListSortOrder.Ascending);
 
-foreach (ThreadMessage threadMessage in messages)
+```C# Snippet:Sample_PersistentAgent_AdditionalMessages_PrintMessagesAsync
+AsyncPageable<ThreadMessage> messages = client.Messages.GetMessagesAsync(
+    threadId: thread.Id,
+    order: ListSortOrder.Ascending);
+
+await foreach (ThreadMessage threadMessage in messages)
 {
-    foreach (MessageContent contentItem in threadMessage.ContentItems)
+    foreach (MessageContent content in threadMessage.ContentItems)
     {
-        if (contentItem is MessageTextContent textItem)
+        switch (content)
         {
-            Console.Write($"{threadMessage.Role}: {textItem.Text}");
+            case MessageTextContent textItem:
+                Console.WriteLine($"[{threadMessage.Role}]: {textItem.Text}");
+                break;
         }
-        Console.WriteLine();
     }
 }
 ```
 
-5. Clean up resources by deleting thread and agent.
+5. Finally, clean up resources (delete the thread and agent).
 
 Synchronous sample:
-```C# Snippet:AgentsOverviewCleanupSync
-client.DeleteThread(threadId: thread.Id);
-client.DeleteAgent(agentId: agent.Id);
+
+```C# Snippet:Sample_PersistentAgent_AdditionalMessages_CleanupSync
+client.Threads.DeleteThread(threadId: thread.Id);
+client.Administration.DeleteAgent(agentId: agent.Id);
 ```
 
 Asynchronous sample:
-```C# Snippet:AgentsOverviewCleanup
-await client.DeleteThreadAsync(threadId: thread.Id);
-await client.DeleteAgentAsync(agentId: agent.Id);
+
+```C# Snippet:Sample_PersistentAgent_AdditionalMessages_CleanupAsync
+await client.Threads.DeleteThreadAsync(threadId: thread.Id);
+await client.Administration.DeleteAgentAsync(agentId: agent.Id);
 ```

samples/microsoft/csharp/getting-started-agents/AdditionalMessageAsync.cs

@@ -7,7 +7,6 @@
     .SetBasePath(AppContext.BaseDirectory)
     .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
     .Build();
-
 var projectEndpoint = configuration["ProjectEndpoint"];
 var modelDeploymentName = configuration["ModelDeploymentName"];
 PersistentAgentsClient client = new(projectEndpoint, new DefaultAzureCredential());
@@ -19,6 +18,7 @@
     tools: [new CodeInterpreterToolDefinition()]);
 
 PersistentAgentThread thread = await client.Threads.CreateThreadAsync();
+
 await client.Messages.CreateMessageAsync(
     thread.Id,
     MessageRole.User,
@@ -49,19 +49,21 @@ await client.Messages.CreateMessageAsync(
     || run.Status == RunStatus.RequiresAction);
 
 AsyncPageable<ThreadMessage> messages = client.Messages.GetMessagesAsync(
-    thread.Id,
+    threadId: thread.Id,
     order: ListSortOrder.Ascending);
 
 await foreach (ThreadMessage threadMessage in messages)
 {
-    foreach (MessageContent contentItem in threadMessage.ContentItems)
+    foreach (MessageContent content in threadMessage.ContentItems)
     {
-        if (contentItem is MessageTextContent textItem)
+        switch (content)
         {
-            Console.WriteLine($"[{threadMessage.Role}]: {textItem.Text}");
+            case MessageTextContent textItem:
+                Console.WriteLine($"[{threadMessage.Role}]: {textItem.Text}");
+                break;
         }
     }
 }
 
 await client.Threads.DeleteThreadAsync(threadId: thread.Id);
-await client.Administration.DeleteAgentAsync(agentId: agent.Id);
+await client.Administration.DeleteAgentAsync(agentId: agent.Id);

samples/microsoft/csharp/getting-started-agents/AdditionalMessageSync.cs

@@ -7,24 +7,24 @@
     .SetBasePath(AppContext.BaseDirectory)
     .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
     .Build();
-
 var projectEndpoint = configuration["ProjectEndpoint"];
 var modelDeploymentName = configuration["ModelDeploymentName"];
 PersistentAgentsClient client = new(projectEndpoint, new DefaultAzureCredential());
 
-PersistentAgent agent = client.Administration.CreateAgent(
+PersistentAgent agent = await client.Administration.CreateAgentAsync(
     model: modelDeploymentName,
     name: "Math Tutor",
     instructions: "You are a personal electronics tutor. Write and run code to answer questions.",
     tools: [new CodeInterpreterToolDefinition()]);
 
-PersistentAgentThread thread = client.Threads.CreateThread();
-client.Messages.CreateMessage(
+PersistentAgentThread thread = await client.Threads.CreateThreadAsync();
+
+await client.Messages.CreateMessageAsync(
     thread.Id,
     MessageRole.User,
     "What is the impedance formula?");
 
-ThreadRun run = client.Runs.CreateRun(
+ThreadRun run = await client.Runs.CreateRunAsync(
     threadId: thread.Id,
     agent.Id,
     additionalMessages: [
@@ -41,27 +41,29 @@
 
 do
 {
-    Thread.Sleep(TimeSpan.FromMilliseconds(500));
-    run = client.Runs.GetRun(thread.Id, run.Id);
+    await Task.Delay(TimeSpan.FromMilliseconds(500));
+    run = await client.Runs.GetRunAsync(thread.Id, run.Id);
 }
 while (run.Status == RunStatus.Queued
     || run.Status == RunStatus.InProgress
     || run.Status == RunStatus.RequiresAction);
 
-Pageable<ThreadMessage> messages = client.Messages.GetMessages(
-    thread.Id,
+AsyncPageable<ThreadMessage> messages = client.Messages.GetMessagesAsync(
+    threadId: thread.Id,
     order: ListSortOrder.Ascending);
 
-foreach (ThreadMessage threadMessage in messages)
+await foreach (ThreadMessage threadMessage in messages)
 {
-    foreach (MessageContent contentItem in threadMessage.ContentItems)
+    foreach (MessageContent content in threadMessage.ContentItems)
     {
-        if (contentItem is MessageTextContent textItem)
+        switch (content)
         {
-            Console.WriteLine($"[{threadMessage.Role}]: {textItem.Text}");
+            case MessageTextContent textItem:
+                Console.WriteLine($"[{threadMessage.Role}]: {textItem.Text}");
+                break;
         }
     }
 }
 
-client.Threads.DeleteThread(threadId: thread.Id);
-client.Administration.DeleteAgent(agentId: agent.Id);
+await client.Threads.DeleteThreadAsync(threadId: thread.Id);
+await client.Administration.DeleteAgentAsync(agentId: agent.Id);