test

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step01.1_Basics/FoundryAgents_Step01.1_Basics.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <NoWarn>$(NoWarn);IDE0059</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.AI.Projects" />
+    <PackageReference Include="Azure.Identity" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI\Microsoft.Agents.AI.AzureAI.csproj" />
+  </ItemGroup>
+
+</Project>

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step01.1_Basics/Program.cs

@@ -0,0 +1,48 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows how to create and use AI agents with Azure Foundry Agents as the backend.
+
+using Azure.AI.Projects;
+using Azure.AI.Projects.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+
+string endpoint = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_ENDPOINT") ?? throw new InvalidOperationException("AZURE_FOUNDRY_PROJECT_ENDPOINT is not set.");
+string deploymentName = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+const string JokerName = "JokerAgent";
+
+// Get a client to create/retrieve/delete server side agents with Azure Foundry Agents.
+AIProjectClient aiProjectClient = new(new Uri(endpoint), new AzureCliCredential());
+
+// Define the agent you want to create. (Prompt Agent in this case)
+AgentVersionCreationOptions options = new(new PromptAgentDefinition(model: deploymentName) { Instructions = "You are good at telling jokes." });
+
+// Azure.AI.Agents SDK creates and manages agent by name and versions.
+// You can create a server side agent version with the Azure.AI.Agents SDK client below.
+AgentVersion createdAgentVersion = aiProjectClient.Agents.CreateAgentVersion(agentName: JokerName, options);
+
+// Note:
+//      agentVersion.Id = "<agentName>:<versionNumber>",
+//      agentVersion.Version = <versionNumber>,
+//      agentVersion.Name = <agentName>
+
+// You can use an AIAgent with an already created server side agent version.
+AIAgent existingJokerAgent = aiProjectClient.AsAIAgent(createdAgentVersion);
+
+// You can also create another AIAgent version by providing the same name with a different definition/instruction.
+AIAgent newJokerAgent = await aiProjectClient.CreateAIAgentAsync(name: JokerName, model: deploymentName, instructions: "You are extremely hilarious at telling jokes.");
+
+// You can also get the AIAgent latest version by just providing its name.
+AIAgent jokerAgentLatest = await aiProjectClient.GetAIAgentAsync(name: JokerName);
+AgentVersion latestAgentVersion = jokerAgentLatest.GetService<AgentVersion>()!;
+
+// The AIAgent version can be accessed via the GetService method.
+Console.WriteLine($"Latest agent version id: {latestAgentVersion.Id}");
+
+// Once you have the AIAgent, you can invoke it like any other AIAgent.
+Console.WriteLine(await jokerAgentLatest.RunAsync("Tell me a joke about a pirate."));
+
+// Cleanup by agent name removes both agent versions created.
+await aiProjectClient.Agents.DeleteAgentAsync(existingJokerAgent.Name);

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step01.1_Basics/README.md

@@ -0,0 +1,40 @@
+# Creating and Managing AI Agents with Versioning
+
+This sample demonstrates how to create and manage AI agents with Azure Foundry Agents, including:
+- Creating agents with different versions
+- Retrieving agents by version or latest version
+- Running multi-turn conversations with agents
+- Managing agent lifecycle (creation and deletion)
+
+## Prerequisites
+
+Before you begin, ensure you have the following prerequisites:
+
+- .NET 10 SDK or later
+- Azure Foundry service endpoint and deployment configured
+- Azure CLI installed and authenticated (for Azure credential authentication)
+
+**Note**: This demo uses Azure CLI credentials for authentication. Make sure you're logged in with `az login` and have access to the Azure Foundry resource. For more information, see the [Azure CLI documentation](https://learn.microsoft.com/cli/azure/authenticate-azure-cli-interactively).
+
+Set the following environment variables:
+
+```powershell
+$env:AZURE_FOUNDRY_PROJECT_ENDPOINT="https://your-foundry-service.services.ai.azure.com/api/projects/your-foundry-project" # Replace with your Azure Foundry resource endpoint
+$env:AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME="gpt-4o-mini"  # Optional, defaults to gpt-4o-mini
+```
+
+## Run the sample
+
+Navigate to the FoundryAgents sample directory and run:
+
+```powershell
+cd dotnet/samples/GettingStarted/FoundryAgents
+dotnet run --project .\FoundryAgents_Step01.1_Basics
+```
+
+## What this sample demonstrates
+
+1. **Creating agents with versions**: Shows how to create multiple versions of the same agent with different instructions
+2. **Retrieving agents**: Demonstrates retrieving agents by specific version or getting the latest version
+3. **Multi-turn conversations**: Shows how to use threads to maintain conversation context across multiple agent runs
+4. **Agent cleanup**: Demonstrates proper resource cleanup by deleting agents

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step01.2_Running/FoundryAgents_Step01.2_Running.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.AI.Projects" />
+    <PackageReference Include="Azure.Identity" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI\Microsoft.Agents.AI.AzureAI.csproj" />
+  </ItemGroup>
+
+</Project>

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step01.2_Running/Program.cs

@@ -0,0 +1,36 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows how to create and use a simple AI agent with Azure Foundry Agents as the backend.
+
+using Azure.AI.Projects;
+using Azure.AI.Projects.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+
+string endpoint = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_ENDPOINT") ?? throw new InvalidOperationException("AZURE_FOUNDRY_PROJECT_ENDPOINT is not set.");
+string deploymentName = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+const string JokerInstructions = "You are good at telling jokes.";
+const string JokerName = "JokerAgent";
+
+// Get a client to create/retrieve/delete server side agents with Azure Foundry Agents.
+AIProjectClient aiProjectClient = new(new Uri(endpoint), new AzureCliCredential());
+
+// Define the agent you want to create. (Prompt Agent in this case)
+AgentVersionCreationOptions options = new(new PromptAgentDefinition(model: deploymentName) { Instructions = JokerInstructions });
+
+// Azure.AI.Agents SDK creates and manages agent by name and versions.
+// You can create a server side agent version with the Azure.AI.Agents SDK client below.
+AgentVersion agentVersion = aiProjectClient.Agents.CreateAgentVersion(agentName: JokerName, options);
+
+// You can use an AIAgent with an already created server side agent version.
+AIAgent jokerAgent = aiProjectClient.AsAIAgent(agentVersion);
+
+// Invoke the agent with streaming support.
+await foreach (AgentResponseUpdate update in jokerAgent.RunStreamingAsync("Tell me a joke about a pirate."))
+{
+    Console.WriteLine(update);
+}
+
+// Cleanup by agent name removes the agent version created.
+await aiProjectClient.Agents.DeleteAgentAsync(jokerAgent.Name);

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step01.2_Running/README.md

@@ -0,0 +1,46 @@
+# Running a Simple AI Agent with Streaming
+
+This sample demonstrates how to create and run a simple AI agent with Azure Foundry Agents, including both text and streaming responses.
+
+## What this sample demonstrates
+
+- Creating a simple AI agent with instructions
+- Running an agent with text output
+- Running an agent with streaming output
+- Managing agent lifecycle (creation and deletion)
+
+## Prerequisites
+
+Before you begin, ensure you have the following prerequisites:
+
+- .NET 10 SDK or later
+- Azure Foundry service endpoint and deployment configured
+- Azure CLI installed and authenticated (for Azure credential authentication)
+
+**Note**: This demo uses Azure CLI credentials for authentication. Make sure you're logged in with `az login` and have access to the Azure Foundry resource. For more information, see the [Azure CLI documentation](https://learn.microsoft.com/cli/azure/authenticate-azure-cli-interactively).
+
+Set the following environment variables:
+
+```powershell
+$env:AZURE_FOUNDRY_PROJECT_ENDPOINT="https://your-foundry-service.services.ai.azure.com/api/projects/your-foundry-project" # Replace with your Azure Foundry resource endpoint
+$env:AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME="gpt-4o-mini"  # Optional, defaults to gpt-4o-mini
+```
+
+## Run the sample
+
+Navigate to the FoundryAgents sample directory and run:
+
+```powershell
+cd dotnet/samples/GettingStarted/FoundryAgents
+dotnet run --project .\FoundryAgents_Step01.2_Running
+```
+
+## Expected behavior
+
+The sample will:
+
+1. Create an agent named "JokerAgent" with instructions to tell jokes
+2. Run the agent with a text prompt and display the response
+3. Run the agent again with streaming to display the response as it's generated
+4. Clean up resources by deleting the agent
+

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step02_MultiturnConversation/FoundryAgents_Step02_MultiturnConversation.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.AI.Projects" />
+    <PackageReference Include="Azure.Identity" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI\Microsoft.Agents.AI.AzureAI.csproj" />
+  </ItemGroup>
+
+</Project>

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step02_MultiturnConversation/Program.cs

@@ -0,0 +1,52 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows how to create and use a simple AI agent with a multi-turn conversation.
+
+using Azure.AI.Projects;
+using Azure.AI.Projects.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+
+string endpoint = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_ENDPOINT") ?? throw new InvalidOperationException("AZURE_FOUNDRY_PROJECT_ENDPOINT is not set.");
+string deploymentName = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+const string JokerInstructions = "You are good at telling jokes.";
+const string JokerName = "JokerAgent";
+
+// Get a client to create/retrieve/delete server side agents with Azure Foundry Agents.
+AIProjectClient aiProjectClient = new(new Uri(endpoint), new AzureCliCredential());
+
+// Define the agent you want to create. (Prompt Agent in this case)
+AgentVersionCreationOptions options = new(new PromptAgentDefinition(model: deploymentName) { Instructions = JokerInstructions });
+
+// Retrieve an AIAgent for the created server side agent version.
+ChatClientAgent jokerAgent = await aiProjectClient.CreateAIAgentAsync(name: JokerName, options);
+
+// Invoke the agent with a multi-turn conversation, where the context is preserved in the thread object.
+// Create a conversation in the server
+ProjectConversationsClient conversationsClient = aiProjectClient.GetProjectOpenAIClient().GetProjectConversationsClient();
+ProjectConversation conversation = await conversationsClient.CreateProjectConversationAsync();
+
+// Providing the conversation Id is not strictly necessary, but by not providing it no information will show up in the Foundry Project UI as conversations.
+// Threads that doesn't have a conversation Id will work based on the `PreviousResponseId`.
+AgentThread thread = await jokerAgent.GetNewThreadAsync(conversation.Id);
+
+Console.WriteLine(await jokerAgent.RunAsync("Tell me a joke about a pirate.", thread));
+Console.WriteLine(await jokerAgent.RunAsync("Now add some emojis to the joke and tell it in the voice of a pirate's parrot.", thread));
+
+// Invoke the agent with a multi-turn conversation and streaming, where the context is preserved in the thread object.
+thread = await jokerAgent.GetNewThreadAsync(conversation.Id);
+await foreach (AgentResponseUpdate update in jokerAgent.RunStreamingAsync("Tell me a joke about a pirate.", thread))
+{
+    Console.WriteLine(update);
+}
+await foreach (AgentResponseUpdate update in jokerAgent.RunStreamingAsync("Now add some emojis to the joke and tell it in the voice of a pirate's parrot.", thread))
+{
+    Console.WriteLine(update);
+}
+
+// Cleanup by agent name removes the agent version created.
+await aiProjectClient.Agents.DeleteAgentAsync(jokerAgent.Name);
+
+// Cleanup the conversation created.
+await conversationsClient.DeleteConversationAsync(conversation.Id);

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step02_MultiturnConversation/README.md

@@ -0,0 +1,59 @@
+# Multi-turn Conversation with AI Agents
+
+This sample demonstrates how to implement multi-turn conversations with AI agents, where context is preserved across multiple agent runs using threads and conversation IDs.
+
+## What this sample demonstrates
+
+- Creating an AI agent with instructions
+- Creating a project conversation to track conversations in the Foundry UI
+- Using threads with conversation IDs to maintain conversation context
+- Running multi-turn conversations with text output
+- Running multi-turn conversations with streaming output
+- Managing agent and conversation lifecycle (creation and deletion)
+
+## Prerequisites
+
+Before you begin, ensure you have the following prerequisites:
+
+- .NET 10 SDK or later
+- Azure Foundry service endpoint and deployment configured
+- Azure CLI installed and authenticated (for Azure credential authentication)
+
+**Note**: This demo uses Azure CLI credentials for authentication. Make sure you're logged in with `az login` and have access to the Azure Foundry resource. For more information, see the [Azure CLI documentation](https://learn.microsoft.com/cli/azure/authenticate-azure-cli-interactively).
+
+Set the following environment variables:
+
+```powershell
+$env:AZURE_FOUNDRY_PROJECT_ENDPOINT="https://your-foundry-service.services.ai.azure.com/api/projects/your-foundry-project" # Replace with your Azure Foundry resource endpoint
+$env:AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME="gpt-4o-mini"  # Optional, defaults to gpt-4o-mini
+```
+
+## Run the sample
+
+Navigate to the FoundryAgents sample directory and run:
+
+```powershell
+cd dotnet/samples/GettingStarted/FoundryAgents
+dotnet run --project .\FoundryAgents_Step02_MultiturnConversation
+```
+
+## Expected behavior
+
+The sample will:
+
+1. Create an agent named "JokerAgent" with instructions to tell jokes
+2. Create a project conversation to enable visibility in the Azure Foundry UI
+3. Create a thread linked to the conversation ID for context tracking
+4. Run the agent with a text prompt and display the response
+5. Send a follow-up message to the same thread, demonstrating context preservation
+6. Create a new thread sharing the same conversation ID and run the agent with streaming
+7. Send a follow-up streaming message to demonstrate multi-turn streaming
+8. Clean up resources by deleting the agent and conversation
+
+## Conversation ID vs PreviousResponseId
+
+When working with multi-turn conversations, there are two approaches:
+
+- **With Conversation ID**: By passing a `conversation.Id` to `GetNewThreadAsync()`, the conversation will be visible in the Azure Foundry Project UI. This is useful for tracking and debugging conversations.
+- **Without Conversation ID**: Threads created without a conversation ID still work correctly, maintaining context via `PreviousResponseId`. However, these conversations may not appear in the Foundry UI.
+

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step03_UsingFunctionTools/FoundryAgents_Step03_UsingFunctionTools.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.AI.Projects" />
+    <PackageReference Include="Azure.Identity" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI\Microsoft.Agents.AI.AzureAI.csproj" />
+  </ItemGroup>
+
+</Project>

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step03_UsingFunctionTools/Program.cs

