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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: distributed_a2a
-Version: 0.2.2
+Version: 0.2.3
 Summary: A library for building A2A agents with routing capabilities
 Home-page: https://github.com/Barra-Technologies/distributed-a2a
 Author: Fabian Bell
@@ -211,6 +211,27 @@ if __name__ == "__main__":
     asyncio.run(main())
 ```
 
+### Binary content handling
+
+When an agent invokes an MCP tool that returns non-text content (files, images,
+`EmbeddedResource`, `ResourceLink`), the library keeps those payloads out of the
+LLM's context window and delivers them out-of-band as A2A `FilePart` artifacts.
+
+Concretely, `RoutingAgentExecutor` installs the
+`hide_binary_content_from_llm` tool-call interceptor on every
+`MultiServerMCPClient` it builds. The interceptor moves any non-`TextContent`
+block from `CallToolResult.content` into `CallToolResult.structuredContent`
+under the `non_text_content` key. The upstream adapter then carries that dict
+into `ToolMessage.artifact['structured_content']`, which LangChain does **not**
+surface to the model. After the graph run, the executor walks the message list,
+extracts the stashed blocks, and emits one `TaskArtifactUpdateEvent` per file
+before the terminating text artifact.
+
+Client-side, `RoutingA2AClient.send_message` returns an `AgentReply` that
+exposes both the LLM's text summary and any `FileRef` payloads (with either
+inline `bytes_b64` or a `uri`), so downstream integrations (e.g. Slack file
+uploads) can forward the bytes without ever routing them through a model.
+
 ### Environment Variables
 The library uses several environment variables for configuration. These can be set in your shell or via a `.env` file.
 

{distributed_a2a-0.2.2 → distributed_a2a-0.2.3}/README.md

@@ -172,6 +172,27 @@ if __name__ == "__main__":
     asyncio.run(main())
 ```
 
+### Binary content handling
+
+When an agent invokes an MCP tool that returns non-text content (files, images,
+`EmbeddedResource`, `ResourceLink`), the library keeps those payloads out of the
+LLM's context window and delivers them out-of-band as A2A `FilePart` artifacts.
+
+Concretely, `RoutingAgentExecutor` installs the
+`hide_binary_content_from_llm` tool-call interceptor on every
+`MultiServerMCPClient` it builds. The interceptor moves any non-`TextContent`
+block from `CallToolResult.content` into `CallToolResult.structuredContent`
+under the `non_text_content` key. The upstream adapter then carries that dict
+into `ToolMessage.artifact['structured_content']`, which LangChain does **not**
+surface to the model. After the graph run, the executor walks the message list,
+extracts the stashed blocks, and emits one `TaskArtifactUpdateEvent` per file
+before the terminating text artifact.
+
+Client-side, `RoutingA2AClient.send_message` returns an `AgentReply` that
+exposes both the LLM's text summary and any `FileRef` payloads (with either
+inline `bytes_b64` or a `uri`), so downstream integrations (e.g. Slack file
+uploads) can forward the bytes without ever routing them through a model.
+
 ### Environment Variables
 The library uses several environment variables for configuration. These can be set in your shell or via a `.env` file.
 

{distributed_a2a-0.2.2 → distributed_a2a-0.2.3}/distributed_a2a/__init__.py

@@ -1,4 +1,6 @@
 from .client import A2ATimeoutError, AgentReply, FileRef, RoutingA2AClient
+from .mcp_interceptors import (NON_TEXT_CONTENT_KEY,
+                               hide_binary_content_from_llm)
 from .model import (AgentConfig, AgentItem, CardConfig, LLMConfig,
                     RegistryConfig, RegistryItemConfig, RouterConfig,
                     RouterItem, SkillConfig)
