vystak-transport-http 0.2.0__tar.gz

vystak_transport_http-0.2.0/.gitignore

@@ -0,0 +1,45 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+.venv/
+.pytest_cache/
+.ruff_cache/
+.pyright/
+
+# TypeScript
+node_modules/
+*.tsbuildinfo
+coverage/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment
+.env
+.env.local
+
+# Vystak generated output (was .agentstack/ before rename)
+.vystak/
+.agentstack/
+
+# Bundled templates copied into vystak-cli wheel at build time (build hook output)
+packages/python/vystak-cli/src/vystak_cli/templates/
+
+# Tooling workspaces (brainstorm sessions, local agent state)
+.superpowers/
+.worktrees/
+.claude/

vystak_transport_http-0.2.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: vystak-transport-http
+Version: 0.2.0
+Summary: HTTP transport for Vystak east-west A2A traffic
+Requires-Python: >=3.11
+Requires-Dist: fastapi>=0.115
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.0
+Requires-Dist: sse-starlette>=2.0
+Requires-Dist: vystak
+Description-Content-Type: text/markdown
+
+# vystak-transport-http
+
+HTTP implementation of the Vystak `Transport` ABC.
+
+- `HttpTransport` — concrete Transport using httpx (client) and FastAPI (server's /a2a is already handled; serve() is a no-op).
+- `HttpTransportPlugin` — `TransportPlugin` providing env-var contract and (empty) provisioning.

vystak_transport_http-0.2.0/README.md

@@ -0,0 +1,6 @@
+# vystak-transport-http
+
+HTTP implementation of the Vystak `Transport` ABC.
+
+- `HttpTransport` — concrete Transport using httpx (client) and FastAPI (server's /a2a is already handled; serve() is a no-op).
+- `HttpTransportPlugin` — `TransportPlugin` providing env-var contract and (empty) provisioning.

vystak_transport_http-0.2.0/pyproject.toml

@@ -0,0 +1,37 @@
+[project]
+name = "vystak-transport-http"
+dynamic = ["version"]
+description = "HTTP transport for Vystak east-west A2A traffic"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "vystak",
+    "httpx>=0.27",
+    "fastapi>=0.115",
+    "sse-starlette>=2.0",
+    "pydantic>=2.0",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.23",
+    "uvicorn>=0.34",
+]
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/vystak_transport_http"]
+
+[tool.uv.sources]
+vystak = { workspace = true }
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = {root = "../../.."}

vystak_transport_http-0.2.0/src/vystak_transport_http/__init__.py

@@ -0,0 +1,6 @@
+"""HTTP transport implementation for Vystak."""
+
+from vystak_transport_http.plugin import HttpTransportPlugin
+from vystak_transport_http.transport import HttpTransport
+
+__all__ = ["HttpTransport", "HttpTransportPlugin"]

vystak_transport_http-0.2.0/src/vystak_transport_http/delivery.py

@@ -0,0 +1,24 @@
+"""HttpChannelDelivery — POST /deliver to the channel's HTTP delivery port."""
+
+from __future__ import annotations
+
+import httpx
+from vystak_channel_runtime.delivery import ChannelDelivery, DeliveryRequest
+
+
+class HttpChannelDelivery(ChannelDelivery):
+    def __init__(self, channel_routes: dict[str, str]) -> None:
+        # canonical_name → base URL like http://host:9999
+        self._routes = dict(channel_routes)
+
+    async def deliver(
+        self,
+        channel_canonical_name: str,
+        request: DeliveryRequest,
+        *,
+        timeout: float = 30,
+    ) -> None:
+        url = self._routes[channel_canonical_name].rstrip("/") + "/deliver"
+        async with httpx.AsyncClient(timeout=timeout) as c:
+            r = await c.post(url, json=request.model_dump(mode="json"))
+            r.raise_for_status()

vystak_transport_http-0.2.0/src/vystak_transport_http/plugin.py

@@ -0,0 +1,39 @@
+"""HttpTransportPlugin — registers the HTTP transport with providers."""
+
+from __future__ import annotations
+
+from vystak.providers.base import GeneratedCode, TransportPlugin
+from vystak.schema import Platform, Transport
+from vystak.schema.agent import Agent
+from vystak.transport.naming import slug
+
+
+class HttpTransportPlugin(TransportPlugin):
+    """HTTP transport plugin. No broker to provision; listener handled by
+    the generated FastAPI app already."""
+
+    type = "http"
+
+    def build_provision_nodes(self, transport: Transport, platform: Platform):
+        return []
+
+    def generate_env_contract(self, transport: Transport, context: dict) -> dict[str, str]:
+        return {"VYSTAK_TRANSPORT_TYPE": "http"}
+
+    def generate_listener_code(self, transport: Transport) -> GeneratedCode | None:
+        return None
+
+    def resolve_address_for(self, agent: Agent, platform: Platform) -> str:
+        """Return the Docker-style DNS URL for an agent.
+
+        Matches the Docker provider's container naming (`vystak-{agent_name}`)
+        since that's what DockerAgentNode actually creates and what Docker's
+        network DNS resolves on the shared vystak-net. Namespace is not
+        encoded in the URL because the container name is namespace-flat today
+        — v1 deployments are single-namespace per Docker host.
+
+        Azure providers override this (or use their own plugin) since the
+        ingress hostname isn't derivable from the name alone.
+        """
+        port = agent.port or 8000
+        return f"http://vystak-{slug(agent.name)}:{port}/a2a"

vystak_transport_http-0.2.0/src/vystak_transport_http/transport.py

@@ -0,0 +1,219 @@
+"""HttpTransport — uses httpx (client) and relies on generated FastAPI /a2a (server)."""
+
+from __future__ import annotations
+
+import json
+import logging
+import uuid
+from collections.abc import AsyncIterator
+from typing import Any
+
+import httpx
+from pydantic import ValidationError
+from vystak.transport import (
+    A2AEvent,
+    A2AMessage,
+    A2AResult,
+    AgentRef,
+    Transport,
+)
+from vystak.transport.base import ServerDispatcherProtocol
+
+logger = logging.getLogger(__name__)
+
+
+class HttpTransport(Transport):
+    """HTTP implementation of the Transport ABC.
+
+    Client side: httpx POST to `{agent_url}/a2a` with JSON-RPC A2A envelope.
+    Server side: the generated agent already exposes `/a2a` via FastAPI;
+    `serve()` is a no-op.
+
+    Routes are supplied at construction time (typically built from
+    `VYSTAK_ROUTES_JSON` + the platform's canonical-to-URL mapping).
+    """
+
+    type = "http"
+    supports_streaming = True
+
+    def __init__(self, routes: dict[str, str]) -> None:
+        """`routes` maps canonical_name -> absolute URL ending in `/a2a`."""
+        self._routes = dict(routes)
+
+    def resolve_address(self, canonical_name: str) -> str:
+        try:
+            return self._routes[canonical_name]
+        except KeyError:
+            raise KeyError(
+                f"HttpTransport has no route for canonical name "
+                f"{canonical_name!r}; known: {sorted(self._routes)}"
+            ) from None
+
+    async def send_task(
+        self,
+        agent: AgentRef,
+        message: A2AMessage,
+        metadata: dict[str, Any],
+        *,
+        timeout: float,
+    ) -> A2AResult:
+        url = self.resolve_address(agent.canonical_name)
+        payload = self._build_payload("message/send", message, metadata)
+        try:
+            async with httpx.AsyncClient(timeout=timeout) as client:
+                response = await client.post(url, json=payload)
+                response.raise_for_status()
+                body = response.json()
+        except httpx.TimeoutException as exc:
+            raise TimeoutError(str(exc)) from exc
+        return self._parse_result(body, message.correlation_id)
+
+    async def stream_task(
+        self,
+        agent: AgentRef,
+        message: A2AMessage,
+        metadata: dict[str, Any],
+        *,
+        timeout: float,
+    ) -> AsyncIterator[A2AEvent]:
+        url = self.resolve_address(agent.canonical_name)
+        payload = self._build_payload("message/stream", message, metadata)
+        async with (
+            httpx.AsyncClient(timeout=timeout) as client,
+            client.stream("POST", url, json=payload) as response,
+        ):
+            response.raise_for_status()
+            async for line in response.aiter_lines():
+                if not line or not line.startswith("data:"):
+                    continue
+                data = line.removeprefix("data:").strip()
+                if not data:
+                    continue
+                try:
+                    parsed = json.loads(data)
+                except json.JSONDecodeError:
+                    continue
+                # A2AEvent model_validate tolerates missing optional fields.
+                try:
+                    yield A2AEvent.model_validate(parsed)
+                except ValidationError:
+                    # Skip lines that don't match the A2AEvent shape (e.g.,
+                    # legacy JSON-RPC envelope frames emitted by the
+                    # LangChain adapter for token/status/final events).
+                    # Existing SSE consumers can still parse the envelope
+                    # themselves at a higher layer. Log at debug so this is
+                    # visible if real bugs surface.
+                    logger.debug("skipping non-A2AEvent SSE frame: %r", parsed)
+                    continue
+
+    async def serve(self, canonical_name: str, handler: ServerDispatcherProtocol) -> None:
+        # FastAPI's /a2a route already handles inbound HTTP; nothing to do.
+        return None
+
+    def _agent_base_url(self, agent: AgentRef) -> str:
+        """Derive the agent's base URL from its A2A wire address.
+
+        Plan A's URL format is consistent: the A2A endpoint lives at `{base}/a2a`,
+        so stripping the suffix gives the base. For future transports that use
+        different paths, revisit.
+        """
+        a2a_url = self.resolve_address(agent.canonical_name)
+        return a2a_url.removesuffix("/a2a")
+
+    async def create_response(
+        self,
+        agent: AgentRef,
+        request: dict[str, Any],
+        metadata: dict[str, Any],
+        *,
+        timeout: float,
+    ) -> dict[str, Any]:
+        base = self._agent_base_url(agent)
+        async with httpx.AsyncClient(timeout=timeout) as client:
+            response = await client.post(f"{base}/v1/responses", json=request)
+            response.raise_for_status()
+            return response.json()
+
+    async def create_response_stream(
+        self,
+        agent: AgentRef,
+        request: dict[str, Any],
+        metadata: dict[str, Any],
+        *,
+        timeout: float,
+    ) -> AsyncIterator[dict[str, Any]]:
+        base = self._agent_base_url(agent)
+        # Force stream=true even if caller didn't set it — this method's
+        # contract is that we yield chunks.
+        body = {**request, "stream": True}
+        async with (
+            httpx.AsyncClient(timeout=timeout) as client,
+            client.stream("POST", f"{base}/v1/responses", json=body) as response,
+        ):
+            response.raise_for_status()
+            async for line in response.aiter_lines():
+                if not line or not line.startswith("data:"):
+                    continue
+                data = line.removeprefix("data:").strip()
+                if not data or data == "[DONE]":
+                    continue
+                try:
+                    yield json.loads(data)
+                except json.JSONDecodeError:
+                    continue
+
+    async def get_response(
+        self,
+        agent: AgentRef,
+        response_id: str,
+        *,
+        timeout: float,
+    ) -> dict[str, Any] | None:
+        base = self._agent_base_url(agent)
+        async with httpx.AsyncClient(timeout=timeout) as client:
+            response = await client.get(f"{base}/v1/responses/{response_id}")
+            if response.status_code == 404:
+                return None
+            response.raise_for_status()
+            return response.json()
+
+    def _build_payload(
+        self, method: str, message: A2AMessage, metadata: dict[str, Any]
+    ) -> dict[str, Any]:
+        # A2A v0.3 spec shape (`message/send`, `message/stream`). The SDK's
+        # v0.3 compat layer requires `kind: "message"` plus a non-empty
+        # `messageId` on the wire — using the correlation_id as the
+        # messageId keeps client/server callsites lined up for tracing.
+        # `kind: "text"` on each part is similarly required.
+        parts = [
+            {**(p if isinstance(p, dict) else {}), "kind": "text"}
+            for p in message.parts
+        ]
+        return {
+            "jsonrpc": "2.0",
+            "id": str(uuid.uuid4()),
+            "method": method,
+            "params": {
+                "message": {
+                    "kind": "message",
+                    "messageId": message.correlation_id,
+                    "role": message.role,
+                    "parts": parts,
+                    "contextId": message.correlation_id,
+                },
+                "metadata": {**message.metadata, **metadata},
+            },
+        }
+
+    def _parse_result(self, body: dict[str, Any], fallback_correlation: str) -> A2AResult:
+        result = body.get("result", {}) or {}
+        parts = result.get("status", {}).get("message", {}).get("parts", [])
+        text = ""
+        for part in parts:
+            if isinstance(part, dict) and "text" in part:
+                text += part["text"]
+        return A2AResult(
+            text=text,
+            correlation_id=result.get("correlation_id") or fallback_correlation,
+            metadata={},
+        )

vystak_transport_http-0.2.0/tests/test_delivery.py

@@ -0,0 +1,30 @@
+"""HttpChannelDelivery test."""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from vystak_channel_runtime.delivery import DeliveryRequest
+from vystak_transport_http.delivery import HttpChannelDelivery
+
+
+@pytest.mark.asyncio
+async def test_post_to_channel_url():
+    routes = {"x.channels.dev": "http://vystak-channel-x:9999"}
+    d = HttpChannelDelivery(routes)
+    with patch("vystak_transport_http.delivery.httpx.AsyncClient") as ac:
+        client = AsyncMock()
+        ac.return_value.__aenter__.return_value = client
+        response = MagicMock()
+        response.raise_for_status = MagicMock()
+        client.post = AsyncMock(return_value=response)
+        await d.deliver("x.channels.dev", DeliveryRequest(thread_id="t", text="x"))
+        client.post.assert_awaited_once()
+        url = client.post.call_args.args[0]
+        assert url == "http://vystak-channel-x:9999/deliver"
+
+
+@pytest.mark.asyncio
+async def test_unknown_channel_raises():
+    d = HttpChannelDelivery({})
+    with pytest.raises(KeyError):
+        await d.deliver("ghost.channels.dev", DeliveryRequest(thread_id="t", text="x"))

vystak_transport_http-0.2.0/tests/test_http_plugin.py

@@ -0,0 +1,60 @@
+"""Tests for HttpTransportPlugin."""
+
+from __future__ import annotations
+
+from vystak.schema import Platform, Transport
+from vystak.schema.agent import Agent
+from vystak.schema.model import Model
+from vystak.schema.provider import Provider
+from vystak_transport_http import HttpTransportPlugin
+
+
+def test_type():
+    p = HttpTransportPlugin()
+    assert p.type == "http"
+
+
+def test_no_provision_nodes():
+    p = HttpTransportPlugin()
+    t = Transport(name="default-http", type="http")
+    provider = Provider(name="docker", type="docker")
+    pl = Platform(name="main", type="docker", provider=provider, transport=t)
+    assert p.build_provision_nodes(t, pl) == []
+
+
+def test_env_contract():
+    p = HttpTransportPlugin()
+    t = Transport(name="default-http", type="http")
+    env = p.generate_env_contract(t, context={})
+    assert env["VYSTAK_TRANSPORT_TYPE"] == "http"
+
+
+def test_no_listener_code():
+    p = HttpTransportPlugin()
+    t = Transport(name="default-http", type="http")
+    assert p.generate_listener_code(t) is None
+
+
+def test_resolve_address_for_docker_dns():
+    """resolve_address_for returns the Docker container name-matched URL."""
+    p = HttpTransportPlugin()
+    provider = Provider(name="docker", type="docker")
+    pl = Platform(name="main", type="docker", provider=provider, namespace="prod")
+    _openai = Provider(name="openai", type="openai", api_key_env="OPENAI_API_KEY")
+    model = Model(name="gpt-4o", model_name="gpt-4o", provider=_openai)
+    agent = Agent(name="my-agent", framework="langchain-python", default_model=model, port=9000)
+    url = p.resolve_address_for(agent, pl)
+    # Matches DockerAgentNode's container naming: `vystak-{agent_name}`.
+    assert url == "http://vystak-my-agent:9000/a2a"
+
+
+def test_resolve_address_for_default_port():
+    """resolve_address_for uses port 8000 when agent.port is None."""
+    p = HttpTransportPlugin()
+    provider = Provider(name="docker", type="docker")
+    pl = Platform(name="main", type="docker", provider=provider, namespace="default")
+    _openai = Provider(name="openai", type="openai", api_key_env="OPENAI_API_KEY")
+    model = Model(name="gpt-4o", model_name="gpt-4o", provider=_openai)
+    agent = Agent(name="worker", framework="langchain-python", default_model=model)
+    url = p.resolve_address_for(agent, pl)
+    assert url == "http://vystak-worker:8000/a2a"

vystak_transport_http-0.2.0/tests/test_http_transport.py

@@ -0,0 +1,219 @@
+"""Tests for HttpTransport."""
+
+from __future__ import annotations
+
+import asyncio
+from contextlib import asynccontextmanager
+
+import pytest
+import uvicorn
+from fastapi import FastAPI, Request
+from sse_starlette.sse import EventSourceResponse
+from vystak.transport import (
+    A2AMessage,
+    AgentRef,
+)
+from vystak.transport.contract import TransportContract
+from vystak_transport_http import HttpTransport
+
+
+def _build_app(handler) -> FastAPI:
+    """Minimal FastAPI app exposing /a2a for the test agent.
+
+    ``handler`` is a ``ServerDispatcherProtocol`` (per Plan C), so A2A calls
+    route via ``dispatch_a2a`` / ``dispatch_a2a_stream``.
+    """
+    app = FastAPI()
+
+    @app.post("/a2a")
+    async def a2a_endpoint(request: Request):
+        body = await request.json()
+        params = body.get("params", {})
+        metadata = params.get("metadata", {})
+        msg_params = params.get("message", {})
+        message = A2AMessage(
+            role=msg_params.get("role", "user"),
+            parts=msg_params.get("parts", []),
+            # Phase 10: v0.3 spec puts the correlation/thread id on the
+            # message itself (`messageId`/`contextId`) rather than top-level
+            # `params.id`. Test fake reads either path for compatibility.
+            correlation_id=(
+                params.get("id")
+                or msg_params.get("messageId")
+                or metadata.get("correlation_id", "")
+            ),
+            metadata=metadata,
+        )
+
+        if body.get("method") == "message/stream":
+
+            async def gen():
+                async for ev in handler.dispatch_a2a_stream(message, metadata):
+                    yield {"data": ev.model_dump_json()}
+
+            return EventSourceResponse(gen())
+
+        result = await handler.dispatch_a2a(message, metadata)
+        return {
+            "jsonrpc": "2.0",
+            "id": body.get("id"),
+            "result": {
+                "status": {"message": {"parts": [{"text": result.text}]}},
+                "correlation_id": result.correlation_id,
+            },
+        }
+
+    return app
+
+
+@asynccontextmanager
+async def _serve(app: FastAPI, port: int):
+    config = uvicorn.Config(app, host="127.0.0.1", port=port, log_level="warning")
+    server = uvicorn.Server(config)
+    task = asyncio.create_task(server.serve())
+    # Wait for the server to bind.
+    for _ in range(100):
+        if server.started:
+            break
+        await asyncio.sleep(0.01)
+    try:
+        yield
+    finally:
+        server.should_exit = True
+        await task
+
+
+class TestHttpTransport(TransportContract):
+    """Runs the shared transport contract against HttpTransport."""
+
+    @pytest.fixture
+    def serve_agent(self, unused_tcp_port):
+        @asynccontextmanager
+        async def _ctx(canonical_name: str, handler):
+            app = _build_app(handler)
+            async with _serve(app, unused_tcp_port):
+                client = HttpTransport(
+                    routes={canonical_name: f"http://127.0.0.1:{unused_tcp_port}/a2a"}
+                )
+                yield client
+
+        return _ctx
+
+
+class TestHttpTransportBasics:
+    def test_type(self):
+        t = HttpTransport(routes={})
+        assert t.type == "http"
+        assert t.supports_streaming is True
+
+    def test_resolve_address_lookup(self):
+        t = HttpTransport(routes={"x.agents.default": "http://example:8000/a2a"})
+        assert t.resolve_address("x.agents.default") == "http://example:8000/a2a"
+
+    def test_resolve_address_unknown(self):
+        t = HttpTransport(routes={})
+        with pytest.raises(KeyError):
+            t.resolve_address("unknown.agents.default")
+
+    @pytest.mark.asyncio
+    async def test_serve_is_noop(self):
+        t = HttpTransport(routes={})
+        # serve() returns immediately; the actual /a2a route is served by
+        # the generated agent's FastAPI app.
+        await t.serve("x.agents.default", handler=None)
+
+    @pytest.mark.asyncio
+    async def test_create_response_posts_to_agent(self, unused_tcp_port):
+        """create_response POSTs the request body to the agent's /v1/responses."""
+        from fastapi import FastAPI
+        from fastapi.responses import JSONResponse
+
+        received: dict = {}
+        app = FastAPI()
+
+        @app.post("/v1/responses")
+        async def handler(request: Request):  # Request imported at module level
+            received["body"] = await request.json()
+            return JSONResponse(
+                {
+                    "id": "resp-1",
+                    "object": "response",
+                    "created_at": 1,
+                    "model": "vystak/test",
+                    "output": [{"type": "message", "content": "hi"}],
+                    "status": "completed",
+                }
+            )
+
+        async with _serve(app, unused_tcp_port):
+            routes = {"test.agents.default": f"http://127.0.0.1:{unused_tcp_port}/a2a"}
+            t = HttpTransport(routes=routes)
+            ref = AgentRef(canonical_name="test.agents.default")
+            result = await t.create_response(
+                ref, {"model": "vystak/test", "input": "hello"}, {}, timeout=5
+            )
+            assert result["id"] == "resp-1"
+            assert received["body"]["input"] == "hello"
+
+    @pytest.mark.asyncio
+    async def test_get_response_returns_none_on_404(self, unused_tcp_port):
+        from fastapi import FastAPI
+        from fastapi.responses import JSONResponse
+
+        app = FastAPI()
+
+        @app.get("/v1/responses/{response_id}")
+        async def handler(response_id: str):
+            if response_id == "missing":
+                return JSONResponse({"error": "not found"}, status_code=404)
+            return JSONResponse({"id": response_id, "object": "response"})
+
+        async with _serve(app, unused_tcp_port):
+            routes = {"test.agents.default": f"http://127.0.0.1:{unused_tcp_port}/a2a"}
+            t = HttpTransport(routes=routes)
+            ref = AgentRef(canonical_name="test.agents.default")
+            assert await t.get_response(ref, "missing", timeout=5) is None
+            got = await t.get_response(ref, "resp-1", timeout=5)
+            assert got["id"] == "resp-1"
+
+    def test_agent_base_url_strips_a2a(self):
+        routes = {"x.agents.default": "http://vystak-x:8000/a2a"}
+        t = HttpTransport(routes=routes)
+        ref = AgentRef(canonical_name="x.agents.default")
+        assert t._agent_base_url(ref) == "http://vystak-x:8000"
+
+    @pytest.mark.asyncio
+    async def test_stream_task_skips_non_a2a_event_frames(self, unused_tcp_port):
+        """stream_task must silently skip SSE frames whose JSON does not
+        match the A2AEvent shape (e.g., legacy JSON-RPC envelope frames
+        from the LangChain adapter), rather than aborting the stream."""
+        app = FastAPI()
+
+        @app.post("/a2a")
+        async def a2a_endpoint(request: Request):
+            body = await request.json()
+            assert body.get("method") == "message/stream"
+
+            async def gen():
+                # Frame 1: valid A2AEvent (bare).
+                yield {"data": '{"type": "tool_call", "data": {"tool_name": "x"}}'}
+                # Frame 2: not an A2AEvent (no `type` field) -> ValidationError.
+                yield {"data": '{"jsonrpc": "2.0", "id": "n", "result": {}}'}
+                # Frame 3: valid A2AEvent (bare).
+                yield {"data": '{"type": "final", "text": "done", "final": true}'}
+
+            return EventSourceResponse(gen())
+
+        async with _serve(app, unused_tcp_port):
+            routes = {"test.agents.default": f"http://127.0.0.1:{unused_tcp_port}/a2a"}
+            t = HttpTransport(routes=routes)
+            ref = AgentRef(canonical_name="test.agents.default")
+            msg = A2AMessage(role="user", parts=[{"text": "x"}], metadata={})
+
+            received = []
+            async for ev in t.stream_task(ref, msg, {}, timeout=5):
+                received.append(ev)
+
+            assert len(received) == 2
+            assert received[0].type == "tool_call"
+            assert received[1].type == "final"