.NET: AG-UI Docs samples (#2194)

* Add AG-UI Blazor sample

* Add AG-UI getting started samples

* Cleanups

* Update the dojo samples

* cleanups

* Fix readme

* Address feedback and further cleanups

* Fix build

* Missing fixes

dotnet/samples/AGUIClientServer/AGUIDojoServer/AGUIDojoServerSerializerContext.cs

@@ -1,6 +1,10 @@
 // Copyright (c) Microsoft. All rights reserved.
 
 using System.Text.Json.Serialization;
+using AGUIDojoServer.AgenticUI;
+using AGUIDojoServer.BackendToolRendering;
+using AGUIDojoServer.PredictiveStateUpdates;
+using AGUIDojoServer.SharedState;
 
 namespace AGUIDojoServer;
 
@@ -8,4 +12,12 @@ namespace AGUIDojoServer;
 [JsonSerializable(typeof(Recipe))]
 [JsonSerializable(typeof(Ingredient))]
 [JsonSerializable(typeof(RecipeResponse))]
+[JsonSerializable(typeof(Plan))]
+[JsonSerializable(typeof(Step))]
+[JsonSerializable(typeof(StepStatus))]
+[JsonSerializable(typeof(StepStatus?))]
+[JsonSerializable(typeof(JsonPatchOperation))]
+[JsonSerializable(typeof(List<JsonPatchOperation>))]
+[JsonSerializable(typeof(List<string>))]
+[JsonSerializable(typeof(DocumentState))]
 internal sealed partial class AGUIDojoServerSerializerContext : JsonSerializerContext;

dotnet/samples/AGUIClientServer/AGUIDojoServer/AgenticUI/AgenticPlanningTools.cs

@@ -0,0 +1,52 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.ComponentModel;
+
+namespace AGUIDojoServer.AgenticUI;
+
+internal static class AgenticPlanningTools
+{
+    [Description("Create a plan with multiple steps.")]
+    public static Plan CreatePlan([Description("List of step descriptions to create the plan.")] List<string> steps)
+    {
+        return new Plan
+        {
+            Steps = [.. steps.Select(s => new Step { Description = s, Status = StepStatus.Pending })]
+        };
+    }
+
+    [Description("Update a step in the plan with new description or status.")]
+    public static async Task<List<JsonPatchOperation>> UpdatePlanStepAsync(
+        [Description("The index of the step to update.")] int index,
+        [Description("The new description for the step (optional).")] string? description = null,
+        [Description("The new status for the step (optional).")] StepStatus? status = null)
+    {
+        var changes = new List<JsonPatchOperation>();
+
+        if (description is not null)
+        {
+            changes.Add(new JsonPatchOperation
+            {
+                Op = "replace",
+                Path = $"/steps/{index}/description",
+                Value = description
+            });
+        }
+
+        if (status.HasValue)
+        {
+            // Status must be lowercase to match AG-UI frontend expectations: "pending" or "completed"
+            string statusValue = status.Value == StepStatus.Pending ? "pending" : "completed";
+            changes.Add(new JsonPatchOperation
+            {
+                Op = "replace",
+                Path = $"/steps/{index}/status",
+                Value = statusValue
+            });
+        }
+
+        await Task.Delay(1000);
+
+        return changes;
+    }
+}

dotnet/samples/AGUIClientServer/AGUIDojoServer/AgenticUI/AgenticUIAgent.cs

@@ -0,0 +1,88 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+using System.Text.Json;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+
+namespace AGUIDojoServer.AgenticUI;
+
+[SuppressMessage("Performance", "CA1812:Avoid uninstantiated internal classes", Justification = "Instantiated by ChatClientAgentFactory.CreateAgenticUI")]
+internal sealed class AgenticUIAgent : DelegatingAIAgent
+{
+    private readonly JsonSerializerOptions _jsonSerializerOptions;
+
+    public AgenticUIAgent(AIAgent innerAgent, JsonSerializerOptions jsonSerializerOptions)
+        : base(innerAgent)
+    {
+        this._jsonSerializerOptions = jsonSerializerOptions;
+    }
+
+    public override Task<AgentRunResponse> RunAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return this.RunStreamingAsync(messages, thread, options, cancellationToken).ToAgentRunResponseAsync(cancellationToken);
+    }
+
+    public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+        IEnumerable<ChatMessage> messages,
+        AgentThread? thread = null,
+        AgentRunOptions? options = null,
+        [EnumeratorCancellation] CancellationToken cancellationToken = default)
+    {
+        // Track function calls that should trigger state events
+        var trackedFunctionCalls = new Dictionary<string, FunctionCallContent>();
+
+        await foreach (var update in this.InnerAgent.RunStreamingAsync(messages, thread, options, cancellationToken).ConfigureAwait(false))
+        {
+            // Process contents: track function calls and emit state events for results
+            List<AIContent> stateEventsToEmit = new();
+            foreach (var content in update.Contents)
+            {
+                if (content is FunctionCallContent callContent)
+                {
+                    if (callContent.Name == "create_plan" || callContent.Name == "update_plan_step")
+                    {
+                        trackedFunctionCalls[callContent.CallId] = callContent;
+                        break;
+                    }
+                }
+                else if (content is FunctionResultContent resultContent)
+                {
+                    // Check if this result matches a tracked function call
+                    if (trackedFunctionCalls.TryGetValue(resultContent.CallId, out var matchedCall))
+                    {
+                        var bytes = JsonSerializer.SerializeToUtf8Bytes((JsonElement)resultContent.Result!, this._jsonSerializerOptions);
+
+                        // Determine event type based on the function name
+                        if (matchedCall.Name == "create_plan")
+                        {
+                            stateEventsToEmit.Add(new DataContent(bytes, "application/json"));
+                        }
+                        else if (matchedCall.Name == "update_plan_step")
+                        {
+                            stateEventsToEmit.Add(new DataContent(bytes, "application/json-patch+json"));
+                        }
+                    }
+                }
+            }
+
+            yield return update;
+
+            yield return new AgentRunResponseUpdate(
+                new ChatResponseUpdate(role: ChatRole.System, stateEventsToEmit)
+                {
+                    MessageId = "delta_" + Guid.NewGuid().ToString("N"),
+                    CreatedAt = update.CreatedAt,
+                    ResponseId = update.ResponseId,
+                    AuthorName = update.AuthorName,
+                    Role = update.Role,
+                    ContinuationToken = update.ContinuationToken,
+                    AdditionalProperties = update.AdditionalProperties,
+                })
+            {
+                AgentId = update.AgentId
+            };
+        }
+    }
+}

