.NET: Add decorator for structured output support

dotnet/samples/GettingStarted/Agents/Agent_Step05_StructuredOutput/Program.cs

@@ -8,64 +8,164 @@
 using Azure.AI.OpenAI;
 using Azure.Identity;
 using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
 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";
+string endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+string 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.");
+// Demonstrates how to work with structured output via ResponseFormat with the non-generic RunAsync method.
+// This approach is useful when:
+// a. Structured output is used for inter-agent communication, where one agent produces structured output
+//    and passes it as text to another agent as input, without the need for the caller to directly work with the structured output.
+// b. The type of the structured output is not known at compile time, so the generic RunAsync<T> method cannot be used.
+// c. The type of the structured output is represented by JSON schema only, without a corresponding class or type in the code.
+await UseStructuredOutputWithResponseFormatAsync(chatClient);
 
-// 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.");
+// Demonstrates how to work with structured output via the generic RunAsync<T> method.
+// This approach is useful when the caller needs to directly work with the structured output in the code
+// via an instance of the corresponding class or type and the type is known at compile time.
+await UseStructuredOutputWithRunAsync(chatClient);
 
-// 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}");
+// Demonstrates how to work with structured output when streaming using the RunStreamingAsync method.
+await UseStructuredOutputWithRunStreamingAsync(chatClient);
 
-// Create the ChatClientAgent with the specified name, instructions, and expected structured output the agent should produce.
-ChatClientAgent agentWithPersonInfo = chatClient.AsAIAgent(new ChatClientAgentOptions()
+// Demonstrates how to add structured output support to agents that don't natively support it using the structured output middleware.
+// This approach is useful when working with agents that don't support structured output natively, like A2A, or agents using models
+// that don't have the capability to produce structured output, allowing you to still leverage structured output features by transforming
+// the text output from the agent into structured data using a chat client.
+await UseStructuredOutputWithMiddlewareAsync(chatClient);
+
+static async Task UseStructuredOutputWithResponseFormatAsync(ChatClient chatClient)
+{
+    Console.WriteLine("=== Structured Output with ResponseFormat ===");
+
+    // Create the agent
+    AIAgent agent = chatClient.AsAIAgent(new ChatClientAgentOptions()
+    {
+        Name = "HelpfulAssistant",
+        ChatOptions = new()
+        {
+            Instructions = "You are a helpful assistant.",
+            // Specify CityInfo as the type parameter of ForJsonSchema to indicate the expected structured output from the agent.
+            ResponseFormat = Microsoft.Extensions.AI.ChatResponseFormat.ForJsonSchema<CityInfo>()
+        }
+    });
+
+    // Invoke the agent with some unstructured input to extract the structured information from.
+    AgentResponse response = await agent.RunAsync("Provide information about the capital of France.");
+
+    // Access the structured output via the Text property of the agent response.
+    Console.WriteLine("Assistant Output:");
+    Console.WriteLine(response.Text);
+    Console.WriteLine();
+}
+
+static async Task UseStructuredOutputWithRunAsync(ChatClient chatClient)
+{
+    Console.WriteLine("=== Structured Output with RunAsync<T> ===");
+
+    // Create the agent
+    AIAgent agent = chatClient.AsAIAgent(name: "HelpfulAssistant", instructions: "You are a helpful assistant.");
+
+    // Set CityInfo as the type parameter of RunAsync method to specify the expected structured output from the agent and invoke it with some unstructured input.
+    AgentResponse<CityInfo> response = await agent.RunAsync<CityInfo>("Provide information about the capital of France.");
+
+    // Access the structured output via the Result property of the agent response.
+    CityInfo cityInfo = response.Result;
+
+    Console.WriteLine("Assistant Output:");
+    Console.WriteLine($"Name: {cityInfo.Name}");
+    Console.WriteLine();
+}
+
+static async Task UseStructuredOutputWithRunStreamingAsync(ChatClient chatClient)
+{
+    Console.WriteLine("=== Structured Output with RunStreamingAsync ===");
+
+    // Create the agent
+    AIAgent agent = chatClient.AsAIAgent(new ChatClientAgentOptions()
+    {
+        Name = "HelpfulAssistant",
+        ChatOptions = new()
+        {
+            Instructions = "You are a helpful assistant.",
+            // Specify CityInfo as the type parameter of ForJsonSchema to indicate the expected structured output from the agent.
+            ResponseFormat = Microsoft.Extensions.AI.ChatResponseFormat.ForJsonSchema<CityInfo>()
+        }
+    });
+
+    // Invoke the agent with some unstructured input while streaming, to extract the structured information from.
+    IAsyncEnumerable<AgentResponseUpdate> updates = agent.RunStreamingAsync("Provide information about the capital of France.");
+
+    // Assemble all the parts of the streamed output.
+    AgentResponse nonGenericResponse = await updates.ToAgentResponseAsync();
+
+    // Access the structured output by deserializing JSON in the Text property.
+    CityInfo cityInfo = JsonSerializer.Deserialize<CityInfo>(nonGenericResponse.Text)!;
+
+    Console.WriteLine("Assistant Output:");
+    Console.WriteLine($"Name: {cityInfo.Name}");
+    Console.WriteLine();
+}
+
+static async Task UseStructuredOutputWithMiddlewareAsync(ChatClient chatClient)
 {
-    Name = "HelpfulAssistant",
-    ChatOptions = new() { Instructions = "You are a helpful assistant.", ResponseFormat = Microsoft.Extensions.AI.ChatResponseFormat.ForJsonSchema<PersonInfo>() }
-});
+    Console.WriteLine("=== Structured Output with UseStructuredOutput Middleware ===");
+
+    // Create chat client that will transform the agent text response into structured output.
+    IChatClient meaiChatClient = chatClient.AsIChatClient();
+
+    // Create the agent
+    AIAgent agent = meaiChatClient.AsAIAgent(name: "HelpfulAssistant", instructions: "You are a helpful assistant.");
 
