meta-ads-mcp 0.5.0__py3-none-any.whl → 0.7.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.5.0"
+__version__ = "0.7.0"
 
 __all__ = [
     'get_ad_accounts',
@@ -26,7 +26,13 @@ __all__ = [
     'get_insights',
     'get_login_link',
     'login_cli',
-    'main'
+    'main',
+    'search_interests',
+    'get_interest_suggestions',
+    'validate_interests',
+    'search_behaviors',
+    'search_demographics',
+    'search_geo_locations'
 ]
 
 # Import key functions to make them available at package level
@@ -47,7 +53,13 @@ from .core import (
     get_insights,
     get_login_link,
     login_cli,
-    main
+    main,
+    search_interests,
+    get_interest_suggestions,
+    validate_interests,
+    search_behaviors,
+    search_demographics,
+    search_geo_locations
 )
 
 # Define a main function to be used as a package entry point

meta_ads_mcp/core/__init__.py

@@ -11,8 +11,10 @@ from .server import login_cli, main
 from .auth import login
 from .ads_library import search_ads_archive
 from .budget_schedules import create_budget_schedule
+from .targeting import search_interests, get_interest_suggestions, validate_interests, search_behaviors, search_demographics, search_geo_locations
 from . import reports  # Import module to register conditional tools
 from . import duplication  # Import module to register conditional duplication tools
+from .openai_deep_research import search, fetch  # OpenAI MCP Deep Research tools
 
 __all__ = [
     'mcp_server',
@@ -36,4 +38,12 @@ __all__ = [
     'main',
     'search_ads_archive',
     'create_budget_schedule',
+    'search_interests',
+    'get_interest_suggestions',
+    'validate_interests',
+    'search_behaviors',
+    'search_demographics',
+    'search_geo_locations',
+    'search',  # OpenAI MCP Deep Research search tool
+    'fetch',   # OpenAI MCP Deep Research fetch tool
 ] 

meta_ads_mcp/core/openai_deep_research.py

@@ -0,0 +1,316 @@
+"""OpenAI MCP Deep Research tools for Meta Ads API.
+
+This module implements the required 'search' and 'fetch' tools for OpenAI's 
+ChatGPT Deep Research feature, providing access to Meta Ads data in the format 
+expected by ChatGPT.
+
+The tools expose Meta Ads data (accounts, campaigns, ads, etc.) as searchable 
+and fetchable records for ChatGPT Deep Research analysis.
+"""
+
+import json
+import re
+from typing import List, Dict, Any, Optional
+from .api import meta_api_tool, make_api_request
+from .server import mcp_server
+from .utils import logger
+
+
+class MetaAdsDataManager:
+    """Manages Meta Ads data for OpenAI MCP search and fetch operations"""
+    
+    def __init__(self):
+        self._cache = {}
+        logger.debug("MetaAdsDataManager initialized")
+    
+    async def _get_ad_accounts(self, access_token: str, limit: int = 25) -> List[Dict[str, Any]]:
+        """Get ad accounts data"""
+        try:
+            endpoint = "me/adaccounts"
+            params = {
+                "fields": "id,name,account_id,account_status,amount_spent,balance,currency,business_city,business_country_code",
+                "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 ad accounts: {e}")
+            return []
+    
+    async def _get_campaigns(self, access_token: str, account_id: str, limit: int = 25) -> List[Dict[str, Any]]:
+        """Get campaigns data for an account"""
+        try:
+            endpoint = f"{account_id}/campaigns"
+            params = {
+                "fields": "id,name,status,objective,daily_budget,lifetime_budget,start_time,stop_time,created_time,updated_time",
+                "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 campaigns for {account_id}: {e}")
+            return []
+    
+    async def _get_ads(self, access_token: str, account_id: str, limit: int = 25) -> List[Dict[str, Any]]:
+        """Get ads data for an account"""
+        try:
+            endpoint = f"{account_id}/ads"
+            params = {
+                "fields": "id,name,status,creative,targeting,bid_amount,created_time,updated_time",
+                "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 ads for {account_id}: {e}")
+            return []
+    
+    async def search_records(self, query: str, access_token: str) -> List[str]:
+        """Search Meta Ads data and return matching record IDs
+        
+        Args:
+            query: Search query string
+            access_token: Meta API access token
+            
+        Returns:
+            List of record IDs that match the query
+        """
+        logger.info(f"Searching Meta Ads data with query: {query}")
+        
+        # Normalize query for matching
+        query_lower = query.lower()
+        query_terms = re.findall(r'\w+', query_lower)
+        
+        matching_ids = []
+        
+        try:
+            # Search ad accounts
+            accounts = await self._get_ad_accounts(access_token, limit=25)
+            for account in accounts:
+                account_text = f"{account.get('name', '')} {account.get('id', '')} {account.get('account_status', '')} {account.get('business_city', '')} {account.get('business_country_code', '')}".lower()
+                
+                if any(term in account_text for term in query_terms):
+                    record_id = f"account:{account['id']}"
+                    matching_ids.append(record_id)
+                    
+                    # Cache the account data
+                    self._cache[record_id] = {
+                        "id": record_id,
+                        "type": "account",
+                        "title": f"Ad Account: {account.get('name', 'Unnamed Account')}",
+                        "text": f"Meta Ads Account {account.get('name', 'Unnamed')} (ID: {account.get('id', 'N/A')}) - Status: {account.get('account_status', 'Unknown')}, Currency: {account.get('currency', 'Unknown')}, Spent: ${account.get('amount_spent', 0)}, Balance: ${account.get('balance', 0)}",
+                        "metadata": {
+                            "account_id": account.get('id'),
+                            "account_name": account.get('name'),
+                            "status": account.get('account_status'),
+                            "currency": account.get('currency'),
+                            "business_location": f"{account.get('business_city', '')}, {account.get('business_country_code', '')}".strip(', '),
+                            "data_type": "meta_ads_account"
+                        },
+                        "raw_data": account
+                    }
+                    
+                    # Also search campaigns for this account if it matches
+                    campaigns = await self._get_campaigns(access_token, account['id'], limit=10)
+                    for campaign in campaigns:
+                        campaign_text = f"{campaign.get('name', '')} {campaign.get('objective', '')} {campaign.get('status', '')}".lower()
+                        
+                        if any(term in campaign_text for term in query_terms):
+                            campaign_record_id = f"campaign:{campaign['id']}"
+                            matching_ids.append(campaign_record_id)
+                            
+                            # Cache the campaign data
+                            self._cache[campaign_record_id] = {
+                                "id": campaign_record_id,
+                                "type": "campaign",
+                                "title": f"Campaign: {campaign.get('name', 'Unnamed Campaign')}",
+                                "text": f"Meta Ads Campaign {campaign.get('name', 'Unnamed')} (ID: {campaign.get('id', 'N/A')}) - Objective: {campaign.get('objective', 'Unknown')}, Status: {campaign.get('status', 'Unknown')}, Daily Budget: ${campaign.get('daily_budget', 'Not set')}, Account: {account.get('name', 'Unknown')}",
+                                "metadata": {
+                                    "campaign_id": campaign.get('id'),
+                                    "campaign_name": campaign.get('name'),
+                                    "objective": campaign.get('objective'),
+                                    "status": campaign.get('status'),
+                                    "account_id": account.get('id'),
+                                    "account_name": account.get('name'),
+                                    "data_type": "meta_ads_campaign"
+                                },
+                                "raw_data": campaign
+                            }
+            
+            # If query specifically mentions "ads" or "ad", also search individual ads
+            if any(term in ['ad', 'ads', 'advertisement', 'creative'] for term in query_terms):
+                for account in accounts[:3]:  # Limit to first 3 accounts for performance
+                    ads = await self._get_ads(access_token, account['id'], limit=10)
+                    for ad in ads:
+                        ad_text = f"{ad.get('name', '')} {ad.get('status', '')}".lower()
+                        
+                        if any(term in ad_text for term in query_terms):
+                            ad_record_id = f"ad:{ad['id']}"
+                            matching_ids.append(ad_record_id)
+                            
+                            # Cache the ad data
+                            self._cache[ad_record_id] = {
+                                "id": ad_record_id,
+                                "type": "ad",
+                                "title": f"Ad: {ad.get('name', 'Unnamed Ad')}",
+                                "text": f"Meta Ad {ad.get('name', 'Unnamed')} (ID: {ad.get('id', 'N/A')}) - Status: {ad.get('status', 'Unknown')}, Bid Amount: ${ad.get('bid_amount', 'Not set')}, Account: {account.get('name', 'Unknown')}",
+                                "metadata": {
+                                    "ad_id": ad.get('id'),
+                                    "ad_name": ad.get('name'),
+                                    "status": ad.get('status'),
+                                    "account_id": account.get('id'),
+                                    "account_name": account.get('name'),
+                                    "data_type": "meta_ads_ad"
+                                },
+                                "raw_data": ad
+                            }
+        
+        except Exception as e:
+            logger.error(f"Error during search operation: {e}")
+            # Return empty list on error, but don't raise exception
+            return []
+        
+        logger.info(f"Search completed. Found {len(matching_ids)} matching records")
+        return matching_ids[:50]  # Limit to 50 results for performance
+    
+    def fetch_record(self, record_id: str) -> Optional[Dict[str, Any]]:
+        """Fetch a cached record by ID
+        
+        Args:
+            record_id: The record ID to fetch
+            
+        Returns:
+            Record data or None if not found
+        """
+        logger.info(f"Fetching record: {record_id}")
+        
+        record = self._cache.get(record_id)
+        if record:
+            logger.debug(f"Record found in cache: {record['type']}")
+            return record
+        else:
+            logger.warning(f"Record not found in cache: {record_id}")
+            return None
+
+
+# Global data manager instance
+_data_manager = MetaAdsDataManager()
+
+
+@mcp_server.tool()
+@meta_api_tool
+async def search(
+    access_token: str = None,
+    query: str = None
+) -> str:
+    """
+    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
+    based on the provided query.
+    
+    Args:
+        access_token: Meta API access token (optional - will use cached token if not provided)
+        query: Search query string to find relevant Meta Ads records
+        
+    Returns:
+        JSON response with list of matching record IDs
+        
+    Example Usage:
+        search(query="active campaigns")
+        search(query="account spending")
+        search(query="facebook ads performance")
+    """
+    if not query:
+        return json.dumps({
+            "error": "query parameter is required",
+            "ids": []
+        }, indent=2)
+    
+    try:
+        # Use the data manager to search records
+        matching_ids = await _data_manager.search_records(query, access_token)
+        
+        response = {
+            "ids": matching_ids,
+            "query": query,
+            "total_results": len(matching_ids)
+        }
+        
+        logger.info(f"Search successful. Query: '{query}', Results: {len(matching_ids)}")
+        return json.dumps(response, indent=2)
+        
+    except Exception as e:
+        error_msg = str(e)
+        logger.error(f"Error in search tool: {error_msg}")
+        
+        return json.dumps({
+            "error": "Failed to search Meta Ads data",
+            "details": error_msg,
+            "ids": [],
+            "query": query
+        }, indent=2)
+
+
+@mcp_server.tool()
+async def fetch(
+    id: str = None
+) -> str:
+    """
+    Fetch complete record data by ID.
+    
+    This tool is required for OpenAI ChatGPT Deep Research integration.
+    It retrieves the full data for a specific record identified by its ID.
+    
+    Args:
+        id: The record ID to fetch (format: "type:id", e.g., "account:act_123456")
+        
+    Returns:
+        JSON response with complete record data including id, title, text, and metadata
+        
+    Example Usage:
+        fetch(id="account:act_123456789")
+        fetch(id="campaign:23842588888640185")
+        fetch(id="ad:23842614006130185")
+    """
+    if not id:
+        return json.dumps({
+            "error": "id parameter is required"
+        }, indent=2)
+    
+    try:
+        # Use the data manager to fetch the record
+        record = _data_manager.fetch_record(id)
+        
+        if record:
+            logger.info(f"Record fetched successfully: {id}")
+            return json.dumps(record, indent=2)
+        else:
+            logger.warning(f"Record not found: {id}")
+            return json.dumps({
+                "error": f"Record not found: {id}",
+                "id": id
+            }, indent=2)
+            
+    except Exception as e:
+        error_msg = str(e)
+        logger.error(f"Error in fetch tool: {error_msg}")
+        
+        return json.dumps({
+            "error": "Failed to fetch record",
+            "details": error_msg,
+            "id": id
+        }, indent=2) 

meta_ads_mcp/core/server.py

@@ -276,6 +276,8 @@ def main():
     pipeboard_api_token = os.environ.get("PIPEBOARD_API_TOKEN")
     if pipeboard_api_token:
         logger.info("Using Pipeboard authentication")
+        print("✅ Pipeboard authentication enabled")
+        print(f"   API token: {pipeboard_api_token[:8]}...{pipeboard_api_token[-4:]}")
         # Check for existing token
         token = pipeboard_auth_manager.get_access_token()
         if not token:
@@ -312,6 +314,9 @@ def main():
             except Exception as e:
                 logger.error(f"Error initiating browser-based authentication: {e}")
                 print(f"Error: Could not start authentication: {e}")
+        else:
+            print(f"✅ Valid Pipeboard access token found")
+            print(f"   Token preview: {token[:10]}...{token[-5:]}")
     
     # Transport-specific server initialization and startup
     if args.transport == "streamable-http":
@@ -336,7 +341,7 @@ def main():
         # Import all tool modules to ensure they are registered
         logger.info("Ensuring all tools are registered for HTTP transport")
         from . import accounts, campaigns, adsets, ads, insights, authentication
-        from . import ads_library, budget_schedules, reports
+        from . import ads_library, budget_schedules, reports, openai_deep_research
         
         # ✅ NEW: Setup HTTP authentication middleware
         logger.info("Setting up HTTP authentication middleware")

meta_ads_mcp/core/targeting.py

@@ -0,0 +1,185 @@
+"""Targeting search functionality for Meta Ads API."""
+
+import json
+from typing import Optional, List, Dict, Any
+from .api import meta_api_tool, make_api_request
+from .server import mcp_server
+
+
+@mcp_server.tool()
+@meta_api_tool
+async def search_interests(access_token: str = None, query: str = None, limit: int = 25) -> str:
+    """
+    Search for interest targeting options by keyword.
+    
+    Args:
+        access_token: Meta API access token (optional - will use cached token if not provided)
+        query: Search term for interests (e.g., "baseball", "cooking", "travel")
+        limit: Maximum number of results to return (default: 25)
+    
+    Returns:
+        JSON string containing interest data with id, name, audience_size, and path fields
+    """
+    if not query:
+        return json.dumps({"error": "No search query provided"}, indent=2)
+    
+    endpoint = "search"
+    params = {
+        "type": "adinterest",
+        "q": query,
+        "limit": limit
+    }
+    
+    data = await make_api_request(endpoint, access_token, params)
+    
+    return json.dumps(data, indent=2)
+
+
+@mcp_server.tool()
+@meta_api_tool
+async def get_interest_suggestions(access_token: str = None, interest_list: List[str] = None, limit: int = 25) -> str:
+    """
+    Get interest suggestions based on existing interests.
+    
+    Args:
+        access_token: Meta API access token (optional - will use cached token if not provided)  
+        interest_list: List of interest names to get suggestions for (e.g., ["Basketball", "Soccer"])
+        limit: Maximum number of suggestions to return (default: 25)
+    
+    Returns:
+        JSON string containing suggested interests with id, name, audience_size, and description fields
+    """
+    if not interest_list:
+        return json.dumps({"error": "No interest list provided"}, indent=2)
+    
+    endpoint = "search"
+    params = {
+        "type": "adinterestsuggestion", 
+        "interest_list": json.dumps(interest_list),
+        "limit": limit
+    }
+    
+    data = await make_api_request(endpoint, access_token, params)
+    
+    return json.dumps(data, indent=2)
+
+
+@mcp_server.tool()
+@meta_api_tool
+async def validate_interests(access_token: str = None, interest_list: List[str] = None, 
+                           interest_fbid_list: List[str] = None) -> str:
+    """
+    Validate interest names or IDs for targeting.
+    
+    Args:
+        access_token: Meta API access token (optional - will use cached token if not provided)
+        interest_list: List of interest names to validate (e.g., ["Japan", "Basketball"])
+        interest_fbid_list: List of interest IDs to validate (e.g., ["6003700426513"])
+    
+    Returns:
+        JSON string with validation results showing valid status and audience_size for each interest
+    """
+    if not interest_list and not interest_fbid_list:
+        return json.dumps({"error": "No interest list or FBID list provided"}, indent=2)
+    
+    endpoint = "search"
+    params = {
+        "type": "adinterestvalid"
+    }
+    
+    if interest_list:
+        params["interest_list"] = json.dumps(interest_list)
+    
+    if interest_fbid_list:
+        params["interest_fbid_list"] = json.dumps(interest_fbid_list)
+    
+    data = await make_api_request(endpoint, access_token, params)
+    
+    return json.dumps(data, indent=2)
+
+
+@mcp_server.tool()
+@meta_api_tool
+async def search_behaviors(access_token: str = None, limit: int = 50) -> str:
+    """
+    Get all available behavior targeting options.
+    
+    Args:
+        access_token: Meta API access token (optional - will use cached token if not provided)
+        limit: Maximum number of results to return (default: 50)
+    
+    Returns:
+        JSON string containing behavior targeting options with id, name, audience_size bounds, path, and description
+    """
+    endpoint = "search"
+    params = {
+        "type": "adTargetingCategory",
+        "class": "behaviors",
+        "limit": limit
+    }
+    
+    data = await make_api_request(endpoint, access_token, params)
+    
+    return json.dumps(data, indent=2)
+
+
+@mcp_server.tool()
+@meta_api_tool
+async def search_demographics(access_token: str = None, demographic_class: str = "demographics", limit: int = 50) -> str:
+    """
+    Get demographic targeting options.
+    
+    Args:
+        access_token: Meta API access token (optional - will use cached token if not provided)
+        demographic_class: Type of demographics to retrieve. Options: 'demographics', 'life_events', 
+                          'industries', 'income', 'family_statuses', 'user_device', 'user_os' (default: 'demographics')
+        limit: Maximum number of results to return (default: 50)
+    
+    Returns:
+        JSON string containing demographic targeting options with id, name, audience_size bounds, path, and description
+    """
+    endpoint = "search"
+    params = {
+        "type": "adTargetingCategory",
+        "class": demographic_class,
+        "limit": limit
+    }
+    
+    data = await make_api_request(endpoint, access_token, params)
+    
+    return json.dumps(data, indent=2)
+
+
+@mcp_server.tool()
+@meta_api_tool
+async def search_geo_locations(access_token: str = None, query: str = None, 
+                             location_types: List[str] = None, limit: int = 25) -> str:
+    """
+    Search for geographic targeting locations.
+    
+    Args:
+        access_token: Meta API access token (optional - will use cached token if not provided)
+        query: Search term for locations (e.g., "New York", "California", "Japan")
+        location_types: Types of locations to search. Options: ['country', 'region', 'city', 'zip', 
+                       'geo_market', 'electoral_district']. If not specified, searches all types.
+        limit: Maximum number of results to return (default: 25)
+    
+    Returns:
+        JSON string containing location data with key, name, type, and geographic hierarchy information
+    """
+    if not query:
+        return json.dumps({"error": "No search query provided"}, indent=2)
+    
+    endpoint = "search"
+    params = {
+        "type": "adgeolocation",
+        "q": query,
+        "limit": limit
+    }
+    
+    if location_types:
+        params["location_types"] = json.dumps(location_types)
+    
+    data = await make_api_request(endpoint, access_token, params)
+    
+    return json.dumps(data, indent=2) 

{meta_ads_mcp-0.5.0.dist-info → meta_ads_mcp-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meta-ads-mcp
-Version: 0.5.0
+Version: 0.7.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
@@ -331,6 +331,54 @@ 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`
+    - Search for interest targeting options by keyword
+    - Inputs:
+      - `access_token` (optional): Meta API access token (will use cached token if not provided)
+      - `query`: Search term for interests (e.g., "baseball", "cooking", "travel")
+      - `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`
+    - Get interest suggestions based on existing interests
+    - Inputs:
+      - `access_token` (optional): Meta API access token (will use cached token if not provided)
+      - `interest_list`: List of interest names to get suggestions for (e.g., ["Basketball", "Soccer"])
+      - `limit`: Maximum number of suggestions to return (default: 25)
+    - Returns: Suggested interests with id, name, audience_size, and description fields
+
+24. `mcp_meta_ads_validate_interests`
+    - Validate interest names or IDs for targeting
+    - Inputs:
+      - `access_token` (optional): Meta API access token (will use cached token if not provided)
+      - `interest_list`: List of interest names to validate (e.g., ["Japan", "Basketball"])
+      - `interest_fbid_list`: List of interest IDs to validate (e.g., ["6003700426513"])
+    - Returns: Validation results showing valid status and audience_size for each interest
+
+25. `mcp_meta_ads_search_behaviors`
+    - Get all available behavior targeting options
+    - Inputs:
+      - `access_token` (optional): Meta API access token (will use cached token if not provided)
+      - `limit`: Maximum number of results to return (default: 50)
+    - Returns: Behavior targeting options with id, name, audience_size bounds, path, and description
+
+26. `mcp_meta_ads_search_demographics`
+    - Get demographic targeting options
+    - Inputs:
+      - `access_token` (optional): Meta API access token (will use cached token if not provided)
+      - `demographic_class`: Type of demographics ('demographics', 'life_events', 'industries', 'income', 'family_statuses', 'user_device', 'user_os')
+      - `limit`: Maximum number of results to return (default: 50)
+    - Returns: Demographic targeting options with id, name, audience_size bounds, path, and description
+
+27. `mcp_meta_ads_search_geo_locations`
+    - Search for geographic targeting locations
+    - Inputs:
+      - `access_token` (optional): Meta API access token (will use cached token if not provided)
+      - `query`: Search term for locations (e.g., "New York", "California", "Japan")
+      - `location_types`: Types of locations to search (['country', 'region', 'city', 'zip', 'geo_market', 'electoral_district'])
+      - `limit`: Maximum number of results to return (default: 25)
+    - Returns: Location data with key, name, type, and geographic hierarchy information
+
 ## Privacy and Security
 
 Meta Ads MCP follows security best practices with secure token management and automatic authentication handling. 

{meta_ads_mcp-0.5.0.dist-info → meta_ads_mcp-0.7.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
-meta_ads_mcp/__init__.py,sha256=sEcedZMAxKadL65GY8HWRyv7PPaCxZ1QrVMtUMaCeh0,1182
+meta_ads_mcp/__init__.py,sha256=UDuLAO7mGVeZrzSJhTr3UAJKug3oHb6IK6OjooX6fk8,1492
 meta_ads_mcp/__main__.py,sha256=XaQt3iXftG_7f0Zu7Wop9SeFgrD2WBn0EQOaPMc27d8,207
-meta_ads_mcp/core/__init__.py,sha256=XVJjMOfdgnqxy3k8vCn2PCf7za8fMk4BdgJGiSFCVZY,1209
+meta_ads_mcp/core/__init__.py,sha256=IHBUfLTQW44VLbH_gZDT83nqzGrVWZ0l7FG4P3bp_bU,1706
 meta_ads_mcp/core/accounts.py,sha256=Nmp7lPxO9wmq25jWV7_H0LIqnEbBhpCVBlLGW2HUaq0,2277
 meta_ads_mcp/core/ads.py,sha256=aaK70mgfhBJRXr4cdkKag5mjYzvHuHpRttJvTMzPk4Y,36156
 meta_ads_mcp/core/ads_library.py,sha256=onStn9UkRqYDC60gOPS-iKDtP1plz6DygUb7hUZ0Jw8,2807
@@ -14,13 +14,15 @@ meta_ads_mcp/core/campaigns.py,sha256=Fd477GsD1Gx08Ve0uXUCvr4fC-xQCeVHPBwRVaeRQK
 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=U7KYdWQpGcdykE1WUtdJdYR3VTwKrXUzIzCREwWbf48,2599
+meta_ads_mcp/core/openai_deep_research.py,sha256=Ocs8bmNNBLZQLmWfL6azlC3RNzevVzV5WgcEp4H2wdY,13240
 meta_ads_mcp/core/pipeboard_auth.py,sha256=VvbxEB8ZOhnMccLU7HI1HgaPWHCl5NGrzZCm-zzHze4,22798
 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=mmhtcyB7h1aO6jK4njLztPdAebPDmc3mhA7DksR1nlY,17583
+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=ofKUhyo-5SZoJVuBeTVFPPQCffk0UKpwmDMrd8qQxNc,8715
-meta_ads_mcp-0.5.0.dist-info/METADATA,sha256=o0vClv8CNhB8eXp9a7ZAnCBKVDo77S_EPBrvV52dMC0,17580
-meta_ads_mcp-0.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-meta_ads_mcp-0.5.0.dist-info/entry_points.txt,sha256=Dv2RkoBjRJBqj6CyhwqGIiwPCD-SCL1-7B9-zmVRuv0,57
-meta_ads_mcp-0.5.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-meta_ads_mcp-0.5.0.dist-info/RECORD,,
+meta_ads_mcp-0.7.0.dist-info/METADATA,sha256=ADo7W0ulgt6gIZzJjOkyxM-PDqE0inab-THLjsStoGo,20409
+meta_ads_mcp-0.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+meta_ads_mcp-0.7.0.dist-info/entry_points.txt,sha256=Dv2RkoBjRJBqj6CyhwqGIiwPCD-SCL1-7B9-zmVRuv0,57
+meta_ads_mcp-0.7.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+meta_ads_mcp-0.7.0.dist-info/RECORD,,