@@ -0,0 +1,51 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample demonstrates how to use an agent with function tools.
+// It shows both non-streaming and streaming agent interactions using weather-related tools.
+
+using System.ComponentModel;
+using Azure.AI.Projects;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+
+string endpoint = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_ENDPOINT") ?? throw new InvalidOperationException("AZURE_FOUNDRY_PROJECT_ENDPOINT is not set.");
+string deploymentName = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+[Description("Get the weather for a given location.")]
+static string GetWeather([Description("The location to get the weather for.")] string location)
+    => $"The weather in {location} is cloudy with a high of 15°C.";
+
+const string AssistantInstructions = "You are a helpful assistant that can get weather information.";
+const string AssistantName = "WeatherAssistant";
+
+// Get a client to create/retrieve/delete server side agents with Azure Foundry Agents.
+AIProjectClient aiProjectClient = new(new Uri(endpoint), new AzureCliCredential());
+
+// Define the agent with function tools.
+AITool tool = AIFunctionFactory.Create(GetWeather);
+
+// Create AIAgent directly
+var newAgent = await aiProjectClient.CreateAIAgentAsync(name: AssistantName, model: deploymentName, instructions: AssistantInstructions, tools: [tool]);
+
+// Getting an already existing agent by name with tools.
+/* 
+ * IMPORTANT: Since agents that are stored in the server only know the definition of the function tools (JSON Schema),
+ * you need to provided all invocable function tools when retrieving the agent so it can invoke them automatically.
+ * If no invocable tools are provided, the function calling needs to handled manually.
+ */
+var existingAgent = await aiProjectClient.GetAIAgentAsync(name: AssistantName, tools: [tool]);
+
+// Non-streaming agent interaction with function tools.
+AgentThread thread = await existingAgent.GetNewThreadAsync();
+Console.WriteLine(await existingAgent.RunAsync("What is the weather like in Amsterdam?", thread));
+
+// Streaming agent interaction with function tools.
+thread = await existingAgent.GetNewThreadAsync();
+await foreach (AgentResponseUpdate update in existingAgent.RunStreamingAsync("What is the weather like in Amsterdam?", thread))
+{
+    Console.WriteLine(update);
+}
+
+// Cleanup by agent name removes the agent version created.
+await aiProjectClient.Agents.DeleteAgentAsync(existingAgent.Name);

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step03_UsingFunctionTools/README.md

@@ -0,0 +1,48 @@
+# Using Function Tools with AI Agents
+
+This sample demonstrates how to use function tools with AI agents, allowing agents to call custom functions to retrieve information.
+
+## What this sample demonstrates
+
+- Creating function tools using AIFunctionFactory
+- Passing function tools to an AI agent
+- Running agents with function tools (text output)
+- Running agents with function tools (streaming output)
+- Managing agent lifecycle (creation and deletion)
+
+## Prerequisites
+
+Before you begin, ensure you have the following prerequisites:
+
+- .NET 10 SDK or later
+- Azure Foundry service endpoint and deployment configured
+- Azure CLI installed and authenticated (for Azure credential authentication)
+
+**Note**: This demo uses Azure CLI credentials for authentication. Make sure you're logged in with `az login` and have access to the Azure Foundry resource. For more information, see the [Azure CLI documentation](https://learn.microsoft.com/cli/azure/authenticate-azure-cli-interactively).
+
+Set the following environment variables:
+
+```powershell
+$env:AZURE_FOUNDRY_PROJECT_ENDPOINT="https://your-foundry-service.services.ai.azure.com/api/projects/your-foundry-project" # Replace with your Azure Foundry resource endpoint
+$env:AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME="gpt-4o-mini"  # Optional, defaults to gpt-4o-mini
+```
+
+## Run the sample
+
+Navigate to the FoundryAgents sample directory and run:
+
+```powershell
+cd dotnet/samples/GettingStarted/FoundryAgents
+dotnet run --project .\FoundryAgents_Step03.1_UsingFunctionTools
+```
+
+## Expected behavior
+
+The sample will:
+
+1. Create an agent named "WeatherAssistant" with a GetWeather function tool
+2. Run the agent with a text prompt asking about weather
+3. The agent will invoke the GetWeather function tool to retrieve weather information
+4. Run the agent again with streaming to display the response as it's generated
+5. Clean up resources by deleting the agent
+

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step04_UsingFunctionToolsWithApprovals/FoundryAgents_Step04_UsingFunctionToolsWithApprovals.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.AI.Projects" />
+    <PackageReference Include="Azure.Identity" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI\Microsoft.Agents.AI.AzureAI.csproj" />
+  </ItemGroup>
+
+</Project>

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step04_UsingFunctionToolsWithApprovals/Program.cs

@@ -0,0 +1,64 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample demonstrates how to use an agent with function tools that require a human in the loop for approvals.
+// It shows both non-streaming and streaming agent interactions using weather-related tools.
+// If the agent is hosted in a service, with a remote user, combine this sample with the Persisted Conversations sample to persist the chat history
+// while the agent is waiting for user input.
+
+using System.ComponentModel;
+using Azure.AI.Projects;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+
+string endpoint = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_ENDPOINT") ?? throw new InvalidOperationException("AZURE_FOUNDRY_PROJECT_ENDPOINT is not set.");
+string deploymentName = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+// Create a sample function tool that the agent can use.
+[Description("Get the weather for a given location.")]
+static string GetWeather([Description("The location to get the weather for.")] string location)
+    => $"The weather in {location} is cloudy with a high of 15°C.";
+
+const string AssistantInstructions = "You are a helpful assistant that can get weather information.";
+const string AssistantName = "WeatherAssistant";
+
+// Get a client to create/retrieve/delete server side agents with Azure Foundry Agents.
+AIProjectClient aiProjectClient = new(new Uri(endpoint), new AzureCliCredential());
+
+ApprovalRequiredAIFunction approvalTool = new(AIFunctionFactory.Create(GetWeather, name: nameof(GetWeather)));
+
+// Create AIAgent directly
+AIAgent agent = await aiProjectClient.CreateAIAgentAsync(name: AssistantName, model: deploymentName, instructions: AssistantInstructions, tools: [approvalTool]);
+
+// Call the agent with approval-required function tools.
+// The agent will request approval before invoking the function.
+AgentThread thread = await agent.GetNewThreadAsync();
+AgentResponse response = await agent.RunAsync("What is the weather like in Amsterdam?", thread);
+
+// Check if there are any user input requests (approvals needed).
+List<UserInputRequestContent> userInputRequests = response.UserInputRequests.ToList();
+
+while (userInputRequests.Count > 0)
+{
+    // Ask the user to approve each function call request.
+    // For simplicity, we are assuming here that only function approval requests are being made.
+    List<ChatMessage> userInputMessages = userInputRequests
+        .OfType<FunctionApprovalRequestContent>()
+        .Select(functionApprovalRequest =>
+        {
+            Console.WriteLine($"The agent would like to invoke the following function, please reply Y to approve: Name {functionApprovalRequest.FunctionCall.Name}");
+            bool approved = Console.ReadLine()?.Equals("Y", StringComparison.OrdinalIgnoreCase) ?? false;
+            return new ChatMessage(ChatRole.User, [functionApprovalRequest.CreateResponse(approved)]);
+        })
+        .ToList();
+
+    // Pass the user input responses back to the agent for further processing.
+    response = await agent.RunAsync(userInputMessages, thread);
+
+    userInputRequests = response.UserInputRequests.ToList();
+}
+
+Console.WriteLine($"\nAgent: {response}");
+
+// Cleanup by agent name removes the agent version created.
+await aiProjectClient.Agents.DeleteAgentAsync(agent.Name);

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step04_UsingFunctionToolsWithApprovals/README.md

@@ -0,0 +1,51 @@
+# Using Function Tools with Approvals (Human-in-the-Loop)
+
+This sample demonstrates how to use function tools that require human approval before execution, implementing a human-in-the-loop workflow.
+
+## What this sample demonstrates
+
+- Creating approval-required function tools using ApprovalRequiredAIFunction
+- Handling user input requests for function approvals
+- Implementing human-in-the-loop approval workflows
+- Processing agent responses with pending approvals
+- Managing agent lifecycle (creation and deletion)
+
+## Prerequisites
+
+Before you begin, ensure you have the following prerequisites:
+
+- .NET 10 SDK or later
+- Azure Foundry service endpoint and deployment configured
+- Azure CLI installed and authenticated (for Azure credential authentication)
+
+**Note**: This demo uses Azure CLI credentials for authentication. Make sure you're logged in with `az login` and have access to the Azure Foundry resource. For more information, see the [Azure CLI documentation](https://learn.microsoft.com/cli/azure/authenticate-azure-cli-interactively).
+
+Set the following environment variables:
+
+```powershell
+$env:AZURE_FOUNDRY_PROJECT_ENDPOINT="https://your-foundry-service.services.ai.azure.com/api/projects/your-foundry-project" # Replace with your Azure Foundry resource endpoint
+$env:AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME="gpt-4o-mini"  # Optional, defaults to gpt-4o-mini
+```
+
+## Run the sample
+
+Navigate to the FoundryAgents sample directory and run:
+
+```powershell
+cd dotnet/samples/GettingStarted/FoundryAgents
+dotnet run --project .\FoundryAgents_Step04_UsingFunctionToolsWithApprovals
+```
+
+## Expected behavior
+
+The sample will:
+
+1. Create an agent named "WeatherAssistant" with an approval-required GetWeather function tool
+2. Run the agent with a prompt asking about weather
+3. The agent will request approval before invoking the GetWeather function
+4. The sample will prompt the user to approve or deny the function call (enter 'Y' to approve)
+5. After approval, the function will be executed and the result returned to the agent
+6. Clean up resources by deleting the agent
+
+**Note**: For hosted agents with remote users, combine this sample with the Persisted Conversations sample to persist chat history while waiting for user approval.
+

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step05_StructuredOutput/FoundryAgents_Step05_StructuredOutput.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.AI.Projects" />
+    <PackageReference Include="Azure.Identity" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI\Microsoft.Agents.AI.AzureAI.csproj" />
+  </ItemGroup>
+
+</Project>

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step05_StructuredOutput/Program.cs

