Merge pull request #4820 from RobiladK/patch-5

Update code-interpreter-samples.md

Author: ShannonLeavitt

articles/ai-services/agents/how-to/tools/code-interpreter-samples.md

@@ -151,196 +151,101 @@ In this example we will demonstrate the Agent streaming support, code interprete
 1. First, we set up configuration using `appsettings.json`, create a `PersistentAgentsClient`, and then create a `PersistentAgent` with the Code Interpreter tool.
 
 ```csharp
-using Azure;
-using Azure.AI.Agents.Persistent;
-using Azure.Identity;
-using Microsoft.Extensions.Configuration;
-using System.Diagnostics;
-
-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(projectEndpoint, new DefaultAzureCredential());
-```
-
-Synchronous sample:
-
-```csharp
-PersistentAgent agent = client.Administration.CreateAgent(
-    model: modelDeploymentName,
-    name: "My Friendly Test Agent",
-    instructions: "You politely help with math questions. Use the code interpreter tool when asked to visualize numbers.",
-    tools: [new CodeInterpreterToolDefinition()]
-);
-```
-
-Asynchronous sample:
-
-```csharp
-PersistentAgent agent = await client.Administration.CreateAgentAsync(
-    model: modelDeploymentName,
-    name: "My Friendly Test Agent",
-    instructions: "You politely help with math questions. Use the code interpreter tool when asked to visualize numbers.",
-    tools: [new CodeInterpreterToolDefinition()]
-);
+    using Azure;
+    using Azure.AI.Agents.Persistent;
+    using Azure.Identity;
+    using Microsoft.Extensions.Configuration;
+    using System.Diagnostics;
+    
+    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(projectEndpoint, new DefaultAzureCredential());
+    
+    PersistentAgent agent = client.Administration.CreateAgent(
+        model: modelDeploymentName,
+        name: "My Friendly Test Agent",
+        instructions: "You politely help with math questions. Use the code interpreter tool when asked to visualize numbers.",
+        tools: [new CodeInterpreterToolDefinition()]
+    );
 ```
 
 2. Next, we create a `PersistentAgentThread` and add a user message to it.
 
-Synchronous sample:
-
 ```csharp
-PersistentAgentThread thread = client.Threads.CreateThread();
-
-client.Messages.CreateMessage(
-    thread.Id,
-    MessageRole.User,
-    "Hi, Agent! Draw a graph for a line with a slope of 4 and y-intercept of 9.");
-```
-
-Asynchronous sample:
-
-```csharp
-PersistentAgentThread thread = await client.Threads.CreateThreadAsync();
-
-await client.Messages.CreateMessageAsync(
-    thread.Id,
-    MessageRole.User,
-    "Hi, Agent! Draw a graph for a line with a slope of 4 and y-intercept of 9.");
+    PersistentAgentThread thread = client.Threads.CreateThread();
+    
+    client.Messages.CreateMessage(
+        thread.Id,
+        MessageRole.User,
+        "Hi, Agent! Draw a graph for a line with a slope of 4 and y-intercept of 9.");
 ```
 
 3. Then, we create a `ThreadRun` for the thread and agent, providing any additional instructions. We poll the run's status until it is no longer queued, in progress, or requires action.
 
-Synchronous sample:
-
-```csharp
-ThreadRun run = client.Runs.CreateRun(
-    thread.Id,
-    agent.Id,
-    additionalInstructions: "Please address the user as Jane Doe. The user has a premium account.");
-
-do
-{
-    Thread.Sleep(TimeSpan.FromMilliseconds(500));
-    run = client.Runs.GetRun(thread.Id, run.Id);
-}
-while (run.Status == RunStatus.Queued
-    || run.Status == RunStatus.InProgress
-    || run.Status == RunStatus.RequiresAction);
-```
-
-Asynchronous sample:
-
-```csharp
-ThreadRun run = await client.Runs.CreateRunAsync(
-    thread.Id,
-    agent.Id,
-    additionalInstructions: "Please address the user as Jane Doe. The user has a premium account.");
-
-do
-{
-    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);
-```
-
-4. Once the run is finished, we retrieve all messages from the thread. We then iterate through the messages to display text content and handle any image files by saving them locally and opening them.
-
-Synchronous sample:
-
 ```csharp
-Pageable<ThreadMessage> messages = client.Messages.GetMessages(
-    threadId: thread.Id,
-    order: ListSortOrder.Ascending);
-
-foreach (ThreadMessage threadMessage in messages)
-{
-    foreach (MessageContent content in threadMessage.ContentItems)
+    ThreadRun run = client.Runs.CreateRun(
+        thread.Id,
+        agent.Id,
+        additionalInstructions: "Please address the user as Jane Doe. The user has a premium account.");
+    
+    do
     {
-        switch (content)
-        {
-            case MessageTextContent textItem:
-                Console.WriteLine($"[{threadMessage.Role}]: {textItem.Text}");
-                break;
-            case MessageImageFileContent imageFileContent:
-                Console.WriteLine($"[{threadMessage.Role}]: Image content file ID = {imageFileContent.FileId}");
-                BinaryData imageContent = client.Files.GetFileContent(imageFileContent.FileId);
-                string tempFilePath = Path.Combine(AppContext.BaseDirectory, $"{Guid.NewGuid()}.png");
-                File.WriteAllBytes(tempFilePath, imageContent.ToArray());
-                client.Files.DeleteFile(imageFileContent.FileId);
-
-                ProcessStartInfo psi = new()
-                {
-                    FileName = tempFilePath,
-                    UseShellExecute = true
-                };
-                Process.Start(psi);
-                break;
-        }
+        Thread.Sleep(TimeSpan.FromMilliseconds(500));
+        run = client.Runs.GetRun(thread.Id, run.Id);
     }
-}
+    while (run.Status == RunStatus.Queued
+        || run.Status == RunStatus.InProgress
+        || run.Status == RunStatus.RequiresAction);
 ```
 