@@ -31,5 +33,7 @@ __all__ = [
     "AgentRegistryClient",
     "McpRegistryClient",
     "InMemoryAgentRegistry",
-    "InMemoryMcpRegistry"
+    "InMemoryMcpRegistry",
+    "hide_binary_content_from_llm",
+    "NON_TEXT_CONTENT_KEY",
 ]

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

@@ -13,7 +13,8 @@ from langgraph.checkpoint.base import BaseCheckpointSaver
 
 from .agent import RoutingResponse, StatusAgent, StringResponse
 from .config import settings
-from .files import extract_file_parts
+from .file_extractors import extract_file_parts
+from .mcp_interceptors import hide_binary_content_from_llm
 from .model import AgentConfig, RouterConfig
 from .registry import AgentRegistryLookupClient, McpRegistryLookup
 
@@ -206,10 +207,18 @@ class RoutingAgentExecutor(AgentExecutor):
             return
 
         logger.info(f"Agent {self.agent_config.agent.card.name} has access to the following tools: {mcp_server_raw}")
-        mcp_servers = {tool["name"]: {"url": tool["url"], "transport": tool["protocol"],
-                                      "headers": settings.get_mcp_auth_headers(tool["name"])} for tool in
-                       mcp_server_raw}
-        mcp_client = MultiServerMCPClient(mcp_servers)  # type: ignore[arg-type]
+        mcp_servers: dict[str, Any] = {
+            tool["name"]: {
+                "url": tool["url"],
+                "transport": tool["protocol"],
+                "headers": settings.get_mcp_auth_headers(tool["name"])
+            }
+            for tool in mcp_server_raw
+        }
+        mcp_client = MultiServerMCPClient(
+            connections=mcp_servers,
+            tool_interceptors=[hide_binary_content_from_llm],
+        )
         mcp_tools = await mcp_client.get_tools()
 
         self.agent = StatusAgent[StringResponse](

distributed_a2a-0.2.3/distributed_a2a/file_extractors.py

@@ -0,0 +1,142 @@
+import json
+import mimetypes
+from typing import Any
+
+from a2a.types import FilePart, FileWithBytes, FileWithUri
+from langchain_core.messages import BaseMessage, ToolMessage
+from mcp.types import (BlobResourceContents, EmbeddedResource, ImageContent,
+                       ResourceLink)
+
+from .mcp_interceptors import NON_TEXT_CONTENT_KEY
+
+_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 _synthetic_name(kind: str, index: int, mime_type: str) -> str:
+    guessed_ext = mimetypes.guess_extension(mime_type)
+    ext = guessed_ext if guessed_ext is not None else ""
+    suffix = f"-{index}" if index > 0 else ""
+    return f"{kind}{suffix}{ext}"
+
+
+def _name_from_uri(uri: str, fallback_kind: str, index: int, mime_type: str) -> str:
+    tail = uri.rsplit("/", 1)[-1]
+    if tail:
+        return tail
+    return _synthetic_name(fallback_kind, index, mime_type)
+
+
+def _extract_from_mcp_blocks(blocks: list[Any]) -> list[tuple[str, FilePart]]:
+    out: list[tuple[str, FilePart]] = []
+    counters: dict[str, int] = {"attachment": 0, "image": 0}
+    for block in blocks:
+        if isinstance(block, EmbeddedResource) and isinstance(block.resource, BlobResourceContents):
+            mime_type = block.resource.mimeType or "application/octet-stream"
+            uri = str(block.resource.uri) if block.resource.uri is not None else ""
+            kind = "image" if mime_type.startswith("image/") else "attachment"
+            if uri:
+                name = _name_from_uri(uri, kind, counters[kind], mime_type)
+            else:
+                name = _synthetic_name(kind, counters[kind], mime_type)
+            counters[kind] += 1
+            out.append((name, FilePart(file=FileWithBytes(
+                name=name, mime_type=mime_type, bytes=block.resource.blob,
+            ))))
+        elif isinstance(block, ImageContent):
+            mime_type = block.mimeType or "application/octet-stream"
+            name = _synthetic_name("image", counters["image"], mime_type)
+            counters["image"] += 1
+            out.append((name, FilePart(file=FileWithBytes(
+                name=name, mime_type=mime_type, bytes=block.data,
+            ))))
+        elif isinstance(block, ResourceLink):
+            mime_type = block.mimeType or "application/octet-stream"
+            uri = str(block.uri)
+            kind = "image" if mime_type.startswith("image/") else "attachment"
+            name = _name_from_uri(uri, kind, counters[kind], mime_type)
+            counters[kind] += 1
+            out.append((name, FilePart(file=FileWithUri(
+                name=name, mime_type=mime_type, uri=uri,
+            ))))
+    return out
+
+
+def _extract_from_langchain_content_blocks(content: list[Any]) -> list[tuple[str, FilePart]]:
+    out: list[tuple[str, FilePart]] = []
+    pending_name: str | None = None
+    counters: dict[str, int] = {"file": 0, "image": 0}
+    for block in 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
+            name = _synthetic_name(kind, index, mime_type)
+        out.append((name, FilePart(file=FileWithBytes(
+            name=name, mime_type=mime_type, bytes=b64,
+        ))))
+    return out
+
+
+def _mcp_blocks_from_artifact(artifact: Any) -> list[Any] | None:
+    if not isinstance(artifact, dict):
+        return None
+    structured = artifact.get("structured_content")
+    if not isinstance(structured, dict):
+        return None
+    blocks = structured.get(NON_TEXT_CONTENT_KEY)
+    if not isinstance(blocks, list) or not blocks:
+        return None
+    return blocks
+
+
+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):
+            continue
+
+        mcp_blocks = _mcp_blocks_from_artifact(message.artifact)
+        if mcp_blocks is not None:
+            parts.extend(_extract_from_mcp_blocks(mcp_blocks))
+            continue
+
+        if isinstance(message.content, list):
+            parts.extend(_extract_from_langchain_content_blocks(message.content))
+    return parts