-// 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.");
+    // Add structured output middleware via UseStructuredOutput method to add structured output support to the agent.
+    // This middleware transforms the agent's text response into structured data using a chat client.
+    // Since our agent does support structured output natively, we will add a middleware that removes ResponseFormat
+    //  from the AgentRunOptions to emulate an agent that doesn't support structured output natively
+    agent = agent
+        .AsBuilder()
+        .UseStructuredOutput(meaiChatClient)
+        .Use(ResponseFormatRemovalMiddleware, null)
+        .Build();
 
-// 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 = JsonSerializer.Deserialize<PersonInfo>((await updates.ToAgentResponseAsync()).Text, JsonSerializerOptions.Web)!;
+    // Set CityInfo as the type parameter of RunAsync method to specify the expected structured output from the agent and invoke it with some unstructured input.
+    AgentResponse<CityInfo> response = await agent.RunAsync<CityInfo>("Provide information about the capital of France.");
 
-Console.WriteLine("Assistant Output:");
-Console.WriteLine($"Name: {personInfo.Name}");
-Console.WriteLine($"Age: {personInfo.Age}");
-Console.WriteLine($"Occupation: {personInfo.Occupation}");
+    // Access the structured output via the Result property of the agent response.
+    CityInfo cityInfo = response.Result;
+
+    Console.WriteLine("Assistant Output:");
+    Console.WriteLine($"Name: {cityInfo.Name}");
+    Console.WriteLine();
+}
+
+static Task<AgentResponse> ResponseFormatRemovalMiddleware(IEnumerable<ChatMessage> messages, AgentSession? session, AgentRunOptions? options, AIAgent innerAgent, CancellationToken cancellationToken)
+{
+    // Remove any ResponseFormat from the options to emulate an agent that doesn't support structured output natively.
+    options = options?.Clone();
+    options?.ResponseFormat = null;
+
+    return innerAgent.RunAsync(messages, session, options, cancellationToken);
+}
 
 namespace SampleApp
 {
     /// <summary>
-    /// Represents information about a person, including their name, age, and occupation, matched to the JSON schema used in the agent.
+    /// Represents information about a city, including its name.
     /// </summary>
-    [Description("Information about a person including their name, age, and occupation")]
-    public class PersonInfo
+    [Description("Information about a city")]
+    public sealed class CityInfo
     {
         [JsonPropertyName("name")]
         public string? Name { get; set; }
-
-        [JsonPropertyName("age")]
-        public int? Age { get; set; }
-
-        [JsonPropertyName("occupation")]
-        public string? Occupation { get; set; }
     }
 }

dotnet/samples/GettingStarted/Agents/Agent_Step05_StructuredOutput/README.md

