diff --git a/PULL_REQUEST.md b/PULL_REQUEST.md
new file mode 100644
index 000000000..e326e262b
--- /dev/null
+++ b/PULL_REQUEST.md
@@ -0,0 +1,70 @@
+## Description
+
+When using A2A (Agent-to-Agent) protocol, agents frequently need to exchange rich content beyond plain text—images for vision tasks, documents for analysis, and videos for multimedia workflows. The current A2A converters only support text content, forcing developers to work around this limitation or lose content fidelity when communicating between agents.
+
+This PR extends the A2A converters to handle image, document, and video content types, enabling seamless multimodal communication between Strands agents and any A2A-compatible agent.
+
+Resolves: #1504
+
+## Public API Changes
+
+No public API changes. The existing `convert_content_blocks_to_parts` and `convert_response_to_agent_result` functions now automatically handle additional content types.
+
+```python
+# Before: only text content was converted, other types were silently dropped
+content_blocks = [
+    {"text": "Analyze this image:"},
+    {"image": {"format": "png", "source": {"bytes": image_bytes}}},
+]
+parts = convert_content_blocks_to_parts(content_blocks)
+# Result: only 1 part (text), image was lost
+
+# After: all content types are preserved
+content_blocks = [
+    {"text": "Analyze this image:"},
+    {"image": {"format": "png", "source": {"bytes": image_bytes}}},
+]
+parts = convert_content_blocks_to_parts(content_blocks)
+# Result: 2 parts - TextPart and FilePart with image/png MIME type
+```
+
+The conversion is bidirectional—A2A FileParts received from remote agents are correctly converted back to Strands ImageContent, DocumentContent, or VideoContent based on MIME type.
+
+## Related Issues
+
+#1504
+
+## Documentation PR
+
+N/A - Internal converter changes with no user-facing API modifications.
+
+## Type of Change
+
+New feature
+
+## Testing
+
+How have you tested the change?  Verify that the changes do not break functionality or introduce warnings in consuming repositories: agents-docs, agents-tools, agents-cli
+
+- [x] I ran `hatch run prepare`
+
+Added 31 new unit tests covering:
+- Image conversion (all formats: png, jpeg, gif, webp) with both inline bytes and S3 URIs
+- Document conversion (all formats: pdf, csv, doc, docx, xls, xlsx, html, txt, md)
+- Video conversion (all formats: flv, mkv, mov, mpeg, mpg, mp4, three_gp, webm, wmv)
+- Mixed content scenarios and edge cases (unknown MIME types, missing MIME types)
+- Full round-trip conversion through response handling
+
+All 136 A2A module tests pass.
+
+## Checklist
+- [x] I have read the CONTRIBUTING document
+- [x] I have added any necessary tests that prove my fix is effective or my feature works
+- [x] I have updated the documentation accordingly
+- [x] I have added an appropriate example to the documentation to outline the feature, or no new docs are needed
+- [x] My changes generate no new warnings
+- [x] Any dependent changes have been merged and published
+
+----
+
+By submitting this pull request, I confirm that you can use, modify, copy, and redistribute this contribution, under the terms of your choice.
diff --git a/src/strands/agent/agent.py b/src/strands/agent/agent.py
index 05c3af191..2f7c4dbd9 100644
--- a/src/strands/agent/agent.py
+++ b/src/strands/agent/agent.py
@@ -59,6 +59,7 @@
 from ..types.exceptions import ConcurrencyException, ContextWindowOverflowException
 from ..types.traces import AttributeValue
 from .agent_result import AgentResult