@@ -0,0 +1,91 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows how to configure an agent to produce structured output.
+
+using System.ComponentModel;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Azure.AI.Projects;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using SampleApp;
+
+#pragma warning disable CA5399
+
+string endpoint = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_ENDPOINT") ?? throw new InvalidOperationException("AZURE_FOUNDRY_PROJECT_ENDPOINT is not set.");
+string deploymentName = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+const string AssistantInstructions = "You are a helpful assistant that extracts structured information about people.";
+const string AssistantName = "StructuredOutputAssistant";
+
+// Get a client to create/retrieve/delete server side agents with Azure Foundry Agents.
+AIProjectClient aiProjectClient = new(new Uri(endpoint), new AzureCliCredential());
+
+// Create ChatClientAgent directly
+ChatClientAgent agent = await aiProjectClient.CreateAIAgentAsync(
+    model: deploymentName,
+    new ChatClientAgentOptions()
+    {
+        Name = AssistantName,
+        ChatOptions = new()
+        {
+            Instructions = AssistantInstructions,
+            ResponseFormat = Microsoft.Extensions.AI.ChatResponseFormat.ForJsonSchema<PersonInfo>()
+        }
+    });
+
+// Set PersonInfo as the type parameter of RunAsync method to specify the expected structured output from the agent and invoke the agent with some unstructured input.
+AgentResponse<PersonInfo> response = await agent.RunAsync<PersonInfo>("Please provide information about John Smith, who is a 35-year-old software engineer.");
+
+// Access the structured output via the Result property of the agent response.
+Console.WriteLine("Assistant Output:");
+Console.WriteLine($"Name: {response.Result.Name}");
+Console.WriteLine($"Age: {response.Result.Age}");
+Console.WriteLine($"Occupation: {response.Result.Occupation}");
+
+// Create the ChatClientAgent with the specified name, instructions, and expected structured output the agent should produce.
+ChatClientAgent agentWithPersonInfo = await aiProjectClient.CreateAIAgentAsync(
+    model: deploymentName,
+    new ChatClientAgentOptions()
+    {
+        Name = AssistantName,
+        ChatOptions = new()
+        {
+            Instructions = AssistantInstructions,
+            ResponseFormat = Microsoft.Extensions.AI.ChatResponseFormat.ForJsonSchema<PersonInfo>()
+        }
+    });
+
+// Invoke the agent with some unstructured input while streaming, to extract the structured information from.
+IAsyncEnumerable<AgentResponseUpdate> updates = agentWithPersonInfo.RunStreamingAsync("Please provide information about John Smith, who is a 35-year-old software engineer.");
+
+// Assemble all the parts of the streamed output, since we can only deserialize once we have the full json,
+// then deserialize the response into the PersonInfo class.
+PersonInfo personInfo = (await updates.ToAgentResponseAsync()).Deserialize<PersonInfo>(JsonSerializerOptions.Web);
+
+Console.WriteLine("Assistant Output:");
+Console.WriteLine($"Name: {personInfo.Name}");
+Console.WriteLine($"Age: {personInfo.Age}");
+Console.WriteLine($"Occupation: {personInfo.Occupation}");
+
+// Cleanup by agent name removes the agent version created.
+await aiProjectClient.Agents.DeleteAgentAsync(agent.Name);
+
+namespace SampleApp
+{
+    /// <summary>
+    /// Represents information about a person, including their name, age, and occupation, matched to the JSON schema used in the agent.
+    /// </summary>
+    [Description("Information about a person including their name, age, and occupation")]
+    public class PersonInfo
+    {
+        [JsonPropertyName("name")]
+        public string? Name { get; set; }
+
+        [JsonPropertyName("age")]
+        public int? Age { get; set; }
+
+        [JsonPropertyName("occupation")]
+        public string? Occupation { get; set; }
+    }
+}

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step05_StructuredOutput/README.md

@@ -0,0 +1,49 @@
+# Structured Output with AI Agents
+
+This sample demonstrates how to configure AI agents to produce structured output in JSON format using JSON schemas.
+
+## What this sample demonstrates
+
+- Configuring agents with JSON schema response formats
+- Using generic RunAsync<T> method for structured output
+- Deserializing structured responses into typed objects
+- Running agents with streaming and structured output
+- Managing agent lifecycle (creation and deletion)
+
+## Prerequisites
+
+Before you begin, ensure you have the following prerequisites:
+
+- .NET 10 SDK or later
+- Azure Foundry service endpoint and deployment configured
+- Azure CLI installed and authenticated (for Azure credential authentication)
+
+**Note**: This demo uses Azure CLI credentials for authentication. Make sure you're logged in with `az login` and have access to the Azure Foundry resource. For more information, see the [Azure CLI documentation](https://learn.microsoft.com/cli/azure/authenticate-azure-cli-interactively).
+
+Set the following environment variables:
+
+```powershell
+$env:AZURE_FOUNDRY_PROJECT_ENDPOINT="https://your-foundry-service.services.ai.azure.com/api/projects/your-foundry-project" # Replace with your Azure Foundry resource endpoint
+$env:AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME="gpt-4o-mini"  # Optional, defaults to gpt-4o-mini
+```
+
+## Run the sample
+
+Navigate to the FoundryAgents sample directory and run:
+
+```powershell
+cd dotnet/samples/GettingStarted/FoundryAgents
+dotnet run --project .\FoundryAgents_Step05_StructuredOutput
+```
+
+## Expected behavior
+
+The sample will:
+
+1. Create an agent named "StructuredOutputAssistant" configured to produce JSON output
+2. Run the agent with a prompt to extract person information
+3. Deserialize the JSON response into a PersonInfo object
+4. Display the structured data (Name, Age, Occupation)
+5. Run the agent again with streaming and deserialize the streamed JSON response
+6. Clean up resources by deleting the agent
+

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step06_PersistedConversations/FoundryAgents_Step06_PersistedConversations.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.AI.Projects" />
+    <PackageReference Include="Azure.Identity" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI\Microsoft.Agents.AI.AzureAI.csproj" />
+  </ItemGroup>
+
+</Project>

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step06_PersistedConversations/Program.cs

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows how to create and use a simple AI agent with a conversation that can be persisted to disk.
+
+using System.Text.Json;
+using Azure.AI.Projects;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+
+string endpoint = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_ENDPOINT") ?? throw new InvalidOperationException("AZURE_FOUNDRY_PROJECT_ENDPOINT is not set.");
+string deploymentName = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+const string JokerInstructions = "You are good at telling jokes.";
+const string JokerName = "JokerAgent";
+
+// Get a client to create/retrieve/delete server side agents with Azure Foundry Agents.
+AIProjectClient aiProjectClient = new(new Uri(endpoint), new AzureCliCredential());
+
+AIAgent agent = await aiProjectClient.CreateAIAgentAsync(name: JokerName, model: deploymentName, instructions: JokerInstructions);
+
+// Start a new thread for the agent conversation.
+AgentThread thread = await agent.GetNewThreadAsync();
+
+// Run the agent with a new thread.
+Console.WriteLine(await agent.RunAsync("Tell me a joke about a pirate.", thread));
+
+// Serialize the thread state to a JsonElement, so it can be stored for later use.
+JsonElement serializedThread = thread.Serialize();
+
+// Save the serialized thread to a temporary file (for demonstration purposes).
+string tempFilePath = Path.GetTempFileName();
+await File.WriteAllTextAsync(tempFilePath, JsonSerializer.Serialize(serializedThread));
+
+// Load the serialized thread from the temporary file (for demonstration purposes).
+JsonElement reloadedSerializedThread = JsonElement.Parse(await File.ReadAllTextAsync(tempFilePath))!;
+
+// Deserialize the thread state after loading from storage.
+AgentThread resumedThread = await agent.DeserializeThreadAsync(reloadedSerializedThread);
+
+// Run the agent again with the resumed thread.
+Console.WriteLine(await agent.RunAsync("Now tell the same joke in the voice of a pirate, and add some emojis to the joke.", resumedThread));
+
+// Cleanup by agent name removes the agent version created.
+await aiProjectClient.Agents.DeleteAgentAsync(agent.Name);

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step06_PersistedConversations/README.md

@@ -0,0 +1,50 @@
+# Persisted Conversations with AI Agents
+
+This sample demonstrates how to serialize and persist agent conversation threads to storage, allowing conversations to be resumed later.
+
+## What this sample demonstrates
+
+- Serializing agent threads to JSON
+- Persisting thread state to disk
+- Loading and deserializing thread state from storage
+- Resuming conversations with persisted threads
+- Managing agent lifecycle (creation and deletion)
+
+## Prerequisites
+
+Before you begin, ensure you have the following prerequisites:
+
+- .NET 10 SDK or later
+- Azure Foundry service endpoint and deployment configured
+- Azure CLI installed and authenticated (for Azure credential authentication)
+
+**Note**: This demo uses Azure CLI credentials for authentication. Make sure you're logged in with `az login` and have access to the Azure Foundry resource. For more information, see the [Azure CLI documentation](https://learn.microsoft.com/cli/azure/authenticate-azure-cli-interactively).
+
+Set the following environment variables:
+
+```powershell
+$env:AZURE_FOUNDRY_PROJECT_ENDPOINT="https://your-foundry-service.services.ai.azure.com/api/projects/your-foundry-project" # Replace with your Azure Foundry resource endpoint
+$env:AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME="gpt-4o-mini"  # Optional, defaults to gpt-4o-mini
+```
+
+## Run the sample
+
+Navigate to the FoundryAgents sample directory and run:
+
+```powershell
+cd dotnet/samples/GettingStarted/FoundryAgents
+dotnet run --project .\FoundryAgents_Step06_PersistedConversations
+```
+
+## Expected behavior
+
+The sample will:
+
+1. Create an agent named "JokerAgent" with instructions to tell jokes
+2. Create a thread and run the agent with an initial prompt
+3. Serialize the thread state to JSON
+4. Save the serialized thread to a temporary file
+5. Load the thread from the file and deserialize it
+6. Resume the conversation with the same thread using a follow-up prompt
+7. Clean up resources by deleting the agent
+

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step07_Observability/FoundryAgents_Step07_Observability.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.AI.Projects" />
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Azure.Monitor.OpenTelemetry.Exporter" />
+    <PackageReference Include="OpenTelemetry" />
+    <PackageReference Include="OpenTelemetry.Exporter.Console" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI\Microsoft.Agents.AI.AzureAI.csproj" />
+  </ItemGroup>
+
+</Project>

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step07_Observability/Program.cs

@@ -0,0 +1,52 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows how to create and use a simple AI agent with Azure Foundry Agents as the backend that logs telemetry using OpenTelemetry.
+
+using Azure.AI.Projects;
+using Azure.Identity;
+using Azure.Monitor.OpenTelemetry.Exporter;
+using Microsoft.Agents.AI;
+using OpenTelemetry;
+using OpenTelemetry.Trace;
+
+string endpoint = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_ENDPOINT") ?? throw new InvalidOperationException("AZURE_FOUNDRY_PROJECT_ENDPOINT is not set.");
+string deploymentName = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+string? applicationInsightsConnectionString = Environment.GetEnvironmentVariable("APPLICATIONINSIGHTS_CONNECTION_STRING");
+
+const string JokerInstructions = "You are good at telling jokes.";
+const string JokerName = "JokerAgent";
+
+// Create TracerProvider with console exporter
+// This will output the telemetry data to the console.
+string sourceName = Guid.NewGuid().ToString("N");
+TracerProviderBuilder tracerProviderBuilder = Sdk.CreateTracerProviderBuilder()
+    .AddSource(sourceName)
+    .AddConsoleExporter();
+if (!string.IsNullOrWhiteSpace(applicationInsightsConnectionString))
+{
+    tracerProviderBuilder.AddAzureMonitorTraceExporter(options => options.ConnectionString = applicationInsightsConnectionString);
+}
+using var tracerProvider = tracerProviderBuilder.Build();
+
+// Get a client to create/retrieve/delete server side agents with Azure Foundry Agents.
+AIProjectClient aiProjectClient = new(new Uri(endpoint), new AzureCliCredential());
+
+// Define the agent you want to create. (Prompt Agent in this case)
+AIAgent agent = (await aiProjectClient.CreateAIAgentAsync(name: JokerName, model: deploymentName, instructions: JokerInstructions))
+    .AsBuilder()
+    .UseOpenTelemetry(sourceName: sourceName)
+    .Build();
+
+// Invoke the agent and output the text result.
+AgentThread thread = await agent.GetNewThreadAsync();
+Console.WriteLine(await agent.RunAsync("Tell me a joke about a pirate.", thread));
+
+// Invoke the agent with streaming support.
+thread = await agent.GetNewThreadAsync();
+await foreach (AgentResponseUpdate update in agent.RunStreamingAsync("Tell me a joke about a pirate.", thread))
+{
+    Console.WriteLine(update);
+}
+
+// Cleanup by agent name removes the agent version created.
+await aiProjectClient.Agents.DeleteAgentAsync(agent.Name);

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step07_Observability/README.md

@@ -0,0 +1,51 @@
+# Observability with OpenTelemetry
+
+This sample demonstrates how to add observability to AI agents using OpenTelemetry for tracing and monitoring.
+
+## What this sample demonstrates
+
+- Setting up OpenTelemetry TracerProvider
+- Configuring console exporter for telemetry output
+- Configuring Azure Monitor exporter for Application Insights
+- Adding OpenTelemetry middleware to agents
+- Running agents with telemetry collection (text and streaming)
+- Managing agent lifecycle (creation and deletion)
+
+## Prerequisites
+
+Before you begin, ensure you have the following prerequisites:
+
+- .NET 10 SDK or later
+- Azure Foundry service endpoint and deployment configured
+- Azure CLI installed and authenticated (for Azure credential authentication)
+- (Optional) Application Insights connection string for Azure Monitor integration
+
+**Note**: This demo uses Azure CLI credentials for authentication. Make sure you're logged in with `az login` and have access to the Azure Foundry resource. For more information, see the [Azure CLI documentation](https://learn.microsoft.com/cli/azure/authenticate-azure-cli-interactively).
+
+Set the following environment variables:
+
+```powershell
+$env:AZURE_FOUNDRY_PROJECT_ENDPOINT="https://your-foundry-service.services.ai.azure.com/api/projects/your-foundry-project" # Replace with your Azure Foundry resource endpoint
+$env:AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME="gpt-4o-mini"  # Optional, defaults to gpt-4o-mini
+$env:APPLICATIONINSIGHTS_CONNECTION_STRING="your-connection-string"  # Optional, for Azure Monitor integration
+```
+
+## Run the sample
+
+Navigate to the FoundryAgents sample directory and run:
+
+```powershell
+cd dotnet/samples/GettingStarted/FoundryAgents
+dotnet run --project .\FoundryAgents_Step07_Observability
+```
+
+## Expected behavior
+
+The sample will:
+
+1. Create a TracerProvider with console exporter (and optionally Azure Monitor exporter)
+2. Create an agent named "JokerAgent" with OpenTelemetry middleware
+3. Run the agent with a text prompt and display telemetry traces to console
+4. Run the agent again with streaming and display telemetry traces
+5. Clean up resources by deleting the agent
+

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step08_DependencyInjection/FoundryAgents_Step08_DependencyInjection.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+
+    <NoWarn>$(NoWarn);CA1812</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.AI.Projects" />
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI\Microsoft.Agents.AI.AzureAI.csproj" />
+  </ItemGroup>
+
+</Project>

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step08_DependencyInjection/Program.cs

