[Feat]: Enable serving dynamically generated agents

[toresenneseth]

Is your feature request related to a problem? Please describe.

There currently seems to be a limitation that you have to know which agent you want to host when the app starts, and you can only host a single one.

This makes the following - very powerful - scenario impossible (from my limited understanding of how the SDK is currently implemented).

Suppose you need to create an enterprise application, or SaaS product, enabling business users to build their own agents using a drag & drop (or similar) UI. Basically AI agents that are generated from configuration, instead of hard-coded by developers using the SDK.

This should be fully possible (as I see it), however, the current implementation of the SDK does not make it possible because you cannot on a pr request basis resolve and execute dynamically generated AI agents based on the url. For example, you currently have to pass in the TaskManager to the MapA2A methods, but the TaskManager.OnMessageReceived does not provide information about the url. This makes sense from a point of view where there's a 1:1 mapping between a TaskManager and agent - which probably is by design.

Describe the solution you'd like

I would like to be able to host dynamically generated AI agents. I want to dynamically serve the agent card, and process the requests, based on the incoming request.

For example, I would like to do something like this:

public static IEndpointConventionBuilder MyMapA2A(this WebApplication app)
{
    app.MapA2A("/a2a/tenants/{tenantId}/workspaces/{workspaceId}/agents/{agentId}");

    var routeGroup = app.MapGroup("/a2a/tenants/{tenantId}/workspaces/{workspaceId}/agents/{agentId}");
    routeGroup.MapGet(".well-known/agent-card.json", async (MyAgentCardService myService, HttpRequest request, CancellationToken cancellationToken) =>
    {
       // quick and dirty hack to remove the well-known part
        var path = request.Path.ToString().Replace("/.well-known/agent-card.json", "");
        var agentUrl = $"{request.Scheme}://{request.Host}{path}";
        var agentCard = await myService.BuildAgentCardAsync(agentUrl, cancellationToken);
        return Results.Ok(agentCard);
    });

    return routeGroup;
}

This is almost possible today, but not quite. If A2AJsonRpcProcessor.ProcessRequestAsync was public, I could create a task manager pr request or agent, and do something like this:

public class DynamicAgentRoutingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IAgentFactory _agentFactory;
    private readonly ConcurrentDictionary<string, ITaskManager> _taskManagers = new();

    public DynamicAgentRoutingMiddleware(
        RequestDelegate next, 
        IAgentFactory agentFactory)
    {
        _next = next;
        _agentFactory = agentFactory;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        // Extract agent identifier from request
        var agentId = context.Request.RouteValues["agentId"]?.ToString();
        
        if (string.IsNullOrEmpty(agentId))
        {
            await _next(context);
            return;
        }

        // Resolve or create task manager for this agent
        var taskManager = _taskManagers.GetOrAdd(agentId, id =>
        {
            var tm = new TaskManager();
            var agent = _agentFactory.CreateAgent(id);
            agent.Attach(tm);
            return tm;
        });

        // Store task manager in HttpContext for use by endpoints
        context.Items["TaskManager"] = taskManager;
        
        await _next(context);
    }
}

// In Program.cs
app.UseMiddleware<DynamicAgentRoutingMiddleware>();

app.MapPost("/a2a/tenants/{tenantId}/workspaces/{workspaceId}/agents/{agentId}", async (
    HttpContext context,
    HttpRequest request,
    CancellationToken cancellationToken) =>
{
    var taskManager = (ITaskManager)context.Items["TaskManager"]!;
     // Not a public API, so I can't do this
    return await A2AJsonRpcProcessor.ProcessRequestAsync(
        taskManager, 
        request, 
        cancellationToken);
});

Describe alternatives you've considered

No response

Additional context

No response

Code of Conduct

• I agree to follow this project's Code of Conduct

[toresenneseth]

Just a quick update: This is what I'm currently doing as a prototype to support dynamically generated agents, which seems to do exactly what I want.

I use a middleware to detect if the request in an A2A request. If it is, I create a service wrapper (of type A2AFlowAgentProxy) that contains a TaskManager.
Then I attach the service wrapper to the HttpContext (items) so I can pick it up the the route handlers.
Note that I had to copy A2AJsonRpcProcessor (because its methods are internal) from the SDK to make this work - so it's a "hack".

Program.cs

app.UseFlowA2A();
app.MapFlowA2A();

Middleware:

public static class A2AMiddlewareExtensions
{
    public static IApplicationBuilder UseFlowA2A(
        this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<A2AMiddleware>();
    }
}