+from .base import AgentBase
 from .conversation_manager import (
     ConversationManager,
     SlidingWindowConversationManager,
@@ -83,7 +84,7 @@ class _DefaultCallbackHandlerSentinel:
 _DEFAULT_AGENT_ID = "default"
 
 
-class Agent:
+class Agent(AgentBase):
     """Core Agent implementation.
 
     An agent orchestrates the following workflow:
diff --git a/src/strands/multiagent/a2a/_converters.py b/src/strands/multiagent/a2a/_converters.py
index b818c824b..0dfc4ab16 100644
--- a/src/strands/multiagent/a2a/_converters.py
+++ b/src/strands/multiagent/a2a/_converters.py
@@ -1,16 +1,92 @@
 """Conversion functions between Strands and A2A types."""
 
-from typing import cast
+import base64
+import logging
+from typing import Any, cast
 from uuid import uuid4
 
+from a2a.types import (
+    FilePart,
+    FileWithBytes,
+    FileWithUri,
+    Part,
+    Role,
+    TaskArtifactUpdateEvent,
+    TaskStatusUpdateEvent,
+    TextPart,
+)
 from a2a.types import Message as A2AMessage
-from a2a.types import Part, Role, TaskArtifactUpdateEvent, TaskStatusUpdateEvent, TextPart
 
 from ...agent.agent_result import AgentResult
 from ...telemetry.metrics import EventLoopMetrics
 from ...types.a2a import A2AResponse
 from ...types.agent import AgentInput
 from ...types.content import ContentBlock, Message
+from ...types.media import (
+    DocumentContent,
+    DocumentFormat,
+    ImageContent,
+    ImageFormat,
+    VideoContent,
+    VideoFormat,
+)
+
+logger = logging.getLogger(__name__)
+
+# MIME type mappings for Strands formats
+IMAGE_FORMAT_TO_MIME: dict[ImageFormat, str] = {
+    "png": "image/png",
+    "jpeg": "image/jpeg",
+    "gif": "image/gif",
+    "webp": "image/webp",
+}
+
+DOCUMENT_FORMAT_TO_MIME: dict[DocumentFormat, str] = {
+    "pdf": "application/pdf",
+    "csv": "text/csv",
+    "doc": "application/msword",
+    "docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "xls": "application/vnd.ms-excel",
+    "xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "html": "text/html",
+    "txt": "text/plain",
+    "md": "text/markdown",
+}
+
+VIDEO_FORMAT_TO_MIME: dict[VideoFormat, str] = {
+    "flv": "video/x-flv",
+    "mkv": "video/x-matroska",
+    "mov": "video/quicktime",
+    "mpeg": "video/mpeg",
+    "mpg": "video/mpeg",
+    "mp4": "video/mp4",
+    "three_gp": "video/3gpp",
+    "webm": "video/webm",
+    "wmv": "video/x-ms-wmv",
+}
+
+# Reverse mappings from MIME type to Strands format
+MIME_TO_IMAGE_FORMAT: dict[str, ImageFormat] = {v: k for k, v in IMAGE_FORMAT_TO_MIME.items()}
+MIME_TO_DOCUMENT_FORMAT: dict[str, DocumentFormat] = {v: k for k, v in DOCUMENT_FORMAT_TO_MIME.items()}
+MIME_TO_VIDEO_FORMAT: dict[str, VideoFormat] = {v: k for k, v in VIDEO_FORMAT_TO_MIME.items()}
+
+
+def _get_location_from_uri(uri: str) -> dict[str, Any]:
+    """Create a Strands location dict from a URI based on its scheme.
+
+    Args:
+        uri: The URI string (s3://, http://, https://, etc.)
+
+    Returns:
+        Location dict with appropriate type field based on URI scheme.
+    """
+    if uri.startswith("s3://"):
+        return {"type": "s3", "uri": uri}
+    elif uri.startswith("http://") or uri.startswith("https://"):
+        return {"type": "url", "uri": uri}
+    else:
+        # Generic location for unknown schemes
+        return {"type": "uri", "uri": uri}
 
 
 def convert_input_to_message(prompt: AgentInput) -> A2AMessage:
@@ -63,9 +139,107 @@ def convert_input_to_message(prompt: AgentInput) -> A2AMessage:
     raise ValueError(f"Unsupported input type: {type(prompt)}")
 
 
+def _convert_image_to_file_part(image: ImageContent) -> Part | None:
+    """Convert Strands ImageContent to A2A FilePart.
+
+    Args:
+        image: Strands image content with format and source.
+
+    Returns:
+        A2A Part containing FilePart, or None if conversion fails.
+    """
+    source = image.get("source", {})
+    mime_type = IMAGE_FORMAT_TO_MIME.get(image.get("format", "png"), "image/png")
+
+    # Handle inline bytes
+    if "bytes" in source and source["bytes"]:
+        raw_bytes = source["bytes"]
+        b64_str = base64.standard_b64encode(raw_bytes).decode("utf-8")
+        file_with_bytes = FileWithBytes(bytes=b64_str, mime_type=mime_type)
+        return Part(FilePart(file=file_with_bytes, kind="file"))
+
+    # Handle location-based references (S3, HTTP, etc.)
+    if "location" in source:
+        location = source["location"]
+        uri = location.get("uri")
+        if uri:
+            file_with_uri = FileWithUri(uri=uri, mime_type=mime_type)
+            return Part(FilePart(file=file_with_uri, kind="file"))
+
+    logger.debug("content_type=<image> | image content dropped due to empty or missing source")
+    return None
+
+
+def _convert_document_to_file_part(document: DocumentContent) -> Part | None:
+    """Convert Strands DocumentContent to A2A FilePart.
+
+    Args:
+        document: Strands document content with format, name, and source.
+
+    Returns:
+        A2A Part containing FilePart, or None if conversion fails.
+    """
+    source = document.get("source", {})
+    doc_format = document.get("format", "txt")
+    mime_type = DOCUMENT_FORMAT_TO_MIME.get(doc_format, "application/octet-stream")
+    name = document.get("name")
+
+    # Handle inline bytes
+    if "bytes" in source and source["bytes"]:
+        raw_bytes = source["bytes"]
+        b64_str = base64.standard_b64encode(raw_bytes).decode("utf-8")
+        file_with_bytes = FileWithBytes(bytes=b64_str, mime_type=mime_type, name=name)
+        return Part(FilePart(file=file_with_bytes, kind="file"))
+
+    # Handle location-based references (S3, HTTP, etc.)
+    if "location" in source:
+        location = source["location"]
+        uri = location.get("uri")
+        if uri:
+            file_with_uri = FileWithUri(uri=uri, mime_type=mime_type, name=name)
+            return Part(FilePart(file=file_with_uri, kind="file"))
+
+    logger.debug("content_type=<document>, name=<%s> | document content dropped due to empty or missing source", name)
+    return None
+
+
+def _convert_video_to_file_part(video: VideoContent) -> Part | None:
+    """Convert Strands VideoContent to A2A FilePart.
+
+    Args:
+        video: Strands video content with format and source.
+
+    Returns:
+        A2A Part containing FilePart, or None if conversion fails.
+    """
+    source = video.get("source", {})
+    video_format = video.get("format", "mp4")
+    mime_type = VIDEO_FORMAT_TO_MIME.get(video_format, "video/mp4")
+
+    # Handle inline bytes
+    if "bytes" in source and source["bytes"]:
+        raw_bytes = source["bytes"]
+        b64_str = base64.standard_b64encode(raw_bytes).decode("utf-8")
+        file_with_bytes = FileWithBytes(bytes=b64_str, mime_type=mime_type)
+        return Part(FilePart(file=file_with_bytes, kind="file"))
+
+    # Handle location-based references (S3, HTTP, etc.)
+    if "location" in source:
+        location = source["location"]
+        uri = location.get("uri")
+        if uri:
+            file_with_uri = FileWithUri(uri=uri, mime_type=mime_type)
+            return Part(FilePart(file=file_with_uri, kind="file"))
+
+    logger.debug("content_type=<video> | video content dropped due to empty or missing source")
+    return None
+
+
 def convert_content_blocks_to_parts(content_blocks: list[ContentBlock]) -> list[Part]:
     """Convert Strands ContentBlocks to A2A Parts.
 
+    Supports conversion of text, image, document, and video content blocks.
+
     Args:
         content_blocks: List of Strands content blocks.
 
@@ -76,12 +250,193 @@ def convert_content_blocks_to_parts(content_blocks: list[ContentBlock]) -> list[
     for block in content_blocks:
         if "text" in block:
             parts.append(Part(TextPart(kind="text", text=block["text"])))
+        elif "image" in block:
+            part = _convert_image_to_file_part(block["image"])
+            if part:
+                parts.append(part)
+        elif "document" in block:
+            part = _convert_document_to_file_part(block["document"])
+            if part:
+                parts.append(part)
+        elif "video" in block:
+            part = _convert_video_to_file_part(block["video"])
+            if part:
+                parts.append(part)
     return parts
 
 
+def _convert_file_part_to_content_block(file_part: FilePart) -> ContentBlock | None:
+    """Convert A2A FilePart to Strands ContentBlock.
+
+    Determines the content type based on MIME type and converts accordingly.
+
+    Args:
+        file_part: A2A FilePart containing file data or URI.
+
+    Returns:
+        Strands ContentBlock (image, document, or video), or None if unsupported.
+    """
+    file_data = file_part.file
+    mime_type = file_data.mime_type or "application/octet-stream"
+
+    # Check if it's an image
+    if mime_type in MIME_TO_IMAGE_FORMAT:
+        return _convert_file_part_to_image(file_data, mime_type)
+
+    # Check if it's a document
+    if mime_type in MIME_TO_DOCUMENT_FORMAT:
+        return _convert_file_part_to_document(file_data, mime_type)
+
+    # Check if it's a video
+    if mime_type in MIME_TO_VIDEO_FORMAT:
+        return _convert_file_part_to_video(file_data, mime_type)
+
+    # Handle generic image/* mime types
+    if mime_type.startswith("image/"):
+        return _convert_file_part_to_image(file_data, mime_type)
+
+    # Handle generic video/* mime types
+    if mime_type.startswith("video/"):
+        return _convert_file_part_to_video(file_data, mime_type)
+
+    # Handle generic application/* and text/* as documents
+    if mime_type.startswith("application/") or mime_type.startswith("text/"):
+        return _convert_file_part_to_document(file_data, mime_type)
+
+    logger.debug("mime_type=<%s> | file part dropped due to unsupported mime type", mime_type)
+    return None
+
+
+def _convert_file_part_to_image(
+    file_data: FileWithBytes | FileWithUri,
+    mime_type: str,
+) -> ContentBlock:
+    """Convert A2A file data to Strands ImageContent block.
+
+    Args:
+        file_data: A2A file with bytes or URI.
+        mime_type: MIME type of the image.
+
+    Returns:
+        Strands ContentBlock containing ImageContent.
+    """
+    image_format: ImageFormat = MIME_TO_IMAGE_FORMAT.get(mime_type, "png")
+
+    if isinstance(file_data, FileWithBytes):
+        raw_bytes = base64.standard_b64decode(file_data.bytes)
+        image_content: ImageContent = {
+            "format": image_format,
+            "source": {"bytes": raw_bytes},
+        }
+    else:
+        # FileWithUri - determine location type from URI scheme
+        location = _get_location_from_uri(file_data.uri)
+        image_content = {
+            "format": image_format,
+            "source": {"location": location},
+        }
+
+    return cast(ContentBlock, {"image": image_content})
+
+
+def _convert_file_part_to_document(
+    file_data: FileWithBytes | FileWithUri,
+    mime_type: str,
+) -> ContentBlock:
+    """Convert A2A file data to Strands DocumentContent block.
+
+    Args:
+        file_data: A2A file with bytes or URI.
+        mime_type: MIME type of the document.
+
+    Returns:
+        Strands ContentBlock containing DocumentContent.
+    """
+    doc_format: DocumentFormat = MIME_TO_DOCUMENT_FORMAT.get(mime_type, "txt")
+    name = file_data.name
+
+    if isinstance(file_data, FileWithBytes):
+        raw_bytes = base64.standard_b64decode(file_data.bytes)
+        doc_content: DocumentContent = {
+            "format": doc_format,
+            "source": {"bytes": raw_bytes},
+        }
+        if name:
+            doc_content["name"] = name
+    else:
+        # FileWithUri - determine location type from URI scheme
+        location = _get_location_from_uri(file_data.uri)
+        doc_content = {
+            "format": doc_format,
+            "source": {"location": location},
+        }
+        if name:
+            doc_content["name"] = name
+
+    return cast(ContentBlock, {"document": doc_content})
+
+
+def _convert_file_part_to_video(
+    file_data: FileWithBytes | FileWithUri,
+    mime_type: str,
+) -> ContentBlock:
+    """Convert A2A file data to Strands VideoContent block.
+
+    Args:
+        file_data: A2A file with bytes or URI.
+        mime_type: MIME type of the video.
+
+    Returns:
+        Strands ContentBlock containing VideoContent.
+    """
+    video_format: VideoFormat = MIME_TO_VIDEO_FORMAT.get(mime_type, "mp4")
+
+    if isinstance(file_data, FileWithBytes):
+        raw_bytes = base64.standard_b64decode(file_data.bytes)
+        video_content: VideoContent = {
+            "format": video_format,
+            "source": {"bytes": raw_bytes},
+        }
+    else:
+        # FileWithUri - determine location type from URI scheme
+        location = _get_location_from_uri(file_data.uri)
+        video_content = {
+            "format": video_format,
+            "source": {"location": location},
+        }
+
+    return cast(ContentBlock, {"video": video_content})
+
+
+def _extract_content_from_parts(parts: list[Part]) -> list[ContentBlock]:
+    """Extract Strands ContentBlocks from A2A Parts.
+
+    Supports extraction of text, image, document, and video parts.
+
+    Args:
+        parts: List of A2A Part objects.
+
+    Returns:
+        List of Strands ContentBlock objects.
+    """
+    content: list[ContentBlock] = []
+    for part in parts:
+        if hasattr(part, "root"):
+            root = part.root
+            if hasattr(root, "text"):
+                content.append({"text": root.text})
+            elif hasattr(root, "file"):
+                block = _convert_file_part_to_content_block(root)
+                if block:
+                    content.append(block)
+    return content
+
+
 def convert_response_to_agent_result(response: A2AResponse) -> AgentResult:
     """Convert A2A response to AgentResult.
 
+    Supports conversion of text, image, document, and video content types.
+
     Args:
         response: A2A response (either A2AMessage or tuple of task and update event).
 
@@ -96,26 +451,18 @@ def convert_response_to_agent_result(response: A2AResponse) -> AgentResult:
         # Handle artifact updates
         if isinstance(update_event, TaskArtifactUpdateEvent):
             if update_event.artifact and hasattr(update_event.artifact, "parts"):
-                for part in update_event.artifact.parts:
-                    if hasattr(part, "root") and hasattr(part.root, "text"):
-                        content.append({"text": part.root.text})
+                content.extend(_extract_content_from_parts(update_event.artifact.parts))
         # Handle status updates with messages
         elif isinstance(update_event, TaskStatusUpdateEvent):
             if update_event.status and hasattr(update_event.status, "message") and update_event.status.message:
-                for part in update_event.status.message.parts:
-                    if hasattr(part, "root") and hasattr(part.root, "text"):
-                        content.append({"text": part.root.text})
+                content.extend(_extract_content_from_parts(update_event.status.message.parts))
         # Handle initial task or task without update event
         elif update_event is None and task and hasattr(task, "artifacts") and task.artifacts is not None:
             for artifact in task.artifacts:
                 if hasattr(artifact, "parts"):
-                    for part in artifact.parts:
-                        if hasattr(part, "root") and hasattr(part.root, "text"):
-                            content.append({"text": part.root.text})
+                    content.extend(_extract_content_from_parts(artifact.parts))
     elif isinstance(response, A2AMessage):
-        for part in response.parts:
-            if hasattr(part, "root") and hasattr(part.root, "text"):
-                content.append({"text": part.root.text})
+        content.extend(_extract_content_from_parts(response.parts))
 
     message: Message = {
         "role": "assistant",
diff --git a/src/strands/multiagent/graph.py b/src/strands/multiagent/graph.py
index d296753c0..617100a19 100644
--- a/src/strands/multiagent/graph.py
+++ b/src/strands/multiagent/graph.py
@@ -26,6 +26,7 @@
 
 from .._async import run_async
 from ..agent import Agent
+from ..agent.base import AgentBase
 from ..agent.state import AgentState
 from ..hooks.events import (
     AfterMultiAgentInvocationEvent,
@@ -161,7 +162,7 @@ class GraphNode:
     """Represents a node in the graph."""
 
     node_id: str
-    executor: Agent | MultiAgentBase
+    executor: AgentBase | MultiAgentBase
     dependencies: set["GraphNode"] = field(default_factory=set)
     execution_status: Status = Status.PENDING
     result: NodeResult | None = None
@@ -206,7 +207,7 @@ def __eq__(self, other: Any) -> bool:
 
 
 def _validate_node_executor(
-    executor: Agent | MultiAgentBase, existing_nodes: dict[str, GraphNode] | None = None
+    executor: AgentBase | MultiAgentBase, existing_nodes: dict[str, GraphNode] | None = None
 ) -> None:
     """Validate a node executor for graph compatibility.
 
@@ -245,8 +246,8 @@ def __init__(self) -> None:
         self._session_manager: SessionManager | None = None
         self._hooks: list[HookProvider] | None = None
 
-    def add_node(self, executor: Agent | MultiAgentBase, node_id: str | None = None) -> GraphNode:
-        """Add an Agent or MultiAgentBase instance as a node to the graph."""
+    def add_node(self, executor: AgentBase | MultiAgentBase, node_id: str | None = None) -> GraphNode:
+        """Add an AgentBase or MultiAgentBase instance as a node to the graph."""
         _validate_node_executor(executor, self.nodes)
 
         # Auto-generate node_id if not provided
@@ -854,9 +855,8 @@ async def _execute_node(self, node: GraphNode, invocation_state: dict[str, Any])
         logger.debug("node_id=<%s> | executing node", node.node_id)
 
         # Emit node start event
-        start_event = MultiAgentNodeStartEvent(
-            node_id=node.node_id, node_type="agent" if isinstance(node.executor, Agent) else "multiagent"
-        )
+        node_type = "multiagent" if isinstance(node.executor, MultiAgentBase) else "agent"
+        start_event = MultiAgentNodeStartEvent(node_id=node.node_id, node_type=node_type)
         yield start_event
 
         before_event, interrupts = await self.hooks.invoke_callbacks_async(
@@ -912,8 +912,8 @@ async def _execute_node(self, node: GraphNode, invocation_state: dict[str, Any])
                     execution_count=multi_agent_result.execution_count,
                 )
 
-            elif isinstance(node.executor, Agent):
-                # For agents, stream their events and collect result
+            elif isinstance(node.executor, AgentBase):
+                # For AgentBase implementations (Agent, A2AAgent, etc.), stream events and collect result
                 agent_response = None
                 async for event in node.executor.stream_async(node_input, invocation_state=invocation_state):
                     # Forward agent events with node context
@@ -934,14 +934,18 @@ async def _execute_node(self, node: GraphNode, invocation_state: dict[str, Any])
                 )
                 metrics = getattr(response_metrics, "accumulated_metrics", Metrics(latencyMs=0))
 
+                # Handle stop_reason and interrupts (use getattr for AgentBase compatibility)
+                stop_reason = getattr(agent_response, "stop_reason", "end_turn")
+                interrupts = getattr(agent_response, "interrupts", None) or []
+
                 node_result = NodeResult(
                     result=agent_response,
                     execution_time=round((time.time() - start_time) * 1000),
-                    status=Status.INTERRUPTED if agent_response.stop_reason == "interrupt" else Status.COMPLETED,
+                    status=Status.INTERRUPTED if stop_reason == "interrupt" else Status.COMPLETED,
                     accumulated_usage=usage,
                     accumulated_metrics=metrics,
                     execution_count=1,
-                    interrupts=agent_response.interrupts or [],
+                    interrupts=interrupts,
                 )
             else:
                 raise ValueError(f"Node '{node.node_id}' of type '{type(node.executor)}' is not supported")
diff --git a/tests/strands/multiagent/a2a/test_converters.py b/tests/strands/multiagent/a2a/test_converters.py
index 002ebf6a6..7bad93c37 100644
--- a/tests/strands/multiagent/a2a/test_converters.py
+++ b/tests/strands/multiagent/a2a/test_converters.py
@@ -1,19 +1,37 @@
 """Tests for A2A converter functions."""
 
+import base64
+import logging
 from unittest.mock import MagicMock
 from uuid import uuid4
 
 import pytest
+from a2a.types import (
+    FilePart,
+    FileWithBytes,
+    FileWithUri,
+    Part,
+    Role,
+    TaskArtifactUpdateEvent,
+    TaskStatusUpdateEvent,
+    TextPart,
+)
 from a2a.types import Message as A2AMessage
-from a2a.types import Part, Role, TaskArtifactUpdateEvent, TaskStatusUpdateEvent, TextPart
 
 from strands.agent.agent_result import AgentResult
 from strands.multiagent.a2a._converters import (
+    _convert_document_to_file_part,
+    _convert_file_part_to_content_block,
+    _convert_image_to_file_part,
+    _convert_video_to_file_part,
+    _get_location_from_uri,
     convert_content_blocks_to_parts,
     convert_input_to_message,
     convert_response_to_agent_result,
 )
 
+# --- Input conversion tests (Strands → A2A) ---
+
 
 def test_convert_string_input():
     """Test converting string input to A2A message."""
@@ -123,9 +141,6 @@ def test_convert_multiple_parts_response():
     assert result.message["content"][1]["text"] == "Second"
 
 
-# --- New tests for coverage ---
-
-
 def test_convert_message_list_finds_last_user_message():
     """Test that message list conversion finds the last user message."""
     messages = [
@@ -141,7 +156,7 @@ def test_convert_message_list_finds_last_user_message():
 
 def test_convert_content_blocks_skips_non_text():
     """Test that non-text content blocks are skipped."""
-    content_blocks = [{"text": "Hello"}, {"image": "data"}, {"text": "World"}]
+    content_blocks = [{"text": "Hello"}, {"toolUse": "data"}, {"text": "World"}]
 
     parts = convert_content_blocks_to_parts(content_blocks)
 
@@ -203,3 +218,658 @@ def test_convert_response_handles_missing_data():
     mock_task.artifacts = [mock_artifact]
     result = convert_response_to_agent_result((mock_task, None))
     assert len(result.message["content"]) == 0
+
+
+# --- URI type handling tests ---
+
+
+class TestUriTypeHandling:
+    """Tests for URI type detection and location creation."""
+
+    def test_get_location_from_s3_uri(self):
+        """Test that S3 URIs get type 's3'."""
+        location = _get_location_from_uri("s3://bucket/path/file.png")
+
+        assert location["type"] == "s3"
+        assert location["uri"] == "s3://bucket/path/file.png"
+
+    def test_get_location_from_http_uri(self):
+        """Test that HTTP URIs get type 'url'."""
+        location = _get_location_from_uri("http://example.com/image.png")
+
+        assert location["type"] == "url"
+        assert location["uri"] == "http://example.com/image.png"
+
+    def test_get_location_from_https_uri(self):
+        """Test that HTTPS URIs get type 'url'."""
+        location = _get_location_from_uri("https://cdn.example.com/assets/image.jpg")
+
+        assert location["type"] == "url"
+        assert location["uri"] == "https://cdn.example.com/assets/image.jpg"
+
+    def test_get_location_from_unknown_scheme(self):
+        """Test that unknown URI schemes get type 'uri'."""
+        location = _get_location_from_uri("ftp://server/file.pdf")
+
+        assert location["type"] == "uri"
+        assert location["uri"] == "ftp://server/file.pdf"
+
+    def test_convert_file_part_with_http_uri_to_image(self):
+        """Test converting A2A FilePart with HTTP URI to Strands ImageContent."""
+        file_with_uri = FileWithUri(uri="https://example.com/image.png", mime_type="image/png")
+        file_part = FilePart(file=file_with_uri, kind="file")
+
+        block = _convert_file_part_to_content_block(file_part)
+
+        assert block is not None
+        assert "image" in block
+        assert block["image"]["source"]["location"]["type"] == "url"
+        assert block["image"]["source"]["location"]["uri"] == "https://example.com/image.png"
+
+    def test_convert_file_part_with_s3_uri_to_image(self):
+        """Test converting A2A FilePart with S3 URI to Strands ImageContent."""
+        file_with_uri = FileWithUri(uri="s3://bucket/image.png", mime_type="image/png")
+        file_part = FilePart(file=file_with_uri, kind="file")
+
+        block = _convert_file_part_to_content_block(file_part)
+
+        assert block is not None
+        assert "image" in block
+        assert block["image"]["source"]["location"]["type"] == "s3"
+        assert block["image"]["source"]["location"]["uri"] == "s3://bucket/image.png"
+
+    def test_convert_file_part_with_http_uri_to_document(self):
+        """Test converting A2A FilePart with HTTP URI to Strands DocumentContent."""
+        file_with_uri = FileWithUri(uri="https://example.com/doc.pdf", mime_type="application/pdf", name="doc.pdf")
+        file_part = FilePart(file=file_with_uri, kind="file")
+
+        block = _convert_file_part_to_content_block(file_part)
+
+        assert block is not None
+        assert "document" in block
+        assert block["document"]["source"]["location"]["type"] == "url"
+        assert block["document"]["source"]["location"]["uri"] == "https://example.com/doc.pdf"
+
+    def test_convert_file_part_with_http_uri_to_video(self):
+        """Test converting A2A FilePart with HTTP URI to Strands VideoContent."""
+        file_with_uri = FileWithUri(uri="https://cdn.example.com/video.mp4", mime_type="video/mp4")
+        file_part = FilePart(file=file_with_uri, kind="file")
+
+        block = _convert_file_part_to_content_block(file_part)
+
+        assert block is not None
+        assert "video" in block
+        assert block["video"]["source"]["location"]["type"] == "url"
+        assert block["video"]["source"]["location"]["uri"] == "https://cdn.example.com/video.mp4"
+
+    def test_convert_image_with_http_location_to_file_part(self):
+        """Test converting Strands image with HTTP location to A2A FilePart."""
+        image_content = {
+            "format": "png",
+            "source": {"location": {"type": "url", "uri": "https://example.com/image.png"}},
+        }
+
+        part = _convert_image_to_file_part(image_content)
+
+        assert part is not None
+        assert isinstance(part.root.file, FileWithUri)
+        assert part.root.file.uri == "https://example.com/image.png"
+
+
+# --- Logging tests for dropped content ---
+
+
+class TestLoggingForDroppedContent:
+    """Tests for debug logging when content is dropped."""
+
+    def test_image_empty_source_logs_debug(self, caplog):
+        """Test that dropping image with empty source logs debug message."""
+        image_content = {"format": "png", "source": {}}
+
+        with caplog.at_level(logging.DEBUG, logger="strands.multiagent.a2a._converters"):
+            result = _convert_image_to_file_part(image_content)
+
+        assert result is None
+        assert "image content dropped" in caplog.text
+
+    def test_document_empty_source_logs_debug(self, caplog):
+        """Test that dropping document with empty source logs debug message."""
+        doc_content = {"format": "pdf", "name": "test.pdf", "source": {}}
+
+        with caplog.at_level(logging.DEBUG, logger="strands.multiagent.a2a._converters"):
+            result = _convert_document_to_file_part(doc_content)
+
+        assert result is None
+        assert "document content dropped" in caplog.text
+
+    def test_video_empty_source_logs_debug(self, caplog):
+        """Test that dropping video with empty source logs debug message."""
+        video_content = {"format": "mp4", "source": {}}
+
+        with caplog.at_level(logging.DEBUG, logger="strands.multiagent.a2a._converters"):
+            result = _convert_video_to_file_part(video_content)
+
+        assert result is None
+        assert "video content dropped" in caplog.text
+
+    def test_unsupported_mime_type_logs_debug(self, caplog):
+        """Test that dropping file part with unsupported MIME type logs debug message."""
+        file_with_bytes = FileWithBytes(bytes="dGVzdA==", mime_type="audio/mp3")
+        file_part = FilePart(file=file_with_bytes, kind="file")
+
+        with caplog.at_level(logging.DEBUG, logger="strands.multiagent.a2a._converters"):
+            result = _convert_file_part_to_content_block(file_part)
+
+        assert result is None
+        assert "file part dropped" in caplog.text
+        assert "audio/mp3" in caplog.text
+
+
+# --- Image content conversion tests ---
+
+
+class TestImageConversion:
+    """Tests for image content type conversion."""
+
+    def test_convert_image_with_bytes_to_file_part(self):
+        """Test converting Strands image with inline bytes to A2A FilePart."""
+        image_bytes = b"fake png data"
+        image_content = {
+            "format": "png",
+            "source": {"bytes": image_bytes},
+        }
+
+        part = _convert_image_to_file_part(image_content)
+
+        assert part is not None
+        assert isinstance(part.root, FilePart)
+        assert part.root.file.mime_type == "image/png"
+        assert isinstance(part.root.file, FileWithBytes)
+        assert base64.standard_b64decode(part.root.file.bytes) == image_bytes
+
+    def test_convert_image_with_s3_location_to_file_part(self):
+        """Test converting Strands image with S3 location to A2A FilePart."""
+        image_content = {
+            "format": "jpeg",
+            "source": {"location": {"type": "s3", "uri": "s3://bucket/image.jpg"}},
+        }
+
+        part = _convert_image_to_file_part(image_content)
+
+        assert part is not None
+        assert isinstance(part.root, FilePart)
+        assert part.root.file.mime_type == "image/jpeg"
+        assert isinstance(part.root.file, FileWithUri)
+        assert part.root.file.uri == "s3://bucket/image.jpg"
+
+    def test_convert_image_returns_none_for_empty_source(self):
+        """Test that image conversion returns None when source is empty."""
+        image_content = {"format": "png", "source": {}}
+
+        part = _convert_image_to_file_part(image_content)
+
+        assert part is None
+
+    def test_convert_image_all_formats(self):
+        """Test conversion of all supported image formats."""
+        formats_and_mimes = [
+            ("png", "image/png"),
+            ("jpeg", "image/jpeg"),
+            ("gif", "image/gif"),
+            ("webp", "image/webp"),
+        ]
+
+        for fmt, expected_mime in formats_and_mimes:
+            image_content = {"format": fmt, "source": {"bytes": b"data"}}
+            part = _convert_image_to_file_part(image_content)
+            assert part is not None
+            assert part.root.file.mime_type == expected_mime
+
+    def test_convert_content_blocks_with_image(self):
+        """Test converting content blocks containing images."""
+        content_blocks = [
+            {"text": "Here is an image:"},
+            {"image": {"format": "png", "source": {"bytes": b"png data"}}},
+        ]
+
+        parts = convert_content_blocks_to_parts(content_blocks)
+
+        assert len(parts) == 2
+        assert parts[0].root.text == "Here is an image:"
+        assert isinstance(parts[1].root, FilePart)
+        assert parts[1].root.file.mime_type == "image/png"
+
+
+class TestImageOutputConversion:
+    """Tests for A2A FilePart to Strands image conversion."""
+
+    def test_convert_file_part_to_image_with_bytes(self):
+        """Test converting A2A FilePart with bytes to Strands ImageContent."""
+        raw_bytes = b"image data"
+        b64_str = base64.standard_b64encode(raw_bytes).decode("utf-8")
+        file_with_bytes = FileWithBytes(bytes=b64_str, mime_type="image/png")
+        file_part = FilePart(file=file_with_bytes, kind="file")
+
+        block = _convert_file_part_to_content_block(file_part)
+
+        assert block is not None
+        assert "image" in block
+        assert block["image"]["format"] == "png"
+        assert block["image"]["source"]["bytes"] == raw_bytes
+
+    def test_convert_file_part_to_image_with_uri(self):
+        """Test converting A2A FilePart with URI to Strands ImageContent."""
+        file_with_uri = FileWithUri(uri="s3://bucket/image.jpeg", mime_type="image/jpeg")
+        file_part = FilePart(file=file_with_uri, kind="file")
+
+        block = _convert_file_part_to_content_block(file_part)
+
+        assert block is not None
+        assert "image" in block
+        assert block["image"]["format"] == "jpeg"
+        assert block["image"]["source"]["location"]["uri"] == "s3://bucket/image.jpeg"
+
+    def test_convert_response_with_image_file_part(self):
+        """Test full response conversion with image FilePart."""
+        raw_bytes = b"image content"
+        b64_str = base64.standard_b64encode(raw_bytes).decode("utf-8")
+        file_with_bytes = FileWithBytes(bytes=b64_str, mime_type="image/png")
+        file_part = FilePart(file=file_with_bytes, kind="file")
+
+        a2a_message = A2AMessage(
+            message_id=uuid4().hex,
+            role=Role.agent,
+            parts=[Part(file_part)],
+        )
+
+        result = convert_response_to_agent_result(a2a_message)
+
+        assert len(result.message["content"]) == 1
+        assert "image" in result.message["content"][0]
+        assert result.message["content"][0]["image"]["source"]["bytes"] == raw_bytes
+
+
+# --- Document content conversion tests ---
+
+
+class TestDocumentConversion:
+    """Tests for document content type conversion."""
+
+    def test_convert_document_with_bytes_to_file_part(self):
+        """Test converting Strands document with inline bytes to A2A FilePart."""
+        doc_bytes = b"%PDF-1.4 fake pdf content"
+        doc_content = {
+            "format": "pdf",
+            "name": "report.pdf",
+            "source": {"bytes": doc_bytes},
+        }
+
+        part = _convert_document_to_file_part(doc_content)
+
+        assert part is not None
+        assert isinstance(part.root, FilePart)
+        assert part.root.file.mime_type == "application/pdf"
+        assert isinstance(part.root.file, FileWithBytes)
+        assert base64.standard_b64decode(part.root.file.bytes) == doc_bytes
+        assert part.root.file.name == "report.pdf"
+
+    def test_convert_document_with_s3_location_to_file_part(self):
+        """Test converting Strands document with S3 location to A2A FilePart."""
+        doc_content = {
+            "format": "docx",
+            "name": "document.docx",
+            "source": {"location": {"type": "s3", "uri": "s3://bucket/doc.docx"}},
+        }
+
+        part = _convert_document_to_file_part(doc_content)
+
+        assert part is not None
+        assert isinstance(part.root, FilePart)
+        expected_mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+        assert part.root.file.mime_type == expected_mime
+        assert isinstance(part.root.file, FileWithUri)
+        assert part.root.file.uri == "s3://bucket/doc.docx"
+        assert part.root.file.name == "document.docx"
+
+    def test_convert_document_returns_none_for_empty_source(self):
+        """Test that document conversion returns None when source is empty."""
+        doc_content = {"format": "pdf", "source": {}}
+
+        part = _convert_document_to_file_part(doc_content)
+
+        assert part is None
+
+    def test_convert_document_all_formats(self):
+        """Test conversion of all supported document formats."""
+        formats_and_mimes = [
+            ("pdf", "application/pdf"),
+            ("csv", "text/csv"),
+            ("doc", "application/msword"),
+            ("docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"),
+            ("xls", "application/vnd.ms-excel"),
+            ("xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"),
+            ("html", "text/html"),
+            ("txt", "text/plain"),
+            ("md", "text/markdown"),
+        ]
+
+        for fmt, expected_mime in formats_and_mimes:
+            doc_content = {"format": fmt, "source": {"bytes": b"data"}}
+            part = _convert_document_to_file_part(doc_content)
+            assert part is not None, f"Failed for format {fmt}"
+            assert part.root.file.mime_type == expected_mime, f"MIME mismatch for format {fmt}"
+
+    def test_convert_content_blocks_with_document(self):
+        """Test converting content blocks containing documents."""
+        content_blocks = [
+            {"text": "Here is a document:"},
+            {"document": {"format": "pdf", "name": "test.pdf", "source": {"bytes": b"pdf data"}}},
+        ]
+
+        parts = convert_content_blocks_to_parts(content_blocks)
+
+        assert len(parts) == 2
+        assert parts[0].root.text == "Here is a document:"
+        assert isinstance(parts[1].root, FilePart)
+        assert parts[1].root.file.mime_type == "application/pdf"
+        assert parts[1].root.file.name == "test.pdf"
+
+
+class TestDocumentOutputConversion:
+    """Tests for A2A FilePart to Strands document conversion."""
+
+    def test_convert_file_part_to_document_with_bytes(self):
+        """Test converting A2A FilePart with bytes to Strands DocumentContent."""
+        raw_bytes = b"document data"
+        b64_str = base64.standard_b64encode(raw_bytes).decode("utf-8")
+        file_with_bytes = FileWithBytes(bytes=b64_str, mime_type="application/pdf", name="test.pdf")
+        file_part = FilePart(file=file_with_bytes, kind="file")
+
+        block = _convert_file_part_to_content_block(file_part)
+
+        assert block is not None
+        assert "document" in block
+        assert block["document"]["format"] == "pdf"
+        assert block["document"]["source"]["bytes"] == raw_bytes
+        assert block["document"]["name"] == "test.pdf"
+
+    def test_convert_file_part_to_document_with_uri(self):
+        """Test converting A2A FilePart with URI to Strands DocumentContent."""
+        file_with_uri = FileWithUri(uri="s3://bucket/doc.csv", mime_type="text/csv", name="data.csv")
+        file_part = FilePart(file=file_with_uri, kind="file")
+
+        block = _convert_file_part_to_content_block(file_part)
+
+        assert block is not None
+        assert "document" in block
+        assert block["document"]["format"] == "csv"
+        assert block["document"]["source"]["location"]["uri"] == "s3://bucket/doc.csv"
+        assert block["document"]["name"] == "data.csv"
+
+    def test_convert_response_with_document_file_part(self):
+        """Test full response conversion with document FilePart."""
+        raw_bytes = b"document content"
+        b64_str = base64.standard_b64encode(raw_bytes).decode("utf-8")
+        file_with_bytes = FileWithBytes(bytes=b64_str, mime_type="application/pdf", name="report.pdf")
+        file_part = FilePart(file=file_with_bytes, kind="file")
+
+        a2a_message = A2AMessage(
+            message_id=uuid4().hex,
+            role=Role.agent,
+            parts=[Part(file_part)],
+        )
+
+        result = convert_response_to_agent_result(a2a_message)
+
+        assert len(result.message["content"]) == 1
+        assert "document" in result.message["content"][0]
+        assert result.message["content"][0]["document"]["source"]["bytes"] == raw_bytes
+
+
+# --- Video content conversion tests ---
+
+
+class TestVideoConversion:
+    """Tests for video content type conversion."""
+
+    def test_convert_video_with_bytes_to_file_part(self):
+        """Test converting Strands video with inline bytes to A2A FilePart."""
+        video_bytes = b"fake mp4 video data"
+        video_content = {
+            "format": "mp4",
+            "source": {"bytes": video_bytes},
+        }
+
+        part = _convert_video_to_file_part(video_content)
+
+        assert part is not None
+        assert isinstance(part.root, FilePart)
+        assert part.root.file.mime_type == "video/mp4"
+        assert isinstance(part.root.file, FileWithBytes)
+        assert base64.standard_b64decode(part.root.file.bytes) == video_bytes
+
+    def test_convert_video_with_s3_location_to_file_part(self):
+        """Test converting Strands video with S3 location to A2A FilePart."""
+        video_content = {
+            "format": "webm",
+            "source": {"location": {"type": "s3", "uri": "s3://bucket/video.webm"}},
+        }
+
+        part = _convert_video_to_file_part(video_content)
+
+        assert part is not None
+        assert isinstance(part.root, FilePart)
+        assert part.root.file.mime_type == "video/webm"
+        assert isinstance(part.root.file, FileWithUri)
+        assert part.root.file.uri == "s3://bucket/video.webm"
+
+    def test_convert_video_returns_none_for_empty_source(self):
+        """Test that video conversion returns None when source is empty."""
+        video_content = {"format": "mp4", "source": {}}
+
+        part = _convert_video_to_file_part(video_content)
+
+        assert part is None
+
+    def test_convert_video_all_formats(self):
+        """Test conversion of all supported video formats."""
+        formats_and_mimes = [
+            ("flv", "video/x-flv"),
+            ("mkv", "video/x-matroska"),
+            ("mov", "video/quicktime"),
+            ("mpeg", "video/mpeg"),
+            ("mpg", "video/mpeg"),
+            ("mp4", "video/mp4"),
+            ("three_gp", "video/3gpp"),
+            ("webm", "video/webm"),
+            ("wmv", "video/x-ms-wmv"),
+        ]
+
+        for fmt, expected_mime in formats_and_mimes:
+            video_content = {"format": fmt, "source": {"bytes": b"data"}}
+            part = _convert_video_to_file_part(video_content)
+            assert part is not None, f"Failed for format {fmt}"
+            assert part.root.file.mime_type == expected_mime, f"MIME mismatch for format {fmt}"
+
+    def test_convert_content_blocks_with_video(self):
+        """Test converting content blocks containing videos."""
+        content_blocks = [
+            {"text": "Here is a video:"},
+            {"video": {"format": "mp4", "source": {"bytes": b"video data"}}},
+        ]
+
+        parts = convert_content_blocks_to_parts(content_blocks)
+
+        assert len(parts) == 2
+        assert parts[0].root.text == "Here is a video:"
+        assert isinstance(parts[1].root, FilePart)
+        assert parts[1].root.file.mime_type == "video/mp4"
+
+
+class TestVideoOutputConversion:
+    """Tests for A2A FilePart to Strands video conversion."""
+
+    def test_convert_file_part_to_video_with_bytes(self):
+        """Test converting A2A FilePart with bytes to Strands VideoContent."""
+        raw_bytes = b"video data"
+        b64_str = base64.standard_b64encode(raw_bytes).decode("utf-8")
+        file_with_bytes = FileWithBytes(bytes=b64_str, mime_type="video/mp4")
+        file_part = FilePart(file=file_with_bytes, kind="file")
+
+        block = _convert_file_part_to_content_block(file_part)
+
+        assert block is not None
+        assert "video" in block
+        assert block["video"]["format"] == "mp4"
+        assert block["video"]["source"]["bytes"] == raw_bytes
+
+    def test_convert_file_part_to_video_with_uri(self):
+        """Test converting A2A FilePart with URI to Strands VideoContent."""
+        file_with_uri = FileWithUri(uri="s3://bucket/video.webm", mime_type="video/webm")
+        file_part = FilePart(file=file_with_uri, kind="file")
+
+        block = _convert_file_part_to_content_block(file_part)
+
+        assert block is not None
+        assert "video" in block
+        assert block["video"]["format"] == "webm"
+        assert block["video"]["source"]["location"]["uri"] == "s3://bucket/video.webm"
+
+    def test_convert_response_with_video_file_part(self):
+        """Test full response conversion with video FilePart."""
+        raw_bytes = b"video content"
+        b64_str = base64.standard_b64encode(raw_bytes).decode("utf-8")
+        file_with_bytes = FileWithBytes(bytes=b64_str, mime_type="video/mp4")
+        file_part = FilePart(file=file_with_bytes, kind="file")
+
+        a2a_message = A2AMessage(
+            message_id=uuid4().hex,
+            role=Role.agent,
+            parts=[Part(file_part)],
+        )
+
+        result = convert_response_to_agent_result(a2a_message)
+
+        assert len(result.message["content"]) == 1
+        assert "video" in result.message["content"][0]
+        assert result.message["content"][0]["video"]["source"]["bytes"] == raw_bytes
+
+
+# --- Mixed content and edge case tests ---
+
+
+class TestMixedContentConversion:
+    """Tests for mixed content type conversion."""
+
+    def test_convert_content_blocks_with_all_types(self):
+        """Test converting content blocks with text, image, document, and video."""
+        content_blocks = [
+            {"text": "Introduction"},
+            {"image": {"format": "png", "source": {"bytes": b"image"}}},
+            {"document": {"format": "pdf", "name": "doc.pdf", "source": {"bytes": b"doc"}}},
+            {"video": {"format": "mp4", "source": {"bytes": b"video"}}},
+            {"text": "Conclusion"},
+        ]
+
+        parts = convert_content_blocks_to_parts(content_blocks)
+
+        assert len(parts) == 5
+        assert parts[0].root.text == "Introduction"
+        assert isinstance(parts[1].root, FilePart)
+        assert parts[1].root.file.mime_type == "image/png"
+        assert isinstance(parts[2].root, FilePart)
+        assert parts[2].root.file.mime_type == "application/pdf"
+        assert isinstance(parts[3].root, FilePart)
+        assert parts[3].root.file.mime_type == "video/mp4"
+        assert parts[4].root.text == "Conclusion"
+
+    def test_convert_response_with_mixed_parts(self):
+        """Test response conversion with mixed text and file parts."""
+        raw_bytes = b"image data"
+        b64_str = base64.standard_b64encode(raw_bytes).decode("utf-8")
+        file_with_bytes = FileWithBytes(bytes=b64_str, mime_type="image/png")
+        file_part = FilePart(file=file_with_bytes, kind="file")
+
+        a2a_message = A2AMessage(
+            message_id=uuid4().hex,
+            role=Role.agent,
+            parts=[
+                Part(TextPart(kind="text", text="Here is an image:")),
+                Part(file_part),
+            ],
+        )
+
+        result = convert_response_to_agent_result(a2a_message)
+
+        assert len(result.message["content"]) == 2
+        assert result.message["content"][0]["text"] == "Here is an image:"
+        assert "image" in result.message["content"][1]
+
+    def test_convert_file_part_with_unknown_mime_type(self):
+        """Test that unknown MIME types return None."""
+        file_with_bytes = FileWithBytes(bytes="dGVzdA==", mime_type="application/x-unknown")
+        file_part = FilePart(file=file_with_bytes, kind="file")
+
+        block = _convert_file_part_to_content_block(file_part)
+
+        # application/* falls back to document conversion
+        assert block is not None
+        assert "document" in block
+
+    def test_convert_file_part_with_generic_image_mime(self):
+        """Test that generic image/* MIME types are handled as images."""
+        raw_bytes = b"image data"
+        b64_str = base64.standard_b64encode(raw_bytes).decode("utf-8")
+        file_with_bytes = FileWithBytes(bytes=b64_str, mime_type="image/x-custom")
+        file_part = FilePart(file=file_with_bytes, kind="file")
+
+        block = _convert_file_part_to_content_block(file_part)
+
+        assert block is not None
+        assert "image" in block
+        # Falls back to png format for unknown image types
+        assert block["image"]["format"] == "png"
+
+    def test_convert_file_part_with_generic_video_mime(self):
+        """Test that generic video/* MIME types are handled as videos."""
+        raw_bytes = b"video data"
+        b64_str = base64.standard_b64encode(raw_bytes).decode("utf-8")
+        file_with_bytes = FileWithBytes(bytes=b64_str, mime_type="video/x-custom")
+        file_part = FilePart(file=file_with_bytes, kind="file")
+
+        block = _convert_file_part_to_content_block(file_part)
+
+        assert block is not None
+        assert "video" in block
+        # Falls back to mp4 format for unknown video types
+        assert block["video"]["format"] == "mp4"
+
+    def test_convert_file_part_with_no_mime_type(self):
+        """Test conversion when MIME type is missing."""
+        file_with_bytes = FileWithBytes(bytes="dGVzdA==")  # No mime_type specified
+        file_part = FilePart(file=file_with_bytes, kind="file")
+
+        block = _convert_file_part_to_content_block(file_part)
+
+        # Defaults to application/octet-stream which falls back to document
+        assert block is not None
+        assert "document" in block
+
+    def test_convert_input_message_with_image(self):
+        """Test converting input message containing images."""
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"text": "What is in this image?"},
+                    {"image": {"format": "jpeg", "source": {"bytes": b"jpeg data"}}},
+                ],
+            }
+        ]
+
+        message = convert_input_to_message(messages)
+
+        assert len(message.parts) == 2
+        assert message.parts[0].root.text == "What is in this image?"
+        assert isinstance(message.parts[1].root, FilePart)
+        assert message.parts[1].root.file.mime_type == "image/jpeg"
diff --git a/tests/strands/multiagent/test_graph.py b/tests/strands/multiagent/test_graph.py
index c511328d4..52a50c75d 100644
--- a/tests/strands/multiagent/test_graph.py
+++ b/tests/strands/multiagent/test_graph.py
@@ -2259,3 +2259,58 @@ def test_graph_interrupt_on_agent(agenerator):
     assert len(multiagent_result.results) == 1
 
     agent.stream_async.assert_called_once_with(responses, invocation_state={})
