Update code-interpreter-samples.md

Porting over the SDK sample that uses code interpreter tool to create an image, download the image and display it using streaming and additional instructions.

Author: RobiladK

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

@@ -144,125 +144,203 @@ for image_content in messages.image_contents:
 
 :::zone pivot="csharp" 
 
-## Create a project client 
+# How to use the code interpreter tool
 
-To use code interpreter, first you need to create a project client, which will contain a connection string to your AI project, and will be used to authenticate API calls.
+In this example we will demonstrate the Agent streaming support, code interpreter creating an image and downloading and viewing the image.
 
-```csharp
-var connectionString = Environment.GetEnvironmentVariable("PROJECT_CONNECTION_STRING");
-AgentsClient client = new AgentsClient(connectionString, new DefaultAzureCredential()); 
-```
+1. First, we set up configuration using `appsettings.json`, create a `PersistentAgentsClient`, and then create a `PersistentAgent` with the Code Interpreter tool.
 
-## Upload a File
+```C# Snippet:AgentsStreaming_Step1_Common_SetupClientAndConfig
+using Azure;
+using Azure.AI.Agents.Persistent;
+using Azure.Identity;
+using Microsoft.Extensions.Configuration;
+using System.Diagnostics;
 
-Files can be uploaded and then referenced by agents or messages. First, use the generalized upload API with a `purpose` of `Agents` to make a file ID available. Once uploaded, the file ID can then be provided to create a vector store for it. The vector store ID can then be provided to an agent upon creation.
+IConfigurationRoot configuration = new ConfigurationBuilder()
+    .SetBasePath(AppContext.BaseDirectory)
+    .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
+    .Build();
 
-```csharp
-// Upload a file and wait for it to be processed
-Response<AgentFile> uploadAgentFileResponse = await client.UploadFileAsync(
-    filePath: "sample_file_for_upload.txt",
-    purpose: AgentFilePurpose.Agents);
+var projectEndpoint = configuration["ProjectEndpoint"];
+var modelDeploymentName = configuration["ModelDeploymentName"];
 
-AgentFile uploadedAgentFile = uploadAgentFileResponse.Value;
+PersistentAgentsClient client = new(projectEndpoint, new DefaultAzureCredential());
+```
 
-// Create a vector store with the file and wait for it to be processed.
-// If you do not specify a vector store, create_message will create a vector store with a default expiration policy of seven days after they were last active
-VectorStore vectorStore = await client.CreateVectorStoreAsync(
-    fileIds:  new List<string> { uploadedAgentFile.Id },
-    name: "my_vector_store");
+Synchronous sample:
 
-CodeInterpreterToolResource codeInterpreterToolResource = new CodeInterpreterToolResource();
-CodeInterpreterToolResource.VectorStoreIds.Add(vectorStore.Id);
+```C# Snippet:AgentsStreaming_Step1_Sync_CreateAgent
+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()]
+);
 ```
 
-## Create an Agent with the Code Interpreter Tool
+Asynchronous sample:
 
-```csharp
-Response<Agent> agentResponse = await client.CreateAgentAsync(
-    model: "gpt-4o-mini",
-    name: "My agent",
-    instructions: "You are a helpful agent.",
-    tools: new List<ToolDefinition> { new CodeInterpreterToolDefinition() },
-    toolResources: new ToolResources() { CodeInterpreter = codeInterpreterToolResource });
-Agent agent = agentResponse.Value;
+```C# Snippet:AgentsStreaming_Step1_Async_CreateAgent
+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()]
+);
 ```
 
-## Create a Thread, Message, and Get the Agent Response
+2. Next, we create a `PersistentAgentThread` and add a user message to it.
 
-Next create a thread with `CreateThreadAsync()` and a thread with `CreateMessageAsync()`. After the thread is created, you can add messages to it with `CreateMessageAsync()` that will cause the code interpreter tool to trigger. Create a run, and then continue polling it until it reaches a terminal status. Assuming the run was successful, parse the agent's response by listing the messages.
+Synchronous sample:
 
-```csharp
-//Create a thread
-Response<AgentThread> threadResponse = await client.CreateThreadAsync();
-AgentThread thread = threadResponse.Value;
+```C# Snippet:AgentsStreaming_Step2_Sync_CreateThreadAndMessage
+PersistentAgentThread thread = client.Threads.CreateThread();
 
-//With a thread created, messages can be created on it:
-Response<ThreadMessage> messageResponse = await client.CreateMessageAsync(
+client.Messages.CreateMessage(
     thread.Id,
     MessageRole.User,
-    "I need to solve the equation `3x + 11 = 14`. Can you help me?");
-ThreadMessage message = messageResponse.Value;
+    "Hi, Agent! Draw a graph for a line with a slope of 4 and y-intercept of 9.");
+```
+
+Asynchronous sample:
+
+```C# Snippet:AgentsStreaming_Step2_Async_CreateThreadAndMessage
+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.");
+```
+
+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:
+
+```C# Snippet:AgentsStreaming_Step3_Sync_CreateAndPollRun
+ThreadRun run = client.Runs.CreateRun(
+    thread.Id,
+    agent.Id,
+    additionalInstructions: "Please address the user as Jane Doe. The user has a premium account.");
 
