chore: import upstream snapshot with attribution

dotnet/samples/02-agents/AGUI/Step05_StateManagement/Client/Client.csproj

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

dotnet/samples/02-agents/AGUI/Step05_StateManagement/Client/Program.cs

@@ -0,0 +1,234 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using AGUI.Abstractions;
+using AGUI.Client;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+using RecipeClient;
+
+string serverUrl = Environment.GetEnvironmentVariable("AGUI_SERVER_URL") ?? "http://localhost:8888";
+
+Console.WriteLine($"Connecting to AG-UI server at: {serverUrl}\n");
+
+// Create the AG-UI client agent
+using HttpClient httpClient = new()
+{
+    Timeout = TimeSpan.FromSeconds(60)
+};
+
+AGUIChatClient chatClient = new(new(httpClient, serverUrl));
+
+AIAgent baseAgent = chatClient.AsAIAgent(
+    name: "recipe-client",
+    description: "AG-UI Recipe Client Agent");
+
+// Wrap the base agent with state management
+JsonSerializerOptions jsonOptions = new(JsonSerializerDefaults.Web)
+{
+    TypeInfoResolver = RecipeSerializerContext.Default
+};
+StatefulAgent<AgentState> agent = new(baseAgent, jsonOptions, new AgentState());
+
+AgentSession session = await agent.CreateSessionAsync();
+List<ChatMessage> messages =
+[
+    new(ChatRole.System, "You are a helpful recipe assistant.")
+];
+
+try
+{
+    while (true)
+    {
+        // Get user input
+        Console.Write("\nUser (:q to quit, :state to show state): ");
+        string? message = Console.ReadLine();
+
+        if (string.IsNullOrWhiteSpace(message))
+        {
+            Console.WriteLine("Request cannot be empty.");
+            continue;
+        }
+
+        if (message is ":q" or "quit")
+        {
+            break;
+        }
+
+        if (message.Equals(":state", StringComparison.OrdinalIgnoreCase))
+        {
+            DisplayState(agent.State.Recipe);
+            continue;
+        }
+
+        messages.Add(new ChatMessage(ChatRole.User, message));
+
+        // Stream the response
+        bool isFirstUpdate = true;
+        string? threadId = null;
+        bool stateReceived = false;
+
+        Console.WriteLine();
+
+        await foreach (AgentResponseUpdate update in agent.RunStreamingAsync(messages, session))
+        {
+            ChatResponseUpdate chatUpdate = update.AsChatResponseUpdate();
+
+            // First update indicates run started
+            if (isFirstUpdate)
+            {
+                // AGUIChatClient is stateless and never surfaces a ConversationId; the thread
+                // id is carried on the AG-UI RUN_STARTED event's raw representation.
+                threadId = (chatUpdate.RawRepresentation as RunStartedEvent)?.ThreadId;
+                Console.ForegroundColor = ConsoleColor.Yellow;
+                Console.WriteLine($"[Run Started - Thread: {threadId}, Run: {chatUpdate.ResponseId}]");
+                Console.ResetColor();
+                isFirstUpdate = false;
+            }
+
+            // Display streaming content
+            foreach (AIContent content in update.Contents)
+            {
+                switch (content)
+                {
+                    case TextContent textContent:
+                        Console.ForegroundColor = ConsoleColor.Cyan;
+                        Console.Write(textContent.Text);
+                        Console.ResetColor();
+                        break;
+
+                    case DataContent dataContent when dataContent.MediaType == "application/json":
+                        // This is a state snapshot - the StatefulAgent has already updated the state
+                        stateReceived = true;
+                        Console.ForegroundColor = ConsoleColor.Blue;
+                        Console.WriteLine("\n[State Snapshot Received]");
+                        Console.ResetColor();
+                        break;
+
+                    case ErrorContent errorContent:
+                        Console.ForegroundColor = ConsoleColor.Red;
+                        Console.WriteLine($"\n[Error: {errorContent.Message}]");
+                        Console.ResetColor();
+                        break;
+                }
+            }
+        }
+
+        Console.ForegroundColor = ConsoleColor.Green;
+        Console.WriteLine($"\n[Run Finished - Thread: {threadId}]");
+        Console.ResetColor();
+
+        // Display final state if received
+        if (stateReceived)
+        {
+            DisplayState(agent.State.Recipe);
+        }
+    }
+}
+catch (Exception ex)
+{
+    Console.WriteLine($"\nAn error occurred: {ex.Message}");
+}
+
+static void DisplayState(RecipeState? state)
+{
+    if (state == null)
+    {
+        Console.ForegroundColor = ConsoleColor.Gray;
+        Console.WriteLine("\n[No state available]");
+        Console.ResetColor();
+        return;
+    }
+
+    Console.ForegroundColor = ConsoleColor.Blue;
+    Console.WriteLine("\n" + new string('=', 60));
+    Console.WriteLine("CURRENT STATE");
+    Console.WriteLine(new string('=', 60));
+    Console.ResetColor();
+
+    if (!string.IsNullOrEmpty(state.Title))
+    {
+        Console.WriteLine("\nRecipe:");
+        Console.WriteLine($"  Title: {state.Title}");
+        if (!string.IsNullOrEmpty(state.Cuisine))
+        {
+            Console.WriteLine($"  Cuisine: {state.Cuisine}");
+        }
+
+        if (!string.IsNullOrEmpty(state.SkillLevel))
+        {
+            Console.WriteLine($"  Skill Level: {state.SkillLevel}");
+        }
+
+        if (state.PrepTimeMinutes > 0)
+        {
+            Console.WriteLine($"  Prep Time: {state.PrepTimeMinutes} minutes");
+        }
+
+        if (state.CookTimeMinutes > 0)
+        {
+            Console.WriteLine($"  Cook Time: {state.CookTimeMinutes} minutes");
+        }
+
+        if (state.Ingredients.Count > 0)
+        {
+            Console.WriteLine("\n  Ingredients:");
+            foreach (var ingredient in state.Ingredients)
+            {
+                Console.WriteLine($"    - {ingredient}");
+            }
+        }
+
+        if (state.Steps.Count > 0)
+        {
+            Console.WriteLine("\n  Steps:");
+            for (int i = 0; i < state.Steps.Count; i++)
+            {
+                Console.WriteLine($"    {i + 1}. {state.Steps[i]}");
+            }
+        }
+    }
+
+    Console.ForegroundColor = ConsoleColor.Blue;
+    Console.WriteLine("\n" + new string('=', 60));
+    Console.ResetColor();
+}
+
+// State wrapper
+internal sealed class AgentState
+{
+    [JsonPropertyName("recipe")]
+    public RecipeState Recipe { get; set; } = new();
+}
+
+// Recipe state model
+internal sealed class RecipeState
+{
+    [JsonPropertyName("title")]
+    public string Title { get; set; } = string.Empty;
+
+    [JsonPropertyName("cuisine")]
+    public string Cuisine { get; set; } = string.Empty;
+
+    [JsonPropertyName("ingredients")]
+    public List<string> Ingredients { get; set; } = [];
+
+    [JsonPropertyName("steps")]
+    public List<string> Steps { get; set; } = [];
+
+    [JsonPropertyName("prep_time_minutes")]
+    public int PrepTimeMinutes { get; set; }
+
+    [JsonPropertyName("cook_time_minutes")]
+    public int CookTimeMinutes { get; set; }
+
+    [JsonPropertyName("skill_level")]
+    public string SkillLevel { get; set; } = string.Empty;
+}
+
+// JSON serialization context
+[JsonSerializable(typeof(AgentState))]
+[JsonSerializable(typeof(RecipeState))]
+[JsonSerializable(typeof(JsonElement))]
+internal sealed partial class RecipeSerializerContext : JsonSerializerContext;

