Backend Agent with A2A Authorization

Give me a markdown report on the last 3 months of stock transactions and the value of my portfolio

public class AgentClient: HttpClientHandler
{
    private readonly OAuthClient oauthClient;
    private readonly A2AClient a2aClient;

    public AgentClient(Uri agentUrl, OAuthClient oauthClient)
    {
        this.a2aClient = new A2AClient(agentUrl, new HttpClient(this));
        this.oauthClient = oauthClient;
    }

    public async Task<string> SendNaturalLanguageCommandAsync(string command)
    {
        var request = new MessageSendParams
        {
            Message = new AgentMessage
            {
                Role = MessageRole.User,
                Parts = [new TextPart { Text = command }]
            }
        };
        
        var response = await this.a2aClient.SendMessageAsync(request);
        return ((response as AgentMessage)?.Parts?[0] as TextPart)?.Text ?? string.Empty;
    }

    protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
        request.Headers.Add("Authorization", $"Bearer {oauthClient.GetAccessToken()}");
        return await base.SendAsync(request, cancellationToken);
    }
}

local function exchange_access_token(received_access_token, config)

    local httpc = http:new()
    local client_credential = config.client_id .. ':' .. config.client_secret
    local basic_auth_header = 'Basic ' .. ngx.encode_base64(client_credential)
    local new_access_token = nil

    local request_body = 'grant_type=urn:ietf:params:oauth:grant-type:token-exchange'
    request_body = request_body .. '&subject_token=' .. received_access_token
    request_body = request_body .. '&subject_token_type=urn:ietf:params:oauth:token-type:access_token'
    request_body = request_body .. '&scope=' .. config.target_scope
    request_body = request_body .. '&audience=' .. config.target_audience

    local response, error = httpc:request_uri(config.token_endpoint, {
        method = 'POST',
        body = request_body,
        headers = { 
            ['authorization'] = basic_auth_header,
            ['content-type'] = 'application/x-www-form-urlencoded',
            ['accept'] = 'application/json'
        }
    })

    if response.status == 200 then
        local data = cjson.decode(response.body)
        new_access_token = data.access_token
    end
end

export AZURE_AI_FOUNDRY_PROJECT_URL='https://curity-demo.cognitiveservices.azure.com/api/projects/proj-default'
export AZURE_AI_MODEL_NAME='gpt-4.1-mini'

var builder = WebApplication.CreateBuilder();
builder.WebHost
    .UseKestrel(options =>
    {
        options.Listen(IPAddress.Any, configuration.Port);
    });

builder.Services
    .AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.Authority = configuration.Issuer;
        options.Audience = configuration.Audience;
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidAlgorithms = [configuration.Algorithm],
        };
    });

builder.Services.AddAuthorization(options =>
{
    options.FallbackPolicy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
    options.AddPolicy("scope", policy =>
        policy.RequireAssertion(context =>
            context.User.HasClaim(claim =>
                claim.Type == "scope" && claim.Value.Split(' ').Any(c => c == configuration.Scope)
            )
        )
    );
});

builder.Services.AddControllers();
var app = builder.Build();
app.UseAuthentication();
app.UseAuthorization();
app.MapControllers();

var agent = new AutonomousAgent(configuration, oauthHttpClientHandler, loggerFactory);
var taskManager = new TaskManager();
agent.Initialize(taskManager);

app.MapA2A(taskManager, path: "/").RequireAuthorization("scope");
app.Run();

public class AutonomousAgent : Controller
{
    [AllowAnonymous]
    [HttpGet(".well-known/agent-card.json")]
    public async Task<AgentCard> GetAgentCardWellKnownAsync()
    {
        var externalUrl = configuration.ExternalBaseUrl;
        return await this.GetAgentCardAsync(externalUrl, CancellationToken.None);
    }

