meta-ads-mcp 0.2.6__py3-none-any.whl → 0.2.9__py3-none-any.whl

meta_ads_mcp/core/adsets.py

@@ -32,15 +32,23 @@ async def get_adsets(access_token: str = None, account_id: str = None, limit: in
         else:
             return json.dumps({"error": "No account ID specified and no accounts found for user"}, indent=2)
     
-    endpoint = f"{account_id}/adsets"
-    params = {
-        "fields": "id,name,campaign_id,status,daily_budget,lifetime_budget,targeting,bid_amount,bid_strategy,optimization_goal,billing_event,start_time,end_time,created_time,updated_time,frequency_control_specs{event,interval_days,max_frequency}",
-        "limit": limit
-    }
-    
+    # Change endpoint based on whether campaign_id is provided
     if campaign_id:
-        params["campaign_id"] = campaign_id
-    
+        endpoint = f"{campaign_id}/adsets"
+        params = {
+            "fields": "id,name,campaign_id,status,daily_budget,lifetime_budget,targeting,bid_amount,bid_strategy,optimization_goal,billing_event,start_time,end_time,created_time,updated_time,frequency_control_specs{event,interval_days,max_frequency}",
+            "limit": limit
+        }
+    else:
+        # Use account endpoint if no campaign_id is given
+        endpoint = f"{account_id}/adsets"
+        params = {
+            "fields": "id,name,campaign_id,status,daily_budget,lifetime_budget,targeting,bid_amount,bid_strategy,optimization_goal,billing_event,start_time,end_time,created_time,updated_time,frequency_control_specs{event,interval_days,max_frequency}",
+            "limit": limit
+        }
+        # Note: Removed the attempt to add campaign_id to params for the account endpoint case, 
+        # as it was ineffective and the logic now uses the correct endpoint for campaign filtering.
+
     data = await make_api_request(endpoint, access_token, params)
     
     return json.dumps(data, indent=2)
@@ -66,19 +74,133 @@ async def get_adset_details(access_token: str = None, adset_id: str = None) -> s
         return json.dumps({"error": "No ad set ID provided"}, indent=2)
     
     endpoint = f"{adset_id}"
+    # Explicitly prioritize frequency_control_specs in the fields request
     params = {
-        "fields": "id,name,campaign_id,status,daily_budget,lifetime_budget,targeting,bid_amount,bid_strategy,optimization_goal,billing_event,start_time,end_time,created_time,updated_time,attribution_spec,destination_type,promoted_object,pacing_type,budget_remaining,frequency_control_specs{event,interval_days,max_frequency}"
+        "fields": "id,name,campaign_id,status,frequency_control_specs{event,interval_days,max_frequency},daily_budget,lifetime_budget,targeting,bid_amount,bid_strategy,optimization_goal,billing_event,start_time,end_time,created_time,updated_time,attribution_spec,destination_type,promoted_object,pacing_type,budget_remaining"
     }
     
     data = await make_api_request(endpoint, access_token, params)
     
+    # For debugging - check if frequency_control_specs was returned
+    if 'frequency_control_specs' not in data:
+        data['_meta'] = {
+            'note': 'No frequency_control_specs field was returned by the API. This means either no frequency caps are set or the API did not include this field in the response.'
+        }
+    
     return json.dumps(data, indent=2)
 
 
+@mcp_server.tool()
+@meta_api_tool
+async def create_adset(
+    account_id: str = None, 
+    campaign_id: str = None, 
+    name: str = None,
+    status: str = "PAUSED",
+    daily_budget = None,
+    lifetime_budget = None,
+    targeting: Dict[str, Any] = None,
+    optimization_goal: str = None,
+    billing_event: str = None,
+    bid_amount = None,
+    bid_strategy: str = None,
+    start_time: str = None,
+    end_time: str = None,
+    access_token: str = None
+) -> str:
+    """
+    Create a new ad set in a Meta Ads account.
+    
+    Args:
+        account_id: Meta Ads account ID (format: act_XXXXXXXXX)
+        campaign_id: Meta Ads campaign ID this ad set belongs to
+        name: Ad set name
+        status: Initial ad set status (default: PAUSED)
+        daily_budget: Daily budget in account currency (in cents) as a string
+        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')
+        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
+        access_token: Meta API access token (optional - will use cached token if not provided)
+    """
+    # Check required parameters
+    if not account_id:
+        return json.dumps({"error": "No account ID provided"}, indent=2)
+    
+    if not campaign_id:
+        return json.dumps({"error": "No campaign ID provided"}, indent=2)
+    
+    if not name:
+        return json.dumps({"error": "No ad set name provided"}, indent=2)
+    
+    if not optimization_goal:
+        return json.dumps({"error": "No optimization goal provided"}, indent=2)
+    
+    if not billing_event:
+        return json.dumps({"error": "No billing event provided"}, indent=2)
+    
+    # Basic targeting is required if not provided
+    if not targeting:
+        targeting = {
+            "age_min": 18,
+            "age_max": 65,
+            "geo_locations": {"countries": ["US"]},
+            "targeting_automation": {"advantage_audience": 1}
+        }
+    
+    endpoint = f"{account_id}/adsets"
+    
+    params = {
+        "name": name,
+        "campaign_id": campaign_id,
+        "status": status,
+        "optimization_goal": optimization_goal,
+        "billing_event": billing_event,
+        "targeting": json.dumps(targeting)  # Properly format as JSON string
+    }
+    
+    # Convert budget values to strings if they aren't already
+    if daily_budget is not None:
+        params["daily_budget"] = str(daily_budget)
+    
+    if lifetime_budget is not None:
+        params["lifetime_budget"] = str(lifetime_budget)
+    
+    # Add other parameters if provided
+    if bid_amount is not None:
+        params["bid_amount"] = str(bid_amount)
+    
+    if bid_strategy:
+        params["bid_strategy"] = bid_strategy
+    
+    if start_time:
+        params["start_time"] = start_time
+    
+    if end_time:
+        params["end_time"] = end_time
+    
+    try:
+        data = await make_api_request(endpoint, access_token, params, method="POST")
+        return json.dumps(data, indent=2)
+    except Exception as e:
+        error_msg = str(e)
+        return json.dumps({
+            "error": "Failed to create ad set",
+            "details": error_msg,
+            "params_sent": params
+        }, indent=2)
+
+
 @mcp_server.tool()
 @meta_api_tool
 async def update_adset(adset_id: str, frequency_control_specs: List[Dict[str, Any]] = None, bid_strategy: str = None, 
-                        bid_amount: int = None, status: str = None, targeting: Dict[str, Any] = None, access_token: str = None) -> str:
+                        bid_amount: int = None, status: str = None, targeting: Dict[str, Any] = None, 
+                        optimization_goal: str = None, access_token: str = None) -> str:
     """
     Update an ad set with new settings including frequency caps.
     
@@ -91,6 +213,7 @@ async def update_adset(adset_id: str, frequency_control_specs: List[Dict[str, An
         status: Update ad set status (ACTIVE, PAUSED, etc.)
         targeting: Targeting specifications including targeting_automation
                   (e.g. {"targeting_automation":{"advantage_audience":1}})
+        optimization_goal: Conversion optimization goal (e.g., 'LINK_CLICKS', 'CONVERSIONS', 'APP_INSTALLS', etc.)
         access_token: Meta API access token (optional - will use cached token if not provided)
     """
     if not adset_id:
