fix(a2a): guarantee artifact streams accurately propagate completion chunks and multi-turn handoffs

- Fixed `lastChunk` flag assignment in `ARTIFACT_PER_RUN` mode to dynamically adhere to `partial` state, instead of remaining `false` indefinitely.
- Fixed `append` initialization in `EventProcessor` to ensure the first streamed chunk signals `append=false`.
- Leaves the `Message` payload in the terminal `TaskStatusUpdateEvent` completion event as `null` by default, aligning identically with the reference Go implementation.
- Refactored `EventConverter.findUserFunctionCall` to ignore `transfer_to_agent` function responses, ensuring remote A2A handoffs dispatch full conversational histories instead of terminating the prompt context.
- Modified `RemoteA2AAgent.StreamHandler` to reliably enforce task progression via standard ADK Payload `TaskState.COMPLETED`, preventing premature stream cancellations by non-gRPC servers executing `!streaming` validations.
- Added unit tests to `AgentExecutorTest` confirming `lastChunk` signals flip properly and affirming the `null` expectation for `Message`.

Author: glaforge

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

@@ -328,9 +328,9 @@ synchronized void handleEvent(ClientEvent clientEvent, AgentCard unused) {
             emitter.onNext(event);
           });
 
-      // For non-streaming communication, complete the flow; for streaming, wait until the client
-      // marks the completion.
-      if (isCompleted(clientEvent) || !streaming) {
+      // Wait until the client receives a status payload marking the completion of the task
+      // regardless of the underlying streaming or non-streaming protocol configuration.
+      if (isCompleted(clientEvent)) {
         // Only complete the flow once.
         if (!done) {
           emitAggregatedEventAndClearBuffer(clientEvent);

a2a/src/main/java/com/google/adk/a2a/converters/EventConverter.java

@@ -74,7 +74,9 @@ public static String contextId(Event event) {
       return null;
     }
     FunctionResponse functionResponse = findUserFunctionResponse(candidate);
-    if (functionResponse == null || functionResponse.id().isEmpty()) {
+    if (functionResponse == null
+        || functionResponse.id().isEmpty()
+        || "transfer_to_agent".equals(functionResponse.name().orElse(""))) {
       return null;
     }
     for (int i = events.size() - 2; i >= 0; i--) {

a2a/src/main/java/com/google/adk/a2a/executor/AgentExecutor.java

@@ -299,6 +299,7 @@ private static class EventProcessor {
     private final String runArtifactId;
     private final AgentExecutorConfig.OutputMode outputMode;
     private final Map<String, String> lastAgentPartialArtifact = new ConcurrentHashMap<>();
+    private boolean isFirstEventForRun = true;
 
     // All artifacts related to the invocation should have the same artifact id.
     private EventProcessor(AgentExecutorConfig.OutputMode outputMode) {
@@ -329,8 +330,9 @@ private Maybe<TaskArtifactUpdateEvent> process(
         }
       }
 
-      Boolean append = true;
-      Boolean lastChunk = false;
+      Boolean append = !isFirstEventForRun;
+      isFirstEventForRun = false;
+      Boolean lastChunk = !event.partial().orElse(false);
       String artifactId = runArtifactId;
 
       if (outputMode == AgentExecutorConfig.OutputMode.ARTIFACT_PER_EVENT) {

a2a/src/test/java/com/google/adk/a2a/executor/AgentExecutorTest.java

@@ -439,6 +439,72 @@ public void process_statefulAggregation_tracksArtifactIdAndAppendForAuthor() {
     assertThat(ev3.getArtifact().artifactId()).isEqualTo(firstArtifactId);
   }
 
+  @Test
+  public void execute_withDefaultArtifactPerRun_emitsMessageAndLastChunk() {
+    Event partialEvent =
+        Event.builder()
+            .partial(true)
+            .author("agent")
+            .content(
+                Content.builder()
+                    .parts(ImmutableList.of(Part.builder().text("chunk1").build()))
+                    .build())
+            .build();
+    Event finalEvent =
+        Event.builder()
+            .partial(false)
+            .author("agent")
+            .content(
+                Content.builder()
+                    .parts(ImmutableList.of(Part.builder().text("chunk1chunk2").build()))
+                    .build())
+            .build();
+
+    testAgent.setEventsToEmit(Flowable.just(partialEvent, finalEvent));
+    AgentExecutor executor =
+        new AgentExecutor.Builder()
+            .app(App.builder().name("test_app").rootAgent(testAgent).build())
+            .sessionService(new InMemorySessionService())
+            .artifactService(new InMemoryArtifactService())
+            .agentExecutorConfig(
+                AgentExecutorConfig.builder()
+                    .outputMode(AgentExecutorConfig.OutputMode.ARTIFACT_PER_RUN)
+                    .build())
+            .build();
+
+    RequestContext requestContext = createRequestContext();
+    executor.execute(requestContext, eventQueue);
+
+    // Verify events were correctly formed.
+    ImmutableList<TaskArtifactUpdateEvent> artifactEvents =
+        enqueuedEvents.stream()
+            .filter(e -> e instanceof TaskArtifactUpdateEvent)
+            .map(e -> (TaskArtifactUpdateEvent) e)
+            .collect(toImmutableList());
+
+    assertThat(artifactEvents).hasSize(2);
+    // Partial event has lastChunk = false
+    assertThat(artifactEvents.get(0).isLastChunk()).isFalse();
+    // Final event has lastChunk = true
+    assertThat(artifactEvents.get(1).isLastChunk()).isTrue();
+
+    // First chunk appends=false, subsequent chunks append=true
+    assertThat(artifactEvents.get(0).isAppend()).isFalse();
+    assertThat(artifactEvents.get(1).isAppend()).isTrue();
+
+    // Now verify the final TaskStatusUpdateEvent has a null message as expected
+    Optional<TaskStatusUpdateEvent> statusEvent =
+        enqueuedEvents.stream()
+            .filter(e -> e instanceof TaskStatusUpdateEvent)
+            .map(e -> (TaskStatusUpdateEvent) e)
+            .filter(TaskStatusUpdateEvent::isFinal)
+            .findFirst();
+
+    assertThat(statusEvent).isPresent();
+    Message finalMessage = statusEvent.get().getStatus().message();
+    assertThat(finalMessage).isNull();
+  }
+
   private static final class TestAgent extends BaseAgent {
     private Flowable<Event> eventsToEmit;