    private async Task<AgentCard> GetAgentCardAsync(string agentUrl, CancellationToken cancellationToken)
    {
        var skill = new AgentSkill()
        {
            Id = "stocks",
            Name = "Stock portfolio operations",
            Description = "Manage stocks within a portfolio.",
            Tags = ["stocks", "portfolio"],
        };

        var scopes = new Dictionary<string, string>
        {
            [configuration.Scope] = "Read only access to a user portfolio",
        };

        var flows = new OAuthFlows()
        {
            AuthorizationCode = new AuthorizationCodeOAuthFlow
            (
                new Uri(this.configuration.AuthorizationUrl),
                new Uri(this.configuration.TokenUrl),
                scopes
            ),
        };

        return new AgentCard
        {
            Name = "Autonomous Agent",
            Description = "Uses backend security to process natural language commands from an external agent",
            Url = agentUrl,
            Version = "1.0.0",
            DefaultInputModes = ["text"],
            DefaultOutputModes = ["text"],
            Skills = [skill],
            SecuritySchemes = new Dictionary<string, SecurityScheme>
            {
                ["oauth2"] = new OAuth2SecurityScheme(flows),
            },
        };
    }
}

public async Task<AIAgent> CreateAgentAsync()
{
    var aiProjectClient = new AIProjectClient(
        new Uri(this.configuration.AzureFoundryProjectUrl),
        new ManagedIdentityCredential(configuration.ManagedIdentityClientId));

    var mcpTools = await this.GetMcpToolsAsync();
    return await aiProjectClient.CreateAIAgentAsync(
        name: "autonomous-agent",
        model: this.configuration.AzureAIModelName,
        instructions: "You are a backend autonomous agent",
        tools: mcpTools.ToArray()
    );
}

public async Task<A2AResponse> ReceiveNaturalLanguageCommandAsync(MessageSendParams messageSendParams, CancellationToken cancellationToken)
{
    var command = messageSendParams.Message.Parts.OfType<TextPart>().First().Text;

    this.logger.LogDebug($">>> LLM request: {command}");
    var agent = await this.agentFactory.Value;
    var response = await agent.RunAsync(command);
    this.logger.LogDebug($">>> LLM response: {response.Text}");

    var message = new AgentMessage()
    {
        Role = MessageRole.Agent,
        MessageId = Guid.NewGuid().ToString(),
        ContextId = messageSendParams.Message.ContextId,
        Parts = [new TextPart { Text = response.Text }]
    };

    return message;
}

protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
    var receivedAccessToken = this.GetReceivedAccessToken(this.httpContextAccessor.HttpContext);
    var exchangedAccessToken = await this.tokenExchangeClient.ExchangeAccessToken(receivedAccessToken);
    request.Headers.Add("Authorization", $"Bearer {exchangedAccessToken}");
}

{ 
    "log_type": "audit",
    "time": "2026-02-22T15:18:09Z",
    "target_host": "localhost",
    "target_path": "/mcp",
    "target_method": "POST",
    "client_id": "console-client",
    "agent_id": "autonomous-agent",
    "scope": "stocks/read",
    "audience": "https://mcp.demo.example",
    "delegation_id": "f8b69837-1d3e-4c8a-886f-82923c35955a",
    "customer_id": "178",
    "region": "USA"
}

var builder = WebApplication.CreateBuilder();
builder.WebHost
    .UseKestrel(options =>
    {
        options.Listen(IPAddress.Any, configuration.Port);
    });

builder.Services
    .AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.Authority = configuration.Issuer;
        options.Audience = configuration.Audience;
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidAlgorithms = [configuration.Algorithm],
        };
    });

builder.Services.AddAuthorization(options =>
{
    options.FallbackPolicy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
    options.AddPolicy("scope", policy =>
        policy.RequireAssertion(context =>
            context.User.HasClaim(claim =>
                claim.Type == "scope" && claim.Value.Split(' ').Any(c => c == configuration.Scope)
            )
        )
    );
});

builder.Services.AddControllers();
var app = builder.Build();
app.UseAuthentication();
app.UseAuthorization();
app.MapControllers();
app.MapMcp().RequireAuthorization("scope");
app.Run();

[McpServerToolType]
public sealed class StocksToolsService
{
    private readonly ClaimsPrincipal claimsPrincipal;

    public StocksToolsService(DataRepository repository, ClaimsPrincipal claimsPrincipal

    [McpServerTool, Description("Return the customer's portfolio with its history of transactions")]
    public Portfolio GetPortfolio()
    {
        var customerId = this.GetClaim("customer_id");
        var region = this.GetClaim("region");
        this.logger.LogDebug($"Returning portfolio for customer {customerId} and region {region}");
        return this.repository.GetPortfolio(customerId, region);
    }
}