tool_stream_event not visible through A2A protocol - am I doing this wrong?

[TidyH]

What I'm trying to do

I have a swarm-as-tool pattern where a top-level orchestrator agent uses Swarms (SoftwareSwarm, InfrastructureSwarm) as
async generator tools. When the orchestrator invokes a swarm tool, the swarm yields progress events like handoffs betw
een agents, status updates, etc.

This works great when I call agent.stream_async() directly, but when I serve the orchestrator via A2AServer and con
nect with an A2A client, I only see the orchestrator's final text output. All the intermediate tool streaming events di
sappear.

I'm not sure if I'm missing a configuration option or if this is a limitation of A2AServer.

My setup

• Docker Compose local development environment
• Orchestrator agent served via A2AServer on port 8000
• Swarms (SoftwareSwarm, InfrastructureSwarm) wrapped as async generator tools
• A2A client connecting with streaming=True

The swarm tool implementation

@tool
async def software_development_swarm(task: str, context: dict = None) -> str:
    """Multi-agent swarm for software development."""
    final_content = []

    async for event in software_swarm.stream_async(task, context or {}):
        event_type = event.get("event_type")
        event_data = event.get("data", {})

        if event_type == "handoff":
            agent_name = event_data.get("agent", "unknown")
            yield f"Handing off to {agent_name}..."

        elif event_type == "agent_start":
            agent_name = event_data.get("agent", "unknown")
            yield f"{agent_name} starting work..."

        elif event_type == "progress":
            content = event_data.get("content", "")
            if content:
                yield content
                final_content.append(content)
            else:
                agent_name = event_data.get("agent", "agent")
                yield f"{agent_name} working..."

        elif event_type == "agent_end":
            agent_name = event_data.get("agent", "unknown")
            yield f"{agent_name} completed"

    return "\n".join(final_content)

What I observe

Server logs (orchestrator container):

2025-11-06 19:23:09 [info] streaming_swarm_task swarm_type=InfrastructureSwarm
2025-11-06 19:23:09 [debug] stream_event_yielded event_type=handoff
2025-11-06 19:23:10 [debug] stream_event_yielded event_type=agent_start
2025-11-06 19:23:10 [debug] stream_event_yielded event_type=progress
2025-11-06 19:23:11 [debug] stream_event_yielded event_type=progress
... (50+ progress events)

The orchestrator is definitely receiving and processing these yields.

Client logs (conduit application):

2025-11-06 19:22:59 [debug] received_a2a_event agent='Full-Stack Orchestrator' event_type=tuple
2025-11-06 19:22:59 [debug] received_update_event update_event_type=TaskStatusUpdateEvent
2025-11-06 19:22:59 [info] yielding_status_content chunk_size=12 content_preview="I'll analyze"
2025-11-06 19:23:02 [info] yielding_status_content chunk_size=35 content_preview='Let me use the appropriate approach'
2025-11-06 19:23:03 [info] yielding_status_content chunk_size=65 content_preview=' since this involves infrastructure/p
ipeline'

The client only receives the orchestrator's own text ("I'll analyze...", "Let me use..."), not any of the swarm's progr
ess events.

What the user sees in the UI:
Just the orchestrator's final summary after the swarm completes. Something like:

I've analyzed the pipeline and delegated to the IaC swarm. Here's what was done:

• Cloned the repository
• Identified the root cause
• Applied fixes
• Committed changes

But they never saw:

• "Handing off to Python Pro..."
• "Python Pro starting work..."
• "agent working..."
• Any of the actual swarm execution progress

My orchestrator setup

from strands import Agent
from strands.multiagent.a2a.server import A2AServer

# Create orchestrator with swarm tools
orchestrator = Agent(
    model=model,
    system_prompt=system_prompt,
    tools=[software_development_swarm, iac_swarm],
    # Note: NO callback_handler - I removed it after learning callbacks
    # and stream_async() are mutually exclusive
)

# Serve via A2A
a2a_server = A2AServer(
    agent=orchestrator,
    host="0.0.0.0",
    port=8000,
    http_url="http://localhost:8000"
)

The agent card declares streaming: true and the client connects with ClientConfig(streaming=True).

What I've tried

1. Removed callback_handler - Initially I had a callback handler attached, but I learned from the docs that callbac
   ks and stream_async() are mutually exclusive, so I removed it. The orchestrator still doesn't forward tool events via A
   2A.

2. Verified local streaming works - When I test the orchestrator locally with agent.stream_async(), I can see all
   the tool_stream_event:

async for event in orchestrator.stream_async("test task"):
    if "tool_stream_event" in event:
        print(event["tool_stream_event"]["data"])
        # This prints all the swarm progress!

3. Checked A2A client configuration - Client has streaming=True, agent card has capabilities.streaming: true, e
   verything seems configured correctly.

My question

Is there a way to make A2AServer forward tool_stream_event to clients? Or is this a known limitation?

I noticed issue #543 ("Streaming Tool results are swallowed") was closed after fixing tool streaming for local usage, b
ut I couldn't find anything about A2A integration. Issue #116 had a comment asking "would this enable to stream sub-age
nt's events for agents-as-tools pattern?" which makes me think this might be a known gap.

For context, this matters a lot for UX - swarms can run for several minutes, and users currently see nothing until the
very end. Being able to stream "Python Pro is working on the code...", "Code Reviewer is checking the changes..." would
make the system feel much more responsive.

Minimal reproduction

If it helps, I can provide a minimal Docker Compose setup that reproduces this, but basically:

1. Create any async generator tool that yields progress
2. Create an agent with that tool
3. Serve via A2AServer
4. Connect with A2A client using streaming
5. Observe that tool yields don't appear in the A2A stream

Thanks for any guidance on whether I'm missing something or if this needs SDK changes

[zastrowm]

This looks to be a gap in the SDK.

In the implementation of the A2A server, it's filtering only data/text events:

sdk-python/src/strands/multiagent/a2a/executor.py

Line 125 in ef18a25

if "data" in event: