meta-ads-mcp 0.8.0__tar.gz → 0.9.1__tar.gz

{meta_ads_mcp-0.8.0 → meta_ads_mcp-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meta-ads-mcp
-Version: 0.8.0
+Version: 0.9.1
 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
@@ -13,7 +13,7 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
 Requires-Dist: httpx>=0.26.0
-Requires-Dist: mcp[cli]>=1.10.1
+Requires-Dist: mcp[cli]<=1.12.2,>=1.10.1
 Requires-Dist: pathlib>=1.0.1
 Requires-Dist: pillow>=10.0.0
 Requires-Dist: pytest-asyncio>=1.0.0

{meta_ads_mcp-0.8.0 → meta_ads_mcp-0.9.1}/meta_ads_mcp/__init__.py

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

{meta_ads_mcp-0.8.0 → meta_ads_mcp-0.9.1}/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()
@@ -1205,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
-        
-        # Approach 1: Get active ads and extract page IDs
-        endpoint = f"{account_id}/ads"
-        params = {
-            "fields": "creative{object_story_spec{page_id}}",
-            "limit": 100
-        }
-        
-        ads_data = await make_api_request(endpoint, access_token, params)
-        
-        # 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"])
+        # Collect all page IDs from multiple approaches
+        all_page_ids = set()
         
-        # If we found page IDs, get details for each
-        if page_ids:
-            page_details = {"data": []}
+        # 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
+        
+        # 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
+        
+        # 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
+        
+        # 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 we found any page IDs, get details for each
+        if all_page_ids:
+            page_details = {
+                "data": [], 
+                "total_pages_found": len(all_page_ids)
+            }
             
-            if page_ids:
-                page_details = {"data": []}
-                for page_id in 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"
@@ -1276,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"]:
@@ -1340,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-0.8.0 → meta_ads_mcp-0.9.1}/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-0.8.0 → meta_ads_mcp-0.9.1}/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-0.8.0 → meta_ads_mcp-0.9.1}/meta_ads_mcp/core/openai_deep_research.py

@@ -103,6 +103,24 @@ class MetaAdsDataManager:
             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
         
@@ -230,6 +248,32 @@ class MetaAdsDataManager:
                                 },
                                 "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}")
@@ -273,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, ads, and pages to find relevant records
+    It searches across ad accounts, campaigns, ads, pages, and businesses to find relevant records
     based on the provided query.
     
     Args:
@@ -288,6 +332,7 @@ async def search(
         search(query="account spending")
         search(query="facebook ads performance")
         search(query="facebook pages")
+        search(query="user businesses")
     """
     if not query:
         return json.dumps({

{meta_ads_mcp-0.8.0 → meta_ads_mcp-0.9.1}/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.8.0 → meta_ads_mcp-0.9.1}/meta_ads_mcp/core/server.py

@@ -14,7 +14,7 @@ from .pipeboard_auth import pipeboard_auth_manager
 import time
 
 # Initialize FastMCP server
-mcp_server = FastMCP("meta-ads", use_consistent_tool_format=True)
+mcp_server = FastMCP("meta-ads")
 
 # Register resource URIs
 mcp_server.resource(uri="meta-ads://resources")(list_resources)

{meta_ads_mcp-0.8.0 → meta_ads_mcp-0.9.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "meta-ads-mcp"
-version = "0.8.0"
+version = "0.9.1"
 description = "Model Context Protocol (MCP) plugin for interacting with Meta Ads API"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -20,7 +20,7 @@ classifiers = [
 ]
 dependencies = [
     "httpx>=0.26.0",
-    "mcp[cli]>=1.10.1",
+    "mcp[cli]>=1.10.1,<=1.12.2",
     "python-dotenv>=1.1.0",
     "requests>=2.32.3",
     "Pillow>=10.0.0",