@@ -110,6 +233,9 @@ async def update_adset(adset_id: str, frequency_control_specs: List[Dict[str, An
     if status is not None:
         changes['status'] = status
         
+    if optimization_goal is not None:
+        changes['optimization_goal'] = optimization_goal
+        
     if targeting is not None:
         # Get current ad set details to preserve existing targeting settings
         current_details_json = await get_adset_details(adset_id=adset_id, access_token=access_token)
@@ -163,7 +289,7 @@ async def update_adset(adset_id: str, frequency_control_specs: List[Dict[str, An
         "current_details": current_details,
         "proposed_changes": changes,
         "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 and your ad set will be updated. Refresh the browser page if it doesn't load immediately."
+        "note": "Click the link to confirm and apply your ad set updates. Refresh the browser page if it doesn't load immediately."
     }
     
     return json.dumps(response, indent=2) 

meta_ads_mcp/core/api.py

@@ -193,7 +193,7 @@ def meta_api_tool(func):
             logger.debug(f"Current app_id: {app_id}")
             logger.debug(f"META_APP_ID env var: {os.environ.get('META_APP_ID')}")
             
-            # If access_token is not in kwargs, try to get it from auth_manager
+            # If access_token is not in kwargs or not kwargs['access_token'], try to get it from auth_manager
             if 'access_token' not in kwargs or not kwargs['access_token']:
                 try:
                     access_token = await get_current_access_token()
@@ -202,13 +202,36 @@ def meta_api_tool(func):
                         logger.debug("Using access token from auth_manager")
                     else:
                         logger.warning("No access token available from auth_manager")
+                        # Add more details about why token might be missing
+                        if (auth_manager.app_id == "YOUR_META_APP_ID" or not auth_manager.app_id) and not auth_manager.use_pipeboard:
+                            logger.error("TOKEN VALIDATION FAILED: No valid app_id configured")
+                            logger.error("Please set META_APP_ID environment variable or configure in your code")
+                        else:
+                            logger.error("Check logs above for detailed token validation failures")
                 except Exception as e:
                     logger.error(f"Error getting access token: {str(e)}")
+                    # Add stack trace for better debugging
+                    import traceback
+                    logger.error(f"Stack trace: {traceback.format_exc()}")
             
             # Final validation - if we still don't have a valid token, return authentication required
             if 'access_token' not in kwargs or not kwargs['access_token']:
                 logger.warning("No access token available, authentication needed")
+                
+                # Add more specific troubleshooting information
                 auth_url = auth_manager.get_auth_url()
+                app_id = auth_manager.app_id
+                
+                logger.error("TOKEN VALIDATION SUMMARY:")
+                logger.error(f"- Current app_id: '{app_id}'")
+                logger.error(f"- Environment META_APP_ID: '{os.environ.get('META_APP_ID', 'Not set')}'")
+                logger.error(f"- Pipeboard API token configured: {'Yes' if os.environ.get('PIPEBOARD_API_TOKEN') else 'No'}")
+                
+                # Check for common configuration issues
+                if app_id == "YOUR_META_APP_ID" or not app_id:
+                    logger.error("ISSUE DETECTED: No valid Meta App ID configured")
+                    logger.error("ACTION REQUIRED: Set META_APP_ID environment variable with a valid App ID")
+                
                 return json.dumps({
                     "error": {
                         "message": "Authentication Required",
@@ -216,6 +239,11 @@ def meta_api_tool(func):
                             "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})"
                         }
                     }

meta_ads_mcp/core/auth.py

@@ -18,8 +18,11 @@ from .callback_server import (
     update_confirmation
 )
 
+# Import the new Pipeboard authentication
+from .pipeboard_auth import pipeboard_auth_manager
+
 # Auth constants
-AUTH_SCOPE = "ads_management,ads_read,business_management"
+AUTH_SCOPE = "ads_management,ads_read,business_management,public_profile"
 AUTH_REDIRECT_URI = "http://localhost:8888/callback"
 AUTH_RESPONSE_TYPE = "token"
 
@@ -39,8 +42,8 @@ class MetaConfig:
         if cls._instance is None:
             logger.debug("Creating new MetaConfig instance")
             cls._instance = super(MetaConfig, cls).__new__(cls)
-            cls._instance.app_id = os.environ.get("META_APP_ID", "")
-            logger.info(f"MetaConfig initialized with app_id from env: {cls._instance.app_id}")
+            cls._instance.app_id = os.environ.get("META_APP_ID", "779761636818489")
+            logger.info(f"MetaConfig initialized with app_id from env/default: {cls._instance.app_id}")
         return cls._instance
     
     def set_app_id(self, app_id):
@@ -123,7 +126,10 @@ class AuthManager:
         self.app_id = app_id
         self.redirect_uri = redirect_uri
         self.token_info = None
-        self._load_cached_token()
+        # Check for Pipeboard token first
+        self.use_pipeboard = bool(os.environ.get("PIPEBOARD_API_TOKEN", ""))
+        if not self.use_pipeboard:
+            self._load_cached_token()
     
     def _get_token_cache_path(self) -> pathlib.Path:
         """Get the platform-specific path for token cache file"""
@@ -154,14 +160,14 @@ class AuthManager:
                 
                 # Check if token is expired
                 if self.token_info.is_expired():
-                    print("Cached token is expired")
+                    logger.info("Cached token is expired")
                     self.token_info = None
                     return False
                 
-                print(f"Loaded cached token (expires in {(self.token_info.created_at + self.token_info.expires_in) - int(time.time())} seconds)")
+                logger.info(f"Loaded cached token (expires in {(self.token_info.created_at + self.token_info.expires_in) - int(time.time())} seconds)")
                 return True
         except Exception as e:
-            print(f"Error loading cached token: {e}")
+            logger.error(f"Error loading cached token: {e}")
             return False
     
     def _save_token_to_cache(self) -> None:
@@ -174,9 +180,9 @@ class AuthManager:
         try:
             with open(cache_path, "w") as f:
                 json.dump(self.token_info.serialize(), f)
-            print(f"Token cached at: {cache_path}")
+            logger.info(f"Token cached at: {cache_path}")
         except Exception as e:
-            print(f"Error saving token to cache: {e}")
+            logger.error(f"Error saving token to cache: {e}")
     
     def get_auth_url(self) -> str:
         """Generate the Facebook OAuth URL for desktop app flow"""
@@ -198,6 +204,12 @@ class AuthManager:
         Returns:
             Access token if successful, None otherwise
         """
+        # If Pipeboard auth is available, use that instead
+        if self.use_pipeboard:
+            logger.info("Using Pipeboard authentication")
+            return pipeboard_auth_manager.get_access_token(force_refresh=force_refresh)
+        
+        # Otherwise, use the original OAuth flow
         # Check if we already have a valid token
         if not force_refresh and self.token_info and not self.token_info.is_expired():
             return self.token_info.access_token
@@ -212,7 +224,7 @@ class AuthManager:
         auth_url = self.get_auth_url()
         
         # Open browser with auth URL
-        print(f"Opening browser with URL: {auth_url}")
+        logger.info(f"Opening browser with URL: {auth_url}")
         webbrowser.open(auth_url)
         
         # We don't wait for the token here anymore
@@ -227,6 +239,10 @@ class AuthManager:
         Returns:
             Access token if available, None otherwise
         """
+        # If using Pipeboard, always delegate to the Pipeboard auth manager
+        if self.use_pipeboard:
+            return pipeboard_auth_manager.get_access_token()
+            
         if not self.token_info or self.token_info.is_expired():
             return None
         
@@ -234,8 +250,13 @@ class AuthManager:
         
     def invalidate_token(self) -> None:
         """Invalidate the current token, usually because it has expired or is invalid"""
+        # If using Pipeboard, delegate to the Pipeboard auth manager
+        if self.use_pipeboard:
+            pipeboard_auth_manager.invalidate_token()
+            return
+            
         if self.token_info:
-            print(f"Invalidating token: {self.token_info.access_token[:10]}...")
+            logger.info(f"Invalidating token: {self.token_info.access_token[:10]}...")
             self.token_info = None
             
             # Signal that authentication is needed
@@ -247,12 +268,12 @@ class AuthManager:
                 cache_path = self._get_token_cache_path()
                 if cache_path.exists():
                     os.remove(cache_path)
-                    print(f"Removed cached token file: {cache_path}")
+                    logger.info(f"Removed cached token file: {cache_path}")
             except Exception as e:
-                print(f"Error removing cached token: {e}")
+                logger.error(f"Error removing cached token file: {e}")
     
     def clear_token(self) -> None:
-        """Clear the current token and remove from cache"""
+        """Alias for invalidate_token for consistency with other APIs"""
         self.invalidate_token()
 
 
@@ -385,18 +406,55 @@ async def get_current_access_token() -> Optional[str]:
     app_id = meta_config.get_app_id()
     logger.debug(f"Current app_id: {app_id}")
     
+    # Check if using Pipeboard authentication
+    using_pipeboard = auth_manager.use_pipeboard
+    
+    # Check if app_id is valid - but only if not using Pipeboard authentication
+    if not app_id and not using_pipeboard:
+        logger.error("TOKEN VALIDATION FAILED: No valid app_id configured")
+        logger.error("Please set META_APP_ID environment variable or configure via meta_config.set_app_id()")
+        return None
+    
     # Attempt to get access token
     try:
         token = auth_manager.get_access_token()
         
         if token:
-            logger.debug("Access token found in auth_manager")
+            # Add basic token validation - check if it looks like a valid token
+            if len(token) < 20:  # Most Meta tokens are much longer
+                logger.error(f"TOKEN VALIDATION FAILED: Token appears malformed (length: {len(token)})")
+                auth_manager.invalidate_token()
+                return None
+                
+            logger.debug(f"Access token found in auth_manager (starts with: {token[:10]}...)")
             return token
         else:
             logger.warning("No valid access token available in auth_manager")
+            
+            # Check why token might be missing
+            if hasattr(auth_manager, 'token_info') and auth_manager.token_info:
+                if auth_manager.token_info.is_expired():
+                    logger.error("TOKEN VALIDATION FAILED: Token is expired")
+                    # Add expiration details
+                    if hasattr(auth_manager.token_info, 'expires_in') and auth_manager.token_info.expires_in:
+                        expiry_time = auth_manager.token_info.created_at + auth_manager.token_info.expires_in
+                        current_time = int(time.time())
+                        expired_seconds_ago = current_time - expiry_time
+                        logger.error(f"Token expired {expired_seconds_ago} seconds ago")
+                elif not auth_manager.token_info.access_token:
+                    logger.error("TOKEN VALIDATION FAILED: Token object exists but access_token is empty")
+                else:
+                    logger.error("TOKEN VALIDATION FAILED: Token exists but was rejected for unknown reason")
+            else:
+                logger.error("TOKEN VALIDATION FAILED: No token information available")
+                
+            # Suggest next steps for troubleshooting
+            logger.error("To fix: Try re-authenticating or check if your token has been revoked")
             return None
     except Exception as e:
         logger.error(f"Error getting access token: {str(e)}")
+        import traceback
+        logger.error(f"Token validation stacktrace: {traceback.format_exc()}")
         return None
 
 
@@ -443,4 +501,14 @@ def login():
 
 # Initialize auth manager with a placeholder - will be updated at runtime
 META_APP_ID = os.environ.get("META_APP_ID", "YOUR_META_APP_ID")
+
+# Only show warnings about missing META_APP_ID/META_APP_SECRET when not using Pipeboard
+if not os.environ.get("PIPEBOARD_API_TOKEN"):
+    # Log warnings about missing environment variables
+    if META_APP_ID == "YOUR_META_APP_ID":
+        logger.warning("META_APP_ID environment variable is not set. Authentication will not work properly.")
+    
+    if not os.environ.get("META_APP_SECRET"):
+        logger.warning("META_APP_SECRET environment variable is not set. Long-lived token exchange will not work.")
+
 auth_manager = AuthManager(META_APP_ID) 

meta_ads_mcp/core/authentication.py

@@ -2,10 +2,12 @@
 
 import json
 import asyncio
+import os
 from .api import meta_api_tool
 from .auth import start_callback_server, auth_manager, get_current_access_token
 from .server import mcp_server
 from .utils import logger, META_APP_SECRET
+from .pipeboard_auth import pipeboard_auth_manager
 
 
 @mcp_server.tool()
@@ -13,60 +15,112 @@ async def get_login_link(access_token: str = None) -> str:
     """
     Get a clickable login link for Meta Ads authentication.
     
+    NOTE: This method should only be used if you're using your own Facebook app.
+    If using Pipeboard authentication (recommended), set the PIPEBOARD_API_TOKEN
+    environment variable instead (token obtainable via https://pipeboard.co).
+    
     Args:
         access_token: Meta API access token (optional - will use cached token if not provided)
     
     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"
+    # Check if we're using pipeboard authentication
+    using_pipeboard = bool(os.environ.get("PIPEBOARD_API_TOKEN", ""))
     
-    # If we already have a valid token and none was provided, just return success
-    if cached_token and not access_token:
-        logger.info("get_login_link called with existing valid token")
-        return json.dumps({
-            "message": "Already authenticated",
+    if using_pipeboard:
+        # Handle Pipeboard authentication
+        # Check if we have a cached token
+        cached_token = pipeboard_auth_manager.get_access_token()
+        token_status = "No token" if not cached_token else "Valid token"
+        
+        # If we already have a valid token and none was provided, just return success
+        if cached_token and not access_token:
+            logger.info("get_login_link called with existing valid Pipeboard token")
+            return json.dumps({
+                "message": "Already authenticated with Pipeboard",
+                "token_status": token_status,
+                "token_preview": cached_token[:10] + "..." if cached_token else None,
+                "authentication_method": "pipeboard"
+            }, indent=2)
+        
+        # Initiate the auth flow via Pipeboard
+        try:
+            auth_data = pipeboard_auth_manager.initiate_auth_flow()
+            login_url = auth_data.get("loginUrl")
+            
+            # Return a special format that helps the LLM format the response properly
+            response = {
+                "login_url": login_url,
+                "token_status": token_status,
+                "markdown_link": f"[Click here to authenticate with Meta Ads via Pipeboard]({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.",
+                "authentication_method": "pipeboard",
+                "token_duration": "Approximately 60 days",
+                "note": "After authenticating, the token will be automatically saved."
+            }
+            
+            return json.dumps(response, indent=2)
+        except Exception as e:
+            logger.error(f"Error initiating Pipeboard auth flow: {e}")
+            return json.dumps({
+                "error": f"Failed to initiate Pipeboard authentication: {str(e)}",
+                "message": "Please check your PIPEBOARD_API_TOKEN environment variable.",
+                "authentication_method": "pipeboard"
+            }, indent=2)
+    else:
+        # Original Meta authentication flow
+        # 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"
+        
+        # If we already have a valid token and none was provided, just return success
+        if cached_token and not access_token:
+            logger.info("get_login_link called with existing valid token")
+            return json.dumps({
+                "message": "Already authenticated",
+                "token_status": token_status,
+                "token_preview": cached_token[:10] + "...",
+                "created_at": auth_manager.token_info.created_at if hasattr(auth_manager, "token_info") else None,
+                "expires_in": auth_manager.token_info.expires_in if hasattr(auth_manager, "token_info") else None,
+                "authentication_method": "meta_oauth"
+            }, 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
+        logger.info("Starting callback server for authentication")
+        port = start_callback_server()
+        logger.info(f"Callback server started on port {port}")
+        
+        # Generate direct login URL
+        auth_manager.redirect_uri = f"http://localhost:{port}/callback"  # Ensure port is set correctly
+        logger.info(f"Setting redirect URI to {auth_manager.redirect_uri}")
+        login_url = auth_manager.get_auth_url()
+        logger.info(f"Generated login URL: {login_url}")
+        
+        # Check if we can exchange for long-lived tokens
+        token_exchange_supported = bool(META_APP_SECRET)
+        token_duration = "60 days" if token_exchange_supported else "1-2 hours"
+        
+        # Return a special format that helps the LLM format the response properly
+        response = {
+            "login_url": login_url,
             "token_status": token_status,
-            "token_preview": cached_token[:10] + "...",
-            "created_at": auth_manager.token_info.created_at if hasattr(auth_manager, "token_info") else None,
-            "expires_in": auth_manager.token_info.expires_in if hasattr(auth_manager, "token_info") else None
-        }, 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
-    logger.info("Starting callback server for authentication")
-    port = start_callback_server()
-    logger.info(f"Callback server started on port {port}")
-    
-    # Generate direct login URL
-    auth_manager.redirect_uri = f"http://localhost:{port}/callback"  # Ensure port is set correctly
-    logger.info(f"Setting redirect URI to {auth_manager.redirect_uri}")
-    login_url = auth_manager.get_auth_url()
-    logger.info(f"Generated login URL: {login_url}")
-    
-    # Check if we can exchange for long-lived tokens
-    token_exchange_supported = bool(META_APP_SECRET)
-    token_duration = "60 days" if token_exchange_supported else "1-2 hours"
-    
-    # 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.",
-        "token_exchange": "enabled" if token_exchange_supported else "disabled",
-        "token_duration": token_duration,
-        "token_exchange_message": f"Your authentication token will be valid for approximately {token_duration}." + 
-                                 (" Long-lived token exchange is enabled." if token_exchange_supported else 
-                                  " To enable long-lived tokens (60 days), set the META_APP_SECRET environment variable."),
-        "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) 
+            "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.",
+            "token_exchange": "enabled" if token_exchange_supported else "disabled",
+            "token_duration": token_duration,
+            "authentication_method": "meta_oauth",
+            "token_exchange_message": f"Your authentication token will be valid for approximately {token_duration}." + 
+                                    (" Long-lived token exchange is enabled." if token_exchange_supported else 
+                                    " To enable long-lived tokens (60 days), set the META_APP_SECRET environment variable."),
+            "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)