+
+
+@pytest.mark.asyncio
+async def test_graph_with_agentbase_implementation(mock_strands_tracer, mock_use_span):
+    """Test that Graph accepts any AgentBase implementation (not just Agent)."""
+    from strands.agent.base import AgentBase
+
+    # Create a minimal AgentBase implementation
+    class CustomAgentBase:
+        """Custom AgentBase implementation for testing."""
+
+        def __init__(self, name: str, response_text: str):
+            self.name = name
+            self.id = f"{name}_id"
+            self._response_text = response_text
+
+        def __call__(self, prompt=None, **kwargs):
+            return AgentResult(
+                message={"role": "assistant", "content": [{"text": self._response_text}]},
+                stop_reason="end_turn",
+                state={},
+                metrics=Mock(
+                    accumulated_usage={"inputTokens": 10, "outputTokens": 20, "totalTokens": 30},
+                    accumulated_metrics={"latencyMs": 100.0},
+                ),
+            )
+
+        async def invoke_async(self, prompt=None, **kwargs):
+            return self(prompt, **kwargs)
+
+        async def stream_async(self, prompt=None, **kwargs):
+            yield {"start": True}
+            yield {"result": self(prompt, **kwargs)}
+
+    # Verify it satisfies AgentBase protocol
+    custom_agent = CustomAgentBase("custom", "Custom response")
+    assert isinstance(custom_agent, AgentBase)
+
+    # Create a regular mock agent
+    regular_agent = create_mock_agent("regular", "Regular response")
+
+    # Build graph with both
+    builder = GraphBuilder()
+    builder.add_node(custom_agent, "custom_node")
+    builder.add_node(regular_agent, "regular_node")
+    builder.add_edge("custom_node", "regular_node")
+    builder.set_entry_point("custom_node")
+    graph = builder.build()
+
+    result = await graph.invoke_async("Test task")
+
+    assert result.status == Status.COMPLETED
+    assert result.completed_nodes == 2
+    assert "custom_node" in result.results
+    assert "regular_node" in result.results
diff --git a/tests_integ/a2a/test_multiagent_a2a.py b/tests_integ/a2a/test_multiagent_a2a.py
index 60cbc9ce5..8b0186bc5 100644
--- a/tests_integ/a2a/test_multiagent_a2a.py
+++ b/tests_integ/a2a/test_multiagent_a2a.py
@@ -6,7 +6,9 @@
 import pytest
 from a2a.client import ClientConfig, ClientFactory
 
