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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meta-ads-mcp
-Version: 0.9.1
+Version: 0.9.3
 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
@@ -136,7 +136,7 @@ For local installation configuration, authentication options, and advanced techn
    - Inputs:
      - `access_token` (optional): Meta API access token (will use cached token if not provided)
      - `user_id`: Meta user ID or "me" for the current user
-     - `limit`: Maximum number of accounts to return (default: 10)
+     - `limit`: Maximum number of accounts to return (default: 200)
    - Returns: List of accessible ad accounts with their details
 
 2. `mcp_meta_ads_get_account_info`

{meta_ads_mcp-0.9.1 → meta_ads_mcp-0.9.3}/README.md

@@ -111,7 +111,7 @@ For local installation configuration, authentication options, and advanced techn
    - Inputs:
      - `access_token` (optional): Meta API access token (will use cached token if not provided)
      - `user_id`: Meta user ID or "me" for the current user
-     - `limit`: Maximum number of accounts to return (default: 10)
+     - `limit`: Maximum number of accounts to return (default: 200)
    - Returns: List of accessible ad accounts with their details
 
 2. `mcp_meta_ads_get_account_info`

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

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

{meta_ads_mcp-0.9.1 → meta_ads_mcp-0.9.3}/meta_ads_mcp/core/accounts.py

@@ -8,14 +8,14 @@ from .server import mcp_server
 
 @mcp_server.tool()
 @meta_api_tool
