feat(showcase/ms-agent-python,ms-agent-dotnet): full LangGraph parity

Author: AlemTuzlak

showcase/packages/ms-agent-dotnet/agent/A2uiFixedSchemaAgent.cs

@@ -0,0 +1,154 @@
+using System.ClientModel;
+using System.ComponentModel;
+using System.Text.Json;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+using Microsoft.Extensions.Logging;
+using OpenAI;
+
+/// <summary>
+/// Factory for the A2UI — Fixed Schema agent.
+///
+/// Mirrors the LangGraph `src/agents/a2ui_fixed.py` reference: the frontend
+/// owns a pre-authored component tree (see
+/// `src/app/demos/a2ui-fixed-schema/a2ui/definitions.ts` + flight_schema.json)
+/// and the agent only streams *data* into the data model via a dedicated
+/// `search_flights` tool that emits an <c>a2ui_operations</c> container.
+/// The A2UI middleware detects that container in the tool result and
+/// forwards rendered surfaces to the frontend.
+/// </summary>
+public class A2uiFixedSchemaAgent
+{
+    private const string DefaultOpenAiEndpoint = "https://models.inference.ai.azure.com";
+    private const string CatalogId = "copilotkit://flight-fixed-catalog";
+    private const string SurfaceId = "flight-fixed-schema";
+
+    private readonly OpenAIClient _openAiClient;
+    private readonly ILogger _logger;
+    private readonly JsonSerializerOptions _jsonSerializerOptions;
+
+    public A2uiFixedSchemaAgent(IConfiguration configuration, ILoggerFactory loggerFactory, JsonSerializerOptions jsonSerializerOptions)
+    {
+        ArgumentNullException.ThrowIfNull(configuration);
+        ArgumentNullException.ThrowIfNull(loggerFactory);
+        ArgumentNullException.ThrowIfNull(jsonSerializerOptions);
+
+        _logger = loggerFactory.CreateLogger<A2uiFixedSchemaAgent>();
+        _jsonSerializerOptions = jsonSerializerOptions;
+
+        var githubToken = configuration["GitHubToken"]
+            ?? throw new InvalidOperationException(
+                "GitHubToken not found in configuration. " +
+                "Please set it using: dotnet user-secrets set GitHubToken \"<your-token>\" " +
+                "or get it using: gh auth token");
+
+        var endpointEnv = Environment.GetEnvironmentVariable("OPENAI_BASE_URL");
+        var endpoint = endpointEnv ?? DefaultOpenAiEndpoint;
+
+        _openAiClient = new(
+            new ApiKeyCredential(githubToken),
+            new OpenAIClientOptions
+            {
+                Endpoint = new Uri(endpoint),
+            });
+    }
+
+    public AIAgent Create()
+    {
+        var chatClient = _openAiClient.GetChatClient("gpt-4o-mini").AsIChatClient();
+
+        return new ChatClientAgent(
+            chatClient,
+            name: "A2uiFixedSchemaAgent",
+            description: @"You help users find flights. When asked about a flight, call
+`search_flights` with origin, destination, airline, and price.
+Use short airport codes (e.g. ""SFO"", ""JFK"") for origin/destination and a price
+string like ""$289"". Keep any chat reply to one short sentence.",
+            tools: [
+                AIFunctionFactory.Create(SearchFlights, options: new() { Name = "search_flights", SerializerOptions = _jsonSerializerOptions })
+            ]);
+    }
+
+    // The fixed-schema flight component tree. Frontend renders this via a
+    // registered catalog (`copilotkit://flight-fixed-catalog`). Matches the
+    // LangGraph reference at src/agents/a2ui_schemas/flight_schema.json.
+    private static readonly object[] FlightSchema = new object[]
+    {
+        new { id = "root", component = "Card", child = "content" },
+        new { id = "content", component = "Column", children = new[] { "title", "route", "meta", "bookButton" } },
+        new { id = "title", component = "Title", text = "Flight Details" },
+        new
+        {
+            id = "route",
+            component = "Row",
+            justify = "spaceBetween",
+            align = "center",
+            children = new[] { "from", "arrow", "to" },
+        },
+        new { id = "from", component = "Airport", code = new { path = "/origin" } },
+        new { id = "arrow", component = "Arrow" },
+        new { id = "to", component = "Airport", code = new { path = "/destination" } },
+        new
+        {
+            id = "meta",
+            component = "Row",
+            justify = "spaceBetween",
+            align = "center",
+            children = new[] { "airline", "price" },
+        },
+        new { id = "airline", component = "AirlineBadge", name = new { path = "/airline" } },
+        new { id = "price", component = "PriceTag", amount = new { path = "/price" } },
+        new
+        {
+            id = "bookButton",
+            component = "Button",
+            variant = "primary",
+            child = "bookButtonLabel",
+            action = new
+            {
+                @event = new
+                {
+                    name = "book_flight",
+                    context = new
+                    {
+                        origin = new { path = "/origin" },
+                        destination = new { path = "/destination" },
+                        airline = new { path = "/airline" },
+                        price = new { path = "/price" },
+                    },
+                },
+            },
+        },
+        new { id = "bookButtonLabel", component = "Text", text = "Book flight" },
+    };
+
+    [Description("Show a flight card for the given trip. Use short airport codes (e.g. SFO, JFK) for origin/destination and a price string like $289.")]
+    private string SearchFlights(
+        [Description("Origin airport code (e.g. SFO)")] string origin,
+        [Description("Destination airport code (e.g. JFK)")] string destination,
+        [Description("Airline name")] string airline,
+        [Description("Price string (e.g. $289)")] string price)
+    {
+        _logger.LogInformation("FixedSchema SearchFlights: {Origin} -> {Destination} on {Airline} at {Price}", origin, destination, airline, price);
+
+        var operations = new object[]
+        {
+            new { type = "create_surface", surfaceId = SurfaceId, catalogId = CatalogId },
+            new { type = "update_components", surfaceId = SurfaceId, components = FlightSchema },
+            new
+            {
+                type = "update_data_model",
+                surfaceId = SurfaceId,
+                data = new
+                {
+                    origin,
+                    destination,
+                    airline,
+                    price,
+                },
+            },
+        };
+
+        return JsonSerializer.Serialize(new { a2ui_operations = operations });
+    }
+}