+from strands import Agent
 from strands.agent.a2a_agent import A2AAgent
+from strands.multiagent.graph import GraphBuilder, Status
 
 
 @pytest.fixture
@@ -70,3 +72,33 @@ async def test_a2a_agent_with_non_streaming_client_config(a2a_server):
         assert result.stop_reason == "end_turn"
     finally:
         await httpx_client.aclose()
+
+
+@pytest.mark.asyncio
+async def test_graph_with_a2a_agent_and_regular_agent(a2a_server):
+    """Test Graph execution with both A2AAgent and regular Agent nodes."""
+    # Create A2AAgent pointing to the test server
+    a2a_agent = A2AAgent(endpoint=a2a_server, name="remote_agent")
+
+    # Create a regular Agent
+    regular_agent = Agent(
+        model="us.amazon.nova-lite-v1:0",
+        system_prompt="You are a summarizer. Summarize the input briefly.",
+        name="summarizer",
+    )
+
+    # Build graph with both agent types
+    builder = GraphBuilder()
+    builder.add_node(a2a_agent, "remote")
+    builder.add_node(regular_agent, "summarizer")
+    builder.add_edge("remote", "summarizer")
+    builder.set_entry_point("remote")
+    graph = builder.build()
+
+    # Execute the graph
+    result = await graph.invoke_async("Say hello in one sentence")
+
+    assert result.status == Status.COMPLETED
+    assert result.completed_nodes == 2
+    assert "remote" in result.results
+    assert "summarizer" in result.results