dotnet/samples/02-agents/AGUI/Step05_StateManagement/Client/StatefulAgent.cs

@@ -0,0 +1,87 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Runtime.CompilerServices;
+using System.Text.Json;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+
+namespace RecipeClient;
+
+/// <summary>
+/// A delegating agent that manages client-side state and automatically attaches it to requests.
+/// </summary>
+/// <typeparam name="TState">The state type.</typeparam>
+internal sealed class StatefulAgent<TState> : DelegatingAIAgent
+    where TState : class, new()
+{
+    private readonly JsonSerializerOptions _jsonSerializerOptions;
+
+    /// <summary>
+    /// Gets or sets the current state.
+    /// </summary>
+    public TState State { get; set; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="StatefulAgent{TState}"/> class.
+    /// </summary>
+    /// <param name="innerAgent">The underlying agent to delegate to.</param>
+    /// <param name="jsonSerializerOptions">The JSON serializer options for state serialization.</param>
+    /// <param name="initialState">The initial state. If null, a new instance will be created.</param>
+    public StatefulAgent(AIAgent innerAgent, JsonSerializerOptions jsonSerializerOptions, TState? initialState = null)
+        : base(innerAgent)
+    {
+        this._jsonSerializerOptions = jsonSerializerOptions;
+        this.State = initialState ?? new TState();
+    }
+
+    /// <inheritdoc />
+    protected override Task<AgentResponse> RunCoreAsync(
+        IEnumerable<ChatMessage> messages,
+        AgentSession? session = null,
+        AgentRunOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return this.RunCoreStreamingAsync(messages, session, options, cancellationToken)
+            .ToAgentResponseAsync(cancellationToken);
+    }
+
+    /// <inheritdoc />
+    protected override async IAsyncEnumerable<AgentResponseUpdate> RunCoreStreamingAsync(
+        IEnumerable<ChatMessage> messages,
+        AgentSession? session = null,
+        AgentRunOptions? options = null,
+        [EnumeratorCancellation] CancellationToken cancellationToken = default)
+    {
+        // Add state to messages
+        List<ChatMessage> messagesWithState = [.. messages];
+
+        // Serialize the state using AgentState wrapper
+        byte[] stateBytes = JsonSerializer.SerializeToUtf8Bytes(
+            this.State,
+            this._jsonSerializerOptions.GetTypeInfo(typeof(TState)));
+        DataContent stateContent = new(stateBytes, "application/json");
+        ChatMessage stateMessage = new(ChatRole.System, [stateContent]);
+        messagesWithState.Add(stateMessage);
+
+        // Stream the response and update state when received
+        await foreach (AgentResponseUpdate update in this.InnerAgent.RunStreamingAsync(messagesWithState, session, options, cancellationToken))
+        {
+            // Check if this update contains a state snapshot
+            foreach (AIContent content in update.Contents)
+            {
+                if (content is DataContent dataContent && dataContent.MediaType == "application/json")
+                {
+                    // Deserialize the state
+                    if (JsonSerializer.Deserialize(
+                        dataContent.Data.Span,
+                        this._jsonSerializerOptions.GetTypeInfo(typeof(TState))) is TState newState)
+                    {
+                        this.State = newState;
+                    }
+                }
+            }
+
+            yield return update;
+        }
+    }
+}

dotnet/samples/02-agents/AGUI/Step05_StateManagement/Server/Program.cs

@@ -0,0 +1,66 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Agents.AI.Hosting.AGUI.AspNetCore;
+using Microsoft.Extensions.Options;
+using OpenAI.Chat;
+using RecipeAssistant;
+
+WebApplicationBuilder builder = WebApplication.CreateBuilder(args);
+builder.Services.AddHttpClient().AddLogging();
+builder.Services.ConfigureHttpJsonOptions(options =>
+    options.SerializerOptions.TypeInfoResolverChain.Add(RecipeSerializerContext.Default));
+builder.Services.AddAGUIServer();
+
+// Configure to listen on port 8888
+builder.WebHost.UseUrls("http://localhost:8888");
+
+// WARNING: When adding session persistence (e.g., WithInMemorySessionStore), or running in production,
+// make sure to also register a SessionIsolationKeyProvider to scope sessions by principal in multi-user
+// deployments, e.g.:
+// builder.Services.UseClaimsBasedSessionIsolation(new() { ClaimType = ClaimTypes.NameIdentifier });
+
+WebApplication app = builder.Build();
+
+string endpoint = builder.Configuration["AZURE_OPENAI_ENDPOINT"]
+    ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+string deploymentName = builder.Configuration["AZURE_OPENAI_DEPLOYMENT_NAME"]
+    ?? throw new InvalidOperationException("AZURE_OPENAI_DEPLOYMENT_NAME is not set.");
+
+// Get JsonSerializerOptions
+var jsonOptions = app.Services.GetRequiredService<IOptions<Microsoft.AspNetCore.Http.Json.JsonOptions>>().Value;
+
+// Create base agent
+// WARNING: DefaultAzureCredential is convenient for development but requires careful consideration in production.
+// In production, consider using a specific credential (e.g., ManagedIdentityCredential) to avoid
+// latency issues, unintended credential probing, and potential security risks from fallback mechanisms.
+ChatClient chatClient = new AzureOpenAIClient(
+        new Uri(endpoint),
+        new DefaultAzureCredential())
+    .GetChatClient(deploymentName);
+
+AIAgent baseAgent = chatClient.AsAIAgent(
+    name: "RecipeAgent",
+    instructions: """
+        You are a helpful recipe assistant. When users ask you to create or suggest a recipe,
+        respond with a complete AgentState JSON object that includes:
+        - recipe.title: The recipe name
+        - recipe.cuisine: Type of cuisine (e.g., Italian, Mexican, Japanese)
+        - recipe.ingredients: Array of ingredient strings with quantities
+        - recipe.steps: Array of cooking instruction strings
+        - recipe.prep_time_minutes: Preparation time in minutes
+        - recipe.cook_time_minutes: Cooking time in minutes
+        - recipe.skill_level: One of "beginner", "intermediate", or "advanced"
+
+        Always include all fields in the response. Be creative and helpful.
+        """);
+
+// Wrap with state management middleware
+AIAgent agent = new SharedStateAgent(baseAgent, jsonOptions.SerializerOptions);
+
+// Map the AG-UI agent endpoint
+app.MapAGUIServer("/", agent);
+
+await app.RunAsync();

dotnet/samples/02-agents/AGUI/Step05_StateManagement/Server/Properties/launchSettings.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "https://json.schemastore.org/launchsettings.json",
+  "profiles": {
+    "http": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "applicationUrl": "http://localhost:5253",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "https": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "applicationUrl": "https://localhost:7047;http://localhost:5253",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

dotnet/samples/02-agents/AGUI/Step05_StateManagement/Server/RecipeModels.cs

@@ -0,0 +1,43 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Text.Json.Serialization;
+
+namespace RecipeAssistant;
+
+// State wrapper
+internal sealed class AgentState
+{
+    [JsonPropertyName("recipe")]
+    public RecipeState Recipe { get; set; } = new();
+}
+
+// Recipe state model
+internal sealed class RecipeState
+{
+    [JsonPropertyName("title")]
+    public string Title { get; set; } = string.Empty;
+
+    [JsonPropertyName("cuisine")]
+    public string Cuisine { get; set; } = string.Empty;
+
+    [JsonPropertyName("ingredients")]
+    public List<string> Ingredients { get; set; } = [];
+
+    [JsonPropertyName("steps")]
+    public List<string> Steps { get; set; } = [];
+
+    [JsonPropertyName("prep_time_minutes")]
+    public int PrepTimeMinutes { get; set; }
+
+    [JsonPropertyName("cook_time_minutes")]
+    public int CookTimeMinutes { get; set; }
+
+    [JsonPropertyName("skill_level")]
+    public string SkillLevel { get; set; } = string.Empty;
+}
+
+// JSON serialization context
+[JsonSerializable(typeof(AgentState))]
+[JsonSerializable(typeof(RecipeState))]
+[JsonSerializable(typeof(System.Text.Json.JsonElement))]
+internal sealed partial class RecipeSerializerContext : JsonSerializerContext;

dotnet/samples/02-agents/AGUI/Step05_StateManagement/Server/Server.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.AI.OpenAI" />
+    <PackageReference Include="Azure.Identity" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Hosting.AGUI.AspNetCore\Microsoft.Agents.AI.Hosting.AGUI.AspNetCore.csproj" />
+    <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Hosting.AspNetCore\Microsoft.Agents.AI.Hosting.AspNetCore.csproj" />
+    <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+
+</Project>

dotnet/samples/02-agents/AGUI/Step05_StateManagement/Server/SharedStateAgent.cs

@@ -0,0 +1,159 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Runtime.CompilerServices;
+using System.Text.Json;
+using AGUI.Abstractions;
+using AGUI.Server;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+
+namespace RecipeAssistant;
+
+internal sealed class SharedStateAgent : DelegatingAIAgent
+{
+    private readonly JsonSerializerOptions _jsonSerializerOptions;
+
+    public SharedStateAgent(AIAgent innerAgent, JsonSerializerOptions jsonSerializerOptions)
+        : base(innerAgent)
+    {
+        this._jsonSerializerOptions = jsonSerializerOptions;
+    }
+
+    protected override Task<AgentResponse> RunCoreAsync(
+        IEnumerable<ChatMessage> messages,
+        AgentSession? session = null,
+        AgentRunOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return this.RunCoreStreamingAsync(messages, session, options, cancellationToken)
+            .ToAgentResponseAsync(cancellationToken);
+    }
+
+    protected override async IAsyncEnumerable<AgentResponseUpdate> RunCoreStreamingAsync(
+        IEnumerable<ChatMessage> messages,
+        AgentSession? session = null,
+        AgentRunOptions? options = null,
+        [EnumeratorCancellation] CancellationToken cancellationToken = default)
+    {
+        // Check if the client sent state in the request
+        if (options is not ChatClientAgentRunOptions { ChatOptions: { } chatOptions } chatRunOptions ||
+            !chatOptions.TryGetRunAgentInput(out RunAgentInput? agentInput) ||
+            agentInput.State is not { ValueKind: JsonValueKind.Object } state)
+        {
+            // No state management requested, pass through to inner agent
+            await foreach (var update in this.InnerAgent.RunStreamingAsync(messages, session, options, cancellationToken).ConfigureAwait(false))
+            {
+                yield return update;
+            }
+            yield break;
+        }
+
+        // Check if state has properties (not empty {})
+        bool hasProperties = false;
+        foreach (JsonProperty _ in state.EnumerateObject())
+        {
+            hasProperties = true;
+            break;
+        }
+
+        if (!hasProperties)
+        {
+            // Empty state - treat as no state
+            await foreach (var update in this.InnerAgent.RunStreamingAsync(messages, session, options, cancellationToken).ConfigureAwait(false))
+            {
+                yield return update;
+            }
+            yield break;
+        }
+
+        // First run: Generate structured state update
+        var firstRunOptions = new ChatClientAgentRunOptions
+        {
+            ChatOptions = chatRunOptions.ChatOptions.Clone(),
+            AllowBackgroundResponses = chatRunOptions.AllowBackgroundResponses,
+            ContinuationToken = chatRunOptions.ContinuationToken,
+            ChatClientFactory = chatRunOptions.ChatClientFactory,
+        };
+
+        // Configure JSON schema response format for structured state output
+        firstRunOptions.ChatOptions.ResponseFormat = ChatResponseFormat.ForJsonSchema<AgentState>(
+            schemaName: "AgentState",
+            schemaDescription: "A response containing a recipe with title, skill level, cooking time, ingredients, and instructions");
+
+        // Add current state to the conversation - state is already a JsonElement
+        ChatMessage stateUpdateMessage = new(
+            ChatRole.System,
+            [
+                new TextContent("Here is the current state in JSON format:"),
+                new TextContent(JsonSerializer.Serialize(state, this._jsonSerializerOptions.GetTypeInfo(typeof(JsonElement)))),
+                new TextContent("The new state is:")
+            ]);
+
+        var firstRunMessages = messages.Append(stateUpdateMessage);
+
+        // Collect all updates from first run
+        var allUpdates = new List<AgentResponseUpdate>();
+        await foreach (var update in this.InnerAgent.RunStreamingAsync(firstRunMessages, session, firstRunOptions, cancellationToken).ConfigureAwait(false))
+        {
+            allUpdates.Add(update);
+
+            // Yield all non-text updates (tool calls, etc.)
+            bool hasNonTextContent = update.Contents.Any(c => c is not TextContent);
+            if (hasNonTextContent)
+            {
+                yield return update;
+            }
+        }
+
+        var response = allUpdates.ToAgentResponse();
+
+        // Try to deserialize the structured state response
+        if (TryDeserialize(response.Text, this._jsonSerializerOptions, out JsonElement stateSnapshot))
+        {
+            // Serialize and emit as STATE_SNAPSHOT via DataContent
+            byte[] stateBytes = JsonSerializer.SerializeToUtf8Bytes(
+                stateSnapshot,
+                this._jsonSerializerOptions.GetTypeInfo(typeof(JsonElement)));
+            yield return new AgentResponseUpdate
+            {
+                Contents = [new DataContent(stateBytes, "application/json")]
+            };
+        }
+        else
+        {
+            yield break;
+        }
+
+        // Second run: Generate user-friendly summary
+        var secondRunMessages = messages.Concat(response.Messages).Append(
+            new ChatMessage(
+                ChatRole.System,
+                [new TextContent("Please provide a concise summary of the state changes in at most two sentences.")]));
+
+        await foreach (var update in this.InnerAgent.RunStreamingAsync(secondRunMessages, session, options, cancellationToken).ConfigureAwait(false))
+        {
+            yield return update;
+        }
+    }
+
+    private static bool TryDeserialize<T>(string json, JsonSerializerOptions jsonSerializerOptions, out T structuredOutput)
+    {
+        try
+        {
+            T? deserialized = JsonSerializer.Deserialize<T>(json, jsonSerializerOptions);
+            if (deserialized is null)
+            {
+                structuredOutput = default!;
+                return false;
+            }
+
+            structuredOutput = deserialized;
+            return true;
+        }
+        catch
+        {
+            structuredOutput = default!;
+            return false;
+        }
+    }
+}

dotnet/samples/02-agents/AGUI/Step05_StateManagement/Server/appsettings.Development.json

@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  }
+}

dotnet/samples/02-agents/AGUI/Step05_StateManagement/Server/appsettings.json

@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*"
+}