meta-ads-mcp 0.4.6__tar.gz → 0.4.8__tar.gz

{meta_ads_mcp-0.4.6 → meta_ads_mcp-0.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meta-ads-mcp
-Version: 0.4.6
+Version: 0.4.8
 Summary: Model Context Protocol (MCP) plugin for interacting with Meta Ads API
 Project-URL: Homepage, https://github.com/pipeboard-co/meta-ads-mcp
 Project-URL: Bug Tracker, https://github.com/pipeboard-co/meta-ads-mcp/issues

{meta_ads_mcp-0.4.6 → meta_ads_mcp-0.4.8}/meta_ads_mcp/__init__.py

@@ -7,7 +7,7 @@ with the Claude LLM.
 
 from meta_ads_mcp.core.server import main
 
-__version__ = "0.4.6"
+__version__ = "0.4.8"
 
 __all__ = [
     'get_ad_accounts',

{meta_ads_mcp-0.4.6 → meta_ads_mcp-0.4.8}/meta_ads_mcp/core/ads.py

@@ -10,7 +10,7 @@ import time
 
 from .api import meta_api_tool, make_api_request
 from .accounts import get_ad_accounts
-from .utils import download_image, try_multiple_download_methods, ad_creative_images
+from .utils import download_image, try_multiple_download_methods, ad_creative_images, extract_creative_image_urls
 from .server import mcp_server
 
 
@@ -179,7 +179,7 @@ async def get_ad_creatives(access_token: str = None, ad_id: str = None) -> str:
     # Add image URLs for direct viewing if available
     if 'data' in data:
         for creative in data['data']:
-            creative['image_urls_for_viewing'] = ad_creative_images(creative)
+            creative['image_urls_for_viewing'] = extract_creative_image_urls(creative)
 
     return json.dumps(data, indent=2)
 
@@ -251,14 +251,27 @@ async def get_ad_image(access_token: str = None, ad_id: str = None) -> Image:
     if not image_hashes:
         # If no hashes found, try to extract from the first creative we found in the API
         # Get creative for ad to try to extract hash
-        creative_json = await get_ad_creatives(ad_id, "", access_token)
-        creative_data = json.loads(creative_json)
-        
-        # Try to extract hash from asset_feed_spec
-        if "asset_feed_spec" in creative_data and "images" in creative_data["asset_feed_spec"]:
-            images = creative_data["asset_feed_spec"]["images"]
-            if images and len(images) > 0 and "hash" in images[0]:
-                image_hashes.append(images[0]["hash"])
+        creative_json = await get_ad_creatives(access_token=access_token, ad_id=ad_id)
+        # The result is wrapped by @meta_api_tool, so we need to extract the data
+        creative_wrapper = json.loads(creative_json)
+        creative_data = json.loads(creative_wrapper["data"])
+        
+        # Try to extract hash from data array
+        if "data" in creative_data and creative_data["data"]:
+            for creative in creative_data["data"]:
+                # Check object_story_spec for image hash
+                if "object_story_spec" in creative and "link_data" in creative["object_story_spec"]:
+                    link_data = creative["object_story_spec"]["link_data"]
+                    if "image_hash" in link_data:
+                        image_hashes.append(link_data["image_hash"])
+                # Check direct image_hash on creative
+                elif "image_hash" in creative:
+                    image_hashes.append(creative["image_hash"])
+                # Check asset_feed_spec for image hashes
+                elif "asset_feed_spec" in creative and "images" in creative["asset_feed_spec"]:
+                    images = creative["asset_feed_spec"]["images"]
+                    if images and len(images) > 0 and "hash" in images[0]:
+                        image_hashes.append(images[0]["hash"])
     
     if not image_hashes:
         return "Error: No image hashes found in creative"
@@ -380,7 +393,9 @@ async def save_ad_image_locally(access_token: str = None, ad_id: str = None, out
     if not image_hashes:
         # Fallback attempt (as in get_ad_image)
         creative_json = await get_ad_creatives(ad_id=ad_id, access_token=access_token) # Ensure ad_id is passed correctly
-        creative_data_list = json.loads(creative_json)
+        # The result is wrapped by @meta_api_tool, so we need to extract the data
+        creative_wrapper = json.loads(creative_json)
+        creative_data_list = json.loads(creative_wrapper["data"])
         if 'data' in creative_data_list and creative_data_list['data']:
              first_creative = creative_data_list['data'][0]
              if 'object_story_spec' in first_creative and 'link_data' in first_creative['object_story_spec'] and 'image_hash' in first_creative['object_story_spec']['link_data']:

{meta_ads_mcp-0.4.6 → meta_ads_mcp-0.4.8}/meta_ads_mcp/core/utils.py

@@ -1,6 +1,6 @@
 """Utility functions for Meta Ads API."""
 
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, List
 import httpx
 import io
 from PIL import Image as PILImage
@@ -74,6 +74,64 @@ logger = setup_logging()
 # Global store for ad creative images
 ad_creative_images = {}
 
+
+def extract_creative_image_urls(creative: Dict[str, Any]) -> List[str]:
+    """
+    Extract image URLs from a creative object for direct viewing.
+    
+    Args:
+        creative: Meta Ads creative object
+        
+    Returns:
+        List of image URLs found in the creative
+    """
+    image_urls = []
+    
+    # Check for direct image_url field
+    if "image_url" in creative and creative["image_url"]:
+        image_urls.append(creative["image_url"])
+    
+    # Check for thumbnail_url field
+    if "thumbnail_url" in creative and creative["thumbnail_url"]:
+        image_urls.append(creative["thumbnail_url"])
+    
+    # Check object_story_spec for image URLs
+    if "object_story_spec" in creative:
+        story_spec = creative["object_story_spec"]
+        
+        # Check link_data for image fields
+        if "link_data" in story_spec:
+            link_data = story_spec["link_data"]
+            
+            # Check for picture field
+            if "picture" in link_data and link_data["picture"]:
+                image_urls.append(link_data["picture"])
+                
+            # Check for image_url field in link_data
+            if "image_url" in link_data and link_data["image_url"]:
+                image_urls.append(link_data["image_url"])
+        
+        # Check video_data for thumbnail (if present)
+        if "video_data" in story_spec and "image_url" in story_spec["video_data"]:
+            image_urls.append(story_spec["video_data"]["image_url"])
+    
+    # Check asset_feed_spec for multiple images
+    if "asset_feed_spec" in creative and "images" in creative["asset_feed_spec"]:
+        for image in creative["asset_feed_spec"]["images"]:
+            if "url" in image and image["url"]:
+                image_urls.append(image["url"])
+    
+    # Remove duplicates while preserving order
+    seen = set()
+    unique_urls = []
+    for url in image_urls:
+        if url not in seen:
+            seen.add(url)
+            unique_urls.append(url)
+    
+    return unique_urls
+
+
 async def download_image(url: str) -> Optional[bytes]:
     """
     Download an image from a URL.

{meta_ads_mcp-0.4.6 → meta_ads_mcp-0.4.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "meta-ads-mcp"
-version = "0.4.6"
+version = "0.4.8"
 description = "Model Context Protocol (MCP) plugin for interacting with Meta Ads API"
 readme = "README.md"
 requires-python = ">=3.10"

meta_ads_mcp-0.4.8/tests/test_get_ad_creatives_fix.py

@@ -0,0 +1,154 @@
+"""Regression tests for get_ad_creatives function bug fix.
+
+Tests for issue where get_ad_creatives would throw:
+'TypeError: 'dict' object is not callable'
+
+This was caused by trying to call ad_creative_images(creative) where 
+ad_creative_images is a dictionary, not a function.
+
+The fix was to create extract_creative_image_urls() function and use that instead.
+"""
+
+import pytest
+import json
+from unittest.mock import AsyncMock, patch
+from meta_ads_mcp.core.ads import get_ad_creatives
+from meta_ads_mcp.core.utils import ad_creative_images
+
+
+@pytest.mark.asyncio
+class TestGetAdCreativesBugFix:
+    """Regression test cases for the get_ad_creatives function bug fix."""
+    
+    async def test_get_ad_creatives_regression_fix(self):
+        """Regression test: ensure get_ad_creatives works correctly and doesn't throw 'dict' object is not callable."""
+        
+        # Mock the make_api_request to return sample creative data
+        sample_creative_data = {
+            "data": [
+                {
+                    "id": "123456789",
+                    "name": "Test Creative",
+                    "status": "ACTIVE",
+                    "thumbnail_url": "https://example.com/thumb.jpg",
+                    "image_url": "https://example.com/image.jpg",
+                    "image_hash": "abc123",
+                    "object_story_spec": {
+                        "page_id": "987654321",
+                        "link_data": {
+                            "image_hash": "abc123",
+                            "link": "https://example.com",
+                            "name": "Test Ad"
+                        }
+                    }
+                }
+            ]
+        }
+        
+        with patch('meta_ads_mcp.core.ads.make_api_request', new_callable=AsyncMock) as mock_api:
+            mock_api.return_value = sample_creative_data
+            
+            # This should NOT raise a TypeError anymore
+            # Previously this would fail with: TypeError: 'dict' object is not callable
+            result = await get_ad_creatives(access_token="test_token", ad_id="120228922933270272")
+            
+            # Parse the result
+            result_data = json.loads(result)
+            
+            # Verify the structure is correct
+            assert "data" in result_data
+            assert len(result_data["data"]) == 1
+            
+            creative = result_data["data"][0]
+            assert creative["id"] == "123456789"
+            assert creative["name"] == "Test Creative"
+            assert "image_urls_for_viewing" in creative
+            assert isinstance(creative["image_urls_for_viewing"], list)
+    
+    async def test_extract_creative_image_urls_function(self):
+        """Test the extract_creative_image_urls function works correctly."""
+        from meta_ads_mcp.core.utils import extract_creative_image_urls
+        
+        # Test creative with various image URL fields
+        test_creative = {
+            "id": "123456789",
+            "name": "Test Creative",
+            "status": "ACTIVE",
+            "thumbnail_url": "https://example.com/thumb.jpg",
+            "image_url": "https://example.com/image.jpg",
+            "image_hash": "abc123",
+            "object_story_spec": {
+                "page_id": "987654321",
+                "link_data": {
+                    "image_hash": "abc123",
+                    "link": "https://example.com",
+                    "name": "Test Ad",
+                    "picture": "https://example.com/picture.jpg"
+                }
+            }
+        }
+        
+        urls = extract_creative_image_urls(test_creative)
+        
+        # Should extract URLs in order: image_url, thumbnail_url, picture
+        expected_urls = [
+            "https://example.com/image.jpg",
+            "https://example.com/thumb.jpg", 
+            "https://example.com/picture.jpg"
+        ]
+        
+        assert urls == expected_urls
+        
+        # Test with empty creative
+        empty_urls = extract_creative_image_urls({})
+        assert empty_urls == []
+        
+        # Test with duplicates (should remove them)
+        duplicate_creative = {
+            "image_url": "https://example.com/same.jpg",
+            "thumbnail_url": "https://example.com/same.jpg",  # Same URL
+        }
+        unique_urls = extract_creative_image_urls(duplicate_creative)
+        assert unique_urls == ["https://example.com/same.jpg"]
+    
+    async def test_get_ad_creatives_no_ad_id(self):
+        """Test get_ad_creatives with no ad_id provided."""
+        
+        result = await get_ad_creatives(access_token="test_token", ad_id=None)
+        result_data = json.loads(result)
+        
+        # The @meta_api_tool decorator wraps the result in a data field
+        assert "data" in result_data
+        error_data = json.loads(result_data["data"])
+        assert "error" in error_data
+        assert error_data["error"] == "No ad ID provided"
+
+    async def test_get_ad_creatives_empty_data(self):
+        """Test get_ad_creatives when API returns empty data."""
+        
+        empty_data = {"data": []}
+        
+        with patch('meta_ads_mcp.core.ads.make_api_request', new_callable=AsyncMock) as mock_api:
+            mock_api.return_value = empty_data
+            
+            result = await get_ad_creatives(access_token="test_token", ad_id="120228922933270272")
+            result_data = json.loads(result)
+            
+            assert "data" in result_data
+            assert len(result_data["data"]) == 0
+
+
+def test_ad_creative_images_is_dict():
+    """Test that ad_creative_images is a dictionary, not a function.
+    
+    This confirms the original issue: ad_creative_images is a dict for storing image data,
+    but was being called as a function ad_creative_images(creative), which would fail.
+    This test ensures we don't accidentally change ad_creative_images to a function
+    and break its intended purpose as a storage dictionary.
+    """
+    assert isinstance(ad_creative_images, dict)
+    
+    # This would raise TypeError: 'dict' object is not callable
+    # This is the original bug - trying to call a dict as a function
+    with pytest.raises(TypeError, match="'dict' object is not callable"):
+        ad_creative_images({"test": "data"}) 

meta_ads_mcp-0.4.8/tests/test_get_ad_image_regression.py

@@ -0,0 +1,188 @@
+"""Regression tests for get_ad_image function JSON parsing fix.
+
+Tests for issue where get_ad_image would throw:
+'TypeError: the JSON object must be str, bytes or bytearray, not dict'
+
+This was caused by:
+1. Wrong parameter order when calling get_ad_creatives (ad_id, "", access_token instead of access_token=x, ad_id=y)
+2. Incorrect JSON parsing of the @meta_api_tool decorator wrapped response
+
+The fix:
+1. Corrected the parameter order in get_ad_creatives calls
+2. Updated JSON parsing to handle the wrapped response format: {"data": "JSON_STRING"}
+"""
+
+import pytest
+import json
+from unittest.mock import AsyncMock, patch, MagicMock
+from meta_ads_mcp.core.ads import get_ad_image
+
+
+@pytest.mark.asyncio
+class TestGetAdImageRegressionFix:
+    """Regression test cases for the get_ad_image JSON parsing bug fix."""
+    
+    async def test_get_ad_image_json_parsing_regression_fix(self):
+        """Regression test: ensure get_ad_image doesn't throw JSON parsing error."""
+        
+        # Mock responses for the main API flow
+        mock_ad_data = {
+            "account_id": "act_123456789",
+            "creative": {"id": "creative_123456789"}
+        }
+        
+        mock_creative_details = {
+            "id": "creative_123456789",
+            "name": "Test Creative", 
+            "image_hash": "test_hash_123"
+        }
+        
+        mock_image_data = {
+            "data": [{
+                "hash": "test_hash_123",
+                "url": "https://example.com/image.jpg",
+                "width": 1200,
+                "height": 628,
+                "name": "test_image.jpg",
+                "status": "ACTIVE"
+            }]
+        }
+        
+        # Mock PIL Image processing to return a valid Image object
+        mock_pil_image = MagicMock()
+        mock_pil_image.mode = "RGB"
+        mock_pil_image.convert.return_value = mock_pil_image
+        
+        mock_byte_stream = MagicMock()
+        mock_byte_stream.getvalue.return_value = b"fake_jpeg_data"
+        
+        with patch('meta_ads_mcp.core.ads.make_api_request', new_callable=AsyncMock) as mock_api, \
+             patch('meta_ads_mcp.core.ads.download_image', new_callable=AsyncMock) as mock_download, \
+             patch('meta_ads_mcp.core.ads.PILImage.open') as mock_pil_open, \
+             patch('meta_ads_mcp.core.ads.io.BytesIO') as mock_bytesio:
+            
+            mock_api.side_effect = [mock_ad_data, mock_creative_details, mock_image_data]
+            mock_download.return_value = b"fake_image_bytes"
+            mock_pil_open.return_value = mock_pil_image
+            mock_bytesio.return_value = mock_byte_stream
+            
+            # This should NOT raise "the JSON object must be str, bytes or bytearray, not dict"
+            # Previously this would fail with: TypeError: the JSON object must be str, bytes or bytearray, not dict
+            result = await get_ad_image(access_token="test_token", ad_id="120228922871870272")
+            
+            # Verify we get an Image object (success) - the exact test depends on the mocking
+            # The key is that we don't get the JSON parsing error
+            assert result is not None
+            
+            # The main regression check: if we got here without an exception, the JSON parsing is fixed
+            # We might get different results based on mocking, but the critical JSON parsing should work
+            
+    async def test_get_ad_image_fallback_path_json_parsing(self):
+        """Test the fallback path that calls get_ad_creatives handles JSON parsing correctly."""
+        
+        # Mock responses that trigger the fallback path (no direct image hash)
+        mock_ad_data = {
+            "account_id": "act_123456789",
+            "creative": {"id": "creative_123456789"}
+        }
+        
+        mock_creative_details = {
+            "id": "creative_123456789",
+            "name": "Test Creative"
+            # No image_hash - this will trigger the fallback
+        }
+        
+        # Mock get_ad_creatives response (wrapped format that caused the original bug)
+        mock_get_ad_creatives_response = json.dumps({
+            "data": json.dumps({
+                "data": [
+                    {
+                        "id": "creative_123456789",
+                        "name": "Test Creative",
+                        "object_story_spec": {
+                            "link_data": {
+                                "image_hash": "fallback_hash_123"
+                            }
+                        }
+                    }
+                ]
+            })
+        })
+        
+        mock_image_data = {
+            "data": [{
+                "hash": "fallback_hash_123",
+                "url": "https://example.com/fallback_image.jpg",
+                "width": 1200,
+                "height": 628
+            }]
+        }
+        
+        # Mock PIL Image processing
+        mock_pil_image = MagicMock()
+        mock_pil_image.mode = "RGB"
+        mock_pil_image.convert.return_value = mock_pil_image
+        
+        mock_byte_stream = MagicMock()
+        mock_byte_stream.getvalue.return_value = b"fake_jpeg_data"
+        
+        with patch('meta_ads_mcp.core.ads.make_api_request', new_callable=AsyncMock) as mock_api, \
+             patch('meta_ads_mcp.core.ads.get_ad_creatives', new_callable=AsyncMock) as mock_get_creatives, \
+             patch('meta_ads_mcp.core.ads.download_image', new_callable=AsyncMock) as mock_download, \
+             patch('meta_ads_mcp.core.ads.PILImage.open') as mock_pil_open, \
+             patch('meta_ads_mcp.core.ads.io.BytesIO') as mock_bytesio:
+            
+            mock_api.side_effect = [mock_ad_data, mock_creative_details, mock_image_data]
+            mock_get_creatives.return_value = mock_get_ad_creatives_response
+            mock_download.return_value = b"fake_image_bytes"
+            mock_pil_open.return_value = mock_pil_image
+            mock_bytesio.return_value = mock_byte_stream
+            
+            # This should handle the wrapped JSON response correctly
+            # Previously would fail: TypeError: the JSON object must be str, bytes or bytearray, not dict
+            result = await get_ad_image(access_token="test_token", ad_id="120228922871870272")
+            
+            # Verify the fallback path worked - key is no JSON parsing exception
+            assert result is not None
+            # Verify get_ad_creatives was called (fallback path was triggered)
+            mock_get_creatives.assert_called_once()
+    
+    async def test_get_ad_image_no_ad_id(self):
+        """Test get_ad_image with no ad_id provided."""
+        
+        result = await get_ad_image(access_token="test_token", ad_id=None)
+        
+        # Should return error string, not throw JSON parsing error
+        assert isinstance(result, str)
+        assert "Error: No ad ID provided" in result
+    
+    async def test_get_ad_image_parameter_order_regression(self):
+        """Regression test: ensure get_ad_creatives is called with correct parameter order."""
+        
+        # This test ensures we don't regress to calling get_ad_creatives(ad_id, "", access_token)
+        # which was the original bug
+        
+        mock_ad_data = {
+            "account_id": "act_123456789", 
+            "creative": {"id": "creative_123456789"}
+        }
+        
+        mock_creative_details = {
+            "id": "creative_123456789",
+            "name": "Test Creative"
+            # No image_hash to trigger fallback
+        }
+        
+        with patch('meta_ads_mcp.core.ads.make_api_request', new_callable=AsyncMock) as mock_api, \
+             patch('meta_ads_mcp.core.ads.get_ad_creatives', new_callable=AsyncMock) as mock_get_creatives:
+            
+            mock_api.side_effect = [mock_ad_data, mock_creative_details]
+            mock_get_creatives.return_value = json.dumps({"data": json.dumps({"data": []})})
+            
+            # Call get_ad_image - it should reach the fallback path
+            result = await get_ad_image(access_token="test_token", ad_id="test_ad_id")
+            
+            # Verify get_ad_creatives was called with correct parameter names (not positional)
+            mock_get_creatives.assert_called_once_with(ad_id="test_ad_id", access_token="test_token")
+            
+            # The key regression test: this should not have raised a JSON parsing error