dotnet/samples/AGUIClientServer/AGUIDojoServer/AgenticUI/JsonPatchOperation.cs

@@ -0,0 +1,20 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Text.Json.Serialization;
+
+namespace AGUIDojoServer.AgenticUI;
+
+internal sealed class JsonPatchOperation
+{
+    [JsonPropertyName("op")]
+    public required string Op { get; set; }
+
+    [JsonPropertyName("path")]
+    public required string Path { get; set; }
+
+    [JsonPropertyName("value")]
+    public object? Value { get; set; }
+
+    [JsonPropertyName("from")]
+    public string? From { get; set; }
+}

dotnet/samples/AGUIClientServer/AGUIDojoServer/AgenticUI/Plan.cs

@@ -0,0 +1,11 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Text.Json.Serialization;
+
+namespace AGUIDojoServer.AgenticUI;
+
+internal sealed class Plan
+{
+    [JsonPropertyName("steps")]
+    public List<Step> Steps { get; set; } = [];
+}

dotnet/samples/AGUIClientServer/AGUIDojoServer/AgenticUI/Step.cs

@@ -0,0 +1,14 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Text.Json.Serialization;
+
+namespace AGUIDojoServer.AgenticUI;
+
+internal sealed class Step
+{
+    [JsonPropertyName("description")]
+    public required string Description { get; set; }
+
+    [JsonPropertyName("status")]
+    public StepStatus Status { get; set; } = StepStatus.Pending;
+}

dotnet/samples/AGUIClientServer/AGUIDojoServer/AgenticUI/StepStatus.cs

@@ -0,0 +1,12 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Text.Json.Serialization;
+
+namespace AGUIDojoServer.AgenticUI;
+
+[JsonConverter(typeof(JsonStringEnumConverter<StepStatus>))]
+internal enum StepStatus
+{
+    Pending,
+    Completed
+}

dotnet/samples/AGUIClientServer/AGUIDojoServer/BackendToolRendering/WeatherInfo.cs