@@ -0,0 +1,94 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows how to use dependency injection to register an AIAgent and use it from a hosted service with a user input chat loop.
+
+using System.ClientModel;
+using Azure.AI.Projects;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+
+string endpoint = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_ENDPOINT") ?? throw new InvalidOperationException("AZURE_FOUNDRY_PROJECT_ENDPOINT is not set.");
+string deploymentName = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+const string JokerInstructions = "You are good at telling jokes.";
+const string JokerName = "JokerAgent";
+
+AIProjectClient aIProjectClient = new(new Uri(endpoint), new AzureCliCredential());
+
+// Create a new agent if one doesn't exist already.
+ChatClientAgent agent;
+try
+{
+    agent = await aIProjectClient.GetAIAgentAsync(name: JokerName);
+}
+catch (ClientResultException ex) when (ex.Status == 404)
+{
+    agent = await aIProjectClient.CreateAIAgentAsync(name: JokerName, model: deploymentName, instructions: JokerInstructions);
+}
+
+// Create a host builder that we will register services with and then run.
+HostApplicationBuilder builder = Host.CreateApplicationBuilder(args);
+
+// Add the agents client to the service collection.
+builder.Services.AddSingleton((sp) => aIProjectClient);
+
+// Add the AI agent to the service collection.
+builder.Services.AddSingleton<AIAgent>((sp) => agent);
+
+// Add a sample service that will use the agent to respond to user input.
+builder.Services.AddHostedService<SampleService>();
+
+// Build and run the host.
+using IHost host = builder.Build();
+await host.RunAsync().ConfigureAwait(false);
+
+/// <summary>
+/// A sample service that uses an AI agent to respond to user input.
+/// </summary>
+internal sealed class SampleService(AIProjectClient client, AIAgent agent, IHostApplicationLifetime appLifetime) : IHostedService
+{
+    private AgentThread? _thread;
+
+    public async Task StartAsync(CancellationToken cancellationToken)
+    {
+        // Create a thread that will be used for the entirety of the service lifetime so that the user can ask follow up questions.
+        this._thread = await agent.GetNewThreadAsync(cancellationToken);
+        _ = this.RunAsync(appLifetime.ApplicationStopping);
+    }
+
+    public async Task RunAsync(CancellationToken cancellationToken)
+    {
+        // Delay a little to allow the service to finish starting.
+        await Task.Delay(100, cancellationToken);
+
+        while (!cancellationToken.IsCancellationRequested)
+        {
+            Console.WriteLine("\nAgent: Ask me to tell you a joke about a specific topic. To exit just press Ctrl+C or enter without any input.\n");
+            Console.Write("> ");
+            string? input = Console.ReadLine();
+
+            // If the user enters no input, signal the application to shut down.
+            if (string.IsNullOrWhiteSpace(input))
+            {
+                appLifetime.StopApplication();
+                break;
+            }
+
+            // Stream the output to the console as it is generated.
+            await foreach (AgentResponseUpdate update in agent.RunStreamingAsync(input, this._thread, cancellationToken: cancellationToken))
+            {
+                Console.Write(update);
+            }
+
+            Console.WriteLine();
+        }
+    }
+
+    public async Task StopAsync(CancellationToken cancellationToken)
+    {
+        Console.WriteLine("\nDeleting agent ...");
+        await client.Agents.DeleteAgentAsync(agent.Name, cancellationToken).ConfigureAwait(false);
+    }
+}

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step08_DependencyInjection/README.md

@@ -0,0 +1,51 @@
+# Dependency Injection with AI Agents
+
+This sample demonstrates how to use dependency injection to register and manage AI agents within a hosted service application.
+
+## What this sample demonstrates
+
+- Setting up dependency injection with HostApplicationBuilder
+- Registering AIProjectClient as a singleton service
+- Registering AIAgent as a singleton service
+- Using agents in hosted services
+- Interactive chat loop with streaming responses
+- Managing agent lifecycle (creation and deletion)
+
+## Prerequisites
+
+Before you begin, ensure you have the following prerequisites:
+
+- .NET 10 SDK or later
+- Azure Foundry service endpoint and deployment configured
+- Azure CLI installed and authenticated (for Azure credential authentication)
+
+**Note**: This demo uses Azure CLI credentials for authentication. Make sure you're logged in with `az login` and have access to the Azure Foundry resource. For more information, see the [Azure CLI documentation](https://learn.microsoft.com/cli/azure/authenticate-azure-cli-interactively).
+
+Set the following environment variables:
+
+```powershell
+$env:AZURE_FOUNDRY_PROJECT_ENDPOINT="https://your-foundry-service.services.ai.azure.com/api/projects/your-foundry-project" # Replace with your Azure Foundry resource endpoint
+$env:AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME="gpt-4o-mini"  # Optional, defaults to gpt-4o-mini
+```
+
+## Run the sample
+
+Navigate to the FoundryAgents sample directory and run:
+
+```powershell
+cd dotnet/samples/GettingStarted/FoundryAgents
+dotnet run --project .\FoundryAgents_Step08_DependencyInjection
+```
+
+## Expected behavior
+
+The sample will:
+
+1. Create a host with dependency injection configured
+2. Register AIProjectClient and AIAgent as services
+3. Create an agent named "JokerAgent" with instructions to tell jokes
+4. Start an interactive chat loop where you can ask the agent questions
+5. The agent will respond with streaming output
+6. Enter an empty line or press Ctrl+C to exit
+7. Clean up resources by deleting the agent
+

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step09_UsingMcpClientAsTools/FoundryAgents_Step09_UsingMcpClientAsTools.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <UserSecretsId>3afc9b74-af74-4d8e-ae96-fa1c511d11ac</UserSecretsId>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.AI.Agents.Persistent" />
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" />
+    <PackageReference Include="ModelContextProtocol" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI\Microsoft.Agents.AI.AzureAI.csproj" />
+  </ItemGroup>
+  
+</Project>

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step09_UsingMcpClientAsTools/Program.cs

@@ -0,0 +1,47 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows how to expose an AI agent as an MCP tool.
+
+using Azure.AI.Projects;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+using ModelContextProtocol.Client;
+
+string endpoint = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_ENDPOINT") ?? throw new InvalidOperationException("AZURE_FOUNDRY_PROJECT_ENDPOINT is not set.");
+string deploymentName = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+Console.WriteLine("Starting MCP Stdio for @modelcontextprotocol/server-github ... ");
+
+// Create an MCPClient for the GitHub server
+await using var mcpClient = await McpClient.CreateAsync(new StdioClientTransport(new()
+{
+    Name = "MCPServer",
+    Command = "npx",
+    Arguments = ["-y", "--verbose", "@modelcontextprotocol/server-github"],
+}));
+
+// Retrieve the list of tools available on the GitHub server
+IList<McpClientTool> mcpTools = await mcpClient.ListToolsAsync();
+string agentName = "AgentWithMCP";
+// Get a client to create/retrieve/delete server side agents with Azure Foundry Agents.
+AIProjectClient aiProjectClient = new(new Uri(endpoint), new AzureCliCredential());
+
+Console.WriteLine($"Creating the agent '{agentName}' ...");
+
+// Define the agent you want to create. (Prompt Agent in this case)
+AIAgent agent = await aiProjectClient.CreateAIAgentAsync(
+    name: agentName,
+    model: deploymentName,
+    instructions: "You answer questions related to GitHub repositories only.",
+    tools: [.. mcpTools.Cast<AITool>()]);
+
+string prompt = "Summarize the last four commits to the microsoft/semantic-kernel repository?";
+
+Console.WriteLine($"Invoking agent '{agent.Name}' with prompt: {prompt} ...");
+
+// Invoke the agent and output the text result.
+Console.WriteLine(await agent.RunAsync(prompt));
+
+// Clean up the agent after use.
+await aiProjectClient.Agents.DeleteAgentAsync(agent.Name);

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step09_UsingMcpClientAsTools/README.md

@@ -0,0 +1,50 @@
+# Using MCP Client Tools with AI Agents
+
+This sample demonstrates how to use Model Context Protocol (MCP) client tools with AI agents, allowing agents to access tools provided by MCP servers. This sample uses the GitHub MCP server to provide tools for querying GitHub repositories.
+
+## What this sample demonstrates
+
+- Creating MCP clients to connect to MCP servers (GitHub server)
+- Retrieving tools from MCP servers
+- Using MCP tools with AI agents
+- Running agents with MCP-provided function tools
+- Managing agent lifecycle (creation and deletion)
+
+## Prerequisites
+
+Before you begin, ensure you have the following prerequisites:
+
+- .NET 10 SDK or later
+- Azure Foundry service endpoint and deployment configured
+- Azure CLI installed and authenticated (for Azure credential authentication)
+- Node.js and npm installed (for running the GitHub MCP server)
+
+**Note**: This demo uses Azure CLI credentials for authentication. Make sure you're logged in with `az login` and have access to the Azure Foundry resource. For more information, see the [Azure CLI documentation](https://learn.microsoft.com/cli/azure/authenticate-azure-cli-interactively).
+
+Set the following environment variables:
+
+```powershell
+$env:AZURE_FOUNDRY_PROJECT_ENDPOINT="https://your-foundry-service.services.ai.azure.com/api/projects/your-foundry-project" # Replace with your Azure Foundry resource endpoint
+$env:AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME="gpt-4o-mini"  # Optional, defaults to gpt-4o-mini
+```
+
+## Run the sample
+
+Navigate to the FoundryAgents sample directory and run:
+
+```powershell
+cd dotnet/samples/GettingStarted/FoundryAgents
+dotnet run --project .\FoundryAgents_Step09_UsingMcpClientAsTools
+```
+
+## Expected behavior
+
+The sample will:
+
+1. Start the GitHub MCP server using `@modelcontextprotocol/server-github`
+2. Create an MCP client to connect to the GitHub server
+3. Retrieve the available tools from the GitHub MCP server
+4. Create an agent named "AgentWithMCP" with the GitHub tools
+5. Run the agent with a prompt to summarize the last four commits to the microsoft/semantic-kernel repository
+6. The agent will use the GitHub MCP tools to query the repository information
+7. Clean up resources by deleting the agent

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step10_UsingImages/FoundryAgents_Step10_UsingImages.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.AI.Projects" />
+    <PackageReference Include="Azure.Identity" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI\Microsoft.Agents.AI.AzureAI.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="Assets\walkway.jpg">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+  
+</Project>

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step10_UsingImages/Program.cs

@@ -0,0 +1,35 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows how to use Image Multi-Modality with an AI agent.
+
+using Azure.AI.Projects;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+
+string endpoint = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_ENDPOINT") ?? throw new InvalidOperationException("AZURE_FOUNDRY_PROJECT_ENDPOINT is not set.");
+string deploymentName = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME") ?? "gpt-4o";
+
+const string VisionInstructions = "You are a helpful agent that can analyze images";
+const string VisionName = "VisionAgent";
+
+// Get a client to create/retrieve/delete server side agents with Azure Foundry Agents.
+AIProjectClient aiProjectClient = new(new Uri(endpoint), new AzureCliCredential());
+
+// Define the agent you want to create. (Prompt Agent in this case)
+AIAgent agent = await aiProjectClient.CreateAIAgentAsync(name: VisionName, model: deploymentName, instructions: VisionInstructions);
+
+ChatMessage message = new(ChatRole.User, [
+    new TextContent("What do you see in this image?"),
+    new DataContent(File.ReadAllBytes("assets/walkway.jpg"), "image/jpeg")
+]);
+
+AgentThread thread = await agent.GetNewThreadAsync();
+
+await foreach (AgentResponseUpdate update in agent.RunStreamingAsync(message, thread))
+{
+    Console.WriteLine(update);
+}
+
+// Cleanup by agent name removes the agent version created.
+await aiProjectClient.Agents.DeleteAgentAsync(agent.Name);

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step10_UsingImages/README.md

