ADD .NET SDK

[ckpearson]

A .NET SDK using the Microsoft.Extensions.AI libraries to bring AG-UI support to .NET.

Core features:

• Mirrored types for all the core protocol types and events
• An IChatClient wrapper that automatically handles emitting the relevant events
• A simple API for producing and emitting the events as-needed
  - [ ] .NET Standard library for consumption by latest .NET and older .NET Framework code
• Support for both frontend and backend tool calls

Nice to haves:

AbstractAgent Equivalent:

• Idiomatic C#, likely through use of System.Threading.Channels or IAsyncEnumerable<BaseEvent> rather than taking a dependency on something like Reactive Extensions
• IChatClient input which handles the core lifecycle and text message lifecycle events semi-automatically with escape hatches for customisation
• Event-driven reactivity to re-entrant tool results from the frontend (e.g. frontend calls tool, provides result in subsequent run, this provides a clean mechanism for responding to that)

ASP.NET Core Middleware

Middleware for registering agents as first-class citizens and hooking them in as endpoints automatically.

builder.Services.AddAGUIAgents()
  .RegisterAgent<DataAgent>("data", "Data Agent", "Agent with access and tooling for working with the data");

var app = builder.Build();

app.UseAGUIAgents("/agents");

Should result in the ability to POST to http://{url}/agents/{data} to be completely up and running.

Auto-Proxy Agent

Given the very common scenario of an agent needing to be a simple proxy over a call to an LLM with additional available tools / context, provide a rapid path to success:

public sealed record MyAgentState
{
   public ImmutableList<string> Messages { get; init; } = [];
}

public sealed class MyAgent : SimpleAgent<MyAgentState>
{
  protected override ValueTask PrepareTools(AgentTools tools)
  {
     /* Filter and inspect the tools passed via the frontend */
     foreach(var frontendTool in tools.Frontend)
     {
       if (frontendTool.Name == "SomeToolWeDoNotWant") {
         tools.MarkForRemoval(frontendTool);
       }
     }

     /* Register tools for the backend */
     tools.Backend.Add(AiFunctionFactory.Create(MyBackendMethod));
  }

  protected override ValueTask OnRunStart()
  {
     /* ... */
     this.Context.UpdateState(state => state with {
       Messages = [.. state.Messages, "This is a new message"]
     });
  }
}

SemanticKernel integration

Need to investigate how best to integrate with SemanticKernel and their agent approach.

[ckpearson]

As per Microsoft (https://devblogs.microsoft.com/dotnet/the-future-of-net-standard/) it looks like .NET Standard (especially 2.0) is largely being abandoned these days, and given this is Greenfield development I think I'll instead be targeting .NET 9 for the SDK initially.

[contextablemark]

I would expect any .NET version of the SDK to integrate with Microsoft Agent Framework : https://devblogs.microsoft.com/foundry/introducing-microsoft-agent-framework-the-open-source-engine-for-agentic-ai-apps/

[ckpearson]

I would expect any .NET version of the SDK to integrate with Microsoft Agent Framework : https://devblogs.microsoft.com/foundry/introducing-microsoft-agent-framework-the-open-source-engine-for-agentic-ai-apps/

Yeah, the PR for this pre-dates the release of the new agent framework, I've called it out in the #38 PR, will need some reworking to use that.

Luckily Microsoft seems to have laid a lot of the groundwork via IChatClient (which this implementation uses), so shouldn't be a huge job to get something put together.

They've even thought about how to handle human-in-the-loop requests for tools that need approval, so that can be leant on too.

Once I have the time to tackle it I'll be getting right on it - should be sometime in the next 2-3 weeks.

[PaulVrugt]

can't wait! We really want to use this sdk!

[ckpearson]

can't wait! We really want to use this sdk!

This code as-is is a pretty good start for getting up and running, even in the pre-release state now.

It's all built on the IChatClient interface from the abstractions library Microsoft released, so my recommendation would be to clone it down, and just copy / reference the bits and pieces.

It might be a little behind the AG-UI spec, but should still do all the core bits and pieces (including client-side tool use from the backend).

The plan is (once I have time) to tackle getting this all updated to use the new Microsoft Agent Framework.

[rafsanulhasan]

@ckpearson I want to collaborate with you about the AgentUI client implementation in Blazor