fix: handle Pydantic TextContent objects in MCP response parser

The MCP SDK returns Pydantic TextContent objects, not plain dicts.
The response_parser.py was using .get() method which only works on dicts,
causing AttributeError: 'TextContent' object has no attribute 'get'.

This change adds a helper function that handles both dict and Pydantic
object access patterns, ensuring compatibility with both the MCP SDK's
actual return types and the test suite's mock dicts.

Tests added for:
- Pydantic TextContent objects
- Mixed dict and Pydantic content
- Empty Pydantic text content handling

Fixes regression introduced in v1.0.3 where parsing logic was added
that assumed dict objects.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: bokelley

src/adcp/utils/response_parser.py

@@ -13,17 +13,20 @@
 T = TypeVar("T", bound=BaseModel)
 
 
-def parse_mcp_content(content: list[dict[str, Any]], response_type: type[T]) -> T:
+def parse_mcp_content(content: list[dict[str, Any] | Any], response_type: type[T]) -> T:
     """
     Parse MCP content array into structured response type.
 
     MCP tools return content as a list of content items:
     [{"type": "text", "text": "..."}, {"type": "resource", ...}]
 
+    Content items may be either plain dicts or Pydantic objects (TextContent, etc.)
+    depending on the MCP SDK version and usage pattern.
+
     For AdCP, we expect JSON data in text content items.
 
     Args:
-        content: MCP content array
+        content: MCP content array (list of dicts or Pydantic objects)
         response_type: Expected Pydantic model type
 
     Returns:
@@ -35,10 +38,19 @@ def parse_mcp_content(content: list[dict[str, Any]], response_type: type[T]) ->
     if not content:
         raise ValueError("Empty MCP content array")
 
+    # Helper to get field value from dict or object
+    def get_field(item: Any, field: str, default: Any = None) -> Any:
+        """Get field from dict or Pydantic object."""
+        if isinstance(item, dict):
+            return item.get(field, default)
+        return getattr(item, field, default)
+
     # Look for text content items that might contain JSON
     for item in content:
-        if item.get("type") == "text":
-            text = item.get("text", "")
+        item_type = get_field(item, "type")
+
+        if item_type == "text":
+            text = get_field(item, "text", "")
             if not text:
                 continue
 
@@ -55,7 +67,7 @@ def parse_mcp_content(content: list[dict[str, Any]], response_type: type[T]) ->
                     f"MCP content doesn't match expected schema {response_type.__name__}: {e}"
                 )
                 raise ValueError(f"MCP response doesn't match expected schema: {e}") from e
-        elif item.get("type") == "resource":
+        elif item_type == "resource":
             # Resource content might have structured data
             try:
                 return response_type.model_validate(item)
@@ -69,9 +81,12 @@ def parse_mcp_content(content: list[dict[str, Any]], response_type: type[T]) ->
     if len(content_preview) > 500:
         content_preview = content_preview[:500] + "..."
 
+    # Extract types for error message
+    content_types = [get_field(item, "type") for item in content]
+
     raise ValueError(
         f"No valid {response_type.__name__} data found in MCP content. "
-        f"Content types: {[item.get('type') for item in content]}. "
+        f"Content types: {content_types}. "
         f"Content preview:\n{content_preview}"
     )
 

tests/test_response_parser.py

@@ -18,6 +18,13 @@ class SampleResponse(BaseModel):
     items: list[str] = Field(default_factory=list)
 
 
+class MockTextContent(BaseModel):
+    """Mock MCP TextContent object for testing."""
+
+    type: str = "text"
+    text: str
+
+
 class TestParseMCPContent:
     """Tests for parse_mcp_content function."""
 
@@ -92,6 +99,50 @@ def test_empty_text_content_skipped(self):
         result = parse_mcp_content(content, SampleResponse)
         assert result.message == "Found"
 
+    def test_parse_pydantic_text_content(self):
+        """Test parsing MCP Pydantic TextContent objects."""
+        content = [
+            MockTextContent(
+                type="text",
+                text=json.dumps({"message": "Pydantic", "count": 99, "items": ["x", "y"]}),
+            )
+        ]
+
+        result = parse_mcp_content(content, SampleResponse)
+
+        assert isinstance(result, SampleResponse)
+        assert result.message == "Pydantic"
+        assert result.count == 99
+        assert result.items == ["x", "y"]
+
+    def test_parse_mixed_dict_and_pydantic_content(self):
+        """Test parsing MCP content with both dicts and Pydantic objects."""
+        content = [
+            {"type": "text", "text": "Not JSON"},
+            MockTextContent(
+                type="text",
+                text=json.dumps({"message": "Mixed", "count": 15}),
+            ),
+        ]
+
+        result = parse_mcp_content(content, SampleResponse)
+
+        assert result.message == "Mixed"
+        assert result.count == 15
+
+    def test_parse_pydantic_empty_text_skipped(self):
+        """Test that empty Pydantic text content is skipped."""
+        content = [
+            MockTextContent(type="text", text=""),
+            MockTextContent(
+                type="text",
+                text=json.dumps({"message": "Skip", "count": 7}),
+            ),
+        ]
+
+        result = parse_mcp_content(content, SampleResponse)
+        assert result.message == "Skip"
+
 
 class TestParseJSONOrText:
     """Tests for parse_json_or_text function."""