@@ -0,0 +1,53 @@
+# Using Images with AI Agents
+
+This sample demonstrates how to use image multi-modality with an AI agent. It shows how to create a vision-enabled agent that can analyze and describe images using Azure Foundry Agents.
+
+## What this sample demonstrates
+
+- Creating a vision-enabled AI agent with image analysis capabilities
+- Sending both text and image content to an agent in a single message
+- Using `UriContent` for URI-referenced images
+- Processing multimodal input (text + image) with an AI agent
+- Managing agent lifecycle (creation and deletion)
+
+## Key features
+
+- **Vision Agent**: Creates an agent specifically instructed to analyze images
+- **Multimodal Input**: Combines text questions with image URI in a single message
+- **Azure Foundry Agents Integration**: Uses Azure Foundry Agents with vision capabilities
+
+## Prerequisites
+
+Before running this sample, ensure you have:
+
+1. An Azure OpenAI project set up
+2. A compatible model deployment (e.g., gpt-4o)
+3. Azure CLI installed and authenticated
+
+## Environment Variables
+
+Set the following environment variables:
+
+```powershell
+$env:AZURE_FOUNDRY_PROJECT_ENDPOINT="https://your-resource.openai.azure.com/" # Replace with your Azure Foundry Project endpoint
+$env:AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME="gpt-4o" # Replace with your model deployment name (optional, defaults to gpt-4o)
+```
+
+## Run the sample
+
+Navigate to the FoundryAgents sample directory and run:
+
+```powershell
+cd dotnet/samples/GettingStarted/FoundryAgents
+dotnet run --project .\FoundryAgents_Step10_UsingImages
+```
+
+## Expected behavior
+
+The sample will:
+
+1. Create a vision-enabled agent named "VisionAgent"
+2. Send a message containing both text ("What do you see in this image?") and a URI-referenced image of a green walkway (nature boardwalk)
+3. The agent will analyze the image and provide a description
+4. Clean up resources by deleting the agent
+

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step11_AsFunctionTool/FoundryAgents_Step11_AsFunctionTool.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <UserSecretsId>3afc9b74-af74-4d8e-ae96-fa1c511d11ac</UserSecretsId>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.AI.Projects" />
+    <PackageReference Include="Azure.Identity" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI\Microsoft.Agents.AI.AzureAI.csproj" />
+  </ItemGroup>
+  
+</Project>

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step11_AsFunctionTool/Program.cs

@@ -0,0 +1,47 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows how to create and use an Azure Foundry Agents AI agent as a function tool.
+
+using System.ComponentModel;
+using Azure.AI.Projects;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+
+string endpoint = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_ENDPOINT") ?? throw new InvalidOperationException("AZURE_FOUNDRY_PROJECT_ENDPOINT is not set.");
+string deploymentName = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+const string WeatherInstructions = "You answer questions about the weather.";
+const string WeatherName = "WeatherAgent";
+const string MainInstructions = "You are a helpful assistant who responds in French.";
+const string MainName = "MainAgent";
+
+[Description("Get the weather for a given location.")]
+static string GetWeather([Description("The location to get the weather for.")] string location)
+    => $"The weather in {location} is cloudy with a high of 15°C.";
+
+// Get a client to create/retrieve/delete server side agents with Azure Foundry Agents.
+AIProjectClient aiProjectClient = new(new Uri(endpoint), new AzureCliCredential());
+
+// Create the weather agent with function tools.
+AITool weatherTool = AIFunctionFactory.Create(GetWeather);
+AIAgent weatherAgent = await aiProjectClient.CreateAIAgentAsync(
+    name: WeatherName,
+    model: deploymentName,
+    instructions: WeatherInstructions,
+    tools: [weatherTool]);
+
+// Create the main agent, and provide the weather agent as a function tool.
+AIAgent agent = await aiProjectClient.CreateAIAgentAsync(
+    name: MainName,
+    model: deploymentName,
+    instructions: MainInstructions,
+    tools: [weatherAgent.AsAIFunction()]);
+
+// Invoke the agent and output the text result.
+AgentThread thread = await agent.GetNewThreadAsync();
+Console.WriteLine(await agent.RunAsync("What is the weather like in Amsterdam?", thread));
+
+// Cleanup by agent name removes the agent versions created.
+await aiProjectClient.Agents.DeleteAgentAsync(agent.Name);
+await aiProjectClient.Agents.DeleteAgentAsync(weatherAgent.Name);

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step11_AsFunctionTool/README.md

@@ -0,0 +1,49 @@
+# Using AI Agents as Function Tools (Nested Agents)
+
+This sample demonstrates how to expose an AI agent as a function tool, enabling nested agent scenarios where one agent can invoke another agent as a tool.
+
+## What this sample demonstrates
+
+- Creating an AI agent that can be used as a function tool
+- Wrapping an agent as an AIFunction
+- Using nested agents where one agent calls another
+- Managing multiple agent instances
+- Managing agent lifecycle (creation and deletion)
+
+## Prerequisites
+
+Before you begin, ensure you have the following prerequisites:
+
+- .NET 10 SDK or later
+- Azure Foundry service endpoint and deployment configured
+- Azure CLI installed and authenticated (for Azure credential authentication)
+
+**Note**: This demo uses Azure CLI credentials for authentication. Make sure you're logged in with `az login` and have access to the Azure Foundry resource. For more information, see the [Azure CLI documentation](https://learn.microsoft.com/cli/azure/authenticate-azure-cli-interactively).
+
+Set the following environment variables:
+
+```powershell
+$env:AZURE_FOUNDRY_PROJECT_ENDPOINT="https://your-foundry-service.services.ai.azure.com/api/projects/your-foundry-project" # Replace with your Azure Foundry resource endpoint
+$env:AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME="gpt-4o-mini"  # Optional, defaults to gpt-4o-mini
+```
+
+## Run the sample
+
+Navigate to the FoundryAgents sample directory and run:
+
+```powershell
+cd dotnet/samples/GettingStarted/FoundryAgents
+dotnet run --project .\FoundryAgents_Step11_AsFunctionTool
+```
+
+## Expected behavior
+
+The sample will:
+
+1. Create a "JokerAgent" that tells jokes
+2. Wrap the JokerAgent as a function tool
+3. Create a "CoordinatorAgent" that has the JokerAgent as a function tool
+4. Run the CoordinatorAgent with a prompt that triggers it to call the JokerAgent
+5. The CoordinatorAgent will invoke the JokerAgent as a function tool
+6. Clean up resources by deleting both agents
+

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step12_Middleware/FoundryAgents_Step12_Middleware.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+    
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" />
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Azure.AI.Projects" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI\Microsoft.Agents.AI.AzureAI.csproj" />
+  </ItemGroup>
+
+</Project>

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step12_Middleware/Program.cs

@@ -0,0 +1,223 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows multiple middleware layers working together with Azure Foundry Agents:
+// agent run (PII filtering and guardrails),
+// function invocation (logging and result overrides), and human-in-the-loop
+// approval workflows for sensitive function calls.
+
+using System.ComponentModel;
+using System.Text.RegularExpressions;
+using Azure.AI.Projects;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+
+// Get Azure AI Foundry configuration from environment variables
+string endpoint = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_ENDPOINT") ?? throw new InvalidOperationException("AZURE_FOUNDRY_PROJECT_ENDPOINT is not set.");
+string deploymentName = System.Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME") ?? "gpt-4o";
+
+const string AssistantInstructions = "You are an AI assistant that helps people find information.";
+const string AssistantName = "InformationAssistant";
+
+// Get a client to create/retrieve/delete server side agents with Azure Foundry Agents.
+AIProjectClient aiProjectClient = new(new Uri(endpoint), new AzureCliCredential());
+
+[Description("Get the weather for a given location.")]
+static string GetWeather([Description("The location to get the weather for.")] string location)
+    => $"The weather in {location} is cloudy with a high of 15°C.";
+
+[Description("The current datetime offset.")]
+static string GetDateTime()
+    => DateTimeOffset.Now.ToString();
+
+AITool dateTimeTool = AIFunctionFactory.Create(GetDateTime, name: nameof(GetDateTime));
+AITool getWeatherTool = AIFunctionFactory.Create(GetWeather, name: nameof(GetWeather));
+
+// Define the agent you want to create. (Prompt Agent in this case)
+AIAgent originalAgent = await aiProjectClient.CreateAIAgentAsync(
+    name: AssistantName,
+    model: deploymentName,
+    instructions: AssistantInstructions,
+    tools: [getWeatherTool, dateTimeTool]);
+
+// Adding middleware to the agent level
+AIAgent middlewareEnabledAgent = originalAgent
+    .AsBuilder()
+    .Use(FunctionCallMiddleware)
+    .Use(FunctionCallOverrideWeather)
+    .Use(PIIMiddleware, null)
+    .Use(GuardrailMiddleware, null)
+    .Build();
+
+AgentThread thread = await middlewareEnabledAgent.GetNewThreadAsync();
+
+Console.WriteLine("\n\n=== Example 1: Wording Guardrail ===");
+AgentResponse guardRailedResponse = await middlewareEnabledAgent.RunAsync("Tell me something harmful.");
+Console.WriteLine($"Guard railed response: {guardRailedResponse}");
+
+Console.WriteLine("\n\n=== Example 2: PII detection ===");
+AgentResponse piiResponse = await middlewareEnabledAgent.RunAsync("My name is John Doe, call me at 123-456-7890 or email me at john@something.com");
+Console.WriteLine($"Pii filtered response: {piiResponse}");
+
+Console.WriteLine("\n\n=== Example 3: Agent function middleware ===");
+
+// Agent function middleware support is limited to agents that wraps a upstream ChatClientAgent or derived from it.
+
+AgentResponse functionCallResponse = await middlewareEnabledAgent.RunAsync("What's the current time and the weather in Seattle?", thread);
+Console.WriteLine($"Function calling response: {functionCallResponse}");
+
+// Special per-request middleware agent.
+Console.WriteLine("\n\n=== Example 4: Middleware with human in the loop function approval ===");
+
+AIAgent humanInTheLoopAgent = await aiProjectClient.CreateAIAgentAsync(
+    name: "HumanInTheLoopAgent",
+    model: deploymentName,
+    instructions: "You are an Human in the loop testing AI assistant that helps people find information.",
+
+    // Adding a function with approval required
+    tools: [new ApprovalRequiredAIFunction(AIFunctionFactory.Create(GetWeather, name: nameof(GetWeather)))]);
+
+// Using the ConsolePromptingApprovalMiddleware for a specific request to handle user approval during function calls.
+AgentResponse response = await humanInTheLoopAgent
+    .AsBuilder()
+    .Use(ConsolePromptingApprovalMiddleware, null)
+    .Build()
+    .RunAsync("What's the current time and the weather in Seattle?");
+
+Console.WriteLine($"HumanInTheLoopAgent agent middleware response: {response}");
+
+// Function invocation middleware that logs before and after function calls.
+async ValueTask<object?> FunctionCallMiddleware(AIAgent agent, FunctionInvocationContext context, Func<FunctionInvocationContext, CancellationToken, ValueTask<object?>> next, CancellationToken cancellationToken)
+{
+    Console.WriteLine($"Function Name: {context!.Function.Name} - Middleware 1 Pre-Invoke");
+    var result = await next(context, cancellationToken);
+    Console.WriteLine($"Function Name: {context!.Function.Name} - Middleware 1 Post-Invoke");
+
+    return result;
+}
+
+// Function invocation middleware that overrides the result of the GetWeather function.
+async ValueTask<object?> FunctionCallOverrideWeather(AIAgent agent, FunctionInvocationContext context, Func<FunctionInvocationContext, CancellationToken, ValueTask<object?>> next, CancellationToken cancellationToken)
+{
+    Console.WriteLine($"Function Name: {context!.Function.Name} - Middleware 2 Pre-Invoke");
+
+    var result = await next(context, cancellationToken);
+
+    if (context.Function.Name == nameof(GetWeather))
+    {
+        // Override the result of the GetWeather function
+        result = "The weather is sunny with a high of 25°C.";
+    }
+    Console.WriteLine($"Function Name: {context!.Function.Name} - Middleware 2 Post-Invoke");
+    return result;
+}
+
+// This middleware redacts PII information from input and output messages.
+async Task<AgentResponse> PIIMiddleware(IEnumerable<ChatMessage> messages, AgentThread? thread, AgentRunOptions? options, AIAgent innerAgent, CancellationToken cancellationToken)
+{
+    // Redact PII information from input messages
+    var filteredMessages = FilterMessages(messages);
+    Console.WriteLine("Pii Middleware - Filtered Messages Pre-Run");
+
+    var response = await innerAgent.RunAsync(filteredMessages, thread, options, cancellationToken).ConfigureAwait(false);
+
+    // Redact PII information from output messages
+    response.Messages = FilterMessages(response.Messages);
+
+    Console.WriteLine("Pii Middleware - Filtered Messages Post-Run");
+
+    return response;
+
+    static IList<ChatMessage> FilterMessages(IEnumerable<ChatMessage> messages)
+    {
+        return messages.Select(m => new ChatMessage(m.Role, FilterPii(m.Text))).ToList();
+    }
+
+    static string FilterPii(string content)
+    {
+        // Regex patterns for PII detection (simplified for demonstration)
+        Regex[] piiPatterns = [
+            new(@"\b\d{3}-\d{3}-\d{4}\b", RegexOptions.Compiled), // Phone number (e.g., 123-456-7890)
+                    new(@"\b[\w\.-]+@[\w\.-]+\.\w+\b", RegexOptions.Compiled), // Email address
+                    new(@"\b[A-Z][a-z]+\s[A-Z][a-z]+\b", RegexOptions.Compiled) // Full name (e.g., John Doe)
+        ];
+
+        foreach (var pattern in piiPatterns)
+        {
+            content = pattern.Replace(content, "[REDACTED: PII]");
+        }
+
+        return content;
+    }
+}
+
+// This middleware enforces guardrails by redacting certain keywords from input and output messages.
+async Task<AgentResponse> GuardrailMiddleware(IEnumerable<ChatMessage> messages, AgentThread? thread, AgentRunOptions? options, AIAgent innerAgent, CancellationToken cancellationToken)
+{
+    // Redact keywords from input messages
+    var filteredMessages = FilterMessages(messages);
+
+    Console.WriteLine("Guardrail Middleware - Filtered messages Pre-Run");
+
+    // Proceed with the agent run
+    var response = await innerAgent.RunAsync(filteredMessages, thread, options, cancellationToken);
+
+    // Redact keywords from output messages
+    response.Messages = FilterMessages(response.Messages);
+
+    Console.WriteLine("Guardrail Middleware - Filtered messages Post-Run");
+
+    return response;
+
+    List<ChatMessage> FilterMessages(IEnumerable<ChatMessage> messages)
+    {
+        return messages.Select(m => new ChatMessage(m.Role, FilterContent(m.Text))).ToList();
+    }
+
+    static string FilterContent(string content)
+    {
+        foreach (var keyword in new[] { "harmful", "illegal", "violence" })
+        {
+            if (content.Contains(keyword, StringComparison.OrdinalIgnoreCase))
+            {
+                return "[REDACTED: Forbidden content]";
+            }
+        }
+
+        return content;
+    }
+}
+
+// This middleware handles Human in the loop console interaction for any user approval required during function calling.
+async Task<AgentResponse> ConsolePromptingApprovalMiddleware(IEnumerable<ChatMessage> messages, AgentThread? thread, AgentRunOptions? options, AIAgent innerAgent, CancellationToken cancellationToken)
+{
+    AgentResponse response = await innerAgent.RunAsync(messages, thread, options, cancellationToken);
+
+    List<UserInputRequestContent> userInputRequests = response.UserInputRequests.ToList();
+
+    while (userInputRequests.Count > 0)
+    {
+        // Ask the user to approve each function call request.
+        // For simplicity, we are assuming here that only function approval requests are being made.
+
+        // Pass the user input responses back to the agent for further processing.
+        response.Messages = userInputRequests
+            .OfType<FunctionApprovalRequestContent>()
+            .Select(functionApprovalRequest =>
+            {
+                Console.WriteLine($"The agent would like to invoke the following function, please reply Y to approve: Name {functionApprovalRequest.FunctionCall.Name}");
+                bool approved = Console.ReadLine()?.Equals("Y", StringComparison.OrdinalIgnoreCase) ?? false;
+                return new ChatMessage(ChatRole.User, [functionApprovalRequest.CreateResponse(approved)]);
+            })
+            .ToList();
+
+        response = await innerAgent.RunAsync(response.Messages, thread, options, cancellationToken);
+
+        userInputRequests = response.UserInputRequests.ToList();
+    }
+
+    return response;
+}
+
+// Cleanup by agent name removes the agent version created.
+await aiProjectClient.Agents.DeleteAgentAsync(middlewareEnabledAgent.Name);

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step12_Middleware/README.md

