Update AG-UI C# docs for MAF v1.14 package/API changes

agent-framework/integrations/ag-ui/backend-tool-rendering.md

@@ -43,18 +43,18 @@ Here's a complete server implementation demonstrating how to register tools with
 
 using System.ComponentModel;
 using System.Text.Json.Serialization;
-using Azure.AI.Projects;
+using Azure.AI.OpenAI;
 using Azure.Identity;
 using Microsoft.Agents.AI;
 using Microsoft.Agents.AI.Hosting.AGUI.AspNetCore;
 using Microsoft.Extensions.AI;
 using Microsoft.Extensions.Options;
+using OpenAI.Chat;
 
 WebApplicationBuilder builder = WebApplication.CreateBuilder(args);
-builder.Services.AddHttpClient().AddLogging();
 builder.Services.ConfigureHttpJsonOptions(options =>
     options.SerializerOptions.TypeInfoResolverChain.Add(SampleJsonSerializerContext.Default));
-builder.Services.AddAGUI();
+builder.Services.AddAGUIServer();
 
 WebApplication app = builder.Build();
 
@@ -63,33 +63,6 @@ string endpoint = builder.Configuration["AZURE_OPENAI_ENDPOINT"]
 string deploymentName = builder.Configuration["AZURE_OPENAI_DEPLOYMENT_NAME"]
     ?? throw new InvalidOperationException("AZURE_OPENAI_DEPLOYMENT_NAME is not set.");
 