-Asynchronous sample:
+4. Once the run is finished, we retrieve all messages from the thread. We then iterate through the messages to display text content and handle any image files by saving them locally and opening them.
 
 ```csharp
-AsyncPageable<ThreadMessage> messages = client.Messages.GetMessagesAsync(
-    threadId: thread.Id,
-    order: ListSortOrder.Ascending);
-
-await foreach (ThreadMessage threadMessage in messages)
-{
-    foreach (MessageContent content in threadMessage.ContentItems)
+    Pageable<ThreadMessage> messages = client.Messages.GetMessages(
+        threadId: thread.Id,
+        order: ListSortOrder.Ascending);
+    
+    foreach (ThreadMessage threadMessage in messages)
     {
-        switch (content)
+        foreach (MessageContent content in threadMessage.ContentItems)
         {
-            case MessageTextContent textItem:
-                Console.WriteLine($"[{threadMessage.Role}]: {textItem.Text}");
-                break;
-            case MessageImageFileContent imageFileContent:
-                Console.WriteLine($"[{threadMessage.Role}]: Image content file ID = {imageFileContent.FileId}");
-                BinaryData imageContent = await client.Files.GetFileContentAsync(imageFileContent.FileId);
-                string tempFilePath = Path.Combine(AppContext.BaseDirectory, $"{Guid.NewGuid()}.png");
-                File.WriteAllBytes(tempFilePath, imageContent.ToArray());
-                await client.Files.DeleteFileAsync(imageFileContent.FileId);
-
-                ProcessStartInfo psi = new()
-                {
-                    FileName = tempFilePath,
-                    UseShellExecute = true
-                };
-                Process.Start(psi);
-                break;
+            switch (content)
+            {
+                case MessageTextContent textItem:
+                    Console.WriteLine($"[{threadMessage.Role}]: {textItem.Text}");
+                    break;
+                case MessageImageFileContent imageFileContent:
+                    Console.WriteLine($"[{threadMessage.Role}]: Image content file ID = {imageFileContent.FileId}");
+                    BinaryData imageContent = client.Files.GetFileContent(imageFileContent.FileId);
+                    string tempFilePath = Path.Combine(AppContext.BaseDirectory, $"{Guid.NewGuid()}.png");
+                    File.WriteAllBytes(tempFilePath, imageContent.ToArray());
+                    client.Files.DeleteFile(imageFileContent.FileId);
+    
+                    ProcessStartInfo psi = new()
+                    {
+                        FileName = tempFilePath,
+                        UseShellExecute = true
+                    };
+                    Process.Start(psi);
+                    break;
+            }
         }
     }
-}
 ```
 
 5. Finally, we delete the thread and the agent to clean up the resources created in this sample.
 
-Synchronous sample:
-
 ```csharp
-client.Threads.DeleteThread(threadId: thread.Id);
-client.Administration.DeleteAgent(agentId: agent.Id);
+    client.Threads.DeleteThread(threadId: thread.Id);
+    client.Administration.DeleteAgent(agentId: agent.Id);
 ```
 
-Asynchronous sample:
-
-```csharp
-await client.Threads.DeleteThreadAsync(threadId: thread.Id);
-await client.Administration.DeleteAgentAsync(agentId: agent.Id);
-```
-
-
 :::zone-end
 
 :::zone pivot="javascript"