@@ -0,0 +1,58 @@
+# Agent Middleware
+
+This sample demonstrates how to add middleware to intercept agent runs and function calls to implement cross-cutting concerns like logging, validation, and guardrails.
+
+## What This Sample Shows
+
+1. Azure Foundry Agents integration via `AIProjectClient` and `AzureCliCredential`
+2. Agent run middleware (logging and monitoring)
+3. Function invocation middleware (logging and overriding tool results)
+4. Per-request agent run middleware
+5. Per-request function pipeline with approval
+6. Combining agent-level and per-request middleware
+
+## Function Invocation Middleware
+
+Not all agents support function invocation middleware.
+
+Attempting to use function middleware on agents that do not wrap a ChatClientAgent or derives from it will throw an InvalidOperationException.
+
+## Prerequisites
+
+Before you begin, ensure you have the following prerequisites:
+
+- .NET 10 SDK or later
+- Azure Foundry service endpoint and deployment configured
+- Azure CLI installed and authenticated (for Azure credential authentication)
+
+**Note**: This demo uses Azure CLI credentials for authentication. Make sure you're logged in with `az login` and have access to the Azure Foundry resource. For more information, see the [Azure CLI documentation](https://learn.microsoft.com/cli/azure/authenticate-azure-cli-interactively).
+
+Set the following environment variables:
+
+```powershell
+$env:AZURE_FOUNDRY_PROJECT_ENDPOINT="https://your-foundry-service.services.ai.azure.com/api/projects/your-foundry-project" # Replace with your Azure Foundry resource endpoint
+$env:AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME="gpt-4o-mini"  # Optional, defaults to gpt-4o-mini
+```
+
+## Running the Sample
+
+Navigate to the FoundryAgents sample directory and run:
+
+```powershell
+cd dotnet/samples/GettingStarted/FoundryAgents
+dotnet run --project .\FoundryAgents_Step12_Middleware
+```
+
+## Expected Behavior
+
+When you run this sample, you will see the following demonstrations:
+
+1. **Example 1: Wording Guardrail** - The agent receives a request for harmful content. The guardrail middleware intercepts the request and prevents the agent from responding to harmful prompts, returning a safe response instead.
+
+2. **Example 2: PII Detection** - The agent receives a message containing personally identifiable information (name, phone number, email). The PII middleware detects and filters this sensitive information before processing.
+
+3. **Example 3: Agent Function Middleware** - The agent uses function tools (GetDateTime and GetWeather) to answer a question about the current time and weather in Seattle. The function middleware logs the function calls and can override results if needed.
+
+4. **Example 4: Human-in-the-Loop Function Approval** - The agent attempts to call a weather function, but the approval middleware intercepts the call and prompts the user to approve or deny the function invocation before it executes. The user can respond with "Y" to approve or any other input to deny.
+
+Each example demonstrates how middleware can be used to implement cross-cutting concerns and control agent behavior at different levels (agent-level and per-request).

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step13_Plugins/FoundryAgents_Step13_Plugins.csproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <NoWarn>$(NoWarn);CA1812</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" />
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Azure.AI.Projects" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI\Microsoft.Agents.AI.AzureAI.csproj" />
+  </ItemGroup>
+  
+</Project>

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step13_Plugins/Program.cs

@@ -0,0 +1,139 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows how to use plugins with an AI agent. Plugin classes can
+// depend on other services that need to be injected. In this sample, the
+// AgentPlugin class uses the WeatherProvider and CurrentTimeProvider classes
+// to get weather and current time information. Both services are registered
+// in the service collection and injected into the plugin.
+// Plugin classes may have many methods, but only some are intended to be used
+// as AI functions. The AsAITools method of the plugin class shows how to specify
+// which methods should be exposed to the AI agent.
+
+using Azure.AI.Projects;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+using Microsoft.Extensions.DependencyInjection;
+
+string endpoint = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_ENDPOINT") ?? throw new InvalidOperationException("AZURE_FOUNDRY_PROJECT_ENDPOINT is not set.");
+string deploymentName = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+const string AssistantInstructions = "You are a helpful assistant that helps people find information.";
+const string AssistantName = "PluginAssistant";
+
+// Create a service collection to hold the agent plugin and its dependencies.
+ServiceCollection services = new();
+services.AddSingleton<WeatherProvider>();
+services.AddSingleton<CurrentTimeProvider>();
+services.AddSingleton<AgentPlugin>(); // The plugin depends on WeatherProvider and CurrentTimeProvider registered above.
+
+IServiceProvider serviceProvider = services.BuildServiceProvider();
+
+// Get a client to create/retrieve/delete server side agents with Azure Foundry Agents.
+AIProjectClient aiProjectClient = new(new Uri(endpoint), new AzureCliCredential());
+
+// Define the agent with plugin tools
+// Define the agent you want to create. (Prompt Agent in this case)
+AIAgent agent = await aiProjectClient.CreateAIAgentAsync(
+    name: AssistantName,
+    model: deploymentName,
+    instructions: AssistantInstructions,
+    tools: serviceProvider.GetRequiredService<AgentPlugin>().AsAITools().ToList(),
+    services: serviceProvider);
+
+// Invoke the agent and output the text result.
+AgentThread thread = await agent.GetNewThreadAsync();
+Console.WriteLine(await agent.RunAsync("Tell me current time and weather in Seattle.", thread));
+
+// Cleanup by agent name removes the agent version created.
+await aiProjectClient.Agents.DeleteAgentAsync(agent.Name);
+
+/// <summary>
+/// The agent plugin that provides weather and current time information.
+/// </summary>
+/// <param name="weatherProvider">The weather provider to get weather information.</param>
+internal sealed class AgentPlugin(WeatherProvider weatherProvider)
+{
+    /// <summary>
+    /// Gets the weather information for the specified location.
+    /// </summary>
+    /// <remarks>
+    /// This method demonstrates how to use the dependency that was injected into the plugin class.
+    /// </remarks>
+    /// <param name="location">The location to get the weather for.</param>
+    /// <returns>The weather information for the specified location.</returns>
+    public string GetWeather(string location)
+    {
+        return weatherProvider.GetWeather(location);
+    }
+
+    /// <summary>
+    /// Gets the current date and time for the specified location.
+    /// </summary>
+    /// <remarks>
+    /// This method demonstrates how to resolve a dependency using the service provider passed to the method.
+    /// </remarks>
+    /// <param name="sp">The service provider to resolve the <see cref="CurrentTimeProvider"/>.</param>
+    /// <param name="location">The location to get the current time for.</param>
+    /// <returns>The current date and time as a <see cref="DateTimeOffset"/>.</returns>
+    public DateTimeOffset GetCurrentTime(IServiceProvider sp, string location)
+    {
+        // Resolve the CurrentTimeProvider from the service provider
+        CurrentTimeProvider currentTimeProvider = sp.GetRequiredService<CurrentTimeProvider>();
+
+        return currentTimeProvider.GetCurrentTime(location);
+    }
+
+    /// <summary>
+    /// Returns the functions provided by this plugin.
+    /// </summary>
+    /// <remarks>
+    /// In real world scenarios, a class may have many methods and only a subset of them may be intended to be exposed as AI functions.
+    /// This method demonstrates how to explicitly specify which methods should be exposed to the AI agent.
+    /// </remarks>
+    /// <returns>The functions provided by this plugin.</returns>
+    public IEnumerable<AITool> AsAITools()
+    {
+        yield return AIFunctionFactory.Create(this.GetWeather);
+        yield return AIFunctionFactory.Create(this.GetCurrentTime);
+    }
+}
+
+/// <summary>
+/// The weather provider that returns weather information.
+/// </summary>
+internal sealed class WeatherProvider
+{
+    /// <summary>
+    /// Gets the weather information for the specified location.
+    /// </summary>
+    /// <remarks>
+    /// The weather information is hardcoded for demonstration purposes.
+    /// In a real application, this could call a weather API to get actual weather data.
+    /// </remarks>
+    /// <param name="location">The location to get the weather for.</param>
+    /// <returns>The weather information for the specified location.</returns>
+    public string GetWeather(string location)
+    {
+        return $"The weather in {location} is cloudy with a high of 15°C.";
+    }
+}
+
+/// <summary>
+/// Provides the current date and time.
+/// </summary>
+/// <remarks>
+/// This class returns the current date and time using the system's clock.
+/// </remarks>
+internal sealed class CurrentTimeProvider
+{
+    /// <summary>
+    /// Gets the current date and time.
+    /// </summary>
+    /// <param name="location">The location to get the current time for (not used in this implementation).</param>
+    /// <returns>The current date and time as a <see cref="DateTimeOffset"/>.</returns>
+    public DateTimeOffset GetCurrentTime(string location)
+    {
+        return DateTimeOffset.Now;
+    }
+}

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step13_Plugins/README.md

@@ -0,0 +1,49 @@
+# Using Plugins with AI Agents
+
+This sample demonstrates how to use plugins with AI agents, where plugins are services registered in dependency injection that expose methods as AI function tools.
+
+## What this sample demonstrates
+
+- Creating plugin services with methods to expose as tools
+- Using AsAITools() to selectively expose plugin methods
+- Registering plugins in dependency injection
+- Using plugins with AI agents
+- Managing agent lifecycle (creation and deletion)
+
+## Prerequisites
+
+Before you begin, ensure you have the following prerequisites:
+
+- .NET 10 SDK or later
+- Azure Foundry service endpoint and deployment configured
+- Azure CLI installed and authenticated (for Azure credential authentication)
+
+**Note**: This demo uses Azure CLI credentials for authentication. Make sure you're logged in with `az login` and have access to the Azure Foundry resource. For more information, see the [Azure CLI documentation](https://learn.microsoft.com/cli/azure/authenticate-azure-cli-interactively).
+
+Set the following environment variables:
+
+```powershell
+$env:AZURE_FOUNDRY_PROJECT_ENDPOINT="https://your-foundry-service.services.ai.azure.com/api/projects/your-foundry-project" # Replace with your Azure Foundry resource endpoint
+$env:AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME="gpt-4o-mini"  # Optional, defaults to gpt-4o-mini
+```
+
+## Run the sample
+
+Navigate to the FoundryAgents sample directory and run:
+
+```powershell
+cd dotnet/samples/GettingStarted/FoundryAgents
+dotnet run --project .\FoundryAgents_Step13_Plugins
+```
+
+## Expected behavior
+
+The sample will:
+
+1. Create a plugin service with methods to expose as tools
+2. Register the plugin in dependency injection
+3. Create an agent named "PluginAgent" with the plugin methods as function tools
+4. Run the agent with a prompt that triggers it to call plugin methods
+5. The agent will invoke the plugin methods to retrieve information
+6. Clean up resources by deleting the agent
+

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step14_CodeInterpreter/FoundryAgents_Step14_CodeInterpreter.csproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <NoWarn>$(NoWarn);CA1812</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" />
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Azure.AI.Projects" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI\Microsoft.Agents.AI.AzureAI.csproj" />
+  </ItemGroup>
+  
+</Project>

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step14_CodeInterpreter/Program.cs

