meta-ads-mcp 0.2.3__py3-none-any.whl → 0.2.4__py3-none-any.whl

meta_ads_mcp/api.py

@@ -26,15 +26,8 @@ META_GRAPH_API_VERSION = "v20.0"
 META_GRAPH_API_BASE = f"https://graph.facebook.com/{META_GRAPH_API_VERSION}"
 USER_AGENT = "meta-ads-mcp/1.0"
 
-# Meta App configuration - Using a placeholder app ID. This will be overridden by:
-# 1. Command line arguments
-# 2. Environment variables 
-# 3. User input during runtime
-META_APP_ID = "YOUR_META_APP_ID"  # Will be replaced at runtime
-
-# Try to load from environment variable
-if os.environ.get("META_APP_ID"):
-    META_APP_ID = os.environ.get("META_APP_ID")
+# Meta App configuration 
+META_APP_ID = os.environ.get("META_APP_ID", "")  # Default to empty string
 
 # Auth constants
 AUTH_SCOPE = "ads_management,ads_read,business_management"
@@ -55,6 +48,35 @@ callback_server_port = None
 # Global token container for communication between threads
 token_container = {"token": None, "expires_in": None, "user_id": None}
 
+# Configuration class to store app ID and other config
+class MetaConfig:
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(MetaConfig, cls).__new__(cls)
+            cls._instance.app_id = os.environ.get("META_APP_ID", "")  # Default from env
+            cls._instance.initialized = False
+        return cls._instance
+    
+    def set_app_id(self, app_id):
+        """Set app ID from CLI or other source"""
+        if app_id:
+            print(f"Setting Meta App ID: {app_id}")
+            self.app_id = app_id
+            self.initialized = True
+    
+    def get_app_id(self):
+        """Get current app ID"""
+        return self.app_id
+        
+    def is_configured(self):
+        """Check if app has been configured with valid app ID"""
+        return bool(self.app_id)
+
+# Create global config instance
+meta_config = MetaConfig()
+
 # Callback Handler class definition
 class CallbackHandler(BaseHTTPRequestHandler):
     def do_GET(self):
@@ -302,8 +324,8 @@ class AuthManager:
         """Clear the current token and remove from cache"""
         self.invalidate_token()
 
-# Initialize auth manager
-auth_manager = AuthManager(META_APP_ID)
+# Initialize auth manager with app_id from config
+auth_manager = AuthManager(meta_config.get_app_id())
 
 # Function to get token without requiring it as a parameter
 async def get_current_access_token() -> Optional[str]:
@@ -315,6 +337,24 @@ async def get_current_access_token() -> Optional[str]:
     """
     return auth_manager.get_access_token()
 
+# Function to get current app ID from all possible sources
+def get_current_app_id():
+    """Get the current app ID from MetaConfig."""
+    # First try to get from our singleton config
+    app_id = meta_config.get_app_id()
+    if app_id:
+        return app_id
+    
+    # If not in config yet, check environment as fallback
+    env_app_id = os.environ.get("META_APP_ID", "")
+    if env_app_id:
+        # Update config for future use
+        meta_config.set_app_id(env_app_id)
+        return env_app_id
+    
+    # Last resort, return empty string
+    return ""
+
 class GraphAPIError(Exception):
     """Exception raised for errors from the Graph API."""
     def __init__(self, error_data: Dict[str, Any]):
@@ -345,6 +385,17 @@ async def make_api_request(
     Returns:
         API response as a dictionary
     """