@@ -0,0 +1,52 @@
+# Structured Output with ChatClientAgent
+
+This sample demonstrates how to configure ChatClientAgent to produce structured output in JSON format using various approaches.
+
+## What this sample demonstrates
+
+- **ResponseFormat approach**: Configuring agents with JSON schema response format via `ChatResponseFormat.ForJsonSchema<T>()` for inter-agent communication or when the type is not known at compile time
+- **Generic RunAsync<T> method**: Using the generic `RunAsync<T>` method for structured output when the caller needs to work directly with typed objects
+- **Structured output with Streaming**: Using `RunStreamingAsync` to stream responses while still obtaining structured output by assembling and deserializing the streamed content
+- **StructuredOutput middleware**: Adding structured output support to agents that don't natively support it (like A2A agents or models without structured output capability) by transforming text output into structured data using a chat client
+
+## 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**: This sample uses 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**: 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 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).
+
+## Environment Variables
+
+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
+```
+
+## Run the sample
+
+Navigate to the sample directory and run:
+
+```powershell
+cd dotnet/samples/GettingStarted/Agents/Agent_Step05_StructuredOutput
+dotnet run
+```
+
+## Expected behavior
+
+The sample will demonstrate four different approaches to structured output:
+
+1. **Structured Output with ResponseFormat**: Creates an agent with `ResponseFormat` set to `ForJsonSchema<CityInfo>()`, invokes it with unstructured input, and accesses the structured output via the `Text` property
+2. **Structured Output with RunAsync<T>**: Creates an agent and uses the generic `RunAsync<CityInfo>()` method to get a typed `AgentResponse<CityInfo>` with the result accessible via the `Result` property
+3. **Structured Output with RunStreamingAsync**: Creates an agent with JSON schema response format, streams the response using `RunStreamingAsync`, assembles the updates using `ToAgentResponseAsync()`, and deserializes the JSON text into a typed object
+4. **Structured Output with StructuredOutput Middleware**: Uses the `UseStructuredOutput` method on `AIAgentBuilder` to add structured output support to agents that don't natively support it
+
+Each approach will output information about the capital of France (Paris) in a structured format.

dotnet/src/Microsoft.Agents.AI.Abstractions/AgentResponse{T}.cs

@@ -11,6 +11,7 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using System.Text.Json.Serialization.Metadata;
+using Microsoft.Extensions.AI;
 
 namespace Microsoft.Agents.AI;
 
@@ -32,6 +33,16 @@ public AgentResponse(AgentResponse response, JsonSerializerOptions serializerOpt
         this._serializerOptions = serializerOptions;
     }
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AgentResponse{T}"/> class.
+    /// </summary>
+    /// <param name="response">The <see cref="ChatResponse"/> from which to populate this <see cref="AgentResponse{T}"/>.</param>
+    /// <param name="serializerOptions">The <see cref="JsonSerializerOptions"/> to use when deserializing the result.</param>
+    public AgentResponse(ChatResponse response, JsonSerializerOptions serializerOptions) : base(response)
+    {
+        this._serializerOptions = serializerOptions;
+    }
+
     /// <summary>
     /// Gets the result value of the agent response as an instance of <typeparamref name="T"/>.
     /// </summary>

dotnet/src/Microsoft.Agents.AI/StructuredOutput/AIAgentBuilderExtensions.cs

@@ -0,0 +1,46 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using Microsoft.Extensions.AI;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Shared.Diagnostics;
+
+namespace Microsoft.Agents.AI;
+
+/// <summary>
+/// Provides extension methods for adding structured output capabilities to <see cref="AIAgentBuilder"/> instances.
+/// </summary>
+public static class AIAgentBuilderExtensions
+{
+    /// <summary>
+    /// Adds structured output capabilities to the agent pipeline, enabling conversion of text responses to structured JSON format.
+    /// </summary>
+    /// <param name="builder">The <see cref="AIAgentBuilder"/> to which structured output support will be added.</param>
+    /// <param name="chatClient">
+    /// The chat client used to transform text responses into structured JSON format.
+    /// If <see langword="null"/>, the chat client will be resolved from the service provider.
+    /// </param>
+    /// <param name="optionsFactory">
+    /// An optional factory function that returns the <see cref="StructuredOutputAgentOptions"/> instance to use.
+    /// This allows for fine-tuning the structured output behavior such as setting the response format or system message.
+    /// </param>
+    /// <returns>The <see cref="AIAgentBuilder"/> with structured output capabilities added, enabling method chaining.</returns>
+    /// <remarks>
+    /// <para>
+    /// A <see cref="ChatResponseFormatJson"/> must be specified either through the
+    /// <see cref="AgentRunOptions.ResponseFormat"/> at runtime or the <see cref="StructuredOutputAgentOptions.ChatOptions"/>
+    /// provided during configuration.
+    /// </para>
+    /// </remarks>
+    public static AIAgentBuilder UseStructuredOutput(
+        this AIAgentBuilder builder,
+        IChatClient? chatClient = null,
+        Func<StructuredOutputAgentOptions>? optionsFactory = null) =>
+        Throw.IfNull(builder).Use((innerAgent, services) =>
+        {
+            chatClient ??= services?.GetService<IChatClient>()
+                ?? throw new InvalidOperationException($"No {nameof(IChatClient)} was provided and none could be resolved from the service provider. Either provide an {nameof(IChatClient)} explicitly or register one in the dependency injection container.");
+
+            return new StructuredOutputAgent(innerAgent, chatClient, optionsFactory?.Invoke());
+        });
+}