distributed_a2a-0.2.3/distributed_a2a/mcp_interceptors.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+from langchain_mcp_adapters.interceptors import (MCPToolCallRequest,
+                                                 MCPToolCallResult)
+from mcp.types import CallToolResult, TextContent
+
+"""Key under ``CallToolResult.structuredContent`` where the interceptor stashes
+any non-text MCP content blocks. Also the key under
+``ToolMessage.artifact['structured_content']`` where downstream extraction
+code (:func:`distributed_a2a.files.extract_file_parts`) reads them back."""
+NON_TEXT_CONTENT_KEY = "non_text_content"
+
+
+async def hide_binary_content_from_llm(
+    request: MCPToolCallRequest,
+    handler: Callable[
+        [MCPToolCallRequest],
+        Awaitable[MCPToolCallResult],  # pyright: ignore[reportInvalidTypeForm]
+    ],
+) -> MCPToolCallResult:  # pyright: ignore[reportInvalidTypeForm]
+    result = await handler(request)
+    if not isinstance(result, CallToolResult) or result.isError:
+        return result
+
+    text_blocks: list[TextContent] = []
+    non_text_blocks: list[Any] = []
+    for block in result.content:
+        if isinstance(block, TextContent):
+            text_blocks.append(block)
+        else:
+            non_text_blocks.append(block)
+
+    merged_structured: dict[str, Any] = (
+        dict(result.structuredContent) if result.structuredContent else {}
+    )
+    merged_structured[NON_TEXT_CONTENT_KEY] = non_text_blocks
+
+    return result.model_copy(update={
+        "content": text_blocks,
+        "structuredContent": merged_structured,
+    })

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: distributed_a2a
-Version: 0.2.2
+Version: 0.2.3
 Summary: A library for building A2A agents with routing capabilities
 Home-page: https://github.com/Barra-Technologies/distributed-a2a
 Author: Fabian Bell