@@ -2,7 +2,7 @@
 
 using System.Text.Json.Serialization;
 
-namespace AGUIDojoServer;
+namespace AGUIDojoServer.BackendToolRendering;
 
 internal sealed class WeatherInfo
 {

dotnet/samples/AGUIClientServer/AGUIDojoServer/ChatClientAgentFactory.cs

@@ -2,10 +2,15 @@
 
 using System.ComponentModel;
 using System.Text.Json;
+using AGUIDojoServer.AgenticUI;
+using AGUIDojoServer.BackendToolRendering;
+using AGUIDojoServer.PredictiveStateUpdates;
+using AGUIDojoServer.SharedState;
 using Azure.AI.OpenAI;
 using Azure.Identity;
 using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;
+using OpenAI;
 using ChatClient = OpenAI.Chat.ChatClient;
 
 namespace AGUIDojoServer;
@@ -66,13 +71,46 @@ internal static class ChatClientAgentFactory
             description: "An agent that uses tools to generate user interfaces using Azure OpenAI");
     }
 
-    public static ChatClientAgent CreateAgenticUI()
+    public static AIAgent CreateAgenticUI(JsonSerializerOptions options)
     {
         ChatClient chatClient = s_azureOpenAIClient!.GetChatClient(s_deploymentName!);
+        var baseAgent = chatClient.AsIChatClient().CreateAIAgent(new ChatClientAgentOptions
+        {
+            Name = "AgenticUIAgent",
+            Description = "An agent that generates agentic user interfaces using Azure OpenAI",
+            ChatOptions = new ChatOptions
+            {
+                Instructions = """
+                    When planning use tools only, without any other messages.
+                    IMPORTANT:
+                    - Use the `create_plan` tool to set the initial state of the steps
+                    - Use the `update_plan_step` tool to update the status of each step
+                    - Do NOT repeat the plan or summarise it in a message
+                    - Do NOT confirm the creation or updates in a message
+                    - Do NOT ask the user for additional information or next steps
+                    - Do NOT leave a plan hanging, always complete the plan via `update_plan_step` if one is ongoing.
+                    - Continue calling update_plan_step until all steps are marked as completed.
 
-        return chatClient.AsIChatClient().CreateAIAgent(
-            name: "AgenticUIAgent",
-            description: "An agent that generates agentic user interfaces using Azure OpenAI");
+                    Only one plan can be active at a time, so do not call the `create_plan` tool
+                    again until all the steps in current plan are completed.
+                    """,
+                Tools = [
+                    AIFunctionFactory.Create(
+                        AgenticPlanningTools.CreatePlan,
+                        name: "create_plan",
+                        description: "Create a plan with multiple steps.",
+                        AGUIDojoServerSerializerContext.Default.Options),
+                    AIFunctionFactory.Create(
+                        AgenticPlanningTools.UpdatePlanStepAsync,
+                        name: "update_plan_step",
+                        description: "Update a step in the plan with new description or status.",
+                        AGUIDojoServerSerializerContext.Default.Options)
+                ],
+                AllowMultipleToolCalls = false
+            }
+        });
+
+        return new AgenticUIAgent(baseAgent, options);
     }
 
     public static AIAgent CreateSharedState(JsonSerializerOptions options)
@@ -86,6 +124,44 @@ internal static class ChatClientAgentFactory
         return new SharedStateAgent(baseAgent, options);
     }
 
