Getting Started with Quarkus and A2A Java SDK 0.3.0

import io.a2a.server.PublicAgentCard;
import io.a2a.spec.AgentCapabilities;
import io.a2a.spec.AgentCard;
import io.a2a.spec.AgentSkill;
...

@ApplicationScoped
public class WeatherAgentCardProducer {

    @Produces
    @PublicAgentCard
    public AgentCard agentCard() {
        return new AgentCard.Builder()
                .name("Weather Agent")
                .description("Helps with weather")
                .url(YOUR_JSONRPC_URL) (1)
                .preferredTransport(TransportProtocol.JSONRPC.asString()) (2)
                .additionalInterfaces(List.of( (3)
                        new AgentInterface(TransportProtocol.JSONRPC.asString(), YOUR_JSONRPC_URL), (4)
                        new AgentInterface(TransportProtocol.GRPC.asString(), YOUR_GRPC_URL) (5)
                ))
                .version("1.0.0")
                .capabilities(new AgentCapabilities.Builder()
                        .streaming(true)
                        .pushNotifications(false)
                        .stateTransitionHistory(false)
                        .build())
                .defaultInputModes(Collections.singletonList("text"))
                .defaultOutputModes(Collections.singletonList("text"))
                .skills(Collections.singletonList(new AgentSkill.Builder()
                        .id("weather_search")
                        .name("Search weather")
                        .description("Helps with weather in city, or states")
                        .tags(Collections.singletonList("weather"))
                        .examples(List.of("weather in LA, CA"))
                        .build()))
                .protocolVersion("0.3.0")
                .build();
    }
}

// First, get the agent card for the A2A server agent you want to connect to
AgentCard agentCard = new A2ACardResolver("http://localhost:1234").getAgentCard();

// Specify general client configuration and preferences for the ClientBuilder
ClientConfig clientConfig = new ClientConfig.Builder()
        .setAcceptedOutputModes(List.of("text"))
        ...
        .build();

// Create event consumers to handle responses that will be received from the A2A server
// (these consumers will be used for both streaming and non-streaming responses)
List<BiConsumer<ClientEvent, AgentCard>> consumers = List.of(
    (event, card) -> {
        if (event instanceof MessageEvent messageEvent) {
            // handle the messageEvent.getMessage()
            ...
        } else if (event instanceof TaskEvent taskEvent) {
            // handle the taskEvent.getTask()
            ...
        } else if (event instanceof TaskUpdateEvent updateEvent) {
            // handle the updateEvent.getTask()
            ...
        }
    }
);

// Create a handler that will be used for any errors that occur during streaming
Consumer<Throwable> errorHandler = error -> {
    // handle the error.getMessage()
    ...
};

// Optional: Create a channel factory function that takes the agent URL and returns a Channel for gRPC
Function<String, Channel> channelFactory = agentUrl -> {
    return ManagedChannelBuilder.forTarget(agentUrl)
            ...
            .build();
};

// Create the client using the builder
Client client = Client
        .builder(agentCard)
        .clientConfig(clientConfig)
        .withTransport(JSONRPCTransport.class, new JSONRPCTransportConfig()) (1)
        .withTransport(GrpcTransport.class, new GrpcTransportConfig(channelFactory)) (2)
        .addConsumers(consumers)
        .streamingErrorHandler(errorHandler)
        .build();