distributed-a2a 0.2.4__tar.gz → 0.2.5__tar.gz

{distributed_a2a-0.2.4/distributed_a2a.egg-info → distributed_a2a-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: distributed_a2a
-Version: 0.2.4
+Version: 0.2.5
 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.4 → distributed_a2a-0.2.5}/distributed_a2a/file_extractors.py

@@ -48,37 +48,110 @@ 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,
-            ))))
+        result = _mcp_block_to_file_part(block, counters)
+        if result is not None:
+            out.append(result)
     return out
 
 
+def _mcp_block_to_file_part(
+    block: Any, counters: dict[str, int],
+) -> tuple[str, FilePart] | None:
+    # Normalise both shapes into (type_tag, extractor-friendly view).
+    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 ""
+        return _blob_resource_to_file_part(
+            mime_type, uri, block.resource.blob, counters,
+        )
+    if isinstance(block, ImageContent):
+        return _image_bytes_to_file_part(
+            block.mimeType or "application/octet-stream", block.data, counters,
+        )
+    if isinstance(block, ResourceLink):
+        return _resource_link_to_file_part(
+            block.mimeType or "application/octet-stream",
+            str(block.uri),
+            counters,
+        )
+
+    if not isinstance(block, dict):
+        return None
+
+    block_type = block.get("type")
+    if block_type == "resource":
+        resource = block.get("resource")
+        if not isinstance(resource, dict):
+            return None
+        blob = resource.get("blob")
+        if not isinstance(blob, str) or not blob:
+            return None
+        mime_type_str = _mime_type_or_default(resource.get("mimeType"))
+        raw_uri = resource.get("uri")
+        uri_str = str(raw_uri) if raw_uri else ""
+        return _blob_resource_to_file_part(
+            mime_type_str, uri_str, blob, counters,
+        )
+    if block_type == "image":
+        data = block.get("data")
+        if not isinstance(data, str) or not data:
+            return None
+        mime_type_str = _mime_type_or_default(block.get("mimeType"))
+        return _image_bytes_to_file_part(mime_type_str, data, counters)
+    if block_type == "resource_link":
+        raw_uri = block.get("uri")
+        if not raw_uri:
+            return None
+        mime_type_str = _mime_type_or_default(block.get("mimeType"))
+        return _resource_link_to_file_part(
+            mime_type_str, str(raw_uri), counters,
+        )
+    return None
+
+
+def _mime_type_or_default(value: Any) -> str:
+    if isinstance(value, str) and value:
+        return value
+    return "application/octet-stream"
+
+
+def _blob_resource_to_file_part(
+    mime_type: str, uri: str, blob: str, counters: dict[str, int],
+) -> tuple[str, FilePart]:
+    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
+    return name, FilePart(file=FileWithBytes(
+        name=name, mime_type=mime_type, bytes=blob,
+    ))
+
+
+def _image_bytes_to_file_part(
+    mime_type: str, data: str, counters: dict[str, int],
+) -> tuple[str, FilePart]:
+    name = _synthetic_name("image", counters["image"], mime_type)
+    counters["image"] += 1
+    return name, FilePart(file=FileWithBytes(
+        name=name, mime_type=mime_type, bytes=data,
+    ))
+
+
+def _resource_link_to_file_part(
+    mime_type: str, uri: str, counters: dict[str, int],
+) -> tuple[str, FilePart]:
+    kind = "image" if mime_type.startswith("image/") else "attachment"
+    name = _name_from_uri(uri, kind, counters[kind], mime_type)
+    counters[kind] += 1
+    return name, FilePart(file=FileWithUri(
+        name=name, mime_type=mime_type, uri=uri,
+    ))
+
+
 def _extract_from_langchain_content_blocks(content: list[Any]) -> list[tuple[str, FilePart]]:
     out: list[tuple[str, FilePart]] = []
     pending_name: str | None = None

{distributed_a2a-0.2.4 → distributed_a2a-0.2.5}/distributed_a2a/mcp_interceptors.py

