RemoteA2aAgent emits only partial events on the streaming path, never a final aggregated non-partial event, so the specialist's answer is never persisted

[virktapvir]

Describe the bug

When RemoteA2aAgent delegates to a streaming A2A agent, every event it yields for the turn has partial=True. It never yields a terminal partial=False event carrying the complete answer.

ADK does not persist partial events to the session. As a result, the parent agent never receives the remote agent's answer as a final response. Live streaming to a UI looks correct, but the answer is missing from session history and from anything that reads the final event.

This was confirmed with Google Cloud Support on the case that also covered #6680 / #7230. Support agreed that RemoteA2aAgent should emit a final aggregated non-partial event on the streaming path, and asked us to file it separately.

Versions

• google-adk at PR fix(a2a): keep streamed artifacts when a Task snapshot arrives mid-stream #7230 head (chelsealong/adk-python@0fe68deb, __version__ 2.9.2), on client and server. fix(a2a): keep streamed artifacts when a Task snapshot arrives mid-stream #7230 is required to get past the nonexistent artifact_id error. This bug is separate and is still present with fix(a2a): keep streamed artifacts when a Task snapshot arrives mid-stream #7230 applied.
• Remote agent deployed on Vertex AI Agent Engine via A2aAgent, northamerica-northeast1.
• Client uses RemoteA2aAgent with streaming enabled, calling /a2a/.../message:stream.

To reproduce

1. Deploy an agent that streams a multi-chunk text answer to Agent Engine via A2aAgent.
2. From a parent agent, delegate to it through RemoteA2aAgent with streaming on.
3. Log every event RemoteA2aAgent._run_async_impl yields for the turn.
4. Inspect the session after the turn.

Expected behavior

• Partial events stream through as they arrive.
• When the remote task reaches a terminal state (COMPLETED, FAILED, CANCELED or INPUT_REQUIRED), RemoteA2aAgent yields one non-partial Event whose content is the full accumulated answer. ADK persists it like any other final response.

Actual behavior

• All answer-bearing events have partial=True.
• The stream reaches TASK_STATE_COMPLETED, with 13 status updates and 1 artifact update in our run, but no non-partial event is yielded.
• The specialist's answer is absent from the parent session.

Related history
On 2.6.3, the old path set event.partial = not update.last_chunk. The final non-partial event then carried only the last delta, not the full answer. The in-code comment explains the trade-off: converting the accumulated task would re-emit earlier chunks. Aggregating the text of the partials into the terminal event avoids that duplication while still producing a complete final event.

Workaround
We subclass RemoteA2aAgent to fix this on our side. The subclass:

• passes partial events through unchanged, so live streaming still works;
• buffers their non-thought text parts, excluding thought=True progress text;
• if a terminal non-partial event arrives, rewrites its text to the full buffer and keeps any non-text parts;
• if the stream ends on partials only, emits one non-partial Event with the buffered text. On 2.9.2 this is the path every streamed turn takes.

class AccumulatingRemoteA2aAgent(RemoteA2aAgent):
    async def _run_async_impl(self, ctx):
        buffered = []
        async for event in super()._run_async_impl(ctx):
            texts = [p.text for p in (event.content.parts if event.content else [])
                     if getattr(p, "text", None) and not getattr(p, "thought", False)]
            if not texts:
                yield event
                continue
            if event.partial:
                buffered.extend(texts)
                yield event
                continue
            if buffered:
                # rewrite terminal event's text parts to "".join(buffered + texts)
                ...
            yield event
        if buffered:
            yield Event(
                author=self.name,
                content=types.Content(parts=[types.Part(text="".join(buffered))]),
                invocation_id=ctx.invocation_id,
                branch=ctx.branch,
            )

We used a subclass rather than the a2a_artifact_update_converter hook because that hook only exists on _handle_a2a_response_v2. That path runs only when the response advertises the new-integration A2A extension, and our custom executor doesn't advertise it.

Suggested fix
Have RemoteA2aAgent do this natively on the streaming path: accumulate answer text from partial events and emit one aggregated non-partial event when the remote task reaches a terminal state. A stream that closes without reaching a terminal state should surface an error instead of returning silently.

Related: #6680, #7230.

[chelsealong]

Picking this one up now — opening a PR shortly. Flagging it here so nobody duplicates the work; if someone is already on it, say so and I will drop mine.

[virktapvir]

Tested #7256 end to end. It resolves this issue for us.

Setup

• google-adk built from fix(a2a): keep streamed artifacts when a Task snapshot arrives mid-stream #7230 + fix(a2a): aggregate streamed text into a final non-partial event in RemoteA2aAgent #7256 applied together (__version__ 2.9.2). They apply cleanly on top of each other; fix(a2a): keep streamed artifacts when a Task snapshot arrives mid-stream #7230 is still needed separately for the nonexistent artifact_id error.
• Server: a streaming test agent on Vertex AI Agent Engine via A2aAgent, northamerica-northeast1, emitting a long multi-chunk text answer.
• Client: RemoteA2aAgent with streaming on, calling message:stream. Each run logs every event _run_async_impl yields and checks what the session persists.

Results

Client	Events	Partial chunks	Streamed text	Non-partial finals	Final text	Persisted
Stock RemoteA2aAgent (#7256)	162	159	18,041 chars	1	18,041 chars (equals streamed)	1 event, 18,041 chars
Our AccumulatingRemoteA2aAgent workaround on top of #7256	148	145	16,388 chars	1	32,776 chars (exactly 2×)	32,776 chars

With stock RemoteA2aAgent, partials still stream through live and exactly one aggregated non-partial event arrives at the end with the full answer, which ADK persists. That is the behaviour this issue asked for.

Note for anyone who used the workaround in the issue body: remove it once you're on #7256. The subclass re-buffers the partials and rewrites the new terminal event, so the final answer is duplicated (2× the streamed text, as above). We've dropped the subclass and now use stock RemoteA2aAgent.

Thanks for the quick fix. We'll move back to a release pin once #7230 and #7256 are both released.

[sanketpatil06]

Hi @virktapvir, thank you for reporting this issue and sharing the workaround. Buffering the partial chunks to emit a terminal event is indeed the right approach in the interim.

Thanks as well for confirming that #7256 resolves the issue on your end. The PR is currently under review by our team and will be merged once approved.