@@ -211,6 +211,27 @@ if __name__ == "__main__":
     asyncio.run(main())
 ```
 
+### Binary content handling
+
+When an agent invokes an MCP tool that returns non-text content (files, images,
+`EmbeddedResource`, `ResourceLink`), the library keeps those payloads out of the
+LLM's context window and delivers them out-of-band as A2A `FilePart` artifacts.
+
+Concretely, `RoutingAgentExecutor` installs the
+`hide_binary_content_from_llm` tool-call interceptor on every
+`MultiServerMCPClient` it builds. The interceptor moves any non-`TextContent`
+block from `CallToolResult.content` into `CallToolResult.structuredContent`
+under the `non_text_content` key. The upstream adapter then carries that dict
+into `ToolMessage.artifact['structured_content']`, which LangChain does **not**
+surface to the model. After the graph run, the executor walks the message list,
+extracts the stashed blocks, and emits one `TaskArtifactUpdateEvent` per file
+before the terminating text artifact.
+
+Client-side, `RoutingA2AClient.send_message` returns an `AgentReply` that
+exposes both the LLM's text summary and any `FileRef` payloads (with either
+inline `bytes_b64` or a `uri`), so downstream integrations (e.g. Slack file
+uploads) can forward the bytes without ever routing them through a model.
+
 ### Environment Variables
 The library uses several environment variables for configuration. These can be set in your shell or via a `.env` file.
 

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

@@ -9,7 +9,8 @@ distributed_a2a/agent.py
 distributed_a2a/client.py
 distributed_a2a/config.py
 distributed_a2a/executors.py
-distributed_a2a/files.py
+distributed_a2a/file_extractors.py
+distributed_a2a/mcp_interceptors.py
 distributed_a2a/model.py
 distributed_a2a/py.typed
 distributed_a2a/registry.py
@@ -31,6 +32,7 @@ distributed_a2a/schemas/router-agent-schema.json
 tests/test_app.py
 tests/test_client.py
 tests/test_executor_files.py
-tests/test_files.py
+tests/test_file_extractors.py
+tests/test_mcp_interceptors.py
 tests/test_rejection.py
 tests/test_timeout.py

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

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

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

@@ -12,9 +12,16 @@ 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
+from distributed_a2a.mcp_interceptors import NON_TEXT_CONTENT_KEY
+
+_DOCX_MIME = (
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+)
 
 
 class _StubStatusAgent:
@@ -214,3 +221,63 @@ async def test_executor_emits_one_file_event_per_file_block() -> None:
                     if isinstance(e, TaskStatusUpdateEvent) and e.final]
     assert len(final_status) == 1
     assert final_status[0].status.state == TaskState.completed
+
+
+@pytest.mark.asyncio
+async def test_executor_emits_file_part_from_interceptor_artifact_shape() -> None:
+    docx_b64 = base64.b64encode(b"PK\x03\x04 hidden bytes").decode("ascii")
+    embedded = EmbeddedResource(
+        type="resource",
+        resource=BlobResourceContents(
+            uri=AnyUrl("cv://cv-carol.docx"), mimeType=_DOCX_MIME, blob=docx_b64,
+        ),
+    )
+    summary_json = (
+        '{"filename": "cv-carol.docx", '
+        f'"mime_type": "{_DOCX_MIME}", "size_bytes": 42}}'
+    )
+    tool_msg = ToolMessage(
+        content=summary_json,
+        tool_call_id="call-cv",
+        artifact={"structured_content": {NON_TEXT_CONTENT_KEY: [embedded]}},
+    )
+
+    executor = RoutingAgentExecutor.__new__(RoutingAgentExecutor)
+    executor.agent_config = SimpleNamespace(  # type: ignore[assignment]
+        agent=SimpleNamespace(card=SimpleNamespace(name="cv-agent")),
+    )
+    executor.agent = _StubStatusAgent(  # type: ignore[assignment]
+        StringResponse(status=TaskState.completed,
+                       response="Here is your CV."),
+        [HumanMessage(content="render a CV please"), tool_msg],
+    )
+
+    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) == 2
+    file_event, text_event = artifact_events
+    assert file_event.last_chunk is False
+    assert file_event.artifact.name == "cv-carol.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-carol.docx"
+    assert file_part.file.mime_type == _DOCX_MIME
+    assert file_part.file.bytes == docx_b64
+
+    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.2/tests/test_files.py → distributed_a2a-0.2.3/tests/test_file_extractors.py

@@ -9,9 +9,17 @@ 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,
+                       ResourceLink)
+from pydantic import AnyUrl
 
 from distributed_a2a.client import AgentReply, RemoteAgentConnection
-from distributed_a2a.files import extract_file_parts
+from distributed_a2a.file_extractors import extract_file_parts
+from distributed_a2a.mcp_interceptors import NON_TEXT_CONTENT_KEY
+
+_DOCX_MIME = (
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+)
 
 
 def _b64(payload: bytes) -> str:
@@ -150,6 +158,174 @@ def test_extract_file_parts_matches_multiple_filenames_by_order() -> None:
     assert parts[1][1].file.bytes == b64_b  # type: ignore[union-attr]
 
 
+def _interceptor_artifact(blocks: list[object], **extra: object) -> dict[str, object]:
+    return {"structured_content": {NON_TEXT_CONTENT_KEY: blocks, **extra}}
+
+
+def test_extract_file_parts_reads_interceptor_artifact_shape() -> None:
+    docx_b64 = _b64(b"PK\x03\x04 real docx bytes")
+    embedded = EmbeddedResource(
+        type="resource",
+        resource=BlobResourceContents(
+            uri=AnyUrl("cv://cv-alice.docx"), mimeType=_DOCX_MIME, blob=docx_b64,
+        ),
+    )
+    tool_msg = ToolMessage(
+        content='{"filename": "cv-alice.docx"}',
+        tool_call_id="call-cv",
+        artifact=_interceptor_artifact([embedded]),
+    )
+
+    parts = extract_file_parts([tool_msg])
+
+    assert len(parts) == 1
+    name, file_part = parts[0]
+    assert name == "cv-alice.docx"
+    assert isinstance(file_part.file, FileWithBytes)
+    assert file_part.file.name == "cv-alice.docx"
+    assert file_part.file.mime_type == _DOCX_MIME
+    assert file_part.file.bytes == docx_b64
+
+
+def test_extract_file_parts_prefers_interceptor_artifact_over_content_blocks() -> None:
+    docx_b64 = _b64(b"PK\x03\x04 interceptor bytes")
+    embedded = EmbeddedResource(
+        type="resource",
+        resource=BlobResourceContents(
+            uri=AnyUrl("cv://cv-interceptor.docx"), mimeType=_DOCX_MIME, blob=docx_b64,
+        ),
+    )
+    tool_msg = ToolMessage(
+        content=[
+            {"type": "text", "text": '{"filename": "cv-legacy.docx"}',
+             "id": "lc_text_1"},
+            {"type": "file",
+             "base64": _b64(b"legacy fallback bytes"),
+             "mime_type": _DOCX_MIME,
+             "id": "lc_file_1"},
+        ],
+        tool_call_id="call-cv",
+        artifact=_interceptor_artifact([embedded]),
+    )
+
+    parts = extract_file_parts([tool_msg])
+
+    assert len(parts) == 1
+    name, file_part = parts[0]
+    assert name == "cv-interceptor.docx"
+    assert isinstance(file_part.file, FileWithBytes)
+    assert file_part.file.bytes == docx_b64
+
+
+def test_extract_file_parts_reads_image_content_from_interceptor_artifact() -> None:
+    png_b64 = _b64(b"\x89PNG\r\n\x1a\n fake image bytes")
+    image = ImageContent(type="image", data=png_b64, mimeType="image/png")
+    tool_msg = ToolMessage(
+        content="here is a chart",
+        tool_call_id="call-img",
+        artifact=_interceptor_artifact([image]),
+    )
+
+    parts = extract_file_parts([tool_msg])
+
+    assert len(parts) == 1
+    name, file_part = parts[0]
+    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_reads_resource_link_as_file_with_uri() -> None:
+    link = ResourceLink(
+        type="resource_link",
+        uri=AnyUrl("https://example.com/reports/report.pdf"),
+        name="report.pdf",
+        mimeType="application/pdf",
+    )
+    tool_msg = ToolMessage(
+        content="see attached report",
+        tool_call_id="call-link",
+        artifact=_interceptor_artifact([link]),
+    )
+
+    parts = extract_file_parts([tool_msg])
+
+    assert len(parts) == 1
+    name, file_part = parts[0]
+    assert name == "report.pdf"
+    assert isinstance(file_part.file, FileWithUri)
+    assert file_part.file.mime_type == "application/pdf"
+    assert file_part.file.uri == "https://example.com/reports/report.pdf"
+
+
+def test_extract_file_parts_reads_multiple_blocks_from_interceptor_artifact() -> None:
+    b64_a = _b64(b"aaa docx")
+    b64_b = _b64(b"bbb docx")
+    a = EmbeddedResource(
+        type="resource",
+        resource=BlobResourceContents(
+            uri=AnyUrl("cv://cv-a.docx"), mimeType=_DOCX_MIME, blob=b64_a,
+        ),
+    )
+    b = EmbeddedResource(
+        type="resource",
+        resource=BlobResourceContents(
+            uri=AnyUrl("cv://cv-b.docx"), mimeType=_DOCX_MIME, blob=b64_b,
+        ),
+    )
+    tool_msg = ToolMessage(
+        content='{"count": 2}',
+        tool_call_id="call-multi",
+        artifact=_interceptor_artifact([a, b]),
+    )
+
+    parts = extract_file_parts([tool_msg])
+
+    assert [name for name, _ in parts] == ["cv-a.docx", "cv-b.docx"]
+    assert parts[0][1].file.bytes == b64_a  # type: ignore[union-attr]
+    assert parts[1][1].file.bytes == b64_b  # type: ignore[union-attr]
+
+
+def test_extract_file_parts_ignores_empty_interceptor_artifact() -> None:
+    """An empty ``non_text_content`` list must not cause the extractor to
+    fall through to the ``content`` path — that would double-extract files
+    on any tool where the interceptor happened to filter everything out."""
+    tool_msg = ToolMessage(
+        content=[
+            {"type": "file", "base64": _b64(b"leaked"),
+             "mime_type": _DOCX_MIME, "id": "lc_file_1"},
+        ],
+        tool_call_id="call-mixed",
+        artifact={"structured_content": {NON_TEXT_CONTENT_KEY: []}},
+    )
+    parts = extract_file_parts([tool_msg])
+    assert len(parts) == 1
+
+
+def test_extract_file_parts_falls_back_to_content_when_artifact_has_no_key() -> None:
+    docx_b64 = _b64(b"PK\x03\x04 bytes")
+    tool_msg = ToolMessage(
+        content=[
+            {"type": "text", "text": '{"filename": "cv-fallback.docx"}',
+             "id": "lc_text_1"},
+            {"type": "file", "base64": docx_b64,
+             "mime_type": _DOCX_MIME, "id": "lc_file_1"},
+        ],
+        tool_call_id="call-fallback",
+        artifact={"structured_content": {"unrelated": {"foo": 1}}},
+    )
+
+    parts = extract_file_parts([tool_msg])
+
+    assert len(parts) == 1
+    name, file_part = parts[0]
+    assert name == "cv-fallback.docx"
+    assert isinstance(file_part.file, FileWithBytes)
+    assert file_part.file.bytes == docx_b64
+
+
 class _StubAgentClient:
     def __init__(self, task: Task):
         self._task = task

distributed_a2a-0.2.3/tests/test_mcp_interceptors.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+from langchain_core.messages import ToolMessage
+from langchain_core.tools import StructuredTool
+from langchain_mcp_adapters.interceptors import MCPToolCallRequest
+from langchain_mcp_adapters.tools import _convert_call_tool_result
+from mcp.types import (BlobResourceContents, CallToolResult, EmbeddedResource,
+                       ImageContent, TextContent)
+from pydantic import AnyUrl
+
+from distributed_a2a.mcp_interceptors import (NON_TEXT_CONTENT_KEY,
+                                              hide_binary_content_from_llm)
+
+
+def _request() -> MCPToolCallRequest:
+    return MCPToolCallRequest(
+        name="render_file", args={}, server_name="test-server",
+    )
+
+
+def _embedded_docx(uri: str = "file://alice.docx", blob: str = "UEsDBAA=") -> EmbeddedResource:
+    return EmbeddedResource(
+        type="resource",
+        resource=BlobResourceContents(
+            uri=AnyUrl(uri),
+            mimeType=(
+                "application/vnd.openxmlformats-officedocument."
+                "wordprocessingml.document"
+            ),
+            blob=blob,
+        ),
+    )
+
+
+def _make_handler(returning: Any) -> Any:
+    async def _handler(_req: MCPToolCallRequest) -> Any:
+        return returning
+    return _handler
+
+
+@pytest.mark.asyncio
+async def test_text_only_result_is_passed_through() -> None:
+    original = CallToolResult(
+        content=[TextContent(type="text", text="just a summary")],
+        structuredContent=None,
+        isError=False,
+    )
+    result = await hide_binary_content_from_llm(_request(), _make_handler(original))
+    assert isinstance(result, CallToolResult)
+    assert result.content == original.content
+    assert result.structuredContent == {NON_TEXT_CONTENT_KEY: []}
+
+
+@pytest.mark.asyncio
+async def test_mixed_result_moves_binary_into_structured_content() -> None:
+    embedded = _embedded_docx()
+    original = CallToolResult(
+        content=[
+            TextContent(type="text", text='{"filename": "alice.docx"}'),
+            embedded,
+        ],
+        structuredContent=None,
+        isError=False,
+    )
+    result = await hide_binary_content_from_llm(_request(), _make_handler(original))
+    assert isinstance(result, CallToolResult)
+    assert result is not original, "A mutated copy is expected, not the original object."
+    assert len(result.content) == 1
+    assert isinstance(result.content[0], TextContent)
+    assert result.content[0].text == '{"filename": "alice.docx"}'
+    assert result.structuredContent is not None
+    assert result.structuredContent[NON_TEXT_CONTENT_KEY] == [embedded]
+
+
+@pytest.mark.asyncio
+async def test_binary_only_result_produces_empty_content_list() -> None:
+    embedded = _embedded_docx()
+    original = CallToolResult(
+        content=[embedded],
+        structuredContent=None,
+        isError=False,
+    )
+    result = await hide_binary_content_from_llm(_request(), _make_handler(original))
+    assert isinstance(result, CallToolResult)
+    assert result.content == [], (
+        "Binary-only tool output should leave content empty — the model "
+        "receives no text, and the block is only reachable via artifact."
+    )
+    assert result.structuredContent == {NON_TEXT_CONTENT_KEY: [embedded]}
+
+
+@pytest.mark.asyncio
+async def test_error_result_is_passed_through_unchanged() -> None:
+    original = CallToolResult(
+        content=[TextContent(type="text", text="boom")],
+        structuredContent=None,
+        isError=True,
+    )
+    result = await hide_binary_content_from_llm(_request(), _make_handler(original))
+    assert result is original
+    assert isinstance(result, CallToolResult) and result.isError is True
+
+
+@pytest.mark.asyncio
+async def test_error_result_with_binary_still_passes_through() -> None:
+    embedded = _embedded_docx()
+    original = CallToolResult(
+        content=[TextContent(type="text", text="oops"), embedded],
+        structuredContent=None,
+        isError=True,
+    )
+    result = await hide_binary_content_from_llm(_request(), _make_handler(original))
+    assert result is original
+
+
+@pytest.mark.asyncio
+async def test_preserves_existing_structured_content() -> None:
+    embedded = _embedded_docx()
+    original = CallToolResult(
+        content=[TextContent(type="text", text="summary"), embedded],
+        structuredContent={"foo": 1, "nested": {"bar": 2}},
+        isError=False,
+    )
+    result = await hide_binary_content_from_llm(_request(), _make_handler(original))
+    assert isinstance(result, CallToolResult)
+    assert result.structuredContent == {
+        "foo": 1,
+        "nested": {"bar": 2},
+        NON_TEXT_CONTENT_KEY: [embedded],
+    }
+    assert original.structuredContent == {"foo": 1, "nested": {"bar": 2}}
+
+
+@pytest.mark.asyncio
+async def test_non_call_tool_result_is_passed_through() -> None:
+    upstream = ToolMessage(content="upstream", tool_call_id="tc-1")
+    result = await hide_binary_content_from_llm(_request(), _make_handler(upstream))
+    assert result is upstream
+
+
+@pytest.mark.asyncio
+async def test_image_content_is_hidden() -> None:
+    image = ImageContent(type="image", data="AA==", mimeType="image/png")
+    original = CallToolResult(
+        content=[TextContent(type="text", text="see below"), image],
+        isError=False,
+    )
+    result = await hide_binary_content_from_llm(_request(), _make_handler(original))
+    assert isinstance(result, CallToolResult)
+    assert result.content == [TextContent(type="text", text="see below")]
+    assert result.structuredContent == {NON_TEXT_CONTENT_KEY: [image]}
+
+
+def test_adapter_forwards_structured_content_into_tool_message_artifact() -> None:
+    embedded = _embedded_docx()
+    stashed = CallToolResult(
+        content=[TextContent(type="text", text='{"filename": "file.docx"}')],
+        structuredContent={NON_TEXT_CONTENT_KEY: [embedded]},
+        isError=False,
+    )
+    content, artifact = _convert_call_tool_result(stashed)
+    assert isinstance(content, list) and content
+    # No file/image block leaked into the LLM-visible content list.
+    for block in content:
+        assert not isinstance(block, dict) or block.get("type") == "text"
+    assert artifact is not None
+    assert artifact["structured_content"] == {NON_TEXT_CONTENT_KEY: [embedded]}
+
+
+def test_base_tool_invoke_sets_tool_call_id_when_content_is_not_tool_message() -> None:
+    def fake_call(**_kwargs: Any) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+        return (
+            [{"type": "text", "text": "summary"}],
+            {"structured_content": {NON_TEXT_CONTENT_KEY: ["placeholder"]}},
+        )
+
+    tool = StructuredTool.from_function(
+        func=fake_call,
+        name="render_file",
+        description="stub",
+        response_format="content_and_artifact",
+    )
+    tool_call = {
+        "name": "render_file",
+        "args": {},
+        "id": "TCID_42",
+        "type": "tool_call",
+    }
+    result = tool.invoke(tool_call)
+    assert isinstance(result, ToolMessage)
+    assert result.tool_call_id == "TCID_42"
+    assert result.artifact == {
+        "structured_content": {NON_TEXT_CONTENT_KEY: ["placeholder"]},
+    }

distributed_a2a-0.2.2/distributed_a2a/files.py

@@ -1,68 +0,0 @@
-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