distributed-a2a 0.2.1__tar.gz → 0.2.2__tar.gz

{distributed_a2a-0.2.1/distributed_a2a.egg-info → distributed_a2a-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: distributed_a2a
-Version: 0.2.1
+Version: 0.2.2
 Summary: A library for building A2A agents with routing capabilities
 Home-page: https://github.com/Barra-Technologies/distributed-a2a
 Author: Fabian Bell

{distributed_a2a-0.2.1 → distributed_a2a-0.2.2}/distributed_a2a/executors.py

@@ -4,50 +4,22 @@ from typing import Any
 
 from a2a.server.agent_execution import AgentExecutor, RequestContext
 from a2a.server.events import EventQueue
-from a2a.types import (Artifact, FilePart, FileWithBytes, Part,
-                       TaskArtifactUpdateEvent, TaskState, TaskStatus,
-                       TaskStatusUpdateEvent)
+from a2a.types import (Artifact, FilePart, Part, TaskArtifactUpdateEvent,
+                       TaskState, TaskStatus, TaskStatusUpdateEvent)
 from a2a.utils import new_text_artifact
-from langchain_core.messages import BaseMessage, ToolMessage
 from langchain_core.tools import BaseTool
 from langchain_mcp_adapters.client import MultiServerMCPClient
 from langgraph.checkpoint.base import BaseCheckpointSaver
-from mcp.types import BlobResourceContents, EmbeddedResource, ImageContent
 
 from .agent import RoutingResponse, StatusAgent, StringResponse
 from .config import settings
+from .files import extract_file_parts
 from .model import AgentConfig, RouterConfig
 from .registry import AgentRegistryLookupClient, McpRegistryLookup
 
 logger = logging.getLogger(__name__)
 
 
-def _extract_file_parts(messages: list[BaseMessage]) -> list[tuple[str, FilePart]]:
-    out: list[tuple[str, FilePart]] = []
-    for message in messages:
-        if not isinstance(message, ToolMessage):
-            continue
-        artifact = getattr(message, "artifact", None)
-        if not artifact:
-            continue
-        for block in artifact:
-            if isinstance(block, EmbeddedResource) and isinstance(block.resource, BlobResourceContents):
-                uri_str = str(block.resource.uri)
-                name = uri_str.rsplit("/", 1)[-1] or "file.bin"
-                out.append((name, FilePart(file=FileWithBytes(
-                    name=name,
-                    mime_type=block.resource.mimeType or "application/octet-stream",
-                    bytes=block.resource.blob,
-                ))))
-            elif isinstance(block, ImageContent):
-                out.append(("image", FilePart(file=FileWithBytes(
-                    name="image",
-                    mime_type=block.mimeType,
-                    bytes=block.data,
-                ))))
-    return out
-
-
 class RoutingFailed(Exception):
     def __init__(self, message: str) -> None:
         super().__init__(message)
@@ -155,7 +127,7 @@ class RoutingAgentExecutor(AgentExecutor):
                 artifact = await _route_request_to_matching_agent(self.routing_agent, self.agent_registry, context)
             else:
                 logger.info(f"Request with id {context.context_id} was successfully processed by agent.")
-                file_parts = _extract_file_parts(invocation.messages)
+                file_parts = extract_file_parts(invocation.messages)
                 artifact = new_text_artifact(
                     name='current_result',
                     description='Result of request to agent.',

distributed_a2a-0.2.2/distributed_a2a/files.py

@@ -0,0 +1,68 @@
+import json
+import mimetypes
+from typing import Any
+
+from a2a.types import FilePart, FileWithBytes
+from langchain_core.messages import BaseMessage, ToolMessage
+
+_LANGCHAIN_BINARY_BLOCK_TYPES: dict[str, str] = {
+    "file": "attachment",
+    "image": "image",
+}
+
+
+def _filename_from_text_block(block: dict[str, Any]) -> str | None:
+    text = block.get("text")
+    if not isinstance(text, str):
+        return None
+    try:
+        payload = json.loads(text)
+    except (ValueError, TypeError):
+        return None
+    if isinstance(payload, dict):
+        name = payload.get("filename")
+        if isinstance(name, str) and name:
+            return name
+    return None
+
+
+def extract_file_parts(messages: list[BaseMessage]) -> list[tuple[str, FilePart]]:
+    parts: list[tuple[str, FilePart]] = []
+    for message in messages:
+        if not (isinstance(message, ToolMessage)
+                and isinstance(message.content, list)):
+            continue
+        pending_name: str | None = None
+        counters: dict[str, int] = {"file": 0, "image": 0}
+        for block in message.content:
+            if not isinstance(block, dict):
+                continue
+            block_type = block.get("type")
+            if not isinstance(block_type, str):
+                continue
+            if block_type == "text":
+                hint = _filename_from_text_block(block)
+                if hint:
+                    pending_name = hint
+                continue
+            kind = _LANGCHAIN_BINARY_BLOCK_TYPES.get(block_type)
+            if kind is None:
+                continue
+            b64 = block.get("base64")
+            if not isinstance(b64, str) or not b64:
+                continue
+            mime_type = block.get("mime_type") or "application/octet-stream"
+            if pending_name is not None:
+                name = pending_name
+                pending_name = None
+            else:
+                index = counters[block_type]
+                counters[block_type] = index + 1
+                guessed_ext = mimetypes.guess_extension(mime_type)
+                ext = f"-{guessed_ext}" if guessed_ext is not None else ""
+                suffix = f"-{index}" if index > 0 else ""
+                name = f"{kind}{suffix}{ext}"
+            parts.append((name, FilePart(file=FileWithBytes(
+                name=name, mime_type=mime_type, bytes=b64,
+            ))))
+    return parts

{distributed_a2a-0.2.1 → distributed_a2a-0.2.2/distributed_a2a.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: distributed_a2a
-Version: 0.2.1
+Version: 0.2.2
 Summary: A library for building A2A agents with routing capabilities
 Home-page: https://github.com/Barra-Technologies/distributed-a2a
 Author: Fabian Bell

{distributed_a2a-0.2.1 → distributed_a2a-0.2.2}/distributed_a2a.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ distributed_a2a/agent.py
 distributed_a2a/client.py
 distributed_a2a/config.py
 distributed_a2a/executors.py
+distributed_a2a/files.py
 distributed_a2a/model.py
 distributed_a2a/py.typed
 distributed_a2a/registry.py

{distributed_a2a-0.2.1 → distributed_a2a-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "distributed_a2a"
-version = "0.2.1"
+version = "0.2.2"
 description = "A library for building A2A agents with routing capabilities"
 readme = "README.md"
 requires-python = ">=3.14"

{distributed_a2a-0.2.1 → distributed_a2a-0.2.2}/tests/test_executor_files.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import base64
+from types import SimpleNamespace
 from typing import Any
 
 import pytest
@@ -11,16 +12,12 @@ from a2a.types import Message as A2AMessage
 from a2a.types import (MessageSendParams, Part, Role, TaskArtifactUpdateEvent,
                        TaskState, TaskStatusUpdateEvent, TextPart)
 from langchain_core.messages import BaseMessage, HumanMessage, ToolMessage
-from mcp.types import BlobResourceContents, EmbeddedResource
-from pydantic import AnyUrl
 
 from distributed_a2a.agent import AgentInvocation, StringResponse
 from distributed_a2a.executors import RoutingAgentExecutor
 
 
 class _StubStatusAgent:
-    """Minimal stand-in for ``StatusAgent`` used in the executor."""
-
     def __init__(self, response: StringResponse, messages: list[BaseMessage]) -> None:
         self._response = response
         self._messages = messages
@@ -47,35 +44,7 @@ def _make_request_context() -> RequestContext:
     )
 
 
-def _make_tool_message_with_docx(b64: str) -> ToolMessage:
-    return ToolMessage(
-        content='{"filename": "cv-foo.docx"}',
-        tool_call_id="call-1",
-        artifact=[
-            EmbeddedResource(
-                type="resource",
-                resource=BlobResourceContents(
-                    uri=AnyUrl("cv://cv-foo.docx"),
-                    mimeType=(
-                        "application/vnd.openxmlformats-officedocument."
-                        "wordprocessingml.document"
-                    ),
-                    blob=b64,
-                ),
-            ),
-        ],
-    )
-
-
 async def _drain_queue(queue: EventQueue) -> list[Any]:
-    """Dequeue every event currently in ``queue`` without blocking.
-
-    Uses ``no_wait=True`` and stops on the first empty/closed exception. We
-    intentionally avoid ``await queue.close()`` because the graceful close
-    waits for ``queue.join()`` — which requires the consumer to call
-    ``task_done()`` for every enqueued item — and would otherwise deadlock
-    the test once we've finished dequeuing.
-    """
     events: list[Any] = []
     while True:
         try:
@@ -88,17 +57,54 @@ async def _drain_queue(queue: EventQueue) -> list[Any]:
 
 
 @pytest.mark.asyncio
-async def test_executor_emits_file_part_event_for_embedded_resource(
-        monkeypatch: pytest.MonkeyPatch) -> None:
-    docx_b64 = base64.b64encode(b"PK\x03\x04 fake docx").decode("ascii")
-    tool_msg = _make_tool_message_with_docx(docx_b64)
+async def test_executor_emits_no_file_event_when_no_artifacts() -> None:
+    executor = RoutingAgentExecutor.__new__(RoutingAgentExecutor)
+    executor.agent_config = SimpleNamespace(  # type: ignore[assignment]
+        agent=SimpleNamespace(card=SimpleNamespace(name="plain-agent")),
+    )
+    executor.agent = _StubStatusAgent(  # type: ignore[assignment]
+        StringResponse(status=TaskState.completed, response="No files here."),
+        [HumanMessage(content="hi")],
+    )
+
+    async def _noop_reinit() -> None:
+        return None
+
+    executor.reinitialize_agent_with_tools = _noop_reinit  # type: ignore[method-assign]
+
+    ctx = _make_request_context()
+    queue = EventQueue()
+    await executor.execute(ctx, queue)
+    events = await _drain_queue(queue)
+
+    artifact_events = [e for e in events if isinstance(e, TaskArtifactUpdateEvent)]
+    assert len(artifact_events) == 1
+    assert artifact_events[0].artifact.name == "current_result"
+    assert artifact_events[0].last_chunk is True
+
 
-    # Build the executor without invoking its real __init__ (which requires
-    # API keys + registry network calls). We only need ``execute`` to use:
-    #   - self.agent (stubbed)
-    #   - self.reinitialize_agent_with_tools (stubbed no-op)
-    #   - self.agent_config.agent.card.name (stubbed via SimpleNamespace)
-    from types import SimpleNamespace
+@pytest.mark.asyncio
+async def test_executor_emits_file_part_from_langchain_content_block() -> None:
+    docx_b64 = base64.b64encode(b"PK\x03\x04 fake docx").decode("ascii")
+    summary_json = (
+        '{"filename": "cv-bob.docx", '
+        '"mime_type": "application/vnd.openxmlformats-officedocument.'
+        'wordprocessingml.document"}'
+    )
+    tool_msg = ToolMessage(
+        content=[
+            {"type": "text", "text": summary_json, "id": "lc_text_1"},
+            {"type": "file",
+             "base64": docx_b64,
+             "mime_type": (
+                 "application/vnd.openxmlformats-officedocument."
+                 "wordprocessingml.document"
+             ),
+             "id": "lc_file_1"},
+        ],
+        tool_call_id="call-cv",
+        artifact={"structured_content": {"filename": "cv-bob.docx"}},
+    )
 
     executor = RoutingAgentExecutor.__new__(RoutingAgentExecutor)
     executor.agent_config = SimpleNamespace(  # type: ignore[assignment]
@@ -120,50 +126,51 @@ async def test_executor_emits_file_part_event_for_embedded_resource(
     await executor.execute(ctx, queue)
     events = await _drain_queue(queue)
 
-    # Expected sequence: working status, file artifact, text artifact, final status.
     artifact_events = [e for e in events if isinstance(e, TaskArtifactUpdateEvent)]
-    status_events = [e for e in events if isinstance(e, TaskStatusUpdateEvent)]
-
     assert len(artifact_events) == 2, (
-        f"Expected 2 artifact events (file + text), got: "
-        f"{[(e.artifact.name, e.last_chunk) for e in artifact_events]}"
+        "Expected the executor to emit a file artifact followed by the text "
+        "artifact when the tool response uses the production LangChain "
+        "content-block shape."
     )
-
     file_event, text_event = artifact_events
-    # 1) file artifact carries a FilePart, is NOT the final chunk
     assert file_event.last_chunk is False
-    assert file_event.artifact.name == "cv-foo.docx"
-    assert len(file_event.artifact.parts) == 1
+    assert file_event.artifact.name == "cv-bob.docx"
     file_part = file_event.artifact.parts[0].root
     assert isinstance(file_part, FilePart)
     assert isinstance(file_part.file, FileWithBytes)
-    assert file_part.file.name == "cv-foo.docx"
+    assert file_part.file.name == "cv-bob.docx"
     assert file_part.file.bytes == docx_b64
 
-    # 2) text artifact carries the LLM-visible summary, IS the final chunk
     assert text_event.last_chunk is True
     assert text_event.artifact.name == "current_result"
-    text_part = text_event.artifact.parts[0].root
-    assert isinstance(text_part, TextPart)
-    assert text_part.text == "*cv-agent*: Here is your CV."
-
-    # 3) Final status event is `completed`
-    final_status = [e for e in status_events if e.final]
-    assert len(final_status) == 1
-    assert final_status[0].status.state == TaskState.completed
 
 
 @pytest.mark.asyncio
-async def test_executor_emits_no_file_event_when_no_artifacts() -> None:
-    from types import SimpleNamespace
+async def test_executor_emits_one_file_event_per_file_block() -> None:
+    b64_a = base64.b64encode(b"aaa docx bytes").decode("ascii")
+    b64_b = base64.b64encode(b"bbb docx bytes").decode("ascii")
+    docx_mime = (
+        "application/vnd.openxmlformats-officedocument."
+        "wordprocessingml.document"
+    )
+    tool_msg = ToolMessage(
+        content=[
+            {"type": "text", "text": '{"filename": "cv-a.docx"}', "id": "t1"},
+            {"type": "file", "base64": b64_a, "mime_type": docx_mime, "id": "f1"},
+            {"type": "text", "text": '{"filename": "cv-b.docx"}', "id": "t2"},
+            {"type": "file", "base64": b64_b, "mime_type": docx_mime, "id": "f2"},
+        ],
+        tool_call_id="call-multi",
+    )
 
     executor = RoutingAgentExecutor.__new__(RoutingAgentExecutor)
     executor.agent_config = SimpleNamespace(  # type: ignore[assignment]
-        agent=SimpleNamespace(card=SimpleNamespace(name="plain-agent")),
+        agent=SimpleNamespace(card=SimpleNamespace(name="cv-agent")),
     )
     executor.agent = _StubStatusAgent(  # type: ignore[assignment]
-        StringResponse(status=TaskState.completed, response="No files here."),
-        [HumanMessage(content="hi")],
+        StringResponse(status=TaskState.completed,
+                       response="Here are your two CVs."),
+        [HumanMessage(content="render two CVs"), tool_msg],
     )
 
     async def _noop_reinit() -> None:
@@ -177,6 +184,33 @@ async def test_executor_emits_no_file_event_when_no_artifacts() -> None:
     events = await _drain_queue(queue)
 
     artifact_events = [e for e in events if isinstance(e, TaskArtifactUpdateEvent)]
-    assert len(artifact_events) == 1
-    assert artifact_events[0].artifact.name == "current_result"
-    assert artifact_events[0].last_chunk is True
+    assert len(artifact_events) == 3, (
+        "Expected 2 file artifacts (last_chunk=False) + 1 text artifact "
+        f"(last_chunk=True). Got: "
+        f"{[(e.artifact.name, e.last_chunk) for e in artifact_events]}"
+    )
+    file_a_event, file_b_event, text_event = artifact_events
+
+    assert file_a_event.last_chunk is False
+    assert file_a_event.artifact.name == "cv-a.docx"
+    file_a_part = file_a_event.artifact.parts[0].root
+    assert isinstance(file_a_part, FilePart)
+    assert isinstance(file_a_part.file, FileWithBytes)
+    assert file_a_part.file.name == "cv-a.docx"
+    assert file_a_part.file.bytes == b64_a
+
+    assert file_b_event.last_chunk is False
+    assert file_b_event.artifact.name == "cv-b.docx"
+    file_b_part = file_b_event.artifact.parts[0].root
+    assert isinstance(file_b_part, FilePart)
+    assert isinstance(file_b_part.file, FileWithBytes)
+    assert file_b_part.file.name == "cv-b.docx"
+    assert file_b_part.file.bytes == b64_b
+
+    assert text_event.last_chunk is True
+    assert text_event.artifact.name == "current_result"
+
+    final_status = [e for e in events
+                    if isinstance(e, TaskStatusUpdateEvent) and e.final]
+    assert len(final_status) == 1
+    assert final_status[0].status.state == TaskState.completed

{distributed_a2a-0.2.1 → distributed_a2a-0.2.2}/tests/test_files.py

@@ -9,117 +9,145 @@ from a2a.types import (AgentCapabilities, AgentCard, Artifact, FilePart,
                        FileWithBytes, FileWithUri, Message, Part, Task,
                        TaskState, TaskStatus, TextPart)
 from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
-from mcp.types import (BlobResourceContents, EmbeddedResource, ImageContent,
-                       TextResourceContents)
-from pydantic import AnyUrl
 
 from distributed_a2a.client import AgentReply, RemoteAgentConnection
-from distributed_a2a.executors import _extract_file_parts
+from distributed_a2a.files import extract_file_parts
 
 
 def _b64(payload: bytes) -> str:
     return base64.b64encode(payload).decode("ascii")
 
 
-def test_extract_file_parts_picks_up_embedded_resource() -> None:
-    docx_b64 = _b64(b"PK\x03\x04 fake docx bytes")
+def test_extract_file_parts_ignores_non_tool_messages_and_string_content() -> None:
+    messages = [
+        HumanMessage(content="hi"),
+        AIMessage(content="hello"),
+        ToolMessage(content="just text", tool_call_id="c1"),
+    ]
+    assert extract_file_parts(messages) == []
+
+
+def test_extract_file_parts_reads_langchain_file_content_block() -> None:
+    docx_b64 = _b64(b"PK\x03\x04 real docx bytes")
+    summary = (
+        '{"filename": "cv-alice.docx", '
+        '"mime_type": "application/vnd.openxmlformats-officedocument.'
+        'wordprocessingml.document", "size_bytes": 4321}'
+    )
     tool_msg = ToolMessage(
-        content="{\"filename\": \"cv-foo.docx\"}",
-        tool_call_id="call-1",
-        artifact=[
-            EmbeddedResource(
-                type="resource",
-                resource=BlobResourceContents(
-                    uri=AnyUrl("cv://cv-foo.docx"),
-                    mimeType="application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-                    blob=docx_b64,
-                ),
-            ),
+        content=[
+            {"type": "text", "text": summary, "id": "lc_text_1"},
+            {"type": "file",
+             "base64": docx_b64,
+             "mime_type": (
+                 "application/vnd.openxmlformats-officedocument."
+                 "wordprocessingml.document"
+             ),
+             "id": "lc_file_1"},
         ],
+        tool_call_id="call-cv",
+        artifact={"structured_content": {"filename": "cv-alice.docx"}},
     )
 
-    parts = _extract_file_parts([HumanMessage(content="hi"), tool_msg])
+    parts = extract_file_parts([HumanMessage(content="hi"), tool_msg])
 
     assert len(parts) == 1
     name, file_part = parts[0]
-    assert name == "cv-foo.docx"
+    assert name == "cv-alice.docx"
     assert isinstance(file_part, FilePart)
     assert isinstance(file_part.file, FileWithBytes)
-    assert file_part.file.name == "cv-foo.docx"
+    assert file_part.file.name == "cv-alice.docx"
     assert file_part.file.mime_type == (
         "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
     )
     assert file_part.file.bytes == docx_b64
 
 
-def test_extract_file_parts_handles_image_content() -> None:
+def test_extract_file_parts_reads_langchain_image_content_block() -> None:
     png_b64 = _b64(b"\x89PNG\r\n\x1a\n fake")
     tool_msg = ToolMessage(
-        content="",
-        tool_call_id="call-img",
-        artifact=[
-            ImageContent(type="image", data=png_b64, mimeType="image/png"),
+        content=[
+            {"type": "image", "base64": png_b64,
+             "mime_type": "image/png", "id": "lc_img_1"},
         ],
+        tool_call_id="call-img",
     )
 
-    parts = _extract_file_parts([tool_msg])
+    parts = extract_file_parts([tool_msg])
 
     assert len(parts) == 1
     name, file_part = parts[0]
-    assert name == "image"
+    assert name.startswith("image")
+    assert name.endswith(".png")
     assert isinstance(file_part.file, FileWithBytes)
     assert file_part.file.mime_type == "image/png"
     assert file_part.file.bytes == png_b64
 
 
-def test_extract_file_parts_ignores_non_tool_messages_and_empty_artifacts() -> None:
-    messages = [
-        HumanMessage(content="hi"),
-        AIMessage(content="hello"),
-        ToolMessage(content="just text", tool_call_id="c1"),
-        ToolMessage(content="empty artifact", tool_call_id="c2", artifact=[]),
-    ]
-    assert _extract_file_parts(messages) == []
+def test_extract_file_parts_synthesises_name_without_filename_hint() -> None:
+    docx_b64 = _b64(b"PK\x03\x04 bytes")
+    tool_msg = ToolMessage(
+        content=[
+            {"type": "text", "text": "no json here", "id": "lc_text_1"},
+            {"type": "file",
+             "base64": docx_b64,
+             "mime_type": (
+                 "application/vnd.openxmlformats-officedocument."
+                 "wordprocessingml.document"
+             ),
+             "id": "lc_file_1"},
+        ],
+        tool_call_id="call-cv",
+    )
+
+    parts = extract_file_parts([tool_msg])
 
+    assert len(parts) == 1
+    name, file_part = parts[0]
+    assert name.startswith("attachment")
+    assert name.endswith(".docx")
+    assert isinstance(file_part.file, FileWithBytes)
+    assert file_part.file.bytes == docx_b64
 
-def test_extract_file_parts_skips_text_resource_contents() -> None:
+
+def test_extract_file_parts_ignores_url_only_file_block() -> None:
     tool_msg = ToolMessage(
-        content="",
-        tool_call_id="call-x",
-        artifact=[
-            EmbeddedResource(
-                type="resource",
-                resource=TextResourceContents(
-                    uri=AnyUrl("text://note.txt"),
-                    mimeType="text/plain",
-                    text="some inline text",
-                ),
-            ),
+        content=[
+            {"type": "file",
+             "url": "https://example.com/report.pdf",
+             "mime_type": "application/pdf",
+             "id": "lc_file_1"},
         ],
+        tool_call_id="call-url-only",
     )
-    assert _extract_file_parts([tool_msg]) == []
+    assert extract_file_parts([tool_msg]) == []
 
 
-def test_extract_file_parts_falls_back_to_octet_stream_when_mime_missing() -> None:
+def test_extract_file_parts_matches_multiple_filenames_by_order() -> None:
+    """Two [text-summary, file] pairs in the same ToolMessage — each
+    text-summary's ``filename`` is consumed by the immediately following
+    file block."""
+    b64_a = _b64(b"aaa")
+    b64_b = _b64(b"bbb")
     tool_msg = ToolMessage(
-        content="",
-        tool_call_id="call-x",
-        artifact=[
-            EmbeddedResource(
-                type="resource",
-                resource=BlobResourceContents(
-                    uri=AnyUrl("file:///tmp/x.bin"),
-                    blob=_b64(b"x"),
-                ),
-            ),
+        content=[
+            {"type": "text", "text": '{"filename": "a.bin"}',
+             "id": "lc_text_1"},
+            {"type": "file", "base64": b64_a,
+             "mime_type": "application/octet-stream", "id": "lc_file_1"},
+            {"type": "text", "text": '{"filename": "b.bin"}',
+             "id": "lc_text_2"},
+            {"type": "file", "base64": b64_b,
+             "mime_type": "application/octet-stream", "id": "lc_file_2"},
         ],
+        tool_call_id="call-multi",
     )
-    parts = _extract_file_parts([tool_msg])
-    assert len(parts) == 1
-    name, file_part = parts[0]
-    assert name == "x.bin"
-    assert isinstance(file_part.file, FileWithBytes)
-    assert file_part.file.mime_type == "application/octet-stream"
+
+    parts = extract_file_parts([tool_msg])
+
+    assert [name for name, _ in parts] == ["a.bin", "b.bin"]
+    assert parts[0][1].file.bytes == b64_a  # type: ignore[union-attr]
+    assert parts[1][1].file.bytes == b64_b  # type: ignore[union-attr]
 
 
 class _StubAgentClient:
@@ -235,3 +263,55 @@ async def test_remote_agent_connection_handles_file_with_uri(
     assert f.mime_type == "application/pdf"
     assert f.bytes_b64 == ""
     assert f.uri == "https://example.com/report.pdf"
+
+
+@pytest.mark.asyncio
+async def test_remote_agent_connection_gathers_multiple_files_in_order(
+        monkeypatch: pytest.MonkeyPatch) -> None:
+    b64_a = _b64(b"aaa")
+    b64_b = _b64(b"bbb")
+    completed_task = Task(
+        id="task-multi",
+        context_id="ctx-multi",
+        status=TaskStatus(state=TaskState.completed),
+        artifacts=[
+            Artifact(
+                artifact_id="a.bin",
+                name="a.bin",
+                parts=[Part(root=FilePart(file=FileWithBytes(
+                    name="a.bin",
+                    mime_type="application/octet-stream",
+                    bytes=b64_a,
+                )))],
+            ),
+            Artifact(
+                artifact_id="b.bin",
+                name="b.bin",
+                parts=[Part(root=FilePart(file=FileWithBytes(
+                    name="b.bin",
+                    mime_type="application/octet-stream",
+                    bytes=b64_b,
+                )))],
+            ),
+            Artifact(
+                artifact_id="current_result",
+                name="current_result",
+                parts=[Part(root=TextPart(text="Two files ready."))],
+            ),
+        ],
+    )
+    _patch_client_factory(monkeypatch, completed_task)
+
+    async with httpx.AsyncClient() as http_client:
+        conn = RemoteAgentConnection(_agent_card(), http_client)
+        reply = await conn.send_message("hello", "ctx-multi")
+
+    assert isinstance(reply, AgentReply)
+    assert reply.text == "Two files ready."
+    assert [f.name for f in reply.files] == ["a.bin", "b.bin"]
+    assert [f.mime_type for f in reply.files] == [
+        "application/octet-stream", "application/octet-stream",
+    ]
+    assert [f.bytes_b64 for f in reply.files] == [b64_a, b64_b]
+    assert all(f.uri is None for f in reply.files)
+