-async def get_ad_accounts(access_token: str = None, user_id: str = "me", limit: int = 10) -> str:
+async def get_ad_accounts(access_token: str = None, user_id: str = "me", limit: int = 200) -> str:
     """
     Get ad accounts accessible by a user.
     
     Args:
         access_token: Meta API access token (optional - will use cached token if not provided)
         user_id: Meta user ID or "me" for the current user
-        limit: Maximum number of accounts to return (default: 10)
+        limit: Maximum number of accounts to return (default: 200)
     """
     endpoint = f"{user_id}/adaccounts"
     params = {
@@ -51,32 +51,7 @@ async def get_account_info(access_token: str = None, account_id: str = None) ->
     if not account_id.startswith("act_"):
         account_id = f"act_{account_id}"
     
-    # First, check if the account is accessible to the user
-    endpoint = "me/adaccounts"
-    params = {
-        "fields": "id,name,account_id,account_status,amount_spent,balance,currency,age,business_city,business_country_code",
-        "limit": 50
-    }
-    accessible_accounts_data = await make_api_request(endpoint, access_token, params)
-    
-    if "data" in accessible_accounts_data:
-        accessible_account_ids = [acc["id"] for acc in accessible_accounts_data["data"]]
-        if account_id not in accessible_account_ids:
-            # Provide a helpful error message with accessible accounts
-            accessible_accounts = [
-                {"id": acc["id"], "name": acc["name"]} 
-                for acc in accessible_accounts_data["data"][:10]  # Show first 10
-            ]
-            return {
-                "error": {
-                    "message": f"Account {account_id} is not accessible to your user account",
-                    "details": "This account either doesn't exist or you don't have permission to access it",
-                    "accessible_accounts": accessible_accounts,
-                    "total_accessible_accounts": len(accessible_accounts_data["data"]),
-                    "suggestion": "Try using one of the accessible account IDs listed above"
-                }
-            }
-    
+    # Try to get the account info directly first
     endpoint = f"{account_id}"
     params = {
         "fields": "id,name,account_id,account_status,amount_spent,balance,currency,age,business_city,business_country_code,timezone_name"
@@ -86,6 +61,32 @@ async def get_account_info(access_token: str = None, account_id: str = None) ->
     
     # Check if the API request returned an error
     if "error" in data:
+        # If access was denied, provide helpful error message with accessible accounts
+        if "access" in str(data.get("error", {})).lower() or "permission" in str(data.get("error", {})).lower():
+            # Get list of accessible accounts for helpful error message
+            accessible_endpoint = "me/adaccounts"
+            accessible_params = {
+                "fields": "id,name,account_id,account_status,amount_spent,balance,currency,age,business_city,business_country_code",
+                "limit": 50
+            }
+            accessible_accounts_data = await make_api_request(accessible_endpoint, access_token, accessible_params)
+            
+            if "data" in accessible_accounts_data:
+                accessible_accounts = [
+                    {"id": acc["id"], "name": acc["name"]} 
+                    for acc in accessible_accounts_data["data"][:10]  # Show first 10
+                ]
+                return {
+                    "error": {
+                        "message": f"Account {account_id} is not accessible to your user account",
+                        "details": "This account either doesn't exist or you don't have permission to access it",
+                        "accessible_accounts": accessible_accounts,
+                        "total_accessible_accounts": len(accessible_accounts_data["data"]),
+                        "suggestion": "Try using one of the accessible account IDs listed above"
+                    }
+                }
+        
+        # Return the original error for non-permission related issues
         return data
     
     # Add DSA requirement detection

{meta_ads_mcp-0.9.1 → meta_ads_mcp-0.9.3}/meta_ads_mcp/core/adsets.py

@@ -104,6 +104,8 @@ async def create_adset(
     start_time: str = None,
     end_time: str = None,
     dsa_beneficiary: str = None,
+    promoted_object: Dict[str, Any] = None,
+    destination_type: str = None,
     access_token: str = None
 ) -> str:
     """
@@ -118,13 +120,18 @@ async def create_adset(
         lifetime_budget: Lifetime budget in account currency (in cents) as a string
         targeting: Targeting specifications including age, location, interests, etc.
                   Use targeting_automation.advantage_audience=1 for automatic audience finding
-        optimization_goal: Conversion optimization goal (e.g., 'LINK_CLICKS', 'REACH', 'CONVERSIONS')
+        optimization_goal: Conversion optimization goal (e.g., 'LINK_CLICKS', 'REACH', 'CONVERSIONS', 'APP_INSTALLS')
         billing_event: How you're charged (e.g., 'IMPRESSIONS', 'LINK_CLICKS')
         bid_amount: Bid amount in account currency (in cents)
         bid_strategy: Bid strategy (e.g., 'LOWEST_COST', 'LOWEST_COST_WITH_BID_CAP')
         start_time: Start time in ISO 8601 format (e.g., '2023-12-01T12:00:00-0800')
         end_time: End time in ISO 8601 format
         dsa_beneficiary: DSA beneficiary (person/organization benefiting from ads) for European compliance
+        promoted_object: Mobile app configuration for APP_INSTALLS campaigns. Required fields: application_id, object_store_url.
+                        Optional fields: custom_event_type, pixel_id, page_id.
+                        Example: {"application_id": "123456789012345", "object_store_url": "https://apps.apple.com/app/id123456789"}
+        destination_type: Where users are directed after clicking the ad (e.g., 'APP_STORE', 'DEEPLINK', 'APP_INSTALL').
+                         Required for mobile app campaigns.
         access_token: Meta API access token (optional - will use cached token if not provided)
     """
     # Check required parameters
@@ -143,6 +150,59 @@ async def create_adset(
     if not billing_event:
         return json.dumps({"error": "No billing event provided"}, indent=2)
     
+    # Validate mobile app parameters for APP_INSTALLS campaigns
+    if optimization_goal == "APP_INSTALLS":
+        if not promoted_object:
+            return json.dumps({
+                "error": "promoted_object is required for APP_INSTALLS optimization goal",
+                "details": "Mobile app campaigns must specify which app is being promoted",
+                "required_fields": ["application_id", "object_store_url"]
+            }, indent=2)
+        
+        # Validate promoted_object structure
+        if not isinstance(promoted_object, dict):
+            return json.dumps({
+                "error": "promoted_object must be a dictionary",
+                "example": {"application_id": "123456789012345", "object_store_url": "https://apps.apple.com/app/id123456789"}
+            }, indent=2)
+        
+        # Validate required promoted_object fields
+        if "application_id" not in promoted_object:
+            return json.dumps({
+                "error": "promoted_object missing required field: application_id",
+                "details": "application_id is the Facebook app ID for your mobile app"
+            }, indent=2)
+        
+        if "object_store_url" not in promoted_object:
+            return json.dumps({
+                "error": "promoted_object missing required field: object_store_url", 
+                "details": "object_store_url should be the App Store or Google Play URL for your app"
+            }, indent=2)
+        
+        # Validate store URL format
+        store_url = promoted_object["object_store_url"]
+        valid_store_patterns = [
+            "apps.apple.com",  # iOS App Store
+            "play.google.com",  # Google Play Store
+            "itunes.apple.com"  # Alternative iOS format
+        ]
+        
+        if not any(pattern in store_url for pattern in valid_store_patterns):
+            return json.dumps({
+                "error": "Invalid object_store_url format",
+                "details": "URL must be from App Store (apps.apple.com) or Google Play (play.google.com)",
+                "provided_url": store_url
+            }, indent=2)
+    
+    # Validate destination_type if provided
+    if destination_type:
+        valid_destination_types = ["APP_STORE", "DEEPLINK", "APP_INSTALL"]
+        if destination_type not in valid_destination_types:
+            return json.dumps({
+                "error": f"Invalid destination_type: {destination_type}",
+                "valid_values": valid_destination_types
+            }, indent=2)
+    
     # Basic targeting is required if not provided
     if not targeting:
         targeting = {
@@ -187,6 +247,13 @@ async def create_adset(
     if dsa_beneficiary:
         params["dsa_beneficiary"] = dsa_beneficiary
     
+    # Add mobile app parameters if provided
+    if promoted_object:
+        params["promoted_object"] = json.dumps(promoted_object)
+    
+    if destination_type:
+        params["destination_type"] = destination_type
+    
     try:
         data = await make_api_request(endpoint, access_token, params, method="POST")
         return json.dumps(data, indent=2)

{meta_ads_mcp-0.9.1 → meta_ads_mcp-0.9.3}/meta_ads_mcp/core/openai_deep_research.py

@@ -23,7 +23,7 @@ class MetaAdsDataManager:
         self._cache = {}
         logger.debug("MetaAdsDataManager initialized")
     
-    async def _get_ad_accounts(self, access_token: str, limit: int = 25) -> List[Dict[str, Any]]:
+    async def _get_ad_accounts(self, access_token: str, limit: int = 200) -> List[Dict[str, Any]]:
         """Get ad accounts data"""
         try:
             endpoint = "me/adaccounts"
@@ -141,7 +141,7 @@ class MetaAdsDataManager:
         
         try:
             # Search ad accounts
-            accounts = await self._get_ad_accounts(access_token, limit=25)
+            accounts = await self._get_ad_accounts(access_token, limit=200)
             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()
                 

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "meta-ads-mcp"
-version = "0.9.1"
+version = "0.9.3"
 description = "Model Context Protocol (MCP) plugin for interacting with Meta Ads API"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -39,3 +39,11 @@ meta-ads-mcp = "meta_ads_mcp:entrypoint"
 
 [tool.hatch.build.targets.wheel]
 packages = ["meta_ads_mcp"]
+
+[tool.pytest.ini_options]
+markers = [
+    "e2e: marks tests as end-to-end (requires running MCP server) - excluded from default runs",
+]
+addopts = "-v --strict-markers -m 'not e2e'"
+testpaths = ["tests"]
+asyncio_mode = "auto"

meta_ads_mcp-0.9.3/tests/e2e_account_info_search_issue.py

@@ -0,0 +1,320 @@
+#!/usr/bin/env python3
+"""
+E2E Test for Account Info Search Issue
+
+This test reproduces the issue reported by a user where get_account_info
+cannot find account ID 414174661097171, while get_ad_accounts can see it.
+
+Usage:
+    1. Start the server: uv run python -m meta_ads_mcp --transport streamable-http --port 8080
+    2. Run test: uv run python tests/e2e_account_info_search_issue.py
+
+Or with pytest (manual only):
+    uv run python -m pytest tests/e2e_account_info_search_issue.py -v -m e2e
+"""
+
+import pytest
+import requests
+import json
+from typing import Dict, Any
+
+@pytest.mark.e2e
+@pytest.mark.skip(reason="E2E test - run manually only")
+class TestAccountInfoSearchIssue:
+    """E2E test for account info search issue"""
+    
+    def __init__(self, base_url: str = "http://localhost:8080"):
+        self.base_url = base_url.rstrip('/')
+        self.endpoint = f"{self.base_url}/mcp/"
+        self.request_id = 1
+        self.target_account_id = "414174661097171"
+    
+    def test_get_ad_accounts_can_see_target_account(self):
+        """Verify get_ad_accounts can see account 414174661097171"""
+        print(f"\n🔍 Testing if get_ad_accounts can see account {self.target_account_id}")
+        
+        params = {
+            "name": "get_ad_accounts",
+            "arguments": {}
+        }
+        
+        result = self._make_request("tools/call", params)
+        
+        if not result["success"]:
+            return {
+                "success": False,
+                "error": f"Request failed: {result.get('error', 'Unknown error')}",
+                "status_code": result["status_code"]
+            }
+        
+        try:
+            response_data = result["json"]["result"]
+            content = response_data.get("content", [{}])[0].get("text", "")
+            parsed_content = json.loads(content)
+            
+            # Check for errors first
+            error_info = self._check_for_errors(parsed_content)
+            if error_info["has_error"]:
+                return {
+                    "success": False,
+                    "error": f"get_ad_accounts returned error: {error_info['error_message']}",
+                    "error_format": error_info["format"]
+                }
+            
+            # Extract accounts data
+            accounts = []
+            if "data" in parsed_content:
+                data = parsed_content["data"]
+                
+                # Handle case where data is already parsed (list/dict)
+                if isinstance(data, list):
+                    accounts = data
+                elif isinstance(data, dict) and "data" in data:
+                    accounts = data["data"]
+                
+                # Handle case where data is a JSON string that needs parsing
+                elif isinstance(data, str):
+                    try:
+                        parsed_data = json.loads(data)
+                        if isinstance(parsed_data, list):
+                            accounts = parsed_data
+                        elif isinstance(parsed_data, dict) and "data" in parsed_data:
+                            accounts = parsed_data["data"]
+                    except json.JSONDecodeError:
+                        pass
+            elif isinstance(parsed_content, list):
+                accounts = parsed_content
+            
+            # Search for target account
+            found_account = None
+            for account in accounts:
+                if isinstance(account, dict):
+                    account_id = account.get("id", "").replace("act_", "")
+                    if account_id == self.target_account_id:
+                        found_account = account
+                        break
+            
+            result_data = {
+                "success": True,
+                "total_accounts": len(accounts),
+                "target_account_found": found_account is not None,
+                "found_account_details": found_account if found_account else None,
+                "all_account_ids": [
+                    acc.get("id", "").replace("act_", "") 
+                    for acc in accounts 
+                    if isinstance(acc, dict) and acc.get("id")
+                ]
+            }
+            
+            print(f"✅ get_ad_accounts results:")
+            print(f"   Total accounts found: {result_data['total_accounts']}")
+            print(f"   Target account {self.target_account_id} found: {result_data['target_account_found']}")
+            if found_account:
+                print(f"   Account details: {found_account}")
+            
+            return result_data
+            
+        except json.JSONDecodeError as e:
+            return {
+                "success": False,
+                "error": f"Could not parse get_ad_accounts response: {str(e)}",
+                "raw_content": content
+            }
+    
+    def test_get_account_info_cannot_find_target_account(self):
+        """Verify get_account_info cannot find account 414174661097171"""
+        print(f"\n🔍 Testing if get_account_info can find account {self.target_account_id}")
+        
+        params = {
+            "name": "get_account_info",
+            "arguments": {
+                "account_id": self.target_account_id
+            }
+        }
+        
+        result = self._make_request("tools/call", params)
+        
+        if not result["success"]:
+            return {
+                "success": False,
+                "error": f"Request failed: {result.get('error', 'Unknown error')}",
+                "status_code": result["status_code"]
+            }
+        
+        try:
+            response_data = result["json"]["result"]
+            content = response_data.get("content", [{}])[0].get("text", "")
+            parsed_content = json.loads(content)
+            
+            # Check for errors
+            error_info = self._check_for_errors(parsed_content)
+            
+            result_data = {
+                "success": True,
+                "has_error": error_info["has_error"],
+                "error_message": error_info.get("error_message", ""),
+                "error_format": error_info.get("format", ""),
+                "raw_response": parsed_content
+            }
+            
+            print(f"✅ get_account_info results:")
+            print(f"   Has error: {result_data['has_error']}")
+            if result_data['has_error']:
+                print(f"   Error message: {result_data['error_message']}")
+                print(f"   Error format: {result_data['error_format']}")
+            else:
+                print(f"   Unexpected success: {parsed_content}")
+            
+            return result_data
+            
+        except json.JSONDecodeError as e:
+            return {
+                "success": False,
+                "error": f"Could not parse get_account_info response: {str(e)}",
+                "raw_content": content
+            }
+    
+    def _check_for_errors(self, parsed_content: Dict[str, Any]) -> Dict[str, Any]:
+        """Properly handle both wrapped and direct error formats"""
+        
+        # Check for data wrapper format first
+        if "data" in parsed_content:
+            data = parsed_content["data"]
+            
+            # Handle case where data is already parsed (dict/list)
+            if isinstance(data, dict) and 'error' in data:
+                return {
+                    "has_error": True,
+                    "error_message": data['error'],
+                    "error_details": data.get('details', ''),
+                    "format": "wrapped_dict"
+                }
+            
+            # Handle case where data is a JSON string that needs parsing
+            if isinstance(data, str):
+                try:
+                    error_data = json.loads(data)
+                    if 'error' in error_data:
+                        return {
+                            "has_error": True,
+                            "error_message": error_data['error'],
+                            "error_details": error_data.get('details', ''),
+                            "format": "wrapped_json"
+                        }
+                except json.JSONDecodeError:
+                    # Data field exists but isn't valid JSON
+                    pass
+        
+        # Check for direct error format
+        if 'error' in parsed_content:
+            return {
+                "has_error": True,
+                "error_message": parsed_content['error'],
+                "error_details": parsed_content.get('details', ''),
+                "format": "direct"
+            }
+        
+        return {"has_error": False}
+    
+    def _make_request(self, method: str, params: Dict[str, Any] = None) -> Dict[str, Any]:
+        """Make a JSON-RPC request to the MCP server"""
+        
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/event-stream",
+            "User-Agent": "E2E-Test-Client/1.0"
+        }
+        
+        payload = {
+            "jsonrpc": "2.0",
+            "method": method,
+            "id": self.request_id
+        }
+        
+        if params:
+            payload["params"] = params
+        
+        try:
+            response = requests.post(
+                self.endpoint,
+                headers=headers,
+                json=payload,
+                timeout=30
+            )
+            
+            self.request_id += 1
+            
+            return {
+                "status_code": response.status_code,
+                "json": response.json() if response.status_code == 200 else None,
+                "text": response.text,
+                "success": response.status_code == 200
+            }
+            
+        except requests.exceptions.RequestException as e:
+            return {
+                "status_code": 0,
+                "json": None,
+                "text": str(e),
+                "success": False,
+                "error": str(e)
+            }
+
+def run_validation():
+    """Run the validation tests"""
+    print("🚀 Starting Account Info Search Issue Validation")
+    print(f"Target Account ID: 414174661097171")
+    print("="*60)
+    
+    test_instance = TestAccountInfoSearchIssue()
+    
+    # Test 1: Check if get_ad_accounts can see the account
+    accounts_result = test_instance.test_get_ad_accounts_can_see_target_account()
+    
+    # Test 2: Check if get_account_info can find the account
+    account_info_result = test_instance.test_get_account_info_cannot_find_target_account()
+    
+    print("\n" + "="*60)
+    print("📊 VALIDATION SUMMARY")
+    print("="*60)
+    
+    if accounts_result["success"]:
+        print(f"✅ get_ad_accounts: Found {accounts_result['total_accounts']} total accounts")
+        if accounts_result["target_account_found"]:
+            print(f"✅ get_ad_accounts: Target account 414174661097171 IS visible")
+        else:
+            print(f"❌ get_ad_accounts: Target account 414174661097171 is NOT visible")
+            print(f"   Available account IDs: {accounts_result.get('all_account_ids', [])}")
+    else:
+        print(f"❌ get_ad_accounts: Failed - {accounts_result['error']}")
+    
+    if account_info_result["success"]:
+        if account_info_result["has_error"]:
+            print(f"❌ get_account_info: Cannot find account (Error: {account_info_result['error_message']})")
+        else:
+            print(f"✅ get_account_info: Successfully found account")
+    else:
+        print(f"❌ get_account_info: Test failed - {account_info_result['error']}")
+    
+    # Determine if issue is confirmed
+    issue_confirmed = (
+        accounts_result.get("success", False) and
+        accounts_result.get("target_account_found", False) and
+        account_info_result.get("success", False) and
+        account_info_result.get("has_error", False)
+    )
+    
+    print("\n" + "="*60)
+    if issue_confirmed:
+        print("🐛 ISSUE CONFIRMED:")
+        print("   - get_ad_accounts CAN see the account")
+        print("   - get_account_info CANNOT find the account")
+        print("   - This validates the user's complaint")
+    else:
+        print("🤔 ISSUE NOT CONFIRMED:")
+        print("   - The behavior may be different than reported")
+        print("   - Check individual test results above")
+    print("="*60)
+
+if __name__ == "__main__":
+    run_validation()