showcase/packages/ms-agent-dotnet/agent/AgentConfigAgent.cs

@@ -0,0 +1,150 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+using System.Text.Json;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+
+// AgentConfigAgent — the /agent-config demo.
+//
+// Reads three forwarded properties — tone, expertise, responseLength — from
+// the AG-UI shared-state payload (attached as `ag_ui_state` on
+// ChatClientAgentRunOptions.AdditionalProperties, matching the convention
+// already used by SharedStateAgent) and builds a dynamic system prompt per
+// turn.
+//
+// The frontend <CopilotKitProvider agent="agent-config-demo" />'s
+// useAgent().setState(...) call pushes the typed config into shared state;
+// this agent reads it on every run and prepends a system message that adapts
+// the inner ChatClientAgent's behavior. Missing / unrecognized values fall
+// back to the documented defaults — the agent never throws on malformed
+// config, so a misbehaving frontend can't kill the demo.
+[SuppressMessage("Performance", "CA1812:Avoid uninstantiated internal classes", Justification = "Instantiated by SalesAgentFactory")]
+internal sealed class AgentConfigAgent : DelegatingAIAgent
+{
+    private static readonly HashSet<string> ValidTones = new(StringComparer.Ordinal)
+    {
+        "professional",
+        "casual",
+        "enthusiastic",
+    };
+
+    private static readonly HashSet<string> ValidExpertise = new(StringComparer.Ordinal)
+    {
+        "beginner",
+        "intermediate",
+        "expert",
+    };
+
+    private static readonly HashSet<string> ValidResponseLengths = new(StringComparer.Ordinal)
+    {
+        "concise",
+        "detailed",
+    };
+
+    private const string DefaultTone = "professional";
+    private const string DefaultExpertise = "intermediate";
+    private const string DefaultResponseLength = "concise";
+
+    private readonly ILogger<AgentConfigAgent> _logger;
+
+    public AgentConfigAgent(AIAgent innerAgent, ILogger<AgentConfigAgent>? logger = null)
+        : base(innerAgent)
+    {
+        ArgumentNullException.ThrowIfNull(innerAgent);
+        _logger = logger ?? NullLogger<AgentConfigAgent>.Instance;
+    }
+
+    public override Task<AgentRunResponse> RunAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return 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)
+    {
+        ArgumentNullException.ThrowIfNull(messages);
+
+        // Materialize up-front so we can both inspect it (to read the state)
+        // and forward it to the inner agent without re-enumerating a
+        // single-use iterator.
+        var messageList = messages as IReadOnlyList<ChatMessage> ?? messages.ToList();
+
+        var (tone, expertise, responseLength) = ReadConfig(options);
+        var systemPrompt = BuildSystemPrompt(tone, expertise, responseLength);
+
+        _logger.LogInformation(
+            "AgentConfigAgent: tone={Tone}, expertise={Expertise}, responseLength={ResponseLength}",
+            tone, expertise, responseLength);
+
+        var systemMessage = new ChatMessage(ChatRole.System, systemPrompt);
+        var augmentedMessages = new List<ChatMessage>(messageList.Count + 1) { systemMessage };
+        augmentedMessages.AddRange(messageList);
+
+        await foreach (var update in InnerAgent.RunStreamingAsync(augmentedMessages, thread, options, cancellationToken).ConfigureAwait(false))
+        {
+            yield return update;
+        }
+    }
+
+    /// <summary>
+    /// Reads the forwarded config triple from the AG-UI shared-state payload
+    /// attached to the run options. Any missing / unrecognized value falls
+    /// back to the corresponding default constant. Never throws.
+    /// </summary>
+    internal static (string Tone, string Expertise, string ResponseLength) ReadConfig(AgentRunOptions? options)
+    {
+        if (options is not ChatClientAgentRunOptions { ChatOptions.AdditionalProperties: { } properties } ||
+            !properties.TryGetValue("ag_ui_state", out JsonElement state) ||
+            state.ValueKind != JsonValueKind.Object)
+        {
+            return (DefaultTone, DefaultExpertise, DefaultResponseLength);
+        }
+
+        var tone = ReadStringProperty(state, "tone", ValidTones, DefaultTone);
+        var expertise = ReadStringProperty(state, "expertise", ValidExpertise, DefaultExpertise);
+        var responseLength = ReadStringProperty(state, "responseLength", ValidResponseLengths, DefaultResponseLength);
+
+        return (tone, expertise, responseLength);
+    }
+
+    private static string ReadStringProperty(JsonElement state, string name, HashSet<string> valid, string defaultValue)
+    {
+        if (!state.TryGetProperty(name, out var element) || element.ValueKind != JsonValueKind.String)
+        {
+            return defaultValue;
+        }
+        var value = element.GetString();
+        return value is not null && valid.Contains(value) ? value : defaultValue;
+    }
+
+    internal static string BuildSystemPrompt(string tone, string expertise, string responseLength)
+    {
+        var toneRule = tone switch
+        {
+            "casual" => "Use friendly, conversational language. Contractions OK. Light humor welcome.",
+            "enthusiastic" => "Use upbeat, energetic language. Exclamation points OK. Emoji OK.",
+            _ => "Use neutral, precise language. No emoji. Short sentences.",
+        };
+        var expertiseRule = expertise switch
+        {
+            "beginner" => "Assume no prior knowledge. Define jargon. Use analogies.",
+            "expert" => "Assume technical fluency. Use precise terminology. Skip basics.",
+            _ => "Assume common terms are understood; explain specialized terms.",
+        };
+        var lengthRule = responseLength switch
+        {
+            "detailed" => "Respond in multiple paragraphs with examples where relevant.",
+            _ => "Respond in 1-3 sentences.",
+        };
+
+        return "You are a helpful assistant.\n\n" +
+            $"Tone: {toneRule}\n" +
+            $"Expertise level: {expertiseRule}\n" +
+            $"Response length: {lengthRule}";
+    }
+}