@@ -26,12 +26,12 @@ async def hide_binary_content_from_llm(
         return result
 
     text_blocks: list[TextContent] = []
-    non_text_blocks: list[Any] = []
+    non_text_blocks: list[dict[str, Any]] = []
     for block in result.content:
         if isinstance(block, TextContent):
             text_blocks.append(block)
         else:
-            non_text_blocks.append(block)
+            non_text_blocks.append(block.model_dump(mode="json"))
 
     merged_structured: dict[str, Any] = (
         dict(result.structuredContent) if result.structuredContent else {}

{distributed_a2a-0.2.4 → distributed_a2a-0.2.5/distributed_a2a.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: distributed_a2a
-Version: 0.2.4
+Version: 0.2.5
 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.4 → distributed_a2a-0.2.5}/pyproject.toml

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

{distributed_a2a-0.2.4 → distributed_a2a-0.2.5}/tests/test_mcp_interceptors.py

@@ -7,6 +7,7 @@ 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 langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer
 from mcp.types import (BlobResourceContents, CallToolResult, EmbeddedResource,
                        ImageContent, TextContent)
 from pydantic import AnyUrl
@@ -72,7 +73,11 @@ async def test_mixed_result_moves_binary_into_structured_content() -> None:
     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]
+    # Non-text blocks are stored as JSON-safe dicts (not raw pydantic
+    # instances) so downstream LangGraph msgpack checkpointing works.
+    assert result.structuredContent[NON_TEXT_CONTENT_KEY] == [
+        embedded.model_dump(mode="json"),
+    ]
 
 
 @pytest.mark.asyncio
@@ -89,7 +94,9 @@ async def test_binary_only_result_produces_empty_content_list() -> None:
         "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]}
+    assert result.structuredContent == {
+        NON_TEXT_CONTENT_KEY: [embedded.model_dump(mode="json")],
+    }
 
 
 @pytest.mark.asyncio
@@ -129,7 +136,7 @@ async def test_preserves_existing_structured_content() -> None:
     assert result.structuredContent == {
         "foo": 1,
         "nested": {"bar": 2},
-        NON_TEXT_CONTENT_KEY: [embedded],
+        NON_TEXT_CONTENT_KEY: [embedded.model_dump(mode="json")],
     }
     assert original.structuredContent == {"foo": 1, "nested": {"bar": 2}}
 
@@ -151,7 +158,9 @@ async def test_image_content_is_hidden() -> None:
     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]}
+    assert result.structuredContent == {
+        NON_TEXT_CONTENT_KEY: [image.model_dump(mode="json")],
+    }
 
 
 def test_adapter_forwards_structured_content_into_tool_message_artifact() -> None:
@@ -195,3 +204,46 @@ def test_base_tool_invoke_sets_tool_call_id_when_content_is_not_tool_message() -
     assert result.artifact == {
         "structured_content": {NON_TEXT_CONTENT_KEY: ["placeholder"]},
     }
+
+
+@pytest.mark.asyncio
+async def test_tool_message_from_interceptor_is_msgpack_serializable() -> None:
+    embedded = _embedded_docx()
+    image = ImageContent(type="image", data="AA==", mimeType="image/png")
+    original = CallToolResult(
+        content=[
+            TextContent(type="text", text='{"filename": "alice.docx"}'),
+            embedded,
+            image,
+        ],
+        isError=False,
+    )
+    stashed = await hide_binary_content_from_llm(
+        _request(), _make_handler(original),
+    )
+    assert isinstance(stashed, CallToolResult)
+
+    content, artifact = _convert_call_tool_result(stashed)
+    tool_msg = ToolMessage(
+        content=content,  # type: ignore[arg-type]
+        tool_call_id="call-1",
+        name="render_file",
+        artifact=artifact,
+    )
+
+    serde = JsonPlusSerializer()
+    kind, blob = serde.dumps_typed({"messages": [tool_msg]})
+    assert kind == "msgpack"
+    loaded = serde.loads_typed((kind, blob))
+    assert isinstance(loaded, dict)
+    loaded_messages = loaded["messages"]
+    assert len(loaded_messages) == 1
+    assert isinstance(loaded_messages[0], ToolMessage)
+    assert loaded_messages[0].tool_call_id == "call-1"
+    assert loaded_messages[0].artifact is not None
+    non_text = loaded_messages[0].artifact["structured_content"][
+        NON_TEXT_CONTENT_KEY
+    ]
+    assert len(non_text) == 2
+    assert non_text[0]["type"] == "resource"
+    assert non_text[1]["type"] == "image"