A2A.AspNetCore "0.3.1-preview"

public class FlightAgent
{
    public void Attach(ITaskManager taskManager)
    {
        taskManager.OnMessageReceived = QueryFlightsAsync;
        taskManager.OnAgentCardQuery = GetAgentCardAsync;
    }
    private Task<A2AResponse> QueryFlightsAsync(MessageSendParams messageSendParams, CancellationToken cancellationToken)
    {
        if (cancellationToken.IsCancellationRequested)
        {
            return Task.FromCanceled<A2AResponse>(cancellationToken);
        }
        // Process the message
        var messageText = messageSendParams.Message.Parts.OfType<TextPart>().First().Text;
        // Create and return an artifact
        var message = new AgentMessage()
        {
            Role = MessageRole.Agent,
            MessageId = Guid.NewGuid().ToString(),
            ContextId = messageSendParams.Message.ContextId,
            Parts = [new TextPart() {
                Text = $"Available Flilghts: CZ6250 - RMB380, MF1952 - RMB 390, GJ3156 - RMB410"
            }]
        };
        return Task.FromResult<A2AResponse>(message);
    }
    private Task<AgentCard> GetAgentCardAsync(string agentUrl, CancellationToken cancellationToken)
    {
        if (cancellationToken.IsCancellationRequested)
        {
            return Task.FromCanceled<AgentCard>(cancellationToken);
        }
        var capabilities = new AgentCapabilities()
        {
            Streaming = true,
            PushNotifications = false,
        };
        return Task.FromResult(new AgentCard()
        {
            Name = "Flight Agent",
            Description = "Agent which will query and return available flights to user.",
            Url = agentUrl,
            Version = "1.0.0",
            DefaultInputModes = ["text"],
            DefaultOutputModes = ["text"],
            Capabilities = capabilities,
            Skills = [],
        });
    }
}

using A2A;
using A2A.AspNetCore;
using FlightAgentServer;
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
var taskManager = new TaskManager();
var agent = new FlightAgent();
agent.Attach(taskManager);
// Add JSON-RPC endpoint for A2A
app.MapA2A(taskManager, "/flights");
// Add well-known agent card endpoint for A2A
app.MapWellKnownAgentCard(taskManager, "/flights");
// Add HTTP endpoint for A2A
app.MapHttpA2A(taskManager, "/flights");

app.Run();

public class HotelAgent
{
    public void Attach(ITaskManager taskManager)
    {
        taskManager.OnMessageReceived = QueryHotelsAsync;
        taskManager.OnAgentCardQuery = GetAgentCardAsync;
    }
    private Task<A2AResponse> QueryHotelsAsync(MessageSendParams messageSendParams, CancellationToken cancellationToken)
    {
        if (cancellationToken.IsCancellationRequested)
        {
            return Task.FromCanceled<A2AResponse>(cancellationToken);
        }
        // Process the message
        var messageText = messageSendParams.Message.Parts.OfType<TextPart>().First().Text;
        // Create and return an artifact
        var message = new AgentMessage()
        {
            Role = MessageRole.Agent,
            MessageId = Guid.NewGuid().ToString(),
            ContextId = messageSendParams.Message.ContextId,
            Parts = [new TextPart() {
                Text = $"Available Hotels: JI Hotel - RMB350, Holiday In - RMB 320, Hilton - RMB610"
            }]
        };
        return Task.FromResult<A2AResponse>(message);
    }
    private Task<AgentCard> GetAgentCardAsync(string agentUrl, CancellationToken cancellationToken)
    {
        if (cancellationToken.IsCancellationRequested)
        {
            return Task.FromCanceled<AgentCard>(cancellationToken);
        }
        var capabilities = new AgentCapabilities()
        {
            Streaming = true,
            PushNotifications = false,
        };
        return Task.FromResult(new AgentCard()
        {
            Name = "Hotel Agent",
            Description = "Agent which will query and return available hotels to user.",
            Url = agentUrl,
            Version = "1.0.0",
            DefaultInputModes = ["text"],
            DefaultOutputModes = ["text"],
            Capabilities = capabilities,
            Skills = [],
        });
    }
}

public class PlanAgent
{
    public void Attach(ITaskManager taskManager)
    {
        taskManager.OnMessageReceived = QueryPlansAsync;
        taskManager.OnAgentCardQuery = GetAgentCardAsync;
    }
    private Task<A2AResponse> QueryPlansAsync(MessageSendParams messageSendParams, CancellationToken cancellationToken)
    {
        if (cancellationToken.IsCancellationRequested)
        {
            return Task.FromCanceled<A2AResponse>(cancellationToken);
        }
        // Process the message
        var messageText = messageSendParams.Message.Parts.OfType<TextPart>().First().Text;
        // Create and return an artifact
        var message = new AgentMessage()
        {
            Role = MessageRole.Agent,
            MessageId = Guid.NewGuid().ToString(),
            ContextId = messageSendParams.Message.ContextId,
            Parts = [new TextPart() {
                Text = $"Available Plans: The Muslim Quarter - 2 Hours, The Terracotta Warriors - 3 Hours, The Huaqing Palace - 2 Hours"
            }]
        };
        return Task.FromResult<A2AResponse>(message);
    }
    private Task<AgentCard> GetAgentCardAsync(string agentUrl, CancellationToken cancellationToken)
    {
        if (cancellationToken.IsCancellationRequested)
        {
            return Task.FromCanceled<AgentCard>(cancellationToken);
        }
        var capabilities = new AgentCapabilities()
        {
            Streaming = true,
            PushNotifications = false,
        };
        return Task.FromResult(new AgentCard()
        {
            Name = "Plan Agent",
            Description = "Agent which will query and return travel plans to user.",
            Url = agentUrl,
            Version = "1.0.0",
            DefaultInputModes = ["text"],
            DefaultOutputModes = ["text"],
            Capabilities = capabilities,
            Skills = [],
        });
    }
}