-// Define request/response types for the tool
-internal sealed class RestaurantSearchRequest
-{
-    public string Location { get; set; } = string.Empty;
-    public string Cuisine { get; set; } = "any";
-}
-
-internal sealed class RestaurantSearchResponse
-{
-    public string Location { get; set; } = string.Empty;
-    public string Cuisine { get; set; } = string.Empty;
-    public RestaurantInfo[] Results { get; set; } = [];
-}
-
-internal sealed class RestaurantInfo
-{
-    public string Name { get; set; } = string.Empty;
-    public string Cuisine { get; set; } = string.Empty;
-    public double Rating { get; set; }
-    public string Address { get; set; } = string.Empty;
-}
-
-// JSON serialization context for source generation
-[JsonSerializable(typeof(RestaurantSearchRequest))]
-[JsonSerializable(typeof(RestaurantSearchResponse))]
-internal sealed partial class SampleJsonSerializerContext : JsonSerializerContext;
-
 // Define the function tool
 [Description("Search for restaurants in a location.")]
 static RestaurantSearchResponse SearchRestaurants(
@@ -137,23 +110,51 @@ AITool[] tools =
 [
     AIFunctionFactory.Create(
         SearchRestaurants,
+        name: "search_restaurants",
         serializerOptions: jsonOptions.SerializerOptions)
 ];
 
 // Create the AI agent with tools
-AIAgent agent = new AIProjectClient(
+AIAgent agent = new AzureOpenAIClient(
         new Uri(endpoint),
         new DefaultAzureCredential())
+    .GetChatClient(deploymentName)
     .AsAIAgent(
-        model: deploymentName,
         name: "AGUIAssistant",
         instructions: "You are a helpful assistant with access to restaurant information.",
         tools: tools);
 
 // Map the AG-UI agent endpoint
-app.MapAGUI("/", agent);
+app.MapAGUIServer("/", agent);
 
 await app.RunAsync();
+
+// Define request/response types for the tool
+internal sealed class RestaurantSearchRequest
+{
+    public string Location { get; set; } = string.Empty;
+    public string Cuisine { get; set; } = "any";
+}
+
+internal sealed class RestaurantSearchResponse
+{
+    public string Location { get; set; } = string.Empty;
+    public string Cuisine { get; set; } = string.Empty;
+    public RestaurantInfo[] Results { get; set; } = [];
+}
+
+internal sealed class RestaurantInfo
+{
+    public string Name { get; set; } = string.Empty;
+    public string Cuisine { get; set; } = string.Empty;
+    public double Rating { get; set; }
+    public string Address { get; set; } = string.Empty;
+}
+
+// JSON serialization context for source generation
+[JsonSerializable(typeof(RestaurantSearchRequest))]
+[JsonSerializable(typeof(RestaurantSearchResponse))]
+internal sealed partial class SampleJsonSerializerContext : JsonSerializerContext;
 ```
 
 > [!WARNING]
@@ -251,9 +252,9 @@ When the agent calls backend tools, you'll see:
 ```
 User (:q or quit to exit): What's the weather like in Amsterdam?
 
-[Run Started - Thread: thread_abc123, Run: run_xyz789]
+[Run Started - Run: run_xyz789]
 
-[Function Call - Name: SearchRestaurants]
+[Function Call - Name: search_restaurants]
   Parameter: Location = Amsterdam
   Parameter: Cuisine = any
 
@@ -262,7 +263,7 @@ User (:q or quit to exit): What's the weather like in Amsterdam?
 
 The weather in Amsterdam is sunny with a temperature of 22°C. Here are some 
 great restaurants in the area: The Golden Fork (Italian, 4.5 stars)...
-[Run Finished - Thread: thread_abc123]
+[Run Finished]
 ```
 
 ### Key Concepts
@@ -739,4 +740,4 @@ a := foundryprovider.NewAgent(endpoint, token, foundryprovider.ModelDeployment(m
 > [!TIP]
 > See the [AG-UI backend tools sample](https://github.com/microsoft/agent-framework-go/blob/main/examples/02-agents/agui/step02_backend_tools/server/main.go) for a complete runnable example.
 
-::: zone-end
+::: zone-end

agent-framework/integrations/ag-ui/frontend-tools.md

@@ -20,7 +20,7 @@ This tutorial shows you how to add frontend function tools to your AG-UI clients
 Before you begin, ensure you have completed the [Getting Started](getting-started.md) tutorial and have:
 
 - .NET 8.0 or later
-- `Microsoft.Agents.AI.AGUI` package installed
+- `AGUI.Client` package installed (the AG-UI C# SDK client)
 - `Microsoft.Agents.AI` package installed
 - Basic understanding of AG-UI client setup
 
@@ -70,61 +70,16 @@ The rest of your client code remains the same as shown in the Getting Started tu
 When you register tools with `AsAIAgent()`, the `AGUIChatClient` automatically:
 
 1. Captures the tool definitions (names, descriptions, parameter schemas)
-3. Sends the tools with each request to the server agent which maps them to `ChatAgentRunOptions.ChatOptions.Tools`
+2. Sends the tools with each request to the server agent, which maps them to `ChatClientAgentRunOptions.ChatOptions.Tools`
 
 The server receives the client tool declarations and the AI model can decide when to call them.
 
-### Inspecting and Modifying Tools with Middleware
-
-You can use agent middleware to inspect or modify the agent run, including accessing the tools:
-
-```csharp
-// Create agent with middleware that inspects tools
-AIAgent inspectableAgent = baseAgent
-    .AsBuilder()
-    .Use(runFunc: null, runStreamingFunc: InspectToolsMiddleware)
-    .Build();
-
-static async IAsyncEnumerable<AgentResponseUpdate> InspectToolsMiddleware(
-    IEnumerable<ChatMessage> messages,
-    AgentSession? session,
-    AgentRunOptions? options,
-    AIAgent innerAgent,
-    CancellationToken cancellationToken)
-{
-    // Access the tools from ChatClientAgentRunOptions
-    if (options is ChatClientAgentRunOptions chatOptions)
-    {
-        IList<AITool>? tools = chatOptions.ChatOptions?.Tools;
-        if (tools != null)
-        {
-            Console.WriteLine($"Tools available for this run: {tools.Count}");
-            foreach (AITool tool in tools)
-            {
-                if (tool is AIFunction function)
-                {
-                    Console.WriteLine($"  - {function.Metadata.Name}: {function.Metadata.Description}");
-                }
-            }
-        }
-    }
-
-    await foreach (AgentResponseUpdate update in innerAgent.RunStreamingAsync(messages, session, options, cancellationToken))
-    {
-        yield return update;
-    }
-}
-```
-
-This middleware pattern allows you to:
-- Validate tool definitions before execution
-
 ### Key Concepts
 
 The following are new concepts for frontend tools:
 
 - **Client-side registration**: Tools are registered on the client using `AIFunctionFactory.Create()` and passed to `AsAIAgent()`
-- **Automatic capture**: Tools are automatically captured and sent via `ChatAgentRunOptions.ChatOptions.Tools`
+- **Automatic capture**: Tools are automatically captured and sent via `ChatClientAgentRunOptions.ChatOptions.Tools`
 
 ## How Frontend Tools Work