test

2026-01-24 03:05:12 +11:00
parent f78f2388b3
commit 539852f81c
2584 changed files with 287471 additions and 0 deletions
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step01_Running/Agent_Step01_Running.csproj
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step01_Running/Agent_Step01_Running.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="Azure.AI.OpenAI" />
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Microsoft.Extensions.AI.OpenAI" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+
+</Project>
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step01_Running/Program.cs
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step01_Running/Program.cs
@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows how to create and use a simple AI agent with Azure OpenAI as the backend.
+
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using OpenAI.Chat;
+
+var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+AIAgent agent = new AzureOpenAIClient(
+    new Uri(endpoint),
+    new AzureCliCredential())
+    .GetChatClient(deploymentName)
+    .AsAIAgent(instructions: "You are good at telling jokes.", name: "Joker");
+
+// Invoke the agent and output the text result.
+Console.WriteLine(await agent.RunAsync("Tell me a joke about a pirate."));
+
+// Invoke the agent with streaming support.
+await foreach (var update in agent.RunStreamingAsync("Tell me a joke about a pirate."))
+{
+    Console.WriteLine(update);
+}
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step02_MultiturnConversation/Agent_Step02_MultiturnConversation.csproj
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step02_MultiturnConversation/Agent_Step02_MultiturnConversation.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="Azure.AI.OpenAI" />
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Microsoft.Extensions.AI.OpenAI" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+
+</Project>
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step02_MultiturnConversation/Program.cs
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step02_MultiturnConversation/Program.cs
@@ -0,0 +1,33 @@
+// 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.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using OpenAI.Chat;
+
+var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+AIAgent agent = new AzureOpenAIClient(
+    new Uri(endpoint),
+    new AzureCliCredential())
+    .GetChatClient(deploymentName)
+    .AsAIAgent(instructions: "You are good at telling jokes.", name: "Joker");
+
+// Invoke the agent with a multi-turn conversation, where the context is preserved in the thread object.
+AgentThread thread = await agent.GetNewThreadAsync();
+Console.WriteLine(await agent.RunAsync("Tell me a joke about a pirate.", thread));
+Console.WriteLine(await agent.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 agent.GetNewThreadAsync();
+await foreach (var update in agent.RunStreamingAsync("Tell me a joke about a pirate.", thread))
+{
+    Console.WriteLine(update);
+}
+await foreach (var update in agent.RunStreamingAsync("Now add some emojis to the joke and tell it in the voice of a pirate's parrot.", thread))
+{
+    Console.WriteLine(update);
+}
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step03_UsingFunctionTools/Agent_Step03_UsingFunctionTools.csproj
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step03_UsingFunctionTools/Agent_Step03_UsingFunctionTools.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="Azure.AI.OpenAI" />
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Microsoft.Extensions.AI.OpenAI" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+
+</Project>
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step03_UsingFunctionTools/Program.cs
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step03_UsingFunctionTools/Program.cs
@@ -0,0 +1,34 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample demonstrates how to use a ChatClientAgent with function tools.
+// It shows both non-streaming and streaming agent interactions using menu-related tools.
+
+using System.ComponentModel;
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+using OpenAI.Chat;
+
+var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_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.";
+
+// Create the chat client and agent, and provide the function tool to the agent.
+AIAgent agent = new AzureOpenAIClient(
+    new Uri(endpoint),
+    new AzureCliCredential())
+    .GetChatClient(deploymentName)
+    .AsAIAgent(instructions: "You are a helpful assistant", tools: [AIFunctionFactory.Create(GetWeather)]);
+
+// Non-streaming agent interaction with function tools.
+Console.WriteLine(await agent.RunAsync("What is the weather like in Amsterdam?"));
+
+// Streaming agent interaction with function tools.
+await foreach (var update in agent.RunStreamingAsync("What is the weather like in Amsterdam?"))
+{
+    Console.WriteLine(update);
+}
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step04_UsingFunctionToolsWithApprovals/Agent_Step04_UsingFunctionToolsWithApprovals.csproj
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step04_UsingFunctionToolsWithApprovals/Agent_Step04_UsingFunctionToolsWithApprovals.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="Azure.AI.OpenAI" />
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Microsoft.Extensions.AI.OpenAI" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+
+</Project>
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step04_UsingFunctionToolsWithApprovals/Program.cs
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step04_UsingFunctionToolsWithApprovals/Program.cs
@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample demonstrates how to use a ChatClientAgent with function tools that require a human in the loop for approvals.
+// It shows both non-streaming and streaming agent interactions using menu-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.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+using OpenAI.Chat;
+using ChatMessage = Microsoft.Extensions.AI.ChatMessage;
+
+var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_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.";
+
+// Create the chat client and agent.
+// Note that we are wrapping the function tool with ApprovalRequiredAIFunction to require user approval before invoking it.
+AIAgent agent = new AzureOpenAIClient(
+    new Uri(endpoint),
+    new AzureCliCredential())
+    .GetChatClient(deploymentName)
+    .AsAIAgent(instructions: "You are a helpful assistant", tools: [new ApprovalRequiredAIFunction(AIFunctionFactory.Create(GetWeather))]);
+
+// Call the agent and check if there are any user input requests to handle.
+AgentThread thread = await agent.GetNewThreadAsync();
+var response = await agent.RunAsync("What is the weather like in Amsterdam?", thread);
+var userInputRequests = response.UserInputRequests.ToList();
+
+// For streaming use:
+// var updates = await agent.RunStreamingAsync("What is the weather like in Amsterdam?", thread).ToListAsync();
+// userInputRequests = updates.SelectMany(x => x.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.
+    var userInputResponses = 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}");
+            return new ChatMessage(ChatRole.User, [functionApprovalRequest.CreateResponse(Console.ReadLine()?.Equals("Y", StringComparison.OrdinalIgnoreCase) ?? false)]);
+        })
+        .ToList();
+
+    // Pass the user input responses back to the agent for further processing.
+    response = await agent.RunAsync(userInputResponses, thread);
+
+    userInputRequests = response.UserInputRequests.ToList();
+
+    // For streaming use:
+    // updates = await agent.RunStreamingAsync(userInputResponses, thread).ToListAsync();
+    // userInputRequests = updates.SelectMany(x => x.UserInputRequests).ToList();
+}
+
+Console.WriteLine($"\nAgent: {response}");
+
+// For streaming use:
+// Console.WriteLine($"\nAgent: {updates.ToAgentResponse()}");
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step05_StructuredOutput/Agent_Step05_StructuredOutput.csproj
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step05_StructuredOutput/Agent_Step05_StructuredOutput.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="Azure.AI.OpenAI" />
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Microsoft.Extensions.AI.OpenAI" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+
+</Project>
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step05_StructuredOutput/Program.cs
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step05_StructuredOutput/Program.cs
@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows how to configure ChatClientAgent to produce structured output.
+
+using System.ComponentModel;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using OpenAI.Chat;
+using SampleApp;
+
+var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+// Create chat client to be used by chat client agents.
+ChatClient chatClient = new AzureOpenAIClient(
+    new Uri(endpoint),
+    new AzureCliCredential())
+        .GetChatClient(deploymentName);
+
+// Create the ChatClientAgent with the specified name and instructions.
+ChatClientAgent agent = chatClient.AsAIAgent(name: "HelpfulAssistant", instructions: "You are a helpful assistant.");
+
+// 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 = chatClient.AsAIAgent(new ChatClientAgentOptions()
+{
+    Name = "HelpfulAssistant",
+    ChatOptions = new() { Instructions = "You are a helpful assistant.", ResponseFormat = Microsoft.Extensions.AI.ChatResponseFormat.ForJsonSchema<PersonInfo>() }
+});
+
+// Invoke the agent with some unstructured input while streaming, to extract the structured information from.
+var 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}");
+
+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; }
+    }
+}
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step06_PersistedConversations/Agent_Step06_PersistedConversations.csproj
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step06_PersistedConversations/Agent_Step06_PersistedConversations.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="Azure.AI.OpenAI" />
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Microsoft.Extensions.AI.OpenAI" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+
+</Project>
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step06_PersistedConversations/Program.cs
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step06_PersistedConversations/Program.cs
@@ -0,0 +1,41 @@
+// 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.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using OpenAI.Chat;
+
+var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+// Create the agent
+AIAgent agent = new AzureOpenAIClient(
+    new Uri(endpoint),
+    new AzureCliCredential())
+    .GetChatClient(deploymentName)
+    .AsAIAgent(instructions: "You are good at telling jokes.", name: "Joker");
+
+// 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));
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step07_3rdPartyThreadStorage/Agent_Step07_3rdPartyThreadStorage.csproj
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step07_3rdPartyThreadStorage/Agent_Step07_3rdPartyThreadStorage.csproj
@@ -0,0 +1,22 @@
+<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.OpenAI" />
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Microsoft.Extensions.AI.OpenAI" />
+    <PackageReference Include="Microsoft.SemanticKernel.Connectors.InMemory" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+
+</Project>
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step07_3rdPartyThreadStorage/Program.cs
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step07_3rdPartyThreadStorage/Program.cs
@@ -0,0 +1,160 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+#pragma warning disable CA1869 // Cache and reuse 'JsonSerializerOptions' instances
+
+// 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.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+using Microsoft.Extensions.VectorData;
+using Microsoft.SemanticKernel.Connectors.InMemory;
+using OpenAI.Chat;
+using SampleApp;
+using ChatMessage = Microsoft.Extensions.AI.ChatMessage;
+
+var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+// Create a vector store to store the chat messages in.
+// Replace this with a vector store implementation of your choice if you want to persist the chat history to disk.
+VectorStore vectorStore = new InMemoryVectorStore();
+
+// Create the agent
+AIAgent agent = new AzureOpenAIClient(
+    new Uri(endpoint),
+    new AzureCliCredential())
+    .GetChatClient(deploymentName)
+    .AsAIAgent(new ChatClientAgentOptions
+    {
+        ChatOptions = new() { Instructions = "You are good at telling jokes." },
+        Name = "Joker",
+        ChatMessageStoreFactory = (ctx, ct) => new ValueTask<ChatMessageStore>(
+            // Create a new chat message store for this agent that stores the messages in a vector store.
+            // Each thread must get its own copy of the VectorChatMessageStore, since the store
+            // also contains the id that the thread is stored under.
+            new VectorChatMessageStore(vectorStore, ctx.SerializedState, ctx.JsonSerializerOptions))
+    });
+
+// Start a new thread for the agent conversation.
+AgentThread thread = await agent.GetNewThreadAsync();
+
+// Run the agent with the thread that stores conversation history in the vector store.
+Console.WriteLine(await agent.RunAsync("Tell me a joke about a pirate.", thread));
+
+// Serialize the thread state, so it can be stored for later use.
+// Since the chat history is stored in the vector store, the serialized thread
+// only contains the guid that the messages are stored under in the vector store.
+JsonElement serializedThread = thread.Serialize();
+
+Console.WriteLine("\n--- Serialized thread ---\n");
+Console.WriteLine(JsonSerializer.Serialize(serializedThread, new JsonSerializerOptions { WriteIndented = true }));
+
+// The serialized thread can now be saved to a database, file, or any other storage mechanism
+// and loaded again later.
+
+// Deserialize the thread state after loading from storage.
+AgentThread resumedThread = await agent.DeserializeThreadAsync(serializedThread);
+
+// Run the agent with the thread that stores conversation history in the vector store a second time.
+Console.WriteLine(await agent.RunAsync("Now tell the same joke in the voice of a pirate, and add some emojis to the joke.", resumedThread));
+
+// We can access the VectorChatMessageStore via the thread's GetService method if we need to read the key under which threads are stored.
+var messageStore = resumedThread.GetService<VectorChatMessageStore>()!;
+Console.WriteLine($"\nThread is stored in vector store under key: {messageStore.ThreadDbKey}");
+
+namespace SampleApp
+{
+    /// <summary>
+    /// A sample implementation of <see cref="ChatMessageStore"/> that stores chat messages in a vector store.
+    /// </summary>
+    internal sealed class VectorChatMessageStore : ChatMessageStore
+    {
+        private readonly VectorStore _vectorStore;
+
+        public VectorChatMessageStore(VectorStore vectorStore, JsonElement serializedStoreState, JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            this._vectorStore = vectorStore ?? throw new ArgumentNullException(nameof(vectorStore));
+
+            if (serializedStoreState.ValueKind is JsonValueKind.String)
+            {
+                // Here we can deserialize the thread id so that we can access the same messages as before the suspension.
+                this.ThreadDbKey = serializedStoreState.Deserialize<string>();
+            }
+        }
+
+        public string? ThreadDbKey { get; private set; }
+
+        public override async ValueTask<IEnumerable<ChatMessage>> InvokingAsync(InvokingContext context, CancellationToken cancellationToken = default)
+        {
+            var collection = this._vectorStore.GetCollection<string, ChatHistoryItem>("ChatHistory");
+            await collection.EnsureCollectionExistsAsync(cancellationToken);
+
+            var records = await collection
+                .GetAsync(
+                    x => x.ThreadId == this.ThreadDbKey, 10,
+                    new() { OrderBy = x => x.Descending(y => y.Timestamp) },
+                    cancellationToken)
+                .ToListAsync(cancellationToken);
+
+            var messages = records.ConvertAll(x => JsonSerializer.Deserialize<ChatMessage>(x.SerializedMessage!)!)
+;
+            messages.Reverse();
+            return messages;
+        }
+
+        public override async ValueTask InvokedAsync(InvokedContext context, CancellationToken cancellationToken = default)
+        {
+            // Don't store messages if the request failed.
+            if (context.InvokeException is not null)
+            {
+                return;
+            }
+
+            this.ThreadDbKey ??= Guid.NewGuid().ToString("N");
+
+            var collection = this._vectorStore.GetCollection<string, ChatHistoryItem>("ChatHistory");
+            await collection.EnsureCollectionExistsAsync(cancellationToken);
+
+            // Add both request and response messages to the store
+            // Optionally messages produced by the AIContextProvider can also be persisted (not shown).
+            var allNewMessages = context.RequestMessages.Concat(context.AIContextProviderMessages ?? []).Concat(context.ResponseMessages ?? []);
+
+            await collection.UpsertAsync(allNewMessages.Select(x => new ChatHistoryItem()
+            {
+                Key = this.ThreadDbKey + x.MessageId,
+                Timestamp = DateTimeOffset.UtcNow,
+                ThreadId = this.ThreadDbKey,
+                SerializedMessage = JsonSerializer.Serialize(x),
+                MessageText = x.Text
+            }), cancellationToken);
+        }
+
+        public override JsonElement Serialize(JsonSerializerOptions? jsonSerializerOptions = null) =>
+            // We have to serialize the thread id, so that on deserialization we can retrieve the messages using the same thread id.
+            JsonSerializer.SerializeToElement(this.ThreadDbKey);
+
+        /// <summary>
+        /// The data structure used to store chat history items in the vector store.
+        /// </summary>
+        private sealed class ChatHistoryItem
+        {
+            [VectorStoreKey]
+            public string? Key { get; set; }
+
+            [VectorStoreData]
+            public string? ThreadId { get; set; }
+
+            [VectorStoreData]
+            public DateTimeOffset? Timestamp { get; set; }
+
+            [VectorStoreData]
+            public string? SerializedMessage { get; set; }
+
+            [VectorStoreData]
+            public string? MessageText { get; set; }
+        }
+    }
+}
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step08_Observability/Agent_Step08_Observability.csproj
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step08_Observability/Agent_Step08_Observability.csproj
@@ -0,0 +1,24 @@
+<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.OpenAI" />
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Azure.Monitor.OpenTelemetry.Exporter" />
+    <PackageReference Include="Microsoft.Extensions.AI.OpenAI" />
+    <PackageReference Include="OpenTelemetry" />
+    <PackageReference Include="OpenTelemetry.Exporter.Console" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+
+</Project>
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step08_Observability/Program.cs
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step08_Observability/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 Azure OpenAI as the backend that logs telemetry using OpenTelemetry.
+
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using Azure.Monitor.OpenTelemetry.Exporter;
+using Microsoft.Agents.AI;
+using OpenAI.Chat;
+using OpenTelemetry;
+using OpenTelemetry.Trace;
+
+var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+var applicationInsightsConnectionString = Environment.GetEnvironmentVariable("APPLICATIONINSIGHTS_CONNECTION_STRING");
+
+// Create TracerProvider with console exporter
+// This will output the telemetry data to the console.
+string sourceName = Guid.NewGuid().ToString("N");
+var tracerProviderBuilder = Sdk.CreateTracerProviderBuilder()
+    .AddSource(sourceName)
+    .AddConsoleExporter();
+if (!string.IsNullOrWhiteSpace(applicationInsightsConnectionString))
+{
+    tracerProviderBuilder.AddAzureMonitorTraceExporter(options => options.ConnectionString = applicationInsightsConnectionString);
+}
+using var tracerProvider = tracerProviderBuilder.Build();
+
+// Create the agent, and enable OpenTelemetry instrumentation.
+AIAgent agent = new AzureOpenAIClient(new Uri(endpoint), new AzureCliCredential())
+    .GetChatClient(deploymentName)
+    .AsAIAgent(instructions: "You are good at telling jokes.", name: "Joker")
+    .AsBuilder()
+    .UseOpenTelemetry(sourceName: sourceName)
+    .Build();
+
+// Invoke the agent and output the text result.
+Console.WriteLine(await agent.RunAsync("Tell me a joke about a pirate."));
+
+// Invoke the agent with streaming support.
+await foreach (var update in agent.RunStreamingAsync("Tell me a joke about a pirate."))
+{
+    Console.WriteLine(update);
+}
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step09_DependencyInjection/Agent_Step09_DependencyInjection.csproj
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step09_DependencyInjection/Agent_Step09_DependencyInjection.csproj
@@ -0,0 +1,22 @@
+<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.OpenAI" />
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Microsoft.Extensions.AI.OpenAI" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+
+</Project>
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step09_DependencyInjection/Program.cs
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step09_DependencyInjection/Program.cs
@@ -0,0 +1,85 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+#pragma warning disable CA1812
+
+// 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 Azure.AI.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+
+var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+// Create a host builder that we will register services with and then run.
+HostApplicationBuilder builder = Host.CreateApplicationBuilder(args);
+
+// Add agent options to the service collection.
+builder.Services.AddSingleton(new ChatClientAgentOptions() { Name = "Joker", ChatOptions = new() { Instructions = "You are good at telling jokes." } });
+
+// Add a chat client to the service collection.
+builder.Services.AddKeyedChatClient("AzureOpenAI", (sp) => new AzureOpenAIClient(
+    new Uri(endpoint),
+    new AzureCliCredential())
+        .GetChatClient(deploymentName)
+        .AsIChatClient());
+
+// Add the AI agent to the service collection.
+builder.Services.AddSingleton<AIAgent>((sp) => new ChatClientAgent(
+    chatClient: sp.GetRequiredKeyedService<IChatClient>("AzureOpenAI"),
+    options: sp.GetRequiredService<ChatClientAgentOptions>()));
+
+// 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(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("> ");
+            var 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 (var update in agent.RunStreamingAsync(input, this._thread, cancellationToken: cancellationToken))
+            {
+                Console.Write(update);
+            }
+
+            Console.WriteLine();
+        }
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+}
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step10_AsMcpTool/Agent_Step10_AsMcpTool.csproj
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step10_AsMcpTool/Agent_Step10_AsMcpTool.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.Persistent\Microsoft.Agents.AI.AzureAI.Persistent.csproj" />
+  </ItemGroup>
+  
+</Project>
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step10_AsMcpTool/Program.cs
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step10_AsMcpTool/Program.cs
@@ -0,0 +1,38 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows how to expose an AI agent as an MCP tool.
+
+using Azure.AI.Agents.Persistent;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using ModelContextProtocol.Server;
+
+var endpoint = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_ENDPOINT") ?? throw new InvalidOperationException("AZURE_FOUNDRY_PROJECT_ENDPOINT is not set.");
+var deploymentName = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+var persistentAgentsClient = new PersistentAgentsClient(endpoint, new AzureCliCredential());
+
+// Create a server side persistent agent
+var agentMetadata = await persistentAgentsClient.Administration.CreateAgentAsync(
+    model: deploymentName,
+    instructions: "You are good at telling jokes, and you always start each joke with 'Aye aye, captain!'.",
+    name: "Joker",
+    description: "An agent that tells jokes.");
+
+// Retrieve the server side persistent agent as an AIAgent.
+AIAgent agent = await persistentAgentsClient.GetAIAgentAsync(agentMetadata.Value.Id);
+
+// Convert the agent to an AIFunction and then to an MCP tool.
+// The agent name and description will be used as the mcp tool name and description.
+McpServerTool tool = McpServerTool.Create(agent.AsAIFunction());
+
+// Register the MCP server with StdIO transport and expose the tool via the server.
+HostApplicationBuilder builder = Host.CreateEmptyApplicationBuilder(settings: null);
+builder.Services
+    .AddMcpServer()
+    .WithStdioServerTransport()
+    .WithTools([tool]);
+
+await builder.Build().RunAsync();
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step10_AsMcpTool/README.md
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step10_AsMcpTool/README.md
@@ -0,0 +1,29 @@
+This sample demonstrates how to expose an existing AI agent as an MCP tool.
+
+## Run the sample
+
+To run the sample, please use one of the following MCP clients: https://modelcontextprotocol.io/clients
+
+Alternatively, use the QuickstartClient sample from this repository: https://github.com/modelcontextprotocol/csharp-sdk/tree/main/samples/QuickstartClient
+
+## Run the sample using MCP Inspector
+
+To use the [MCP Inspector](https://modelcontextprotocol.io/docs/tools/inspector), follow these steps:
+
+1. Open a terminal in the Agent_Step10_AsMcpTool project directory.
+1. Run the `npx @modelcontextprotocol/inspector dotnet run` command to start the MCP Inspector. Make sure you have [node.js](https://nodejs.org/en/download/) and npm installed.
+   ```bash
+   npx @modelcontextprotocol/inspector dotnet run
+   ```
+1. When the inspector is running, it will display a URL in the terminal, like this:
+   ```
+   MCP Inspector is up and running at http://127.0.0.1:6274
+   ```
+1. Open a web browser and navigate to the URL displayed in the terminal. If not opened automatically, this will open the MCP Inspector interface.
+1. In the MCP Inspector interface, add the following environment variables to allow your MCP server to access Azure AI Foundry Project to create and run the agent:
+    - AZURE_FOUNDRY_PROJECT_ENDPOINT = https://your-resource.openai.azure.com/ # Replace with your Azure AI Foundry Project endpoint
+    - AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME = gpt-4o-mini # Replace with your model deployment name
+1. Find and click the `Connect` button in the MCP Inspector interface to connect to the MCP server.
+1. As soon as the connection is established, open the `Tools` tab in the MCP Inspector interface and select the `Joker` tool from the list.
+1. Specify your prompt as a value for the `query` argument, for example: `Tell me a joke about a pirate` and click the `Run Tool` button to run the tool.
+1. The agent will process the request and return a response in accordance with the provided instructions that instruct it to always start each joke with 'Aye aye, captain!'.
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step11_UsingImages/Agent_Step11_UsingImages.csproj
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step11_UsingImages/Agent_Step11_UsingImages.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.OpenAI" />
+    <PackageReference Include="Azure.Identity" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+  
+</Project>
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step11_UsingImages/Program.cs
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step11_UsingImages/Program.cs
@@ -0,0 +1,30 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows how to use Image Multi-Modality with an AI agent.
+
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using Microsoft.Extensions.AI;
+using OpenAI.Chat;
+using ChatMessage = Microsoft.Extensions.AI.ChatMessage;
+
+var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+var deploymentName = System.Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o";
+
+var agent = new AzureOpenAIClient(new Uri(endpoint), new AzureCliCredential())
+    .GetChatClient(deploymentName)
+    .AsAIAgent(
+        name: "VisionAgent",
+        instructions: "You are a helpful agent that can analyze images");
+
+ChatMessage message = new(ChatRole.User, [
+    new TextContent("What do you see in this image?"),
+    new UriContent("https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg", "image/jpeg")
+]);
+
+var thread = await agent.GetNewThreadAsync();
+
+await foreach (var update in agent.RunStreamingAsync(message, thread))
+{
+    Console.WriteLine(update);
+}
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step11_UsingImages/README.md
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step11_UsingImages/README.md
@@ -0,0 +1,52 @@
+# 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 OpenAI.
+
+## What this sample demonstrates
+
+- Creating a persistent AI agent with vision capabilities
+- Sending both text and image content to an agent in a single message
+- Using `UriContent` to Uri referenced images
+- Processing multimodal input (text + image) with an AI agent
+
+## 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 OpenAI Integration**: Uses AzureOpenAI LLM agents
+
+## 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_OPENAI_ENDPOINT="https://your-resource.openai.azure.com/" # Replace with your Azure OpenAI endpoint
+$env:AZURE_OPENAI_DEPLOYMENT_NAME="gpt-4o" # Replace with your model deployment name (optional, defaults to gpt-4o)
+```
+
+## Run the sample
+
+Navigate to the sample directory and run:
+
+```powershell
+cd Agent_Step11_UsingImages
+dotnet run
+```
+
+## 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 image of a green walk
+3. The agent will analyze the image and provide a description
+4. Clean up resources by deleting the thread and agent
+
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step12_AsFunctionTool/Agent_Step12_AsFunctionTool.csproj
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step12_AsFunctionTool/Agent_Step12_AsFunctionTool.csproj
@@ -0,0 +1,22 @@
+<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.OpenAI" />
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+  
+</Project>
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step12_AsFunctionTool/Program.cs
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step12_AsFunctionTool/Program.cs
@@ -0,0 +1,38 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows how to create and use a Azure OpenAI AI agent as a function tool.
+
+using System.ComponentModel;
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+using OpenAI.Chat;
+
+var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_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.";
+
+// Create the chat client and agent, and provide the function tool to the agent.
+AIAgent weatherAgent = new AzureOpenAIClient(
+    new Uri(endpoint),
+    new AzureCliCredential())
+     .GetChatClient(deploymentName)
+     .AsAIAgent(
+        instructions: "You answer questions about the weather.",
+        name: "WeatherAgent",
+        description: "An agent that answers questions about the weather.",
+        tools: [AIFunctionFactory.Create(GetWeather)]);
+
+// Create the main agent, and provide the weather agent as a function tool.
+AIAgent agent = new AzureOpenAIClient(
+    new Uri(endpoint),
+    new AzureCliCredential())
+    .GetChatClient(deploymentName)
+    .AsAIAgent(instructions: "You are a helpful assistant who responds in French.", tools: [weatherAgent.AsAIFunction()]);
+
+// Invoke the agent and output the text result.
+Console.WriteLine(await agent.RunAsync("What is the weather like in Amsterdam?"));
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step13_BackgroundResponsesWithToolsAndPersistence/Agent_Step13_BackgroundResponsesWithToolsAndPersistence.csproj
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step13_BackgroundResponsesWithToolsAndPersistence/Agent_Step13_BackgroundResponsesWithToolsAndPersistence.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.OpenAI" />
+    <PackageReference Include="Azure.Identity" />
+  </ItemGroup>
+  
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+  
+</Project>
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step13_BackgroundResponsesWithToolsAndPersistence/Program.cs
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step13_BackgroundResponsesWithToolsAndPersistence/Program.cs
@@ -0,0 +1,110 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample demonstrates how to use background responses with ChatClientAgent and Azure OpenAI Responses for long-running operations.
+// It shows polling for completion using continuation tokens, function calling during background operations,
+// and persisting/restoring agent state between polling cycles.
+
+#pragma warning disable CA1050 // Declare types in namespaces
+
+using System.ComponentModel;
+using System.Text.Json;
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+using OpenAI.Responses;
+
+var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-5";
+
+var stateStore = new Dictionary<string, JsonElement?>();
+
+AIAgent agent = new AzureOpenAIClient(
+    new Uri(endpoint),
+    new AzureCliCredential())
+     .GetResponsesClient(deploymentName)
+     .AsAIAgent(
+        name: "SpaceNovelWriter",
+        instructions: "You are a space novel writer. Always research relevant facts and generate character profiles for the main characters before writing novels." +
+                      "Write complete chapters without asking for approval or feedback. Do not ask the user about tone, style, pace, or format preferences - just write the novel based on the request.",
+        tools: [AIFunctionFactory.Create(ResearchSpaceFactsAsync), AIFunctionFactory.Create(GenerateCharacterProfilesAsync)]);
+
+// Enable background responses (only supported by {Azure}OpenAI Responses at this time).
+AgentRunOptions options = new() { AllowBackgroundResponses = true };
+
+AgentThread thread = await agent.GetNewThreadAsync();
+
+// Start the initial run.
+AgentResponse response = await agent.RunAsync("Write a very long novel about a team of astronauts exploring an uncharted galaxy.", thread, options);
+
+// Poll for background responses until complete.
+while (response.ContinuationToken is not null)
+{
+    PersistAgentState(thread, response.ContinuationToken);
+
+    await Task.Delay(TimeSpan.FromSeconds(10));
+
+    var (restoredThread, continuationToken) = await RestoreAgentState(agent);
+
+    options.ContinuationToken = continuationToken;
+    response = await agent.RunAsync(restoredThread, options);
+}
+
+Console.WriteLine(response.Text);
+
+void PersistAgentState(AgentThread thread, ResponseContinuationToken? continuationToken)
+{
+    stateStore["thread"] = thread.Serialize();
+    stateStore["continuationToken"] = JsonSerializer.SerializeToElement(continuationToken, AgentAbstractionsJsonUtilities.DefaultOptions.GetTypeInfo(typeof(ResponseContinuationToken)));
+}
+
+async Task<(AgentThread Thread, ResponseContinuationToken? ContinuationToken)> RestoreAgentState(AIAgent agent)
+{
+    JsonElement serializedThread = stateStore["thread"] ?? throw new InvalidOperationException("No serialized thread found in state store.");
+    JsonElement? serializedToken = stateStore["continuationToken"];
+
+    AgentThread thread = await agent.DeserializeThreadAsync(serializedThread);
+    ResponseContinuationToken? continuationToken = (ResponseContinuationToken?)serializedToken?.Deserialize(AgentAbstractionsJsonUtilities.DefaultOptions.GetTypeInfo(typeof(ResponseContinuationToken)));
+
+    return (thread, continuationToken);
+}
+
+[Description("Researches relevant space facts and scientific information for writing a science fiction novel")]
+async Task<string> ResearchSpaceFactsAsync(string topic)
+{
+    Console.WriteLine($"[ResearchSpaceFacts] Researching topic: {topic}");
+
+    // Simulate a research operation
+    await Task.Delay(TimeSpan.FromSeconds(10));
+
+    string result = topic.ToUpperInvariant() switch
+    {
+        var t when t.Contains("GALAXY") => "Research findings: Galaxies contain billions of stars. Uncharted galaxies may have unique stellar formations, exotic matter, and unexplored phenomena like dark energy concentrations.",
+        var t when t.Contains("SPACE") || t.Contains("TRAVEL") => "Research findings: Interstellar travel requires advanced propulsion systems. Challenges include radiation exposure, life support, and navigation through unknown space.",
+        var t when t.Contains("ASTRONAUT") => "Research findings: Astronauts undergo rigorous training in zero-gravity environments, emergency protocols, spacecraft systems, and team dynamics for long-duration missions.",
+        _ => $"Research findings: General space exploration facts related to {topic}. Deep space missions require advanced technology, crew resilience, and contingency planning for unknown scenarios."
+    };
+
+    Console.WriteLine("[ResearchSpaceFacts] Research complete");
+    return result;
+}
+
+[Description("Generates character profiles for the main astronaut characters in the novel")]
+async Task<IEnumerable<string>> GenerateCharacterProfilesAsync()
+{
+    Console.WriteLine("[GenerateCharacterProfiles] Generating character profiles...");
+
+    // Simulate a character generation operation
+    await Task.Delay(TimeSpan.FromSeconds(10));
+
+    string[] profiles = [
+        "Captain Elena Voss: A seasoned mission commander with 15 years of experience. Strong-willed and decisive, she struggles with the weight of responsibility for her crew. Former military pilot turned astronaut.",
+            "Dr. James Chen: Chief science officer and astrophysicist. Brilliant but socially awkward, he finds solace in data and discovery. His curiosity often pushes the mission into uncharted territory.",
+            "Lieutenant Maya Torres: Navigation specialist and youngest crew member. Optimistic and tech-savvy, she brings fresh perspective and innovative problem-solving to challenges.",
+            "Commander Marcus Rivera: Chief engineer with expertise in spacecraft systems. Pragmatic and resourceful, he can fix almost anything with limited resources. Values crew safety above all.",
+            "Dr. Amara Okafor: Medical officer and psychologist. Empathetic and observant, she helps maintain crew morale and mental health during the long journey. Expert in space medicine."
+    ];
+
+    Console.WriteLine($"[GenerateCharacterProfiles] Generated {profiles.Length} character profiles");
+    return profiles;
+}
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step13_BackgroundResponsesWithToolsAndPersistence/README.md
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step13_BackgroundResponsesWithToolsAndPersistence/README.md
@@ -0,0 +1,28 @@
+# What This Sample Shows
+
+This sample demonstrates how to use background responses with ChatCompletionAgent and Azure OpenAI Responses for long-running operations. Background responses support:
+
+- **Polling for completion** - Non-streaming APIs can start a background operation and return a continuation token. Poll with the token until the response completes.
+- **Function calling** - Functions can be called during background operations.
+- **State persistence** - Thread and continuation token can be persisted and restored between polling cycles.
+
+> **Note:** Background responses are currently only supported by OpenAI Responses.
+
+For more information, see the [official documentation](https://learn.microsoft.com/en-us/agent-framework/user-guide/agents/agent-background-responses?pivots=programming-language-csharp).
+
+# Prerequisites
+
+Before you begin, ensure you have the following prerequisites:
+
+- .NET 10 SDK or later
+- Azure OpenAI 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 OpenAI 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_OPENAI_ENDPOINT="https://your-resource.openai.azure.com/" # Replace with your Azure OpenAI resource endpoint
+$env:AZURE_OPENAI_DEPLOYMENT_NAME="gpt-5"  # Optional, defaults to gpt-5
+```
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step14_Middleware/Agent_Step14_Middleware.csproj
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step14_Middleware/Agent_Step14_Middleware.csproj
@@ -0,0 +1,22 @@
+<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.OpenAI" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+	  <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI\Microsoft.Agents.AI.csproj" />
+  </ItemGroup>
+
+</Project>
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step14_Middleware/Program.cs
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step14_Middleware/Program.cs
@@ -0,0 +1,261 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows multiple middleware layers working together with Azure OpenAI:
+// chat client (global/per-request), 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.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+
+// Get Azure AI Foundry configuration from environment variables
+var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+var deploymentName = System.Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o";
+
+// Get a client to create/retrieve server side agents with
+var azureOpenAIClient = new AzureOpenAIClient(new Uri(endpoint), new AzureCliCredential())
+    .GetChatClient(deploymentName);
+
+[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();
+
+// Adding middleware to the chat client level and building an agent on top of it
+var originalAgent = azureOpenAIClient.AsIChatClient()
+    .AsBuilder()
+    .Use(getResponseFunc: ChatClientMiddleware, getStreamingResponseFunc: null)
+    .BuildAIAgent(
+        instructions: "You are an AI assistant that helps people find information.",
+        tools: [AIFunctionFactory.Create(GetDateTime, name: nameof(GetDateTime))]);
+
+// Adding middleware to the agent level
+var middlewareEnabledAgent = originalAgent
+    .AsBuilder()
+    .Use(FunctionCallMiddleware)
+    .Use(FunctionCallOverrideWeather)
+    .Use(PIIMiddleware, null)
+    .Use(GuardrailMiddleware, null)
+    .Build();
+
+var thread = await middlewareEnabledAgent.GetNewThreadAsync();
+
+Console.WriteLine("\n\n=== Example 1: Wording Guardrail ===");
+var guardRailedResponse = await middlewareEnabledAgent.RunAsync("Tell me something harmful.");
+Console.WriteLine($"Guard railed response: {guardRailedResponse}");
+
+Console.WriteLine("\n\n=== Example 2: PII detection ===");
+var 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.
+
+// Add Per-request tools
+var options = new ChatClientAgentRunOptions(new()
+{
+    Tools = [AIFunctionFactory.Create(GetWeather, name: nameof(GetWeather))]
+});
+
+var functionCallResponse = await middlewareEnabledAgent.RunAsync("What's the current time and the weather in Seattle?", thread, options);
+Console.WriteLine($"Function calling response: {functionCallResponse}");
+
+// Special per-request middleware agent.
+Console.WriteLine("\n\n=== Example 4: Per-request middleware with human in the loop function approval ===");
+
+var optionsWithApproval = new ChatClientAgentRunOptions(new()
+{
+    // Adding a function with approval required
+    Tools = [new ApprovalRequiredAIFunction(AIFunctionFactory.Create(GetWeather, name: nameof(GetWeather)))],
+})
+{
+    ChatClientFactory = (chatClient) => chatClient
+        .AsBuilder()
+        .Use(PerRequestChatClientMiddleware, null) // Using the non-streaming for handling streaming as well
+        .Build()
+};
+
+// var response = middlewareAgent  // Using per-request middleware pipeline in addition to existing agent-level middleware
+var response = await originalAgent // Using per-request middleware pipeline without existing agent-level middleware
+    .AsBuilder()
+    .Use(PerRequestFunctionCallingMiddleware)
+    .Use(ConsolePromptingApprovalMiddleware, null)
+    .Build()
+    .RunAsync("What's the current time and the weather in Seattle?", thread, optionsWithApproval);
+
+Console.WriteLine($"Per-request 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;
+}
+
+// There's no difference per-request middleware, except it's added to the agent and used for a single agent run.
+// This middleware logs function names before and after they are invoked.
+async ValueTask<object?> PerRequestFunctionCallingMiddleware(AIAgent agent, FunctionInvocationContext context, Func<FunctionInvocationContext, CancellationToken, ValueTask<object?>> next, CancellationToken cancellationToken)
+{
+    Console.WriteLine($"Agent Id: {agent.Id}");
+    Console.WriteLine($"Function Name: {context!.Function.Name} - Per-Request Pre-Invoke");
+    var result = await next(context, cancellationToken);
+    Console.WriteLine($"Function Name: {context!.Function.Name} - Per-Request 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)
+{
+    var response = await innerAgent.RunAsync(messages, thread, options, cancellationToken);
+
+    var 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}");
+                return new ChatMessage(ChatRole.User, [functionApprovalRequest.CreateResponse(Console.ReadLine()?.Equals("Y", StringComparison.OrdinalIgnoreCase) ?? false)]);
+            })
+            .ToList();
+
+        response = await innerAgent.RunAsync(response.Messages, thread, options, cancellationToken);
+
+        userInputRequests = response.UserInputRequests.ToList();
+    }
+
+    return response;
+}
+
+// This middleware handles chat client lower level invocations.
+// This is useful for handling agent messages before they are sent to the LLM and also handle any response messages from the LLM before they are sent back to the agent.
+async Task<ChatResponse> ChatClientMiddleware(IEnumerable<ChatMessage> message, ChatOptions? options, IChatClient innerChatClient, CancellationToken cancellationToken)
+{
+    Console.WriteLine("Chat Client Middleware - Pre-Chat");
+    var response = await innerChatClient.GetResponseAsync(message, options, cancellationToken);
+    Console.WriteLine("Chat Client Middleware - Post-Chat");
+
+    return response;
+}
+
+// There's no difference per-request middleware, except it's added to the chat client and used for a single agent run.
+// This middleware handles chat client lower level invocations.
+// This is useful for handling agent messages before they are sent to the LLM and also handle any response messages from the LLM before they are sent back to the agent.
+async Task<ChatResponse> PerRequestChatClientMiddleware(IEnumerable<ChatMessage> message, ChatOptions? options, IChatClient innerChatClient, CancellationToken cancellationToken)
+{
+    Console.WriteLine("Per-Request Chat Client Middleware - Pre-Chat");
+    var response = await innerChatClient.GetResponseAsync(message, options, cancellationToken);
+    Console.WriteLine("Per-Request Chat Client Middleware - Post-Chat");
+
+    return response;
+}
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step14_Middleware/README.md
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step14_Middleware/README.md
@@ -0,0 +1,41 @@
+# Agent Middleware 
+
+This sample demonstrates how to add middleware to intercept:
+- Chat client calls (global and per‑request)
+- Agent runs (guardrails and PII filtering)
+- Function calling (logging/override)
+
+## What This Sample Shows
+
+1. Azure OpenAI integration via `AzureOpenAIClient` and `AzureCliCredential`
+2. Chat client middleware using `ChatClientBuilder.Use(...)`
+3. Agent run middleware (PII redaction and wording guardrails)
+4. Function invocation middleware (logging and overriding a tool result)
+5. Per‑request chat client middleware
+6. Per‑request function pipeline with approval
+7. 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
+
+1. Environment variables:
+   - `AZURE_OPENAI_ENDPOINT`: Your Azure OpenAI endpoint
+   - `AZURE_OPENAI_DEPLOYMENT_NAME`: Chat deployment name (optional; defaults to `gpt-4o`)
+2. Sign in with Azure CLI (PowerShell):
+   ```powershell
+   az login
+   ```
+
+## Running the Sample
+
+Use PowerShell:
+```powershell
+cd dotnet/samples/GettingStarted/Agents/Agent_Step14_Middleware
+dotnet run
+```
+
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step15_Plugins/Agent_Step15_Plugins.csproj
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step15_Plugins/Agent_Step15_Plugins.csproj
@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <NoWarn>$(NoWarn);CA1812</NoWarn>
+    <RootNamespace>Agent_Step15_Plugins</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" />
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Azure.AI.OpenAI" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI\Microsoft.Agents.AI.csproj" />
+  </ItemGroup>
+  
+</Project>
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step15_Plugins/Program.cs
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step15_Plugins/Program.cs
@@ -0,0 +1,130 @@
+// 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.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+using Microsoft.Extensions.DependencyInjection;
+using OpenAI.Chat;
+
+var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+// 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();
+
+AIAgent agent = new AzureOpenAIClient(
+    new Uri(endpoint),
+    new AzureCliCredential())
+    .GetChatClient(deploymentName)
+    .AsAIAgent(
+        instructions: "You are a helpful assistant that helps people find information.",
+        name: "Assistant",
+        tools: [.. serviceProvider.GetRequiredService<AgentPlugin>().AsAITools()],
+        services: serviceProvider); // Pass the service provider to the agent so it will be available to plugin functions to resolve dependencies.
+
+Console.WriteLine(await agent.RunAsync("Tell me current time and weather in Seattle."));
+
+/// <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
+        var 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;
+    }
+}
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step16_ChatReduction/Agent_Step16_ChatReduction.csproj
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step16_ChatReduction/Agent_Step16_ChatReduction.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="Azure.AI.OpenAI" />
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Microsoft.Extensions.AI.OpenAI" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+
+</Project>
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step16_ChatReduction/Program.cs
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step16_ChatReduction/Program.cs
@@ -0,0 +1,49 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows how to use a chat history reducer to keep the context within model size limits.
+// Any implementation of Microsoft.Extensions.AI.IChatReducer can be used to customize how the chat history is reduced.
+// NOTE: this feature is only supported where the chat history is stored locally, such as with OpenAI Chat Completion.
+// Where the chat history is stored server side, such as with Azure Foundry Agents, the service must manage the chat history size.
+
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+using OpenAI.Chat;
+using ChatMessage = Microsoft.Extensions.AI.ChatMessage;
+
+var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+// Construct the agent, and provide a factory to create an in-memory chat message store with a reducer that keeps only the last 2 non-system messages.
+AIAgent agent = new AzureOpenAIClient(
+    new Uri(endpoint),
+    new AzureCliCredential())
+    .GetChatClient(deploymentName)
+    .AsAIAgent(new ChatClientAgentOptions
+    {
+        ChatOptions = new() { Instructions = "You are good at telling jokes." },
+        Name = "Joker",
+        ChatMessageStoreFactory = (ctx, ct) => new ValueTask<ChatMessageStore>(new InMemoryChatMessageStore(new MessageCountingChatReducer(2), ctx.SerializedState, ctx.JsonSerializerOptions))
+    });
+
+AgentThread thread = await agent.GetNewThreadAsync();
+
+// Invoke the agent and output the text result.
+Console.WriteLine(await agent.RunAsync("Tell me a joke about a pirate.", thread));
+
+// Get the chat history to see how many messages are stored.
+IList<ChatMessage>? chatHistory = thread.GetService<IList<ChatMessage>>();
+Console.WriteLine($"\nChat history has {chatHistory?.Count} messages.\n");
+
+// Invoke the agent a few more times.
+Console.WriteLine(await agent.RunAsync("Tell me a joke about a robot.", thread));
+Console.WriteLine($"\nChat history has {chatHistory?.Count} messages.\n");
+Console.WriteLine(await agent.RunAsync("Tell me a joke about a lemur.", thread));
+Console.WriteLine($"\nChat history has {chatHistory?.Count} messages.\n");
+
+// At this point, the chat history has exceeded the limit and the original message will not exist anymore,
+// so asking a follow up question about it will not work as expected.
+Console.WriteLine(await agent.RunAsync("Tell me the joke about the pirate again, but add emojis and use the voice of a parrot.", thread));
+
+Console.WriteLine($"\nChat history has {chatHistory?.Count} messages.\n");
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step17_BackgroundResponses/Agent_Step17_BackgroundResponses.csproj
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step17_BackgroundResponses/Agent_Step17_BackgroundResponses.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.OpenAI" />
+    <PackageReference Include="Azure.Identity" />
+  </ItemGroup>
+  
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+  
+</Project>
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step17_BackgroundResponses/Program.cs
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step17_BackgroundResponses/Program.cs
@@ -0,0 +1,70 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows how to use background responses with ChatClientAgent and Azure OpenAI Responses.
+
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using OpenAI.Responses;
+
+var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+AIAgent agent = new AzureOpenAIClient(
+    new Uri(endpoint),
+    new AzureCliCredential())
+     .GetResponsesClient(deploymentName)
+     .AsAIAgent();
+
+// Enable background responses (only supported by OpenAI Responses at this time).
+AgentRunOptions options = new() { AllowBackgroundResponses = true };
+
+AgentThread thread = await agent.GetNewThreadAsync();
+
+// Start the initial run.
+AgentResponse response = await agent.RunAsync("Write a very long novel about otters in space.", thread, options);
+
+// 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.
+    options.ContinuationToken = token;
+
+    response = await agent.RunAsync(thread, options);
+}
+
+// Display the result.
+Console.WriteLine(response.Text);
+
+// Reset options and thread for streaming.
+options = new() { AllowBackgroundResponses = true };
+thread = await agent.GetNewThreadAsync();
+
+AgentResponseUpdate? lastReceivedUpdate = null;
+// Start streaming.
+await foreach (AgentResponseUpdate update in agent.RunStreamingAsync("Write a very long novel about otters in space.", thread, options))
+{
+    // Output each update.
+    Console.Write(update.Text);
+
+    // Track last update.
+    lastReceivedUpdate = update;
+
+    // Simulate connection loss after first piece of content received.
+    if (update.Text.Length > 0)
+    {
+        break;
+    }
+}
+
+// Resume from interruption point.
+options.ContinuationToken = lastReceivedUpdate?.ContinuationToken;
+
+await foreach (AgentResponseUpdate update in agent.RunStreamingAsync(thread, options))
+{
+    // Output each update.
+    Console.Write(update.Text);
+}
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step17_BackgroundResponses/README.md
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step17_BackgroundResponses/README.md
@@ -0,0 +1,27 @@
+# What This Sample Shows
+
+This sample demonstrates how to use background responses with ChatCompletionAgent and Azure OpenAI Responses for long-running operations. Background responses support:
+
+- **Polling for completion** - Non-streaming APIs can start a background operation and return a continuation token. Poll with the token until the response completes.
+- **Resuming after interruption** - Streaming APIs can be interrupted and resumed from the last update using the continuation token.
+
+> **Note:** Background responses are currently only supported by OpenAI Responses.
+
+For more information, see the [official documentation](https://learn.microsoft.com/en-us/agent-framework/user-guide/agents/agent-background-responses?pivots=programming-language-csharp).
+
+# Prerequisites
+
+Before you begin, ensure you have the following prerequisites:
+
+- .NET 10 SDK or later
+- Azure OpenAI 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 OpenAI 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_OPENAI_ENDPOINT="https://your-resource.openai.azure.com/" # Replace with your Azure OpenAI resource endpoint
+$env:AZURE_OPENAI_DEPLOYMENT_NAME="gpt-4o-mini"  # Optional, defaults to gpt-4o-mini
+```
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step18_DeepResearch/Agent_Step18_DeepResearch.csproj
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step18_DeepResearch/Agent_Step18_DeepResearch.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.Agents.Persistent" />
+    <PackageReference Include="Azure.Identity" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI.Persistent\Microsoft.Agents.AI.AzureAI.Persistent.csproj" />
+  </ItemGroup>
+
+</Project>
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step18_DeepResearch/Program.cs
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step18_DeepResearch/Program.cs
@@ -0,0 +1,52 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows how to create an Azure AI Foundry Agent with the Deep Research Tool.
+
+using Azure.AI.Agents.Persistent;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+
+var endpoint = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_ENDPOINT") ?? throw new InvalidOperationException("AZURE_FOUNDRY_PROJECT_ENDPOINT is not set.");
+var deepResearchDeploymentName = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_DEEP_RESEARCH_DEPLOYMENT_NAME") ?? "o3-deep-research";
+var modelDeploymentName = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME") ?? "gpt-4o";
+var bingConnectionId = Environment.GetEnvironmentVariable("BING_CONNECTION_ID") ?? throw new InvalidOperationException("BING_CONNECTION_ID is not set.");
+
+// Configure extended network timeout for long-running Deep Research tasks.
+PersistentAgentsAdministrationClientOptions persistentAgentsClientOptions = new();
+persistentAgentsClientOptions.Retry.NetworkTimeout = TimeSpan.FromMinutes(20);
+
+// Get a client to create/retrieve server side agents with.
+PersistentAgentsClient persistentAgentsClient = new(endpoint, new AzureCliCredential(), persistentAgentsClientOptions);
+
+// Define and configure the Deep Research tool.
+DeepResearchToolDefinition deepResearchTool = new(new DeepResearchDetails(
+    bingGroundingConnections: [new(bingConnectionId)],
+    model: deepResearchDeploymentName)
+ );
+
+// Create an agent with the Deep Research tool on the Azure AI agent service.
+AIAgent agent = await persistentAgentsClient.CreateAIAgentAsync(
+    model: modelDeploymentName,
+    name: "DeepResearchAgent",
+    instructions: "You are a helpful Agent that assists in researching scientific topics.",
+    tools: [deepResearchTool]);
+
+const string Task = "Research the current state of studies on orca intelligence and orca language, " +
+    "including what is currently known about orcas' cognitive capabilities and communication systems.";
+
+Console.WriteLine($"# User: '{Task}'");
+Console.WriteLine();
+
+try
+{
+    AgentThread thread = await agent.GetNewThreadAsync();
+
+    await foreach (var response in agent.RunStreamingAsync(Task, thread))
+    {
+        Console.Write(response.Text);
+    }
+}
+finally
+{
+    await persistentAgentsClient.Administration.DeleteAgentAsync(agent.Id);
+}
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step18_DeepResearch/README.md
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step18_DeepResearch/README.md
@@ -0,0 +1,47 @@
+# What this sample demonstrates
+
+This sample demonstrates how to create an Azure AI Agent with the Deep Research Tool, which leverages the o3-deep-research reasoning model to perform comprehensive research on complex topics.
+
+Key features:
+- Configuring and using the Deep Research Tool with Bing grounding
+- Creating a persistent AI agent with deep research capabilities
+- Executing deep research queries and retrieving results
+
+## Prerequisites
+
+Before running this sample, ensure you have:
+
+1. An Azure AI Foundry project set up
+2. A deep research model deployment (e.g., o3-deep-research)
+3. A model deployment (e.g., gpt-4o)
+4. A Bing Connection configured in your Azure AI Foundry project
+5. Azure CLI installed and authenticated
+
+**Important**: Please visit the following documentation for detailed setup instructions:
+- [Deep Research Tool Documentation](https://aka.ms/agents-deep-research)
+- [Research Tool Setup](https://learn.microsoft.com/en-us/azure/ai-foundry/agents/how-to/tools/deep-research#research-tool-setup)
+
+Pay special attention to the purple `Note` boxes in the Azure documentation.
+
+**Note**: The Bing Connection ID must be from the **project**, not the resource. It has the following format:
+
+```
+/subscriptions/<sub_id>/resourceGroups/<rg_name>/providers/<provider_name>/accounts/<account_name>/projects/<project_name>/connections/<connection_name>
+```
+
+## Environment Variables
+
+Set the following environment variables:
+
+```powershell
+# Replace with your Azure AI Foundry project endpoint
+$env:AZURE_FOUNDRY_PROJECT_ENDPOINT="https://your-project.services.ai.azure.com/"
+
+# Replace with your Bing connection ID from the project
+$env:BING_CONNECTION_ID="/subscriptions/.../connections/your-bing-connection"
+
+# Optional, defaults to o3-deep-research
+$env:AZURE_FOUNDRY_PROJECT_DEEP_RESEARCH_DEPLOYMENT_NAME="o3-deep-research"
+
+# Optional, defaults to gpt-4o
+$env:AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME="gpt-4o"
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step19_Declarative/Agent_Step19_Declarative.csproj
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step19_Declarative/Agent_Step19_Declarative.csproj
@@ -0,0 +1,25 @@
+<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.OpenAI" />
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Microsoft.Extensions.AI.OpenAI" />
+    <PackageReference Include="Microsoft.Bot.ObjectModel" />
+    <PackageReference Include="Microsoft.Bot.ObjectModel.Json" />
+    <PackageReference Include="Microsoft.Bot.ObjectModel.PowerFx" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.Declarative\Microsoft.Agents.AI.Declarative.csproj" />
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+
+</Project>
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step19_Declarative/Program.cs
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step19_Declarative/Program.cs
@@ -0,0 +1,54 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows how to create an agent from a YAML based declarative representation.
+
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+
+var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+// Create the chat client
+IChatClient chatClient = new AzureOpenAIClient(
+    new Uri(endpoint),
+    new AzureCliCredential())
+     .GetChatClient(deploymentName)
+     .AsIChatClient();
+
+// Define the agent using a YAML definition.
+var text =
+    """
+    kind: Prompt
+    name: Assistant
+    description: Helpful assistant
+    instructions: You are a helpful assistant. You answer questions in the language specified by the user. You return your answers in a JSON format.
+    model:
+        options:
+            temperature: 0.9
+            topP: 0.95
+    outputSchema:
+        properties:
+            language:
+                type: string
+                required: true
+                description: The language of the answer.
+            answer:
+                type: string
+                required: true
+                description: The answer text.
+    """;
+
+// Create the agent from the YAML definition.
+var agentFactory = new ChatClientPromptAgentFactory(chatClient);
+var agent = await agentFactory.CreateFromYamlAsync(text);
+
+// Invoke the agent and output the text result.
+Console.WriteLine(await agent!.RunAsync("Tell me a joke about a pirate in English."));
+
+// Invoke the agent with streaming support.
+await foreach (var update in agent!.RunStreamingAsync("Tell me a joke about a pirate in French."))
+{
+    Console.WriteLine(update);
+}
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step20_AdditionalAIContext/Agent_Step20_AdditionalAIContext.csproj
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step20_AdditionalAIContext/Agent_Step20_AdditionalAIContext.csproj
@@ -0,0 +1,25 @@
+<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.OpenAI" />
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Microsoft.Extensions.AI.OpenAI" />
+    <PackageReference Include="Microsoft.Bot.ObjectModel" />
+    <PackageReference Include="Microsoft.Bot.ObjectModel.Json" />
+    <PackageReference Include="Microsoft.Bot.ObjectModel.PowerFx" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.Declarative\Microsoft.Agents.AI.Declarative.csproj" />
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+
+</Project>
--- a/dotnet/samples/GettingStarted/Agents/Agent_Step20_AdditionalAIContext/Program.cs
+++ b/dotnet/samples/GettingStarted/Agents/Agent_Step20_AdditionalAIContext/Program.cs
@@ -0,0 +1,228 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample shows how to inject additional AI context into a ChatClientAgent using a custom AIContextProvider component that is attached to the agent.
+// The sample also shows how to combine the results from multiple providers into a single class, in order to attach multiple of these to an agent.
+// This mechanism can be used for various purposes, such as injecting RAG search results or memories into the agent's context.
+// Also note that Agent Framework already provides built-in AIContextProviders for many of these scenarios.
+
+#pragma warning disable CA1869 // Cache and reuse 'JsonSerializerOptions' instances
+
+using System.ComponentModel;
+using System.Text;
+using System.Text.Json;
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+using OpenAI.Chat;
+using SampleApp;
+using MEAI = Microsoft.Extensions.AI;
+
+var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-5-mini";
+
+// A sample function to load the next three calendar events for the user.
+Func<Task<string[]>> loadNextThreeCalendarEvents = async () =>
+{
+    // In a real implementation, this method would connect to a calendar service
+    return new string[]
+    {
+        "Doctor's appointment today at 15:00",
+        "Team meeting today at 17:00",
+        "Birthday party today at 20:00"
+    };
+};
+
+// Create an agent with an AI context provider attached that aggregates two other providers:
+AIAgent agent = new AzureOpenAIClient(
+    new Uri(endpoint),
+    new AzureCliCredential())
+    .GetChatClient(deploymentName)
+    .AsAIAgent(new ChatClientAgentOptions()
+    {
+        ChatOptions = new() { Instructions = """
+        You are a helpful personal assistant.
+        You manage a TODO list for the user. When the user has completed one of the tasks it can be removed from the TODO list. Only provide the list of TODO items if asked.
+        You remind users of upcoming calendar events when the user interacts with you.
+        """ },
+        ChatMessageStoreFactory = (ctx, ct) => new ValueTask<ChatMessageStore>(new InMemoryChatMessageStore()
+            // Use WithAIContextProviderMessageRemoval, so that we don't store the messages from the AI context provider in the chat history.
+            // You may want to store these messages, depending on their content and your requirements.
+            .WithAIContextProviderMessageRemoval()),
+        // Add an AI context provider that maintains a todo list for the agent and one that provides upcoming calendar entries.
+        // Wrap these in an AI context provider that aggregates the other two.
+        AIContextProviderFactory = (ctx, ct) => new ValueTask<AIContextProvider>(new AggregatingAIContextProvider([
+            AggregatingAIContextProvider.CreateFactory((jsonElement, jsonSerializerOptions) => new TodoListAIContextProvider(jsonElement, jsonSerializerOptions)),
+            AggregatingAIContextProvider.CreateFactory((_, _) => new CalendarSearchAIContextProvider(loadNextThreeCalendarEvents))
+        ], ctx.SerializedState, ctx.JsonSerializerOptions)),
+    });
+
+// Invoke the agent and output the text result.
+AgentThread thread = await agent.GetNewThreadAsync();
+Console.WriteLine(await agent.RunAsync("I need to pick up milk from the supermarket.", thread) + "\n");
+Console.WriteLine(await agent.RunAsync("I need to take Sally for soccer practice.", thread) + "\n");
+Console.WriteLine(await agent.RunAsync("I need to make a dentist appointment for Jimmy.", thread) + "\n");
+Console.WriteLine(await agent.RunAsync("I've taken Sally to soccer practice.", thread) + "\n");
+
+// We can serialize the thread, and it will contain both the chat history and the data that each AI context provider serialized.
+JsonElement serializedThread = thread.Serialize();
+// Let's print it to console to show the contents.
+Console.WriteLine(JsonSerializer.Serialize(serializedThread, options: new JsonSerializerOptions() { WriteIndented = true, IndentSize = 2 }) + "\n");
+// The serialized thread can be stored long term in a persistent store, but in this case we will just deserialize again and continue the conversation.
+thread = await agent.DeserializeThreadAsync(serializedThread);
+
+Console.WriteLine(await agent.RunAsync("Considering my appointments, can you create a plan for my day that plans out when I should complete the items on my todo list?", thread) + "\n");
+
+namespace SampleApp
+{
+    /// <summary>
+    /// An <see cref="AIContextProvider"/>, which maintains a todo list for the agent.
+    /// </summary>
+    internal sealed class TodoListAIContextProvider : AIContextProvider
+    {
+        private readonly List<string> _todoItems = new();
+
+        public TodoListAIContextProvider(JsonElement jsonElement, JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            // Only try and restore the state if we got an array, since any other json would be invalid or undefined/null meaning
+            // it's the first time we are running.
+            if (jsonElement.ValueKind == JsonValueKind.Array)
+            {
+                this._todoItems = JsonSerializer.Deserialize<List<string>>(jsonElement.GetRawText(), jsonSerializerOptions) ?? new List<string>();
+            }
+        }
+
+        public override ValueTask<AIContext> InvokingAsync(InvokingContext context, CancellationToken cancellationToken = default)
+        {
+            StringBuilder outputMessageBuilder = new();
+            outputMessageBuilder.AppendLine("Your todo list contains the following items:");
+
+            if (this._todoItems.Count == 0)
+            {
+                outputMessageBuilder.AppendLine("  (no items)");
+            }
+            else
+            {
+                for (int i = 0; i < this._todoItems.Count; i++)
+                {
+                    outputMessageBuilder.AppendLine($"{i}. {this._todoItems[i]}");
+                }
+            }
+
+            return new ValueTask<AIContext>(new AIContext
+            {
+                Tools = [AIFunctionFactory.Create(this.AddTodoItem), AIFunctionFactory.Create(this.RemoveTodoItem)],
+                Messages = [new MEAI.ChatMessage(ChatRole.User, outputMessageBuilder.ToString())]
+            });
+        }
+
+        [Description("Adds an item to the todo list. Index is zero based.")]
+        private void RemoveTodoItem(int index) =>
+            this._todoItems.RemoveAt(index);
+
+        private void AddTodoItem(string item) =>
+            this._todoItems.Add(string.IsNullOrWhiteSpace(item) ? throw new ArgumentException("Item must have a value") : item);
+
+        public override JsonElement Serialize(JsonSerializerOptions? jsonSerializerOptions = null) =>
+            JsonSerializer.SerializeToElement(this._todoItems, jsonSerializerOptions);
+    }
+
+    /// <summary>
+    /// An <see cref="AIContextProvider"/> which searches for upcoming calendar events and adds them to the AI context.
+    /// </summary>
+    internal sealed class CalendarSearchAIContextProvider(Func<Task<string[]>> loadNextThreeCalendarEvents) : AIContextProvider
+    {
+        public override async ValueTask<AIContext> InvokingAsync(InvokingContext context, CancellationToken cancellationToken = default)
+        {
+            var events = await loadNextThreeCalendarEvents();
+
+            StringBuilder outputMessageBuilder = new();
+            outputMessageBuilder.AppendLine("You have the following upcoming calendar events:");
+            foreach (var calendarEvent in events)
+            {
+                outputMessageBuilder.AppendLine($" - {calendarEvent}");
+            }
+
+            return new()
+            {
+                Messages =
+                [
+                    new MEAI.ChatMessage(ChatRole.User, outputMessageBuilder.ToString()),
+                ]
+            };
+        }
+    }
+
+    /// <summary>
+    /// An <see cref="AIContextProvider"/> which aggregates multiple AI context providers into one.
+    /// Serialized state for the different providers are stored under their type name.
+    /// Tools and messages from all providers are combined, and instructions are concatenated.
+    /// </summary>
+    internal sealed class AggregatingAIContextProvider : AIContextProvider
+    {
+        private readonly List<AIContextProvider> _providers = new();
+
+        public AggregatingAIContextProvider(ProviderFactory[] providerFactories, JsonElement jsonElement, JsonSerializerOptions? jsonSerializerOptions)
+        {
+            // We received a json object, so let's check if it has some previously serialized state that we can use.
+            if (jsonElement.ValueKind == JsonValueKind.Object)
+            {
+                this._providers = providerFactories
+                    .Select(factory => factory.FactoryMethod(jsonElement.TryGetProperty(factory.ProviderType.Name, out var prop) ? prop : default, jsonSerializerOptions))
+                    .ToList();
+                return;
+            }
+
+            // We didn't receive any valid json, so we can just construct fresh providers.
+            this._providers = providerFactories
+                .Select(factory => factory.FactoryMethod(default, jsonSerializerOptions))
+                .ToList();
+        }
+
+        public override async ValueTask<AIContext> InvokingAsync(InvokingContext context, CancellationToken cancellationToken = default)
+        {
+            // Invoke all the sub providers.
+            var tasks = this._providers.Select(provider => provider.InvokingAsync(context, cancellationToken).AsTask());
+            var results = await Task.WhenAll(tasks);
+
+            // Combine the results from each sub provider.
+            return new AIContext
+            {
+                Tools = results.SelectMany(r => r.Tools ?? []).ToList(),
+                Messages = results.SelectMany(r => r.Messages ?? []).ToList(),
+                Instructions = string.Join("\n", results.Select(r => r.Instructions).Where(s => !string.IsNullOrEmpty(s)))
+            };
+        }
+
+        public override JsonElement Serialize(JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            Dictionary<string, JsonElement> elements = new();
+            foreach (var provider in this._providers)
+            {
+                JsonElement element = provider.Serialize(jsonSerializerOptions);
+
+                // Don't try to store state for any providers that aren't producing any.
+                if (element.ValueKind != JsonValueKind.Undefined && element.ValueKind != JsonValueKind.Null)
+                {
+                    elements[provider.GetType().Name] = element;
+                }
+            }
+
+            return JsonSerializer.SerializeToElement(elements, jsonSerializerOptions);
+        }
+
+        public static ProviderFactory CreateFactory<TProviderType>(Func<JsonElement, JsonSerializerOptions?, TProviderType> factoryMethod)
+            where TProviderType : AIContextProvider => new()
+            {
+                FactoryMethod = (jsonElement, jsonSerializerOptions) => factoryMethod(jsonElement, jsonSerializerOptions),
+                ProviderType = typeof(TProviderType)
+            };
+
+        public readonly struct ProviderFactory
+        {
+            public Func<JsonElement, JsonSerializerOptions?, AIContextProvider> FactoryMethod { get; init; }
+
+            public Type ProviderType { get; init; }
+        }
+    }
+}
--- a/dotnet/samples/GettingStarted/Agents/README.md
+++ b/dotnet/samples/GettingStarted/Agents/README.md
@@ -0,0 +1,90 @@
+# Getting started with agents
+
+The getting started with agents samples demonstrate the fundamental concepts and functionalities
+of single agents and can be used with any agent type.
+
+While the functionality can be used with any agent type, these samples use Azure OpenAI as the AI provider
+and use ChatCompletion as the type of service.
+
+For other samples that demonstrate how to create and configure each type of agent that come with the agent framework,
+see the [How to create an agent for each provider](../AgentProviders/README.md) samples.
+
+## Getting started with agents prerequisites
+
+Before you begin, ensure you have the following prerequisites:
+
+- .NET 10 SDK or later
+- Azure OpenAI service endpoint and deployment configured
+- Azure CLI installed and authenticated (for Azure credential authentication)
+- User has the `Cognitive Services OpenAI Contributor` role for the Azure OpenAI resource.
+
+**Note**: These samples use Azure OpenAI models. For more information, see [how to deploy Azure OpenAI models with Azure AI Foundry](https://learn.microsoft.com/en-us/azure/ai-foundry/how-to/deploy-models-openai).
+
+**Note**: These samples use Azure CLI credentials for authentication. Make sure you're logged in with `az login` and have access to the Azure OpenAI resource and have the `Cognitive Services OpenAI Contributor` role. For more information, see the [Azure CLI documentation](https://learn.microsoft.com/cli/azure/authenticate-azure-cli-interactively).
+
+## Samples
+
+|Sample|Description|
+|---|---|
+|[Running a simple agent](./Agent_Step01_Running/)|This sample demonstrates how to create and run a basic agent with instructions|
+|[Multi-turn conversation with a simple agent](./Agent_Step02_MultiturnConversation/)|This sample demonstrates how to implement a multi-turn conversation with a simple agent|
+|[Using function tools with a simple agent](./Agent_Step03_UsingFunctionTools/)|This sample demonstrates how to use function tools with a simple agent|
+|[Using OpenAPI function tools with a simple agent](https://github.com/microsoft/semantic-kernel/tree/main/dotnet/samples/AgentFrameworkMigration/AzureOpenAI/Step04_ToolCall_WithOpenAPI)|This sample demonstrates how to create function tools from an OpenAPI spec and use them with a simple agent (note that this sample is in the Semantic Kernel repository)|
+|[Using function tools with approvals](./Agent_Step04_UsingFunctionToolsWithApprovals/)|This sample demonstrates how to use function tools where approvals require human in the loop approvals before execution|
+|[Structured output with a simple agent](./Agent_Step05_StructuredOutput/)|This sample demonstrates how to use structured output with a simple agent|
+|[Persisted conversations with a simple agent](./Agent_Step06_PersistedConversations/)|This sample demonstrates how to persist conversations and reload them later. This is useful for cases where an agent is hosted in a stateless service|
+|[3rd party thread storage with a simple agent](./Agent_Step07_3rdPartyThreadStorage/)|This sample demonstrates how to store conversation history in a 3rd party storage solution|
+|[Observability with a simple agent](./Agent_Step08_Observability/)|This sample demonstrates how to add telemetry to a simple agent|
+|[Dependency injection with a simple agent](./Agent_Step09_DependencyInjection/)|This sample demonstrates how to add and resolve an agent with a dependency injection container|
+|[Exposing a simple agent as MCP tool](./Agent_Step10_AsMcpTool/)|This sample demonstrates how to expose an agent as an MCP tool|
+|[Using images with a simple agent](./Agent_Step11_UsingImages/)|This sample demonstrates how to use image multi-modality with an AI agent|
+|[Exposing a simple agent as a function tool](./Agent_Step12_AsFunctionTool/)|This sample demonstrates how to expose an agent as a function tool|
+|[Background responses with tools and persistence](./Agent_Step13_BackgroundResponsesWithToolsAndPersistence/)|This sample demonstrates advanced background response scenarios including function calling during background operations and state persistence|
+|[Using middleware with an agent](./Agent_Step14_Middleware/)|This sample demonstrates how to use middleware with an agent|
+|[Using plugins with an agent](./Agent_Step15_Plugins/)|This sample demonstrates how to use plugins with an agent|
+|[Reducing chat history size](./Agent_Step16_ChatReduction/)|This sample demonstrates how to reduce the chat history to constrain its size, where chat history is maintained locally|
+|[Background responses](./Agent_Step17_BackgroundResponses/)|This sample demonstrates how to use background responses for long-running operations with polling and resumption support|
+|[Deep research with an agent](./Agent_Step18_DeepResearch/)|This sample demonstrates how to use the Deep Research Tool to perform comprehensive research on complex topics|
+|[Declarative agent](./Agent_Step19_Declarative/)|This sample demonstrates how to declaratively define an agent.|
+|[Providing additional AI Context to an agent using multiple AIContextProviders](./Agent_Step20_AdditionalAIContext/)|This sample demonstrates how to inject additional AI context into a ChatClientAgent using multiple custom AIContextProvider components that are attached to the agent.|
+
+## Running the samples from the console
+
+To run the samples, navigate to the desired sample directory, e.g.
+
+```powershell
+cd Agents_Step01_Running
+```
+
+Set the following environment variables:
+
+```powershell
+$env:AZURE_OPENAI_ENDPOINT="https://your-resource.openai.azure.com/" # Replace with your Azure OpenAI resource endpoint
+$env:AZURE_OPENAI_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.