@@ -0,0 +1,90 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows how to use Code Interpreter Tool with AI Agents.
+
+using System.Text;
+using Azure.AI.Projects;
+using Azure.AI.Projects.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+using OpenAI.Assistants;
+using OpenAI.Responses;
+
+string endpoint = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_ENDPOINT") ?? throw new InvalidOperationException("AZURE_FOUNDRY_PROJECT_ENDPOINT is not set.");
+string deploymentName = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+const string AgentInstructions = "You are a personal math tutor. When asked a math question, write and run code using the python tool to answer the question.";
+const string AgentNameMEAI = "CoderAgent-MEAI";
+const string AgentNameNative = "CoderAgent-NATIVE";
+
+// Get a client to create/retrieve/delete server side agents with Azure Foundry Agents.
+AIProjectClient aiProjectClient = new(new Uri(endpoint), new AzureCliCredential());
+
+// Option 1 - Using HostedCodeInterpreterTool + AgentOptions (MEAI + AgentFramework)
+// Create the server side agent version
+AIAgent agentOption1 = await aiProjectClient.CreateAIAgentAsync(
+    model: deploymentName,
+    name: AgentNameMEAI,
+    instructions: AgentInstructions,
+    tools: [new HostedCodeInterpreterTool() { Inputs = [] }]);
+
+// Option 2 - Using PromptAgentDefinition SDK native type
+// Create the server side agent version
+AIAgent agentOption2 = await aiProjectClient.CreateAIAgentAsync(
+    name: AgentNameNative,
+    creationOptions: new AgentVersionCreationOptions(
+        new PromptAgentDefinition(model: deploymentName)
+        {
+            Instructions = AgentInstructions,
+            Tools = {
+                ResponseTool.CreateCodeInterpreterTool(
+                    new CodeInterpreterToolContainer(
+                        CodeInterpreterToolContainerConfiguration.CreateAutomaticContainerConfiguration(fileIds: [])
+                    )
+                ),
+            }
+        })
+);
+
+// Either invoke option1 or option2 agent, should have same result
+// Option 1
+AgentResponse response = await agentOption1.RunAsync("I need to solve the equation sin(x) + x^2 = 42");
+
+// Option 2
+// AgentResponse response = await agentOption2.RunAsync("I need to solve the equation sin(x) + x^2 = 42");
+
+// Get the CodeInterpreterToolCallContent
+CodeInterpreterToolCallContent? toolCallContent = response.Messages.SelectMany(m => m.Contents).OfType<CodeInterpreterToolCallContent>().FirstOrDefault();
+if (toolCallContent?.Inputs is not null)
+{
+    DataContent? codeInput = toolCallContent.Inputs.OfType<DataContent>().FirstOrDefault();
+    if (codeInput?.HasTopLevelMediaType("text") ?? false)
+    {
+        Console.WriteLine($"Code Input: {Encoding.UTF8.GetString(codeInput.Data.ToArray()) ?? "Not available"}");
+    }
+}
+
+// Get the CodeInterpreterToolResultContent
+CodeInterpreterToolResultContent? toolResultContent = response.Messages.SelectMany(m => m.Contents).OfType<CodeInterpreterToolResultContent>().FirstOrDefault();
+if (toolResultContent?.Outputs is not null && toolResultContent.Outputs.OfType<TextContent>().FirstOrDefault() is { } resultOutput)
+{
+    Console.WriteLine($"Code Tool Result: {resultOutput.Text}");
+}
+
+// Getting any annotations generated by the tool
+foreach (AIAnnotation annotation in response.Messages.SelectMany(m => m.Contents).SelectMany(C => C.Annotations ?? []))
+{
+    if (annotation.RawRepresentation is TextAnnotationUpdate citationAnnotation)
+    {
+        Console.WriteLine($$"""
+            File Id: {{citationAnnotation.OutputFileId}}
+            Text to Replace: {{citationAnnotation.TextToReplace}}
+            Filename: {{Path.GetFileName(citationAnnotation.TextToReplace)}}
+            """);
+    }
+}
+
+// Cleanup by agent name removes the agent version created.
+await aiProjectClient.Agents.DeleteAgentAsync(agentOption1.Name);
+await aiProjectClient.Agents.DeleteAgentAsync(agentOption2.Name);

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step14_CodeInterpreter/README.md

@@ -0,0 +1,53 @@
+# Using Code Interpreter with AI Agents
+
+This sample demonstrates how to use the code interpreter tool with AI agents. The code interpreter allows agents to write and execute Python code to solve problems, perform calculations, and analyze data.
+
+## What this sample demonstrates
+
+- Creating agents with code interpreter capabilities
+- Using HostedCodeInterpreterTool (MEAI abstraction)
+- Using native SDK code interpreter tools (ResponseTool.CreateCodeInterpreterTool)
+- Extracting code inputs and results from agent responses
+- Handling code interpreter annotations
+- Managing agent lifecycle (creation and deletion)
+
+## Prerequisites
+
+Before you begin, ensure you have the following prerequisites:
+
+- .NET 10 SDK or later
+- Azure Foundry service endpoint and deployment configured
+- Azure CLI installed and authenticated (for Azure credential authentication)
+
+**Note**: This demo uses Azure CLI credentials for authentication. Make sure you're logged in with `az login` and have access to the Azure Foundry resource. For more information, see the [Azure CLI documentation](https://learn.microsoft.com/cli/azure/authenticate-azure-cli-interactively).
+
+Set the following environment variables:
+
+```powershell
+$env:AZURE_FOUNDRY_PROJECT_ENDPOINT="https://your-foundry-service.services.ai.azure.com/api/projects/your-foundry-project" # Replace with your Azure Foundry resource endpoint
+$env:AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME="gpt-4o-mini"  # Optional, defaults to gpt-4o-mini
+```
+
+## Run the sample
+
+Navigate to the FoundryAgents sample directory and run:
+
+```powershell
+cd dotnet/samples/GettingStarted/FoundryAgents
+dotnet run --project .\FoundryAgents_Step14_CodeInterpreter
+```
+
+## Expected behavior
+
+The sample will:
+
+1. Create two agents with code interpreter capabilities:
+   - Option 1: Using HostedCodeInterpreterTool (MEAI abstraction)
+   - Option 2: Using native SDK code interpreter tools
+2. Run the agent with a mathematical problem: "I need to solve the equation sin(x) + x^2 = 42"
+3. The agent will use the code interpreter to write and execute Python code to solve the equation
+4. Extract and display the code that was executed
+5. Display the results from the code execution
+6. Display any annotations generated by the code interpreter tool
+7. Clean up resources by deleting both agents
+

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step15_ComputerUse/ComputerUseUtil.cs

@@ -0,0 +1,98 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using OpenAI.Responses;
+
+namespace Demo.ComputerUse;
+
+/// <summary>
+/// Enum for tracking the state of the simulated web search flow.
+/// </summary>
+internal enum SearchState
+{
+    Initial,        // Browser search page
+    Typed,          // Text entered in search box
+    PressedEnter   // Enter key pressed, transitioning to results
+}
+
+internal static class ComputerUseUtil
+{
+    /// <summary>
+    /// Load and convert screenshot images to base64 data URLs.
+    /// </summary>
+    internal static Dictionary<string, byte[]> LoadScreenshotAssets()
+    {
+        string baseDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Assets");
+
+        ReadOnlySpan<(string key, string fileName)> screenshotFiles =
+            [
+                ("browser_search", "cua_browser_search.png"),
+                ("search_typed", "cua_search_typed.png"),
+                ("search_results", "cua_search_results.png")
+            ];
+
+        Dictionary<string, byte[]> screenshots = [];
+        foreach (var (key, fileName) in screenshotFiles)
+        {
+            string fullPath = Path.GetFullPath(Path.Combine(baseDir, fileName));
+            screenshots[key] = File.ReadAllBytes(fullPath);
+        }
+
+        return screenshots;
+    }
+
+    /// <summary>
+    /// Process a computer action and simulate its execution.
+    /// </summary>
+    internal static (SearchState CurrentState, byte[] ImageBytes) HandleComputerActionAndTakeScreenshot(
+        ComputerCallAction action,
+        SearchState currentState,
+        Dictionary<string, byte[]> screenshots)
+    {
+        Console.WriteLine($"Simulating the execution of computer action: {action.Kind}");
+
+        SearchState newState = DetermineNextState(action, currentState);
+        string imageKey = GetImageKey(newState);
+
+        return (newState, screenshots[imageKey]);
+    }
+
+    private static SearchState DetermineNextState(ComputerCallAction action, SearchState currentState)
+    {
+        string actionType = action.Kind.ToString();
+
+        if (actionType.Equals("type", StringComparison.OrdinalIgnoreCase) && action.TypeText is not null)
+        {
+            return SearchState.Typed;
+        }
+
+        if (IsEnterKeyAction(action, actionType))
+        {
+            Console.WriteLine("  -> Detected ENTER key press");
+            return SearchState.PressedEnter;
+        }
+
+        if (actionType.Equals("click", StringComparison.OrdinalIgnoreCase) && currentState == SearchState.Typed)
+        {
+            Console.WriteLine("  -> Detected click after typing");
+            return SearchState.PressedEnter;
+        }
+
+        return currentState;
+    }
+
+    private static bool IsEnterKeyAction(ComputerCallAction action, string actionType)
+    {
+        return (actionType.Equals("key", StringComparison.OrdinalIgnoreCase) ||
+                actionType.Equals("keypress", StringComparison.OrdinalIgnoreCase)) &&
+               action.KeyPressKeyCodes is not null &&
+               (action.KeyPressKeyCodes.Contains("Return", StringComparer.OrdinalIgnoreCase) ||
+                action.KeyPressKeyCodes.Contains("Enter", StringComparer.OrdinalIgnoreCase));
+    }
+
+    private static string GetImageKey(SearchState state) => state switch
+    {
+        SearchState.PressedEnter => "search_results",
+        SearchState.Typed => "search_typed",
+        _ => "browser_search"
+    };
+}

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step15_ComputerUse/FoundryAgents_Step15_ComputerUse.csproj

@@ -0,0 +1,33 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <NoWarn>$(NoWarn);OPENAICUA001</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI\Microsoft.Agents.AI.AzureAI.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="Assets\cua_browser_search.png">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="Assets\cua_search_results.png">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="Assets\cua_search_typed.png">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+  
+</Project>

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step15_ComputerUse/Program.cs

