adcp 1.0.3__tar.gz → 1.0.5__tar.gz

{adcp-1.0.3/src/adcp.egg-info → adcp-1.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: adcp
-Version: 1.0.3
+Version: 1.0.5
 Summary: Official Python client for the Ad Context Protocol (AdCP)
 Author-email: AdCP Community <maintainers@adcontextprotocol.org>
 License: Apache-2.0

{adcp-1.0.3 → adcp-1.0.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "adcp"
-version = "1.0.3"
+version = "1.0.5"
 description = "Official Python client for the Ad Context Protocol (AdCP)"
 authors = [
     {name = "AdCP Community", email = "maintainers@adcontextprotocol.org"}

{adcp-1.0.3 → adcp-1.0.5}/src/adcp/__init__.py

@@ -46,7 +46,7 @@ from adcp.types.generated import (
     UpdateMediaBuyResponse,
 )
 
-__version__ = "1.0.3"
+__version__ = "1.0.5"
 
 __all__ = [
     # Client classes

{adcp-1.0.3 → adcp-1.0.5}/src/adcp/__main__.py

@@ -23,37 +23,38 @@ from adcp.types.core import AgentConfig, Protocol
 
 def print_json(data: Any) -> None:
     """Print data as JSON."""
-    print(json.dumps(data, indent=2, default=str))
+    from pydantic import BaseModel
+
+    # Handle Pydantic models
+    if isinstance(data, BaseModel):
+        print(data.model_dump_json(indent=2, exclude_none=True))
+    else:
+        print(json.dumps(data, indent=2, default=str))
 
 
 def print_result(result: Any, json_output: bool = False) -> None:
     """Print result in formatted or JSON mode."""
     if json_output:
-        print_json(
-            {
-                "status": result.status.value,
-                "success": result.success,
-                "data": result.data,
-                "error": result.error,
-                "metadata": result.metadata,
-                "debug_info": (
-                    {
-                        "request": result.debug_info.request,
-                        "response": result.debug_info.response,
-                        "duration_ms": result.debug_info.duration_ms,
-                    }
-                    if result.debug_info
-                    else None
-                ),
-            }
-        )
+        # Match JavaScript client: output just the data for scripting
+        if result.success and result.data:
+            print_json(result.data)
+        else:
+            # On error, output error info
+            print_json({"error": result.error, "success": False})
     else:
-        print(f"\nStatus: {result.status.value}")
+        # Pretty output with message and data (like JavaScript client)
         if result.success:
+            print("\nSUCCESS\n")
+            # Show protocol message if available
+            if hasattr(result, "message") and result.message:
+                print("Protocol Message:")
+                print(result.message)
+                print()
             if result.data:
-                print("\nResult:")
+                print("Response:")
                 print_json(result.data)
         else:
+            print("\nFAILED\n")
             print(f"Error: {result.error}")
 
 

{adcp-1.0.3 → adcp-1.0.5}/src/adcp/protocols/base.py

@@ -49,6 +49,7 @@ class ProtocolAdapter(ABC):
             return TaskResult[T](
                 status=raw_result.status,
                 data=None,
+                message=raw_result.message,
                 success=False,
                 error=raw_result.error or "No data returned from adapter",
                 metadata=raw_result.metadata,
@@ -66,6 +67,7 @@ class ProtocolAdapter(ABC):
             return TaskResult[T](
                 status=raw_result.status,
                 data=parsed_data,
+                message=raw_result.message,  # Preserve human-readable message from protocol
                 success=raw_result.success,
                 error=raw_result.error,
                 metadata=raw_result.metadata,
@@ -76,6 +78,7 @@ class ProtocolAdapter(ABC):
             return TaskResult[T](
                 status=TaskStatus.FAILED,
                 error=f"Failed to parse response: {e}",
+                message=raw_result.message,
                 success=False,
                 debug_info=raw_result.debug_info,
             )

{adcp-1.0.3 → adcp-1.0.5}/src/adcp/protocols/mcp.py

@@ -186,6 +186,40 @@ class MCPAdapter(ProtocolAdapter):
         else:
             raise ValueError(f"Unsupported transport scheme: {parsed.scheme}")
 
+    def _serialize_mcp_content(self, content: list[Any]) -> list[dict[str, Any]]:
+        """
+        Convert MCP SDK content objects to plain dicts.
+
+        The MCP SDK returns Pydantic objects (TextContent, ImageContent, etc.)
+        but the rest of the ADCP client expects protocol-agnostic dicts.
+        This method handles the translation at the protocol boundary.
+
+        Args:
+            content: List of MCP content items (may be dicts or Pydantic objects)
+
+        Returns:
+            List of plain dicts representing the content
+        """
+        result = []
+        for item in content:
+            # Already a dict, pass through
+            if isinstance(item, dict):
+                result.append(item)
+            # Pydantic v2 model with model_dump()
+            elif hasattr(item, "model_dump"):
+                result.append(item.model_dump())
+            # Pydantic v1 model with dict()
+            elif hasattr(item, "dict") and callable(item.dict):
+                result.append(item.dict())
+            # Fallback: try to access __dict__
+            elif hasattr(item, "__dict__"):
+                result.append(dict(item.__dict__))
+            # Last resort: serialize as unknown type
+            else:
+                logger.warning(f"Unknown MCP content type: {type(item)}, serializing as string")
+                result.append({"type": "unknown", "data": str(item)})
+        return result
+
     async def _call_mcp_tool(self, tool_name: str, params: dict[str, Any]) -> TaskResult[Any]:
         """Call a tool using MCP protocol."""
         start_time = time.time() if self.agent_config.debug else None
@@ -205,22 +239,49 @@ class MCPAdapter(ProtocolAdapter):
             # Call the tool using MCP client session
             result = await session.call_tool(tool_name, params)
 
+            # This SDK requires MCP tools to return structuredContent
+            # The content field may contain human-readable messages but the actual
+            # response data must be in structuredContent
+            if not hasattr(result, "structuredContent") or result.structuredContent is None:
+                raise ValueError(
+                    f"MCP tool {tool_name} did not return structuredContent. "
+                    f"This SDK requires MCP tools to provide structured responses. "
+                    f"Got content: {result.content if hasattr(result, 'content') else 'none'}"
+                )
+
+            # Extract the structured data (required)
+            data_to_return = result.structuredContent
+
+            # Extract human-readable message from content (optional)
+            # This is typically a status message like "Found 42 creative formats"
+            message_text = None
+            if hasattr(result, "content") and result.content:
+                # Serialize content using the same method used for backward compatibility
+                serialized_content = self._serialize_mcp_content(result.content)
+                if isinstance(serialized_content, list):
+                    for item in serialized_content:
+                        is_text = isinstance(item, dict) and item.get("type") == "text"
+                        if is_text and item.get("text"):
+                            message_text = item["text"]
+                            break
+
             if self.agent_config.debug and start_time:
                 duration_ms = (time.time() - start_time) * 1000
                 debug_info = DebugInfo(
                     request=debug_request,
                     response={
-                        "content": result.content,
+                        "data": data_to_return,
+                        "message": message_text,
                         "is_error": result.isError if hasattr(result, "isError") else False,
                     },
                     duration_ms=duration_ms,
                 )
 
-            # MCP tool results contain a list of content items
-            # For AdCP, we expect the data in the content
+            # Return both the structured data and the human-readable message
             return TaskResult[Any](
                 status=TaskStatus.COMPLETED,
-                data=result.content,
+                data=data_to_return,
+                message=message_text,
                 success=True,
                 debug_info=debug_info,
             )

{adcp-1.0.3 → adcp-1.0.5}/src/adcp/types/core.py

@@ -127,6 +127,7 @@ class TaskResult(BaseModel, Generic[T]):
 
     status: TaskStatus
     data: T | None = None
+    message: str | None = None  # Human-readable message from agent (e.g., MCP content text)
     submitted: SubmittedInfo | None = None
     needs_input: NeedsInputInfo | None = None
     error: str | None = None

{adcp-1.0.3 → adcp-1.0.5}/src/adcp/utils/response_parser.py

@@ -20,10 +20,13 @@ def parse_mcp_content(content: list[dict[str, Any]], response_type: type[T]) ->
     MCP tools return content as a list of content items:
     [{"type": "text", "text": "..."}, {"type": "resource", ...}]
 
+    The MCP adapter is responsible for serializing MCP SDK Pydantic objects
+    to plain dicts before calling this function.
+
     For AdCP, we expect JSON data in text content items.
 
     Args:
-        content: MCP content array
+        content: MCP content array (list of plain dicts)
         response_type: Expected Pydantic model type
 
     Returns:

{adcp-1.0.3 → adcp-1.0.5/src/adcp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: adcp
-Version: 1.0.3
+Version: 1.0.5
 Summary: Official Python client for the Ad Context Protocol (AdCP)
 Author-email: AdCP Community <maintainers@adcontextprotocol.org>
 License: Apache-2.0

{adcp-1.0.3 → adcp-1.0.5}/tests/test_protocols.py

@@ -155,13 +155,15 @@ class TestMCPAdapter:
 
     @pytest.mark.asyncio
     async def test_call_tool_success(self, mcp_config):
-        """Test successful tool call via MCP."""
+        """Test successful tool call via MCP with proper structuredContent."""
         adapter = MCPAdapter(mcp_config)
 
         # Mock MCP session
         mock_session = AsyncMock()
         mock_result = MagicMock()
+        # Mock MCP result with structuredContent (required for AdCP)
         mock_result.content = [{"type": "text", "text": "Success"}]
+        mock_result.structuredContent = {"products": [{"id": "prod1"}]}
         mock_session.call_tool.return_value = mock_result
 
         with patch.object(adapter, "_get_session", return_value=mock_session):
@@ -175,10 +177,53 @@ class TestMCPAdapter:
             assert call_args[0][0] == "get_products"
             assert call_args[0][1] == {"brief": "test"}
 
-            # Verify result parsing
+            # Verify result uses structuredContent
+            assert result.success is True
+            assert result.status == TaskStatus.COMPLETED
+            assert result.data == {"products": [{"id": "prod1"}]}
+
+    @pytest.mark.asyncio
+    async def test_call_tool_with_structured_content(self, mcp_config):
+        """Test successful tool call via MCP with structuredContent field."""
+        adapter = MCPAdapter(mcp_config)
+
+        # Mock MCP session
+        mock_session = AsyncMock()
+        mock_result = MagicMock()
+        # Mock MCP result with structuredContent (preferred over content)
+        mock_result.content = [{"type": "text", "text": "Found 42 creative formats"}]
+        mock_result.structuredContent = {"formats": [{"id": "format1"}, {"id": "format2"}]}
+        mock_session.call_tool.return_value = mock_result
+
+        with patch.object(adapter, "_get_session", return_value=mock_session):
+            result = await adapter._call_mcp_tool("list_creative_formats", {})
+
+            # Verify result uses structuredContent, not content array
             assert result.success is True
             assert result.status == TaskStatus.COMPLETED
-            assert result.data == [{"type": "text", "text": "Success"}]
+            assert result.data == {"formats": [{"id": "format1"}, {"id": "format2"}]}
+            # Verify message extraction from content array
+            assert result.message == "Found 42 creative formats"
+
+    @pytest.mark.asyncio
+    async def test_call_tool_missing_structured_content(self, mcp_config):
+        """Test tool call fails when structuredContent is missing."""
+        adapter = MCPAdapter(mcp_config)
+
+        mock_session = AsyncMock()
+        mock_result = MagicMock()
+        # Mock MCP result WITHOUT structuredContent (invalid for AdCP)
+        mock_result.content = [{"type": "text", "text": "Success"}]
+        mock_result.structuredContent = None
+        mock_session.call_tool.return_value = mock_result
+
+        with patch.object(adapter, "_get_session", return_value=mock_session):
+            result = await adapter._call_mcp_tool("get_products", {"brief": "test"})
+
+            # Verify error handling for missing structuredContent
+            assert result.success is False
+            assert result.status == TaskStatus.FAILED
+            assert "did not return structuredContent" in result.error
 
     @pytest.mark.asyncio
     async def test_call_tool_error(self, mcp_config):
@@ -240,3 +285,59 @@ class TestMCPAdapter:
         mock_exit_stack.aclose.assert_called_once()
         assert adapter._exit_stack is None
         assert adapter._session is None
+
+    def test_serialize_mcp_content_with_dicts(self, mcp_config):
+        """Test serializing MCP content that's already dicts."""
+        adapter = MCPAdapter(mcp_config)
+
+        content = [
+            {"type": "text", "text": "Hello"},
+            {"type": "resource", "uri": "file://test.txt"},
+        ]
+
+        result = adapter._serialize_mcp_content(content)
+
+        assert result == content  # Pass through unchanged
+        assert len(result) == 2
+
+    def test_serialize_mcp_content_with_pydantic_v2(self, mcp_config):
+        """Test serializing MCP content with Pydantic v2 objects."""
+        from pydantic import BaseModel
+
+        adapter = MCPAdapter(mcp_config)
+
+        class MockTextContent(BaseModel):
+            type: str
+            text: str
+
+        content = [
+            MockTextContent(type="text", text="Pydantic v2"),
+        ]
+
+        result = adapter._serialize_mcp_content(content)
+
+        assert len(result) == 1
+        assert result[0] == {"type": "text", "text": "Pydantic v2"}
+        assert isinstance(result[0], dict)
+
+    def test_serialize_mcp_content_mixed(self, mcp_config):
+        """Test serializing mixed MCP content (dicts and Pydantic objects)."""
+        from pydantic import BaseModel
+
+        adapter = MCPAdapter(mcp_config)
+
+        class MockTextContent(BaseModel):
+            type: str
+            text: str
+
+        content = [
+            {"type": "text", "text": "Plain dict"},
+            MockTextContent(type="text", text="Pydantic object"),
+        ]
+
+        result = adapter._serialize_mcp_content(content)
+
+        assert len(result) == 2
+        assert result[0] == {"type": "text", "text": "Plain dict"}
+        assert result[1] == {"type": "text", "text": "Pydantic object"}
+        assert all(isinstance(item, dict) for item in result)