This class is similar to Python's A2aAgentExecutor and handles:
+ *
+ *
+ *
Full A2A task lifecycle (submitted → working → completed/failed)
+ *
Task status updates
+ *
Task artifact updates
+ *
Event conversion from ADK to A2A format
+ *
+ */
+public class A2aAgentExecutor {
+ private static final Logger logger = LoggerFactory.getLogger(A2aAgentExecutor.class);
+
+ private final Runner runner;
+ private final String appName;
+
+ /**
+ * Creates an executor with a pre-configured Runner.
+ *
+ * @param runner The Runner instance to use for agent execution.
+ */
+ public A2aAgentExecutor(Runner runner) {
+ this.runner = runner;
+ this.appName = runner.appName();
+ }
+
+ /**
+ * Creates an executor with a BaseAgent, automatically creating a Runner with in-memory services.
+ *
+ * @param agent The BaseAgent to execute.
+ * @param appName The application name.
+ */
+ public A2aAgentExecutor(BaseAgent agent, String appName) {
+ this.runner =
+ new Runner.Builder()
+ .agent(agent)
+ .appName(appName)
+ .artifactService(new InMemoryArtifactService())
+ .sessionService(new InMemorySessionService())
+ .memoryService(new InMemoryMemoryService())
+ .build();
+ this.appName = appName;
+ }
+
+ /**
+ * Executes an A2A request and returns a stream of A2A events (TaskStatusUpdateEvent,
+ * TaskArtifactUpdateEvent, etc.).
+ *
+ * @param request The A2A message request.
+ * @param taskId The task ID for this execution.
+ * @param contextId The context ID for this execution.
+ * @return A Flowable stream of A2A events.
+ */
+ public Flowable execute(Message request, String taskId, String contextId) {
+ if (request == null) {
+ throw new IllegalArgumentException("A2A request must have a message");
+ }
+
+ // 1. Convert A2A request to ADK content
+ List inputEvents =
+ RequestConverter.convertAggregatedA2aMessageToAdkEvents(
+ request, UUID.randomUUID().toString());
+
+ // 2. Extract user content from events
+ Content userContent = null;
+ for (Event event : inputEvents) {
+ if (event.content().isPresent()) {
+ Content content = event.content().get();
+ if (content.role().isPresent() && "user".equals(content.role().get())) {
+ userContent = content;
+ break;
+ }
+ }
+ }
+
+ if (userContent == null || userContent.parts().isEmpty()) {
+ throw new IllegalArgumentException("A2A request must have user content");
+ }
+
+ // Make userContent final for lambda
+ final Content finalUserContent = userContent;
+
+ // 3. Get or create session
+ final String userId = contextId; // Use contextId as userId for simplicity
+ final String sessionId = contextId;
+
+ return Flowable.fromCallable(
+ () -> {
+ io.reactivex.rxjava3.core.Maybe sessionMaybe =
+ runner
+ .sessionService()
+ .getSession(appName, userId, sessionId, java.util.Optional.empty());
+
+ Session session = sessionMaybe.blockingGet();
+
+ if (session == null) {
+ java.util.concurrent.ConcurrentHashMap initialState =
+ new java.util.concurrent.ConcurrentHashMap<>();
+ session =
+ runner
+ .sessionService()
+ .createSession(appName, userId, initialState, sessionId)
+ .blockingGet();
+ }
+ return session;
+ })
+ .flatMap(
+ session -> {
+ // 4. Publish task submitted event
+ TaskStatusUpdateEvent submittedEvent =
+ new TaskStatusUpdateEvent(
+ taskId,
+ new TaskStatus(TaskState.SUBMITTED, request, null),
+ contextId,
+ false,
+ null);
+
+ // 5. Publish task working event
+ TaskStatusUpdateEvent workingEvent =
+ new TaskStatusUpdateEvent(
+ taskId,
+ new TaskStatus(TaskState.WORKING, null, null),
+ contextId,
+ false,
+ null);
+
+ // 6. Execute agent
+ Flowable agentEvents =
+ runner.runAsync(
+ userId,
+ sessionId,
+ finalUserContent,
+ RunConfig.builder()
+ .setStreamingMode(RunConfig.StreamingMode.SSE)
+ .setMaxLlmCalls(20)
+ .build());
+
+ // 7. Convert ADK events to A2A task artifact events
+ Flowable a2aEvents =
+ agentEvents
+ .flatMap(
+ adkEvent -> {
+ List converted = new ArrayList<>();
+
+ // Convert to A2A message
+ Message a2aMessage =
+ ResponseConverter.eventToMessage(adkEvent, contextId);
+ if (a2aMessage != null && !a2aMessage.getParts().isEmpty()) {
+ // Create artifact update event
+ Artifact artifact =
+ new Artifact.Builder()
+ .artifactId(UUID.randomUUID().toString())
+ .parts(a2aMessage.getParts())
+ .build();
+ TaskArtifactUpdateEvent artifactEvent =
+ new TaskArtifactUpdateEvent.Builder()
+ .taskId(taskId)
+ .contextId(contextId)
+ .artifact(artifact)
+ .lastChunk(false)
+ .build();
+ converted.add(artifactEvent);
+ }
+
+ return Flowable.fromIterable(converted);
+ })
+ .onErrorResumeNext(
+ error -> {
+ logger.error("Error converting ADK event to A2A event", error);
+ TaskStatusUpdateEvent errorEvent =
+ new TaskStatusUpdateEvent(
+ taskId,
+ new TaskStatus(
+ TaskState.FAILED,
+ new Message.Builder()
+ .messageId(UUID.randomUUID().toString())
+ .role(Message.Role.AGENT)
+ .parts(
+ ImmutableList.of(
+ new io.a2a.spec.TextPart(
+ "Error: " + error.getMessage())))
+ .build(),
+ null),
+ contextId,
+ true,
+ null);
+ return Flowable.just(errorEvent);
+ });
+
+ // 8. Create final completion events
+ TaskArtifactUpdateEvent finalArtifact =
+ new TaskArtifactUpdateEvent.Builder()
+ .taskId(taskId)
+ .contextId(contextId)
+ .artifact(
+ new Artifact.Builder()
+ .artifactId(UUID.randomUUID().toString())
+ .parts(ImmutableList.of())
+ .build())
+ .lastChunk(true)
+ .build();
+
+ TaskStatusUpdateEvent completedEvent =
+ new TaskStatusUpdateEvent(
+ taskId,
+ new TaskStatus(TaskState.COMPLETED, null, null),
+ contextId,
+ true,
+ null);
+
+ // Combine all events in sequence: submitted → working → agent events → completion
+ return Flowable.just((io.a2a.spec.Event) submittedEvent)
+ .concatWith(Flowable.just((io.a2a.spec.Event) workingEvent))
+ .concatWith(a2aEvents)
+ .concatWith(Flowable.just((io.a2a.spec.Event) finalArtifact))
+ .concatWith(Flowable.just((io.a2a.spec.Event) completedEvent));
+ })
+ .onErrorResumeNext(
+ error -> {
+ logger.error("Error executing A2A request", error);
+ TaskStatusUpdateEvent errorEvent =
+ new TaskStatusUpdateEvent(
+ taskId,
+ new TaskStatus(
+ TaskState.FAILED,
+ new Message.Builder()
+ .messageId(UUID.randomUUID().toString())
+ .role(Message.Role.AGENT)
+ .parts(
+ ImmutableList.of(
+ new io.a2a.spec.TextPart("Error: " + error.getMessage())))
+ .build(),
+ null),
+ contextId,
+ true,
+ null);
+ return Flowable.just(errorEvent);
+ });
+ }
+}
diff --git a/a2a/src/main/java/com/google/adk/a2a/grpc/A2aGrpcServer.java b/a2a/src/main/java/com/google/adk/a2a/grpc/A2aGrpcServer.java
new file mode 100644
index 000000000..bdf2871e7
--- /dev/null
+++ b/a2a/src/main/java/com/google/adk/a2a/grpc/A2aGrpcServer.java
@@ -0,0 +1,117 @@
+/**
+ * @author Sandeep Belgavi
+ */
+package com.google.adk.a2a.grpc;
+
+import com.google.adk.agents.BaseAgent;
+import java.io.IOException;
+import java.net.URL;
+
+/**
+ * A utility class to easily expose an ADK BaseAgent as a standalone A2A gRPC server. This class
+ * provides a Python-like {@code to_a2a} experience for Java developers.
+ *
+ *
This utility abstracts away the boilerplate of creating a gRPC server, allowing developers to
+ * expose their agents with minimal code.
+ *
+ *
Example usage:
+ *
+ *
{@code
+ * import com.google.adk.agents.LlmAgent;
+ * import com.google.adk.a2a.grpc.A2aGrpcServer;
+ *
+ * public class Main {
+ * public static void main(String[] args) {
+ * BaseAgent agent = new LlmAgent(...);
+ * // This single line starts the entire gRPC A2A server!
+ * A2aGrpcServer.run(agent, args);
+ * }
+ * }
+ * }
+ *
+ *
Note: This assumes the gRPC service definition (`.proto` file) and generated classes
+ * ({@code A2AServiceGrpc}, {@code SendMessageRequest}, {@code SendMessageResponse}) are available
+ * in the classpath through the Maven {@code protobuf-maven-plugin} configuration.
+ */
+public final class A2aGrpcServer {
+
+ private A2aGrpcServer() {
+ // Utility class - prevent instantiation
+ }
+
+ /**
+ * Starts an A2A gRPC server for the given agent instance. This method creates and starts a gRPC
+ * server on the default port (8080).
+ *
+ *
The server will run until the JVM is shut down. A shutdown hook is automatically registered
+ * to ensure graceful shutdown.
+ *
+ * @param agent The ADK agent to expose as a gRPC service.
+ * @throws IOException If the server fails to start.
+ * @throws InterruptedException If the server is interrupted while waiting for termination.
+ */
+ public static void run(BaseAgent agent) throws IOException, InterruptedException {
+ run(agent, 8080);
+ }
+
+ /**
+ * Starts an A2A gRPC server for the given agent instance on the specified port.
+ *
+ *
The server will run until the JVM is shut down. A shutdown hook is automatically registered
+ * to ensure graceful shutdown.
+ *
+ * @param agent The ADK agent to expose as a gRPC service.
+ * @param port The port number on which the server should listen.
+ * @throws IOException If the server fails to start.
+ * @throws InterruptedException If the server is interrupted while waiting for termination.
+ */
+ public static void run(BaseAgent agent, int port) throws IOException, InterruptedException {
+ run(agent, port, null);
+ }
+
+ /**
+ * Starts an A2A gRPC server for the given agent instance with optional registry integration.
+ *
+ *
The server will run until the JVM is shut down. A shutdown hook is automatically registered
+ * to ensure graceful shutdown.
+ *
+ * @param agent The ADK agent to expose as a gRPC service.
+ * @param port The port number on which the server should listen.
+ * @param registryUrl Optional URL of the service registry. If provided, the server will register
+ * itself with the registry upon startup and unregister upon shutdown.
+ * @throws IOException If the server fails to start.
+ * @throws InterruptedException If the server is interrupted while waiting for termination.
+ */
+ public static void run(BaseAgent agent, int port, URL registryUrl)
+ throws IOException, InterruptedException {
+ if (agent == null) {
+ throw new IllegalArgumentException("Agent cannot be null");
+ }
+
+ A2aServer server = new A2aServerBuilder(agent).port(port).withRegistry(registryUrl).build();
+
+ // Start the server and block until termination
+ server.start();
+ }
+
+ /**
+ * Creates and returns an {@link A2aServerBuilder} for advanced configuration. This allows for
+ * more fine-grained control over the server setup.
+ *
+ *
+ *
+ * @param agent The ADK agent to expose as a gRPC service.
+ * @return A new {@link A2aServerBuilder} instance.
+ */
+ public static A2aServerBuilder builder(BaseAgent agent) {
+ return new A2aServerBuilder(agent);
+ }
+}
diff --git a/a2a/src/main/java/com/google/adk/a2a/grpc/A2aServer.java b/a2a/src/main/java/com/google/adk/a2a/grpc/A2aServer.java
new file mode 100644
index 000000000..58c26c35b
--- /dev/null
+++ b/a2a/src/main/java/com/google/adk/a2a/grpc/A2aServer.java
@@ -0,0 +1,197 @@
+/**
+ * @author Sandeep Belgavi
+ */
+package com.google.adk.a2a.grpc;
+
+import com.google.gson.Gson;
+import io.grpc.Server;
+import java.io.IOException;
+import java.net.URI;
+import java.net.URL;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.util.concurrent.TimeUnit;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/** Manages the lifecycle of a standalone A2A gRPC server. */
+public class A2aServer {
+
+ private static final Logger logger = LoggerFactory.getLogger(A2aServer.class);
+ private static final Gson gson = new Gson();
+
+ private final Server server;
+ private final URL registryUrl;
+ private final AgentInfo agentInfo;
+ private final HttpClient httpClient;
+
+ /**
+ * Constructs a new server instance.
+ *
+ * @param server The underlying gRPC {@link Server} to manage.
+ * @param registryUrl The URL of the service registry.
+ * @param httpClient The HTTP client to use for registry communication.
+ */
+ public A2aServer(Server server, URL registryUrl, HttpClient httpClient, int port) {
+ this.server = server;
+ this.registryUrl = registryUrl;
+ this.agentInfo = new AgentInfo(port);
+ this.httpClient = httpClient;
+ }
+
+ /**
+ * Starts the gRPC server and blocks the current thread until the server is terminated.
+ *
+ * @throws IOException If the server fails to start.
+ * @throws InterruptedException If the server is interrupted while waiting for termination.
+ */
+ public void start() throws IOException, InterruptedException {
+ start(true);
+ }
+
+ /**
+ * Starts the gRPC server.
+ *
+ * @param awaitTermination If true, blocks the current thread until the server is terminated.
+ * @throws IOException If the server fails to start.
+ * @throws InterruptedException If the server is interrupted while waiting for termination.
+ */
+ public void start(boolean awaitTermination) throws IOException, InterruptedException {
+ server.start();
+ logger.info("A2A gRPC server started, listening on port " + server.getPort());
+
+ if (registryUrl != null) {
+ register();
+ }
+
+ // Add a shutdown hook to ensure a graceful server shutdown
+ Runtime.getRuntime()
+ .addShutdownHook(
+ new Thread(
+ () -> {
+ logger.info("Shutting down gRPC server since JVM is shutting down");
+ try {
+ A2aServer.this.stop();
+ } catch (InterruptedException e) {
+ logger.error("gRPC server shutdown interrupted", e);
+ Thread.currentThread().interrupt(); // Preserve the interrupted status
+ }
+ logger.info("Server shut down");
+ }));
+
+ // Block until the server is terminated
+ if (awaitTermination) {
+ server.awaitTermination();
+ }
+ }
+
+ /**
+ * Gets the port on which the server is listening.
+ *
+ * @return The port number.
+ */
+ public int getPort() {
+ return server.getPort();
+ }
+
+ /**
+ * Stops the gRPC server gracefully.
+ *
+ * @throws InterruptedException If the server is interrupted while shutting down.
+ */
+ public void stop() throws InterruptedException {
+ if (registryUrl != null) {
+ unregister();
+ }
+ if (server != null) {
+ server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
+ }
+ }
+
+ private void register() {
+ try {
+ HttpRequest request =
+ HttpRequest.newBuilder()
+ .uri(URI.create(registryUrl + "/register"))
+ .header("Content-Type", "application/json")
+ .POST(HttpRequest.BodyPublishers.ofString(gson.toJson(agentInfo)))
+ .build();
+
+ httpClient
+ .sendAsync(request, HttpResponse.BodyHandlers.ofString())
+ .whenComplete(
+ (response, throwable) -> {
+ if (throwable != null) {
+ logger.error("Failed to register with registry service", throwable);
+ return;
+ }
+ if (response.statusCode() >= 200 && response.statusCode() < 300) {
+ logger.info(
+ "Successfully registered with registry service. Status: {}, Body: {}",
+ response.statusCode(),
+ response.body());
+ } else {
+ logger.warn(
+ "Failed to register with registry service. Status: {}, Body: {}",
+ response.statusCode(),
+ response.body());
+ }
+ });
+ } catch (Exception e) {
+ logger.error("Error building registry request", e);
+ }
+ }
+
+ private void unregister() {
+ try {
+ HttpRequest request =
+ HttpRequest.newBuilder()
+ .uri(URI.create(registryUrl + "/unregister"))
+ .header("Content-Type", "application/json")
+ .POST(HttpRequest.BodyPublishers.ofString(gson.toJson(agentInfo)))
+ .build();
+
+ httpClient
+ .sendAsync(request, HttpResponse.BodyHandlers.ofString())
+ .whenComplete(
+ (response, throwable) -> {
+ if (throwable != null) {
+ logger.error("Failed to unregister from registry service", throwable);
+ return;
+ }
+ if (response.statusCode() >= 200 && response.statusCode() < 300) {
+ logger.info(
+ "Successfully unregistered from registry service. Status: {}, Body: {}",
+ response.statusCode(),
+ response.body());
+ } else {
+ logger.warn(
+ "Failed to unregister from registry service. Status: {}, Body: {}",
+ response.statusCode(),
+ response.body());
+ }
+ });
+ } catch (Exception e) {
+ logger.error("Error building unregister request", e);
+ }
+ }
+
+ private static class AgentInfo {
+ private final String name;
+ private final String url;
+
+ AgentInfo(int port) {
+ this.name = "agent-" + port;
+ this.url = "http://localhost:" + port;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public String getUrl() {
+ return url;
+ }
+ }
+}
diff --git a/a2a/src/main/java/com/google/adk/a2a/grpc/A2aServerBuilder.java b/a2a/src/main/java/com/google/adk/a2a/grpc/A2aServerBuilder.java
new file mode 100644
index 000000000..3db250d9d
--- /dev/null
+++ b/a2a/src/main/java/com/google/adk/a2a/grpc/A2aServerBuilder.java
@@ -0,0 +1,80 @@
+/**
+ * @author Sandeep Belgavi
+ */
+package com.google.adk.a2a.grpc;
+
+import com.google.adk.agents.BaseAgent;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import java.net.URL;
+import java.net.http.HttpClient;
+
+/** A builder for creating a lightweight, standalone A2A gRPC server. */
+public class A2aServerBuilder {
+
+ private final BaseAgent agent;
+ private int port = 8080; // Default port
+ private URL registryUrl;
+ private HttpClient httpClient;
+
+ /**
+ * Constructs a new builder for a given ADK agent.
+ *
+ * @param agent The ADK {@link BaseAgent} to be exposed via the gRPC service.
+ */
+ public A2aServerBuilder(BaseAgent agent) {
+ if (agent == null) {
+ throw new IllegalArgumentException("Agent cannot be null");
+ }
+ this.agent = agent;
+ }
+
+ /**
+ * Sets the port on which the server should listen.
+ *
+ * @param port The port number.
+ * @return This builder instance for chaining.
+ */
+ public A2aServerBuilder port(int port) {
+ if (port <= 0 || port > 65535) {
+ throw new IllegalArgumentException("Port must be between 1 and 65535");
+ }
+ this.port = port;
+ return this;
+ }
+
+ /**
+ * Sets the URL of the A2A service registry. If set, the server will attempt to register itself
+ * with the registry upon startup.
+ *
+ * @param registryUrl The URL of the service registry.
+ * @return This builder instance for chaining.
+ */
+ public A2aServerBuilder withRegistry(URL registryUrl) {
+ this.registryUrl = registryUrl;
+ return this;
+ }
+
+ /**
+ * Sets the {@link HttpClient} to be used for registry communication. If not set, a default client
+ * will be created.
+ *
+ * @param httpClient The HTTP client to use.
+ * @return This builder instance for chaining.
+ */
+ public A2aServerBuilder httpClient(HttpClient httpClient) {
+ this.httpClient = httpClient;
+ return this;
+ }
+
+ /**
+ * Builds the {@link A2aServer} instance.
+ *
+ * @return A new {@link A2aServer} configured with the settings from this builder.
+ */
+ public A2aServer build() {
+ Server grpcServer = ServerBuilder.forPort(port).addService(new A2aService(agent)).build();
+ HttpClient client = (httpClient != null) ? httpClient : HttpClient.newHttpClient();
+ return new A2aServer(grpcServer, registryUrl, client, this.port);
+ }
+}
diff --git a/a2a/src/main/java/com/google/adk/a2a/grpc/A2aService.java b/a2a/src/main/java/com/google/adk/a2a/grpc/A2aService.java
new file mode 100644
index 000000000..e6658e6c0
--- /dev/null
+++ b/a2a/src/main/java/com/google/adk/a2a/grpc/A2aService.java
@@ -0,0 +1,248 @@
+/**
+ * @author Sandeep Belgavi
+ */
+package com.google.adk.a2a.grpc;
+
+import com.google.adk.agents.BaseAgent;
+import com.google.adk.agents.RunConfig;
+import com.google.adk.artifacts.InMemoryArtifactService;
+import com.google.adk.events.Event;
+import com.google.adk.memory.InMemoryMemoryService;
+import com.google.adk.runner.Runner;
+import com.google.adk.sessions.InMemorySessionService;
+import com.google.adk.sessions.Session;
+import com.google.genai.types.Content;
+import com.google.genai.types.Part;
+import io.grpc.stub.StreamObserver;
+import io.reactivex.rxjava3.core.Flowable;
+import io.reactivex.rxjava3.core.Maybe;
+import java.time.LocalDate;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Implements the A2A gRPC service, bridging requests to an ADK agent.
+ *
+ *
This service uses a Runner internally to properly handle agent execution with session
+ * management, artifacts, and memory services.
+ */
+class A2aService extends A2AServiceGrpc.A2AServiceImplBase {
+
+ private static final Logger logger = LoggerFactory.getLogger(A2aService.class);
+ private final BaseAgent agent;
+ private final Runner runner;
+ private static final String DEFAULT_APP_NAME = "adk-a2a-server";
+
+ /**
+ * Constructs the service with a given ADK agent.
+ *
+ *
This constructor creates an internal Runner with in-memory services for sessions, artifacts,
+ * and memory. For production use, consider using a constructor that accepts a pre-configured
+ * Runner.
+ *
+ * @param agent The {@link BaseAgent} to handle the requests.
+ */
+ A2aService(BaseAgent agent) {
+ this.agent = agent;
+ // Create a Runner with in-memory services for simplicity
+ // In production, this could be configured with persistent services
+ this.runner =
+ new Runner.Builder()
+ .agent(agent)
+ .appName(DEFAULT_APP_NAME)
+ .artifactService(new InMemoryArtifactService())
+ .sessionService(new InMemorySessionService())
+ .memoryService(new InMemoryMemoryService())
+ .build();
+ }
+
+ /**
+ * Constructs the service with a pre-configured Runner.
+ *
+ * @param agent The {@link BaseAgent} to handle the requests.
+ * @param runner The {@link Runner} instance to use for agent execution.
+ */
+ A2aService(BaseAgent agent, Runner runner) {
+ this.agent = agent;
+ this.runner = runner;
+ }
+
+ @Override
+ public void sendMessage(
+ SendMessageRequest request, StreamObserver responseObserver) {
+ String userQuery = request.getUserQuery();
+ String sessionId =
+ request.getSessionId() != null && !request.getSessionId().isEmpty()
+ ? request.getSessionId()
+ : "new-session";
+
+ // Console output for validation
+ System.out.println("\n" + "=".repeat(80));
+ System.out.println("🔵 A2A REQUEST RECEIVED");
+ System.out.println("=".repeat(80));
+ System.out.println("Session ID: " + sessionId);
+ System.out.println("Agent: " + agent.name());
+ System.out.println("Query: " + userQuery);
+ System.out.println("=".repeat(80) + "\n");
+
+ logger.info("Received message from client: sessionId={}, query={}", sessionId, userQuery);
+
+ try {
+ // Extract session ID from request or generate a new one
+ String userId = "default-user";
+ final String actualSessionId =
+ (sessionId == null || sessionId.equals("new-session"))
+ ? UUID.randomUUID().toString()
+ : sessionId;
+
+ // Create user content from the request
+ Content userContent = Content.fromParts(Part.fromText(request.getUserQuery()));
+
+ // Get or create session - Runner requires session to exist
+ Maybe maybeSession =
+ runner
+ .sessionService()
+ .getSession(runner.appName(), userId, actualSessionId, Optional.empty());
+
+ Session session =
+ maybeSession
+ .switchIfEmpty(
+ runner
+ .sessionService()
+ .createSession(runner.appName(), userId, null, null)
+ .toMaybe())
+ .blockingGet();
+
+ // Initialize session state with default values if missing
+ // This prevents errors when agent instruction references state variables
+ // The state map is mutable, so we can update it directly
+ Map sessionState = session.state();
+ if (sessionState.isEmpty() || !sessionState.containsKey("currentDate")) {
+ sessionState.put("currentDate", LocalDate.now().toString());
+ sessionState.put("sourceCityName", "");
+ sessionState.put("destinationCityName", "");
+ sessionState.put("dateOfJourney", "");
+ sessionState.put("mriSessionId", actualSessionId);
+ sessionState.put("userMsg", request.getUserQuery());
+ // Track A2A handovers (using _temp prefix for non-persistent tracking)
+ sessionState.put("_temp_a2aCallCount", 0);
+ sessionState.put("_temp_a2aCalls", new java.util.ArrayList>());
+ } else {
+ // Ensure required fields exist even if state is not empty
+ if (!sessionState.containsKey("mriSessionId")) {
+ sessionState.put("mriSessionId", actualSessionId);
+ }
+ if (!sessionState.containsKey("userMsg")) {
+ sessionState.put("userMsg", request.getUserQuery());
+ }
+ if (!sessionState.containsKey("currentDate")) {
+ sessionState.put("currentDate", LocalDate.now().toString());
+ }
+ // Ensure empty strings for city names if not present
+ if (!sessionState.containsKey("sourceCityName")) {
+ sessionState.put("sourceCityName", "");
+ }
+ if (!sessionState.containsKey("destinationCityName")) {
+ sessionState.put("destinationCityName", "");
+ }
+ if (!sessionState.containsKey("dateOfJourney")) {
+ sessionState.put("dateOfJourney", "");
+ }
+ // Initialize A2A tracking if not present
+ if (!sessionState.containsKey("_temp_a2aCallCount")) {
+ sessionState.put("_temp_a2aCallCount", 0);
+ }
+ if (!sessionState.containsKey("_temp_a2aCalls")) {
+ sessionState.put("_temp_a2aCalls", new java.util.ArrayList>());
+ }
+ }
+
+ // Configure run settings for streaming
+ RunConfig runConfig =
+ RunConfig.builder()
+ .setStreamingMode(RunConfig.StreamingMode.SSE)
+ .setMaxLlmCalls(20)
+ .build();
+
+ // Execute the agent using Runner with Session object
+ Flowable eventStream = runner.runAsync(session, userContent, runConfig);
+
+ // Collect all events and aggregate into a single response
+ // Since sendMessage is unary RPC, we need to send a single response
+ eventStream
+ .doOnError(
+ error -> {
+ logger.error("Error executing agent", error);
+ responseObserver.onError(
+ io.grpc.Status.INTERNAL
+ .withDescription("Agent execution failed: " + error.getMessage())
+ .withCause(error)
+ .asRuntimeException());
+ })
+ .toList()
+ .subscribe(
+ events -> {
+ // Aggregate all events into a single response
+ StringBuilder aggregatedResponse = new StringBuilder();
+ for (Event event : events) {
+ String content = event.stringifyContent();
+ if (content != null && !content.trim().isEmpty()) {
+ if (aggregatedResponse.length() > 0) {
+ aggregatedResponse.append("\n");
+ }
+ aggregatedResponse.append(content);
+ }
+ }
+
+ String finalResponse = aggregatedResponse.toString();
+ if (finalResponse.isEmpty()) {
+ finalResponse = "(No response generated)";
+ }
+
+ // Console output for validation
+ System.out.println("\n" + "=".repeat(80));
+ System.out.println("🟢 A2A RESPONSE SENT");
+ System.out.println("=".repeat(80));
+ System.out.println("Session ID: " + actualSessionId);
+ System.out.println("Agent: " + agent.name());
+ System.out.println("Response Length: " + finalResponse.length() + " characters");
+ System.out.println("Response Preview (first 500 chars):");
+ System.out.println(
+ finalResponse.substring(0, Math.min(500, finalResponse.length())));
+ if (finalResponse.length() > 500) {
+ System.out.println("... (truncated)");
+ }
+ System.out.println("=".repeat(80) + "\n");
+
+ logger.info(
+ "Agent execution completed for sessionId={}, response length={}",
+ actualSessionId,
+ finalResponse.length());
+
+ SendMessageResponse response =
+ SendMessageResponse.newBuilder().setAgentReply(finalResponse).build();
+ responseObserver.onNext(response);
+ responseObserver.onCompleted();
+ },
+ error -> {
+ logger.error("Error collecting events", error);
+ responseObserver.onError(
+ io.grpc.Status.INTERNAL
+ .withDescription("Error collecting agent response: " + error.getMessage())
+ .withCause(error)
+ .asRuntimeException());
+ });
+
+ } catch (Exception e) {
+ logger.error("Unexpected error processing request", e);
+ responseObserver.onError(
+ io.grpc.Status.INTERNAL
+ .withDescription("Unexpected error: " + e.getMessage())
+ .withCause(e)
+ .asRuntimeException());
+ }
+ }
+}
diff --git a/a2a/src/main/java/com/google/adk/a2a/grpc/A2aServiceEnhanced.java b/a2a/src/main/java/com/google/adk/a2a/grpc/A2aServiceEnhanced.java
new file mode 100644
index 000000000..28cb720d5
--- /dev/null
+++ b/a2a/src/main/java/com/google/adk/a2a/grpc/A2aServiceEnhanced.java
@@ -0,0 +1,162 @@
+/**
+ * @author Sandeep Belgavi
+ */
+package com.google.adk.a2a.grpc;
+
+import com.google.adk.agents.BaseAgent;
+import io.a2a.spec.Artifact;
+import io.a2a.spec.Event;
+import io.a2a.spec.Message;
+import io.a2a.spec.TaskArtifactUpdateEvent;
+import io.a2a.spec.TaskStatus;
+import io.a2a.spec.TaskStatusUpdateEvent;
+import io.a2a.spec.TextPart;
+import io.grpc.stub.StreamObserver;
+import io.reactivex.rxjava3.core.Flowable;
+import java.util.UUID;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Enhanced A2A gRPC service implementation with full task lifecycle support.
+ *
+ *
This service provides Python-like functionality:
+ *
+ *
+ *
Full A2A task lifecycle (submitted → working → completed/failed)
+ *
**EXPERIMENTAL:** Subject to change, rename, or removal in any future patch release. Do not
+ * use in production code.
+ */
+@SpringBootApplication
+@Import(A2ARemoteConfiguration.class)
+public class A2ARemoteApplication {
+
+ public static void main(String[] args) {
+ SpringApplication.run(A2ARemoteApplication.class, args);
+ }
+}
diff --git a/a2a/webservice/src/main/java/com/google/adk/webservice/A2ARemoteConfiguration.java b/a2a/webservice/src/main/java/com/google/adk/webservice/A2ARemoteConfiguration.java
new file mode 100644
index 000000000..b4af7878e
--- /dev/null
+++ b/a2a/webservice/src/main/java/com/google/adk/webservice/A2ARemoteConfiguration.java
@@ -0,0 +1,52 @@
+/**
+ * @author Sandeep Belgavi
+ */
+package com.google.adk.webservice;
+
+import com.google.adk.a2a.A2ASendMessageExecutor;
+import com.google.adk.agents.BaseAgent;
+import java.time.Duration;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * Registers the transport-only A2A webservice stack.
+ *
+ *
Importers must supply a {@link BaseAgent} bean. The agent remains opaque to this module so the
+ * transport can be reused across applications.
+ *
+ *
TODO:
+ *
+ *
+ *
Expose discovery endpoints (agent card / extended card) so clients can fetch metadata
+ * directly.
+ *
Add optional remote-proxy wiring for cases where no local agent bean is available.
+ *
+ *
+ *
**EXPERIMENTAL:** Subject to change, rename, or removal in any future patch release. Do not
+ * use in production code.
+ */
+@Configuration
+@ComponentScan(basePackages = "com.google.adk.webservice")
+public class A2ARemoteConfiguration {
+
+ private static final Logger logger = LoggerFactory.getLogger(A2ARemoteConfiguration.class);
+ private static final String DEFAULT_APP_NAME = "a2a-remote-service";
+ private static final long DEFAULT_TIMEOUT_SECONDS = 15L;
+
+ @Bean
+ public A2ASendMessageExecutor a2aSendMessageExecutor(
+ BaseAgent agent,
+ @Value("${a2a.remote.appName:" + DEFAULT_APP_NAME + "}") String appName,
+ @Value("${a2a.remote.timeoutSeconds:" + DEFAULT_TIMEOUT_SECONDS + "}") long timeoutSeconds) {
+ logger.info(
+ "Initializing A2A send message executor for appName {} with timeout {}s",
+ appName,
+ timeoutSeconds);
+ return new A2ASendMessageExecutor(agent, appName, Duration.ofSeconds(timeoutSeconds));
+ }
+}
diff --git a/a2a/webservice/src/main/java/com/google/adk/webservice/A2ARemoteController.java b/a2a/webservice/src/main/java/com/google/adk/webservice/A2ARemoteController.java
new file mode 100644
index 000000000..56d5a9e60
--- /dev/null
+++ b/a2a/webservice/src/main/java/com/google/adk/webservice/A2ARemoteController.java
@@ -0,0 +1,43 @@
+/**
+ * @author Sandeep Belgavi
+ */
+package com.google.adk.webservice;
+
+import io.a2a.spec.SendMessageRequest;
+import io.a2a.spec.SendMessageResponse;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * REST controller exposing an A2A-compliant JSON-RPC endpoint backed by a local ADK runner.
+ *
+ *
**EXPERIMENTAL:** Subject to change, rename, or removal in any future patch release. Do not
+ * use in production code.
+ */
+@RestController
+@RequestMapping("/a2a/remote")
+public class A2ARemoteController {
+
+ private static final Logger logger = LoggerFactory.getLogger(A2ARemoteController.class);
+
+ private final A2ARemoteService service;
+
+ public A2ARemoteController(A2ARemoteService service) {
+ this.service = service;
+ }
+
+ @PostMapping(
+ path = "/v1/message:send",
+ consumes = "application/json",
+ produces = "application/json")
+ public SendMessageResponse sendMessage(@RequestBody SendMessageRequest request) {
+ logger.debug("Received remote A2A request: {}", request);
+ SendMessageResponse response = service.handle(request);
+ logger.debug("Responding with remote A2A payload: {}", response);
+ return response;
+ }
+}
diff --git a/a2a/webservice/src/main/java/com/google/adk/webservice/A2ARemoteService.java b/a2a/webservice/src/main/java/com/google/adk/webservice/A2ARemoteService.java
new file mode 100644
index 000000000..1af9309d2
--- /dev/null
+++ b/a2a/webservice/src/main/java/com/google/adk/webservice/A2ARemoteService.java
@@ -0,0 +1,96 @@
+/**
+ * @author Sandeep Belgavi
+ */
+package com.google.adk.webservice;
+
+import com.google.adk.a2a.A2ASendMessageExecutor;
+import com.google.adk.a2a.converters.ResponseConverter;
+import io.a2a.spec.JSONRPCError;
+import io.a2a.spec.Message;
+import io.a2a.spec.MessageSendParams;
+import io.a2a.spec.SendMessageRequest;
+import io.a2a.spec.SendMessageResponse;
+import java.util.List;
+import java.util.UUID;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+
+/**
+ * Core service that bridges the A2A JSON-RPC sendMessage API to a local ADK runner.
+ *
+ *
**EXPERIMENTAL:** Subject to change, rename, or removal in any future patch release. Do not
+ * use in production code.
+ */
+@Service
+public class A2ARemoteService {
+
+ private static final Logger logger = LoggerFactory.getLogger(A2ARemoteService.class);
+ private static final int ERROR_CODE_INVALID_PARAMS = -32602;
+ private static final int ERROR_CODE_INTERNAL_ERROR = -32603;
+
+ private final A2ASendMessageExecutor executor;
+
+ public A2ARemoteService(A2ASendMessageExecutor executor) {
+ this.executor = executor;
+ }
+
+ public SendMessageResponse handle(SendMessageRequest request) {
+ if (request == null) {
+ logger.warn("Received null SendMessageRequest");
+ return invalidParamsResponse(null, "Request body is missing");
+ }
+
+ MessageSendParams params = request.getParams();
+ if (params == null) {
+ logger.warn("SendMessageRequest {} missing params", request.getId());
+ return invalidParamsResponse(request, "Request params are missing");
+ }
+
+ Message inbound = params.message();
+ if (inbound == null) {
+ logger.warn("SendMessageRequest {} missing message payload", request.getId());
+ return invalidParamsResponse(request, "Request message payload is missing");
+ }
+
+ boolean generatedContext = inbound.getContextId() == null || inbound.getContextId().isEmpty();
+ Message normalized = ensureContextId(inbound);
+ if (generatedContext) {
+ logger.debug("Incoming request lacked contextId; generated {}", normalized.getContextId());
+ }
+
+ try {
+ Message result = executor.execute(normalized).blockingGet();
+ if (result == null) {
+ result =
+ ResponseConverter.eventsToMessage(
+ List.of(), normalized.getContextId(), normalized.getTaskId());
+ }
+
+ logger.debug("Returning A2A response for context {}", normalized.getContextId());
+ return new SendMessageResponse(request.getId(), result);
+ } catch (RuntimeException e) {
+ logger.error("Failed to process remote A2A request", e);
+ return errorResponse(request, e);
+ }
+ }
+
+ private static Message ensureContextId(Message message) {
+ if (message.getContextId() != null && !message.getContextId().isEmpty()) {
+ return message;
+ }
+ return new Message.Builder(message).contextId(UUID.randomUUID().toString()).build();
+ }
+
+ private static SendMessageResponse invalidParamsResponse(
+ SendMessageRequest request, String reason) {
+ JSONRPCError error = new JSONRPCError(ERROR_CODE_INVALID_PARAMS, reason, null);
+ return new SendMessageResponse(request != null ? request.getId() : null, error);
+ }
+
+ private static SendMessageResponse errorResponse(SendMessageRequest request, Throwable error) {
+ String message = "Internal error processing sendMessage request";
+ JSONRPCError jsonrpcError = new JSONRPCError(ERROR_CODE_INTERNAL_ERROR, message, null);
+ return new SendMessageResponse(request != null ? request.getId() : null, jsonrpcError);
+ }
+}
diff --git a/contrib/samples/a2a_remote/README.md b/contrib/samples/a2a_remote/README.md
new file mode 100644
index 000000000..d1d2601ca
--- /dev/null
+++ b/contrib/samples/a2a_remote/README.md
@@ -0,0 +1,70 @@
+# A2A Remote Prime Service Sample
+
+This sample starts a standalone Spring Boot service that exposes the
+`remote_prime_agent` via the shared A2A webservice module
+(`google-adk-a2a-webservice`). It behaves like a third‑party service that
+implements the A2A JSON‑RPC contract and can be used by the ADK client (for
+example, the `a2a_basic` demo) as its remote endpoint.
+
+## Running the service
+
+```bash
+cd google_adk
+mvn -f contrib/samples/a2a_remote/pom.xml package
+
+GOOGLE_GENAI_USE_VERTEXAI=FALSE \
+GOOGLE_API_KEY= \
+mvn -f contrib/samples/a2a_remote/pom.xml exec:java
+```
+
+`RemoteA2AApplication` imports the reusable controller/service from
+`google-adk-a2a-webservice`, so the server listens on
+`http://localhost:8080/a2a/remote/v1/message:send` by default. Override the
+port with `-Dspring-boot.run.arguments=--server.port=` when running via
+`spring-boot:run` if you need to avoid collisions.
+
+```
+POST /a2a/remote/v1/message:send
+Content-Type: application/json
+```
+
+and accepts standard A2A JSON‑RPC payloads (`SendMessageRequest`). The
+response is a `SendMessageResponse` that contains either a `Message` or a
+`Task` in the `result` field. Spring Boot logs the request/response lifecycle
+to the console; add your preferred logging configuration if you need
+persistent logs.
+
+## Agent implementation
+
+- `remote_prime_agent/Agent.java` hosts the LLM agent that checks whether
+ numbers are prime (lifted from the Stubby demo). The model name defaults
+ to `gemini-2.5-pro`; set `GOOGLE_API_KEY` before running.
+- `RemoteA2AApplication` bootstraps the service by importing
+ `A2ARemoteConfiguration` and publishing the prime `BaseAgent` bean. The shared
+ configuration consumes that bean to create the `A2ASendMessageExecutor`.
+
+## Sample request
+
+```bash
+curl -X POST http://localhost:8080/a2a/remote/v1/message:send \
+ -H 'Content-Type: application/json' \
+ -d '{
+ "jsonrpc": "2.0",
+ "id": "demo-123",
+ "method": "message/send",
+ "params": {
+ "message": {
+ "role": "user",
+ "messageId": "msg-1",
+ "contextId": "ctx-1",
+ "parts": [
+ {"kind": "text", "text": "Check if 17 is prime"}
+ ]
+ },
+ "metadata": {}
+ }
+ }'
+```
+
+The response contains the prime check result, and the interaction is logged in
+the application console.
diff --git a/contrib/samples/a2a_remote/pom.xml b/contrib/samples/a2a_remote/pom.xml
new file mode 100644
index 000000000..59d9cf01e
--- /dev/null
+++ b/contrib/samples/a2a_remote/pom.xml
@@ -0,0 +1,139 @@
+
+
+ 4.0.0
+
+
+ com.google.adk
+ google-adk-parent
+ 0.5.1-SNAPSHOT
+ ../../../pom.xml
+
+
+ google-adk-sample-a2a-remote
+ Google ADK - Sample - A2A Remote Prime Service
+ Spring Boot service that exposes the remote prime-check agent over the A2A REST interface.
+ jar
+
+
+ 3.3.4
+ 17
+ 0.8
+ com.google.adk.samples.a2a_remote.RemoteA2AApplication
+
+
+
+
+
+ org.springframework.boot
+ spring-boot-dependencies
+ ${spring-boot.version}
+ pom
+ import
+
+
+
+
+
+
+ org.springframework.boot
+ spring-boot-starter-web
+
+
+
+ com.google.adk
+ google-adk
+ ${project.version}
+
+
+
+ com.google.adk
+ google-adk-a2a
+ ${project.version}
+
+
+
+ com.google.adk
+ google-adk-a2a-webservice
+ ${project.version}
+
+
+
+ com.google.flogger
+ flogger
+ ${flogger.version}
+
+
+ com.google.flogger
+ google-extensions
+ ${flogger.version}
+
+
+ com.google.flogger
+ flogger-system-backend
+ ${flogger.version}
+
+
+
+ org.springframework.boot
+ spring-boot-starter-test
+ test
+
+
+
+ com.google.truth
+ truth
+ ${truth.version}
+ test
+
+
+
+
+
+
+ org.springframework.boot
+ spring-boot-maven-plugin
+ ${spring-boot.version}
+
+
+ org.codehaus.mojo
+ build-helper-maven-plugin
+ 3.6.0
+
+
+ add-source
+ generate-sources
+
+ add-source
+
+
+
+ .
+
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-source-plugin
+
+
+ **/*.jar
+ target/**
+
+
+
+
+ org.codehaus.mojo
+ exec-maven-plugin
+ 3.2.0
+
+ ${exec.mainClass}
+ runtime
+
+
+
+
+
\ No newline at end of file
diff --git a/contrib/samples/a2a_remote/remote_prime_agent/Agent.java b/contrib/samples/a2a_remote/remote_prime_agent/Agent.java
new file mode 100644
index 000000000..9828bb4dc
--- /dev/null
+++ b/contrib/samples/a2a_remote/remote_prime_agent/Agent.java
@@ -0,0 +1,104 @@
+/**
+ * @author Sandeep Belgavi
+ */
+package com.google.adk.samples.a2a_remote.remote_prime_agent;
+
+import static java.util.stream.Collectors.joining;
+
+import com.google.adk.agents.LlmAgent;
+import com.google.adk.tools.FunctionTool;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.flogger.GoogleLogger;
+import io.reactivex.rxjava3.core.Maybe;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/** Agent that can check whether numbers are prime. */
+public final class Agent {
+
+ private static final GoogleLogger logger = GoogleLogger.forEnclosingClass();
+
+ public static ImmutableMap checkPrime(List nums) {
+ logger.atInfo().log("checkPrime called with nums=%s", nums);
+ Set primes = new HashSet<>();
+ for (int num : nums) {
+ if (num <= 1) {
+ continue;
+ }
+ boolean isPrime = true;
+ for (int i = 2; i <= Math.sqrt(num); i++) {
+ if (num % i == 0) {
+ isPrime = false;
+ break;
+ }
+ }
+ if (isPrime) {
+ primes.add(num);
+ }
+ }
+ String result;
+ if (primes.isEmpty()) {
+ result = "No prime numbers found.";
+ } else if (primes.size() == 1) {
+ int only = primes.iterator().next();
+ // Per request: singular phrasing without article
+ result = only + " is prime number.";
+ } else {
+ result = primes.stream().map(String::valueOf).collect(joining(", ")) + " are prime numbers.";
+ }
+ logger.atInfo().log("checkPrime result=%s", result);
+ return ImmutableMap.of("result", result);
+ }
+
+ public static final LlmAgent ROOT_AGENT =
+ LlmAgent.builder()
+ .model("gemini-2.5-pro")
+ .name("check_prime_agent")
+ .description("check prime agent that can check whether numbers are prime.")
+ .instruction(
+ """
+ You check whether numbers are prime.
+
+ If the last user message contains numbers, call checkPrime exactly once with exactly
+ those integers as a list (e.g., [2]). Never add other numbers. Do not ask for
+ clarification. Return only the tool's result.
+
+ Always pass a list of integers to the tool (use a single-element list for one
+ number). Never pass strings.
+ """)
+ // Log the exact contents passed to the LLM request for verification
+ .beforeModelCallback(
+ (callbackContext, llmRequest) -> {
+ try {
+ logger.atInfo().log(
+ "Invocation events (count=%d): %s",
+ callbackContext.events().size(), callbackContext.events());
+ } catch (Throwable t) {
+ logger.atWarning().withCause(t).log("BeforeModel logging error");
+ }
+ return Maybe.empty();
+ })
+ .afterModelCallback(
+ (callbackContext, llmResponse) -> {
+ try {
+ String content =
+ llmResponse.content().map(Object::toString).orElse("");
+ logger.atInfo().log("AfterModel content=%s", content);
+ llmResponse
+ .errorMessage()
+ .ifPresent(
+ error ->
+ logger.atInfo().log(
+ "AfterModel errorMessage=%s", error.replace("\n", "\\n")));
+ } catch (Throwable t) {
+ logger.atWarning().withCause(t).log("AfterModel logging error");
+ }
+ return Maybe.empty();
+ })
+ .tools(ImmutableList.of(FunctionTool.create(Agent.class, "checkPrime")))
+ .build();
+
+ private Agent() {}
+}
diff --git a/contrib/samples/a2a_remote/remote_prime_agent/agent.json b/contrib/samples/a2a_remote/remote_prime_agent/agent.json
new file mode 100644
index 000000000..87f2d9ecc
--- /dev/null
+++ b/contrib/samples/a2a_remote/remote_prime_agent/agent.json
@@ -0,0 +1,17 @@
+{
+ "capabilities": {},
+ "defaultInputModes": ["text/plain"],
+ "defaultOutputModes": ["application/json"],
+ "description": "An agent specialized in checking whether numbers are prime. It can efficiently determine the primality of individual numbers or lists of numbers.",
+ "name": "check_prime_agent",
+ "skills": [
+ {
+ "id": "prime_checking",
+ "name": "Prime Number Checking",
+ "description": "Check if numbers in a list are prime using efficient mathematical algorithms",
+ "tags": ["mathematical", "computation", "prime", "numbers"]
+ }
+ ],
+ "url": "http://localhost:8080/a2a/prime_agent",
+ "version": "1.0.0"
+}
diff --git a/contrib/samples/a2a_remote/src/main/java/com/google/adk/samples/a2a_remote/RemoteA2AApplication.java b/contrib/samples/a2a_remote/src/main/java/com/google/adk/samples/a2a_remote/RemoteA2AApplication.java
new file mode 100644
index 000000000..95ca73c12
--- /dev/null
+++ b/contrib/samples/a2a_remote/src/main/java/com/google/adk/samples/a2a_remote/RemoteA2AApplication.java
@@ -0,0 +1,27 @@
+/**
+ * @author Sandeep Belgavi
+ */
+package com.google.adk.samples.a2a_remote;
+
+import com.google.adk.agents.BaseAgent;
+import com.google.adk.samples.a2a_remote.remote_prime_agent.Agent;
+import com.google.adk.webservice.A2ARemoteConfiguration;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Import;
+
+/** Spring Boot entry point that wires the shared A2A webservice with the prime demo agent. */
+@SpringBootApplication
+@Import(A2ARemoteConfiguration.class)
+public class RemoteA2AApplication {
+
+ public static void main(String[] args) {
+ SpringApplication.run(RemoteA2AApplication.class, args);
+ }
+
+ @Bean
+ public BaseAgent primeAgent() {
+ return Agent.ROOT_AGENT;
+ }
+}
diff --git a/contrib/samples/pom.xml b/contrib/samples/pom.xml
index 55e1ae236..737584e8b 100644
--- a/contrib/samples/pom.xml
+++ b/contrib/samples/pom.xml
@@ -17,6 +17,7 @@
a2a_basic
+ a2a_remoteconfigagenthelloworldmcpfilesystem
diff --git a/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/SarvamAiConfigTest.java b/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/SarvamAiConfigTest.java
index b1a5243a0..508f8f834 100644
--- a/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/SarvamAiConfigTest.java
+++ b/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/SarvamAiConfigTest.java
@@ -21,7 +21,9 @@
import org.junit.jupiter.api.Test;
-/** @author Sandeep Belgavi */
+/**
+ * @author Sandeep Belgavi
+ */
class SarvamAiConfigTest {
@Test
diff --git a/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/SarvamAiTest.java b/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/SarvamAiTest.java
index 9fb79c8f6..a45a207e3 100644
--- a/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/SarvamAiTest.java
+++ b/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/SarvamAiTest.java
@@ -35,7 +35,9 @@
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
-/** @author Sandeep Belgavi */
+/**
+ * @author Sandeep Belgavi
+ */
class SarvamAiTest {
private MockWebServer server;
diff --git a/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/SarvamRetryInterceptorTest.java b/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/SarvamRetryInterceptorTest.java
index f62907cde..6c6432279 100644
--- a/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/SarvamRetryInterceptorTest.java
+++ b/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/SarvamRetryInterceptorTest.java
@@ -20,7 +20,9 @@
import org.junit.jupiter.api.Test;
-/** @author Sandeep Belgavi */
+/**
+ * @author Sandeep Belgavi
+ */
class SarvamRetryInterceptorTest {
@Test
diff --git a/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/chat/ChatRequestTest.java b/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/chat/ChatRequestTest.java
index aa39eb743..595014f1e 100644
--- a/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/chat/ChatRequestTest.java
+++ b/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/chat/ChatRequestTest.java
@@ -27,7 +27,9 @@
import java.util.List;
import org.junit.jupiter.api.Test;
-/** @author Sandeep Belgavi */
+/**
+ * @author Sandeep Belgavi
+ */
class ChatRequestTest {
private final ObjectMapper objectMapper = new ObjectMapper();
diff --git a/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/stt/SarvamSttServiceTest.java b/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/stt/SarvamSttServiceTest.java
index 8fca0ee6f..a38ee95f4 100644
--- a/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/stt/SarvamSttServiceTest.java
+++ b/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/stt/SarvamSttServiceTest.java
@@ -33,7 +33,9 @@
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
-/** @author Sandeep Belgavi */
+/**
+ * @author Sandeep Belgavi
+ */
class SarvamSttServiceTest {
private MockWebServer server;
diff --git a/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/tts/SarvamTtsServiceTest.java b/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/tts/SarvamTtsServiceTest.java
index 922cc8572..021d4d109 100644
--- a/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/tts/SarvamTtsServiceTest.java
+++ b/contrib/sarvam-ai/src/test/java/com/google/adk/models/sarvamai/tts/SarvamTtsServiceTest.java
@@ -32,7 +32,9 @@
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
-/** @author Sandeep Belgavi */
+/**
+ * @author Sandeep Belgavi
+ */
class SarvamTtsServiceTest {
private MockWebServer server;
diff --git a/core/src/main/java/com/google/adk/agents/LlmAgent.java b/core/src/main/java/com/google/adk/agents/LlmAgent.java
index ee24cae4d..218ac7358 100644
--- a/core/src/main/java/com/google/adk/agents/LlmAgent.java
+++ b/core/src/main/java/com/google/adk/agents/LlmAgent.java
@@ -66,6 +66,7 @@
import io.reactivex.rxjava3.core.Flowable;
import io.reactivex.rxjava3.core.Maybe;
import io.reactivex.rxjava3.core.Single;
+import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
@@ -651,6 +652,87 @@ public LlmAgent build() {
validate();
return new LlmAgent(this);
}
+
+ /**
+ * Builds the agent and starts it as an A2A server on the default port (8080). This method
+ * blocks until the server is terminated.
+ *
+ *
This method requires the {@code google-adk-a2a} module to be on the classpath. If the A2A
+ * module is not available, this will throw a {@link NoClassDefFoundError}.
+ *
+ *
+ *
+ * @throws NoClassDefFoundError if the A2A module is not on the classpath
+ * @throws IOException if the server fails to start
+ * @throws InterruptedException if interrupted while starting
+ */
+ public void toA2aServerAndStart() throws IOException, InterruptedException {
+ toA2aServerAndStart(8080);
+ }
+
+ /**
+ * Builds the agent and starts it as an A2A server on the specified port. This method blocks
+ * until the server is terminated.
+ *
+ *
This method requires the {@code google-adk-a2a} module to be on the classpath. If the A2A
+ * module is not available, this will throw a {@link NoClassDefFoundError}.
+ *
+ *
+ *
+ * @param port The port to start the server on
+ * @throws NoClassDefFoundError if the A2A module is not on the classpath
+ * @throws IOException if the server fails to start
+ * @throws InterruptedException if interrupted while starting
+ */
+ public void toA2aServerAndStart(int port) throws IOException, InterruptedException {
+ LlmAgent agent = build();
+ agent.toA2aServerAndStart(port);
+ }
+
+ /**
+ * Returns an A2aServerBuilder for advanced configuration. The returned object is an instance of
+ * {@code com.google.adk.a2a.grpc.A2aServerBuilder}.
+ *
+ *
This method requires the {@code google-adk-a2a} module to be on the classpath. If the A2A
+ * module is not available, this will throw a {@link NoClassDefFoundError}.
+ *
+ *
+ *
+ * @return An A2aServerBuilder instance (cast to the concrete type if needed)
+ * @throws NoClassDefFoundError if the A2A module is not on the classpath
+ */
+ public Object toA2a() {
+ LlmAgent agent = build();
+ return agent.toA2a();
+ }
}
protected BaseLlmFlow determineLlmFlow() {
@@ -956,6 +1038,78 @@ public Model resolvedModel() {
return resolvedModel;
}
+ private static final String A2A_SERVER_BUILDER_CLASS = "com.google.adk.a2a.grpc.A2aServerBuilder";
+
+ /**
+ * Starts this agent as an A2A server on the default port (8080). This method blocks until the
+ * server is terminated.
+ *
+ *
This method requires the {@code google-adk-a2a} module to be on the classpath.
+ *
+ * @throws NoClassDefFoundError if the A2A module is not on the classpath
+ * @throws IOException if the server fails to start
+ * @throws InterruptedException if interrupted while starting
+ */
+ public void toA2aServerAndStart() throws IOException, InterruptedException {
+ toA2aServerAndStart(8080);
+ }
+
+ /**
+ * Starts this agent as an A2A server on the specified port. This method blocks until the server
+ * is terminated.
+ *
+ *
This method requires the {@code google-adk-a2a} module to be on the classpath.
+ *
+ * @param port The port to start the server on
+ * @throws NoClassDefFoundError if the A2A module is not on the classpath
+ * @throws IOException if the server fails to start
+ * @throws InterruptedException if interrupted while starting
+ */
+ public void toA2aServerAndStart(int port) throws IOException, InterruptedException {
+ try {
+ Class builderClass = Class.forName(A2A_SERVER_BUILDER_CLASS);
+ Object builder = builderClass.getConstructor(LlmAgent.class).newInstance(this);
+ Object portedBuilder = builderClass.getMethod("port", int.class).invoke(builder, port);
+ Object server = portedBuilder.getClass().getMethod("build").invoke(portedBuilder);
+ server.getClass().getMethod("start").invoke(server);
+ } catch (ClassNotFoundException e) {
+ throw new NoClassDefFoundError(
+ "A2aServerBuilder not found. Add google-adk-a2a module to your classpath.");
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ Throwable cause = e.getCause();
+ if (cause instanceof IOException) {
+ throw (IOException) cause;
+ }
+ if (cause instanceof InterruptedException) {
+ throw (InterruptedException) cause;
+ }
+ throw new RuntimeException(cause);
+ } catch (ReflectiveOperationException e) {
+ throw new RuntimeException("Failed to invoke A2A server builder", e);
+ }
+ }
+
+ /**
+ * Returns an A2aServerBuilder for advanced configuration of this agent. The returned object is an
+ * instance of {@code com.google.adk.a2a.grpc.A2aServerBuilder}.
+ *
+ *
This method requires the {@code google-adk-a2a} module to be on the classpath.
+ *
+ * @return An A2aServerBuilder instance (cast to the concrete type if needed)
+ * @throws NoClassDefFoundError if the A2A module is not on the classpath
+ */
+ public Object toA2a() {
+ try {
+ Class builderClass = Class.forName(A2A_SERVER_BUILDER_CLASS);
+ return builderClass.getConstructor(LlmAgent.class).newInstance(this);
+ } catch (ClassNotFoundException e) {
+ throw new NoClassDefFoundError(
+ "A2aServerBuilder not found. Add google-adk-a2a module to your classpath.");
+ } catch (ReflectiveOperationException e) {
+ throw new RuntimeException("Failed to create A2aServerBuilder", e);
+ }
+ }
+
/**
* Resolves the model for this agent, checking first if it is defined locally, then searching
* through ancestors.
diff --git a/core/src/main/java/com/google/adk/models/BedrockBaseLM.java b/core/src/main/java/com/google/adk/models/BedrockBaseLM.java
index c2bac7793..9b90ccc45 100644
--- a/core/src/main/java/com/google/adk/models/BedrockBaseLM.java
+++ b/core/src/main/java/com/google/adk/models/BedrockBaseLM.java
@@ -786,7 +786,7 @@ public BufferedReader callLLMChatStream(String model, JSONArray messages, JSONAr
}
int responseCode = connection.getResponseCode();
- //System.out.println("Bedrock Response Code: " + responseCode);
+ // System.out.println("Bedrock Response Code: " + responseCode);
if (responseCode >= 200 && responseCode < 300) {
return new BufferedReader(new InputStreamReader(connection.getInputStream(), "UTF-8"));
@@ -908,14 +908,14 @@ public JSONObject callLLMChat(String model, JSONArray messages, JSONArray tools)
try (OutputStream outputStream = connection.getOutputStream();
OutputStreamWriter writer = new OutputStreamWriter(outputStream, "UTF-8")) {
writer.write(jsonString);
- // System.out.println("Bedrock Base LM => " + jsonString);
+ // System.out.println("Bedrock Base LM => " + jsonString);
writer.flush();
} catch (IOException ex) {
java.util.logging.Logger.getLogger(RedbusADG.class.getName()).log(Level.SEVERE, null, ex);
}
int responseCode = connection.getResponseCode();
- //System.out.println("Response Code: " + responseCode);
+ // System.out.println("Response Code: " + responseCode);
InputStream inputStream =
(responseCode < 400) ? connection.getInputStream() : connection.getErrorStream();
@@ -975,7 +975,7 @@ public static JSONObject callLLMChat(
String jsonString = payload.toString();
URL url = new URL(apiUrl);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
- //System.out.print("HTTP Connection to Ollama API: " + apiUrl.toString());
+ // System.out.print("HTTP Connection to Ollama API: " + apiUrl.toString());
connection.setRequestMethod("POST");
connection.setRequestProperty("Content-Type", "application/json");
connection.setRequestProperty("Authorization", "Bearer " + AWS_BEARER_TOKEN_BEDROCK);
@@ -983,11 +983,11 @@ public static JSONObject callLLMChat(
connection.setFixedLengthStreamingMode(jsonString.getBytes().length);
try (DataOutputStream outputStream = new DataOutputStream(connection.getOutputStream())) {
outputStream.writeBytes(jsonString);
- // System.out.println("Bedrock Base LM => " + jsonString);
+ // System.out.println("Bedrock Base LM => " + jsonString);
outputStream.flush();
}
int responseCode = connection.getResponseCode();
- //System.out.println("Response Code: " + responseCode);
+ // System.out.println("Response Code: " + responseCode);
try (BufferedReader reader =
new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
StringBuilder response = new StringBuilder();
@@ -1009,10 +1009,10 @@ public static JSONObject callLLMChat(
streamOutput.append(responseText);
// Display the parsed data
-// System.out.println("Model: " + model);
-// System.out.println("Response Text: " + responseText);
-// System.out.println("Done: " + done);
-// System.out.println("----------");
+ // System.out.println("Model: " + model);
+ // System.out.println("Response Text: " + responseText);
+ // System.out.println("Done: " + done);
+ // System.out.println("----------");
// Break if response is marked as done
if (done) {
@@ -1033,7 +1033,7 @@ public static JSONObject callLLMChat(
response.append(line);
}
String responseBody = response.toString();
- //System.out.println("Response Body: " + responseBody);
+ // System.out.println("Response Body: " + responseBody);
responseJ = new JSONObject(responseBody);
}
diff --git a/core/src/test/java/com/google/adk/agents/LlmAgentA2aTest.java b/core/src/test/java/com/google/adk/agents/LlmAgentA2aTest.java
new file mode 100644
index 000000000..0b88d459a
--- /dev/null
+++ b/core/src/test/java/com/google/adk/agents/LlmAgentA2aTest.java
@@ -0,0 +1,230 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @author Sandeep Belgavi
+ */
+package com.google.adk.agents;
+
+import static com.google.adk.testing.TestUtils.createLlmResponse;
+import static com.google.adk.testing.TestUtils.createTestAgentBuilder;
+import static com.google.adk.testing.TestUtils.createTestLlm;
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.adk.testing.TestLlm;
+import com.google.genai.types.Content;
+import com.google.genai.types.Part;
+import java.io.IOException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link LlmAgent} A2A fluent API methods.
+ *
+ *
Note: These tests require the {@code google-adk-a2a} module to be on the classpath. If the
+ * module is not available, tests will be skipped or throw {@link NoClassDefFoundError}.
+ */
+@RunWith(JUnit4.class)
+public final class LlmAgentA2aTest {
+
+ @Test
+ public void testBuilder_toA2a_returnsA2aServerBuilder() {
+ TestLlm testLlm = createTestLlm(createLlmResponse(Content.fromParts(Part.fromText("Test"))));
+ LlmAgent.Builder builder = createTestAgentBuilder(testLlm).name("TestAgent");
+
+ try {
+ Object result = builder.toA2a();
+ assertThat(result).isNotNull();
+ // Verify it's an A2aServerBuilder instance
+ assertThat(result.getClass().getName()).contains("A2aServerBuilder");
+ } catch (NoClassDefFoundError e) {
+ // A2A module not available - skip test
+ System.out.println("Skipping A2A test - module not available: " + e.getMessage());
+ }
+ }
+
+ @Test
+ public void testBuilder_toA2a_buildsAgentFirst() {
+ TestLlm testLlm = createTestLlm(createLlmResponse(Content.fromParts(Part.fromText("Test"))));
+ LlmAgent.Builder builder = createTestAgentBuilder(testLlm).name("TestAgent");
+
+ try {
+ Object result = builder.toA2a();
+ assertThat(result).isNotNull();
+ // Verify builder can still be used after toA2a()
+ LlmAgent agent = builder.build();
+ assertThat(agent.name()).isEqualTo("TestAgent");
+ } catch (NoClassDefFoundError e) {
+ System.out.println("Skipping A2A test - module not available: " + e.getMessage());
+ }
+ }
+
+ @Test
+ public void testBuilder_toA2aServerAndStart_withPort() throws IOException, InterruptedException {
+ TestLlm testLlm = createTestLlm(createLlmResponse(Content.fromParts(Part.fromText("Test"))));
+ LlmAgent.Builder builder = createTestAgentBuilder(testLlm).name("TestAgent");
+
+ try {
+ // This will start a server and block, so we test it in a separate thread
+ Thread testThread =
+ new Thread(
+ () -> {
+ try {
+ builder.toA2aServerAndStart(0); // Use port 0 for auto-assignment
+ } catch (Exception e) {
+ // Expected - port 0 might not work, or server might start successfully
+ }
+ });
+ testThread.start();
+ Thread.sleep(100); // Give it a moment to start
+ testThread.interrupt(); // Stop the blocking call
+ testThread.join(1000);
+ } catch (NoClassDefFoundError e) {
+ System.out.println("Skipping A2A test - module not available: " + e.getMessage());
+ } catch (IllegalArgumentException e) {
+ // Port 0 might not be valid - that's okay, we're just testing the method exists
+ assertThat(e.getMessage()).contains("port");
+ }
+ }
+
+ @Test
+ public void testBuilder_toA2aServerAndStart_defaultPort()
+ throws IOException, InterruptedException {
+ TestLlm testLlm = createTestLlm(createLlmResponse(Content.fromParts(Part.fromText("Test"))));
+ LlmAgent.Builder builder = createTestAgentBuilder(testLlm).name("TestAgent");
+
+ try {
+ // This will start a server and block, so we test it in a separate thread
+ Thread testThread =
+ new Thread(
+ () -> {
+ try {
+ builder.toA2aServerAndStart(); // Uses default port 8080
+ } catch (Exception e) {
+ // Expected - port might be in use, or server might start successfully
+ }
+ });
+ testThread.start();
+ Thread.sleep(100); // Give it a moment to start
+ testThread.interrupt(); // Stop the blocking call
+ testThread.join(1000);
+ } catch (NoClassDefFoundError e) {
+ System.out.println("Skipping A2A test - module not available: " + e.getMessage());
+ }
+ }
+
+ @Test
+ public void testInstance_toA2a_returnsA2aServerBuilder() {
+ TestLlm testLlm = createTestLlm(createLlmResponse(Content.fromParts(Part.fromText("Test"))));
+ LlmAgent agent = createTestAgentBuilder(testLlm).name("TestAgent").build();
+
+ try {
+ Object result = agent.toA2a();
+ assertThat(result).isNotNull();
+ // Verify it's an A2aServerBuilder instance
+ assertThat(result.getClass().getName()).contains("A2aServerBuilder");
+ } catch (NoClassDefFoundError e) {
+ System.out.println("Skipping A2A test - module not available: " + e.getMessage());
+ }
+ }
+
+ @Test
+ public void testInstance_toA2aServerAndStart_withPort() throws IOException, InterruptedException {
+ TestLlm testLlm = createTestLlm(createLlmResponse(Content.fromParts(Part.fromText("Test"))));
+ LlmAgent agent = createTestAgentBuilder(testLlm).name("TestAgent").build();
+
+ try {
+ // This will start a server and block, so we test it in a separate thread
+ Thread testThread =
+ new Thread(
+ () -> {
+ try {
+ agent.toA2aServerAndStart(0); // Use port 0 for auto-assignment
+ } catch (Exception e) {
+ // Expected - port 0 might not work, or server might start successfully
+ }
+ });
+ testThread.start();
+ Thread.sleep(100); // Give it a moment to start
+ testThread.interrupt(); // Stop the blocking call
+ testThread.join(1000);
+ } catch (NoClassDefFoundError e) {
+ System.out.println("Skipping A2A test - module not available: " + e.getMessage());
+ } catch (IllegalArgumentException e) {
+ // Port 0 might not be valid - that's okay, we're just testing the method exists
+ assertThat(e.getMessage()).contains("port");
+ }
+ }
+
+ @Test
+ public void testInstance_toA2aServerAndStart_defaultPort()
+ throws IOException, InterruptedException {
+ TestLlm testLlm = createTestLlm(createLlmResponse(Content.fromParts(Part.fromText("Test"))));
+ LlmAgent agent = createTestAgentBuilder(testLlm).name("TestAgent").build();
+
+ try {
+ // This will start a server and block, so we test it in a separate thread
+ Thread testThread =
+ new Thread(
+ () -> {
+ try {
+ agent.toA2aServerAndStart(); // Uses default port 8080
+ } catch (Exception e) {
+ // Expected - port might be in use, or server might start successfully
+ }
+ });
+ testThread.start();
+ Thread.sleep(100); // Give it a moment to start
+ testThread.interrupt(); // Stop the blocking call
+ testThread.join(1000);
+ } catch (NoClassDefFoundError e) {
+ System.out.println("Skipping A2A test - module not available: " + e.getMessage());
+ }
+ }
+
+ @Test
+ public void testBuilder_toA2a_throwsNoClassDefFoundError_whenA2aNotAvailable() {
+ // This test verifies that NoClassDefFoundError is thrown when A2A module is not available
+ // In practice, if A2A is not on classpath, the method will throw NoClassDefFoundError
+ // We can't easily simulate this without removing the dependency, so we just verify
+ // the method exists and can be called when A2A is available
+ TestLlm testLlm = createTestLlm(createLlmResponse(Content.fromParts(Part.fromText("Test"))));
+ LlmAgent.Builder builder = createTestAgentBuilder(testLlm).name("TestAgent");
+
+ try {
+ builder.toA2a();
+ // If we get here, A2A is available - test passes
+ } catch (NoClassDefFoundError e) {
+ // Expected if A2A module not available
+ assertThat(e.getMessage()).contains("A2aServerBuilder");
+ }
+ }
+
+ @Test
+ public void testInstance_toA2a_throwsNoClassDefFoundError_whenA2aNotAvailable() {
+ TestLlm testLlm = createTestLlm(createLlmResponse(Content.fromParts(Part.fromText("Test"))));
+ LlmAgent agent = createTestAgentBuilder(testLlm).name("TestAgent").build();
+
+ try {
+ agent.toA2a();
+ // If we get here, A2A is available - test passes
+ } catch (NoClassDefFoundError e) {
+ // Expected if A2A module not available
+ assertThat(e.getMessage()).contains("A2aServerBuilder");
+ }
+ }
+}
diff --git a/pom.xml b/pom.xml
index 02eb8175e..90e20906e 100644
--- a/pom.xml
+++ b/pom.xml
@@ -36,6 +36,7 @@
tutorials/city-time-weathertutorials/live-audio-single-agenta2a
+ a2a/webservice