@@ -0,0 +1,174 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows how to use Computer Use Tool with AI Agents.
+
+using Azure.AI.Projects;
+using Azure.AI.Projects.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+using OpenAI.Responses;
+
+namespace Demo.ComputerUse;
+
+internal sealed class Program
+{
+    private static async Task Main(string[] args)
+    {
+        string endpoint = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_ENDPOINT") ?? throw new InvalidOperationException("AZURE_FOUNDRY_PROJECT_ENDPOINT is not set.");
+        string deploymentName = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME") ?? "computer-use-preview";
+
+        // Get a client to create/retrieve/delete server side agents with Azure Foundry Agents.
+        AIProjectClient aiProjectClient = new(new Uri(endpoint), new AzureCliCredential());
+        const string AgentInstructions = @"
+                    You are a computer automation assistant. 
+                    
+                    Be direct and efficient. When you reach the search results page, read and describe the actual search result titles and descriptions you can see.
+                ";
+
+        const string AgentNameMEAI = "ComputerAgent-MEAI";
+        const string AgentNameNative = "ComputerAgent-NATIVE";
+
+        // Option 1 - Using ComputerUseTool + AgentOptions (MEAI + AgentFramework)
+        // Create AIAgent directly
+        AIAgent agentOption1 = await aiProjectClient.CreateAIAgentAsync(
+            name: AgentNameMEAI,
+            model: deploymentName,
+            instructions: AgentInstructions,
+            description: "Computer automation agent with screen interaction capabilities.",
+            tools: [
+                    ResponseTool.CreateComputerTool(ComputerToolEnvironment.Browser, 1026, 769).AsAITool(),
+                ]);
+
+        // Option 2 - Using PromptAgentDefinition SDK native type
+        // Create the server side agent version
+        AIAgent agentOption2 = await aiProjectClient.CreateAIAgentAsync(
+            name: AgentNameNative,
+            creationOptions: new AgentVersionCreationOptions(
+                new PromptAgentDefinition(model: deploymentName)
+                {
+                    Instructions = AgentInstructions,
+                    Tools = { ResponseTool.CreateComputerTool(
+                environment: new ComputerToolEnvironment("windows"),
+                displayWidth: 1026,
+                displayHeight: 769) }
+                })
+        );
+
+        // Either invoke option1 or option2 agent, should have same result
+        // Option 1
+        await InvokeComputerUseAgentAsync(agentOption1);
+
+        // Option 2
+        //await InvokeComputerUseAgentAsync(agentOption2);
+
+        // Cleanup by agent name removes the agent version created.
+        await aiProjectClient.Agents.DeleteAgentAsync(agentOption1.Name);
+        await aiProjectClient.Agents.DeleteAgentAsync(agentOption2.Name);
+    }
+
+    private static async Task InvokeComputerUseAgentAsync(AIAgent agent)
+    {
+        // Load screenshot assets
+        Dictionary<string, byte[]> screenshots = ComputerUseUtil.LoadScreenshotAssets();
+
+        ChatOptions chatOptions = new();
+        CreateResponseOptions responseCreationOptions = new()
+        {
+            TruncationMode = ResponseTruncationMode.Auto
+        };
+        chatOptions.RawRepresentationFactory = (_) => responseCreationOptions;
+        ChatClientAgentRunOptions runOptions = new(chatOptions)
+        {
+            AllowBackgroundResponses = true,
+        };
+
+        AgentThread thread = await agent.GetNewThreadAsync();
+
+        ChatMessage message = new(ChatRole.User, [
+            new TextContent("I need you to help me search for 'OpenAI news'. Please type 'OpenAI news' and submit the search. Once you see search results, the task is complete."),
+            new DataContent(new BinaryData(screenshots["browser_search"]), "image/png")
+        ]);
+
+        // Initial request with screenshot - start with Bing search page
+        Console.WriteLine("Starting computer automation session (initial screenshot: cua_browser_search.png)...");
+
+        AgentResponse response = await agent.RunAsync(message, thread: thread, options: runOptions);
+
+        // Main interaction loop
+        const int MaxIterations = 10;
+        int iteration = 0;
+        // Initialize state machine
+        SearchState currentState = SearchState.Initial;
+        string initialCallId = string.Empty;
+
+        while (true)
+        {
+            // Poll until the response is complete.
+            while (response.ContinuationToken is { } token)
+            {
+                // Wait before polling again.
+                await Task.Delay(TimeSpan.FromSeconds(2));
+
+                // Continue with the token.
+                runOptions.ContinuationToken = token;
+
+                response = await agent.RunAsync(thread, runOptions);
+            }
+
+            Console.WriteLine($"Agent response received (ID: {response.ResponseId})");
+
+            if (iteration >= MaxIterations)
+            {
+                Console.WriteLine($"\nReached maximum iterations ({MaxIterations}). Stopping.");
+                break;
+            }
+
+            iteration++;
+            Console.WriteLine($"\n--- Iteration {iteration} ---");
+
+            // Check for computer calls in the response
+            IEnumerable<ComputerCallResponseItem> computerCallResponseItems = response.Messages
+                .SelectMany(x => x.Contents)
+                .Where(c => c.RawRepresentation is ComputerCallResponseItem and not null)
+                .Select(c => (ComputerCallResponseItem)c.RawRepresentation!);
+
+            ComputerCallResponseItem? firstComputerCall = computerCallResponseItems.FirstOrDefault();
+            if (firstComputerCall is null)
+            {
+                Console.WriteLine("No computer call actions found. Ending interaction.");
+                Console.WriteLine($"Final Response: {response}");
+                break;
+            }
+
+            // Process the first computer call response
+            ComputerCallAction action = firstComputerCall.Action;
+            string currentCallId = firstComputerCall.CallId;
+
+            // Set the initial computer call ID for tracking and subsequent responses.
+            if (string.IsNullOrEmpty(initialCallId))
+            {
+                initialCallId = currentCallId;
+            }
+
+            Console.WriteLine($"Processing computer call (ID: {currentCallId})");
+
+            // Simulate executing the action and taking a screenshot
+            (SearchState CurrentState, byte[] ImageBytes) screenInfo = ComputerUseUtil.HandleComputerActionAndTakeScreenshot(action, currentState, screenshots);
+            currentState = screenInfo.CurrentState;
+
+            Console.WriteLine("Sending action result back to agent...");
+
+            AIContent content = new()
+            {
+                RawRepresentation = new ComputerCallOutputResponseItem(
+                    initialCallId,
+                    output: ComputerCallOutput.CreateScreenshotOutput(new BinaryData(screenInfo.ImageBytes), "image/png"))
+            };
+
+            // Follow-up message with action result and new screenshot
+            message = new(ChatRole.User, [content]);
+            response = await agent.RunAsync(message, thread: thread, options: runOptions);
+        }
+    }
+}

dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step15_ComputerUse/README.md

@@ -0,0 +1,55 @@
+# Using Computer Use Tool with AI Agents
+
+This sample demonstrates how to use the computer use tool with AI agents. The computer use tool allows agents to interact with a computer environment by viewing the screen, controlling the mouse and keyboard, and performing various actions to help complete tasks.
+
+## What this sample demonstrates
+
+- Creating agents with computer use capabilities
+- Using HostedComputerTool (MEAI abstraction)
+- Using native SDK computer use tools (ResponseTool.CreateComputerTool)
+- Extracting computer action information from agent responses
+- Handling computer tool results (text output and screenshots)
+- Managing agent lifecycle (creation and deletion)
+
+## Prerequisites
+
+Before you begin, ensure you have the following prerequisites:
+
+- .NET 10 SDK or later
+- Azure Foundry service endpoint and deployment configured
+- Azure CLI installed and authenticated (for Azure credential authentication)
+
+**Note**: This demo uses Azure CLI credentials for authentication. Make sure you're logged in with `az login` and have access to the Azure Foundry resource. For more information, see the [Azure CLI documentation](https://learn.microsoft.com/cli/azure/authenticate-azure-cli-interactively).
+
+Set the following environment variables:
+
+```powershell
+$env:AZURE_FOUNDRY_PROJECT_ENDPOINT="https://your-foundry-service.services.ai.azure.com/api/projects/your-foundry-project" # Replace with your Azure Foundry resource endpoint
+$env:AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME="computer-use-preview"  # Optional, defaults to computer-use-preview
+```
+
+## Run the sample
+
+Navigate to the FoundryAgents sample directory and run:
+
+```powershell
+cd dotnet/samples/GettingStarted/FoundryAgents
+dotnet run --project .\FoundryAgents_Step15_ComputerUse
+```
+
+## Expected behavior
+
+The sample will:
+
+1. Create two agents with computer use capabilities:
+   - Option 1: Using HostedComputerTool (MEAI abstraction)
+   - Option 2: Using native SDK computer use tools
+2. Run the agent with a task: "I need you to help me search for 'OpenAI news'. Please type 'OpenAI news' and submit the search. Once you see search results, the task is complete."
+3. The agent will use the computer use tool to:
+   - Interpret the screenshots
+   - Issue action requests based on the task
+   - Analyze the search results for "OpenAI news" from the screenshots.
+4. Extract and display the computer actions performed
+5. Display the results from the computer tool execution
+6. Display the final response from the agent
+7. Clean up resources by deleting both agents

dotnet/samples/GettingStarted/FoundryAgents/README.md

@@ -0,0 +1,102 @@
+# Getting started with Foundry Agents
+
+The getting started with Foundry Agents samples demonstrate the fundamental concepts and functionalities
+of Azure Foundry Agents and can be used with Azure Foundry as the AI provider.
+
+These samples showcase how to work with agents managed through Azure Foundry, including agent creation,
+versioning, multi-turn conversations, and advanced features like code interpretation and computer use.
+
+## Classic vs New Foundry Agents
+
+> [!NOTE]
+> Recently, Azure Foundry introduced a new and improved experience for creating and managing AI agents, which is the target of these samples.
+
+For more information about the previous classic agents and for what's new in Foundry Agents, see the [Foundry Agents migration documentation](https://learn.microsoft.com/en-us/azure/ai-foundry/agents/how-to/migrate?view=foundry).
+
+For a sample demonstrating how to use classic Foundry Agents, see the following: [Agent with Azure AI Persistent](../AgentProviders/Agent_With_AzureAIAgentsPersistent/README.md).
+
+## Agent Versioning and Static Definitions
+
+One of the key architectural changes in the new Foundry Agents compared to the classic experience is how agent definitions are handled. In the new architecture, agents have **versions** and their definitions are established at creation time. This means that the agent's configuration—including instructions, tools, and options—is fixed when the agent version is created.
+
+> [!IMPORTANT]
+> Agent versions are static and strictly adhere to their original definition. Any attempt to provide or override tools, instructions, or options during an agent run or request will be ignored by the agent, as the API does not support runtime configuration changes. All agent behavior must be defined at agent creation time.
+
+This design ensures consistency and predictability in agent behavior across all interactions with a specific agent version.
+
+The Agent Framework intentionally ignores unsupported runtime parameters rather than throwing exceptions. This abstraction-first approach ensures that code written against the unified agent abstraction remains portable across providers (OpenAI, Azure OpenAI, Foundry Agents). It removes the need for provider-specific conditional logic. Teams can adopt Foundry Agents without rewriting existing orchestration code. Configurations that work with other providers will gracefully degrade, rather than fail, when the underlying API does not support them.
+
+## Getting started with Foundry Agents prerequisites
+
+Before you begin, ensure you have the following prerequisites:
+
+- .NET 10 SDK or later
+- Azure Foundry service endpoint and project configured
+- Azure CLI installed and authenticated (for Azure credential authentication)
+
+**Note**: These samples use Azure Foundry Agents. For more information, see [Azure AI Foundry documentation](https://learn.microsoft.com/en-us/azure/ai-foundry/).
+
+**Note**: These samples use Azure CLI credentials for authentication. Make sure you're logged in with `az login` and have access to the Azure Foundry resource. For more information, see the [Azure CLI documentation](https://learn.microsoft.com/cli/azure/authenticate-azure-cli-interactively).
+
+## Samples
+
+|Sample|Description|
+|---|---|
+|[Basics](./FoundryAgents_Step01.1_Basics/)|This sample demonstrates how to create and manage AI agents with versioning|
+|[Running a simple agent](./FoundryAgents_Step01.2_Running/)|This sample demonstrates how to create and run a basic Foundry agent|
+|[Multi-turn conversation](./FoundryAgents_Step02_MultiturnConversation/)|This sample demonstrates how to implement a multi-turn conversation with a Foundry agent|
+|[Using function tools](./FoundryAgents_Step03_UsingFunctionTools/)|This sample demonstrates how to use function tools with a Foundry agent|
+|[Using function tools with approvals](./FoundryAgents_Step04_UsingFunctionToolsWithApprovals/)|This sample demonstrates how to use function tools where approvals require human in the loop approvals before execution|
+|[Structured output](./FoundryAgents_Step05_StructuredOutput/)|This sample demonstrates how to use structured output with a Foundry agent|
+|[Persisted conversations](./FoundryAgents_Step06_PersistedConversations/)|This sample demonstrates how to persist conversations and reload them later|
+|[Observability](./FoundryAgents_Step07_Observability/)|This sample demonstrates how to add telemetry to a Foundry agent|
+|[Dependency injection](./FoundryAgents_Step08_DependencyInjection/)|This sample demonstrates how to add and resolve a Foundry agent with a dependency injection container|
+|[Using MCP client as tools](./FoundryAgents_Step09_UsingMcpClientAsTools/)|This sample demonstrates how to use MCP clients as tools with a Foundry agent|
+|[Using images](./FoundryAgents_Step10_UsingImages/)|This sample demonstrates how to use image multi-modality with a Foundry agent|
+|[Exposing as a function tool](./FoundryAgents_Step11_AsFunctionTool/)|This sample demonstrates how to expose a Foundry agent as a function tool|
+|[Using middleware](./FoundryAgents_Step12_Middleware/)|This sample demonstrates how to use middleware with a Foundry agent|
+|[Using plugins](./FoundryAgents_Step13_Plugins/)|This sample demonstrates how to use plugins with a Foundry agent|
+|[Code interpreter](./FoundryAgents_Step14_CodeInterpreter/)|This sample demonstrates how to use the code interpreter tool with a Foundry agent|
+|[Computer use](./FoundryAgents_Step15_ComputerUse/)|This sample demonstrates how to use computer use capabilities with a Foundry agent|
+
+## Running the samples from the console
+
+To run the samples, navigate to the desired sample directory, e.g.
+
+```powershell
+cd FoundryAgents_Step01.2_Running
+```
+
+Set the following environment variables:
+
+```powershell
+$env:AZURE_FOUNDRY_PROJECT_ENDPOINT="https://your-foundry-service.services.ai.azure.com/api/projects/your-foundry-project" # Replace with your Azure Foundry resource endpoint
+$env:AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME="gpt-4o-mini"  # Optional, defaults to gpt-4o-mini
+```
+
+If the variables are not set, you will be prompted for the values when running the samples.
+
+Execute the following command to build the sample:
+
+```powershell
+dotnet build
+```
+
+Execute the following command to run the sample:
+
+```powershell
+dotnet run --no-build
+```
+
+Or just build and run in one step:
+
+```powershell
+dotnet run
+```
+
+## Running the samples from Visual Studio
+
+Open the solution in Visual Studio and set the desired sample project as the startup project. Then, run the project using the built-in debugger or by pressing `F5`.
+
+You will be prompted for any required environment variables if they are not already set.
+