+    public static AIAgent CreatePredictiveStateUpdates(JsonSerializerOptions options)
+    {
+        ChatClient chatClient = s_azureOpenAIClient!.GetChatClient(s_deploymentName!);
+
+        var baseAgent = chatClient.AsIChatClient().CreateAIAgent(new ChatClientAgentOptions
+        {
+            Name = "PredictiveStateUpdatesAgent",
+            Description = "An agent that demonstrates predictive state updates using Azure OpenAI",
+            ChatOptions = new ChatOptions
+            {
+                Instructions = """
+                    You are a document editor assistant. When asked to write or edit content:
+                    
+                    IMPORTANT:
+                    - Use the `write_document` tool with the full document text in Markdown format
+                    - Format the document extensively so it's easy to read
+                    - You can use all kinds of markdown (headings, lists, bold, etc.)
+                    - However, do NOT use italic or strike-through formatting
+                    - You MUST write the full document, even when changing only a few words
+                    - When making edits to the document, try to make them minimal - do not change every word
+                    - Keep stories SHORT!
+                    - After you are done writing the document you MUST call a confirm_changes tool after you call write_document
+                    
+                    After the user confirms the changes, provide a brief summary of what you wrote.
+                    """,
+                Tools = [
+                    AIFunctionFactory.Create(
+                        WriteDocument,
+                        name: "write_document",
+                        description: "Write a document. Use markdown formatting to format the document.",
+                        AGUIDojoServerSerializerContext.Default.Options)
+                ]
+            }
+        });
+
+        return new PredictiveStateUpdatesAgent(baseAgent, options);
+    }
+
     [Description("Get the weather for a given location.")]
     private static WeatherInfo GetWeather([Description("The location to get the weather for.")] string location) => new()
     {
@@ -95,4 +171,11 @@ internal static class ChatClientAgentFactory
         WindSpeed = 10,
         FeelsLike = 25
     };
+
+    [Description("Write a document in markdown format.")]
+    private static string WriteDocument([Description("The document content to write.")] string document)
+    {
+        // Simply return success - the document is tracked via state updates
+        return "Document written successfully";
+    }
 }

dotnet/samples/AGUIClientServer/AGUIDojoServer/PredictiveStateUpdates/DocumentState.cs

@@ -0,0 +1,11 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Text.Json.Serialization;
+
+namespace AGUIDojoServer.PredictiveStateUpdates;
+
+internal sealed class DocumentState
+{
+    [JsonPropertyName("document")]
+    public string Document { get; set; } = string.Empty;
+}

dotnet/samples/AGUIClientServer/AGUIDojoServer/PredictiveStateUpdates/PredictiveStateUpdatesAgent.cs

@@ -0,0 +1,104 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+using System.Text.Json;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+
+namespace AGUIDojoServer.PredictiveStateUpdates;
+
+[SuppressMessage("Performance", "CA1812:Avoid uninstantiated internal classes", Justification = "Instantiated by ChatClientAgentFactory.CreatePredictiveStateUpdates")]
+internal sealed class PredictiveStateUpdatesAgent : DelegatingAIAgent
+{
+    private readonly JsonSerializerOptions _jsonSerializerOptions;
+    private const int ChunkSize = 10; // Characters per chunk for streaming effect
+
+    public PredictiveStateUpdatesAgent(AIAgent innerAgent, JsonSerializerOptions jsonSerializerOptions)
+        : base(innerAgent)
+    {
+        this._jsonSerializerOptions = jsonSerializerOptions;
+    }
+
+    public override Task<AgentRunResponse> RunAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return this.RunStreamingAsync(messages, thread, options, cancellationToken).ToAgentRunResponseAsync(cancellationToken);
+    }
+
+    public override async IAsyncEnumerable<AgentRunResponseUpdate> RunStreamingAsync(
+        IEnumerable<ChatMessage> messages,
+        AgentThread? thread = null,
+        AgentRunOptions? options = null,
+        [EnumeratorCancellation] CancellationToken cancellationToken = default)
+    {
+        // Track the last emitted document state to avoid duplicates
+        string? lastEmittedDocument = null;
+
+        await foreach (var update in this.InnerAgent.RunStreamingAsync(messages, thread, options, cancellationToken).ConfigureAwait(false))
+        {
+            // Check if we're seeing a write_document tool call and emit predictive state
+            bool hasToolCall = false;
+            string? documentContent = null;
+
+            foreach (var content in update.Contents)
+            {
+                if (content is FunctionCallContent callContent && callContent.Name == "write_document")
+                {
+                    hasToolCall = true;
+                    // Try to extract the document argument directly from the dictionary
+                    if (callContent.Arguments?.TryGetValue("document", out var documentValue) == true)
+                    {
+                        documentContent = documentValue?.ToString();
+                    }
+                }
+            }
+
+            // Always yield the original update first
+            yield return update;
+
+            // If we got a complete tool call with document content, "fake" stream it in chunks
+            if (hasToolCall && documentContent != null && documentContent != lastEmittedDocument)
+            {
+                // Chunk the document content and emit progressive state updates
+                int startIndex = 0;
+                if (lastEmittedDocument != null && documentContent.StartsWith(lastEmittedDocument, StringComparison.Ordinal))
+                {
+                    // Only stream the new portion that was added
+                    startIndex = lastEmittedDocument.Length;
+                }
+
+                // Stream the document in chunks
+                for (int i = startIndex; i < documentContent.Length; i += ChunkSize)
+                {
+                    int length = Math.Min(ChunkSize, documentContent.Length - i);
+                    string chunk = documentContent.Substring(0, i + length);
+
+                    // Prepare predictive state update as DataContent
+                    var stateUpdate = new DocumentState { Document = chunk };
+                    byte[] stateBytes = JsonSerializer.SerializeToUtf8Bytes(
+                        stateUpdate,
+                        this._jsonSerializerOptions.GetTypeInfo(typeof(DocumentState)));
+
+                    yield return new AgentRunResponseUpdate(
+                        new ChatResponseUpdate(role: ChatRole.Assistant, [new DataContent(stateBytes, "application/json")])
+                        {
+                            MessageId = "snapshot" + Guid.NewGuid().ToString("N"),
+                            CreatedAt = update.CreatedAt,
+                            ResponseId = update.ResponseId,
+                            AdditionalProperties = update.AdditionalProperties,
+                            AuthorName = update.AuthorName,
+                            ContinuationToken = update.ContinuationToken,
+                        })
+                    {
+                        AgentId = update.AgentId
+                    };
+
+                    // Small delay to simulate streaming
+                    await Task.Delay(50, cancellationToken).ConfigureAwait(false);
+                }
+
+                lastEmittedDocument = documentContent;
+            }
+        }
+    }
+}