+    # Validate access token before proceeding
+    if not access_token:
+        print("API request attempted with blank access token")
+        return {
+            "error": "Authentication Required",
+            "details": {
+                "message": "A valid access token is required to access the Meta API",
+                "action_required": "Please authenticate first"
+            }
+        }
+        
     url = f"{META_GRAPH_API_BASE}/{endpoint}"
     
     headers = {
@@ -391,6 +442,19 @@ async def make_api_request(
                 # Check for specific FB API errors related to auth
                 if isinstance(error_obj, dict) and error_obj.get("code") in [190, 102, 4, 200, 10]:
                     print(f"Detected Facebook API auth error: {error_obj.get('code')}")
+                    # For app ID errors, provide more useful error message
+                    if error_obj.get("code") == 200 and "Provide valid app ID" in error_obj.get("message", ""):
+                        print("Meta API authentication configuration issue")
+                        app_id = auth_manager.app_id
+                        print(f"Current app_id: {app_id}")
+                        return {
+                            "error": f"HTTP Error: {e.response.status_code}",
+                            "details": {
+                                "message": "Meta API authentication configuration issue. Please check your app credentials.",
+                                "original_error": error_obj.get("message"),
+                                "code": error_obj.get("code")
+                            }
+                        }
                     auth_manager.invalidate_token()
             
             return {"error": f"HTTP Error: {e.response.status_code}", "details": error_info}
@@ -403,6 +467,7 @@ async def make_api_request(
 def meta_api_tool(func):
     """Decorator to handle authentication for all Meta API tools"""
     async def wrapper(*args, **kwargs):
+        global needs_authentication
         # Handle various MCP invocation patterns
         if len(args) == 1:
             # MCP might pass a single string argument that contains JSON
@@ -449,39 +514,44 @@ def meta_api_tool(func):
         # If not, try to get it from the auth manager
         if not access_token:
             access_token = await get_current_access_token()
+            if access_token:
+                kwargs['access_token'] = access_token
         
         # If still no token, we need authentication
         if not access_token:
-            global needs_authentication
             needs_authentication = True
             
             # Start the callback server
             port = start_callback_server()
             
+            # Get current app ID from config
+            current_app_id = meta_config.get_app_id()
+            if not current_app_id:
+                return json.dumps({
+                    "error": "No Meta App ID provided. Please provide a valid app ID via environment variable META_APP_ID or --app-id CLI argument.",
+                    "help": "This is required for authentication with Meta Graph API."
+                }, indent=2)
+                
+            # Update auth manager with current app ID
+            auth_manager.app_id = current_app_id
+            print(f"Using Meta App ID from config: {current_app_id}")
+            
             # Update auth manager's redirect URI with the current port
             auth_manager.redirect_uri = f"http://localhost:{port}/callback"
             
             # Generate the authentication URL
             login_url = auth_manager.get_auth_url()
             
-            # Create a resource response that includes the markdown link format
-            response = {
-                "error": "Authentication required to use Meta Ads API",
-                "login_url": login_url,
-                "server_status": f"Callback server running on port {port}",
-                "markdown_link": f"[Click here to authenticate with Meta Ads API]({login_url})",
-                "message": "IMPORTANT: Please use the Markdown link format in your response to allow the user to click it.",
-                "instructions_for_llm": "You must present this link as clickable Markdown to the user using the markdown_link format provided.",
-                "note": "After authenticating, the token will be automatically saved."
-            }
-            
-            # Wait a moment to ensure the server is fully started
-            await asyncio.sleep(1)
-            
-            return json.dumps(response, indent=2)
-        
-        # Update kwargs with the token
-        kwargs['access_token'] = access_token
+            # Return a user-friendly authentication required response
+            return json.dumps({
+                "error": "Authentication Required",
+                "details": {
+                    "message": "You need to authenticate with the Meta API before using this tool",
+                    "action_required": "Please authenticate using the link below",
+                    "login_url": login_url,
+                    "markdown_link": f"[Click here to authenticate with Meta Ads API]({login_url})"
+                }
+            }, indent=2)
         
         # Call the original function
         try:
@@ -492,6 +562,17 @@ def meta_api_tool(func):
                 # Start the callback server
                 port = start_callback_server()
                 
+                # Get current app ID from config
+                current_app_id = meta_config.get_app_id()
+                if not current_app_id:
+                    return json.dumps({
+                        "error": "No Meta App ID provided. Please provide a valid app ID via environment variable META_APP_ID or --app-id CLI argument.",
+                        "help": "This is required for authentication with Meta Graph API."
+                    }, indent=2)
+                    
+                auth_manager.app_id = current_app_id
+                print(f"Using Meta App ID from config: {current_app_id}")
+                
                 # Update auth manager's redirect URI with the current port
                 auth_manager.redirect_uri = f"http://localhost:{port}/callback"
                 
@@ -514,6 +595,28 @@ def meta_api_tool(func):
                 
                 return json.dumps(response, indent=2)
             
+            # If result is a string (JSON), check for app ID errors and improve them
+            if isinstance(result, str):
+                try:
+                    result_obj = json.loads(result)
+                    if "error" in result_obj and "details" in result_obj and "error" in result_obj["details"]:
+                        error_obj = result_obj["details"].get("error", {})
+                        if isinstance(error_obj, dict) and error_obj.get("code") == 200 and "Provide valid app ID" in error_obj.get("message", ""):
+                            # Replace with more user-friendly message
+                            app_id = auth_manager.app_id
+                            return json.dumps({
+                                "error": "Meta API Configuration Issue",
+                                "details": {
+                                    "message": "Your Meta API app is not properly configured",
+                                    "action_required": "Check your META_APP_ID environment variable",
+                                    "current_app_id": app_id,
+                                    "original_error": error_obj.get("message")
+                                }
+                            }, indent=2)
+                except Exception:
+                    # Not JSON or other parsing error, just continue
+                    pass
+            
             return result
         except Exception as e:
             # Handle any unexpected errors
@@ -1171,10 +1274,35 @@ async def get_insights(
         breakdown: Optional breakdown dimension (e.g., age, gender, country)
         level: Level of aggregation (ad, adset, campaign, account)
     """
+    # Import logger
+    from meta_ads_mcp.core.utils import logger
+    
+    # Log function call details
+    logger.info(f"get_insights called with object_id: {object_id}, time_range: {time_range}, level: {level}")
+    
+    # Log authentication details
+    from meta_ads_mcp.core.auth import meta_config
+    app_id = meta_config.get_app_id()
+    logger.info(f"App ID from meta_config: {app_id}")
+    
+    # Validate inputs
     if not object_id:
-        return json.dumps({"error": "No object ID provided"}, indent=2)
+        logger.error("No object ID provided for get_insights")
+        return json.dumps({"error": "Missing Required Parameter", "details": {"message": "No object ID provided"}}, indent=2)
         
+    # Check access token (masking for security)
+    token_status = "provided" if access_token else "not provided"
+    logger.info(f"Access token status: {token_status}")
+    
+    # Log the specific object ID format for troubleshooting
+    if object_id.startswith("act_"):
+        logger.info(f"Object ID is an account ID: {object_id}")
+    else:
+        logger.info(f"Object ID format: {object_id}")
+    
     endpoint = f"{object_id}/insights"
+    logger.info(f"Using endpoint: {endpoint}")
+    
     params = {
         "date_preset": time_range,
         "fields": "account_id,account_name,campaign_id,campaign_name,adset_id,adset_name,ad_id,ad_name,impressions,clicks,spend,cpc,cpm,ctr,reach,frequency,actions,conversions,unique_clicks,cost_per_action_type",
@@ -1184,43 +1312,52 @@ async def get_insights(
     if breakdown:
         params["breakdowns"] = breakdown
     
-    data = await make_api_request(endpoint, access_token, params)
+    logger.info("Making API request for insights")
+    try:
+        data = await make_api_request(endpoint, access_token, params)
+        logger.info(f"API response received: {'success' if 'error' not in data else 'error'}")
+        
+        # Check for specific app ID errors and improve error message
+        if "error" in data:
+            error_details = data.get("details", {}).get("error", {})
+            if isinstance(error_details, dict) and error_details.get("code") == 200:
+                logger.error(f"Authentication configuration error in response: {error_details.get('message')}")
+                return json.dumps({
+                    "error": "Meta API Configuration Issue", 
+                    "details": {
+                        "message": "There is an issue with your Meta API configuration",
+                        "action_required": "Check your META_APP_ID environment variable or re-authenticate",
+                        "current_app_id": app_id
+                    }
+                }, indent=2)
+    except Exception as e:
+        logger.error(f"Exception during get_insights API call: {str(e)}")
+        data = {"error": str(e)}
     
     return json.dumps(data, indent=2)
 
 @mcp_server.tool()
 @meta_api_tool
-async def debug_image_download(access_token: str = None, url: str = "", ad_id: str = "") -> str:
-    """
-    Debug image download issues and report detailed diagnostics.
-    
-    Args:
-        access_token: Meta API access token (optional - will use cached token if not provided)
-        url: Direct image URL to test (optional)
-        ad_id: Meta Ads ad ID (optional, used if url is not provided)
-    """
-    results = {
-        "diagnostics": {
-            "timestamp": str(datetime.datetime.now()),
-            "methods_tried": [],
-            "request_details": [],
-            "network_info": {}
-        }
-    }
+async def debug_image_download(url="", ad_id="", access_token=None):
+    """Debug image download issues and report detailed diagnostics."""
+    results = {}
     
-    # If no URL provided but ad_id is, get URL from ad creative
-    if not url and ad_id:
-        print(f"Getting image URL from ad creative for ad {ad_id}")
-        # Get the creative details
-        creative_json = await get_ad_creatives(access_token=access_token, ad_id=ad_id)
-        creative_data = json.loads(creative_json)
-        results["creative_data"] = creative_data
-        
-        # Look for image URL in the creative
-        if "full_image_url" in creative_data:
-            url = creative_data.get("full_image_url")
-        elif "thumbnail_url" in creative_data:
-            url = creative_data.get("thumbnail_url")
+    if url:
+        results["image_url"] = url
+    else:
+        # If no URL provided but ad_id is, get URL from ad creative
+        if ad_id:
+            print(f"Getting image URL from ad creative for ad {ad_id}")
+            # Get the creative details
+            creative_json = await get_ad_creatives(access_token=access_token, ad_id=ad_id)
+            creative_data = json.loads(creative_json)
+            results["creative_data"] = creative_data
+            
+            # Look for image URL in the creative
+            if "full_image_url" in creative_data:
+                url = creative_data.get("full_image_url")
+            elif "thumbnail_url" in creative_data:
+                url = creative_data.get("thumbnail_url")
     
     if not url:
         return json.dumps({
@@ -1229,29 +1366,13 @@ async def debug_image_download(access_token: str = None, url: str = "", ad_id: s
         }, indent=2)
     
     results["image_url"] = url
-    print(f"Debug: Testing image URL: {url}")
-    
-    # Try to get network information to help debug
-    try:
-        import socket
-        hostname = urlparse(url).netloc
-        ip_address = socket.gethostbyname(hostname)
-        results["diagnostics"]["network_info"] = {
-            "hostname": hostname,
-            "ip_address": ip_address,
-            "is_facebook_cdn": "fbcdn" in hostname
-        }
-    except Exception as e:
-        results["diagnostics"]["network_info"] = {
-            "error": str(e)
-        }
     
     # Method 1: Basic download
     method_result = {
         "method": "Basic download with standard headers",
         "success": False
     }
-    results["diagnostics"]["methods_tried"].append(method_result)
+    results["diagnostics"] = {"methods_tried": [method_result]}
     
     try:
         headers = {
@@ -1386,228 +1507,160 @@ async def save_ad_image_via_api(access_token: str = None, ad_id: str = None) ->
     if not ad_id:
         return json.dumps({"error": "No ad ID provided"}, indent=2)
         
-    # First get the ad's creative ID
+    print(f"Attempting to save image for ad {ad_id} using API methods")
+    
+    # First, get creative ID and account ID
     ad_endpoint = f"{ad_id}"
     ad_params = {
-        "fields": "creative,account_id"
+        "fields": "creative{id},account_id"
     }
     
     ad_data = await make_api_request(ad_endpoint, access_token, ad_params)
     
     if "error" in ad_data:
-        return json.dumps({
-            "error": "Could not get ad data",
-            "details": ad_data
-        }, indent=2)
-    
-    if "creative" not in ad_data or "id" not in ad_data["creative"]:
-        return json.dumps({
-            "error": "No creative ID found for this ad",
-            "ad_data": ad_data
-        }, indent=2)
+        return json.dumps({"error": f"Could not get ad data - {ad_data['error']}"}, indent=2)
     
-    creative_id = ad_data["creative"]["id"]
+    # Extract account_id
     account_id = ad_data.get("account_id", "")
+    if not account_id:
+        return json.dumps({"error": "No account ID found"}, indent=2)
     
-    # Now get the creative object
+    # Extract creative ID
+    if "creative" not in ad_data:
+        return json.dumps({"error": "No creative found for this ad"}, indent=2)
+        
+    creative_data = ad_data.get("creative", {})
+    creative_id = creative_data.get("id")
+    if not creative_id:
+        return json.dumps({"error": "No creative ID found"}, indent=2)
+    
+    # Get creative details to find image hash
     creative_endpoint = f"{creative_id}"
     creative_params = {
-        "fields": "id,name,thumbnail_url,image_hash,asset_feed_spec"
+        "fields": "id,name,image_hash,thumbnail_url,image_url,object_story_spec"
     }
     
-    creative_data = await make_api_request(creative_endpoint, access_token, creative_params)
-    
-    if "error" in creative_data:
-        return json.dumps({
-            "error": "Could not get creative data",
-            "details": creative_data
-        }, indent=2)
+    creative_details = await make_api_request(creative_endpoint, access_token, creative_params)
     
-    # Approach 1: Try to get image through adimages endpoint if we have image_hash
-    image_hash = None
-    if "image_hash" in creative_data:
-        image_hash = creative_data["image_hash"]
-    elif "asset_feed_spec" in creative_data and "images" in creative_data["asset_feed_spec"] and len(creative_data["asset_feed_spec"]["images"]) > 0:
-        image_hash = creative_data["asset_feed_spec"]["images"][0].get("hash")
+    if "error" in creative_details:
+        return json.dumps({"error": f"Could not get creative details - {creative_details['error']}"}, indent=2)
     
-    result = {
+    results = {
         "ad_id": ad_id,
         "creative_id": creative_id,
-        "attempts": []
+        "account_id": account_id,
+        "creative_details": creative_details
     }
     
-    if image_hash and account_id:
-        attempt = {
-            "method": "adimages endpoint with hash",
-            "success": False
-        }
-        result["attempts"].append(attempt)
-        
-        try:
-            image_endpoint = f"act_{account_id}/adimages"
-            image_params = {
-                "hashes": [image_hash]
-            }
-            image_data = await make_api_request(image_endpoint, access_token, image_params)
-            attempt["response"] = image_data
-            
-            if "data" in image_data and len(image_data["data"]) > 0 and "url" in image_data["data"][0]:
-                url = image_data["data"][0]["url"]
-                attempt["url"] = url
-                
-                # Try to download the image
-                image_bytes = await download_image(url)
-                if image_bytes:
-                    attempt["success"] = True
-                    attempt["image_size"] = len(image_bytes)
-                    
-                    # Save the image
-                    resource_id = f"ad_creative_{ad_id}_method1"
-                    resource_uri = f"meta-ads://images/{resource_id}"
-                    ad_creative_images[resource_id] = {
-                        "data": image_bytes,
-                        "mime_type": "image/jpeg",
-                        "name": f"Ad Creative for {ad_id} (Method 1)"
-                    }
-                    
-                    # Return success with resource info
-                    result["resource_uri"] = resource_uri
-                    result["success"] = True
-                    base64_sample = base64.b64encode(image_bytes[:100]).decode("utf-8") + "..."
-                    result["base64_sample"] = base64_sample
-        except Exception as e:
-            attempt["error"] = str(e)
+    # Try to find image hash
+    image_hash = None
     
-    # Approach 2: Try directly with the thumbnails endpoint
-    attempt = {
-        "method": "thumbnails endpoint on creative",
-        "success": False
-    }
-    result["attempts"].append(attempt)
+    # Direct hash on creative
+    if "image_hash" in creative_details:
+        image_hash = creative_details["image_hash"]
+        
+    # Look in object_story_spec
+    elif "object_story_spec" in creative_details:
+        spec = creative_details["object_story_spec"]
+        
+        # For link ads
+        if "link_data" in spec:
+            link_data = spec["link_data"]
+            if "image_hash" in link_data:
+                image_hash = link_data["image_hash"]
+        
+        # For photo ads
+        elif "photo_data" in spec:
+            photo_data = spec["photo_data"]
+            if "image_hash" in photo_data:
+                image_hash = photo_data["image_hash"]
     
-    try:
-        thumbnails_endpoint = f"{creative_id}/thumbnails"
-        thumbnails_params = {}
-        thumbnails_data = await make_api_request(thumbnails_endpoint, access_token, thumbnails_params)
-        attempt["response"] = thumbnails_data
-        
-        if "data" in thumbnails_data and len(thumbnails_data["data"]) > 0:
-            for thumbnail in thumbnails_data["data"]:
-                if "uri" in thumbnail:
-                    url = thumbnail["uri"]
-                    attempt["url"] = url
-                    
-                    # Try to download the image
-                    image_bytes = await download_image(url)
-                    if image_bytes:
-                        attempt["success"] = True
-                        attempt["image_size"] = len(image_bytes)
-                        
-                        # Save the image if method 1 didn't already succeed
-                        if "success" not in result or not result["success"]:
-                            resource_id = f"ad_creative_{ad_id}_method2"
-                            resource_uri = f"meta-ads://images/{resource_id}"
-                            ad_creative_images[resource_id] = {
-                                "data": image_bytes,
-                                "mime_type": "image/jpeg",
-                                "name": f"Ad Creative for {ad_id} (Method 2)"
-                            }
-                            
-                            # Return success with resource info
-                            result["resource_uri"] = resource_uri
-                            result["success"] = True
-                            base64_sample = base64.b64encode(image_bytes[:100]).decode("utf-8") + "..."
-                            result["base64_sample"] = base64_sample
-                        
-                        # No need to try more thumbnails if we succeeded
-                        break
-    except Exception as e:
-        attempt["error"] = str(e)
+    if not image_hash:
+        return json.dumps({
+            "error": "No image hash found in creative",
+            "creative_details": creative_details
+        }, indent=2)
     
-    # Approach 3: Try using the preview shareable link as an alternate source
-    attempt = {
-        "method": "preview_shareable_link",
-        "success": False
+    # Now get image data from the adimages endpoint
+    image_endpoint = f"act_{account_id}/adimages"
+    image_params = {
+        "hashes": [image_hash]
     }
-    result["attempts"].append(attempt)
     
-    try:
-        # Get ad details with preview link
-        ad_preview_endpoint = f"{ad_id}"
-        ad_preview_params = {
-            "fields": "preview_shareable_link"
-        }
-        ad_preview_data = await make_api_request(ad_preview_endpoint, access_token, ad_preview_params)
-        
-        if "preview_shareable_link" in ad_preview_data:
-            preview_link = ad_preview_data["preview_shareable_link"]
-            attempt["preview_link"] = preview_link
-            
-            # We can't directly download the preview image, but let's note it for manual inspection
-            attempt["note"] = "Preview link available for manual inspection in browser"
-            
-            # This approach doesn't actually download the image, but the link might be useful
-            # for debugging purposes or manual verification
-    except Exception as e:
-        attempt["error"] = str(e)
+    image_data = await make_api_request(image_endpoint, access_token, image_params)
     
-    # Overall result
-    if "success" in result and result["success"]:
-        result["message"] = "Successfully retrieved ad image through one of the API methods"
-    else:
-        result["message"] = "Failed to retrieve ad image through any API method"
-        
-    return json.dumps(result, indent=2)
-
-@mcp_server.tool()
-@meta_api_tool
-async def get_login_link(access_token: str = None) -> str:
-    """
-    Get a clickable login link for Meta Ads authentication.
+    if "error" in image_data:
+        return json.dumps({
+            "error": f"Failed to get image data - {image_data['error']}",
+            "hash": image_hash
+        }, indent=2)
     
-    Args:
-        access_token: Meta API access token (optional - will use cached token if not provided)
+    if "data" not in image_data or not image_data["data"]:
+        return json.dumps({
+            "error": "No image data returned from API",
+            "hash": image_hash
+        }, indent=2)
     
-    Returns:
-        A clickable resource link for Meta authentication
-    """
-    # Check if we have a cached token
-    cached_token = auth_manager.get_access_token()
-    token_status = "No token" if not cached_token else "Valid token"
+    # Get the URL from the first image
+    first_image = image_data["data"][0]
+    image_url = first_image.get("url")
     
-    # If we already have a valid token and none was provided, just return success
-    if cached_token and not access_token:
+    if not image_url:
         return json.dumps({
-            "message": "Already authenticated",
-            "token_status": token_status,
-            "token_preview": cached_token[:10] + "...",
-            "created_at": auth_manager.token_info.created_at,
-            "expires_in": auth_manager.token_info.expires_in
+            "error": "No image URL found in API response",
+            "api_response": image_data
         }, indent=2)
     
-    # IMPORTANT: Start the callback server first by calling our helper function
-    # This ensures the server is ready before we provide the URL to the user
-    port = start_callback_server()
-    
-    # Generate direct login URL
-    auth_manager.redirect_uri = f"http://localhost:{port}/callback"  # Ensure port is set correctly
-    login_url = auth_manager.get_auth_url()
-    
-    # Return a special format that helps the LLM format the response properly
-    response = {
-        "login_url": login_url,
-        "token_status": token_status,
-        "server_status": f"Callback server running on port {port}",
-        "markdown_link": f"[Click here to authenticate with Meta Ads]({login_url})",
-        "message": "IMPORTANT: Please use the Markdown link format in your response to allow the user to click it.",
-        "instructions_for_llm": "You must present this link as clickable Markdown to the user using the markdown_link format provided.",
-        "note": "After authenticating, the token will be automatically saved."
-    }
-    
-    # Wait a moment to ensure the server is fully started
-    await asyncio.sleep(1)
+    # Try to save the image by directly downloading it
+    results["image_url"] = image_url
     
-    return json.dumps(response, indent=2)
+    try:
+        # Try multiple download methods
+        image_bytes = await try_multiple_download_methods(image_url)
+        
+        if not image_bytes:
+            return json.dumps({
+                "error": "Failed to download image from URL provided by API",
+                "image_url": image_url,
+                "suggestion": "Try using the debug_image_download tool for more details"
+            }, indent=2)
+        
+        # Create a resource ID for this image
+        resource_id = f"ad_{ad_id}_{int(time.time())}"
+        
+        # Store the image
+        img = PILImage.open(io.BytesIO(image_bytes))
+        mime_type = f"image/{img.format.lower()}" if img.format else "image/jpeg"
+        
+        # Save to our global dictionary
+        ad_creative_images[resource_id] = {
+            "data": image_bytes,
+            "mime_type": mime_type,
+            "name": f"Ad {ad_id} Image",
+            "width": img.width,
+            "height": img.height,
+            "format": img.format
+        }
+        
+        # Return the success result with resource info
+        return json.dumps({
+            "success": True,
+            "message": "Successfully saved image",
+            "resource_id": resource_id,
+            "resource_uri": f"meta-ads://images/{resource_id}",
+            "image_details": {
+                "width": img.width,
+                "height": img.height,
+                "format": img.format,
+                "size_bytes": len(image_bytes)
+            }
+        }, indent=2)
+        
+    except Exception as e:
+        return json.dumps({
+            "error": f"Error saving image: {str(e)}",
+            "image_url": image_url
+        }, indent=2)
 
 # Helper function to start the login flow
 def login():
@@ -1616,6 +1669,16 @@ def login():
     """
     print("Starting Meta Ads authentication flow...")
     
+    # Ensure auth_manager has the current app ID from config
+    current_app_id = meta_config.get_app_id()
+    if not current_app_id:
+        print("Error: No Meta App ID available. Authentication will fail.")
+        print("Please provide an app ID using --app-id or via META_APP_ID environment variable.")
+        return
+        
+    auth_manager.app_id = current_app_id
+    print(f"Using Meta App ID from config: {current_app_id}")
+    
     try:
         # Start the callback server first
         port = start_callback_server()
@@ -1767,6 +1830,12 @@ def start_callback_server():
         
         # Update auth manager's redirect URI with new port
         auth_manager.redirect_uri = f"http://localhost:{port}/callback"
+        
+        # Always make sure auth_manager has the current app ID from config
+        current_app_id = meta_config.get_app_id()
+        if current_app_id:
+            auth_manager.app_id = current_app_id
+            
         callback_server_port = port
         
         try:
@@ -1834,9 +1903,17 @@ def login_cli():
     
     args = parser.parse_args()
     
-    # Update app ID if provided
+    # Update app ID if provided via CLI
     if args.app_id:
-        auth_manager.app_id = args.app_id
+        meta_config.set_app_id(args.app_id)
+    else:
+        # Use existing config or environment variable
+        if not meta_config.is_configured():
+            print("Error: No Meta App ID provided. Please provide using --app-id or META_APP_ID environment variable.")
+            return 1
+    
+    # Update auth_manager with app ID from config
+    auth_manager.app_id = meta_config.get_app_id()
     
     if args.force_login:
         # Clear existing token
@@ -1849,7 +1926,7 @@ def login_cli():
 
 def main():
     """
-    Main entry point for the Meta Ads MCP server.
+    Main entry point for the Meta Ads MCP Server.
     This function handles command line arguments and runs the server.
     """
     # Set up command line arguments
@@ -1859,12 +1936,22 @@ def main():
     
     args = parser.parse_args()
     
-    # Update app ID if provided
+    # Update app ID if provided via CLI (highest priority)
     if args.app_id:
-        auth_manager.app_id = args.app_id
+        meta_config.set_app_id(args.app_id)
+    
+    # Ensure auth_manager has the current app ID
+    app_id = get_current_app_id()
+    if app_id:
+        auth_manager.app_id = app_id
+    else:
+        print("Warning: No Meta App ID provided. Authentication will fail.")
     
     # Handle login command
     if args.login:
+        if not meta_config.is_configured():
+            print("Error: Cannot login without a Meta App ID. Please provide using --app-id or META_APP_ID environment variable.")
+            return 1
         login()
     else:
         # Initialize and run the server