feat(compat): Tests and unified REST url.

Author: bartek-w

src/a2a/server/apps/rest/fastapi_app.py

@@ -121,6 +121,15 @@ def build(
             A configured FastAPI application instance.
         """
         app = FastAPI(**kwargs)
+        if self.enable_v0_3_compat and self._v03_adapter:
+            v03_adapter = self._v03_adapter
+            v03_router = APIRouter()
+            for route, callback in v03_adapter.routes().items():
+                v03_router.add_api_route(
+                    f'{rpc_url}{route[0]}', callback, methods=[route[1]]
+                )
+            app.include_router(v03_router)
+
         router = APIRouter()
         for route, callback in self._adapter.routes().items():
             router.add_api_route(
@@ -134,19 +143,4 @@ async def get_agent_card(request: Request) -> Response:
 
         app.include_router(router)
 
-        if self.enable_v0_3_compat and self._v03_adapter:
-            v03_adapter = self._v03_adapter
-            v03_router = APIRouter()
-            for route, callback in v03_adapter.routes().items():
-                v03_router.add_api_route(
-                    f'{rpc_url}/v0.3{route[0]}', callback, methods=[route[1]]
-                )
-
-            @v03_router.get(f'{rpc_url}/v0.3{agent_card_url}')
-            async def get_v03_agent_card(request: Request) -> Response:
-                card = await v03_adapter.handle_get_agent_card(request)
-                return JSONResponse(card)
-
-            app.include_router(v03_router)
-
         return app

tests/compat/v0_3/test_rest_fastapi_app_compat.py

@@ -92,7 +92,7 @@ async def test_send_message_success_message_v03(
     )
 
     response = await client.post(
-        '/v0.3/v1/message:send', json=json_format.MessageToDict(request)
+        '/v1/message:send', json=json_format.MessageToDict(request)
     )
     response.raise_for_status()
 
@@ -127,7 +127,7 @@ async def test_send_message_success_task_v03(
     )
 
     response = await client.post(
-        '/v0.3/v1/message:send', json=json_format.MessageToDict(request)
+        '/v1/message:send', json=json_format.MessageToDict(request)
     )
     response.raise_for_status()
 
@@ -155,7 +155,7 @@ async def test_get_task_v03(
         ),
     )
 
-    response = await client.get('/v0.3/v1/tasks/test_task_id')
+    response = await client.get('/v1/tasks/test_task_id')
     response.raise_for_status()
 
     actual_response = a2a_v0_3_pb2.Task()
@@ -182,7 +182,7 @@ async def test_cancel_task_v03(
         ),
     )
 
-    response = await client.post('/v0.3/v1/tasks/test_task_id:cancel')
+    response = await client.post('/v1/tasks/test_task_id:cancel')
     response.raise_for_status()
 
     actual_response = a2a_v0_3_pb2.Task()

tests/integration/cross_version/client_server/client_0_3.py

@@ -14,20 +14,45 @@
     TransportProtocol,
     TaskQueryParams,
     TaskIdParams,
+    TaskState,
     TaskPushNotificationConfig,
     PushNotificationConfig,
+    FilePart,
+    FileWithUri,
+    FileWithBytes,
+    DataPart,
 )
 from a2a.client.errors import A2AClientJSONRPCError, A2AClientHTTPError
 import sys
+import traceback
 
 
 async def test_send_message_stream(client):
     print('Testing send_message (streaming)...')
+
     msg = Message(
         role=Role.user,
         message_id=f'stream-{uuid4()}',
-        parts=[Part(root=TextPart(text='stream'))],
-        metadata={'test_key': 'test_value'},
+        parts=[
+            Part(root=TextPart(text='stream')),
+            Part(
+                root=FilePart(
+                    file=FileWithUri(
+                        uri='https://example.com/file.txt',
+                        mime_type='text/plain',
+                    )
+                )
+            ),
+            Part(
+                root=FilePart(
+                    file=FileWithBytes(
+                        bytes=b'aGVsbG8=', mime_type='application/octet-stream'
+                    )
+                )
+            ),
+            Part(root=DataPart(data={'key': 'value'})),
+        ],
+        metadata={'test_key': 'full_message'},
     )
     events = []
 
@@ -62,38 +87,43 @@ async def test_send_message_sync(url, protocol_enum):
         role=Role.user,
         message_id=f'sync-{uuid4()}',
         parts=[Part(root=TextPart(text='sync'))],
-        metadata={'test_key': 'test_value'},
+        metadata={'test_key': 'simple_message'},
     )
 
-    # In v0.3 SDK, send_message ALWAYS returns an async generator
     async for event in client.send_message(request=msg):
         assert event is not None
         event_obj = event[0] if isinstance(event, tuple) else event
-        if (
-            getattr(event_obj, 'status', None)
-            and getattr(event_obj.status, 'state', None)
-            == 'TASK_STATE_COMPLETED'
-        ):
-            assert (
-                getattr(event_obj.status.message, 'metadata', {}).get(
-                    'response_key'
-                )
-                == 'response_value'
-            ), (
-                f'Missing response metadata: {getattr(event_obj.status.message, "metadata", {})}'
+
+        status = getattr(event_obj, 'status', None)
+        if status and str(getattr(status, 'state', '')).endswith('completed'):
+            # In 0.3 SDK, the message on the status might be exposed as 'message' or 'update'
+            status_msg = getattr(
+                status, 'message', getattr(status, 'update', None)
             )
-        elif getattr(event_obj, 'status', None) and str(
-            getattr(event_obj.status, 'state', None)
-        ).endswith('completed'):
-            assert (
-                getattr(event_obj.status.message, 'metadata', {}).get(
-                    'response_key'
-                )
-                == 'response_value'
-            ), (
-                f'Missing response metadata: {getattr(event_obj.status.message, "metadata", {})}'
+            assert status_msg is not None, (
+                'TaskStatus message/update is missing'
             )
-        break
+
+            metadata = getattr(status_msg, 'metadata', {})
+            assert metadata.get('response_key') == 'response_value', (
+                f'Missing response metadata: {metadata}'
+            )
+
+            # Check Part translation (root text part in 0.3)
+            parts = getattr(
+                status_msg, 'parts', getattr(status_msg, 'content', [])
+            )
+            assert len(parts) > 0, 'No parts found in TaskStatus message'
+            first_part = parts[0]
+            text = getattr(first_part, 'text', '')
+            if (
+                not text
+                and hasattr(first_part, 'root')
+                and hasattr(first_part.root, 'text')
+            ):
+                text = first_part.root.text
+            assert text == 'done', f"Expected 'done' text in Part, got '{text}'"
+            break
 
     print(f'Success: send_message (synchronous) passed.')
 
@@ -102,20 +132,73 @@ async def test_get_task(client, task_id):
     print(f'Testing get_task ({task_id})...')
     task = await client.get_task(request=TaskQueryParams(id=task_id))
     assert task.id == task_id
+
+    user_msgs = [
+        m for m in task.history if getattr(m, 'role', None) == Role.user
+    ]
+    assert user_msgs, 'Expected at least one ROLE_USER message in task history'
+
+    client_msg = user_msgs[0]
+
+    parts = client_msg.parts
+    assert len(parts) == 4, f'Expected 4 parts, got {len(parts)}'
+
+    # 1. text part
+    text = getattr(parts[0].root, 'text', '')
+    assert text == 'stream', f"Expected 'stream', got {text}"
+
+    # 2. uri part
+    file_uri = getattr(parts[1].root, 'file', None)
+    assert (
+        file_uri is not None
+        and getattr(file_uri, 'uri', None) == 'https://example.com/file.txt'
+    )
+
+    # 3. bytes part
+    file_bytes = getattr(parts[2].root, 'file', None)
+    actual_bytes = getattr(file_bytes, 'bytes', None)
+    assert actual_bytes == 'aGVsbG8=', (
+        f"Expected base64 'hello', got {actual_bytes}"
+    )
+
+    # 4. data part
+    data_val = getattr(parts[3].root, 'data', None)
+    assert data_val is not None
+    assert data_val == {'key': 'value'}
+
     print('Success: get_task passed.')
 
 
 async def test_cancel_task(client, task_id):
     print(f'Testing cancel_task ({task_id})...')
     await client.cancel_task(request=TaskIdParams(id=task_id))
+    task = await client.get_task(request=TaskQueryParams(id=task_id))
+    assert task.status.state == TaskState.canceled, (
+        f'Expected a canceled state, got {task.status.state}'
+    )
     print('Success: cancel_task passed.')
 
 
 async def test_subscribe(client, task_id):
     print(f'Testing subscribe ({task_id})...')
+    has_artifact = False
     async for event in client.resubscribe(request=TaskIdParams(id=task_id)):
-        print(f'Received event: {event}')
-        break
+        # event is tuple (Task, UpdateEvent)
+        task, update = event
+        if update and hasattr(update, 'artifact'):
+            has_artifact = True
+            artifact = update.artifact
+            assert artifact.name == 'test-artifact'
+            assert artifact.metadata.get('artifact_key') == 'artifact_value'
+            # part check
+            assert len(artifact.parts) > 0
+            p = artifact.parts[0]
+            text = getattr(p.root, 'text', '')
+            assert text == 'artifact-chunk'
+            print('Success: received artifact update.')
+
+        if has_artifact:
+            break
     print('Success: subscribe passed.')
 
 
@@ -124,7 +207,27 @@ async def test_get_extended_agent_card(client):
     # In v0.3, extended card is fetched via get_card() on the client
     card = await client.get_card()
     assert card is not None
-    # the MockAgentExecutor might not have a name or has one, just assert card exists
+    assert card.name in ('Server 0.3', 'Server 1.0')
+    assert card.version == '1.0.0'
+    assert 'Server running on a2a v' in card.description
+
+    assert card.capabilities is not None
+    assert card.capabilities.streaming is True
+    assert card.capabilities.push_notifications is True
+
+    if card.name == 'Server 0.3':
+        assert card.url is not None
+        assert card.preferred_transport == TransportProtocol.jsonrpc
+        assert len(card.additional_interfaces) == 2
+        assert card.supports_authenticated_extended_card is False
+    else:
+        assert card.url is not None
+        assert card.preferred_transport is not None
+        print(
+            f'card.supports_authenticated_extended_card is: {card.supports_authenticated_extended_card}'
+        )
+        assert card.supports_authenticated_extended_card in (False, None)
+
     print(f'Success: get_extended_agent_card passed.')
 
 
@@ -177,8 +280,6 @@ def main():
         try:
             asyncio.run(run_client(args.url, protocol))
         except Exception as e:
-            import traceback
-
             traceback.print_exc()
             print(f'FAILED protocol {protocol}: {e}')
             failed = True