public sealed class A2AMiddleware(RequestDelegate next)
{
    private readonly RequestDelegate _next = next;
    private readonly ConcurrentDictionary<string, A2AFlowAgentProxy> _agentProxies = new();    

    public async Task InvokeAsync(HttpContext context)
    {        
        var url = context.Request.GetFullRequestPath();
        if (A2AServerRoute.IsA2AServerRoute(url))
        {
            // Extract agent identifier from request
            var a2aUrlComponents = A2AServerRoute.Parse(url);
            string agentId = A2AFlowAgentProxy.CreateAgentId(
                a2aUrlComponents.TenantId,
                a2aUrlComponents.WorkspaceId,
                a2aUrlComponents.FlowId,
                a2aUrlComponents.Environment);
            
            var agentProxy = _agentProxies.GetOrAdd(agentId, id =>
            {
                return new A2AFlowAgentProxy(a2aUrlComponents.TenantId, a2aUrlComponents.WorkspaceId, a2aUrlComponents.FlowId, a2aUrlComponents.Environment);
            });

            agentProxy.Services = context.RequestServices;

            // The agent proxy is used in the route handlers.
            context.Items[HttpContextItems.FlowAgentProxy] = agentProxy;
        }

        await _next(context);
    }
}

Route handlers

public static class A2AWebApplicationExtensions
{
    public static IEndpointConventionBuilder MapFlowA2A(this WebApplication app)
    {
        MapA2A(app);

        var routeGroup = app.MapGroup("/a2a/tenants/{tenantId}/workspaces/{workspaceId}/flows/{flowId}/environments/{environment}");
        routeGroup.MapGet(".well-known/agent-card.json", async (HttpRequest request, CancellationToken cancellationToken) =>
        {
            var agentUrl = request.GetFullRequestPath();

            // Quick and dirty: Remove the .well-known/agent-card.json part
            agentUrl = agentUrl.Substring(0, agentUrl.Length - ".well-known/agent-card.json".Length);
            var a2aProxy = (A2AFlowAgentProxy?)request.HttpContext.Items[HttpContextItems.FlowAgentProxy];
            var agentCard = await a2aProxy.TaskManager.OnAgentCardQuery(agentUrl, cancellationToken);
            return Results.Ok(agentCard);
        });

        return routeGroup;
    }

    private static void MapA2A(IEndpointRouteBuilder endpoints)
    {
        var routeGroup = endpoints.MapGroup("");
        routeGroup.MapPost("/a2a/tenants/{tenantId}/workspaces/{workspaceId}/flows/{flowId}/environments/{environment}", (IServiceProvider serviceProvider, HttpRequest request, CancellationToken cancellationToken) =>
        {
            var a2aProxy = (A2AFlowAgentProxy?)request.HttpContext.Items[HttpContextItems.FlowAgentProxy];
            a2aProxy.Services = serviceProvider;

            // Copied from the A2A SDK because ProcessRequestAsync is internal.
            return A2AJsonRpcProcessor.ProcessRequestAsync(a2aProxy.TaskManager, request, cancellationToken);
        });
    }
}

Service wrapper

public sealed class A2AFlowAgentProxy
{
    private readonly string _tenantId;
    private readonly string _workspaceId;
    private readonly string _flowId;
    private readonly FlowEnvironment _flowEnvironment;    
    
    private IFlowsRepository? _flowsRepository;
        
    public ITaskManager TaskManager { get; private set; }

    public IServiceProvider Services { get; set; }

    public A2AFlowAgentProxy(string tenantId, string workspaceId, string flowId, FlowEnvironment flowEnvironment)
    {
        _tenantId = tenantId;
        _workspaceId = workspaceId;
        _flowId = flowId;
        _flowEnvironment = flowEnvironment;

        TaskManager = new TaskManager();
        TaskManager.OnAgentCardQuery = HandleAgentCardQuery;
        TaskManager.OnMessageReceived = HandleMessageReceived;
    }

    private async Task<AgentCard> HandleAgentCardQuery(string context, CancellationToken cancellationToken)
    {
        _dbRepository ??= this.Services.GetRequiredService<IFlowsRepository>();
        // read config from db and return AgentCard        
    }

    private async Task<A2AResponse> HandleMessageReceived(MessageSendParams messageSendParams, CancellationToken cancellationToken)
    {
        // Runs the agent executor and returns the response
    }

    internal static string CreateAgentId(string tenantId, string workspaceId, string flowId, FlowEnvironment environment) =>
        $"{tenantId}:{workspaceId}:{flowId}:{environment}";

}