fix: the RemoteA2AAgent does not support resumability and always transfers to the parent

Only LLMAgent supported this via the disallowTransferToParent attribute
Add Resumable interface and test for runner resumability.
This change introduces the `Resumable` interface, allowing agents to indicate if they can be resumed from a previous state. Also the LLMAgent and RemoteA2A agent has been modified to implement this. Ea A new test case in `RunnerResumabilityTest` demonstrates how the runner can leverage this to resume execution from a resumable sub-agent based on the session history.

PiperOrigin-RevId: 898502514

Author: google-genai-bot

a2a/src/main/java/com/google/adk/a2a/agent/RemoteA2AAgent.java

@@ -27,6 +27,7 @@
 import com.google.adk.agents.BaseAgent;
 import com.google.adk.agents.Callbacks;
 import com.google.adk.agents.InvocationContext;
+import com.google.adk.agents.Resumable;
 import com.google.adk.events.Event;
 import com.google.adk.utils.AgentEnums.AgentOrigin;
 import com.google.common.collect.ImmutableList;
@@ -75,7 +76,7 @@
  *   <li>Converting A2A client responses back into ADK format
  * </ul>
  */
-public class RemoteA2AAgent extends BaseAgent {
+public class RemoteA2AAgent extends BaseAgent implements Resumable {
 
   private static final Logger logger = LoggerFactory.getLogger(RemoteA2AAgent.class);
   private static final ObjectMapper objectMapper =
@@ -85,6 +86,7 @@ public class RemoteA2AAgent extends BaseAgent {
   private final Client a2aClient;
   private String description;
   private final boolean streaming;
+  private final boolean resumable;
 
   // Internal constructor used by builder
   private RemoteA2AAgent(Builder builder) {
@@ -118,6 +120,7 @@ private RemoteA2AAgent(Builder builder) {
       this.description = this.agentCard.description();
     }
     this.streaming = builder.streaming && this.agentCard.capabilities().streaming();
+    this.resumable = builder.resumable;
   }
 
   public static Builder builder() {
@@ -134,13 +137,20 @@ public static class Builder {
     private List<Callbacks.BeforeAgentCallback> beforeAgentCallback;
     private List<Callbacks.AfterAgentCallback> afterAgentCallback;
     private boolean streaming;
+    private boolean resumable = true;
 
     @CanIgnoreReturnValue
     public Builder streaming(boolean streaming) {
       this.streaming = streaming;
       return this;
     }
 
+    @CanIgnoreReturnValue
+    public Builder resumable(boolean resumable) {
+      this.resumable = resumable;
+      return this;
+    }
+
     @CanIgnoreReturnValue
     public Builder name(String name) {
       this.name = name;
@@ -192,6 +202,11 @@ public boolean isStreaming() {
     return streaming;
   }
 
+  @Override
+  public boolean isResumable() {
+    return resumable;
+  }
+
   private Message.Builder newA2AMessage(Message.Role role, List<io.a2a.spec.Part<?>> parts) {
     return new Message.Builder().messageId(UUID.randomUUID().toString()).role(role).parts(parts);
   }
@@ -249,7 +264,6 @@ private static class StreamHandler {
     private final FlowableEmitter<Event> emitter;
     private final InvocationContext invocationContext;
     private final String requestJson;
-    private final boolean streaming;
     private final String agentName;
     private boolean done = false;
     private final StringBuilder textBuffer = new StringBuilder();
@@ -259,12 +273,10 @@ private static class StreamHandler {
         FlowableEmitter<Event> emitter,
         InvocationContext invocationContext,
         String requestJson,
-        boolean streaming,
         String agentName) {
       this.emitter = emitter;
       this.invocationContext = invocationContext;
       this.requestJson = requestJson;
-      this.streaming = streaming;
       this.agentName = agentName;
     }
 

a2a/src/test/java/com/google/adk/a2a/agent/RemoteA2AAgentTest.java

@@ -127,6 +127,18 @@ public void createAgent_streaming_true_returnsStreamingAgent() {
     assertThat(agent.isStreaming()).isTrue();
   }
 
+  @Test
+  public void createAgent_resumable_default_true() {
+    RemoteA2AAgent agent = getAgentBuilder().build();
+    assertThat(agent.isResumable()).isTrue();
+  }
+
+  @Test
+  public void createAgent_resumable_false() {
+    RemoteA2AAgent agent = getAgentBuilder().resumable(false).build();
+    assertThat(agent.isResumable()).isFalse();
+  }
+
   @Test
   public void runAsync_aggregatesPartialEvents() {
     RemoteA2AAgent agent = createAgent();

core/src/main/java/com/google/adk/agents/LlmAgent.java

@@ -76,7 +76,7 @@
 import org.slf4j.LoggerFactory;
 
 /** The LLM-based agent. */
-public class LlmAgent extends BaseAgent {
+public class LlmAgent extends BaseAgent implements Resumable {
 
   private static final Logger logger = LoggerFactory.getLogger(LlmAgent.class);
 
@@ -779,6 +779,11 @@ public boolean disallowTransferToParent() {
     return disallowTransferToParent;
   }
 
+  @Override
+  public boolean isResumable() {
+    return !disallowTransferToParent();
+  }
+
   public boolean disallowTransferToPeers() {
     return disallowTransferToPeers;
   }

core/src/main/java/com/google/adk/agents/Resumable.java

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2026 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.
+ */
+package com.google.adk.agents;
+
+/** Interface for agents that can be resumed from history directly. */
+public interface Resumable {
+  boolean isResumable();
+}

core/src/main/java/com/google/adk/runner/Runner.java

@@ -22,6 +22,7 @@
 import com.google.adk.agents.InvocationContext;
 import com.google.adk.agents.LiveRequestQueue;
 import com.google.adk.agents.LlmAgent;
+import com.google.adk.agents.Resumable;
 import com.google.adk.agents.RunConfig;
 import com.google.adk.apps.App;
 import com.google.adk.artifacts.BaseArtifactService;
@@ -752,13 +753,7 @@ protected Flowable<Event> runLiveImpl(
   private boolean isTransferableAcrossAgentTree(BaseAgent agentToRun) {
     BaseAgent current = agentToRun;
     while (current != null) {
-      // Agents eligible to transfer must have an LLM-based agent parent.
-      if (!(current instanceof LlmAgent)) {
-        return false;
-      }
-      // If any agent can't transfer to its parent, the chain is broken.
-      LlmAgent agent = (LlmAgent) current;
-      if (agent.disallowTransferToParent()) {
+      if (!(current instanceof Resumable resumableAgent) || !resumableAgent.isResumable()) {
         return false;
       }
       current = current.parentAgent();

core/src/test/java/com/google/adk/runner/RunnerResumabilityTest.java

@@ -0,0 +1,141 @@
+package com.google.adk.runner;
+
+import static com.google.adk.testing.TestUtils.createContent;
+import static com.google.adk.testing.TestUtils.createLlmResponse;
+import static com.google.adk.testing.TestUtils.createTestLlm;
+import static com.google.adk.testing.TestUtils.simplifyEvents;
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.adk.agents.BaseAgent;
+import com.google.adk.agents.InvocationContext;
+import com.google.adk.agents.LlmAgent;
+import com.google.adk.agents.Resumable;
+import com.google.adk.apps.App;
+import com.google.adk.events.Event;
+import com.google.adk.sessions.Session;
+import com.google.common.collect.ImmutableList;
+import com.google.genai.types.Content;
+import com.google.genai.types.Part;
+import io.reactivex.rxjava3.core.Flowable;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for the resumability feature in the {@link Runner}.
+ *
+ * <p>This test suite verifies that when a session contains events from a resumable agent, the
+ * runner correctly bypasses earlier workflow steps (like the root agent) and resumes execution
+ * directly at the last active resumable agent.
+ */
+@RunWith(JUnit4.class)
+public final class RunnerResumabilityTest {
+
+  private static class TestResumableAgent extends BaseAgent implements Resumable {
+    private final boolean resumable;
+
+    public TestResumableAgent(String name, boolean resumable) {
+      super(name, "", ImmutableList.of(), ImmutableList.of(), ImmutableList.of());
+      this.resumable = resumable;
+    }
+
+    @Override
+    public boolean isResumable() {
+      return resumable;
+    }
+
+    @Override
+    protected Flowable<Event> runAsyncImpl(InvocationContext context) {
+      return Flowable.just(
+          Event.builder()
+              .id("event-" + name())
+              .author(name())
+              .content(
+                  Content.builder()
+                      .parts(
+                          ImmutableList.of(Part.builder().text("response from " + name()).build()))
+                      .build())
+              .build());
+    }
+
+    @Override
+    protected Flowable<Event> runLiveImpl(InvocationContext context) {
+      return runAsyncImpl(context);
+    }
+  }
+
+  /**
+   * Verifies that {@link Runner#runAsync} picks up execution from a resumable sub-agent.
+   *
+   * <p>This test configures a workflow hierarchy with a root agent and a resumable sub-agent. By
+   * pre-loading the session state with an initial event authored by the sub-agent, we simulate a
+   * scenario where execution stopped within the sub-workflow. Calling {@code runAsync} triggers the
+   * resume behavior, bypassing the default root flow.
+   */
+  @Test
+  public void runAsync_resumesAtResumableSubAgent() {
+    TestResumableAgent subAgent = new TestResumableAgent("sub_agent", true);
+    LlmAgent rootAgent =
+        LlmAgent.builder()
+            .name("root_agent")
+            .model(createTestLlm(createLlmResponse(createContent("from root"))))
+            .subAgents(ImmutableList.of(subAgent))
+            .build();
+
+    Runner runner =
+        Runner.builder().app(App.builder().name("test").rootAgent(rootAgent).build()).build();
+
+    Session session = runner.sessionService().createSession("test", "user").blockingGet();
+
+    Event subAgentEvent =
+        Event.builder()
+            .id("initial-event")
+            .author("sub_agent")
+            .content(createContent("subagent greeting"))
+            .build();
+
+    var unused = runner.sessionService().appendEvent(session, subAgentEvent).blockingGet();
+
+    var events =
+        runner.runAsync("user", session.id(), createContent("continue")).toList().blockingGet();
+
+    assertThat(simplifyEvents(events)).containsExactly("sub_agent: response from sub_agent");
+  }
+
+  /**
+   * Verifies that {@link Runner#runAsync} does not resume execution from a non-resumable sub-agent.
+   *
+   * <p>This test ensures that if the sub-agent is NOT marked as resumable, even if there are
+   * existing events from it in the session, the runner falls back to regular execution starting
+   * from the root agent.
+   */
+  @Test
+  public void runAsync_doesNotResumeAtNonResumableSubAgent() {
+    TestResumableAgent subAgent = new TestResumableAgent("sub_agent", false);
+    LlmAgent rootAgent =
+        LlmAgent.builder()
+            .name("root_agent")
+            .model(createTestLlm(createLlmResponse(createContent("from root"))))
+            .subAgents(ImmutableList.of(subAgent))
+            .build();
+
+    Runner runner =
+        Runner.builder().app(App.builder().name("test").rootAgent(rootAgent).build()).build();
+
+    Session session = runner.sessionService().createSession("test", "user").blockingGet();
+
+    Event subAgentEvent =
+        Event.builder()
+            .id("initial-event")
+            .author("sub_agent")
+            .content(createContent("subagent greeting"))
+            .build();
+
+    var unused = runner.sessionService().appendEvent(session, subAgentEvent).blockingGet();
+
+    var events =
+        runner.runAsync("user", session.id(), createContent("continue")).toList().blockingGet();
+
+    assertThat(simplifyEvents(events)).containsExactly("root_agent: from root");
+  }
+}

core/src/test/java/com/google/adk/testing/TestUtils.java

@@ -234,6 +234,10 @@ public static TestLlm createTestLlm(Supplier<Flowable<LlmResponse>> responsesSup
     return new TestLlm(responsesSupplier);
   }
 
+  public static Content createContent(String text) {
+    return Content.builder().parts(Part.builder().text(text).build()).build();
+  }
+
   public static LlmResponse createLlmResponse(Content content) {
     return LlmResponse.builder().content(content).build();
   }