A2A 0.3.1-preivew
Microsoft.SemanticKernel.Agents.Core 1.65.0
Microsoft.SemanticKernel.Agents.OpenAI 1.65.0-preview

{
  "LLM": {
    "BASE_URL": "//api.siliconflow.cn",
    "API_KEY": "******************************",
    "MODEL_ID": "Qwen/Qwen2.5-32B-Instruct"
  }
}

using A2A;
using Microsoft.Extensions.Configuration;
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.ChatCompletion;
using TravelPlannerClient.Infrastructure;

Console.WriteLine("[Step1] Now loading the configuration...");
var config = new ConfigurationBuilder()
    .AddJsonFile($"appsettings.json", optional: false, reloadOnChange: true)
    .Build();

Console.WriteLine("[Step2] Now loading the chat client...");
var chattingApiConfiguration = new OpenAiConfiguration(
            config.GetSection("LLM:MODEL_ID").Value,
            config.GetSection("LLM:BASE_URL").Value,
            config.GetSection("LLM:API_KEY").Value);
var openAiChattingClient = new HttpClient(new OpenAiHttpHandler(chattingApiConfiguration.EndPoint));
var kernel = Kernel.CreateBuilder()
    .AddOpenAIChatCompletion(chattingApiConfiguration.ModelId, chattingApiConfiguration.ApiKey, httpClient: openAiChattingClient)
    .Build();

Console.WriteLine("[Step3] Now loading the remote agent clients...");
// Remote Agent 1 : Flight Agent
var cardResolver = new A2ACardResolver(new Uri("//localhost:7011/"));
var agentCard = await cardResolver.GetAgentCardAsync();
var flightAgentClient = new A2AClient(new Uri(agentCard.Url));
// Remote Agent 2 : Hotel Agent
cardResolver = new A2ACardResolver(new Uri("//localhost:7021/"));
agentCard = await cardResolver.GetAgentCardAsync();
var hotelAgentClient = new A2AClient(new Uri(agentCard.Url));
// Remote Agent 3 : Plan Agent
cardResolver = new A2ACardResolver(new Uri("//localhost:7031/"));
agentCard = await cardResolver.GetAgentCardAsync();
var planAgentClient = new A2AClient(new Uri(agentCard.Url));

Console.WriteLine("[Step4] Welcome to use Travel Planner!\n");
var task = "Hello, I'd like to have a travelling in Xian, please give me one travel plan.";
Console.WriteLine($"# User Message: \n{task}\n");
var userMessage = new AgentMessage
{
    Role = MessageRole.User,
    Parts = [new TextPart { Text = task }]
};

Console.WriteLine("[Step5] Now getting A2A Response from Remote Agents...");
var agentResponse = (AgentMessage)await flightAgentClient.SendMessageAsync(new MessageSendParams
{
    Message = userMessage
});
var flightOptions = ((TextPart)agentResponse.Parts[0]).Text;
Console.WriteLine($"Flight-Agent Response: {flightOptions}");
agentResponse = (AgentMessage)await hotelAgentClient.SendMessageAsync(new MessageSendParams
{
    Message = userMessage
});
var hotelOptions = ((TextPart)agentResponse.Parts[0]).Text;
Console.WriteLine($"Hotel-Agent Response: {hotelOptions}");
agentResponse = (AgentMessage)await planAgentClient.SendMessageAsync(new MessageSendParams
{
    Message = userMessage
});
var planOptions = ((TextPart)agentResponse.Parts[0]).Text;
Console.WriteLine($"Plan-Agent Response: {planOptions}\n");

Console.WriteLine("[Step6] Now sumarizing the final response to user...");
var prompt = $"""
You are a travel planner assistant.
You have received the flight options, hotel options and travel plan from different agents.
You need to summarize the information and give a final travel plan to user.
Flight Options: {flightOptions}
Hotel Options: {hotelOptions}
Travel Plan: {planOptions}
Please provide a concise and clear travel plan to the user.
""";
var chatCompletionService = kernel.GetRequiredService<IChatCompletionService>();
var response = await chatCompletionService.GetChatMessageContentAsync(prompt);
Console.WriteLine($"Your Plan: {response.Content}");

Console.ReadKey();