dotnet/samples/AGUIClientServer/AGUIDojoServer/Program.cs

@@ -35,11 +35,13 @@ app.MapAGUI("/human_in_the_loop", ChatClientAgentFactory.CreateHumanInTheLoop())
 
 app.MapAGUI("/tool_based_generative_ui", ChatClientAgentFactory.CreateToolBasedGenerativeUI());
 
-app.MapAGUI("/agentic_generative_ui", ChatClientAgentFactory.CreateAgenticUI());
-
 var jsonOptions = app.Services.GetRequiredService<IOptions<Microsoft.AspNetCore.Http.Json.JsonOptions>>();
+app.MapAGUI("/agentic_generative_ui", ChatClientAgentFactory.CreateAgenticUI(jsonOptions.Value.SerializerOptions));
+
 app.MapAGUI("/shared_state", ChatClientAgentFactory.CreateSharedState(jsonOptions.Value.SerializerOptions));
 
+app.MapAGUI("/predictive_state_updates", ChatClientAgentFactory.CreatePredictiveStateUpdates(jsonOptions.Value.SerializerOptions));
+
 await app.RunAsync();
 
 public partial class Program;

dotnet/samples/AGUIClientServer/AGUIDojoServer/SharedState/Ingredient.cs

@@ -2,7 +2,7 @@
 
 using System.Text.Json.Serialization;
 
-namespace AGUIDojoServer;
+namespace AGUIDojoServer.SharedState;
 
 internal sealed class Ingredient
 {

dotnet/samples/AGUIClientServer/AGUIDojoServer/SharedState/Recipe.cs

@@ -2,7 +2,7 @@
 
 using System.Text.Json.Serialization;
 
-namespace AGUIDojoServer;
+namespace AGUIDojoServer.SharedState;
 
 internal sealed class Recipe
 {

dotnet/samples/AGUIClientServer/AGUIDojoServer/SharedState/RecipeResponse.cs

@@ -2,7 +2,7 @@
 
 using System.Text.Json.Serialization;
 
-namespace AGUIDojoServer;
+namespace AGUIDojoServer.SharedState;
 
 #pragma warning disable CA1812 // Used for the JsonSchema response format
 internal sealed class RecipeResponse

dotnet/samples/AGUIClientServer/AGUIDojoServer/SharedState/SharedStateAgent.cs

@@ -6,7 +6,7 @@ using System.Text.Json;
 using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;
 
-namespace AGUIDojoServer;
+namespace AGUIDojoServer.SharedState;
 
 [SuppressMessage("Performance", "CA1812:Avoid uninstantiated internal classes", Justification = "Instantiated by ChatClientAgentFactory.CreateSharedState")]
 internal sealed class SharedStateAgent : DelegatingAIAgent