-//A run can then be started that evaluates the thread against an agent:
-Response<ThreadRun> runResponse = await client.CreateRunAsync(
+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:
+
+```C# Snippet:AgentsStreaming_Step3_Async_CreateAndPollRun
+ThreadRun run = await client.Runs.CreateRunAsync(
     thread.Id,
     agent.Id,
     additionalInstructions: "Please address the user as Jane Doe. The user has a premium account.");
-ThreadRun run = runResponse.Value;
 
-//Once the run has started, it should then be polled until it reaches a terminal status:
 do
 {
     await Task.Delay(TimeSpan.FromMilliseconds(500));
-    runResponse = await client.GetRunAsync(thread.Id, runResponse.Value.Id);
+    run = await client.Runs.GetRunAsync(thread.Id, run.Id);
 }
-while (runResponse.Value.Status == RunStatus.Queued
-    || runResponse.Value.Status == RunStatus.InProgress);
+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.
 
-//Assuming the run successfully completed, listing messages from the thread that was run will now reflect new information added by the agent:
+Synchronous sample:
 
-Response<PageableList<ThreadMessage>> afterRunMessagesResponse
-    = await client.GetMessagesAsync(thread.Id);
-IReadOnlyList<ThreadMessage> messages = afterRunMessagesResponse.Value.Data;
+```C# Snippet:AgentsStreaming_Step4_Sync_ProcessMessages
+Pageable<ThreadMessage> messages = client.Messages.GetMessages(
+    threadId: thread.Id,
+    order: ListSortOrder.Ascending);
 
-// Note: messages iterate from newest to oldest, with the messages[0] being the most recent
 foreach (ThreadMessage threadMessage in messages)
 {
-    Console.Write($"{threadMessage.CreatedAt:yyyy-MM-dd HH:mm:ss} - {threadMessage.Role,10}: ");
-    foreach (MessageContent contentItem in threadMessage.ContentItems)
+    foreach (MessageContent content in threadMessage.ContentItems)
     {
-        if (contentItem is MessageTextContent textItem)
-        {
-            Console.Write(textItem.Text);
-        }
-        else if (contentItem is MessageImageFileContent imageFileItem)
+        switch (content)
         {
-            Console.Write($"<image from ID: {imageFileItem.FileId}");
+            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;
         }
-        Console.WriteLine();
     }
 }
 ```
 
-## Download Files Generated by Code Interpreter
+Asynchronous sample:
 
-Files generated by code interpreter can be found in the Agent message responses. You can download image files generated by code interpreter by iterating through the response's messages and checking for an `ImageFileId`. If that field exists, use the following code:
+```C# Snippet:AgentsStreaming_Step4_Async_ProcessMessages
+AsyncPageable<ThreadMessage> messages = client.Messages.GetMessagesAsync(
+    threadId: thread.Id,
+    order: ListSortOrder.Ascending);
 
-```csharp
-foreach (MessageContent contentItem in message.Content)
+await foreach (ThreadMessage threadMessage in messages)
 {
-    if (!string.IsNullOrEmpty(contentItem.ImageFileId))
+    foreach (MessageContent content in threadMessage.ContentItems)
     {
-        OpenAIFileInfo imageInfo = await fileClient.GetFileAsync(contentItem.ImageFileId);
-        BinaryData imageBytes = await fileClient.DownloadFileAsync(contentItem.ImageFileId);
-        using FileStream stream = File.OpenWrite($"{imageInfo.Filename}.png");
-        imageBytes.ToStream().CopyTo(stream);
-
-        Console.WriteLine($"<image: {imageInfo.Filename}.png>");
+        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 = 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;
+        }
     }
 }
 ```
 
+5. Finally, we delete the thread and the agent to clean up the resources created in this sample.
+
+Synchronous sample:
+
+```C# Snippet:AgentsStreaming_Step5_Sync_Cleanup
+client.Threads.DeleteThread(threadId: thread.Id);
+client.Administration.DeleteAgent(agentId: agent.Id);
+```
+
+Asynchronous sample:
+
+```C# Snippet:AgentsStreaming_Step5_Async_Cleanup
+await client.Threads.DeleteThreadAsync(threadId: thread.Id);
+await client.Administration.DeleteAgentAsync(agentId: agent.Id);
+```
+
+
 :::zone-end
 
 :::zone pivot="javascript" 
@@ -470,4 +548,4 @@ curl $AZURE_AI_AGENTS_ENDPOINT/threads/thread_abc123/messages?api-version=2024-1
   -H "Authorization: Bearer $AZURE_AI_AGENTS_TOKEN"
 ```
 
-:::zone-end
+:::zone-end