meta-ads-mcp 0.7.10__py3-none-any.whl → 0.9.0__py3-none-any.whl

meta_ads_mcp/__init__.py

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

meta_ads_mcp/core/ads.py

@@ -519,6 +519,7 @@ async def update_ad(
     status: str = None,
     bid_amount: int = None,
     tracking_specs = None,
+    creative_id: str = None,
     access_token: str = None
 ) -> str:
     """
@@ -529,6 +530,7 @@ async def update_ad(
         status: Update ad status (ACTIVE, PAUSED, etc.)
         bid_amount: Bid amount in account currency (in cents for USD)
         tracking_specs: Optional tracking specifications (e.g., for pixel events).
+        creative_id: ID of the creative to associate with this ad (changes the ad's image/content)
         access_token: Meta API access token (optional - will use cached token if not provided)
     """
     if not ad_id:
@@ -542,14 +544,19 @@ async def update_ad(
         params["bid_amount"] = str(bid_amount)
     if tracking_specs is not None: # Add tracking_specs to params if provided
         params["tracking_specs"] = json.dumps(tracking_specs) # Needs to be JSON encoded string
+    if creative_id is not None:
+        # Creative parameter needs to be a JSON object containing creative_id
+        params["creative"] = json.dumps({"creative_id": creative_id})
 
     if not params:
-        return json.dumps({"error": "No update parameters provided (status, bid_amount, or tracking_specs)"}, indent=2)
+        return json.dumps({"error": "No update parameters provided (status, bid_amount, tracking_specs, or creative_id)"}, indent=2)
 
     endpoint = f"{ad_id}"
-    data = await make_api_request(endpoint, access_token, params, method='POST')
-
-    return json.dumps(data, indent=2)
+    try:
+        data = await make_api_request(endpoint, access_token, params, method='POST')
+        return json.dumps(data, indent=2)
+    except Exception as e:
+        return json.dumps({"error": f"Failed to update ad: {str(e)}"}, indent=2)
 
 
 @mcp_server.tool()
@@ -633,7 +640,10 @@ async def create_ad_creative(
     link_url: str = None,
     message: str = None,
     headline: str = None,
+    headlines: List[str] = None,
     description: str = None,
+    descriptions: List[str] = None,
+    dynamic_creative_spec: Dict[str, Any] = None,
     call_to_action_type: str = None,
     instagram_actor_id: str = None
 ) -> str:
@@ -648,8 +658,11 @@ async def create_ad_creative(
         page_id: Facebook Page ID to be used for the ad
         link_url: Destination URL for the ad
         message: Ad copy/text
-        headline: Ad headline
-        description: Ad description
+        headline: Single headline for simple ads (cannot be used with headlines)
+        headlines: List of headlines for dynamic creative testing (cannot be used with headline)
+        description: Single description for simple ads (cannot be used with descriptions)
+        descriptions: List of descriptions for dynamic creative testing (cannot be used with description)
+        dynamic_creative_spec: Dynamic creative optimization settings
         call_to_action_type: Call to action button type (e.g., 'LEARN_MORE', 'SIGN_UP', 'SHOP_NOW')
         instagram_actor_id: Optional Instagram account ID for Instagram placements
     
@@ -697,29 +710,98 @@ async def create_ad_creative(
                 "suggestion": "Please provide a page_id parameter or use get_account_pages to find available pages"
             }, indent=2)
     
+    # Validate headline/description parameters - cannot mix simple and complex
+    if headline and headlines:
+        return json.dumps({"error": "Cannot specify both 'headline' and 'headlines'. Use 'headline' for single headline or 'headlines' for multiple."}, indent=2)
+    
+    if description and descriptions:
+        return json.dumps({"error": "Cannot specify both 'description' and 'descriptions'. Use 'description' for single description or 'descriptions' for multiple."}, indent=2)
+    
+    # Convert simple parameters to complex format for internal processing
+    final_headlines = None
+    final_descriptions = None
+    
+    if headline:
+        final_headlines = [headline]
+    elif headlines:
+        final_headlines = headlines
+        
+    if description:
+        final_descriptions = [description]
+    elif descriptions:
+        final_descriptions = descriptions
+    
+    # Validate dynamic creative parameters
+    if final_headlines:
+        if len(final_headlines) > 5:
+            return json.dumps({"error": "Maximum 5 headlines allowed for dynamic creatives"}, indent=2)
+        for i, h in enumerate(final_headlines):
+            if len(h) > 40:
+                return json.dumps({"error": f"Headline {i+1} exceeds 40 character limit"}, indent=2)
+    
+    if final_descriptions:
+        if len(final_descriptions) > 5:
+            return json.dumps({"error": "Maximum 5 descriptions allowed for dynamic creatives"}, indent=2)
+        for i, d in enumerate(final_descriptions):
+            if len(d) > 125:
+                return json.dumps({"error": f"Description {i+1} exceeds 125 character limit"}, indent=2)
+    
     # Prepare the creative data
     creative_data = {
-        "name": name,
-        "object_story_spec": {
+        "name": name
+    }
+    
+    # Choose between asset_feed_spec (dynamic creative) or object_story_spec (traditional)
+    if final_headlines or final_descriptions:
+        # Use asset_feed_spec for dynamic creatives
+        asset_feed_spec = {
+            "ad_formats": ["SINGLE_IMAGE"],
+            "images": [{"hash": image_hash}],
+            "link_urls": [{"website_url": link_url if link_url else "https://facebook.com"}]
+        }
+        
+        # Handle headlines
+        if final_headlines:
+            asset_feed_spec["headlines"] = [{"text": headline_text} for headline_text in final_headlines]
+            
+        # Handle descriptions  
+        if final_descriptions:
+            asset_feed_spec["descriptions"] = [{"text": description_text} for description_text in final_descriptions]
+        
+        # Add message as primary_texts if provided
+        if message:
+            asset_feed_spec["primary_texts"] = [{"text": message}]
+        
+        # Add call_to_action_types if provided
+        if call_to_action_type:
+            asset_feed_spec["call_to_action_types"] = [call_to_action_type]
+        
+        creative_data["asset_feed_spec"] = asset_feed_spec
+        
+        # For dynamic creatives, we need a simplified object_story_spec
+        creative_data["object_story_spec"] = {
+            "page_id": page_id
+        }
+    else:
+        # Use traditional object_story_spec for single creative
+        creative_data["object_story_spec"] = {
             "page_id": page_id,
             "link_data": {
                 "image_hash": image_hash,
                 "link": link_url if link_url else "https://facebook.com"
             }
         }
-    }
-    
-    # Add optional parameters if provided
-    if message:
-        creative_data["object_story_spec"]["link_data"]["message"] = message
-    
-    if headline:
-        creative_data["object_story_spec"]["link_data"]["name"] = headline
         
-    if description:
-        creative_data["object_story_spec"]["link_data"]["description"] = description
+        # Add optional parameters if provided
+        if message:
+            creative_data["object_story_spec"]["link_data"]["message"] = message
     
-    if call_to_action_type:
+    # Add dynamic creative spec if provided
+    if dynamic_creative_spec:
+        creative_data["dynamic_creative_spec"] = dynamic_creative_spec
+    
+    # Only add call_to_action to object_story_spec if we're not using asset_feed_spec
+    if call_to_action_type and "asset_feed_spec" not in creative_data:
         creative_data["object_story_spec"]["link_data"]["call_to_action"] = {
             "type": call_to_action_type
         }
@@ -739,7 +821,7 @@ async def create_ad_creative(
             creative_id = data["id"]
             creative_endpoint = f"{creative_id}"
             creative_params = {
-                "fields": "id,name,status,thumbnail_url,image_url,image_hash,object_story_spec,url_tags,link_url"
+                "fields": "id,name,status,thumbnail_url,image_url,image_hash,object_story_spec,asset_feed_spec,url_tags,link_url"
             }
             
             creative_details = await make_api_request(creative_endpoint, access_token, creative_params)
@@ -759,6 +841,154 @@ async def create_ad_creative(
         }, indent=2)
 
 
+@mcp_server.tool()
+@meta_api_tool
+async def update_ad_creative(
+    access_token: str = None,
+    creative_id: str = None,
+    name: str = None,
+    message: str = None,
+    headline: str = None,
+    headlines: List[str] = None,
+    description: str = None,
+    descriptions: List[str] = None,
+    dynamic_creative_spec: Dict[str, Any] = None,
+    call_to_action_type: str = None
+) -> str:
+    """
+    Update an existing ad creative with new content or settings.
+    
+    Args:
+        access_token: Meta API access token (optional - will use cached token if not provided)
+        creative_id: Meta Ads creative ID to update
+        name: New creative name
+        message: New ad copy/text
+        headline: Single headline for simple ads (cannot be used with headlines)
+        headlines: New list of headlines for dynamic creative testing (cannot be used with headline)
+        description: Single description for simple ads (cannot be used with descriptions)
+        descriptions: New list of descriptions for dynamic creative testing (cannot be used with description)
+        dynamic_creative_spec: New dynamic creative optimization settings
+        call_to_action_type: New call to action button type
+    
+    Returns:
+        JSON response with updated creative details
+    """
+    # Check required parameters
+    if not creative_id:
+        return json.dumps({"error": "No creative ID provided"}, indent=2)
+    
+    # Validate headline/description parameters - cannot mix simple and complex
+    if headline and headlines:
+        return json.dumps({"error": "Cannot specify both 'headline' and 'headlines'. Use 'headline' for single headline or 'headlines' for multiple."}, indent=2)
+    
+    if description and descriptions:
+        return json.dumps({"error": "Cannot specify both 'description' and 'descriptions'. Use 'description' for single description or 'descriptions' for multiple."}, indent=2)
+    
+    # Convert simple parameters to complex format for internal processing
+    final_headlines = None
+    final_descriptions = None
+    
+    if headline:
+        final_headlines = [headline]
+    elif headlines:
+        final_headlines = headlines
+        
+    if description:
+        final_descriptions = [description]
+    elif descriptions:
+        final_descriptions = descriptions
+    
+    # Validate dynamic creative parameters
+    if final_headlines:
+        if len(final_headlines) > 5:
+            return json.dumps({"error": "Maximum 5 headlines allowed for dynamic creatives"}, indent=2)
+        for i, h in enumerate(final_headlines):
+            if len(h) > 40:
+                return json.dumps({"error": f"Headline {i+1} exceeds 40 character limit"}, indent=2)
+    
+    if final_descriptions:
+        if len(final_descriptions) > 5:
+            return json.dumps({"error": "Maximum 5 descriptions allowed for dynamic creatives"}, indent=2)
+        for i, d in enumerate(final_descriptions):
+            if len(d) > 125:
+                return json.dumps({"error": f"Description {i+1} exceeds 125 character limit"}, indent=2)
+    
+    # Prepare the update data
+    update_data = {}
+    
+    if name:
+        update_data["name"] = name
+    
+    if message:
+        update_data["object_story_spec"] = {"link_data": {"message": message}}
+    
+    # Handle dynamic creative assets via asset_feed_spec
+    if final_headlines or final_descriptions or dynamic_creative_spec:
+        asset_feed_spec = {}
+        
+        # Add required ad_formats field for dynamic creatives
+        asset_feed_spec["ad_formats"] = ["SINGLE_IMAGE"]
+        
+        # Handle headlines
+        if final_headlines:
+            asset_feed_spec["headlines"] = [{"text": headline_text} for headline_text in final_headlines]
+            
+        # Handle descriptions  
+        if final_descriptions:
+            asset_feed_spec["descriptions"] = [{"text": description_text} for description_text in final_descriptions]
+        
+        # Add message as primary_texts if provided
+        if message:
+            asset_feed_spec["primary_texts"] = [{"text": message}]
+        
+        update_data["asset_feed_spec"] = asset_feed_spec
+    
+    # Add dynamic creative spec if provided
+    if dynamic_creative_spec:
+        update_data["dynamic_creative_spec"] = dynamic_creative_spec
+    
+    # Handle call_to_action - add to asset_feed_spec if using dynamic creative, otherwise to object_story_spec
+    if call_to_action_type:
+        if "asset_feed_spec" in update_data:
+            update_data["asset_feed_spec"]["call_to_action_types"] = [call_to_action_type]
+        else:
+            if "object_story_spec" not in update_data:
+                update_data["object_story_spec"] = {"link_data": {}}
+            update_data["object_story_spec"]["link_data"]["call_to_action"] = {
+                "type": call_to_action_type
+            }
+    
+    # Prepare the API endpoint for updating the creative
+    endpoint = f"{creative_id}"
+    
+    try:
+        # Make API request to update the creative
+        data = await make_api_request(endpoint, access_token, update_data, method="POST")
+        
+        # If successful, get more details about the updated creative
+        if "id" in data:
+            creative_endpoint = f"{creative_id}"
+            creative_params = {
+                "fields": "id,name,status,thumbnail_url,image_url,image_hash,object_story_spec,url_tags,link_url,dynamic_creative_spec"
+            }
+            
+            creative_details = await make_api_request(creative_endpoint, access_token, creative_params)
+            return json.dumps({
+                "success": True,
+                "creative_id": creative_id,
+                "details": creative_details
+            }, indent=2)
+        
+        return json.dumps(data, indent=2)
+    
+    except Exception as e:
+        return json.dumps({
+            "error": "Failed to update ad creative",
+            "details": str(e),
+            "update_data_sent": update_data
+        }, indent=2)
+
+
 async def _discover_pages_for_account(account_id: str, access_token: str) -> dict:
     """
     Internal function to discover pages for an account using multiple approaches.
@@ -982,69 +1212,143 @@ async def get_account_pages(access_token: str = None, account_id: str = None) ->
         account_id = f"act_{account_id}"
     
     try:
-        # Try all approaches that might work
+        # Collect all page IDs from multiple approaches
+        all_page_ids = set()
         
-        # Approach 1: Get active ads and extract page IDs
-        endpoint = f"{account_id}/ads"
-        params = {
-            "fields": "creative{object_story_spec{page_id}}",
-            "limit": 100
-        }
+        # Approach 1: Get user's personal pages (broad scope)
+        try:
+            endpoint = "me/accounts"
+            params = {
+                "fields": "id,name,username,category,fan_count,link,verification_status,picture"
+            }
+            user_pages_data = await make_api_request(endpoint, access_token, params)
+            if "data" in user_pages_data:
+                for page in user_pages_data["data"]:
+                    if "id" in page:
+                        all_page_ids.add(page["id"])
+        except Exception:
+            pass
         
-        ads_data = await make_api_request(endpoint, access_token, params)
+        # Approach 2: Try business manager pages
+        try:
+            # Strip 'act_' prefix to get raw account ID for business endpoints
+            raw_account_id = account_id.replace("act_", "")
+            endpoint = f"{raw_account_id}/owned_pages"
+            params = {
+                "fields": "id,name,username,category,fan_count,link,verification_status,picture"
+            }
+            business_pages_data = await make_api_request(endpoint, access_token, params)
+            if "data" in business_pages_data:
+                for page in business_pages_data["data"]:
+                    if "id" in page:
+                        all_page_ids.add(page["id"])
+        except Exception:
+            pass
         
-        # Extract unique page IDs from ads
-        page_ids = set()
-        if "data" in ads_data:
-            for ad in ads_data.get("data", []):
-                if "creative" in ad and "creative" in ad and "object_story_spec" in ad["creative"] and "page_id" in ad["creative"]["object_story_spec"]:
-                    page_ids.add(ad["creative"]["object_story_spec"]["page_id"])
+        # Approach 3: Try ad account client pages
+        try:
+            endpoint = f"{account_id}/client_pages"
+            params = {
+                "fields": "id,name,username,category,fan_count,link,verification_status,picture"
+            }
+            client_pages_data = await make_api_request(endpoint, access_token, params)
+            if "data" in client_pages_data:
+                for page in client_pages_data["data"]:
+                    if "id" in page:
+                        all_page_ids.add(page["id"])
+        except Exception:
+            pass
         
-        # If we found page IDs, get details for each
-        if page_ids:
-            page_details = {"data": []}
+        # Approach 4: Extract page IDs from all ad creatives (broader creative search)
+        try:
+            endpoint = f"{account_id}/adcreatives"
+            params = {
+                "fields": "id,name,object_story_spec,link_url,call_to_action,image_hash",
+                "limit": 100
+            }
+            creatives_data = await make_api_request(endpoint, access_token, params)
+            if "data" in creatives_data:
+                for creative in creatives_data["data"]:
+                    if "object_story_spec" in creative and "page_id" in creative["object_story_spec"]:
+                        all_page_ids.add(creative["object_story_spec"]["page_id"])
+        except Exception:
+            pass
             
-            for page_id in page_ids:
-                page_endpoint = f"{page_id}"
-                page_params = {
-                    "fields": "id,name,username,category,fan_count,link,verification_status,picture"
-                }
-                
-                page_data = await make_api_request(page_endpoint, access_token, page_params)
-                if "id" in page_data:
-                    page_details["data"].append(page_data)
+        # Approach 5: Get active ads and extract page IDs from creatives
+        try:
+            endpoint = f"{account_id}/ads"
+            params = {
+                "fields": "creative{object_story_spec{page_id},link_url,call_to_action}",
+                "limit": 100
+            }
+            ads_data = await make_api_request(endpoint, access_token, params)
+            if "data" in ads_data:
+                for ad in ads_data.get("data", []):
+                    if "creative" in ad and "object_story_spec" in ad["creative"] and "page_id" in ad["creative"]["object_story_spec"]:
+                        all_page_ids.add(ad["creative"]["object_story_spec"]["page_id"])
+        except Exception:
+            pass
+
+        # Approach 6: Try promoted_objects endpoint
+        try:
+            endpoint = f"{account_id}/promoted_objects"
+            params = {
+                "fields": "page_id,object_store_url,product_set_id,application_id"
+            }
+            promoted_objects_data = await make_api_request(endpoint, access_token, params)
+            if "data" in promoted_objects_data:
+                for obj in promoted_objects_data["data"]:
+                    if "page_id" in obj:
+                        all_page_ids.add(obj["page_id"])
+        except Exception:
+            pass
+
+        # Approach 7: Extract page IDs from tracking_specs in ads (most reliable)
+        try:
+            endpoint = f"{account_id}/ads"
+            params = {
+                "fields": "id,name,status,creative,tracking_specs",
+                "limit": 100
+            }
+            tracking_ads_data = await make_api_request(endpoint, access_token, params)
+            if "data" in tracking_ads_data:
+                for ad in tracking_ads_data.get("data", []):
+                    tracking_specs = ad.get("tracking_specs", [])
+                    if isinstance(tracking_specs, list):
+                        for spec in tracking_specs:
+                            if isinstance(spec, dict) and "page" in spec:
+                                page_list = spec["page"]
+                                if isinstance(page_list, list):
+                                    for page_id in page_list:
+                                        if isinstance(page_id, (str, int)) and str(page_id).isdigit():
+                                            all_page_ids.add(str(page_id))
+        except Exception:
+            pass
             
-            if page_details["data"]:
-                return json.dumps(page_details, indent=2)
-        
-        # Approach 2: Try client_pages endpoint
-        endpoint = f"{account_id}/client_pages"
-        params = {
-            "fields": "id,name,username,category,fan_count,link,verification_status,picture"
-        }
-        
-        client_pages_data = await make_api_request(endpoint, access_token, params)
-        
-        if "data" in client_pages_data and client_pages_data["data"]:
-            return json.dumps(client_pages_data, indent=2)
-        
-        # Approach 3: Try promoted_objects endpoint to find page IDs
-        endpoint = f"{account_id}/promoted_objects"
-        params = {
-            "fields": "page_id"
-        }
-        
-        promoted_objects_data = await make_api_request(endpoint, access_token, params)
-        
-        if "data" in promoted_objects_data and promoted_objects_data["data"]:
-            page_ids = set()
-            for obj in promoted_objects_data["data"]:
-                if "page_id" in obj:
-                    page_ids.add(obj["page_id"])
+        # Approach 8: Try campaigns and extract page info
+        try:
+            endpoint = f"{account_id}/campaigns"
+            params = {
+                "fields": "id,name,promoted_object,objective",
+                "limit": 50
+            }
+            campaigns_data = await make_api_request(endpoint, access_token, params)
+            if "data" in campaigns_data:
+                for campaign in campaigns_data["data"]:
+                    if "promoted_object" in campaign and "page_id" in campaign["promoted_object"]:
+                        all_page_ids.add(campaign["promoted_object"]["page_id"])
+        except Exception:
+            pass
             
-            if page_ids:
-                page_details = {"data": []}
-                for page_id in page_ids:
+        # If we found any page IDs, get details for each
+        if all_page_ids:
+            page_details = {
+                "data": [], 
+                "total_pages_found": len(all_page_ids)
+            }
+            
+            for page_id in all_page_ids:
+                try:
                     page_endpoint = f"{page_id}"
                     page_params = {
                         "fields": "id,name,username,category,fan_count,link,verification_status,picture"
@@ -1053,62 +1357,15 @@ async def get_account_pages(access_token: str = None, account_id: str = None) ->
                     page_data = await make_api_request(page_endpoint, access_token, page_params)
                     if "id" in page_data:
                         page_details["data"].append(page_data)
-                
-                if page_details["data"]:
-                    return json.dumps(page_details, indent=2)
-        
-        # Approach 4: Extract page IDs from tracking_specs in ads
-        # Inspired by praveen92y's implementation for robust page detection
-        # This approach is often the most reliable as confirmed by community feedback
-        endpoint = f"{account_id}/ads"
-        params = {
-            "fields": "id,name,adset_id,campaign_id,status,creative,created_time,updated_time,bid_amount,conversion_domain,tracking_specs",
-            "limit": 100
-        }
-        
-        tracking_ads_data = await make_api_request(endpoint, access_token, params)
-        
-        tracking_page_ids = set()
-        if "data" in tracking_ads_data:
-            for ad in tracking_ads_data.get("data", []):
-                tracking_specs = ad.get("tracking_specs", [])
-                if isinstance(tracking_specs, list):
-                    for spec in tracking_specs:
-                        # If 'page' key exists, add all page IDs
-                        if isinstance(spec, dict) and "page" in spec:
-                            page_list = spec["page"]
-                            if isinstance(page_list, list):
-                                for page_id in page_list:
-                                    # Validate page ID format (should be numeric string)
-                                    if isinstance(page_id, (str, int)) and str(page_id).isdigit():
-                                        tracking_page_ids.add(str(page_id))
-        
-        if tracking_page_ids:
-            page_details = {"data": [], "source": "tracking_specs", "note": "Page IDs extracted from active ads - these are the most reliable for ad creation"}
-            for page_id in tracking_page_ids:
-                page_endpoint = f"{page_id}"
-                page_params = {
-                    "fields": "id,name,username,category,fan_count,link,verification_status,picture"
-                }
-                
-                page_data = await make_api_request(page_endpoint, access_token, page_params)
-                if "id" in page_data:
-                    # Add additional context about this page ID being suitable for ads
-                    page_data["_meta"] = {
-                        "suitable_for_ads": True,
-                        "found_in_tracking_specs": True,
-                        "recommended_for_create_ad_creative": True
-                    }
-                    page_details["data"].append(page_data)
-                else:
+                    else:
+                        page_details["data"].append({
+                            "id": page_id, 
+                            "error": "Page details not accessible"
+                        })
+                except Exception as e:
                     page_details["data"].append({
-                        "id": page_id, 
-                        "error": "Page details not found",
-                        "_meta": {
-                            "suitable_for_ads": True,
-                            "found_in_tracking_specs": True,
-                            "note": "Page ID exists in ads but details not accessible - you can still use this ID for ad creation"
-                        }
+                        "id": page_id,
+                        "error": f"Failed to get page details: {str(e)}"
                     })
             
             if page_details["data"]:
@@ -1117,18 +1374,17 @@ async def get_account_pages(access_token: str = None, account_id: str = None) ->
         # If all approaches failed, return empty data with a message
         return json.dumps({
             "data": [],
-            "message": "No pages found associated with this account using automated methods",
-            "troubleshooting": {
-                "suggestion_1": "If you have existing ads, run 'get_ads' and look for page IDs in the 'tracking_specs' field",
-                "suggestion_2": "Use the exact page ID from existing ads' tracking_specs for creating new ad creatives",
-                "suggestion_3": "Verify your page ID format - it should be a numeric string (e.g., '123456789')",
-                "suggestion_4": "Check for digit transpositions or formatting errors in your page ID"
-            },
-            "note": "Based on community feedback, page IDs from existing ads' tracking_specs are the most reliable for ad creation"
+            "message": "No pages found associated with this account",
+            "suggestion": "Create a Facebook page and connect it to this ad account, or ensure existing pages are properly connected through Business Manager"
         }, indent=2)
         
     except Exception as e:
         return json.dumps({
             "error": "Failed to get account pages",
             "details": str(e)
-        }, indent=2)
+        }, indent=2)
+
+
+
+
+

meta_ads_mcp/core/api.py

@@ -240,22 +240,43 @@ def meta_api_tool(func):
                     logger.error("ISSUE DETECTED: Pipeboard authentication configured but no valid token available")
                     logger.error("ACTION REQUIRED: Complete authentication via Pipeboard service")
                 
-                return json.dumps({
-                    "error": {
-                        "message": "Authentication Required",
-                        "details": {
-                            "description": "You need to authenticate with the Meta API before using this tool",
-                            "action_required": "Please authenticate first",
-                            "auth_url": auth_url,
-                            "configuration_status": {
-                                "app_id_configured": bool(app_id) and app_id != "YOUR_META_APP_ID",
-                                "pipeboard_enabled": bool(os.environ.get('PIPEBOARD_API_TOKEN')),
-                            },
-                            "troubleshooting": "Check logs for TOKEN VALIDATION FAILED messages",
-                            "markdown_link": f"[Click here to authenticate with Meta Ads API]({auth_url})"
+                # Provide different guidance based on authentication method
+                if using_pipeboard:
+                    return json.dumps({
+                        "error": {
+                            "message": "Pipeboard Authentication Required",
+                            "details": {
+                                "description": "Your Pipeboard API token is invalid or has expired",
+                                "action_required": "Update your Pipeboard token",
+                                "setup_url": "https://pipeboard.co/setup",
+                                "token_url": "https://pipeboard.co/api-tokens",
+                                "configuration_status": {
+                                    "app_id_configured": bool(app_id) and app_id != "YOUR_META_APP_ID",
+                                    "pipeboard_enabled": True,
+                                },
+                                "troubleshooting": "Go to https://pipeboard.co/setup to verify your account setup, then visit https://pipeboard.co/api-tokens to obtain a new API token",
+                                "setup_link": "[Verify your Pipeboard account setup](https://pipeboard.co/setup)",
+                                "token_link": "[Get a new Pipeboard API token](https://pipeboard.co/api-tokens)"
+                            }
+                        }
+                    }, indent=2)
+                else:
+                    return json.dumps({
+                        "error": {
+                            "message": "Authentication Required",
+                            "details": {
+                                "description": "You need to authenticate with the Meta API before using this tool",
+                                "action_required": "Please authenticate first",
+                                "auth_url": auth_url,
+                                "configuration_status": {
+                                    "app_id_configured": bool(app_id) and app_id != "YOUR_META_APP_ID",
+                                    "pipeboard_enabled": False,
+                                },
+                                "troubleshooting": "Check logs for TOKEN VALIDATION FAILED messages",
+                                "markdown_link": f"[Click here to authenticate with Meta Ads API]({auth_url})"
+                            }
                         }
-                    }
-                }, indent=2)
+                    }, indent=2)
                 
             # Call the original function
             result = await func(*args, **kwargs)

meta_ads_mcp/core/insights.py

@@ -25,7 +25,29 @@ async def get_insights(access_token: str = None, object_id: str = None,
                    last_3d, last_7d, last_14d, last_28d, last_30d, last_90d, last_week_mon_sun, 
                    last_week_sun_sat, last_quarter, last_year, this_week_mon_today, this_week_sun_today, this_year
                    Dictionary example: {"since":"2023-01-01","until":"2023-01-31"}
-        breakdown: Optional breakdown dimension (e.g., age, gender, country)
+        breakdown: Optional breakdown dimension. Valid values include:
+                   Demographic: age, gender, country, region, dma
+                   Platform/Device: device_platform, platform_position, publisher_platform, impression_device
+                   Creative Assets: ad_format_asset, body_asset, call_to_action_asset, description_asset, 
+                                  image_asset, link_url_asset, title_asset, video_asset, media_asset_url,
+                                  media_creator, media_destination_url, media_format, media_origin_url,
+                                  media_text_content, media_type, creative_relaxation_asset_type,
+                                  flexible_format_asset_type, gen_ai_asset_type
+                   Campaign/Ad Attributes: breakdown_ad_objective, breakdown_reporting_ad_id, app_id, product_id
+                   Conversion Tracking: coarse_conversion_value, conversion_destination, standard_event_content_type,
+                                       signal_source_bucket, is_conversion_id_modeled, fidelity_type, redownload
+                   Time-based: hourly_stats_aggregated_by_advertiser_time_zone, 
+                              hourly_stats_aggregated_by_audience_time_zone, frequency_value
+                   Extensions/Landing: ad_extension_domain, ad_extension_url, landing_destination, 
+                                      mdsa_landing_destination
+                   Attribution: sot_attribution_model_type, sot_attribution_window, sot_channel, 
+                               sot_event_type, sot_source
+                   Mobile/SKAN: skan_campaign_id, skan_conversion_id, skan_version, postback_sequence_index
+                   CRM/Business: crm_advertiser_l12_territory_ids, crm_advertiser_subvertical_id,
+                                crm_advertiser_vertical_id, crm_ult_advertiser_id, user_persona_id, user_persona_name
+                   Advanced: hsid, is_auto_advance, is_rendered_as_delayed_skip_ad, mmm, place_page_id,
+                            marketing_messages_btn_name, impression_view_time_advertiser_hour_v2, comscore_market,
+                            comscore_market_code
         level: Level of aggregation (ad, adset, campaign, account)
     """
     if not object_id:

meta_ads_mcp/core/openai_deep_research.py

@@ -77,6 +77,50 @@ class MetaAdsDataManager:
             logger.error(f"Error fetching ads for {account_id}: {e}")
             return []
     
+    async def _get_pages_for_account(self, access_token: str, account_id: str) -> List[Dict[str, Any]]:
+        """Get pages associated with an account"""
+        try:
+            # Import the page discovery function from ads module
+            from .ads import _discover_pages_for_account
+            
+            # Ensure account_id has the 'act_' prefix
+            if not account_id.startswith("act_"):
+                account_id = f"act_{account_id}"
+            
+            page_discovery_result = await _discover_pages_for_account(account_id, access_token)
+            
+            if not page_discovery_result.get("success"):
+                return []
+            
+            # Return page data in a consistent format
+            return [{
+                "id": page_discovery_result["page_id"],
+                "name": page_discovery_result.get("page_name", "Unknown"),
+                "source": page_discovery_result.get("source", "unknown"),
+                "account_id": account_id
+            }]
+        except Exception as e:
+            logger.error(f"Error fetching pages for {account_id}: {e}")
+            return []
+    
+    async def _get_businesses(self, access_token: str, user_id: str = "me", limit: int = 25) -> List[Dict[str, Any]]:
+        """Get businesses accessible by the current user"""
+        try:
+            endpoint = f"{user_id}/businesses"
+            params = {
+                "fields": "id,name,created_time,verification_status",
+                "limit": limit
+            }
+            
+            data = await make_api_request(endpoint, access_token, params)
+            
+            if "data" in data:
+                return data["data"]
+            return []
+        except Exception as e:
+            logger.error(f"Error fetching businesses: {e}")
+            return []
+    
     async def search_records(self, query: str, access_token: str) -> List[str]:
         """Search Meta Ads data and return matching record IDs
         
@@ -176,6 +220,60 @@ class MetaAdsDataManager:
                                 },
                                 "raw_data": ad
                             }
+            
+            # If query specifically mentions "page" or "pages", also search pages
+            if any(term in ['page', 'pages', 'facebook page'] for term in query_terms):
+                for account in accounts[:5]:  # Limit to first 5 accounts for performance
+                    pages = await self._get_pages_for_account(access_token, account['id'])
+                    for page in pages:
+                        page_text = f"{page.get('name', '')} {page.get('source', '')}".lower()
+                        
+                        if any(term in page_text for term in query_terms):
+                            page_record_id = f"page:{page['id']}"
+                            matching_ids.append(page_record_id)
+                            
+                            # Cache the page data
+                            self._cache[page_record_id] = {
+                                "id": page_record_id,
+                                "type": "page",
+                                "title": f"Facebook Page: {page.get('name', 'Unnamed Page')}",
+                                "text": f"Facebook Page {page.get('name', 'Unnamed')} (ID: {page.get('id', 'N/A')}) - Source: {page.get('source', 'Unknown')}, Account: {account.get('name', 'Unknown')}",
+                                "metadata": {
+                                    "page_id": page.get('id'),
+                                    "page_name": page.get('name'),
+                                    "source": page.get('source'),
+                                    "account_id": account.get('id'),
+                                    "account_name": account.get('name'),
+                                    "data_type": "meta_ads_page"
+                                },
+                                "raw_data": page
+                            }
+            
+            # If query specifically mentions "business" or "businesses", also search businesses
+            if any(term in ['business', 'businesses', 'company', 'companies'] for term in query_terms):
+                businesses = await self._get_businesses(access_token, limit=25)
+                for business in businesses:
+                    business_text = f"{business.get('name', '')} {business.get('verification_status', '')}".lower()
+                    
+                    if any(term in business_text for term in query_terms):
+                        business_record_id = f"business:{business['id']}"
+                        matching_ids.append(business_record_id)
+                        
+                        # Cache the business data
+                        self._cache[business_record_id] = {
+                            "id": business_record_id,
+                            "type": "business",
+                            "title": f"Business: {business.get('name', 'Unnamed Business')}",
+                            "text": f"Meta Business {business.get('name', 'Unnamed')} (ID: {business.get('id', 'N/A')}) - Created: {business.get('created_time', 'Unknown')}, Verification: {business.get('verification_status', 'Unknown')}",
+                            "metadata": {
+                                "business_id": business.get('id'),
+                                "business_name": business.get('name'),
+                                "created_time": business.get('created_time'),
+                                "verification_status": business.get('verification_status'),
+                                "data_type": "meta_ads_business"
+                            },
+                            "raw_data": business
+                        }
         
         except Exception as e:
             logger.error(f"Error during search operation: {e}")
@@ -219,7 +317,7 @@ async def search(
     Search through Meta Ads data and return matching record IDs.
     
     This tool is required for OpenAI ChatGPT Deep Research integration.
-    It searches across ad accounts, campaigns, and ads to find relevant records
+    It searches across ad accounts, campaigns, ads, pages, and businesses to find relevant records
     based on the provided query.
     
     Args:
@@ -233,6 +331,8 @@ async def search(
         search(query="active campaigns")
         search(query="account spending")
         search(query="facebook ads performance")
+        search(query="facebook pages")
+        search(query="user businesses")
     """
     if not query:
         return json.dumps({
@@ -285,6 +385,7 @@ async def fetch(
         fetch(id="account:act_123456789")
         fetch(id="campaign:23842588888640185")
         fetch(id="ad:23842614006130185")
+        fetch(id="page:123456789")
     """
     if not id:
         return json.dumps({

meta_ads_mcp/core/pipeboard_auth.py

@@ -120,7 +120,7 @@ class PipeboardAuthManager:
         else:
             logger.info("Pipeboard authentication not enabled. Set PIPEBOARD_API_TOKEN environment variable to enable.")
         self.token_info = None
-        self._load_cached_token()
+        # Note: Token caching is disabled to always fetch fresh tokens from Pipeboard
     
     def _get_token_cache_path(self) -> Path:
         """Get the platform-specific path for token cache file"""
@@ -320,18 +320,7 @@ class PipeboardAuthManager:
             logger.error("Please set PIPEBOARD_API_TOKEN environment variable")
             return None
             
-        # Check if we already have a valid token
-        if not force_refresh and self.token_info and not self.token_info.is_expired():
-            logger.debug("Using existing valid token")
-            return self.token_info.access_token
-            
-        # If we have a token but it's expired, log that information
-        if not force_refresh and self.token_info and self.token_info.is_expired():
-            logger.error("TOKEN VALIDATION FAILED: Existing token is expired")
-            if self.token_info.expires_at:
-                logger.error(f"Token expiration time: {self.token_info.expires_at}")
-        
-        logger.info(f"Getting new token (force_refresh={force_refresh})")
+        logger.info("Getting fresh token from Pipeboard (caching disabled)")
         
         # If force refresh or no token/expired token, get a new one from Pipeboard
         try:
@@ -398,8 +387,7 @@ class PipeboardAuthManager:
                 token_type=data.get("token_type", "bearer")
             )
             
-            # Save to cache
-            self._save_token_to_cache()
+            # Note: Token caching is disabled
             
             masked_token = self.token_info.access_token[:10] + "..." + self.token_info.access_token[-5:] if self.token_info.access_token else "None"
             logger.info(f"Successfully retrieved access token: {masked_token}")

{meta_ads_mcp-0.7.10.dist-info → meta_ads_mcp-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meta-ads-mcp
-Version: 0.7.10
+Version: 0.9.0
 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
@@ -111,9 +111,11 @@ For detailed step-by-step instructions, authentication setup, debugging, and tro
 - **Automated Monitoring**: Ask any MCP-compatible LLM to track performance metrics and alert you about significant changes
 - **Budget Optimization**: Get recommendations for reallocating budget to better-performing ad sets
 - **Creative Improvement**: Receive feedback on ad copy, imagery, and calls-to-action
+- **Dynamic Creative Testing**: Easy API for both simple ads (single headline/description) and advanced A/B testing (multiple headlines/descriptions)
 - **Campaign Management**: Request changes to campaigns, ad sets, and ads (all changes require explicit confirmation)
 - **Cross-Platform Integration**: Works with Facebook, Instagram, and all Meta ad platforms
 - **Universal LLM Support**: Compatible with any MCP client including Claude Desktop, Cursor, Cherry Studio, and more
+- **Enhanced Search**: Generic search function includes page searching when queries mention "page" or "pages"
 - **Simple Authentication**: Easy setup with secure OAuth authentication
 - **Cross-Platform Support**: Works on Windows, macOS, and Linux
 
@@ -260,14 +262,32 @@ For local installation configuration, authentication options, and advanced techn
       - `page_id`: Facebook Page ID for the ad
       - `link_url`: Destination URL
       - `message`: Ad copy/text
-      - `headline`: Ad headline
-      - `description`: Ad description
+      - `headline`: Single headline for simple ads (cannot be used with headlines)
+      - `headlines`: List of headlines for dynamic creative testing (cannot be used with headline)
+      - `description`: Single description for simple ads (cannot be used with descriptions)
+      - `descriptions`: List of descriptions for dynamic creative testing (cannot be used with description)
+      - `dynamic_creative_spec`: Dynamic creative optimization settings
       - `call_to_action_type`: CTA button type (e.g., 'LEARN_MORE')
       - `instagram_actor_id`: Optional Instagram account ID
       - `access_token` (optional): Meta API access token
     - Returns: Confirmation with new creative details
 
-15. `mcp_meta_ads_upload_ad_image`
+15. `mcp_meta_ads_update_ad_creative`
+    - Update an existing ad creative with new content or settings
+    - Inputs:
+      - `creative_id`: Meta Ads creative ID to update
+      - `name`: New creative name
+      - `message`: New ad copy/text
+      - `headline`: Single headline for simple ads (cannot be used with headlines)
+      - `headlines`: New list of headlines for dynamic creative testing (cannot be used with headline)
+      - `description`: Single description for simple ads (cannot be used with descriptions)
+      - `descriptions`: New list of descriptions for dynamic creative testing (cannot be used with description)
+      - `dynamic_creative_spec`: New dynamic creative optimization settings
+      - `call_to_action_type`: New call to action button type
+      - `access_token` (optional): Meta API access token (will use cached token if not provided)
+    - Returns: Confirmation with updated creative details
+
+16. `mcp_meta_ads_upload_ad_image`
     - Upload an image to use in Meta Ads creatives
     - Inputs:
       - `account_id`: Meta Ads account ID (format: act_XXXXXXXXX)
@@ -276,14 +296,14 @@ For local installation configuration, authentication options, and advanced techn
       - `access_token` (optional): Meta API access token
     - Returns: JSON response with image details including hash
 
-16. `mcp_meta_ads_get_ad_image`
+17. `mcp_meta_ads_get_ad_image`
     - Get, download, and visualize a Meta ad image in one step
     - Inputs:
       - `access_token` (optional): Meta API access token (will use cached token if not provided)
       - `ad_id`: Meta Ads ad ID
     - Returns: The ad image ready for direct visual analysis
 
-17. `mcp_meta_ads_update_ad`
+18. `mcp_meta_ads_update_ad`
     - Update an ad with new settings
     - Inputs:
       - `ad_id`: Meta Ads ad ID
@@ -292,7 +312,7 @@ For local installation configuration, authentication options, and advanced techn
       - `access_token` (optional): Meta API access token (will use cached token if not provided)
     - Returns: Confirmation with updated ad details and a confirmation link
 
-18. `mcp_meta_ads_update_adset`
+19. `mcp_meta_ads_update_adset`
     - Update an ad set with new settings including frequency caps
     - Inputs:
       - `adset_id`: Meta Ads ad set ID
@@ -304,7 +324,7 @@ For local installation configuration, authentication options, and advanced techn
       - `access_token` (optional): Meta API access token (will use cached token if not provided)
     - Returns: Confirmation with updated ad set details and a confirmation link
 
-19. `mcp_meta_ads_get_insights`
+20. `mcp_meta_ads_get_insights`
     - Get performance insights for a campaign, ad set, ad or account
     - Inputs:
       - `access_token` (optional): Meta API access token (will use cached token if not provided)
@@ -314,13 +334,13 @@ For local installation configuration, authentication options, and advanced techn
       - `level`: Level of aggregation (ad, adset, campaign, account)
     - Returns: Performance metrics for the specified object
 
-20. `mcp_meta_ads_get_login_link`
+21. `mcp_meta_ads_get_login_link`
     - Get a clickable login link for Meta Ads authentication
     - Inputs:
       - `access_token` (optional): Meta API access token (will use cached token if not provided)
     - Returns: A clickable resource link for Meta authentication
 
-21. `mcp_meta-ads_create_budget_schedule`
+22. `mcp_meta-ads_create_budget_schedule`
     - Create a budget schedule for a Meta Ads campaign.
     - Inputs:
       - `campaign_id`: Meta Ads campaign ID.
@@ -331,7 +351,7 @@ For local installation configuration, authentication options, and advanced techn
       - `access_token` (optional): Meta API access token.
     - Returns: JSON string with the ID of the created budget schedule or an error message.
 
-22. `mcp_meta_ads_search_interests`
+23. `mcp_meta_ads_search_interests`
     - Search for interest targeting options by keyword
     - Inputs:
       - `access_token` (optional): Meta API access token (will use cached token if not provided)
@@ -339,7 +359,7 @@ For local installation configuration, authentication options, and advanced techn
       - `limit`: Maximum number of results to return (default: 25)
     - Returns: Interest data with id, name, audience_size, and path fields
 
-23. `mcp_meta_ads_get_interest_suggestions`
+24. `mcp_meta_ads_get_interest_suggestions`
     - Get interest suggestions based on existing interests
     - Inputs:
       - `access_token` (optional): Meta API access token (will use cached token if not provided)
@@ -379,6 +399,14 @@ For local installation configuration, authentication options, and advanced techn
       - `limit`: Maximum number of results to return (default: 25)
     - Returns: Location data with key, name, type, and geographic hierarchy information
 
+28. `mcp_meta_ads_search` (Enhanced)
+    - Generic search across accounts, campaigns, ads, and pages
+    - Automatically includes page searching when query mentions "page" or "pages"
+    - Inputs:
+      - `access_token` (optional): Meta API access token (will use cached token if not provided)
+      - `query`: Search query string (e.g., "Injury Payouts pages", "active campaigns")
+    - Returns: List of matching record IDs in ChatGPT-compatible format
+
 ## Privacy and Security
 
 Meta Ads MCP follows security best practices with secure token management and automatic authentication handling. 

{meta_ads_mcp-0.7.10.dist-info → meta_ads_mcp-0.9.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
-meta_ads_mcp/__init__.py,sha256=Y0Oj0zMOmh2TX_E4iBNehH9NFlM1w9O3injKT8FJMbw,1493
+meta_ads_mcp/__init__.py,sha256=HV-_j707lfnxzSKt6hrk2hD1PPP3y6Rfp7rlwCJBDFQ,1492
 meta_ads_mcp/__main__.py,sha256=XaQt3iXftG_7f0Zu7Wop9SeFgrD2WBn0EQOaPMc27d8,207
 meta_ads_mcp/core/__init__.py,sha256=6nYdue6yRepkt6JTAoPGhGbS51qfDSvmczRrDwYOG6A,1709
 meta_ads_mcp/core/accounts.py,sha256=4IAdGLZ4WE4j4pGW6E0qaXcXqbUIW6Wk2kuQUtlmRTQ,4030
-meta_ads_mcp/core/ads.py,sha256=lUq5te8SDFHS2gn8IlwVa0svyFyqJBMvWtuxy1hacFI,44428
+meta_ads_mcp/core/ads.py,sha256=3UpoktML-5hJ_k2u5KOk3-VcFe_goz531jLi6-qJhqU,54929
 meta_ads_mcp/core/ads_library.py,sha256=BBGVbtjO5eFV42iiY3XPU-wIV8HupzUKpHgPBrydSvU,3232
 meta_ads_mcp/core/adsets.py,sha256=vY5JNHmGK1a_sQ5B1LnjxLYXzs5_jOajTTjWHRDJ4_Y,12518
-meta_ads_mcp/core/api.py,sha256=aAzM6Q75VQOFXtr5D-mDmBRhxWK4wsiODsJYnR3mpDI,14994
+meta_ads_mcp/core/api.py,sha256=kWpIafvSsxnesfb5TqndA7ozKoIspby5e_6Jl23L7hY,16447
 meta_ads_mcp/core/auth.py,sha256=2CjFbxpJM3OR3OzCipB8l_-l2xQ1nioGfdI3ZDMnjHM,23629
 meta_ads_mcp/core/authentication.py,sha256=-AJxa3a5ZshRCvmJThBaNwCAJ1D2_qOgUkvu539c_MY,10159
 meta_ads_mcp/core/budget_schedules.py,sha256=UxseExsvKAiPwfDCY9aycT4kys4xqeNytyq-yyDOxrs,2901
@@ -13,16 +13,16 @@ meta_ads_mcp/core/callback_server.py,sha256=LIAJv9DW--83kdZ7VWWZal8xEprYjRZ8iug4
 meta_ads_mcp/core/campaigns.py,sha256=0yDVgi7rN4eMQk1_w0A2vnoXd8y0t8R77Ji4gna1Gj4,14030
 meta_ads_mcp/core/duplication.py,sha256=UUmTDFx9o5ZsPQG2Rb9c4ZyuKUVN3FfTjebfTIHHdo4,18984
 meta_ads_mcp/core/http_auth_integration.py,sha256=lGpKhfzJcyWugBcYEvypY-qnlt-3UDBLqh7xAUH0DGw,12473
-meta_ads_mcp/core/insights.py,sha256=Qr1wq-1VT9HwF4w11rIRM4IBYdrksJ-6EOv3p33ZtKw,2613
-meta_ads_mcp/core/openai_deep_research.py,sha256=Ocs8bmNNBLZQLmWfL6azlC3RNzevVzV5WgcEp4H2wdY,13240
-meta_ads_mcp/core/pipeboard_auth.py,sha256=yT2-e9dpmkMOg6rMJWaQAMg4DZu4RxlDV5zkTm-G--o,25168
+meta_ads_mcp/core/insights.py,sha256=unhcCaYjgsir62llCdIDg0F-PHISiHune08uYG5IXTM,4707
+meta_ads_mcp/core/openai_deep_research.py,sha256=gLQlzIUBd-VyBMYjJ4vchMadQ-4aT3PEMqd9GLq6MYw,18805
+meta_ads_mcp/core/pipeboard_auth.py,sha256=ZwEQy8r0TwobFRQ5gmlSjhIfvlUmMtfWNlpQjXCUhl0,24582
 meta_ads_mcp/core/reports.py,sha256=Dv3hfsPOR7IZ9WrYrKd_6SNgZl-USIphg7knva3UYAw,5747
 meta_ads_mcp/core/resources.py,sha256=-zIIfZulpo76vcKv6jhAlQq91cR2SZ3cjYZt3ek3x0w,1236
 meta_ads_mcp/core/server.py,sha256=WhbAag7xdhbGcp7rnU4sKhqXJ8Slapa_ba3T23Yp_2U,17889
 meta_ads_mcp/core/targeting.py,sha256=3HW1qirEdwaQurlBZGenbIwawcb5J06ghJKRfgu9ZEs,6318
 meta_ads_mcp/core/utils.py,sha256=ytj41yC5SqduLrAiZYBSd6OUwlJRaIClTwnnYKpNFds,9387
-meta_ads_mcp-0.7.10.dist-info/METADATA,sha256=DCV6TdsYdyLogsgvOpIu8hBjawrGo1FWiF4PuKp20AU,20410
-meta_ads_mcp-0.7.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-meta_ads_mcp-0.7.10.dist-info/entry_points.txt,sha256=Dv2RkoBjRJBqj6CyhwqGIiwPCD-SCL1-7B9-zmVRuv0,57
-meta_ads_mcp-0.7.10.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-meta_ads_mcp-0.7.10.dist-info/RECORD,,
+meta_ads_mcp-0.9.0.dist-info/METADATA,sha256=SHl5v6vr5zhzMmsITPis8sgIGXyCOWCBRI66tdcJQ7A,22434
+meta_ads_mcp-0.9.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+meta_ads_mcp-0.9.0.dist-info/entry_points.txt,sha256=Dv2RkoBjRJBqj6CyhwqGIiwPCD-SCL1-7B9-zmVRuv0,57
+meta_ads_mcp-0.9.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+meta_ads_mcp-0.9.0.dist-info/RECORD,,